예제 #1
0
        protected virtual void OnAddAssignment(Cmd cmd)
        {
            CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;

            if (addCmd.CreatePreview)
            {
                CmdResultCode noFail = m_dataController.CreatePreview(addCmd.PreviewType, addCmd.PreviewCoordinate);
                if (noFail != CmdResultCode.Success)
                {
                    throw new InvalidOperationException();
                }

                Coordinate coordinate = addCmd.PreviewCoordinate;
                //Voxel cloneActor = null;
                if (m_voxelMap.IsVisible(coordinate.MapPos, coordinate.Weight))
                {
                    Debug.Assert(m_controlledVoxel.Owner == addCmd.TargetPlayerIndex);
                    VoxelData voxelData = m_voxelMap.Map.GetPreview(addCmd.TargetPlayerIndex, coordinate);
                    AcquireVoxel(voxelData, coordinate.MapPos, coordinate.Weight);
                }
            }
        }
        private List <long> PostprocessCommand(List <long> spawnedUnitsList, Cmd cmd, IMatchUnitControllerCli unitController)
        {
            if (cmd.Code == CmdCode.Split || cmd.Code == CmdCode.Split4)
            {
                CoordinateCmd splitCmd = (CoordinateCmd)cmd;
                for (int i = 0; i < splitCmd.Coordinates.Length; ++i)
                {
                    Coordinate coordinate = splitCmd.Coordinates[i];
                    VoxelData  voxelData  = m_voxelMap.Map.Get(coordinate);
                    if (voxelData != null)
                    {
                        if (spawnedUnitsList == null)
                        {
                            spawnedUnitsList = new List <long>();
                        }

                        spawnedUnitsList.Add(m_identity);
                        CreateUnitController(voxelData, coordinate);
                    }
                }
            }
            else if (cmd.Code == CmdCode.Convert)
            {
                Coordinate coordinate = unitController.DataController.Coordinate;
                MapCell    cell       = m_voxelMap.Map.Get(coordinate.Row, coordinate.Col, coordinate.Weight);
                VoxelData  voxelData  = cell.GetVoxelDataAt(coordinate.Altitude);
                if (voxelData != null)
                {
                    if (VoxelData.IsUnit(voxelData.Type))
                    {
                        if (spawnedUnitsList == null)
                        {
                            spawnedUnitsList = new List <long>();
                        }

                        spawnedUnitsList.Add(m_identity);
                        CreateUnitController(voxelData, coordinate);
                    }
                    else
                    {
                        CreateAsset(voxelData, m_allAbilities[voxelData.Owner][voxelData.Type], cell);
                    }
                }
            }
            else if (cmd.Code == CmdCode.CreateAssignment)
            {
                CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;
                if (addCmd.CreatePreview)
                {
                    Coordinate coord     = addCmd.PreviewCoordinate;
                    MapCell    cell      = m_voxelMap.Map.Get(coord.Row, coord.Col, coord.Weight);
                    VoxelData  voxelData = cell.GetPreviewAt(m_playerIndex, coord.Altitude);
                    Debug.Assert(voxelData != null);

                    if (spawnedUnitsList == null)
                    {
                        spawnedUnitsList = new List <long>();
                    }

                    spawnedUnitsList.Add(m_identity);
                    CreateUnitController(voxelData, coord);
                }

                AssignmentsController.CreateAssignment(addCmd.GroupId, addCmd.UnitIndex, addCmd.TaskLaunchInfo, addCmd.HasTarget, addCmd.TargetPlayerIndex, addCmd.TargetId);
            }

            return(spawnedUnitsList);
        }
        private bool PostprocessCmd(bool unitsChanged, IMatchUnitController unitController, Cmd cmd)
        {
            if (cmd.IsFailed)
            {
                return(unitsChanged);
            }
            if (cmd.Code == CmdCode.Split || cmd.Code == CmdCode.Split4)
            {
                CoordinateCmd splitCmd = (CoordinateCmd)cmd;
                for (int c = 0; c < splitCmd.Coordinates.Length; ++c)
                {
                    Coordinate coordinate = splitCmd.Coordinates[c];
                    VoxelData  voxelData  = m_engine.Map.Get(coordinate);

                    if (voxelData != null)
                    {
                        CreateUnitController(voxelData, coordinate);
                        unitsChanged = true;
                    }
                }
            }
            else if (cmd.Code == CmdCode.Convert)
            {
                Coordinate coord     = unitController.DataController.Coordinate;
                MapCell    cell      = m_engine.Map.Get(coord.Row, coord.Col, coord.Weight);
                VoxelData  voxelData = cell.GetVoxelDataAt(coord.Altitude);

                if (voxelData != null)
                {
                    if (VoxelData.IsUnit(voxelData.Type))
                    {
                        CreateUnitController(voxelData, unitController.DataController.Coordinate);
                        unitsChanged = true;
                    }
                    else
                    {
                        CreateAsset(voxelData, cell);
                    }
                }
            }
            else if (cmd.Code == CmdCode.CreateAssignment)
            {
                CreateAssignmentCmd addCmd = (CreateAssignmentCmd)cmd;
                if (addCmd.CreatePreview)
                {
                    Coordinate coord     = addCmd.PreviewCoordinate;
                    MapCell    cell      = m_engine.Map.Get(coord.Row, coord.Col, coord.Weight);
                    VoxelData  voxelData = cell.GetPreviewAt(m_playerIndex, coord.Altitude);
                    Debug.Assert(voxelData != null);
                    CreateUnitController(voxelData, coord);

                    addCmd.HasTarget         = true;
                    addCmd.TargetId          = voxelData.UnitOrAssetIndex;
                    addCmd.TargetPlayerIndex = voxelData.Owner;
                }

                m_assignmentController.CreateAssignment(addCmd.GroupId, addCmd.UnitIndex, addCmd.TaskLaunchInfo, addCmd.HasTarget, addCmd.TargetPlayerIndex, addCmd.TargetId);
            }

            return(unitsChanged);
        }
예제 #4
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);
        }