go-susapp/gamerpcprocessor.go

package main

import (
	"encoding/hex"
	"fmt"

	"codehub.onpointcoding.net/sean/go-susapp/gamedata"
	"codehub.onpointcoding.net/sean/go-susapp/innernetobjects"
	"codehub.onpointcoding.net/sean/go-susapp/protocol"
)

type GameRPCProcessor struct {
	sus        *SusApp
	rpcCallMap map[byte]func(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc)
}

func NewGameRPCProcessor(sus *SusApp) *GameRPCProcessor {
	proc := &GameRPCProcessor{sus: sus}
	proc.rpcCallMap = map[byte]func(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc){
		0x00: proc.captureRpcPlayAnimation,
		0x02: proc.captureRpcSyncSettings,
		0x03: proc.captureRpcSetInfected,
		0x04: proc.captureRpcExiled,
		0x06: proc.captureRpcSetName,
		0x08: proc.captureRpcSetColor,
		0x09: proc.captureRpcSetHat,
		0x0a: proc.captureRpcSetSkin,
		0x11: proc.captureRpcSetPet,
		0x12: proc.captureRpcSetStartCounter,
		0x13: proc.captureRpcEnterVent,
		0x14: proc.captureRpcExitVent,
		0x15: proc.captureRpcSnapTo,
		0x1d: proc.captureRpcSetTasks,
	}
	return proc
}

func (proc *GameRPCProcessor) receiveGameRpcCall(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	v, ok := proc.rpcCallMap[rpc.RPCCallID]
	if ok {
		v(net, GameID, rpc)
	} else {
		fmt.Printf("Unable to parse gamedata rpc call with id of %x\n", rpc.RPCCallID)
		fmt.Printf("Packet: %v\n", hex.EncodeToString(rpc.GetUnderlyingHazel().GetUnderlyingPacket().Dump()))
	}
}

func (proc *GameRPCProcessor) captureRpcPlayAnimation(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {

}

func (proc *GameRPCProcessor) captureRpcSyncSettings(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSyncSettings{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	if a.Options.IsDefaults {
		proc.sus.state.CurrentGame.GameOptions = protocol.NewDefaultGameOptionsData()
	} else {
		proc.sus.state.CurrentGame.GameOptions = a.Options
	}
}

func (proc *GameRPCProcessor) captureRpcSetInfected(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetInfected{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	for i := 0; i < len(a.Impostors); i++ {
		proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerID[a.Impostors[i]].IsImpostor = true
	}
}

func (proc *GameRPCProcessor) captureRpcExiled(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {

}

func (proc *GameRPCProcessor) captureRpcSetName(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetName{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerName = a.Name
}

func (proc *GameRPCProcessor) captureRpcSetColor(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetColor{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerColor = a.Color
}

func (proc *GameRPCProcessor) captureRpcSetHat(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetHat{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerHat = a.HatID
}

func (proc *GameRPCProcessor) captureRpcSetSkin(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetSkin{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerSkin = a.SkinID
}

func (proc *GameRPCProcessor) captureRpcSetPet(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetPet{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerPet = a.PetID
}

func (proc *GameRPCProcessor) captureRpcSetStartCounter(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetStartCounter{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	if proc.sus.state.CurrentGame != nil {
		proc.sus.state.CurrentGame.StartGameTimer = a.TimeRemaining
	}
}

func (proc *GameRPCProcessor) captureRpcEnterVent(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcEnterVent{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].InVent = true
}

func (proc *GameRPCProcessor) captureRpcExitVent(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcExitVent{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].InVent = false
}

func (proc *GameRPCProcessor) captureRpcSnapTo(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSnapTo{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())
	netId := proc.sus.state.CurrentGame.PlayerNetObjects.ByPlayerNetID[rpc.SenderNetID].PlayerNetworkTransform
	var c0 innernetobjects.InnerNetObject = *proc.sus.state.CurrentGame.NetObjects[netId]
	b, ok := c0.(*innernetobjects.PlayerNetworkTransform)
	if ok {
		b.TargetPosition = a.Position
	}
}

func (proc *GameRPCProcessor) captureRpcSetTasks(net *protocol.PacketHandler, GameID int32, rpc *gamedata.Rpc) {
	a := &gamedata.RpcSetTasks{}
	a.ReadFromPacket(rpc.GetUnderlyingHazel().GetUnderlyingPacket())

	if a.PlayerID == proc.sus.state.CurrentGame.GetMyPlayer().PlayerID {
		proc.sus.state.CurrentGame.MyTasks = a.Tasks
	}
}