private static void RemoveOldGameStates(Queue <PlayerCommandData> playerCommandsTmp)
{
if (players.Count == 0)
{
gameStates = new Dictionary <int, GameState>();
}
//Remove old states
Queue <PlayerCommandData> .Enumerator enumerator = playerCommandsTmp.GetEnumerator();
Dictionary <int, int> turnsReceived = new Dictionary <int, int>();
while (enumerator.MoveNext())
{
PlayerCommandData cmd = enumerator.Current;
if (!turnsReceived.ContainsKey(cmd.turnNumber))
{
turnsReceived.Add(cmd.turnNumber, 0);
}
turnsReceived[cmd.turnNumber] = turnsReceived[cmd.turnNumber] + 1;
}
foreach (KeyValuePair <int, int> entry in turnsReceived)
{
if (entry.Value >= players.Count)
{
gameStates.Remove(entry.Key);
}
}
}
public static void PlayerCommand(int _fromClient, Packet _packet)
{
PlayerCommandData cmd = new PlayerCommandData(_packet);
cmd.playerId = _fromClient;
GameLogic.onPlayerCommand(cmd);
}
protected override void OnUpdate()
{
var entities = cmdTargetGroup.ToEntityArray(Allocator.TempJob);
if (entities.Length == 1)
{
var ent = entities[0];
if (!EntityManager.HasComponent <PlayerCommandData>(ent))
{
PostUpdateCommands.AddBuffer <PlayerCommandData>(ent);
var ctc = EntityManager.GetComponentData <CommandTargetComponent>(ent);
ctc.targetEntity = ent;
PostUpdateCommands.SetComponent(ent, ctc);
}
else
{
var cmdBuf = EntityManager.GetBuffer <PlayerCommandData>(ent);
PlayerCommandData cmdData = default;
cmdData.tick = m_TimeSystem.predictTargetTick;
cmdData.horizontal = Input.GetAxisRaw("Horizontal");
cmdData.vertical = Input.GetAxisRaw("Vertical");
cmdBuf.AddCommandData(cmdData);
}
}
entities.Dispose();
}
void UpdatePlayerCommand(UnitBase unit, PlayerCommandData cmd)
{
Debug.Log("Player " + unit.PlayerId + " " + cmd.command.ToString() + " , value = " + cmd.value);
switch (cmd.command)
{
case PlayerCommand.LookUp:
break;
case PlayerCommand.LookDown:
break;
case PlayerCommand.FireBullet:
unit.FireBullet();
playersCommands.Add(cmd);
break;
case PlayerCommand.Respawn:
RespawnPlayer(unit.PlayerId);
playersCommands.Add(cmd);
break;
default:
Debug.Assert(false, "TODO: Missing command : " + cmd.command.ToString());
break;
}
}
public static void PlayerCommand(PlayerCommandData data)
{
using (Packet _packet = new Packet((int)ClientPackets.playerCommand))
{
data.WriteToPacket(_packet);
SendTCPData(_packet);
}
}
protected override void OnUpdate()
{
if (cmdTargetGroup.IsEmptyIgnoreFilter)
{
return;
}
var entityArray = cmdTargetGroup.GetEntityArraySt();
if (entityArray.Length == 1)
{
Entity ent = entityArray[0];
if (!EntityManager.HasComponent <PlayerCommandData>(ent))
{
EntityManager.AddBuffer <PlayerCommandData>(ent);
var ctc = EntityManager.GetComponentData <CommandTargetComponent>(ent);
ctc.targetEntity = ent;
EntityManager.SetComponentData(ent, ctc);
}
if (!EntityManager.HasComponent <NetworkStreamDisconnected>(ent))
{
var cmdBuf = EntityManager.GetBuffer <PlayerCommandData>(ent);
PlayerCommandData cmdData = default(PlayerCommandData);
if (Input.GetKey("left"))
{
cmdData.left = 1;
}
if (Input.GetKey("right"))
{
cmdData.right = 1;
}
if (Input.GetKey("up"))
{
cmdData.forward = 1;
}
if (Input.GetMouseButtonUp(1))
{
cmdData.grenade = grenadeDebugNo;
Debug.Log("LZ: Send Grenade #" + cmdData.grenade + " at frame #" + Time.frameCount);
grenadeDebugNo++;
}
cmdData.tick = NetworkTimeSystem.predictTargetTick;
cmdBuf.AddCommandData(cmdData);
}
}
}
public static void handlePlayerCommands()
{
while (playerCommands.Count > 0)
{
PlayerCommandData playerCommandData = playerCommands.Dequeue();
if (players.ContainsKey(playerCommandData.playerId) && players[playerCommandData.playerId].gameObj != null)
{
Player player = players[playerCommandData.playerId];
CharacterObject characterObject = player.gameObj;
characterObject.position = playerCommandData.position;
characterObject.direction = playerCommandData.direction;
handlePlayerAbilities(characterObject, playerCommandData.turnNumber, playerCommandData.abilityActivations);
}
}
}
private void FixedUpdate()
{
//TODO now we apply directly -> fix add interpolation between old and new
while (gameStateQueue.Count > 0)
{
GameState gameState = gameStateQueue.Dequeue();
turnNumber = gameState.turnNumber;
//Handle events
handleEvents(gameState.events);
//Update character states
foreach (CharacterStateData characterStateData in gameState.characters)
{
if (!characters.ContainsKey(characterStateData.id))
{
OnCharacterShouldSpawn(characterStateData);
}
else
{
CharacterObject character = characters[characterStateData.id];
character.hp = characterStateData.hp;
character.speed = characterStateData.speed;
//Only update other players
if (players[Client.instance.myId].character != null && players[Client.instance.myId].character.id != characterStateData.id)
{
character.direction = characterStateData.direction;
character.Move(new Vector2(characterStateData.position.X, characterStateData.position.Y));
}
}
}
//Update building states
foreach (BuildingStateData buildingStateData in gameState.buildings)
{
if (!buildings.ContainsKey(buildingStateData.id))
{
onBuildingShouldSpawn(buildingStateData);
}
else
{
//TODO
}
}
//Handle local player input
if (players.ContainsKey(Client.instance.myId) && players[Client.instance.myId].character != null)
{
Player localPlayer = players[Client.instance.myId];
CharacterObject character = localPlayer.character;
float delta = Time.deltaTime;
List <EPlayerAction> actions = PlayerController.GetActions();
List <EPlayerAction> abilities = PlayerController.GetAbilities();
List <AbilityActivationData> abilityActivations = ActivateAbilities(character, abilities);
MoveLocalPlayer(character, actions, delta);
character.SetDirection(actions);
EObjectDirection direction = character.direction;
System.Numerics.Vector2 characterPosition = new System.Numerics.Vector2(character.transform.position.x, character.transform.position.y);
//Send player command to server
PlayerCommandData cmdData = new PlayerCommandData(turnNumber, delta, characterPosition, direction, actions, abilityActivations);
ClientSend.PlayerCommand(cmdData);
}
gameStateHistory.Add(gameState);
}
if (gameStateHistory.Count > 5)
{
gameStateHistory.RemoveAt(0);
}
}
public static void onPlayerCommand(PlayerCommandData cmd)
{
playerCommands.Enqueue(cmd);
}
