예제 #1
0
        public void Update(uint tick, RenderMap map, uint position)
        {
            uint spriteIndex = (uint)objectType - 8;

            if (spriteIndex < 24) // tree
            {
                /* Adding sprite number to animation ensures
                 * that the tree animation won't be synchronized
                 * for all trees on the map. */
                uint treeAnim = (tick + spriteIndex) >> 4;

                if (spriteIndex < 16) // pine and normal tree (8 sprites each)
                {
                    spriteIndex = (uint)((spriteIndex & ~7) + (treeAnim & 7));
                }
                else // palm and water tree (4 sprites each)
                {
                    spriteIndex = (uint)((spriteIndex & ~3) + (treeAnim & 3));
                }
            }

            // the tree sprite sizes are the same per tree type, so no resize is necessary

            var textureAtlas = TextureAtlasManager.Instance.GetOrCreate(Layer.Objects);

            var renderPosition = map.CoordinateSpace.TileSpaceToViewSpace(position);

            sprite.X       = renderPosition.X + spriteOffsets[spriteIndex].X;
            sprite.Y       = renderPosition.Y + spriteOffsets[spriteIndex].Y;
            shadowSprite.X = renderPosition.X + shadowSpriteOffsets[spriteIndex].X;
            shadowSprite.Y = renderPosition.Y + shadowSpriteOffsets[spriteIndex].Y;

            sprite.TextureAtlasOffset       = textureAtlas.GetOffset(spriteIndex);
            shadowSprite.TextureAtlasOffset = textureAtlas.GetOffset(1000u + spriteIndex);
        }
예제 #2
0
        public void Update(RenderMap map)
        {
            var renderPosition = map.CoordinateSpace.TileSpaceToViewSpace(position);

            sprite.X = renderPosition.X + offsetX;
            sprite.Y = renderPosition.Y + offsetY;
        }
예제 #3
0
        public void Update(uint tick, RenderMap map, MapPos position)
        {
            var  textureAtlas = TextureAtlasManager.Instance.GetOrCreate(Layer.Objects);
            uint offset       = (tick >> 3) & 3;
            uint spriteIndex  = 128u + offset;

            uint flagSpriteIndex = spriteIndex + flag.Player * 16u; // player colors

            var renderPosition = map.CoordinateSpace.TileSpaceToViewSpace(position);

            sprite.X       = renderPosition.X + spriteOffsets[(int)offset].X;
            sprite.Y       = renderPosition.Y + spriteOffsets[(int)offset].Y;
            shadowSprite.X = renderPosition.X + shadowSpriteOffsets[(int)offset].X;
            shadowSprite.Y = renderPosition.Y + shadowSpriteOffsets[(int)offset].Y;

            sprite.TextureAtlasOffset       = textureAtlas.GetOffset(flagSpriteIndex);
            shadowSprite.TextureAtlasOffset = textureAtlas.GetOffset(1000u + spriteIndex);

            int baseLine = sprite.Y + sprite.Height;

            if (baseLine > maxBaseLine)
            {
                maxBaseLine = baseLine;
            }
            else if (baseLine < maxBaseLine)
            {
                sprite.BaseLineOffset = maxBaseLine - baseLine;
            }

            // resources
            for (int i = 0; i < 8; ++i)
            {
                var resource = flag.GetResourceAtSlot(i);

                if (resource != Resource.Type.None)
                {
                    int baselineOffset = (i < 3) ? -2 : 2;
                    var info           = resourceSpriteInfos[(int)resource];

                    if (resources[i] == null)
                    {
                        var spriteOffset = textureAtlas.GetOffset(2000u + (uint)resource);
                        resources[i] = spriteFactory.Create(info.Size.Width, info.Size.Height, spriteOffset.X, spriteOffset.Y, false, false);
                    }

                    // resource at slot 2 may be hidden by castle/stock so adjust baseline in this case
                    if (i == 2 && flag.HasBuilding)
                    {
                        switch (flag.Building.BuildingType)
                        {
                        case Building.Type.Castle:
                        case Building.Type.Stock:
                            baselineOffset += 4;
                            break;
                        }
                    }

                    resources[i].X              = renderPosition.X + info.Position.X + ResPos[i * 2];
                    resources[i].Y              = renderPosition.Y + info.Position.Y + ResPos[i * 2 + 1];
                    resources[i].Layer          = sprite.Layer;
                    resources[i].BaseLineOffset = baselineOffset;
                    resources[i].Visible        = true;
                }
                else
                {
                    resources[i]?.Delete();
                    resources[i] = null;
                }
            }
        }