Golang player.Player類代碼示例

func player_walk(player player.Player, packet encoding.Decodable) {
	var walkPacket *game_protocol.InboundPlayerWalkBlock
	switch p := packet.(type) {
	case *game_protocol.InboundPlayerWalk:
		walkPacket = (*game_protocol.InboundPlayerWalkBlock)(p)
	case *game_protocol.InboundPlayerWalkMap:
		walkPacket = (*game_protocol.InboundPlayerWalkBlock)(p)
	default:
		panic(fmt.Sprintf("got invalid walk packet: %T", p))
	}

	height := player.Position().Z()
	origin := position.NewAbsolute(int(walkPacket.OriginX), int(walkPacket.OriginY), height)

	waypoints := make([]*position.Absolute, len(walkPacket.Waypoints))

	wpq := player.WaypointQueue()
	wpq.Clear()
	wpq.Push(origin)
	for i, wp := range walkPacket.Waypoints {
		x1, y1 := int(wp.X), int(wp.Y)
		x2, y2 := int(origin.X()), int(origin.Y())
		waypoints[i] = position.NewAbsolute(int(x1+x2), int(y1+y2), height)

		wpq.Push(waypoints[i])
	}
}

// decodePacket decodes from the readBuffer using the ISAAC rand generator
func (svc *GameService) decodePacket(client player.Player) error {
	b := client.Conn().ReadBuffer
	data, err := b.Peek(1)
	if err != nil {
		return err
	}

	idByte := int(data[0])

	rand := client.ISAACIn().Rand()
	realId := uint8(uint32(idByte) - rand)
	packet, err := game_protocol.NewInboundPacket(int(realId))
	if err != nil {
		return fmt.Errorf("%v: packet %v", err, realId)
	}
	err = packet.Decode(b, rand)
	if err != nil {
		return err
	}

	if !client.Conn().IsDisconnecting() {
		client.Conn().Read <- packet
	}
	return nil
}

func Dispatch(player player.Player, packet encoding.Decodable) {
	typeString := reflect.TypeOf(packet).String()
	if handler, ok := routingTable[typeString]; ok {
		handler(player, packet)
	} else {
		player.Log().Info("Unhandled packet of type %v: %v", typeString, packet)
	}
}

// decodeLoginBlock handles the unencrypted login block
func (svc *GameService) decodeLoginBlock(client player.Player) error {
	loginBlock := game_protocol.InboundLoginBlock{}
	if err := loginBlock.Decode(client.Conn().ReadBuffer, nil); err != nil {
		return err
	}

	expectedSecureBlockSize := int(loginBlock.LoginLen) - ((9 * 4) + 1 + 1 + 1 + 2)
	if expectedSecureBlockSize != int(loginBlock.SecureBlockSize) {
		client.Log().Error("Secure block size mismatch: got %v expected %v", loginBlock.SecureBlockSize, expectedSecureBlockSize)
		client.Conn().Disconnect()
	}

	client.SetSecureBlockSize(int(loginBlock.SecureBlockSize))

	client.SetDecodeFunc(svc.decodeSecureBlock)
	return nil
}

// decodeSecureBlock handles the secure login block and the login response (via doLogin)
func (svc *GameService) decodeSecureBlock(client player.Player) error {
	rsaBlock := encoding.RSABlock{&game_protocol.InboundSecureLoginBlock{}}
	rsaArgs := encoding.RSADecodeArgs{
		Key:       svc.key,
		BlockSize: client.SecureBlockSize(),
	}
	if err := rsaBlock.Decode(client.Conn().ReadBuffer, rsaArgs); err != nil {
		return err
	}
	secureBlock := rsaBlock.Codable.(*game_protocol.InboundSecureLoginBlock)

	// Seed the RNGs
	inSeed := make([]uint32, 4)
	outSeed := make([]uint32, 4)
	for i := range inSeed {
		inSeed[i] = uint32(secureBlock.ISAACSeed[i])
		outSeed[i] = uint32(secureBlock.ISAACSeed[i]) + 50
	}
	client.InitISAAC(inSeed, outSeed)

	username := string(secureBlock.Username)
	password := string(secureBlock.Password)
	password = auth.HashPassword(password)

	return svc.doLogin(client, username, password)
}

// handshake performs the isaac key exchange
func (svc *GameService) handshake(client player.Player) error {
	serverSeed := client.ServerISAACSeed()

	handshake := protocol.InboundGameHandshake{}
	if err := handshake.Decode(client.Conn().ReadBuffer, nil); err != nil {
		return err
	}

	client.Conn().Write <- &protocol.OutboundGameHandshake{
		ServerISAACSeed: [2]encoding.Uint32{
			encoding.Uint32(serverSeed[0]), encoding.Uint32(serverSeed[1]),
		},
	}

	client.SetDecodeFunc(svc.decodeLoginBlock)
	return nil
}

// packetConsumer is the goroutine which picks packets from the readQueue and does something with them
func (svc *GameService) packetConsumer(client player.Player) {
L:
	for {
		select {
		case <-client.Conn().DisconnectChan:
			break L
		case pkt := <-client.Conn().Read:
			if _, ok := pkt.(*game_protocol.UnknownPacket); ok {
				/* unknown packet; dump to the log */
				client.Log().Debug("Got unknown packet: %v", pkt)
				continue
			}
			packet.Dispatch(client, pkt)
		}

	}
}

func (struc *PlayerUpdateBlock) buildUpdateBlock(w io.Writer, thisPlayer player.Player) error {
	flags := thisPlayer.Flags() & ^entity.MobFlagMovementUpdate
	if flags == 0 {
		return nil
	}

	if flags >= 256 {
		flags |= 64
		flagsEnc := encoding.Uint16(flags)
		err := flagsEnc.Encode(w, encoding.IntLittleEndian)
		if err != nil {
			return err
		}
	} else {
		flagsEnc := encoding.Uint8(flags)
		err := flagsEnc.Encode(w, encoding.IntNilFlag)
		if err != nil {
			return err
		}
	}

	/* Update appearance */
	if (flags & entity.MobFlagIdentityUpdate) != 0 {
		buf := encoding.NewBuffer()
		appearance := thisPlayer.Profile().Appearance()
		anims := thisPlayer.Animations()
		appearanceBlock := OutboundPlayerAppearance{
			Gender:   encoding.Uint8(appearance.Gender()),
			HeadIcon: encoding.Uint8(appearance.HeadIcon()),

			HelmModel:       encoding.Uint8(0),
			CapeModel:       encoding.Uint8(0),
			AmuletModel:     encoding.Uint8(0),
			RightWieldModel: encoding.Uint8(0),
			TorsoModel:      encoding.Uint16(256 + appearance.Model(player.Torso)),
			LeftWieldModel:  encoding.Uint8(0),
			ArmsModel:       encoding.Uint16(256 + appearance.Model(player.Arms)),
			LegsModel:       encoding.Uint16(256 + appearance.Model(player.Legs)),
			HeadModel:       encoding.Uint16(256 + appearance.Model(player.Head)),
			HandsModel:      encoding.Uint16(256 + appearance.Model(player.Hands)),
			FeetModel:       encoding.Uint16(256 + appearance.Model(player.Feet)),
			BeardModel:      encoding.Uint16(256 + appearance.Model(player.Beard)),

			HairColor:  encoding.Uint8(appearance.Color(player.Hair)),
			TorsoColor: encoding.Uint8(appearance.Color(player.Torso)),
			LegColor:   encoding.Uint8(appearance.Color(player.Legs)),
			FeetColor:  encoding.Uint8(appearance.Color(player.Feet)),
			SkinColor:  encoding.Uint8(appearance.Color(player.Skin)),

			AnimIdle:       encoding.Uint16(anims.Animation(player.AnimIdle)),
			AnimSpotRotate: encoding.Uint16(anims.Animation(player.AnimSpotRotate)),
			AnimWalk:       encoding.Uint16(anims.Animation(player.AnimWalk)),
			AnimRotate180:  encoding.Uint16(anims.Animation(player.AnimRotate180)),
			AnimRotateCCW:  encoding.Uint16(anims.Animation(player.AnimRotateCCW)),
			AnimRotateCW:   encoding.Uint16(anims.Animation(player.AnimRotateCW)),
			AnimRun:        encoding.Uint16(anims.Animation(player.AnimRun)),
		}

		err := appearanceBlock.Encode(buf, nil)
		if err != nil {
			return err
		}

		block := buf.Bytes()
		blockSize := encoding.Uint8(len(block))
		err = blockSize.Encode(w, encoding.IntNegate)
		if err != nil {
			return err
		}

		_, err = w.Write(block)
		if err != nil {
			return err
		}
	}
	return nil
}

// doLogin authenticates the user, sends the login response, and sets up the client for standard packet processing
func (svc *GameService) doLogin(client player.Player, username, password string) error {
	profile, responseCode := svc.auth.LookupProfile(username, password)

	if responseCode != auth.AuthOkay {
		client.Conn().Write <- &game_protocol.OutboundLoginResponseUnsuccessful{
			Response: encoding.Uint8(responseCode),
		}
		client.Conn().Disconnect()
		return nil
	}

	client.SetProfile(profile.(player.Profile))

	// Successful login, do all the stuff
	client.Conn().Write <- &game_protocol.OutboundLoginResponse{
		Response: encoding.Uint8(responseCode),
		Rights:   encoding.Uint8(client.Profile().Rights()),
		Flagged:  0,
	}
	client.SetDecodeFunc(svc.decodePacket)
	go svc.packetConsumer(client)

	game_event.PlayerLogin.NotifyObservers(client)
	client.LoadProfile()
	game_event.PlayerFinishLogin.NotifyObservers(client)

	go func() {
		client.Conn().WaitForDisconnect()
		game_event.PlayerLogout.NotifyObservers(client)
	}()
	return nil
}