예제 #1
0
        public Character ReadClass(int archetype, string wrmc)
        {
            int choice;
            Character player;

            MyTTY.Show("The following " + wrmc + " are available to you:\n\n");

            switch (archetype)
            {
                case 1:
                    MyTTY.Show("1) Knight\n");
                    MyTTY.Show("2) Berserker\n");
                    break;

                case 2:
                    MyTTY.Show("1) Hunter\n");
                    MyTTY.Show("2) Assassin\n");
                    break;

                case 3:
                    MyTTY.Show("1) Sorcerer\n");
                    MyTTY.Show("2) Warlock\n");
                    break;

                case 4:
                    MyTTY.Show("1) Priest\n");
                    MyTTY.Show("2) Druid\n");
                    break;
            }

            choice = MyTTY.ReadIntLimit("\nEnter the number of your selection: ", 2);

            switch (archetype)
            {
                case 1:
                    if (choice < 2) player = new Knight(); else player = new Berserker();
                    break;
                case 2:
                    if (choice < 2) player = new Hunter(); else player = new Assassin();
                    break;
                case 3:
                    if (choice < 2) player = new Sorcerer(); else player = new Warlock();
                    break;
                case 4:
                    if (choice < 2) player = new Priest(); else player = new Druid();
                    break;
                default:
                    player = null;
            }

            return player;
        }
 private void AddWarlockLoss(HSCounter hsc)
 {
     Warlock warlock = new Warlock();
     warlock.LoseButton_Clicked(hsc);
 }
 private void AddWarlockWin(HSCounter hsc)
 {
     Warlock warlock = new Warlock();
     warlock.WinButton_Clicked(hsc);
 }
예제 #4
0
        public void GameStart(GameModel game, PlayerModel firstPlayer, PlayerModel secondPlayer, List <UserCardGroupDetailModel> firstCardGroup, List <UserCardGroupDetailModel> secondCardGroup, string firstUserProfession, string secondUserProfession)
        {
            #region 加载玩家卡组
            UserContext firstUser = new UserContext
            {
                UserCode     = firstPlayer.UserCode,
                Player       = firstPlayer,
                IsActivation = true,
                IsFirst      = true,
                AllCards     = new List <Card>()
            };
            List <Card> lstCardLib = _gameCache.GetAllCard();

            int cardInGameIndex = 0;
            foreach (var cg in firstCardGroup)
            {
                Card libCard = lstCardLib.First(c => c.CardCode == cg.CardCode);
                var  card    = Activator.CreateInstance(libCard.GetType()) as Card;
                card.CardInGameCode    = cardInGameIndex.ToString();
                card.IsFirstPlayerCard = true;
                firstUser.AllCards.Add(card);
                cardInGameIndex++;
            }

            UserContext secondUser = new UserContext
            {
                UserCode     = secondPlayer.UserCode,
                Player       = secondPlayer,
                IsActivation = true,
                IsFirst      = false,
                AllCards     = new List <Card>()
            };
            secondCardGroup.ForEach(delegate(UserCardGroupDetailModel detail)
            {
                Card libCard           = lstCardLib.First(c => c.CardCode == detail.CardCode);
                var card               = Activator.CreateInstance(libCard.GetType()) as Card;
                card.CardInGameCode    = cardInGameIndex.ToString();
                card.IsFirstPlayerCard = false;
                secondUser.AllCards.Add(card);
                cardInGameIndex++;
            });

            //secondUser.StockCards = secondUser.AllCards;


            GameContext = new GameContext
            {
                Players         = new List <UserContext>(),
                DeskCards       = null,
                GameCode        = game.GameCode,
                CurrentTurnCode = game.CurrentTurnCode,
                NextTurnCode    = game.NextTurnCode,
                GameStatus      = GameStatus.进行中,
                GameCache       = _gameCache
            };
            GameContext.Players.Add(firstUser);
            GameContext.Players.Add(secondUser);
            #endregion

            #region 初始化开场选牌
            int        firstPickUpCount = 4;
            List <int> lstRndIndex      = RandomUtil.CreateRandomInt(0, GameContext.Players.First(c => c.IsFirst).AllCards.Count - 1, firstPickUpCount);
            for (int i = 0; i < lstRndIndex.Count; i++)
            {
                if (i < lstRndIndex.Count - 1)
                {
                    //lstFirstPickUpCard.Add(GameContext.Players.First(c => c.IsFirst).AllCards[lstRndIndex[i]]);
                    GameContext.Players.First(c => c.IsFirst).AllCards[lstRndIndex[i]].CardLocation = CardLocation.InitCard;
                }
                //lstSecondPickUpCard.Add(GameContext.Players.First(c => c.IsFirst == false).AllCards[lstRndIndex[i]]);
                GameContext.Players.First(c => c.IsFirst == false).AllCards[lstRndIndex[i]].CardLocation = CardLocation.InitCard;
            }

            BaseHero firstHero = null, secondHero = null;
            switch (firstUserProfession)
            {
            case "Druid": firstHero = new Druid(); break;

            case "Hunter": firstHero = new Hunter(); break;

            case "Mage": firstHero = new Mage(); break;

            case "Paladin": firstHero = new Paladin(); break;

            case "Priest": firstHero = new Priest(); break;

            case "Rogue": firstHero = new Rogue(); break;

            case "Shaman": firstHero = new Shaman(); break;

            case "Warlock": firstHero = new Warlock(); break;

            case "Warrior": firstHero = new Warrior(); break;
            }
            switch (secondUserProfession)
            {
            case "Druid": secondHero = new Druid(); break;

            case "Hunter": secondHero = new Hunter(); break;

            case "Mage": secondHero = new Mage(); break;

            case "Paladin": secondHero = new Paladin(); break;

            case "Priest": secondHero = new Priest(); break;

            case "Rogue": secondHero = new Rogue(); break;

            case "Shaman": secondHero = new Shaman(); break;

            case "Warlock": secondHero = new Warlock(); break;

            case "Warrior": secondHero = new Warrior(); break;
            }

            cardInGameIndex++;
            firstHero.CardLocation      = CardLocation.场上;
            firstHero.CardInGameCode    = cardInGameIndex.ToString();
            firstHero.DeskIndex         = 0;
            firstHero.IsFirstPlayerCard = true;
            firstUser.AllCards.Add(firstHero);

            cardInGameIndex++;
            secondHero.CardLocation      = CardLocation.场上;
            secondHero.CardInGameCode    = cardInGameIndex.ToString();
            secondHero.DeskIndex         = 8;
            secondHero.IsFirstPlayerCard = false;
            secondUser.AllCards.Add(secondHero);

            GameContext.DeskCards = new DeskBoard()
            {
                firstHero, null, null, null, null, null, null, null, secondHero, null, null, null, null, null, null, null
            };
            #endregion

            GameContext.Settlement();
            _gameCache.SetContext(GameContext);
        }
예제 #5
0
        public IActionResult Warlock(AddWarlockViewModel model)
        {
            if (ModelState.IsValid)
            {
                Warlock newSolo = new Warlock();


                newSolo.Name           = model.Name;
                newSolo.ARM            = model.ARM;
                newSolo.CMD            = model.CMD;
                newSolo.DEF            = model.DEF;
                newSolo.MAT            = model.MAT;
                newSolo.PointCost      = model.PointCost;
                newSolo.RAT            = model.RAT;
                newSolo.SPD            = model.SPD;
                newSolo.STR            = model.STR;
                newSolo.WarbeastPoints = model.WarbeastPoints;
                newSolo.factionName    = model.Faction;


                context.Warlocks.Add(newSolo);
                context.SaveChanges();

                if (model.abilIDS != null)
                {
                    foreach (var abil in model.abilIDS)
                    {
                        WarlockAbillity NewSoloAbility = new WarlockAbillity();
                        NewSoloAbility.AbillityId = abil;
                        NewSoloAbility.WarlockId  = newSolo.ID;
                        context.WarlockAbillities.Add(NewSoloAbility);
                        context.SaveChanges();
                    }
                }


                if (model.weapIDS != null)
                {
                    foreach (var weap in model.weapIDS)
                    {
                        WarlockWeapon NewSoloWeapon = new WarlockWeapon();
                        NewSoloWeapon.WeaponId  = weap;
                        NewSoloWeapon.WarlockId = newSolo.ID;
                        context.WarlockWeapons.Add(NewSoloWeapon);
                        context.SaveChanges();
                    }
                }

                if (model.spellIDS != null)
                {
                    foreach (var spell in model.spellIDS)
                    {
                        WarlockSpell NewSoloSpell = new WarlockSpell();
                        NewSoloSpell.SpellId   = spell;
                        NewSoloSpell.WarlockId = newSolo.ID;
                        context.WarlockSpells.Add(NewSoloSpell);
                        context.SaveChanges();
                    }
                }



                return(Redirect("/"));
            }

            return(View("Warcaster", model));
        }
예제 #6
0
        internal static void DoRotation()
        {
            if (DetectKeyPress.GetKeyState(DetectKeyPress.Shift) < 0)
            {
                return;
            }
            if (DetectKeyPress.GetKeyState(DetectKeyPress.Z) < 0)
            {
                Rotation.ChangeRotation();
            }
            if (ObjectManager.LocalPlayer.IsMounted)
            {
                return;
            }



            switch (ObjectManager.LocalPlayer.Class)
            {
            case WowUnit.WowUnitClass.Paladin:
                //Paladin.DoPaladin();
                break;

            case WowUnit.WowUnitClass.Warrior:
                Warrior.DoWarrior();
                break;

            case WowUnit.WowUnitClass.Hunter:
                Hunter.DoHunter();
                break;

            case WowUnit.WowUnitClass.Druid:
                Druid.DoDruid();
                break;

            case WowUnit.WowUnitClass.Shaman:
                Shaman.DoShaman();
                break;

            case WowUnit.WowUnitClass.Rogue:
                Rogue.DoRogue();
                break;

            case WowUnit.WowUnitClass.Priest:
                Priest.DoPriest();
                break;

            case WowUnit.WowUnitClass.DeathKnight:
                DeathKnight.DoDeathKnight();
                break;

            case WowUnit.WowUnitClass.Mage:
                Mage.DoMage();
                break;

            case WowUnit.WowUnitClass.Warlock:
                Warlock.DoWarlock();
                break;

            case WowUnit.WowUnitClass.Monk:
                Monk.DoMonk();
                break;
            }
        }
        //for Sorceror only ^^
        public AllSpells(Character character)
        {
            Lvl = character.Lvl;
            string classStr  = character.ChosenClass;
            string archetype = character.Archetype;

            if (classStr == "Artificer" || classStr == "Fighter" || classStr == "Rogue" || classStr == "Wizard")
            {
                Stat = "Int";
            }
            else if (classStr == "Cleric" || classStr == "Druid" || classStr == "Ranger")
            {
                Stat = "Wis";
            }
            else if (classStr == "Bard" || classStr == "Paladin" || classStr == "Sorcerer" || classStr == "Swordmage" || classStr == "Warlock")
            {
                Stat = "Cha";
            }
            if (classStr == "Psion")
            {
                switch (archetype)
                {
                case "Clairsentience(Seer)":
                    Stat = "Wis";
                    break;

                case "Metacreativity(Shaper)":
                    Stat = "Int";
                    break;

                case "Psychokinesis(Savant)":
                    Stat = "Str";
                    break;

                case "Psychometabolism(Egoist)":
                    Stat = "Con";
                    break;

                case "Psychoportation(Nomad)":
                    Stat = "Dex";
                    break;

                case "Telepathy(Telepath)":
                    Stat = "Cha";
                    break;
                }
            }
            switch (classStr)
            {
            case "Artificer":
                Artificer.Add(0, ArtificerSpells.Cantrips);
                Artificer.Add(1, ArtificerSpells.FirstLvls);
                Artificer.Add(2, ArtificerSpells.SecondLvls);
                Artificer.Add(3, ArtificerSpells.ThirdLvls);
                Artificer.Add(4, ArtificerSpells.FourthLvls);
                Artificer.Add(5, ArtificerSpells.FifthLvls);
                break;

            case "Bard":
                Bard.Add(0, BardSpells.Cantrips);
                Bard.Add(1, BardSpells.FirstLvls);
                Bard.Add(2, BardSpells.SecondLvls);
                Bard.Add(3, BardSpells.ThirdLvls);
                Bard.Add(4, BardSpells.FourthLvls);
                Bard.Add(5, BardSpells.FifthLvls);
                Bard.Add(6, BardSpells.SixthLvls);
                Bard.Add(7, BardSpells.SeventhLvls);
                Bard.Add(8, BardSpells.EigthLvls);
                Bard.Add(9, BardSpells.NinthLvls);
                break;

            case "Cleric":
                Cleric.Add(0, ClericSpells.Cantrips);
                Cleric.Add(1, ClericSpells.FirstLvls);
                Cleric.Add(2, ClericSpells.SecondLvls);
                Cleric.Add(3, ClericSpells.ThirdLvls);
                Cleric.Add(4, ClericSpells.FourthLvls);
                Cleric.Add(5, ClericSpells.FifthLvls);
                Cleric.Add(6, ClericSpells.SixthLvls);
                Cleric.Add(7, ClericSpells.SeventhLvls);
                Cleric.Add(8, ClericSpells.EigthLvls);
                Cleric.Add(9, ClericSpells.NinthLvls);
                break;

            case "Druid":
                Druid.Add(0, DruidSpells.Cantrips);
                Druid.Add(1, DruidSpells.FirstLvls);
                Druid.Add(2, DruidSpells.SecondLvls);
                Druid.Add(3, DruidSpells.ThirdLvls);
                Druid.Add(4, DruidSpells.FourthLvls);
                Druid.Add(5, DruidSpells.FifthLvls);
                Druid.Add(6, DruidSpells.SixthLvls);
                Druid.Add(7, DruidSpells.SeventhLvls);
                Druid.Add(8, DruidSpells.EigthLvls);
                Druid.Add(9, DruidSpells.NinthLvls);
                break;

            case "Fighter":
                Fighter.Add(0, FighterSpells.Cantrips);
                Fighter.Add(1, FighterSpells.FirstLvls);
                Fighter.Add(2, FighterSpells.SecondLvls);
                Fighter.Add(3, FighterSpells.ThirdLvls);
                Fighter.Add(4, FighterSpells.FourthLvls);
                Wizard.Add(0, WizardSpells.Cantrips);
                Wizard.Add(1, WizardSpells.FirstLvls);
                Wizard.Add(2, WizardSpells.SecondLvls);
                Wizard.Add(3, WizardSpells.ThirdLvls);
                Wizard.Add(4, WizardSpells.FourthLvls);
                break;

            case "Paladin":
                Paladin.Add(1, PaladinSpells.FirstLvls);
                Paladin.Add(2, PaladinSpells.SecondLvls);
                Paladin.Add(3, PaladinSpells.ThirdLvls);
                Paladin.Add(4, PaladinSpells.FourthLvls);
                Paladin.Add(5, PaladinSpells.FifthLvls);
                break;

            case "Ranger":
                Ranger.Add(1, RangerSpells.FirstLvls);
                Ranger.Add(2, RangerSpells.SecondLvls);
                Ranger.Add(3, RangerSpells.ThirdLvls);
                Ranger.Add(4, RangerSpells.FourthLvls);
                Ranger.Add(5, RangerSpells.FifthLvls);
                break;

            case "Rogue":
                Rogue.Add(0, RogueSpells.Cantrips);
                Rogue.Add(1, RogueSpells.FirstLvls);
                Rogue.Add(2, RogueSpells.SecondLvls);
                Rogue.Add(3, RogueSpells.ThirdLvls);
                Rogue.Add(4, RogueSpells.FourthLvls);
                Wizard.Add(0, WizardSpells.Cantrips);
                Wizard.Add(1, WizardSpells.FirstLvls);
                Wizard.Add(2, WizardSpells.SecondLvls);
                Wizard.Add(3, WizardSpells.ThirdLvls);
                Wizard.Add(4, WizardSpells.FourthLvls);
                break;

            case "Psion":
                Psion.Add(0, PsionSpells.Cantrips);
                Psion.Add(1, PsionSpells.FirstLvls);
                Psion.Add(2, PsionSpells.SecondLvls);
                Psion.Add(3, PsionSpells.ThirdLvls);
                Psion.Add(4, PsionSpells.FourthLvls);
                Psion.Add(5, PsionSpells.FifthLvls);
                Psion.Add(6, PsionSpells.SixthLvls);
                Psion.Add(7, PsionSpells.SeventhLvls);
                Psion.Add(8, PsionSpells.EigthLvls);
                Psion.Add(9, PsionSpells.NinthLvls);
                break;

            case "Swordmage":
                Swordmage.Add(0, SwordmageSpells.Cantrips);
                Swordmage.Add(1, SwordmageSpells.FirstLvls);
                Swordmage.Add(2, SwordmageSpells.SecondLvls);
                Swordmage.Add(3, SwordmageSpells.ThirdLvls);
                Swordmage.Add(4, SwordmageSpells.FourthLvls);
                Swordmage.Add(5, SwordmageSpells.FifthLvls);
                break;

            case "Warlock":
                Warlock.Add(0, WarlockSpells.Cantrips);
                Warlock.Add(1, WarlockSpells.FirstLvls);
                Warlock.Add(2, WarlockSpells.SecondLvls);
                Warlock.Add(3, WarlockSpells.ThirdLvls);
                Warlock.Add(4, WarlockSpells.FourthLvls);
                Warlock.Add(5, WarlockSpells.FifthLvls);
                Warlock.Add(6, WarlockSpells.SixthLvls);
                Warlock.Add(7, WarlockSpells.SeventhLvls);
                Warlock.Add(8, WarlockSpells.EigthLvls);
                Warlock.Add(9, WarlockSpells.NinthLvls);
                break;

            case "Wizard":
                Wizard.Add(0, WizardSpells.Cantrips);
                Wizard.Add(1, WizardSpells.FirstLvls);
                Wizard.Add(2, WizardSpells.SecondLvls);
                Wizard.Add(3, WizardSpells.ThirdLvls);
                Wizard.Add(4, WizardSpells.FourthLvls);
                Wizard.Add(5, WizardSpells.FifthLvls);
                Wizard.Add(6, WizardSpells.SixthLvls);
                Wizard.Add(7, WizardSpells.SeventhLvls);
                Wizard.Add(8, WizardSpells.EigthLvls);
                Wizard.Add(9, WizardSpells.NinthLvls);
                break;
            }
        }