Beispiel #1
0
        protected virtual void ReadFirstInput()
        {
            Cmd cmd = ReadInput <Cmd>(m_taskInfo.Inputs[1]);

            m_taskInfo.Cmd = cmd;
        }
Beispiel #2
0
 protected virtual void OnCommand(Cmd cmd)
 {
 }
Beispiel #3
0
 private void BeginMutation(Cmd cmd)
 {
     m_dataController.ControlledData.Unit.MutationStartTick = m_currentTick;
     m_dataController.ControlledData.Unit.MutationDuration  = cmd.Duration;
 }
Beispiel #4
0
 protected abstract void OnExecuteCommand(Cmd cmd);
Beispiel #5
0
        private void ExecuteCommand(Cmd cmd)
        {
            if (cmd.ErrorCode != CmdResultCode.Success)
            {
                Debug.LogWarningFormat("Cmd {0} failed with error {1}", cmd.Code, cmd.ErrorCode);
                if (m_controlledVoxel != null)
                {
                    //Last command was failed go to idle state
                }
            }
            else
            {
                switch (cmd.Code)
                {
                case CmdCode.StateChanged:
                    OnStateChanged(cmd);
                    break;

                case CmdCode.Move:
                    OnMove(cmd);
                    break;

                case CmdCode.RotateLeft:
                    OnRotateLeft();
                    break;

                case CmdCode.RotateRight:
                    OnRotateRight();
                    break;

                case CmdCode.BeginSplit:
                    OnBeginSplit(cmd);
                    break;

                case CmdCode.Split:
                    OnSplit(cmd);
                    break;

                case CmdCode.BeginSplit4:
                    OnBeginSplit4(cmd);
                    break;

                case CmdCode.Split4:
                    OnSplit4(cmd);
                    break;

                case CmdCode.BeginGrow:
                    OnBeginGrow(cmd);
                    break;

                case CmdCode.Grow:
                    OnGrow();
                    break;

                case CmdCode.BeginDiminish:
                    OnBeginDiminish(cmd);
                    break;

                case CmdCode.Diminish:
                    OnDiminish();
                    break;

                case CmdCode.BeginConvert:
                    OnBeginConvert(cmd);
                    break;

                case CmdCode.Convert:
                    OnConvert(cmd);
                    break;

                case CmdCode.BeginSetHealth:
                    OnBeginSetHealth(cmd);
                    break;

                case CmdCode.SetHealth:
                    OnSetHealth(cmd);
                    break;

                case CmdCode.CreateAssignment:
                    OnAddAssignment(cmd);
                    break;

                case CmdCode.Cancel:
                    OnCancel(cmd);
                    break;

                default:
                    OnCommand(cmd);
                    break;
                }
            }
        }
Beispiel #6
0
 private void OnEngineCommandSubmitted(int playerIndex, Cmd cmd)
 {
     m_replay.Record(playerIndex, cmd, m_tick);
 }
Beispiel #7
0
 protected virtual void OnBeginSetHealth(Cmd cmd)
 {
 }
Beispiel #8
0
 public PlayerCmd(int playerIndex, Cmd cmd)
 {
     PlayerIndex = playerIndex;
     Cmd         = cmd;
 }
Beispiel #9
0
        public void Submit(Guid clientId, int playerIndex, Cmd cmd, ServerEventHandler <Cmd> callback)
        {
            Error error = new Error(StatusCode.OK);

            if (!m_clientIdToPlayers.ContainsKey(clientId))
            {
                error.Code = StatusCode.NotRegistered;
                callback(error, cmd);
                return;
            }

            if (cmd.Code == CmdCode.LeaveRoom)
            {
                error.Code = StatusCode.NotAllowed;
            }
            else
            {
                if (!m_initialized)
                {
                    error.Code    = StatusCode.NotAllowed;
                    error.Message = "Match is not initialized";
                }
                else if (!enabled)
                {
                    error.Code    = StatusCode.Paused;
                    error.Message = "Match is paused";
                }
                else if (playerIndex < 0 || playerIndex >= m_room.Players.Count)
                {
                    error.Code    = StatusCode.NotAllowed;
                    error.Message = "Wrong player index";
                }
                else
                {
                    if (m_botControlManager.IsActiveBot(playerIndex))
                    {
                        if (m_botControlManager.HasControl(clientId))
                        {
                            m_engine.Submit(playerIndex, cmd); // if I will use RTT Ticks then it will be possible to reverse order of commands sent by client (which is BAD!)
                        }
                        else
                        {
                            error.Code    = StatusCode.NotAuthorized;
                            error.Message = "Not authorized";
                        }
                    }
                    else
                    {
                        Guid playerClientId;
                        if (m_playerToClientId.TryGetValue(m_room.Players[playerIndex], out playerClientId))
                        {
                            if (clientId == playerClientId)
                            {
                                m_engine.Submit(playerIndex, cmd);
                            }
                            else
                            {
                                error.Code    = StatusCode.NotAuthorized;
                                error.Message = "Not authorized";
                            }
                        }
                        else
                        {
                            error.Code    = StatusCode.NotAuthorized;
                            error.Message = "Not authorized";
                        }
                    }
                }
            }
            callback(error, cmd);
        }
Beispiel #10
0
 protected virtual Cmd HandleNextCmd(Cmd cmd)
 {
     return(cmd);
 }
Beispiel #11
0
 protected override void OnSetCommand(Cmd cmd)
 {
 }
Beispiel #12
0
        protected override Cmd OnTick(long tick) //Tick should be able return several commands
        {
            if (State == VoxelDataState.Moving)
            {
                if (m_commandsQueue.Count > 0 && !m_dataController.IsCollapsedOrBlocked)
                {
                    Cmd cmd = m_commandsQueue.Peek();
                    m_ticksBeforeNextCommand = cmd.Duration;

                    bool dequeue = true;
                    switch (cmd.Code)
                    {
                    case CmdCode.Move:
                    {
                        cmd = HandleNextMoveCmd(cmd);
                        if (cmd == null)
                        {
                            m_failedMoveAttempts++;
                            m_failedMoveAttempts %= (m_maxFailedMoveAttempts + 1);
                        }
                        else
                        {
                            m_failedMoveAttempts = 0;
                        }
                        dequeue = cmd != null;     //if null then wait a little bit and try again
                        break;
                    }

                    case CmdCode.RotateLeft:
                    {
                        m_dataController.RotateLeft();
                        break;
                    }

                    case CmdCode.RotateRight:
                    {
                        m_dataController.RotateRight();
                        break;
                    }

                    default:
                    {
                        cmd     = HandleNextCmd(cmd);
                        dequeue = cmd != null;     //if null then wait a little bit and try again
                        break;
                    }
                    }

                    if (dequeue && m_commandsQueue.Count > 0)
                    {
                        m_commandsQueue.Dequeue();
                    }

                    if (m_commandsQueue.Count == 0)
                    {
                        RaiseCmdExecuted();
                    }

                    return(cmd);
                }

                if (m_commandsQueue.Count == 0)
                {
                    RaiseCmdExecuted();
                }

                return(null);
            }
            else if ((State & VoxelDataState.Busy) == VoxelDataState.Busy)
            {
                if (m_commandsQueue.Count > 0)
                {
                    Cmd cmd = m_commandsQueue.Dequeue();
                    m_ticksBeforeNextCommand = cmd.Duration;

                    switch (cmd.Code)
                    {
                    case CmdCode.BeginSplit:
                    case CmdCode.BeginSplit4:
                    case CmdCode.BeginGrow:
                    case CmdCode.BeginDiminish:
                    case CmdCode.BeginConvert:
                    case CmdCode.BeginSetHealth:
                    {
                        m_dataController.ControlledData.Unit.MutationStartTick = tick;
                        return(cmd);
                    }

                    case CmdCode.Split:
                    {
                        CoordinateCmd coordinateCmd = new CoordinateCmd(cmd.Code, cmd.UnitIndex, cmd.Duration);
                        Coordinate[]  coordinates;
                        CmdResultCode result = m_dataController.Split(out coordinates, EatOrDestroyCallback);
                        if (result == CmdResultCode.Success)
                        {
                            coordinateCmd.Coordinates = coordinates;
                            RaiseCmdExecuted();
                        }
                        else
                        {
                            RaiseCmdFailed(coordinateCmd, result);
                        }

                        return(coordinateCmd);
                    }

                    case CmdCode.Split4:
                    {
                        CoordinateCmd coordinateCmd = new CoordinateCmd(cmd.Code, cmd.UnitIndex, cmd.Duration);
                        Coordinate[]  coordinates;
                        CmdResultCode result = m_dataController.Split4(out coordinates);
                        if (result == CmdResultCode.Success)
                        {
                            coordinateCmd.Coordinates = coordinates;
                            RaiseCmdExecuted();
                        }
                        else
                        {
                            RaiseCmdFailed(coordinateCmd, result);
                        }

                        return(coordinateCmd);
                    }

                    case CmdCode.Grow:
                    {
                        CmdResultCode result = m_dataController.Grow(EatOrDestroyCallback);
                        if (result == CmdResultCode.Success)
                        {
                            RaiseCmdExecuted();
                        }
                        else
                        {
                            RaiseCmdFailed(cmd, result);
                        }

                        return(cmd);
                    }

                    case CmdCode.Diminish:
                    {
                        CmdResultCode result = m_dataController.Diminish();
                        if (result == CmdResultCode.Success)
                        {
                            RaiseCmdExecuted();
                        }
                        else
                        {
                            RaiseCmdFailed(cmd, result);
                        }

                        return(cmd);
                    }

                    case CmdCode.Convert:
                    {
                        ChangeParamsCmd convertCmd = (ChangeParamsCmd)cmd;

                        int type = convertCmd.IntParams[0];

                        CmdResultCode result = m_dataController.Convert(type);
                        if (result == CmdResultCode.Success)
                        {
                            RaiseCmdExecuted();
                        }
                        else
                        {
                            RaiseCmdFailed(cmd, result);
                        }

                        return(cmd);
                    }

                    case CmdCode.SetHealth:
                    {
                        ChangeParamsCmd changeCmd = (ChangeParamsCmd)cmd;
                        int             health    = changeCmd.IntParams[0];
                        m_dataController.SetHealth(health);
                        RaiseCmdExecuted();
                        return(changeCmd);
                    }

                    case CmdCode.CreateAssignment:
                    {
                        CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;
                        if (addCmd.CreatePreview)
                        {
                            CmdResultCode result = m_dataController.CreatePreview(addCmd.PreviewType, addCmd.PreviewCoordinate);
                            if (result == CmdResultCode.Success)
                            {
                                RaiseCmdExecuted();
                            }
                            else
                            {
                                RaiseCmdFailed(cmd, result);
                            }
                        }
                        else
                        {
                            RaiseCmdExecuted();
                        }
                        return(cmd);
                    }

                    case CmdCode.Cancel:
                    {
                        IMatchPlayerController playerController = m_engine.GetPlayerController(m_dataController.PlayerIndex);
                        playerController.AssignmentsController.RemoveAssignment(this, null);
                        RaiseCmdExecuted();
                        return(cmd);
                    }
                    }
                }
            }

            return(null);
        }
Beispiel #13
0
 protected abstract void OnSetCommand(Cmd cmd);
Beispiel #14
0
        public void Tick(long tick, out Cmd cmd)
        {
            if (m_createdVoxels.Count != 0)
            {
                m_createdVoxels.Clear();
            }

            if (m_eatenOrDestroyedVoxels.Count != 0)
            {
                m_eatenOrDestroyedVoxels.Clear();
            }

            if (!m_dataController.IsAlive)
            {
                if (State != VoxelDataState.Idle)
                {
                    RaiseCmdFailed(null, CmdResultCode.Fail_NoUnit);
                }
                else
                {
                    GoToIdleState();
                }
                cmd = null;
                return;
            }

            if (m_ticksBeforeNextCommand == 0)
            {
                cmd = OnTick(tick);

                if (State != m_prevState)
                {
                    if (cmd != null)
                    {
                        cmd = new CompositeCmd
                        {
                            UnitIndex = cmd.UnitIndex,
                            Duration  = cmd.Duration,
                            Commands  = new[]
                            {
                                cmd,
                                new ChangeParamsCmd(CmdCode.StateChanged)
                                {
                                    UnitIndex = cmd.UnitIndex,
                                    Duration  = cmd.Duration,
                                    IntParams = new[]
                                    {
                                        (int)m_prevState,
                                        (int)State
                                    }
                                }
                            }
                        };
                    }
                    else
                    {
                        cmd = new ChangeParamsCmd(CmdCode.StateChanged)
                        {
                            UnitIndex = Id,
                            IntParams = new[]
                            {
                                (int)m_prevState,
                                (int)State
                            }
                        };
                    }

                    CmdResultCode noFail = m_dataController.SetVoxelDataState(State);
                    if (noFail != CmdResultCode.Success)
                    {
                        throw new InvalidOperationException("");
                    }
                    m_prevState = State;
                }

                return;
            }
            else
            {
                m_ticksBeforeNextCommand--;
            }

            cmd = null;
            return;
        }
Beispiel #15
0
 public virtual void Record(int playerIndex, Cmd cmd, long tick)
 {
     m_playerIndices.Enqueue(playerIndex);
     m_ticks.Enqueue(tick);
     m_commands.Enqueue(cmd);
 }
Beispiel #16
0
 public override void Record(int playerId, Cmd cmd, long tick)
 {
 }