Esempio n. 1
0
 public bool CheckTileAllowed(Point TileCoords, MapZones AllowedZones, CardCanUseOnTiles AllowedTiles)
 {
     if (AllowedZones == MapZones.RIGHT && TileCoords.Y != Tiles[0].Length - 1)
     {
         return(false);
     }
     if (AllowedZones == MapZones.LEFT && TileCoords.Y != 0)
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.ONLY_NONE && Tiles[TileCoords.X][TileCoords.Y].TileContains != MapTiles.NONE)
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.ONLY_WITH_BUILDING && Tiles[TileCoords.X][TileCoords.Y].TileContains != MapTiles.WITH_BUILDING)
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.ONLY_WITH_UNIT && Tiles[TileCoords.X][TileCoords.Y].TileContains != MapTiles.WITH_UNIT)
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.WITH_BUILDING_AND_WITH_UNIT && Tiles[TileCoords.X][TileCoords.Y].TileContains != MapTiles.WITH_UNIT_AND_BUILDING)
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.NONE_OR_WITH_UNIT && !(Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.NONE || Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.WITH_UNIT))
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.NONE_OR_WITH_BUILDING && !(Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.NONE || Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.WITH_BUILDING))
     {
         return(false);
     }
     if (AllowedTiles == CardCanUseOnTiles.WITH_BUILDING_OR_WITH_UNIT && !(Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.WITH_UNIT || Tiles[TileCoords.X][TileCoords.Y].TileContains == MapTiles.WITH_BUILDING))
     {
         return(false);
     }
     return(true);
 }
Esempio n. 2
0
        public Card(Vector2 Position, Texture2D Texture, Texture2D ArtTexture, Vector2 ArtOffset, int FrameSizeX, int FPS, int NotSelectedFrame, int DisabledFrame, Animation Selected, Animation Disappear, Animation Appear, Animation Choosed, int ClickedFrame, SpriteFont Font, Color TextColor, string CardName, string DamageInfo, string DefenseInfo, string AttackDistanceInfo, string MovePointsInfo, string HPInfo, string MoneyInfo, int CardName_OffsY, int Stats_OffsY, int FirstStat_OffsX, int MidStat_OffsX, int StatCellWidth, bool IsTargeted, MapZones AllowedZones = MapZones.ALL, CardCanUseOnTiles AllowedTiles = CardCanUseOnTiles.ONLY_NONE, float Layer = DefaultLayer) : base(Position, Texture, FrameSizeX, FPS, NotSelectedFrame, Selected, ClickedFrame, DisabledFrame, Layer)
        {
            _UpPosition             = new Vector2(base.Position.X - FrameSize.X * 0.25f, base.Position.Y - FrameSize.Y * 0.5f);
            _DownPosition           = new Vector2(base.Position.X, base.Position.Y);
            this.ArtOffset          = ArtOffset;
            this.Stats_OffsY        = Stats_OffsY;
            this.FirstStat_OffsX    = FirstStat_OffsX;
            this.MidStat_OffsX      = MidStat_OffsX;
            this.StatCellWidth      = StatCellWidth;
            this.CardName           = new BasicText(new Vector2(Position.X + (FrameSize.X - Font.MeasureString(CardName).X) / 2, Position.Y + CardName_OffsY), CardName, Font, TextColor, Layer - 0.0001f);
            this.CardName_OffsY     = CardName_OffsY;
            this.DamageInfo         = new BasicText(new Vector2(Position.X + FirstStat_OffsX + (StatCellWidth - Font.MeasureString(DamageInfo).X) / 2, Position.Y + Stats_OffsY), DamageInfo, Font, TextColor, Layer - 0.0001f);
            this.DefenseInfo        = new BasicText(new Vector2(Position.X + FirstStat_OffsX + StatCellWidth + (StatCellWidth - Font.MeasureString(DefenseInfo).X) / 2, Position.Y + Stats_OffsY), DefenseInfo, Font, TextColor, Layer - 0.0001f);
            this.AttackDistanceInfo = new BasicText(new Vector2(Position.X + FirstStat_OffsX + MidStat_OffsX + StatCellWidth * 2 + (StatCellWidth - Font.MeasureString(AttackDistanceInfo).X) / 2, Position.Y + Stats_OffsY), AttackDistanceInfo, Font, TextColor, Layer - 0.0001f);
            this.MovePointsInfo     = new BasicText(new Vector2(Position.X + FirstStat_OffsX + MidStat_OffsX * 2 + StatCellWidth * 3 + (StatCellWidth - Font.MeasureString(MovePointsInfo).X) / 2, Position.Y + Stats_OffsY), MovePointsInfo, Font, TextColor, Layer - 0.0001f);
            this.HPInfo             = new BasicText(new Vector2(Position.X + FirstStat_OffsX + MidStat_OffsX * 2 + StatCellWidth * 4 + (StatCellWidth - Font.MeasureString(HPInfo).X) / 2, Position.Y + Stats_OffsY), HPInfo, Font, TextColor, Layer - 0.0001f);

            this.MoneyInfo = new BasicText(new Vector2(Position.X + FirstStat_OffsX + MidStat_OffsX * 2 + StatCellWidth * 4 + 1 + (StatCellWidth - Font.MeasureString(MoneyInfo).X) / 2, Position.Y + 1 + (StatCellWidth - Font.MeasureString(MoneyInfo).Y) / 2), MoneyInfo, Font, Color.Khaki, Layer - 0.0001f);

            Art = new BasicSprite(Position + ArtOffset, ArtTexture, Layer + 0.0005f);
            AddAnimation("Disappear", Disappear);
            AddAnimation("Appear", Appear);
            AddAnimation("Choosed", Choosed);
            LastLayer       = Layer;
            IsDown          = true;
            IsPressed       = false;
            LockClicking    = false;
            IsMoving        = false;
            this.IsTargeted = IsTargeted;
            MoveSpeed       = 0;
            UpdBtnAnims     = false;

            this.AllowedTiles = AllowedTiles;
            this.AllowedZones = AllowedZones;
        }
Esempio n. 3
0
        public Point[] GetTilesByAllowedZones(MapZones AllowedZones, CardCanUseOnTiles AllowedTiles)
        {
            var TileList = new List <Point>();

            if (AllowedZones == MapZones.ALL)
            {
                switch (AllowedTiles)
                {
                case CardCanUseOnTiles.ONLY_NONE:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.NONE)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.WITH_BUILDING)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.WITH_UNIT)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_AND_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.WITH_UNIT_AND_BUILDING)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.NONE || Tiles[i][j].TileContains == MapTiles.WITH_BUILDING)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.NONE || Tiles[i][j].TileContains == MapTiles.WITH_UNIT)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        for (var j = 0; j < Tiles[0].Length; j++)
                        {
                            if (Tiles[i][j] != null)
                            {
                                if (Tiles[i][j].TileContains == MapTiles.WITH_BUILDING || Tiles[i][j].TileContains == MapTiles.WITH_UNIT)
                                {
                                    TileList.Add(new Point(i, j));
                                }
                            }
                        }
                    }
                    break;
                }
            }
            else
            if (AllowedZones == MapZones.LEFT)
            {
                switch (AllowedTiles)
                {
                case CardCanUseOnTiles.ONLY_NONE:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.NONE)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.WITH_BUILDING)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_AND_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.WITH_UNIT_AND_BUILDING)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.NONE || Tiles[i][0].TileContains == MapTiles.WITH_BUILDING)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.NONE || Tiles[i][0].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][0].TileContains == MapTiles.WITH_BUILDING || Tiles[i][0].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, 0));
                        }
                    }
                    break;
                }
            }
            else
            {
                switch (AllowedTiles)
                {
                case CardCanUseOnTiles.ONLY_NONE:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.NONE)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.WITH_BUILDING)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.ONLY_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_AND_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.WITH_UNIT_AND_BUILDING)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_BUILDING:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.NONE || Tiles[Tiles[0].Length - 1][i].TileContains == MapTiles.WITH_BUILDING)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.NONE_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.NONE || Tiles[Tiles[0].Length - 1][i].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;

                case CardCanUseOnTiles.WITH_BUILDING_OR_WITH_UNIT:
                    for (var i = 0; i < Tiles.Length; i++)
                    {
                        if (Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.WITH_BUILDING || Tiles[i][Tiles[0].Length - 1].TileContains == MapTiles.WITH_UNIT)
                        {
                            TileList.Add(new Point(i, Tiles[0].Length - 1));
                        }
                    }
                    break;
                }
            }
            if (ChangedAnimTiles.Count > 0)
            {
                SetDefault();
            }
            ChangedAnimTiles = new List <Point>(TileList);
            return(TileList.ToArray());
        }