public void Set(int index, int x, int y, byte floorSubImage, byte ceilingSubImage, byte wallSubImage, int frame)
{
bool isAnimated = Floors.IsAnimated(floorSubImage) || Floors.IsAnimated(ceilingSubImage) || Walls.IsAnimated(wallSubImage);
if (isAnimated)
{
AnimatedTiles.Add(index);
}
else
{
AnimatedTiles.Remove(index);
}
unsafe
{
fixed(Tile *tile = &Tiles[index])
{
tile->TilePosition = new Vector2(x, y);
tile->Floor = (byte)Floors.GetSubImageAtTime(floorSubImage, frame);
tile->Ceiling = (byte)Floors.GetSubImageAtTime(ceilingSubImage, frame);
tile->Wall = (byte)Walls.GetSubImageAtTime(wallSubImage, frame);
tile->Flags = 0; // TileFlags.UsePalette;
var subImage = Walls.GetSubImageDetails(tile->Wall);
tile->WallSize = subImage.TexSize;
}
}
}
public FancyFallingBlock(EntityData data, Vector2 offset)
: base(data.Position + offset, '3', data.Width, data.Height, data.Bool("finalBoss", false), data.Bool("behind", false), data.Bool("climbFall", true))
{
baseData = new DynData <FallingBlock>(this);
Remove(baseData.Get <TileGrid>("tiles"));
Remove(Get <TileInterceptor>());
badLightOcclude = Get <LightOcclude>();
int newSeed = Calc.Random.Next();
Calc.PushRandom(newSeed);
tileMap = GenerateTileMap(data.Attr("tileData", ""));
Autotiler.Generated generated = GFX.FGAutotiler.GenerateMap(tileMap, default(Autotiler.Behaviour));
baseData["tiles"] = generated.TileGrid;
Add(baseData.Get <TileGrid>("tiles"));
Add(animatedTiles = generated.SpriteOverlay);
Calc.PopRandom();
if (data.Bool("finalBoss", false))
{
VirtualMap <char> tileMapHighlighted = GenerateTileMap(data.Attr("tileDataHighlight", ""));
Calc.PushRandom(newSeed);
TileGrid highlight = GFX.FGAutotiler.GenerateMap(tileMapHighlighted, default(Autotiler.Behaviour)).TileGrid;
highlight.Alpha = 0f;
baseData["highlight"] = highlight;
Add(baseData.Get <TileGrid>("highlight"));
Calc.PopRandom();
}
ColliderList colliders = GenerateBetterColliderGrid(tileMap, 8, 8);
AddLightOcclude(this, colliders);
Collider = colliders;
Add(new TileInterceptor(baseData.Get <TileGrid>("tiles"), false));
}
public patch_BackgroundTiles(Vector2 position, VirtualMap <char> data)
{
Position = position;
Tag = Tags.Global;
Autotiler.Generated generated = GFX.BGAutotiler.GenerateMap(data, paddingIgnoreOutOfLevel: false);
Tiles = generated.TileGrid;
Tiles.VisualExtend = 1;
Add(Tiles);
Add(AnimatedTiles = generated.SpriteOverlay);
Depth = Depths.BGTerrain;
}
private static Autotiler.Generated Generate(this Autotiler tiler, VirtualMap <char> mapData, int startX, int startY, VirtualMap <char> forceData, Autotiler.Behaviour behaviour)
{
usingCustomAutotiler = true;
forceData_CustomAutotiler = forceData;
startPoint_CustomAutotiler = new Point(startX, startY);
TileGrid tileGrid = new TileGrid(8, 8, forceData.Columns, forceData.Rows);
AnimatedTiles animatedTiles = new AnimatedTiles(forceData.Columns, forceData.Rows, GFX.AnimatedTilesBank);
Rectangle empty = new Rectangle(startX, startY, forceData.Columns, forceData.Rows);
for (int i = startX; i < startX + forceData.Columns; i += 50)
{
for (int j = startY; j < startY + forceData.Rows; j += 50)
{
if (!mapData.AnyInSegmentAtTile(i, j))
{
j = j / 50 * 50;
}
else
{
int k = i;
int num = Math.Min(i + 50, startX + forceData.Columns);
while (k < num)
{
int l = j;
int num2 = Math.Min(j + 50, startY + forceData.Rows);
while (l < num2)
{
object tiles = m_TileHandler.Invoke(tiler, new object[] { mapData, k, l, empty, forceData[k - startX, l - startY], behaviour });
if (tiles != null)
{
(Calc.Random as PositionRandom)?.SetPosition(k - startX, l - startY); // Positional Randomization for TileSeedController
tileGrid.Tiles[k - startX, l - startY] = Calc.Random.Choose(f_Tiles_Textures.GetValue(tiles));
if (f_Tiles_HasOverlays.GetValue(tiles))
{
animatedTiles.Set(k - startX, l - startY, Calc.Random.Choose(f_Tiles_OverlapSprites.GetValue(tiles)), 1f, 1f);
}
}
l++;
}
k++;
}
}
}
}
usingCustomAutotiler = false;
return(new Autotiler.Generated {
TileGrid = tileGrid,
SpriteOverlay = animatedTiles
});
}
private Autotiler.Generated Generate(
VirtualMap <char> mapData,
int startX,
int startY,
int tilesX,
int tilesY,
bool forceSolid,
char forceID,
Autotiler.Behaviour behaviour)
{
TileGrid tileGrid = new TileGrid(8, 8, tilesX, tilesY);
AnimatedTiles animatedTiles = new AnimatedTiles(tilesX, tilesY, Gfx.AnimatedTilesBank);
Rectangle forceFill = Rectangle.Empty;
if (forceSolid)
{
forceFill = new Rectangle(startX, startY, tilesX, tilesY);
}
if (mapData != null)
{
for (int x1 = startX; x1 < startX + tilesX; x1 += 50)
{
for (int y1 = startY; y1 < startY + tilesY; y1 += 50)
{
if (!mapData.AnyInSegmentAtTile(x1, y1))
{
y1 = y1 / 50 * 50;
}
else
{
int x2 = x1;
for (int index1 = Math.Min(x1 + 50, startX + tilesX); x2 < index1; ++x2)
{
int y2 = y1;
for (int index2 = Math.Min(y1 + 50, startY + tilesY); y2 < index2; ++y2)
{
Autotiler.Tiles tiles = this.TileHandler(mapData, x2, y2, forceFill, forceID, behaviour);
if (tiles != null)
{
tileGrid.Tiles[x2 - startX, y2 - startY] = RandomUtil.Random.Choose <MTexture>(tiles.Textures);
if (tiles.HasOverlays)
{
animatedTiles.Set(x2 - startX, y2 - startY, RandomUtil.Random.Choose <string>(tiles.OverlapSprites), 1f, 1f);
}
}
}
}
}
}
}
}
else
{
for (int x = startX; x < startX + tilesX; ++x)
{
for (int y = startY; y < startY + tilesY; ++y)
{
Autotiler.Tiles tiles = this.TileHandler((VirtualMap <char>)null, x, y, forceFill, forceID, behaviour);
if (tiles != null)
{
tileGrid.Tiles[x - startX, y - startY] = RandomUtil.Random.Choose <MTexture>(tiles.Textures);
if (tiles.HasOverlays)
{
animatedTiles.Set(x - startX, y - startY, RandomUtil.Random.Choose <string>(tiles.OverlapSprites), 1f, 1f);
}
}
}
}
}
return(new Autotiler.Generated()
{
TileGrid = tileGrid,
SpriteOverlay = animatedTiles
});
}
