//交换entity位置
public void SwapTile(TileMapComponent tileMapComponent, Vector2Int aPos, Vector2Int bPos)
{
var temp = tileMapComponent.entities[aPos.x, aPos.y];
tileMapComponent.entities[aPos.x, aPos.y] = tileMapComponent.entities[bPos.x, bPos.y];
tileMapComponent.entities[bPos.x, bPos.y] = temp;
}
public Vector2Int GetTileIdxPosition(TileMapComponent tileMapComponent, Vector3 worldPos)
{
var column = Mathf.FloorToInt((worldPos.x - tileMapComponent.origin.x) / tileMapComponent.tileWidth);
var row = Mathf.FloorToInt((worldPos.y - tileMapComponent.origin.y) / tileMapComponent.tileHeight);
return(new Vector2Int(row, column));
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
Tile.TileVisualOffsetX = 0;
Tile.TileVisualOffsetY = 48;
mapManager = new MapManager(this, @"Textures\TileSets\IsometricTiles");
mapComponent = new TileMapComponent<InGameObject>(this, mapManager);
Components.Add(mapComponent);
frameRateViewer = new FPSComponent(this);
Components.Add(frameRateViewer);
Window.AllowUserResizing = true;
Window.ClientSizeChanged += new EventHandler<EventArgs>(Window_ClientSizeChanged);
preferredWindowedWidth = graphics.PreferredBackBufferWidth;
preferredWindowedHeight = graphics.PreferredBackBufferHeight;
if (UseUnboundedFrameRate)
{
this.IsFixedTimeStep = false;
this.graphics.SynchronizeWithVerticalRetrace = false;
this.graphics.ApplyChanges();
}
base.Initialize();
}
public bool CheckRemoveTiles(TileMapComponent tileMapComponent, HashSet <Vector2Int> lstCheckPos, HashSet <Vector2Int> lstCheckResult)
{
var tileCheckComponent = World.GetSingletonComponent <TileCheckComponent>();
var stateCaches = tileCheckComponent.stateCaches;
ClearState(stateCaches, TileCheckState.None);
foreach (var checkPos in lstCheckPos)
{
CheckState(tileMapComponent, stateCaches, checkPos.x, checkPos.y);
}
//获取所有状态为CheckedSuccess的位置
for (int row = 0; row < stateCaches.GetLength(0); row++)
{
for (int column = 0; column < stateCaches.GetLength(1); column++)
{
if (0 != (stateCaches[row, column] & TileCheckState.CheckedSuccess))
{
lstCheckResult.Add(new Vector2Int(row, column));
}
}
}
bool result = lstCheckResult.Count > 0;
return(result);
}
public void RemoveTile(TileMapComponent tileMapComponent, Vector2Int pos, float time = 0)
{
var entities = tileMapComponent.entities;
var entity = entities[pos.x, pos.y];
World.GetOrCreateSystem <TileDestroySystem>().DestroyEntity(entity, time);
entities[pos.x, pos.y] = Entity.Null;
}
public Vector3 GetTileWorldPosition(TileMapComponent tileMapComponent, Vector2Int pos)
{
float x = tileMapComponent.origin.x + (pos.y + tileMapComponent.tileWidth * 0.5f) * tileMapComponent.tileWidth;
float y = tileMapComponent.origin.y + (pos.x + tileMapComponent.tileHeight * 0.5f) * tileMapComponent.tileHeight;
float z = tileMapComponent.origin.z;
return(new Vector3(x, y, z));
}
/// <summary>
/// 随机生成，现在只保证不会出现可直接消除的行或列
/// </summary>
/// <param name="tileMapComponent"></param>
/// <param name="row"></param>
/// <param name="column"></param>
/// <returns></returns>
public Entity RandomCreateTile(TileMapComponent tileMapComponent, int row, int column)
{
var lstCfg = ResCfgSys.Instance.GetCfgLst <ResTile>();
int excludeLeftId = -1;
if (row > tileMapComponent.minRemoveCount - 2)
{
var minIdx = row - tileMapComponent.minRemoveCount + 1;
var leftEntity = tileMapComponent.entities[row - 1, column];
excludeLeftId = World.GetComponent <TileComponent>(leftEntity).tileId;
for (int i = row - 1; i > minIdx; i--)
{
var leftTwoEntity = tileMapComponent.entities[i - 1, column];
if (World.GetComponent <TileComponent>(leftTwoEntity).tileId != excludeLeftId)
{
excludeLeftId = -1;
break;
}
}
}
int excludeDownId = -1;
if (column > tileMapComponent.minRemoveCount - 2)
{
var minIdx = column - tileMapComponent.minRemoveCount + 1;
var downEntity = tileMapComponent.entities[row, column - 1];
excludeDownId = World.GetComponent <TileComponent>(downEntity).tileId;
for (int i = column - 1; i > minIdx; i--)
{
var downTwoEntity = tileMapComponent.entities[row, i - 1];
if (World.GetComponent <TileComponent>(downTwoEntity).tileId != excludeDownId)
{
excludeDownId = -1;
break;
}
}
}
var lst = ResetObjectPool <List <int> > .Instance.GetObject();
for (int i = 0; i < lstCfg.Count; i++)
{
var id = lstCfg[i].id;
if (id != excludeLeftId && id != excludeDownId)
{
lst.Add(id);
}
}
var index = Random.Range(0, lst.Count);
var cfg = ResCfgSys.Instance.GetCfg <ResTile>(lst[index]);
ResetObjectPool <List <int> > .Instance.SaveObject(lst);
var entity = CreateTile(cfg, GetTileWorldPosition(tileMapComponent, new Vector2Int(row, column)));
return(entity);
}
public void Init(GameObject tile_map_obj, GameObject player_obj_)
{
mTileMap = tile_map_obj.AddComponent <TileMapComponent>();
var player_obj = TileObjFactory.Instance.CreatePlayer(TileFactory.Instance.CreatePlayer());
mPlayer = player_obj.GetComponent <TileComponent>();
//mPlayer = player_obj;
}
private void CheckAndRemoveTiles(TileMapComponent tileMapComponent, HashSet <Vector2Int> lstCheck)
{
var tileCheckSystem = World.GetExistingSystem <TileCheckSystem>();
var lstClear = ResetObjectPool <HashSet <Vector2Int> > .Instance.GetObject();
var result = tileCheckSystem.CheckRemoveTiles(tileMapComponent, lstCheck, lstClear);
if (result)
{
RemoveTiles(tileMapComponent, lstClear);
}
ResetObjectPool <HashSet <Vector2Int> > .Instance.SaveObject(lstClear);
}
// public Entity CreateEffectEntity(string name)
// {
// var effectEntity = World.CreateEntity();
// var prefabComponent = World.AddComponentOnce<PrefabComponent>(effectEntity);
// prefabComponent.go = prefabComponent.gameObject;
// prefabComponent.trans = prefabComponent.transform;
// var view = new EffectView();
// view.Init(name, false, prefabComponent.transform);
// prefabComponent.view = view;
// return effectEntity;
// }
// private void CheckStateAll(TileMapComponent tileMapComponent, byte[,] stateCaches)
// {
// var entities = tileMapComponent.entities;
//
// var maxRow = stateCaches.GetLength(0);
// var maxColumn = stateCaches.GetLength(1);
// for (int row = 0; row < maxRow; row++)
// {
// for (int column = 0; column < maxColumn; column++)
// {
// var state = stateCaches[row, column];
// if (state == TileCheckState.WaitCheck)
// {
// CheckState(tileMapComponent, stateCaches, row, column);
// }
// }
// }
// }
public bool SwapTilePos(TileMapComponent tileMapComponent, Vector2Int aPos, Vector2Int bPos, HashSet <Vector2Int> lstClear)
{
//先交换数据
tileSprawnSystem.SwapTile(tileMapComponent, aPos, bPos);
var tileCheckSystem = World.GetExistingSystem <TileCheckSystem>();
var lstCheck = ResetObjectPool <HashSet <Vector2Int> > .Instance.GetObject();
lstCheck.Add(aPos);
lstCheck.Add(bPos);
var result = tileCheckSystem.CheckRemoveTiles(tileMapComponent, lstCheck, lstClear);
if (!result)
{
//如果没有成功，将数据还原回去
tileSprawnSystem.SwapTile(tileMapComponent, aPos, bPos);
}
return(result);
}
/// <summary>
/// Set level data, initialize pathfinding and node cache.
/// </summary>
/// <param name="grid"></param>
//public void SetupLevel(Node[,] grid)
public void SetupLevel()
{
if (FindObjectOfType <GridLayout>())
{
TileGrid = FindObjectOfType <GridLayout>();
} //Get the levels' gridLayout
TilemapCollider2D[] tilemapColliders = TileGrid.GetComponentsInChildren <TilemapCollider2D>();
foreach (TilemapCollider2D tilemapCollider in tilemapColliders)
{
TilemapRenderer tilemapRenderer = tilemapCollider.GetComponent <TilemapRenderer>(); //Find the attached renderer.
Tilemap tilemap = tilemapCollider.GetComponent <Tilemap>(); //Find the attached tilemap.
if (tilemapRenderer != null && tilemap != null)
{
TileMapComponent thisTileMapComponent = new TileMapComponent()
{
Tilemap = tilemap,
Collider2D = tilemapCollider,
Renderer = tilemapRenderer
};
tileMapComponents.Add(thisTileMapComponent);
if (tilemapRenderer.sortingLayerName == "Default")
{
WalkableTilemap = thisTileMapComponent;
NavGrid = GenerateGrid(thisTileMapComponent.Tilemap);
NavGrid.Init();
}
}
}
//MethodInfo method = GetType().GetMethod(DebugNavGrid);
InvokeRepeating("DebugNavGrid", 0, 10f); //TODO: Replace this so it only updates on a new turn.
Pathfinding = new Pathfinding(NavGrid);
nodeCache = new List <Node>(NavGrid.GetLength(0) * NavGrid.GetLength(1));
}
private void LoadTileMap()
{
if (string.IsNullOrEmpty(MapName) || !Content.Exists(MapName))
{
return;
}
var serial = new TiledDeserializer(new TiledDeserializerOptions((s) => Content.OpenAsStream(s, StreamFlags.None), VirtualFileSystem.Combine));
var map = serial.LoadTileMap(MapName);
var lookup = new XenkoTileLookup(map, Content);
var tileSets = new List <Xenko.TileSet>();
foreach (var tileSet in map.TileSets)
{
var xenkoTileSet = new TilemapTools.Xenko.TileSet();
var texture = lookup.GetTexture(tileSet.Image);
var columns = tileSet.Columns.GetValueOrDefault(1);
for (int localId = 0; localId < tileSet.TileCount; localId++)
{
var x = localId % columns;
var y = localId / columns;
var left = x * (tileSet.TileWidth + tileSet.Spacing) + tileSet.Margin;
var top = y * (tileSet.TileHeight + tileSet.Spacing) + tileSet.Margin;
var rect = new SiliconStudio.Core.Mathematics.Rectangle();
rect.X = left;
rect.Y = top;
rect.Width = tileSet.TileWidth;
rect.Height = tileSet.TileHeight;
xenkoTileSet.Tiles.Add(new TilemapTools.Xenko.Tile(texture, rect));
}
tileSets.Add(xenkoTileSet);
}
var firstGlobalId = map.TileSets[0].FirstGlobalId;
float layerDepth = 0;
foreach (var layer in map.Layers.OfType <Layer>())
{
var tileMapComponent = new TileMapComponent();
tileMapComponent.Grid.CellSize = new Vector2(1.5f);
tileSets.ForEach(ts => tileMapComponent.Grid.TileSets.Add(ts));
int x = -map.Width / 2;
int y = map.Height / 2;
for (int my = 0; my < map.Height; my++)
{
for (int mx = 0; mx < map.Width; mx++)
{
var layerTile = layer.Tiles[map.Width * my + mx];
if (!layerTile.IsEmpty)
{
tileMapComponent.Grid[x, y] = new TileReference((byte)lookup.FindTileSetIndex(layerTile.GlobalId), (short)(layerTile.GlobalId - firstGlobalId));
}
x++;
if (x == 0)
{
x++;
}
}
x = -map.Width / 2;
y--;
if (y == 0)
{
y--;
}
}
//tileMapComponent.Sampler = TileMapComponent.TileMapSampler.LinearClamp;
tileMapComponent.Color = new Color4(1, 1, 1, 1) * (float)layer.Opacity; //PreMulitplied Alpha
tileMapComponent.FramesPerSecond = layer.Property <int>("FramesPerSecond");
var layerEntity = new Entity()
{
tileMapComponent,
};
layerEntity.Transform.Position = new Vector3(0, 0, layerDepth);
if (layer.Property <bool>("CollisionEnabled"))
{
var physicsShapeBuilder = new MinimumPhysicsShapeBuilder();
var staticColliderComponent = new StaticColliderComponent();
staticColliderComponent.Restitution = 0;
physicsShapeBuilder.Update(tileMapComponent.Grid, staticColliderComponent);
layerEntity.Add(staticColliderComponent);
}
layers.Add(tileMapComponent);
Entity.AddChild(layerEntity);
layerDepth += 1f;
}
}
public void RemoveTiles(TileMapComponent tileMapComponent, HashSet <Vector2Int> lstClear, float time = 0.5f)
{
var tileSprawnComponent = World.GetSingletonComponent <TileSprawnComponent>();
foreach (Vector2Int pos in lstClear)
{
RemoveTile(tileMapComponent, pos, time);
}
int maxRow = tileMapComponent.rowCount;
int maxColumn = tileMapComponent.columnCount;
var lstMovePos = ResetObjectPool <HashSet <Vector2Int> > .Instance.GetObject();
var dicMinNullColumnToRow = ResetObjectPool <Dictionary <int, int> > .Instance.GetObject();
for (int i = 0; i < maxColumn; i++)
{
dicMinNullColumnToRow.Add(i, maxRow);
}
foreach (Vector2Int pos in lstClear)
{
var clearEntity = tileMapComponent.entities[pos.x, pos.y];
if (clearEntity != Entity.Null)
{
continue;
}
int row = pos.x + 1;
int nullRow = pos.x;
while (row < maxRow)
{
var entity = tileMapComponent.entities[row, pos.y];
if (entity != Entity.Null)
{
var nullPos = new Vector2Int(nullRow, pos.y);
var curEntityPos = new Vector2Int(row, pos.y);
SwapTile(tileMapComponent, nullPos, curEntityPos);
nullRow++;
}
row++;
}
if (dicMinNullColumnToRow[pos.y] > nullRow)
{
dicMinNullColumnToRow[pos.y] = nullRow;
}
}
var lstCfg = ResCfgSys.Instance.GetCfgLst <ResTile>();
foreach (var item in dicMinNullColumnToRow)
{
var column = item.Key;
var startNullRow = item.Value;
for (int i = 0; i < startNullRow; i++)
{
if (startNullRow < maxRow)
{
lstMovePos.Add(new Vector2Int(i, column));
}
}
for (int i = startNullRow; i < maxRow; i++)
{
var index = Random.Range(0, lstCfg.Count);
var cfg = lstCfg[index];
var worldPos = GetTileWorldPosition(tileMapComponent, new Vector2Int(maxRow + i - startNullRow, column));
var entity = CreateTile(cfg, worldPos);
tileMapComponent.entities[i, column] = entity;
var newEntityPos = new Vector2Int(i, column);
lstMovePos.Add(newEntityPos);
}
}
tileSprawnComponent.lstDownPos.Clear();
foreach (var pos in lstMovePos)
{
var entity = tileMapComponent.entities[pos.x, pos.y];
var prefabComponent = World.GetComponent <PrefabComponent>(entity);
tileMoveSystem.MoveTile(entity, prefabComponent.trans.position, GetTileWorldPosition(tileMapComponent, pos), tileSprawnComponent.downDuration, 0.3f);
tileSprawnComponent.lstDownPos.Add(pos);
}
tileSprawnComponent.isTileDowning = true;
ResetObjectPool <HashSet <Vector2Int> > .Instance.SaveObject(lstMovePos);
ResetObjectPool <Dictionary <int, int> > .Instance.SaveObject(dicMinNullColumnToRow);
}
private void CheckState(TileMapComponent tileMapComponent, byte[,] stateCaches, int row, int column)
{
var entities = tileMapComponent.entities;
var curEntity = entities[row, column];
var curTileComponent = World.GetComponent <TileComponent>(curEntity);
var curTileId = curTileComponent.tileId;
var maxRow = stateCaches.GetLength(0);
var maxColumn = stateCaches.GetLength(1);
int left = column - 1;
while (left >= 0)
{
if (!CheckOnePosState(entities, stateCaches, row, left, curTileId, TileCheckState.RowChecked))
{
break;
}
left = left - 1;
}
int right = column + 1;
while (right < maxColumn)
{
if (!CheckOnePosState(entities, stateCaches, row, right, curTileId, TileCheckState.RowChecked))
{
break;
}
right = right + 1;
}
var rowCount = right - left - 1;
if (rowCount >= tileMapComponent.minRemoveCount)
{
UpdateState(stateCaches, row, row, left + 1, right - 1, TileCheckState.CheckedSuccess, false);
}
else
{
UpdateState(stateCaches, row, row, left + 1, right - 1, TileCheckState.RowChecked, false);
}
int bottom = row - 1;
while (bottom >= 0)
{
if (!CheckOnePosState(entities, stateCaches, bottom, column, curTileId, TileCheckState.ColumnChecked))
{
break;
}
bottom = bottom - 1;
}
int up = row + 1;
while (up < maxRow)
{
if (!CheckOnePosState(entities, stateCaches, up, column, curTileId, TileCheckState.ColumnChecked))
{
break;
}
up = up + 1;
}
var columnCount = up - bottom - 1;
if (columnCount >= tileMapComponent.minRemoveCount)
{
UpdateState(stateCaches, bottom + 1, up - 1, column, column, TileCheckState.CheckedSuccess, false);
}
else
{
UpdateState(stateCaches, bottom + 1, up - 1, column, column, TileCheckState.ColumnChecked, false);
}
}
