Ejemplo n.º 1
0
        /// <summary>
        /// Creates a new, unique clone of the spell.
        /// Uses the effect metadata to create new instances of
        ///  effects too.
        /// </summary>
        /// <param name="owner"></param>
        /// <returns></returns>
        public Spell CreateInstance(Player owner)
        {
            var spell = new Spell
            {
                ID = ID,
                TargetType = TargetType,
                TargetGroup = TargetGroup,
                UID = SID.New()
            };

            foreach (var effect in EffectData)
            {
                // Need to create a new instance of effect for every spell!
                spell.Effects.Add(Game.SpellEffects.CreateInstance(effect.Name, effect.Attributes));
            }

            return spell;
        }
Ejemplo n.º 2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Card Game Server Initialising..");
            Console.WriteLine("Protocol Version: " + GameActionWriter.PROTOCOL_VERSION);
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Loading Data..");
            Console.ForegroundColor = ConsoleColor.Yellow;

            // Load in all the game data (xml)
            Game.Load();

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Starting Server..");
            Console.ForegroundColor = ConsoleColor.White;

            var p = new Player();
            var test = Game.Spells["frostbolt"].CreateInstance(p);
            var test2 = Game.Spells["deepfreeze"].CreateInstance(p);
            Console.WriteLine(test.GetDescription());
            Console.WriteLine(test2.GetDescription());

            // Start the listen server and wait for connections!
            Server.Start();
        }
Ejemplo n.º 3
0
        // Use a template model ?
        //  -> Load creature data externally
        //  -> Create an instance of this creature class for each creature in database
        //  -> Set appropriate attributes and add effects (based on data)
        //  -> Create deep clone using this function when we want to make a usable copy
        public Creature CreateInstance(Player owner, bool commander, int team)
        {
            var newCreature = new Creature
            {
                ID = ID,
                Description = Description,
                Name = Name,
                BaseHealth = BaseHealth,
                Damage = Damage,
                Team = team,
                Commander = commander,
                SleepSickness = SleepSickness,
                CanAttack = CanAttack,
                Taunt = Taunt,
                MagicImmune = MagicImmune,
                PhysicalImmune = PhysicalImmune,
                Stealth = Stealth,
                AttackDamageType = AttackDamageType,
                Owner = owner,
                Image = Image,
                UID = SID.New()
            };

            foreach (var effect in EffectData)
            {
                // Need to create a new instance of effect for every creature!
                newCreature.Effects.Add(Game.CreatureEffects.CreateInstance(effect.Name, effect.Attributes));
            }

            return newCreature;
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Generates a list of targets from the spell and player data, 
 ///  then casts the spell on them.
 /// </summary>
 /// <param name="player">Player who is casting spell</param>
 /// <param name="spell">Spell to cast</param>
 /// <param name="pickedTarget">The creature/commander to target with spell, if needed.</param>
 /// <returns>True if spell cast started (even if spell was blocked), false if invalid target given.</returns>
 public bool Cast(Player player, Spell spell, Creature pickedTarget = null)
 {
     var targets = GetPossibleTargets(player, spell);
     switch (spell.TargetType)
     {
         case TargetType.Random:
             Cast(spell, new List<Creature> { targets[ServerRandom.Generator.Next(targets.Count)] });
             return true;
         case TargetType.Single:
             if (targets.Contains(pickedTarget))
             {
                 Cast(spell, new List<Creature> { pickedTarget });
                 return true;
             }
             return false;
         case TargetType.None:
             Cast(spell, targets);
             return true;
         default:
             throw new ArgumentOutOfRangeException();
     }
 }
Ejemplo n.º 5
0
 protected virtual void OnTurnStart(Board arg1, Player arg2)
 {
     var handler = TurnStart;
     handler?.Invoke(arg1, arg2);
 }
Ejemplo n.º 6
0
 // TODO: Finish the actual game logic!
 public void Summon(Player owner, Creature creature)
 {
     Console.WriteLine("SUMMONING: " + creature.Name);
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Handles a GameAction command sent by a player.
        /// </summary>
        /// <param name="player">The player that sent the command</param>
        /// <param name="action">What type of action it is</param>
        /// <param name="data">The data, such as who to target or the player's name</param>
        public void RecieveCommand(Player player, GameDataAction dataAction)
        {
            // TODO: Finish the command recieved events
            var data = dataAction.Data;
            var action = dataAction.Action;
            if (player == ActivePlayer)
            {
                switch (action)
                {
                    case GameAction.TurnEnd:
                        EndTurn(null);
                        break;
                    case GameAction.PlayCard:
                        Card card;
                        // Attempt to get the card matching the UID
                        if (player.Cards.TryGetValue(data["uid"], out card))
                        {
                            GameData targetID;
                            if (data.TryGetValue("target", out targetID))
                            {

                            }
                            card.Play();
                        }
                        break;
                    case GameAction.GameStart:
                        break;
                    case GameAction.TurnStart:
                        break;
                    case GameAction.DrawCard:
                        break;
                    case GameAction.SetMana:
                        break;
                    case GameAction.SetHealth:
                        break;
                    case GameAction.Attack:
                        break;
                    case GameAction.Trigger:
                        break;
                    case GameAction.Kill:
                        break;
                    case GameAction.MinionSummoned:
                        break;
                    case GameAction.SpellCast:
                        break;
                    case GameAction.GameOver:
                        break;
                    case GameAction.Meta:
                        break;
                    case GameAction.Ping:
                        break;
                    default:
                        throw new ArgumentOutOfRangeException(nameof(action), action, null);
                }
            }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Builds up a list of possible targets for the given spell and player.
        /// </summary>
        /// <param name="owner">Owner of the spell</param>
        /// <param name="spell">Spell in question</param>
        /// <returns></returns>
        public List<Creature> GetPossibleTargets(Player owner, Spell spell)
        {
            var creatures = new List<Creature>();
            if (spell.TargetGroup.IsFlagSet(TargetGroup.None))
            {
                return creatures;
            }
            if (spell.TargetGroup.IsFlagSet(TargetGroup.Champions))
            {
                if (spell.TargetGroup.IsFlagSet(TargetGroup.Allies))
                {
                    creatures.Add(owner.Commander);
                }
                if (spell.TargetGroup.IsFlagSet(TargetGroup.Enemies))
                {
                    creatures.AddRange(from p in Players where p != owner select p.Commander);
                }
            }

            if (!spell.TargetGroup.IsFlagSet(TargetGroup.Minions)) return creatures;

            if (spell.TargetGroup.IsFlagSet(TargetGroup.Allies))
            {
                creatures.AddRange(owner.Creatures.Where(c => !c.Commander));
            }
            if (spell.TargetGroup.IsFlagSet(TargetGroup.Enemies))
            {
                creatures.AddRange(from p in Players from c in p.Creatures where !c.Commander select c);
            }
            return creatures;
        }
Ejemplo n.º 9
0
        private void DrawCard(Player activePlayer)
        {
            var drawnCard = activePlayer.Deck.Pop();
            activePlayer.Cards.Add(drawnCard.UID, drawnCard);

            drawnCard.Effects.ForEach(x => x.Start(drawnCard));

            // Show the player what card they have drawn
            activePlayer.DataWriter.SendAction(GameAction.DrawCard, new Dictionary<string, GameData>()
            {
                // TODO: Send modifiers
                {"player", ActivePlayerID}, {"card", drawnCard.ID}, {"uid", drawnCard.UID.ToString()}
            });

            // Tell the other players that a card has been drawn
            SendToInactivePlayers(GameAction.DrawCard, new Dictionary<string, GameData>
            {
                {"player", ActivePlayerID}, {"card", "-1"}
            });
        }