Golang ICreature.GetUID方法代碼示例

// 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
}

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)
	}
}

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)
		}
	}
}

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
	}
}

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)
}

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())
}

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)
}

// 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
}

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)
	}
}

func (c *Connection) SendCreatureRemove(_creature pul.ICreature) {
	if _creature.GetUID() != c.Owner.GetUID() {
		msg := pnetmsg.NewCreatureRemoveMessage(_creature)
		c.SendMessage(msg)
	}
}

func (c *Creature) KnowsVisibleCreature(_creature pul.ICreature) (found bool) {
	_, found = c.VisibleCreatures[_creature.GetUID()]
	return
}

func (c *Creature) RemoveVisibleCreature(_creature pul.ICreature) {
	if _, found := c.VisibleCreatures[_creature.GetUID()]; !found {
		c.VisibleCreatures[_creature.GetUID()] = _creature
	}
}

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)
}

func (p *Player) AddVisibleCreature(_creature pul.ICreature) {
	if _, found := p.VisibleCreatures[_creature.GetUID()]; !found {
		p.VisibleCreatures[_creature.GetUID()] = _creature
		p.sendCreatureAdd(_creature)
	}
}

func (p *Player) OnCreatureTurn(_creature pul.ICreature) {
	if _creature.GetUID() != p.GetUID() {
		p.sendCreatureTurn(_creature)
	}
}