Exemple #1
0
    private void AddLocalChangeBehaviourCommand(Entity entity, Behaviour newBehaviour)
    {
        Debug.Assert(entityManager.HasComponent <GroupBehaviour>(entity), "the current selected entity doesn't have a group behaviour component. can't recieve a change behaviour command");

        CommandStorageSystem.TryAddLocalCommand(new ChangeBehaviourCommand()
        {
            Target       = entity,
            NewBehaviour = new GroupBehaviour()
            {
                Value = newBehaviour
            }
        }, World.Active);
    }
Exemple #2
0
    private void SendCommandsToNetwork()
    {
        if (OfflineMode.OffLineMode)
        {
            return;
        }

        int  turnToExecuteTheCommands = MainSimulationLoopSystem.CurrentLockstepTurn + MainSimulationLoopSystem.COMMANDS_DELAY;
        byte eventCode;

        object[] content;

        Debug.Log($"On CommandNetworkSender, volatile commands to send {CommandStorageSystem.AreVolatileCommands()}");
        if (CommandStorageSystem.AreVolatileCommands())
        {
            eventCode = (byte)NetworkEventTypes.CommandEventCode;
            object[] commands = CommandStorageSystem.GetAllVolatileCommandsSerialized();
            content = new object[]
            {
                turnToExecuteTheCommands,
                commands[0],
                commands[1],
                commands[2]
            };
        }
        else
        {
            eventCode = (byte)NetworkEventTypes.EmptyCommandEventCode;
            content   = new object[] { turnToExecuteTheCommands };
        }

        RaiseEventOptions raiseOptions = new RaiseEventOptions()
        {
            Receivers = ReceiverGroup.Others
        };
        SendOptions sendOptions = new SendOptions()
        {
            Reliability = true
        };

        PhotonNetwork.RaiseEvent(eventCode, content, raiseOptions, sendOptions);
    }
Exemple #3
0
    //event data layout:
    //it must be a object array.
    //and always the first element is the turn of execution.
    private void CommandCallback(EventData photonEvent)
    {
        //null check is important

        object[] eventData     = (object[])photonEvent.CustomData;
        int      turnToExecute = (int)eventData[0];


        object[]      serializedMoveCommands = (object[])eventData[1];
        MoveCommand[] moveCommands;
        if (serializedMoveCommands != null)
        {
            moveCommands = new MoveCommand[serializedMoveCommands.Length];
            for (int i = 0; i < serializedMoveCommands.Length; i++)
            {
                moveCommands[i] = CommandUtils.DeserializeMoveCommand((object[])serializedMoveCommands[i]);
            }
        }
        else
        {
            moveCommands = null;
        }



        object[] serializedChangeBehaviourCommand = (object[])eventData[2];
        ChangeBehaviourCommand[] changeBehaviourCommands;
        if (serializedChangeBehaviourCommand != null)
        {
            changeBehaviourCommands = new ChangeBehaviourCommand[serializedChangeBehaviourCommand.Length];
            for (int i = 0; i < changeBehaviourCommands.Length; i++)
            {
                changeBehaviourCommands[i] = CommandUtils.DeserializeChangeBehaviourCommand((object[])serializedChangeBehaviourCommand[i]);
            }
        }
        else
        {
            changeBehaviourCommands = null;
        }


        object[]        serializedGatherCommand = (object[])eventData[3];
        GatherCommand[] gatherCommands;
        if (serializedGatherCommand != null)
        {
            gatherCommands = new GatherCommand[serializedGatherCommand.Length];
            for (int i = 0; i < gatherCommands.Length; i++)
            {
                gatherCommands[i] = CommandUtils.DeserializeGatherCommand((object[])serializedGatherCommand[i]);
            }
        }
        else
        {
            gatherCommands = null;
        }

        //otros commandos
        CommandStorageSystem.QueueNetworkedCommands(turnToExecute, moveCommands, changeBehaviourCommands, gatherCommands);

        CreateCommandLockstepCheck(turnToExecute);
        SendCommandConfirmationEvent(turnToExecute);
    }
Exemple #4
0
 //this system manages the volatile commands of each lockstep turn.
 //sends them to the network and queues them into the definitive dictionary.
 protected override void OnUpdate()
 {
     SendCommandsToNetwork();
     CommandStorageSystem.QueueVolatileCommands(MainSimulationLoopSystem.CurrentLockstepTurn + MainSimulationLoopSystem.COMMANDS_DELAY);
 }
Exemple #5
0
    protected override void OnUpdate()
    {
        if (Input.GetMouseButtonDown(1))
        {
            var currentSelected = SelectionSystem.CurrentSelection;
            if (MapManager.ActiveMap == null)
            {
                Debug.Log("we need the active map");
                return;
            }
            else if (currentSelected == null)
            {
                Debug.Log("There is not an entity selected");
                return;
            }
            //early out if the entity is of other team or doesn't have team.
            if (!EntityManager.HasComponent <Team>(currentSelected.entity))
            {
                return;
            }
            var selectedTeam = EntityManager.GetComponentData <Team>(currentSelected.entity).Number;
            if (!GameManager.PlayerTeams.Contains(selectedTeam))
            {
                return;
            }

            var currentSelectedEntity = currentSelected.entity;
            if (EntityManager.HasComponent <Commandable>(currentSelectedEntity))
            {
                //here we see the default command for the commandable
                var defaultCommandType = EntityManager.GetComponentData <Commandable>(currentSelectedEntity).DeafaultCommand;
                Hex clickHex           = MapManager.ActiveMap.layout.PixelToHex(Input.mousePosition, Camera.main);


                switch (defaultCommandType)
                {
                case CommandType.MOVE_COMMAND:
                    var moveCommand = new MoveCommand()
                    {
                        Target      = currentSelectedEntity,
                        Destination = new DestinationHex()
                        {
                            FinalDestination = clickHex
                        }
                    };
                    CommandStorageSystem.TryAddLocalCommand(moveCommand, World.Active);
                    break;

                case CommandType.GATHER_COMMAND:
                    //gather si es que se cliquea a un recurso, si no solo moverse.
                    if (ResourceSourceManagerSystem.TryGetResourceAtHex(clickHex, out ResourceSourceAndEntity source))
                    {
                        var gatherCommand = new GatherCommand()
                        {
                            Target    = currentSelectedEntity,
                            TargetPos = clickHex
                        };
                        CommandStorageSystem.TryAddLocalCommand(gatherCommand, World.Active);
                    }
                    else
                    {
                        var moveCommand2 = new MoveCommand()
                        {
                            Target      = currentSelectedEntity,
                            Destination = new DestinationHex()
                            {
                                FinalDestination = clickHex
                            }
                        };
                        CommandStorageSystem.TryAddLocalCommand(moveCommand2, World.Active);
                    }
                    break;


                default:
                    Debug.LogError("commandable doesn't have a valid default command");
                    break;
                }
            }
            else
            {
                Debug.Log("The selected entity cannot recieve commands. It isn't commandable!");
            }
        }
    }