Esempio n. 1
0
        /// Une seul case
        ///                 [x]
        ///
        public static List <ZoneEffectTemplate> affected(object[] parameters)
        {
            Battle battle   = (Battle)parameters[0];
            Point  spellPos = (Point)parameters[1];

            //mysql.spells spell_template = parameters[2] as mysql.spells;
            #region spellCaster not used
            //PlayerInfo spellCaster = parameters[3] as PlayerInfo;
            #endregion

            List <ZoneEffectTemplate> l = new List <ZoneEffectTemplate>();
            Actor actor = battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X && f.map_position.Y == spellPos.Y);

            if (actor == null)
            {
                return(l);
            }
            ZoneEffectTemplate t = new ZoneEffectTemplate
            {
                AffectedActor = actor,
                Pertinance    = 100
            };
            // pertinance toujours 100% puisque le sort se lance sur une seul case qui est la case centrale

            l.Add(t);
            return(l);
        }
Esempio n. 2
0
        public static List <Effects.ZoneEffect.ZoneEffectTemplate> affected(object[] parameters)
        {
            /// Glyphe / losange  / rhombus
            ///                 [ ]
            ///              [ ][ ][ ]
            ///           [ ][ ][ ][ ][ ]
            ///        [ ][ ][ ][x][ ][ ][ ]
            ///           [ ][ ][ ][ ][ ]
            ///              [ ][ ][ ]
            ///                 [ ]
            ///
            Battle _battle  = parameters[0] as Battle;
            Point  spellPos = parameters[1] as Point;

            mysql.spells spell_template = parameters[2] as mysql.spells;
            Actor        spellCaster    = parameters[3] as Actor;

            // liste qui contiens tous les joueurs dans la zone d'effet
            List <ZoneEffectTemplate> l = new List <ZoneEffectTemplate>();

            // joueur dans la case centrale
            Actor pi = _battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X && f.map_position.Y == spellPos.Y);

            if (pi != null)
            {
                ZoneEffectTemplate centralT = new ZoneEffectTemplate();
                centralT.AffectedActor = pi;
                centralT.Pertinance    = 100;
                l.Add(centralT);

                // algo pour trouver tout les adversaire dans la glyph
                for (int vertical = 0; vertical < spell_template.sizeEffect; vertical++)
                {
                    for (int horizontal = 0; horizontal < spell_template.sizeEffect; horizontal++)
                    {
                        if (vertical == 0 && horizontal == 0)
                        {
                            continue;
                        }

                        // tuile à droite du centre
                        Actor rightPlayer = _battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X + horizontal && f.map_position.Y == spellPos.Y + vertical);
                        Effects.ZoneEffect.ZoneEffectTemplate rightT = new ZoneEffectTemplate();
                        rightT.AffectedActor = rightPlayer;
                        rightT.Pertinance    = 100 - ((vertical * 10) / 100) - ((horizontal * 10) / 100);
                        l.Add(rightT);

                        // tuile à gauche du centre
                        Actor leftPlayer = _battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X - horizontal && f.map_position.Y == spellPos.Y - vertical);
                        Effects.ZoneEffect.ZoneEffectTemplate leftT = new ZoneEffectTemplate();
                        leftT.AffectedActor = leftPlayer;
                        leftT.Pertinance    = 100 - ((vertical * 10) / 100) - ((horizontal * 10) / 100);
                        l.Add(leftT);
                    }
                }
            }

            return(l);
        }
Esempio n. 3
0
        // Not extentable
        ///                    [ ]                       [ ][ ][ ]                  [ ]
        ///                 [x][ ]          or              [x]             or      [ ][x]          or          [x]
        ///                    [ ]                                                  [ ]                      [ ][ ][ ]
        ///

        public static List <ZoneEffectTemplate> affected(object[] parameters)
        {
            Battle battle   = (Battle)parameters[0];
            Point  spellPos = (Point)parameters[1];
            //mysql.spells spell_template = parameters[2] as mysql.spells;
            Actor actor = (Actor)parameters[3];

            // liste des joueurs affecté par l'effet
            List <ZoneEffectTemplate> l = new List <ZoneEffectTemplate>();

            Actor middleTile = battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X && f.map_position.Y == spellPos.Y);

            if (middleTile != null)
            {
                ZoneEffectTemplate t = new ZoneEffectTemplate
                {
                    AffectedActor = middleTile,
                    Pertinance    = 100
                };

                l.Add(t);
            }

            // determination de l'orientation pour extraire les positions
            if (actor.map_position.X == spellPos.X)
            {
                // vers le bas
                Actor leftTile = battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X - 1 && f.map_position.Y == spellPos.Y);

                if (leftTile != null)
                {
                    ZoneEffectTemplate t = new ZoneEffectTemplate
                    {
                        AffectedActor = leftTile,
                        Pertinance    = 90
                    };
                    // pertinance toujours 100% puisque le sort se lance sur une seul case qui est la case centrale

                    l.Add(t);
                }

                // case à droite
                Actor rightTile = battle.AllPlayersByOrder.Find(f => f.map_position.X + 1 == spellPos.X && f.map_position.Y == spellPos.Y);

                if (rightTile == null)
                {
                    return(l);
                }
                {
                    ZoneEffectTemplate t = new ZoneEffectTemplate
                    {
                        AffectedActor = rightTile,
                        Pertinance    = 90
                    };
                    // pertinance toujours 100% puisque le sort se lance sur une seul case qui est la case centrale

                    l.Add(t);
                }
            }
            else
            {
                // vers l'adroite ou la gauche
                Actor upTile = battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X && f.map_position.Y == spellPos.Y - 1);

                if (upTile != null)
                {
                    ZoneEffectTemplate t = new ZoneEffectTemplate
                    {
                        AffectedActor = upTile,
                        Pertinance    = 90
                    };
                    // pertinance toujours 100% puisque le sort se lance sur une seul case qui est la case centrale

                    l.Add(t);
                }

                // case à droite
                Actor downTile = battle.AllPlayersByOrder.Find(f => f.map_position.X == spellPos.X && f.map_position.Y == spellPos.Y + 1);

                if (downTile == null)
                {
                    return(l);
                }
                {
                    ZoneEffectTemplate t = new ZoneEffectTemplate
                    {
                        AffectedActor = downTile,
                        Pertinance    = 90
                    };
                    // pertinance toujours 100% puisque le sort se lance sur une seul case qui est la case centrale

                    l.Add(t);
                }
            }

            return(l);
        }