private char GetTile(
VirtualMap <char> mapData,
int x,
int y,
Rectangle forceFill,
char forceID,
Autotiler.Behaviour behaviour)
{
if (forceFill.Contains(x, y))
{
return(forceID);
}
if (mapData == null)
{
return(!behaviour.EdgesExtend ? '0' : forceID);
}
if (x >= 0 && y >= 0 && x < mapData.Columns && y < mapData.Rows)
{
return(mapData[x, y]);
}
if (!behaviour.EdgesExtend)
{
return('0');
}
int index1 = Util.Clamp(x, 0, mapData.Columns - 1);
int index2 = Util.Clamp(y, 0, mapData.Rows - 1);
return(mapData[index1, index2]);
}
private bool CheckTile(
Autotiler.TerrainType set,
VirtualMap <char> mapData,
int x,
int y,
Rectangle forceFill,
Autotiler.Behaviour behaviour)
{
if (forceFill.Contains(x, y))
{
return(true);
}
if (mapData == null)
{
return(behaviour.EdgesExtend);
}
if (x < 0 || y < 0 || x >= mapData.Columns || y >= mapData.Rows)
{
if (!behaviour.EdgesExtend)
{
return(false);
}
char ch = mapData[Util.Clamp(x, 0, mapData.Columns - 1), Util.Clamp(y, 0, mapData.Rows - 1)];
return(!this.IsEmpty(ch) && !set.Ignore(ch));
}
char ch1 = mapData[x, y];
return(!this.IsEmpty(ch1) && !set.Ignore(ch1));
}
public static Autotiler.Generated GenerateOverlay(this Autotiler tiler, VirtualMap <char> tileMap, int x, int y, VirtualMap <char> mapData)
{
Autotiler.Behaviour behaviour = new Autotiler.Behaviour {
EdgesExtend = true,
EdgesIgnoreOutOfLevel = true,
PaddingIgnoreOutOfLevel = true
};
return(tiler.Generate(mapData, x, y, tileMap, behaviour));
}
void Start()
{
Debug.Log("==读取GamePlay的Texture");
Gfx.Game = Atlas.FromAtlas(Path.Combine("Graphics", "Atlases", "Gameplay"), Atlas.AtlasDataFormat.Packer);
foregroundTiles = new Tiles(Path.Combine(Util.GAME_PATH_CONTENT, Path.Combine("Graphics", "ForegroundTiles.xml")));
backgroundTiles = new Tiles(Path.Combine(Util.GAME_PATH_CONTENT, Path.Combine("Graphics", "BackgroundTiles.xml")));
AreaData.Load();
Stage stage = new Stage(0, AreaMode.Normal);
stage.Load();
//生成地图数据
Autotiler.Behaviour fgBehaviour = new Autotiler.Behaviour()
{
EdgesExtend = true,
EdgesIgnoreOutOfLevel = false,
PaddingIgnoreOutOfLevel = true
};
Autotiler.Behaviour bgBehaviour = new Autotiler.Behaviour()
{
EdgesExtend = true,
EdgesIgnoreOutOfLevel = false,
PaddingIgnoreOutOfLevel = false
};
VirtualMap <char> foregroundData = stage.ForegroundData;
this.colliderGrid = new ColliderGrid(foregroundData.Columns, foregroundData.Rows, 8f, 8f);
for (int x = 0; x < foregroundData.Columns; x += 50)
{
for (int y = 0; y < foregroundData.Rows; y += 50)
{
if (foregroundData.AnyInSegmentAtTile(x, y))
{
int index1 = x;
for (int index2 = Math.Min(index1 + 50, foregroundData.Columns); index1 < index2; ++index1)
{
int index3 = y;
for (int index4 = Math.Min(index3 + 50, foregroundData.Rows); index3 < index4; ++index3)
{
if (foregroundData[index1, index3] != '0')
{
this.colliderGrid[index1, index3] = true;
}
else
{
this.colliderGrid[index1, index3] = false;
}
}
}
}
}
}
//VirtualMap<char> backgroundData = stage.BackgroundData;
foregroundTiles.GenerateTiles(this.fgTilemap, foregroundData, 0, 0, foregroundData.Columns, foregroundData.Rows, false, '0', fgBehaviour, colliderGrid);
//bgTileDictionary.GenerateTiles(this.bgTilemap, backgroundData, 0, 0, backgroundData.Columns, backgroundData.Rows, false, '0', bgBehaviour);
}
public Autotiler.Generated GenerateMap(VirtualMap <char> mapData, bool paddingIgnoreOutOfLevel)
{
Autotiler.Behaviour behaviour = new Autotiler.Behaviour()
{
EdgesExtend = true,
EdgesIgnoreOutOfLevel = false,
PaddingIgnoreOutOfLevel = paddingIgnoreOutOfLevel
};
return(this.Generate(mapData, 0, 0, mapData.Columns, mapData.Rows, false, '0', behaviour));
}
private static void LevelLoader_LoadingThread(On.Celeste.LevelLoader.orig_LoadingThread orig, LevelLoader self)
{
orig(self);
MapData mapData = self.Level.Session.MapData;
var controllers = from level in mapData.Levels
from entity in level.Entities
where entity.Name == "FancyTileEntities/TileSeedController"
select new { entity, level };
Rectangle mapTileBounds = mapData.TileBounds;
SolidTiles fgTiles = self.Level.SolidTiles;
BackgroundTiles bgTiles = self.Level.BgTiles;
Regex regex = new Regex("\\r\\n|\\n\\r|\\n|\\r");
Autotiler.Behaviour behaviour = new Autotiler.Behaviour {
EdgesExtend = true,
EdgesIgnoreOutOfLevel = false,
PaddingIgnoreOutOfLevel = true
};
foreach (var controller in controllers)
{
EntityData data = controller.entity;
LevelData level = controller.level;
int randomSeed = data.Int("randomSeed", 42);
Rectangle bounds = level.TileBounds;
Rectangle tileBounds = self.Level.Session.MapData.TileBounds;
if (data.Bool("fg", true))
{
VirtualMap <char> map = new VirtualMap <char>(bounds.Width, bounds.Height, '0');
string[] array = regex.Split(level.Solids);
for (int y = 0; y < array.Length; y++)
{
for (int x = 0; x < array[y].Length; x++)
{
map[x, y] = array[y][x];
}
}
Calc.PushRandom(randomSeed);
Autotiler.Generated gen = Extensions.GenerateOverlay(GFX.FGAutotiler, map, bounds.X - tileBounds.Left, bounds.Y - tileBounds.Top, self.Level.SolidsData, behaviour);
Calc.PopRandom();
int left = bounds.Left;
int top = bounds.Top;
for (int y = top; y < top + array.Length; y++)
{
for (int x = left; x < left + array[y - top].Length; x++)
{
fgTiles.Tiles.Tiles[x - mapTileBounds.Left, y - mapTileBounds.Top] = gen.TileGrid.Tiles[x - left, y - top];
}
}
}
if (data.Bool("bg", true))
{
VirtualMap <char> map = new VirtualMap <char>(bounds.Width, bounds.Height, '0');
string[] array = regex.Split(level.Bg);
for (int y = 0; y < array.Length; y++)
{
for (int x = 0; x < array[y].Length; x++)
{
map[x, y] = array[y][x];
}
}
Calc.PushRandom(randomSeed);
Autotiler.Generated gen = Extensions.GenerateOverlay(GFX.BGAutotiler, map, bounds.X - tileBounds.Left, bounds.Y - tileBounds.Top, self.Level.BgData, behaviour);
Calc.PopRandom();
int left = bounds.Left;
int top = bounds.Top;
for (int y = top; y < top + array.Length; y++)
{
for (int x = left; x < left + array[y - top].Length; x++)
{
bgTiles.Tiles.Tiles[x - mapTileBounds.Left, y - mapTileBounds.Top] = gen.TileGrid.Tiles[x - left, y - top];
}
}
}
}
}
private static bool Autotiler_CheckTile(On.Celeste.Autotiler.orig_CheckTile orig, Autotiler self, object set, VirtualMap <char> mapData, int x, int y, Rectangle forceFill, Autotiler.Behaviour behaviour)
{
if (usingCustomAutotiler)
{
Point origin = startPoint_CustomAutotiler;
char c = forceData_CustomAutotiler[x - origin.X, y - origin.Y];
if (IsEmpty(c))
{
forceFill = Rectangle.Empty;
}
else if ((bool)m_TerrainType_Ignore.Invoke(set, new object[] { c }))
{
// Hack to make sure `ignores` attributes are respected
return(false);
}
}
return(orig(self, set, mapData, x, y, forceFill, behaviour));
}
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
});
}
public static Autotiler.Generated GenerateOverlay(this Autotiler tiler, VirtualMap <char> tileMap, int x, int y, VirtualMap <char> mapData, Autotiler.Behaviour behaviour)
{
return(tiler.Generate(mapData, x, y, tileMap, behaviour));
}
private Autotiler.Tiles TileHandler(VirtualMap <char> mapData, int x, int y, Rectangle forceFill, char forceID, Autotiler.Behaviour behaviour)
{
char tile = this.GetTile(mapData, x, y, forceFill, forceID, behaviour);
if (this.IsEmpty(tile))
{
return(null);
}
Autotiler.TerrainType set = this.lookup[tile];
bool flag1 = true;
int num = 0;
for (int index1 = -1; index1 < 2; ++index1)
{
for (int index2 = -1; index2 < 2; ++index2)
{
bool flag2 = this.CheckTile(set, mapData, x + index2, y + index1, forceFill, behaviour);
if (!flag2 && behaviour.EdgesIgnoreOutOfLevel && !this.CheckForSameLevel(x, y, x + index2, y + index1))
{
flag2 = true;
}
this.adjacent[num++] = flag2 ? (byte)1 : (byte)0;
if (!flag2)
{
flag1 = false;
}
}
}
if (flag1)
{
if ((behaviour.PaddingIgnoreOutOfLevel ? ((!this.CheckTile(set, mapData, x - 2, y, forceFill, behaviour) && this.CheckForSameLevel(x, y, x - 2, y)) || (!this.CheckTile(set, mapData, x + 2, y, forceFill, behaviour) && this.CheckForSameLevel(x, y, x + 2, y)) || (!this.CheckTile(set, mapData, x, y - 2, forceFill, behaviour) && this.CheckForSameLevel(x, y, x, y - 2)) || (!this.CheckTile(set, mapData, x, y + 2, forceFill, behaviour) && this.CheckForSameLevel(x, y, x, y + 2))) : (!this.CheckTile(set, mapData, x - 2, y, forceFill, behaviour) || !this.CheckTile(set, mapData, x + 2, y, forceFill, behaviour)) || (!this.CheckTile(set, mapData, x, y - 2, forceFill, behaviour)) || (!this.CheckTile(set, mapData, x, y + 2, forceFill, behaviour))))
{
return(this.lookup[tile].Padded);
}
else
{
return(this.lookup[tile].Center);
}
}
//return ? this.lookup[tile].Padded : this.lookup[tile].Center;
for (int p = 0; p < set.Masked.Count; p++)
{
Autotiler.Masked masked = set.Masked[p];
bool flag2 = true;
for (int index = 0; index < 9 & flag2; ++index)
{
if (masked.Mask[index] != (byte)2 && (int)masked.Mask[index] != (int)this.adjacent[index])
{
flag2 = false;
}
}
if (flag2)
{
return(masked.Tiles);
}
}
return(null);
}
public void GenerateTiles(Tilemap tilemap, VirtualMap <char> foregroundData, int startX, int startY, int tilesX, int tilesY, bool forceSolid, char forceID, Autotiler.Behaviour behaviour, ColliderGrid colliderGrid)
{
Rectangle forceFill = Rectangle.Empty;
if (forceSolid)
{
forceFill = new Rectangle(startX, startY, tilesX, tilesY);
}
if (foregroundData != null)
{
for (int x1 = startX; x1 < startX + tilesX; x1 += 50)
{
for (int y1 = startY; y1 < startY + tilesY; y1 += 50)
{
if (!foregroundData.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(foregroundData, x2, y2, forceFill, forceID, behaviour);
if (tiles != null)
{
SolidTile tile = ScriptableObject.CreateInstance <SolidTile>();
tile.SetTile(tiles);
tile.colliderType = colliderGrid[x2 - startX, y2 - startY]? Tile.ColliderType.Grid:Tile.ColliderType.None;
tilemap.SetTile(new Vector3Int(x2 - startX, -(y2 - startY), 0), tile);
//this.tilemap.SetTile(new Vector3Int(0, 0, 0), tile);
//return;
}
//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)
{
SolidTile tile = ScriptableObject.CreateInstance <SolidTile>();
tile.SetTile(tiles);
tile.colliderType = colliderGrid[x - startX, y - startY] ? Tile.ColliderType.Grid : Tile.ColliderType.None;
tilemap.SetTile(new Vector3Int(x - startX, -(y - startY), 0), tile);
//this.tilemap.SetTile(new Vector3Int(0, 0, 0), tile);
//return;
}
//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);
//}
}
}
}
}
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
});
}
