Пример #1
0
func (g *Game) internalCreatureTeleport(_creature pul.ICreature, _from pul.ITile, _to pul.ITile) (ret int) {
	ret = RET_NOERROR

	if _from == nil || _to == nil {
		ret = RET_NOTPOSSIBLE
	} else {
		// Move creature object to destination tile
		if ret = _from.RemoveCreature(_creature, true); ret == RET_NOTPOSSIBLE {
			return
		}

		if ret = _to.AddCreature(_creature, false); ret == RET_NOTPOSSIBLE {
			_from.AddCreature(_creature, false) // Something went wrong, put creature back on old tile
			return
		}

		_creature.SetTile(_to)

		// Tell creatures this creature has been teleported
		g.mutexCreatureList.RLock()
		defer g.mutexCreatureList.RUnlock()
		for _, value := range g.Creatures {
			if value != nil {
				value.OnCreatureMove(_creature, _from, _to, true)
			}
		}
	}

	// No error, played succesfully teleported
	if ret == RET_NOERROR {
		ret = RET_PLAYERISTELEPORTED
	}

	return
}
Пример #2
0
func (g *Game) internalCreatureSay(_creature pul.ICreature, _speakType int, _message string) bool {
	list := make(pul.CreatureList)
	if _speakType == pnet.SPEAK_YELL {
		position := _creature.GetPosition() // Get position of speaker

		g.mutexPlayerList.RLock()
		defer g.mutexPlayerList.RUnlock()
		for _, player := range g.Players {
			if player != nil {
				if position.IsInRange3p(player.GetPosition(), pos.NewPositionFrom(27, 21, 0)) {
					list[player.GetUID()] = player
				}
			}
		}
	} else {
		list = _creature.GetVisibleCreatures()
	}

	// Send chat message to all visible players
	for _, creature := range list {
		if creature.GetType() == CTYPE_PLAYER {
			player := creature.(*Player)
			// player.sendCreatureSay(_creature, _speakType, _message)
			player.sendToChannel(_creature, _speakType, _message, pnet.CHANNEL_LOCAL, 0)
		}
	}

	return true
}
Пример #3
0
// AddCreature adds a new active creature to this tile
func (t *Tile) AddCreature(_creature pul.ICreature, _checkEvents bool) (ret int) {
	ret = RET_NOERROR

	if _checkEvents && t.Events.Len() > 0 {
		var i int = 0
		for e := t.Events.Front(); e != nil; e = e.Next() {
			event, valid := e.Value.(ITileEvent)
			if valid {
				ret = event.OnCreatureEnter(_creature, ret)
			}

			if ret == RET_NOTPOSSIBLE {
				return
			}
			i++
		}
	}

	_, found := t.Creatures[_creature.GetUID()]
	if !found {
		t.Creatures[_creature.GetUID()] = _creature
	}

	return
}
Пример #4
0
func (g *Game) internalCreatureChangeVisible(_creature pul.ICreature, _visible bool) {
	list := _creature.GetVisibleCreatures()
	for _, tmpCreature := range list {
		if tmpCreature.GetType() == CTYPE_PLAYER {
			tmpCreature.(*Player).sendCreatureChangeVisibility(_creature, _visible)
		}
	}
}
Пример #5
0
func (n *Npc) OnCreatureDisappear(_creature pul.ICreature, _isLogout bool) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}

	n.RemoveVisibleCreature(_creature)
}
Пример #6
0
func (p *Player) sendCreatureChangeVisibility(_creature pul.ICreature, _visible bool) {
	if _creature.GetUID() != p.GetUID() {
		if _visible {
			p.AddVisibleCreature(_creature)
		} else if !p.HasFlag(PlayerFlag_CanSenseInvisibility) {
			p.RemoveVisibleCreature(_creature)
		}
	}
}
Пример #7
0
func (e *Warp) OnCreatureEnter(_creature pul.ICreature, _prevRet int) (ret int) {
	currentTile := _creature.GetTile()
	destinationTile, found := g_map.GetTileFromPosition(e.destination)

	if found {
		ret = g_game.internalCreatureTeleport(_creature, currentTile, destinationTile)
	} else {
		ret = RET_NOTPOSSIBLE
	}

	return
}
Пример #8
0
func (p *Player) OnCreatureDisappear(_creature pul.ICreature, _isLogout bool) {
	if _creature.GetUID() == p.GetUID() {
		return
	}

	if _isLogout {
		// Check if creature is in friendlist
		p.UpdateFriend(_creature.GetName(), false)
	}

	p.RemoveVisibleCreature(_creature)
}
Пример #9
0
func (g *Game) OnPlayerMove(_creature pul.ICreature, _direction int, _sendMap bool) {
	ret := g.OnCreatureMove(_creature, _direction)

	player := _creature.(*Player)
	if ret == RET_NOTPOSSIBLE {
		player.sendCreatureMove(_creature, _creature.GetTile(), _creature.GetTile())
	} else if ret == RET_PLAYERISTELEPORTED {
		player.sendPlayerWarp()
		player.sendMapData(DIR_NULL)
	} else {
		player.sendMapData(_direction)
	}
}
Пример #10
0
func (p *Player) OnCreatureMove(_creature pul.ICreature, _from pul.ITile, _to pul.ITile, _teleport bool) {
	if _creature.GetUID() == p.GetUID() {
		p.lastStep = PUSYS_TIME()
		return
	}

	from := _from.(*Tile)
	to := _to.(*Tile)

	canSeeFromTile := CanSeePosition(p.GetPosition(), from.Position)
	canSeeToTile := CanSeePosition(p.GetPosition(), to.Position)

	if canSeeFromTile && !canSeeToTile { // Leaving viewport
		p.sendCreatureMove(_creature, from, to)

		p.RemoveVisibleCreature(_creature)
		_creature.RemoveVisibleCreature(p)
	} else if canSeeToTile && !canSeeFromTile { // Entering viewport
		p.AddVisibleCreature(_creature)
		_creature.RemoveVisibleCreature(p)

		p.sendCreatureMove(_creature, from, to)
	} else { // Moving inside viewport
		p.AddVisibleCreature(_creature)
		_creature.AddVisibleCreature(p)

		p.sendCreatureMove(_creature, from, to)
	}
}
Пример #11
0
func (n *Npc) RemoveVisibleCreature(_creature pul.ICreature) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}

	// Check if the player was interacting with this npc
	if n.HasInteractingPlayer(_creature.(*Player)) {
		n.RemoveInteractingPlayer(_creature.(*Player))
	}

	// No need to check if the key actually exists because Go is awesome
	// http://golang.org/doc/effective_go.html#maps
	delete(n.VisibleCreatures, _creature.GetUID())
}
Пример #12
0
func (n *Npc) OnCreatureAppear(_creature pul.ICreature, _isLogin bool) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}

	canSeeCreature := CanSeeCreature(n, _creature)
	if !canSeeCreature {
		return
	}

	// We're checking the existence of _creature inside the AddVisibleCreature method
	// so no need to check here
	n.AddVisibleCreature(_creature)
	_creature.AddVisibleCreature(n)
}
Пример #13
0
// RemoveCreature removes an active creature from this tile
func (t *Tile) RemoveCreature(_creature pul.ICreature, _checkEvents bool) (ret int) {
	ret = RET_NOERROR

	if _checkEvents && t.Events.Len() > 0 {
		for e := t.Events.Front(); e != nil; e = e.Next() {
			event, valid := e.Value.(ITileEvent)
			if valid {
				ret = event.OnCreatureLeave(_creature, ret)
			}

			if ret == RET_NOTPOSSIBLE {
				return
			}
		}
	}

	delete(t.Creatures, _creature.GetUID())

	return
}
Пример #14
0
// CheckMovement checks if a creature can move to this tile
func (t *Tile) CheckMovement(_creature pul.ICreature, _dir int) int {
	movement := _creature.GetMovement()
	blocking := t.Blocking

	if blocking != TILEBLOCK_WALK {
		if blocking == TILEBLOCK_BLOCK ||
			(blocking == TILEBLOCK_SURF && movement != MOVEMENT_SURF) ||
			(blocking == TILEBLOCK_TOP && _dir == DIR_SOUTH) ||
			(blocking == TILEBLOCK_BOTTOM && _dir == DIR_NORTH) ||
			(blocking == TILEBLOCK_LEFT && _dir == DIR_EAST) ||
			(blocking == TILEBLOCK_RIGHT && _dir == DIR_WEST) ||
			(blocking == TILEBLOCK_TOPLEFT && (_dir == DIR_EAST || _dir == DIR_SOUTH)) ||
			(blocking == TILEBLOCK_TOPRIGHT && (_dir == DIR_WEST || _dir == DIR_SOUTH)) ||
			(blocking == TILEBLOCK_BOTTOMLEFT && (_dir == DIR_EAST || _dir == DIR_NORTH)) ||
			(blocking == TILEBLOCK_BOTTOMRIGHT && (_dir == DIR_WEST || _dir == DIR_NORTH)) {
			return RET_NOTPOSSIBLE
		}
	}

	return RET_NOERROR
}
Пример #15
0
func (n *Npc) AddVisibleCreature(_creature pul.ICreature) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}

	if _, found := n.VisibleCreatures[_creature.GetUID()]; !found {
		n.VisibleCreatures[_creature.GetUID()] = _creature
	}
}
Пример #16
0
func (g *Game) OnCreatureTurn(_creature pul.ICreature, _direction int) {
	if _creature.GetDirection() != _direction {
		_creature.SetDirection(_direction)

		visibleCreatures := _creature.GetVisibleCreatures()
		for _, value := range visibleCreatures {
			value.OnCreatureTurn(_creature)
		}
	}
}
Пример #17
0
func (n *Npc) OnCreatureMove(_creature pul.ICreature, _from pul.ITile, _to pul.ITile, _teleport bool) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}

	canSeeFromTile := CanSeePosition(n.GetPosition(), _from.GetPosition())
	canSeeToTile := CanSeePosition(n.GetPosition(), _to.GetPosition())

	if canSeeFromTile && !canSeeToTile { // Leaving viewport
		n.RemoveVisibleCreature(_creature)
		_creature.RemoveVisibleCreature(n)
	} else if canSeeToTile && !canSeeFromTile { // Entering viewport
		n.AddVisibleCreature(_creature)
		_creature.RemoveVisibleCreature(n)
	} else { // Moving inside viewport
		n.AddVisibleCreature(_creature)
		_creature.AddVisibleCreature(n)
	}
}
Пример #18
0
func (p *Player) OnCreatureAppear(_creature pul.ICreature, _isLogin bool) {
	if _creature.GetUID() == p.GetUID() {
		return
	}

	if _isLogin {
		// Check if creature is in friendlist
		p.UpdateFriend(_creature.GetName(), true)
	}

	canSeeCreature := CanSeeCreature(p, _creature)
	if !canSeeCreature {
		return
	}

	// We're checking inside the AddVisibleCreature method so no need to check here
	p.AddVisibleCreature(_creature)
	_creature.AddVisibleCreature(p)
}
Пример #19
0
func (g *Game) AddCreature(_creature pul.ICreature) {
	// TODO: Maybe only take the creatues from the area the new creature is in. This saves some extra iterating

	g.mutexCreatureList.Lock()
	defer g.mutexCreatureList.Unlock()
	for _, value := range g.Creatures {
		value.OnCreatureAppear(_creature, true)
	}

	g.Creatures[_creature.GetUID()] = _creature

	if _creature.GetType() == CTYPE_PLAYER {
		g.mutexPlayerList.Lock()
		defer g.mutexPlayerList.Unlock()
		g.Players[_creature.GetUID()] = _creature.(*Player)

		// Join default channels
		g.Chat.AddUserToChannel(_creature.(*Player), pnet.CHANNEL_WORLD)
		g.Chat.AddUserToChannel(_creature.(*Player), pnet.CHANNEL_TRADE)
	}
}
Пример #20
0
func (c *Connection) SendCreatureRemove(_creature pul.ICreature) {
	if _creature.GetUID() != c.Owner.GetUID() {
		msg := pnetmsg.NewCreatureRemoveMessage(_creature)
		c.SendMessage(msg)
	}
}
Пример #21
0
func (n *Npc) OnCreatureTurn(_creature pul.ICreature) {
	// Check if _creature is a Player, otherwise return
	if _creature.GetType() != CTYPE_PLAYER {
		return
	}
}
Пример #22
0
func (g *Game) checkForWildEncounter(_creature pul.ICreature) {
	if _creature.GetType() == CTYPE_PLAYER {
		// Do some checkin'
	}
}
Пример #23
0
func (g *Game) OnCreatureMove(_creature pul.ICreature, _direction int) (ret int) {
	ret = RET_NOTPOSSIBLE

	if !CreatureCanMove(_creature) {
		return
	}

	currentTile := _creature.GetTile()
	destinationPosition := currentTile.GetPosition()

	switch _direction {
	case DIR_NORTH:
		destinationPosition.Y -= 1
	case DIR_SOUTH:
		destinationPosition.Y += 1
	case DIR_WEST:
		destinationPosition.X -= 1
	case DIR_EAST:
		destinationPosition.X += 1
	}

	// Check if destination tile exists
	destinationTile, ok := g_map.GetTileFromPosition(destinationPosition)
	if !ok {
		return
	}

	// Check if we can move to the destination tile
	if ret = destinationTile.CheckMovement(_creature, _direction); ret == RET_NOTPOSSIBLE {
		return
	}

	// Update position
	_creature.SetTile(destinationTile)

	// fmt.Printf("[%v] From (%v,%v) To (%v,%v)\n", _creature.GetName(), currentTile.Position.X, currentTile.Position.Y, destinationPosition.X, destinationPosition.Y)

	// Tell creatures this creature has moved
	g.mutexCreatureList.RLock()
	defer g.mutexCreatureList.RUnlock()
	for _, value := range g.Creatures {
		if value != nil {
			value.OnCreatureMove(_creature, currentTile, destinationTile, false)
		}
	}

	// Move creature object to destination tile
	if ret = currentTile.RemoveCreature(_creature, true); ret == RET_NOTPOSSIBLE {
		return
	}
	if ret = destinationTile.AddCreature(_creature, true); ret == RET_NOTPOSSIBLE {
		currentTile.AddCreature(_creature, false) // Something went wrong, put creature back on old tile
		_creature.SetTile(currentTile)
		return
	}

	// If ICreature is a player type we can check for wild encounter
	g.checkForWildEncounter(_creature)

	return
}
Пример #24
0
// Returns true if the passed creature can move
func CreatureCanMove(_creature pul.ICreature) bool {
	canMove := (_creature.GetTimeSinceLastMove() >= _creature.GetMovementSpeed())
	return canMove
}
Пример #25
0
func (p *Player) OnCreatureTurn(_creature pul.ICreature) {
	if _creature.GetUID() != p.GetUID() {
		p.sendCreatureTurn(_creature)
	}
}
Пример #26
0
// CanSeeCreature checks if 2 creatures are near each others viewport
func CanSeeCreature(_self pul.ICreature, _other pul.ICreature) bool {
	return CanSeePosition(_self.GetPosition(), _other.GetPosition())
}
Пример #27
0
func (c *Creature) KnowsVisibleCreature(_creature pul.ICreature) (found bool) {
	_, found = c.VisibleCreatures[_creature.GetUID()]
	return
}
Пример #28
0
func (c *Creature) RemoveVisibleCreature(_creature pul.ICreature) {
	if _, found := c.VisibleCreatures[_creature.GetUID()]; !found {
		c.VisibleCreatures[_creature.GetUID()] = _creature
	}
}
Пример #29
0
func (p *Player) AddVisibleCreature(_creature pul.ICreature) {
	if _, found := p.VisibleCreatures[_creature.GetUID()]; !found {
		p.VisibleCreatures[_creature.GetUID()] = _creature
		p.sendCreatureAdd(_creature)
	}
}
Пример #30
0
func (p *Player) RemoveVisibleCreature(_creature pul.ICreature) {
	// No need to check if the key actually exists because Go is awesome
	// http://tip.golang.org/doc/effective_go.html#maps
	delete(p.VisibleCreatures, _creature.GetUID())
	p.sendCreatureRemove(_creature)
}