Пример #1
0
 public void AddArgument(ArgHandler handler, params string[] names)
 {
     foreach (string name in names)
     {
         argumentHandlers.Add(name, handler);
     }
 }
Пример #2
0
 public void PreMergeOperations()
 {
     foreach (Player player in Players)
     {
         ArgHandler argument = new ArgHandler("CallCrusade" + player.color + "Blocked2", "Crusade now Unavailable");
         ListOfArguments.Add(argument);
     }
 }
Пример #3
0
 public void Run()
 {
     if (!disabled)
     {
         ActivePlayer.Gold        -= 300;
         ActivePlayer.Stone       -= 150;
         SelectedNode.NodeType     = enmNodeType.Castle;
         SelectedNode.DefenseLevel = 1;
         ArgHandler arg1 = new ArgHandler("ReformVillageToCastle" + ActivePlayer.color.ToString() + SelectedNode.Name,
                                          SelectedNode.Name);
         ListOfArguments.Add(arg1);
     }
 }
Пример #4
0
        public void Run()
        {
            Random rnd = new Random();

            foreach (Node node in Map.nodeList)
            {
                if (node.NodeType == enmNodeType.Church)
                {
                    string    ID           = ActivePlayer.color.ToString() + "Commander" + ActivePlayer.AgentCounter.ToString();
                    Commander newCommander = new Commander(ID, Constants.commanderGoldUpkeep, Constants.commanderFoodUpkeep, node.Name, ActivePlayer.color);
                    newCommander.army.LightInfantry = rnd.Next(5, 15);
                    newCommander.army.HeavyInfantry = rnd.Next(1, 10);
                    newCommander.army.LightCavalry  = rnd.Next(1, 10);
                    newCommander.army.HeavyCavalry  = rnd.Next(0, 5);
                    newCommander.army.Archers       = rnd.Next(5, 25);
                    newCommander.army.Musketeers    = rnd.Next(0, 5);
                    ActivePlayer.addCommander(newCommander);
                }
            }
            ArgHandler argument = new ArgHandler("CallCrusade" + ActivePlayer.color + "Blocked1", "Crusade Already Called");

            ListOfArguments.Add(argument);
        }
Пример #5
0
 public void AddArgument(ArgHandler handler, params string[] names)
 {
     foreach(string name in names)
         argumentHandlers.Add(name, handler);
 }
Пример #6
0
        public void Parse(string[] args)
        {
            for (int i = 0; i < args.Length; ++i)
            {
                string arg = args[i];

                // Check the dash.
                if (arg[0] != '-')
                {
                    Miscellaneous(arg);
                    continue;
                }

                // Check the colon.
                int index = arg.IndexOf(':');
                if (index >= 0)
                {
                    // Split the argument name and value
                    string argName  = arg.Substring(0, index);
                    string argValue = arg.Substring(index + 1);

                    // In windows some path names can fall in this case.
                    if (argumentHandlers.ContainsKey(argName))
                    {
                        // Invoke the handler.
                        ArgHandler1 handler = (ArgHandler1)argumentHandlers[argName];
                        handler(argValue);
                        continue;
                    }
                }

                // Check full name.
                if (argumentHandlers.ContainsKey(arg))
                {
                    // Found a handler.
                    object handler = argumentHandlers[arg];

                    if (handler is ArgHandler)
                    {
                        ArgHandler h = (ArgHandler)handler;
                        h();
                    }
                    else if (handler is ArgHandler1)
                    {
                        ArgHandler1 h = (ArgHandler1)handler;
                        h(args[++i]);
                    }
                    else if (handler is ArgHandler2)
                    {
                        ArgHandler2 h = (ArgHandler2)handler;
                        h(args[++i], args[++i]);
                    }

                    continue;
                }

                // Find a prefix.
                bool found = false;
                foreach (string prefix in prefixes.Keys)
                {
                    if (!arg.StartsWith(prefix))
                    {
                        continue;
                    }

                    // Found a prefix.
                    arg = arg.Substring(prefix.Length);
                    prefixes[prefix](arg);
                    found = true;
                }

                // Print help
                if (!found)
                {
                    System.Console.WriteLine("Unknown option " + arg);
                    Help();
                    System.Environment.Exit(-1);
                }
            }
        }