public void AssignMonument(List <string> monumentArgs)
    {
        switch (monumentArgs[1])
        {
        case "Fire":
            var fireMonument = new FireMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            nations.FireMonuments.Add(fireMonument);
            break;

        case "Air":
            var airMonument = new AirMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            nations.AirMonuments.Add(airMonument);

            break;

        case "Water":
            var waterMonument = new WaterMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            nations.WaterMonuments.Add(waterMonument);

            break;

        case "Earth":
            var earthMonument = new EarthMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            nations.EarthMonuments.Add(earthMonument);
            break;
        }
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        switch (monumentArgs[1])
        {
        case "Air":
            Monument airMonument = new AirMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            Airmonuments.Add(airMonument);
            break;

        case "Water":
            Monument waterMonument = new WaterMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            Watermonuments.Add(waterMonument);
            break;

        case "Fire":
            Monument fireMonument = new FireMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            Firemonuments.Add(fireMonument);
            break;

        case "Earth":
            Monument earthMonument = new EarthMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            Earthmonuments.Add(earthMonument);
            break;
        }
    }
Example #3
0
    private static void InsertMonument(string[] cmdArgs, List <Nation> nations)
    {
        var type     = cmdArgs[1];
        var name     = cmdArgs[2];
        var affinity = int.Parse(cmdArgs[3]);

        switch (type)
        {
        case "Air":
            Monument airMonument = new AirMonument(name, affinity);
            var      airNation   = nations.FirstOrDefault(n => n.Name == "Air Nation");
            airNation.Monuments.Add(airMonument);
            break;

        case "Earth":
            Monument earthMonument = new EarthMonument(name, affinity);
            var      earthNation   = nations.FirstOrDefault(n => n.Name == "Earth Nation");
            earthNation.Monuments.Add(earthMonument);
            break;

        case "Fire":
            Monument fireMonument = new FireMonument(name, affinity);
            var      fireNation   = nations.FirstOrDefault(n => n.Name == "Fire Nation");
            fireNation.Monuments.Add(fireMonument);
            break;

        case "Water":
            Monument waterMonument = new WaterMonument(name, affinity);
            var      waterNation   = nations.FirstOrDefault(n => n.Name == "Water Nation");
            waterNation.Monuments.Add(waterMonument);
            break;
        }
    }
Example #4
0
    public void AssignMonument(List <string> monumentArgs)
    {
        Monument monument = null;

        switch (monumentArgs[1])
        {
        case "Air":
            monument = new AirMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            break;

        case "Water":
            monument = new WaterMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            break;

        case "Fire":
            monument = new FireMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            break;

        case "Earth":
            monument = new EarthMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            break;

        default:
            break;
        }
        monuments.Add(monument);
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        string type     = monumentArgs[0];
        string name     = monumentArgs[1];
        int    affinity = int.Parse(monumentArgs[2]);

        if (type == "Air")
        {
            AirMonument airMonument = new AirMonument(name, affinity);
            monuments.Add(airMonument);
        }
        else if (type == "Water")
        {
            WaterMonument waterMonument = new WaterMonument(name, affinity);
            monuments.Add(waterMonument);
        }
        else if (type == "Fire")
        {
            FireMonument fireMonument = new FireMonument(name, affinity);
            monuments.Add(fireMonument);
        }
        else if (type == "Earth")
        {
            EarthMonument earthMonument = new EarthMonument(name, affinity);
            monuments.Add(earthMonument);
        }
    }
Example #6
0
    public void AssignMonument(List <string> monumentArgs)
    {
        var      type     = monumentArgs[0];
        var      name     = monumentArgs[1];
        var      affinity = int.Parse(monumentArgs[2]);
        Monument monument = null;

        switch (type)
        {
        case "Air":
            monument = new AirMonument(name, affinity);
            break;

        case "Earth":
            monument = new EarthMonument(name, affinity);
            break;

        case "Fire":
            monument = new FireMonument(name, affinity);
            break;

        case "Water":
            monument = new WaterMonument(name, affinity);
            break;

        default:
            throw new ArgumentException();
        }

        nations[type].monuments.Add(monument);
    }
    public Monument CreateMonument(List <string> monumentArgs)
    {
        var type     = monumentArgs[0];
        var name     = monumentArgs[1];
        var affinity = int.Parse(monumentArgs[2]);

        Monument newMonument = null;

        switch (type)
        {
        case "Air":
            newMonument = new AirMonument(name, affinity);
            break;

        case "Water":
            newMonument = new WaterMonument(name, affinity);
            break;

        case "Fire":
            newMonument = new FireMonument(name, affinity);
            break;

        case "Earth":
            newMonument = new EarthMonument(name, affinity);
            break;

        default:
            throw new NotSupportedException();
        }

        return(newMonument);
    }
Example #8
0
    public static Monument MakeMonument(string type, string name, int affinity)
    {
        Monument monument = null;

        switch (type)
        {
        case "Air":
            monument = new AirMonument(name, affinity);
            break;

        case "Water":
            monument = new WaterMonument(name, affinity);
            break;

        case "Fire":
            monument = new FireMonument(name, affinity);
            break;

        case "Earth":
            monument = new EarthMonument(name, affinity);
            break;
        }

        return(monument);
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        var monumentType = monumentArgs[1];
        var monumentName = monumentArgs[2];
        var affinity     = int.Parse(monumentArgs[3]);

        Monument currMonument = null;

        switch (monumentType)
        {
        case "Air":
            currMonument = new AirMonument(monumentName, affinity);
            airNation.Add(currMonument);
            break;

        case "Fire":
            currMonument = new FireMonument(monumentName, affinity);
            fireNation.Add(currMonument);
            break;

        case "Water":
            currMonument = new WaterMonument(monumentName, affinity);
            waterNation.Add(currMonument);
            break;

        case "Earth":
            currMonument = new EarthMonument(monumentName, affinity);
            earthNation.Add(currMonument);
            break;
        }
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        var nation   = monumentArgs[1];
        var name     = monumentArgs[2];
        var affinity = int.Parse(monumentArgs[3]);

        switch (nation)
        {
        case "Air":
            Monument airMonument = new AirMonument(name, affinity);
            monumentsOfNation[nation].Add(airMonument);
            break;

        case "Water":
            Monument waterMonument = new WaterMonument(name, affinity);
            monumentsOfNation[nation].Add(waterMonument);
            break;

        case "Fire":
            Monument fireMonument = new FireMonument(name, affinity);
            monumentsOfNation[nation].Add(fireMonument);
            break;

        case "Earth":
            Monument earthMonument = new EarthMonument(name, affinity);
            monumentsOfNation[nation].Add(earthMonument);
            break;
        }
    }
Example #11
0
    }//Done

    public void AssignMonument(List <string> monumentArgs)
    {
        var type     = monumentArgs[0];
        var name     = monumentArgs[1];
        var affinity = int.Parse(monumentArgs[2]);

        switch (type)
        {
        case "Air":
            Monument monument = new AirMonument(name, affinity);
            this.nations[type].AddMonument(monument);
            break;

        case "Water":
            monument = new WaterMonument(name, affinity);
            this.nations[type].AddMonument(monument);
            break;

        case "Fire":
            monument = new FireMonument(name, affinity);
            this.nations[type].AddMonument(monument);
            break;

        case "Earth":
            monument = new EarthMonument(name, affinity);
            this.nations[type].AddMonument(monument);
            break;
        }
    } //Done
    public void AssignMonument(List <string> monumentArgs)
    {
        var type     = monumentArgs[0];
        var name     = monumentArgs[1];;
        var affinity = int.Parse(monumentArgs[2]);

        switch (type)
        {
        case "Air":
            var airMonument = new AirMonument(name, affinity);
            this.AddMonumentToNation(type, airMonument);
            break;

        case "Earth":
            var earthMonument = new EarthMonument(name, affinity);
            this.AddMonumentToNation(type, earthMonument);
            break;

        case "Fire":
            var fireMonument = new FireMonument(name, affinity);
            this.AddMonumentToNation(type, fireMonument);
            break;

        case "Water":
            var waterMonument = new WaterMonument(name, affinity);
            this.AddMonumentToNation(type, waterMonument);
            break;
        }
    }
Example #13
0
    public void AssignMonument(List <string> monumentArgs)
    {
        var monumentType = monumentArgs[1];
        var name         = monumentArgs[2];
        var affinity     = int.Parse(monumentArgs[3]);

        switch (monumentType)
        {
        case "Air":
            var airMonument = new AirMonument(name, affinity);
            airNation.AddAirMonument(airMonument);
            break;

        case "Water":
            var waterMonument = new WaterMonument(name, affinity);
            waterNation.AddWaterMonument(waterMonument);
            break;

        case "Fire":
            var fireMonument = new FireMonument(name, affinity);
            fireNation.AddFireMonument(fireMonument);
            break;

        case "Earth":
            var eartMonument = new EarthMonument(name, affinity);
            earthNation.AddEartMonument(eartMonument);
            break;
        }
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        var typeOfMonument = monumentArgs[1];
        var monumentName   = monumentArgs[2];
        var affinity       = int.Parse(monumentArgs[3]);

        switch (typeOfMonument)
        {
        case "Air":
            Monument airMonument = new AirMonument(monumentName, affinity);
            nations[typeOfMonument].AddMonument(airMonument);
            break;

        case "Water":
            Monument waterMonument = new WaterMonument(monumentName, affinity);
            nations[typeOfMonument].AddMonument(waterMonument);
            break;

        case "Fire":
            Monument fireMonument = new FireMonument(monumentName, affinity);
            nations[typeOfMonument].AddMonument(fireMonument);
            break;

        case "Earth":
            Monument earthMonument = new EarthMonument(monumentName, affinity);
            nations[typeOfMonument].AddMonument(earthMonument);
            break;
        }
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        string type     = monumentArgs[0];
        string name     = monumentArgs[1];
        int    affinity = int.Parse(monumentArgs[2]);

        switch (type)
        {
        case "Air":
            Monument airMonument = new AirMonument(name, affinity);
            this.nations[type].AddMonument(airMonument);
            break;

        case "Water":
            Monument waterMonument = new WaterMonument(name, affinity);
            this.nations[type].AddMonument(waterMonument);
            break;

        case "Fire":
            Monument fireMonument = new FireMonument(name, affinity);
            this.nations[type].AddMonument(fireMonument);
            break;

        case "Earth":
            EarthMonument earthMonument = new EarthMonument(name, affinity);
            this.nations[type].AddMonument(earthMonument);
            break;
        }
    }
Example #16
0
    public static Monument CreateMonument(List <string> monumentArgs)
    {
        var type     = monumentArgs[1];
        var name     = monumentArgs[2];
        int affinity = int.Parse(monumentArgs[3]);

        Monument monument;

        switch (type)
        {
        case "Air":
            monument = new AirMonument(name, affinity);
            return(monument);

        case "Water":
            monument = new WaterMonument(name, affinity);
            return(monument);

        case "Fire":
            monument = new FireMonument(name, affinity);
            return(monument);

        default:
            monument = new EarthMonument(name, affinity);
            return(monument);
        }
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        string type = monumentArgs[1];

        switch (type)
        {
        case "Air":
            AirMonument airMonument = new AirMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            this.nations["Air"].Monuments.Add(airMonument);
            break;

        case "Earth":
            EarthMonument earthMonument = new EarthMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            this.nations["Earth"].Monuments.Add(earthMonument);
            break;

        case "Fire":
            FireMonument fireMonument = new FireMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            this.nations["Fire"].Monuments.Add(fireMonument);
            break;

        case "Water":
            WaterMonument waterMonument = new WaterMonument(monumentArgs[2], int.Parse(monumentArgs[3]));
            this.nations["Water"].Monuments.Add(waterMonument);
            break;
        }
    }
Example #18
0
    public static Monument CreateMonument(List <string> monumentArgs)
    {
        Monument monument = null;

        string name     = monumentArgs[2];
        int    affinity = int.Parse(monumentArgs[3]);

        switch (monumentArgs[1])
        {
        case "Air":
            monument = new AirMonument(name, affinity);
            break;

        case "Water":
            monument = new WaterMonument(name, affinity);
            break;

        case "Fire":
            monument = new FireMonument(name, affinity);
            break;

        case "Earth":
            monument = new EarthMonument(name, affinity);
            break;
        }
        return(monument);
    }
    public void AssignMonument(List <string> monumentArgs)
    {
        string type     = monumentArgs[0];
        string name     = monumentArgs[1];
        int    affinity = int.Parse(monumentArgs[2]);

        Monument monument = null;

        switch (type)
        {
        case "Air":
            monument = new AirMonument(name, affinity);
            break;

        case "Water":
            monument = new WaterMonument(name, affinity);
            break;

        case "Fire":
            monument = new FireMonument(name, affinity);
            break;

        case "Earth":
            monument = new EarthMonument(name, affinity);
            break;
        }

        monuments.Add(new KeyValuePair <string, Monument>(type, monument));
    }
Example #20
0
    private void CreateMonument(string type, string name, long affinity)
    {
        switch (type)
        {
        case "Fire":
            FireMonument fireMonument = new FireMonument(name, affinity);
            this.fireNation.FireMonuments.Add(fireMonument);
            break;

        case "Water":
            WaterMonument waterMonument = new WaterMonument(name, affinity);
            this.waterNation.WaterMonuments.Add(waterMonument);
            break;

        case "Air":
            AirMonument airMonument = new AirMonument(name, affinity);
            this.airNation.AirMonuments.Add(airMonument);
            break;

        case "Earth":
            EarthMonument earthMonument = new EarthMonument(name, affinity);
            this.earthNation.EarthMonuments.Add(earthMonument);
            break;
        }
    }
Example #21
0
 public void AssignMonument(string type, string name, int affinity)
 {
     if (type == "Air")
     {
         var airMonument = new AirMonument(name, affinity);
         airMonuments.Add(airMonument);
     }
     else if (type == "Water")
     {
         var waterMonument = new WaterMonument(name, affinity);
         waterMonuments.Add(waterMonument);
     }
     else if (type == "Fire")
     {
         var fireMonument = new FireMonument(name, affinity);
         fireMonuments.Add(fireMonument);
     }
     else if (type == "Earth")
     {
         var earthMonument = new EarthMonument(name, affinity);
         earthMonuments.Add(earthMonument);
     }
 }
Example #22
0
    public void AssignMonument(List <string> monumentArgs)
    {
        switch (monumentArgs[0])
        {
        case "Air":
            AirMonument airMonument = new AirMonument(monumentArgs[1], int.Parse(monumentArgs[2]));
            if (nations.Any(x => x.Name == "Air Nation"))
            {
                nations.Find(n => n.Name == "Air Nation").Monuments.Add(airMonument);
            }
            break;

        case "Water":
            WaterMonument waterMonument = new WaterMonument(monumentArgs[1], int.Parse(monumentArgs[2]));
            if (nations.Any(x => x.Name == "Water Nation"))
            {
                nations.Find(n => n.Name == "Water Nation").Monuments.Add(waterMonument);
            }
            break;

        case "Fire":
            FireMonument fireMonument = new FireMonument(monumentArgs[1], int.Parse(monumentArgs[2]));
            if (nations.Any(x => x.Name == "Fire Nation"))
            {
                nations.Find(n => n.Name == "Fire Nation").Monuments.Add(fireMonument);
            }
            break;

        case "Earth":
            EarthMonument earthMonument = new EarthMonument(monumentArgs[1], int.Parse(monumentArgs[2]));
            if (nations.Any(x => x.Name == "Earth Nation"))
            {
                nations.Find(n => n.Name == "Earth Nation").Monuments.Add(earthMonument);
            }
            break;
        }
    }
 public void AddAirMonument(AirMonument airMonument)
 {
     this.AirMonuments.Add(airMonument);
 }