예제 #1
0
        public override void AddMapTile(MapTile t)
        {
            Vector2 position = new Vector2(0, 0);

            //IrrlichtLime.Core.Recti  textureRect = new IrrlichtLime.Core.Recti(0, 0, 0, 0);
            Rectangle destSize = new Rectangle();

            int fX = t.ScreenXPos - (int)(MapRendering.TileWidthHalf * MapRendering.Scale);
            int fY = t.ScreenYPos - (int)(MapRendering.TileHeight * MapRendering.Scale);

            position.X = fX;
            position.Y = fY;

            destSize.Width = (int)(MapRendering.TileWidth * MapRendering.Scale);
            destSize.Height = (int)(MapRendering.TileHeight * MapRendering.Scale);

            int iGfxTile = t.GfxIdx;
            int iRow = (iGfxTile / 9);
            int iTile = iGfxTile - (9 * (iGfxTile / 9));

            int iStartU = 0 + (MapRendering.TileWidth * iTile);
            int iStartV = 0 + (MapRendering.TileHeight * iRow);

            MapRendering.AddTerrainBatch(t, position, new Rectangle(iStartU, iStartV, MapRendering.TileWidth, MapRendering.TileHeight));
        }
예제 #2
0
파일: Unit.cs 프로젝트: jimmyh77/IndieCiv
        public Unit(UnitData UnitData, MapTile MapTile)
        {
            this.UnitData = UnitData;
            this.MapTile = MapTile;

            UnitAnimation = new UnitAnimation();
        }
예제 #3
0
        public override void AddMapTile( MapTile t )
        {
            Vector2 position = new Vector2(0, 0);

            //IrrlichtLime.Core.Recti  textureRect = new IrrlichtLime.Core.Recti(0, 0, 0, 0);
            Rectangle destSize = new Rectangle();

            int fX = t.ScreenXPos - ( TileWidthHalf / Scale );
            int fY = t.ScreenYPos - ( TileHeightHalf / Scale );

            position.X = fX;
            position.Y = fY;

            destSize.Width = TileWidth / Scale;
            destSize.Height = TileHeight / Scale;

            int iGfxTile = t.GfxIdx;
            int iRow = (iGfxTile / 9);
            int iTile = iGfxTile - (9 * (iGfxTile / 9));

            int iStartU = 0 + ( TileWidth * iTile );
            int iStartV = 0 + ( TileHeight * iRow );

            if ( t.TerrainArt.Path != null )
                //Terrain [ t.TerrainArt.Path ].AddBatch( position, new IrrlichtLime.Core.Recti( iStartU, iStartV, iStartU + TileWidth, iStartV + TileHeight ), destSize );
                Terrain[t.TerrainArt.Path].AddBatch(new Rectangle((int)position.X, (int)position.Y, TileWidth, TileHeight), new Rectangle(iStartU, iStartV, iStartU + TileWidth, iStartV + TileHeight));
        }
예제 #4
0
        public override void AddRelief(MapTile t)
        {
            ReliefArt ReliefArt = ResourceInterface.ReliefArtData.Find(x => x.Type == t.ReliefType.ReliefArt);

            Vector2 position = new Vector2(0, 0);

            Rectangle destSize = new Rectangle();

            int fX = t.ScreenXPos - (int)(MapRendering.TileWidthHalf * MapRendering.Scale);
            int fY = t.ScreenYPos - (int)(MapRendering.TileHeightHalf * MapRendering.Scale);
            fY -= ((ReliefArt.Height - 64));

            position.X = fX;
            position.Y = fY;

            destSize.Width = (int)(ReliefArt.Width * MapRendering.Scale);
            destSize.Height = (int)(ReliefArt.Height * MapRendering.Scale);

            if (t.ReliefType.Index == 6) {
                MapTile MapTileNorthEast = t.NeighbouringTiles[MapTile.NeighbouringDirections.Northeast];
                MapTile MapTileNorth = t.NeighbouringTiles[MapTile.NeighbouringDirections.North];
                MapTile MapTileNorthWest = t.NeighbouringTiles[MapTile.NeighbouringDirections.Northwest];

                int iStartCol = 1;
                int iStartRow = 1;

                //if (pMapTile->mRiverConnectionInfo & RIVER_CONNECTION_NORTH_WEST)
                    //iStartRow += 1;

                //if (pMapTile->mRiverConnectionInfo & RIVER_CONNECTION_NORTH_EAST)
                    //iStartRow += 2;

                //if (pMapTileNorthWest->mRiverConnectionInfo & RIVER_CONNECTION_NORTH_EAST)
                    //iStartCol += 1;

                //if (pMapTileNorthEast->mRiverConnectionInfo & RIVER_CONNECTION_NORTH_WEST)
                    //iStartCol += 2;

                if (iStartCol == 1 && iStartRow == 1)
                    return;

                t.ReliefGfxIdx = ((iStartRow - 1) * 4) + (iStartCol - 1);

                fX = t.ScreenXPos - (int)(MapRendering.TileWidthHalf * MapRendering.Scale);
                fY = t.ScreenYPos - (int)(MapRendering.TileHeight * MapRendering.Scale);

                position.X = fX;
                position.Y = fY;
            }

            int iGfxTile = t.ReliefGfxIdx;
            int iRow = (iGfxTile / 4);
            int iTile = iGfxTile - (4 * (iGfxTile / 4));

            int iStartU = 0 + (ReliefArt.Width * iTile);
            int iStartV = 0 + (ReliefArt.Height * iRow);

            MapRendering.AddReliefBatch(t, position, new Rectangle(iStartU, iStartV, ReliefArt.Width, ReliefArt.Height));
        }
예제 #5
0
파일: Player.cs 프로젝트: jimmyh77/IndieCiv
        public override Unit AddUnit(UnitData UnitData, MapTile MapTile)
        {
            ActiveUnit = base.AddUnit(UnitData, MapTile);

            ActiveUnit.Owner = this;

            ActiveUnit.CenterOnMap();

            return ActiveUnit;
        }
예제 #6
0
        public virtual Unit AddUnit(UnitData UnitData, MapTile MapTile)
        {
            foreach (var Item in UnitList) {
                Item.Active = false;
            }

            Unit Unit = new Unit(UnitData, MapTile);
            Unit.Init();
            Unit.ResetMoves();
            Unit.Owner = this;
            Unit.Active = true;

            MapTile.AddUnit(Unit);

            UnitList.Add(Unit);

            return Unit;
        }
예제 #7
0
 public static void AddReliefBatch(MapTile mapTile, Vector2 dest, Rectangle source )
 {
     ReliefArt ReliefArt = ResourceInterface.ReliefArtData.Find(x => x.Type == mapTile.ReliefType.ReliefArt);
     Relief[ReliefArt.Index].AddBatch(dest, source);
 }
예제 #8
0
        public override void SetTextures(MapTile MapTile)
        {
            int TerrainIdx = MapTile.TerrainType.Index;

            int[] Direction = {0, 0, 0};

            Direction[0] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northeast] == null ? 0 : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northeast].TerrainType.Index;
            Direction[1] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.North] == null ? 0 : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.North].TerrainType.Index;
            Direction[2] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northwest] == null ? 0 : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northwest].TerrainType.Index;

            List<TerrainArt> possibleTerrainArt = new List<TerrainArt>();

            foreach ( string art in MapTile.TerrainType.TerrainArt ) {

                TerrainArt TerrainArt = ResourceInterface.TerrainArtData.Find(x => x.Type == art);

                TerrainData TerrainA = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[0]);
                TerrainData TerrainB = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[1]);
                TerrainData TerrainC = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[2]);

                bool bFoundNorthWest = false;
                bool bFoundWest = false;
                bool bFoundSouthWest = false;

                if ( Direction[0] == TerrainA.Index || Direction[0] == TerrainB.Index || Direction[0] == TerrainC.Index )
                    bFoundNorthWest = true;
                if ( Direction[1] == TerrainA.Index || Direction[1] == TerrainB.Index || Direction[1] == TerrainC.Index )
                    bFoundWest = true;
                if ( Direction[2] == TerrainA.Index || Direction[2] == TerrainB.Index || Direction[2] == TerrainC.Index )
                    bFoundSouthWest = true;

                if (bFoundNorthWest == true && bFoundWest == true && bFoundSouthWest == true)
                    possibleTerrainArt.Add(TerrainArt);
            }

            if ( possibleTerrainArt.Count > 0 ) {
                int idx = ( (MapTile.X+1) * (MapTile.Y+1) ) % (int)possibleTerrainArt.Count;

                TerrainArt TerrainArt = possibleTerrainArt[idx];

                TerrainData TerrainA = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[0]);
                TerrainData TerrainB = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[1]);
                TerrainData TerrainC = ResourceInterface.TerrainData.Find(x => x.Type == TerrainArt.Blend[2]);

                int iStartCol = 0;
                int iStartRow = 0;

                if ( Direction[2] == TerrainA.Index )
                    iStartCol = 1;
                if ( Direction[2] == TerrainB.Index )
                    iStartCol = 4;
                if ( Direction[2] == TerrainC.Index )
                    iStartCol = 7;

                if ( TerrainIdx == TerrainA.Index )
                    iStartRow = 1;
                if ( TerrainIdx == TerrainB.Index )
                    iStartRow = 4;
                if ( TerrainIdx == TerrainC.Index )
                    iStartRow = 7;

                if ( Direction[0] == TerrainA.Index )
                    iStartRow += 0;
                if ( Direction[0] == TerrainB.Index )
                    iStartRow += 1;
                if ( Direction[0] == TerrainC.Index )
                    iStartRow += 2;

                if ( Direction[1] == TerrainA.Index )
                    iStartCol += 0;
                if ( Direction[1] == TerrainB.Index )
                    iStartCol += 1;
                if ( Direction[1] == TerrainC.Index )
                    iStartCol += 2;

                MapTile.GfxIdx = ((iStartRow - 1) * 9) + (iStartCol - 1);
                MapTile.Variation = TerrainArt.Index;
            }

            if (MapTile.ReliefType != null) {

                SetReliefTexture(MapTile);
            }
        }
예제 #9
0
        public override void SetReliefTexture(MapTile MapTile)
        {
            bool[] bReliefDirectionIdx = { false, false, false, false };

            bReliefDirectionIdx[0] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northwest] == null ? false : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northwest].ReliefType != null ? true : false;
            bReliefDirectionIdx[1] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northeast] == null ? false : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Northeast].ReliefType != null ? true : false;
            bReliefDirectionIdx[2] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Southwest] == null ? false : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Southwest].ReliefType != null ? true : false;
            bReliefDirectionIdx[3] = MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Southeast] == null ? false : MapTile.NeighbouringTiles[Map.MapTile.NeighbouringDirections.Southeast].ReliefType != null ? true : false;

            int iStartRow = 1;
            int iStartCol = 1;

            if (bReliefDirectionIdx[2] == true)
                iStartRow = 2;
            if (bReliefDirectionIdx[3] == true)
                iStartRow = 3;
            if (bReliefDirectionIdx[2] == true && bReliefDirectionIdx[3] == true)
                iStartRow = 4;

            if (bReliefDirectionIdx[0] == true)
                iStartCol = 2;
            if (bReliefDirectionIdx[1] == true)
                iStartCol = 3;
            if (bReliefDirectionIdx[0] == true && bReliefDirectionIdx[1] == true)
                iStartCol = 4;

            MapTile.ReliefGfxIdx = ((iStartRow - 1) * 4) + (iStartCol - 1);
        }
예제 #10
0
        public override void AddTerritory(MapTile t)
        {
            Vector2 position = new Vector2(0, 0);
            Rectangle destSize = new Rectangle();

            int fX = t.ScreenXPos - (int)(MapRendering.TileWidthHalf * MapRendering.Scale);
            int fY = t.ScreenYPos - (int)(MapRendering.TileHeightHalf * MapRendering.Scale);
            fY -= ((72 - 64));

            position.X = fX;
            position.Y = fY;

            destSize.Width = (int)(MapRendering.TileWidth * MapRendering.Scale);
            destSize.Height = (int)(72 * MapRendering.Scale);

            MapTile NorthWest = t.NeighbouringTiles[MapTile.NeighbouringDirections.Northwest];
            MapTile NorthEast = t.NeighbouringTiles[MapTile.NeighbouringDirections.Northeast];
            MapTile SouthWest = t.NeighbouringTiles[MapTile.NeighbouringDirections.Southwest];
            MapTile SouthEast = t.NeighbouringTiles[MapTile.NeighbouringDirections.Southeast];

            int iRow = 0;
            int iTile = 0;

            if (NorthWest != null && ( NorthWest.Owner == null || NorthWest.Owner != t.Owner ) ){
                iRow = 0;
                iTile = 0;
                MapRendering.AddTerritoryBatch(t, position, new Rectangle(0 + (MapRendering.TileWidth * iTile), 0 + (72 * iRow), MapRendering.TileWidth, 72));
            }
            if (NorthEast != null && (NorthEast.Owner == null || NorthEast.Owner != t.Owner)) {
                iRow = 1;
                iTile = 0;
                MapRendering.AddTerritoryBatch(t, position, new Rectangle(0 + (MapRendering.TileWidth * iTile), 0 + (72 * iRow), MapRendering.TileWidth, 72));
            }
            if (SouthWest != null && (SouthWest.Owner == null || SouthWest.Owner != t.Owner)) {
                iRow = 2;
                iTile = 0;
                MapRendering.AddTerritoryBatch(t, position, new Rectangle(0 + (MapRendering.TileWidth * iTile), 0 + (72 * iRow), MapRendering.TileWidth, 72));
            }
            if (SouthEast != null && (SouthEast.Owner == null || SouthEast.Owner != t.Owner)) {
                iRow = 3;
                iTile = 0;
                MapRendering.AddTerritoryBatch(t, position, new Rectangle(0 + (MapRendering.TileWidth * iTile), 0 + (72 * iRow), MapRendering.TileWidth, 72));
            }
        }
예제 #11
0
        public override void AddResource(MapTile t)
        {
            Vector2 position = new Vector2(0, 0);

            //IrrlichtLime.Core.Recti  textureRect = new IrrlichtLime.Core.Recti(0, 0, 0, 0);
            Rectangle destSize = new Rectangle();

            int fX = t.ScreenXPos - (int)(25 * MapRendering.Scale);
            int fY = t.ScreenYPos - (int)(25 * MapRendering.Scale);

            position.X = fX;
            position.Y = fY;

            destSize.Width = (int)(50 * MapRendering.Scale);
            destSize.Height = (int)(50 * MapRendering.Scale);

            int iGfxTile = t.ResourceType.Icon;
            int iRow = (iGfxTile / 6);
            int iTile = iGfxTile - (6 * (iGfxTile / 6));

            int iStartU = 0 + (50 * iTile);
            int iStartV = 0 + (50 * iRow);

            MapRendering.AddResourceBatch(t, position, new Rectangle(iStartU, iStartV, 50, 50));
        }
예제 #12
0
 public override void SetTextures(MapTile MapTile)
 {
 }
예제 #13
0
 public static void AddTerritoryBatch(MapTile maptile, Vector2 dest, Rectangle source)
 {
     Territory.AddBatch(dest, source, maptile.Owner.CivilizationData.Color);
 }
예제 #14
0
 public static void AddTerrainBatch(MapTile mapTile, Vector2 dest, Rectangle source )
 {
     Terrain[mapTile.Variation].AddBatch( dest, source);
 }
예제 #15
0
 public static void AddResourceBatch(MapTile mapTile, Vector2 dest, Rectangle source)
 {
     Resource.AddBatch(dest, source);
 }
예제 #16
0
 public override void AddRelief(MapTile t)
 {
 }
예제 #17
0
 public override void AddMapTile(MapTile t)
 {
 }
예제 #18
0
        public void PlayAnimation( UnitAnimation.EAnimStates animState, MapTile.NeighbouringDirections direction, IndieCivCore.Resources.UnitData unitData )
        {
            AnimState = animState;

            switch ( AnimState ) {
                case EAnimStates.EAnimState_Default:
                    this.CurrentFlc = unitData.GetUnitAnimation("UNIT_ART_DEFAULT");
                    break;

            }

            if ( this.CurrentFlc != null )
                this.Start(direction);
        }
예제 #19
0
        public void Start(MapTile.NeighbouringDirections Direction)
        {
            AnimDirection = Direction;
            CurrentFrame = StartFrame = (int)AnimDirection * (CurrentFlc.Civ3Header.animLength+1);
            //CurrentFrame = StartFrame = 0;
            //EndFrame = 14;
            EndFrame = StartFrame + CurrentFlc.Civ3Header.animLength;
            //EndFrame = ((int)AnimDirection * CurrentFlc.Civ3Header.animLength) + CurrentFlc.Civ3Header.animLength - 1;

            Speed = (float)CurrentFlc.FlcHeader.speed;
        }
예제 #20
0
 public override bool SmoothTile(MapTile MapTile)
 {
     return false;
 }
예제 #21
0
        public override bool SmoothTile(MapTile MapTile)
        {
            bool Changed = false;

            foreach ( var item in MapTile.NeighbouringTiles ) {
                MapTile Direction = MapTile.NeighbouringTiles[item.Key];

                if (Direction != null) {
                    if (CanBlend(MapTile, Direction) == false) {

                        foreach ( var blend in MapTile.TerrainType.Blend ) {
                            TerrainData From = ResourceInterface.TerrainData.Find(x => x.Type == blend.From);
                            if (From == Direction.TerrainType) {
                                Direction.TerrainType = ResourceInterface.TerrainData.Find(x => x.Type == blend.To);
                                Changed = true;
                            }
                        }

                    }
                }
            }

            return Changed;
        }
예제 #22
0
        private bool CanBlend( MapTile MapTile, MapTile Blend )
        {
            foreach ( string art in MapTile.TerrainType.TerrainArt ) {
                TerrainArt TerrainArt = ResourceInterface.TerrainArtData.Find(x => x.Type == art);

                foreach ( string b in TerrainArt.Blend ) {
                    //TerrainData TerrainData = ResourceInterface.TerrainData.Find(x => x.Type == b);

                    if ( b == Blend.TerrainType.Type )
                        return true;
                }
            }

            return false;
        }
예제 #23
0
 public override bool PointInsideMapTile(MapTile t)
 {
     return true;
 }
예제 #24
0
 public override void AddResource(MapTile t)
 {
 }
예제 #25
0
        public override bool PointInsideMapTile(MapTile MapTile)
        {
            Vector2[] points = new Vector2[4];
            Vector2 mouse;

            int xTile = MapTile.ScreenXPos;// +MapRendering.TileWidthHalf;
            int yTile = MapTile.ScreenYPos;// +MapRendering.TileHeightHalf;

            points[0] = new Vector2(xTile - MapRendering.TileWidthHalf, yTile);
            points[1] = new Vector2(xTile, yTile - MapRendering.TileHeightHalf);
            points[2] = new Vector2(xTile + MapRendering.TileWidthHalf, yTile );
            points[3] = new Vector2(xTile , yTile + MapRendering.TileHeightHalf);

            int iMouseX = (int)MouseState.Position.X;
            int iMouseY = (int)MouseState.Position.Y;

            mouse = new Vector2(iMouseX, iMouseY);

            float nx, ny, x, y;
            for (int i = 0; i < 4; i++) {
                nx = points[(i + 1) % 4].Y - points[i].Y;
                ny = points[i].X - points[(i + 1) % 4].X;

                x = mouse.X - points[i].X;
                y = mouse.Y - points[i].Y;

                if ((x * nx) + (y * ny) > 0)
                    return false;
            }

            return true;
        }
예제 #26
0
 public override void AddTerritory(MapTile t)
 {
 }
예제 #27
0
 public static void AddStartLocationBatch(MapTile maptile, Vector2 dest, Rectangle source)
 {
     StartLocation.AddBatch(dest, source);
 }