C# Commands.GetType方法代码示例

 // Constructor
 public PrioritizedCommand(Commands.Command newCommand)
 {
     /*if (newCommand.GetType() == typeof(Tests.DynamicDamageCommand))
     {
         damage = ((Tests.DynamicDamageCommand)newCommand).Strength;
     }
     else*/ if (newCommand.GetType() == typeof(Commands.DamageCommand))
     {
         damage = ((Commands.DamageCommand)newCommand).Strength;
     }
     range = newCommand.Range;
     command = newCommand;
     next = null;
     targetOptions = new List<CommandInfo>();
 }

 private void RunMainAndEpilog(Commands.BaseCommand command)
 {
     Debug.Assert(command.Context == this);
     Debug.Assert(RunningCommand == null);
     RunningCommand = command;
     if (command.ValidateOnRun() && command.DefaultValidateOnRun(this))
     {
         command.ExecutionPhase = Commands.CommandPhase.Main;
         command.RunMain();
         if (!(command is Commands.ISilentCommand))
         {
             command.ExecutionPhase = Commands.CommandPhase.Epilog;
             GetCommandRunner(command.GetType()).RunEpilog(command);
         }
     }
     Game.Controller.OnCommandEnd(command);
     RunningCommand = null;
 }

        private CommandResult RunPrerequisite(Commands.BaseCommand command, bool resolveConditions)
        {
            Debug.Assert(command.Context == this);
            Debug.Assert(RunningCommand == null);
            RunningCommand = command;
            command.ExecutionPhase = Commands.CommandPhase.Prerequisite;

            var runner = GetCommandRunner(command.GetType());
            var ret = runner.RunPrerequisite(command);
            if (!ret.Canceled)
            {
                command.ExecutionPhase = Commands.CommandPhase.Condition;
                ret = ResolveConditions(!resolveConditions);
            }

            RunningCommand = null;

            return ret;
        }

        // This function accepts program, target, and intended command.  It first performs error checking to
        // ensure that the command is valid, then updates the associated AINodeData and program list to reflect
        // game changes as a result of this command, and finally submits the command to the turnActions queue for
        // sending during subsequent calls to HandleAITurn.
        private CommandCode PerformCommand(Haxxit.Maps.Point target, Haxxit.Maps.Point source, Commands.Command command)
        {
            if (command == null)
            {
                return CommandCode.NoCommandSpecified;
            }
            else if (!IsInBounds(target))
            {
                return CommandCode.TargetWasOutOfBounds;
            }
            else if (mapData[target.X, target.Y].OccupiedBy == null)
            {
                return CommandCode.NoProgramAtTarget;
            }
            else if (command.Range < Math.Abs(target.X - source.X) + Math.Abs(target.Y - source.Y))
            {
                return CommandCode.ProgramOutOfRange;
            }

            // Will hold all nodes touched by target program both before and after command
            List<Haxxit.Maps.Point> programPoints = new List<Haxxit.Maps.Point>();

            // Get all the nodes currently associated with the program
            Haxxit.Maps.ProgramHeadNode targetProgram = mapData[target.X, target.Y].OccupiedBy;
            foreach (Haxxit.Maps.MapNode node in targetProgram.GetAllNodes())
            {
                programPoints.Insert(0, node.coordinate);
            }

            Haxxit.Maps.CommandEventArgs commandArgs = new Haxxit.Maps.CommandEventArgs(target, source, command.Name);
            turnActions.Enqueue(new NotifyArgs("haxxit.map.command", this, commandArgs, NotifyArgs.ArgType.Command));
            if(command.GetType() == typeof(Commands.DamageCommand))
            {
                int damage = ((Commands.DamageCommand)command).Strength;
                int index = 0;
                foreach (Haxxit.Maps.Point point in programPoints)
                {
                    if (index < damage)
                    {
                        mapData[point.X, point.Y].IsAvailable = true;
                        mapData[point.X, point.Y].OccupiedBy = null;
                    }
                    index++;
                }
                if (index <= damage)
                {
                    enemyPrograms.Remove(targetProgram);
                }
            }
            else if (command.GetType() == typeof(Commands.DamageCommand))
            {
                int damage = ((Commands.DamageCommand)command).Strength;
                int index = 0;
                foreach (Haxxit.Maps.Point point in programPoints)
                {
                    if (index < damage)
                    {
                        mapData[point.X, point.Y].IsAvailable = true;
                        mapData[point.X, point.Y].OccupiedBy = null;
                    }
                    index++;
                }
                if (index <= damage)
                {
                    enemyPrograms.Remove(targetProgram);
                }
            }
            return CommandCode.Success;
        }

        /// <summary>
        /// Ein neuer Kommand ist über eine Kommunikationsschnittstelle angekommen
        /// kümmern wir uns darum!
        /// </summary>
        /// <param name="client"></param>
        /// <param name="Command"></param>
        public virtual void CommandRecieved(System.Net.Sockets.TcpClient client, Commands.BaseCommand recievedCommand)
        {
            Console.WriteLine(recievedCommand.GetType().ToString());
            try{
            if (recievedCommand.completed)
            {
                recievedCommand.ProcessResults(this);
                if (!recievedCommand.isAsync)
                {
                    lock (SynclockCommands)
                    {
                        SyncCommands.Add(recievedCommand.guid, recievedCommand);
                    }
                }
            }
            else
            {
                    Console.WriteLine("RemoteExec");
                recievedCommand.RemoteExecute(this);
                recievedCommand.completed = true;
                BinaryFormatter formatter = new BinaryFormatter();
                    MemoryStream memstr = new MemoryStream();
                formatter.Serialize(memstr, recievedCommand);
                    var outputstream = client.GetStream();
                        outputstream.Write(memstr.ToArray(),0,Convert.ToInt32(memstr.Length));
                    outputstream.Flush();

            }
            }catch (Exception ex){
                Console.WriteLine(ex.Message+ " "+ ex.StackTrace.ToString());

            }
        }