void ApplayObstacleLightUpdate()
{
if (ScreenUpdateManager.GetChangeObstacleLight())
{
var addSize = obstacleLight.layerData.SizeAdd;
for (int i = 0; i < countTileX + 2 * addSize - 1; i++)
{
for (int j = 0; j < countTileY + 2 * addSize - 1; j++)
{
if (!ScreenUpdateManager.IsUpdateOffsetObstacleLight(i, j))
{
continue;
}
var x = p1.x + i * tileSize - (tileSize * addSize);
var y = p1.y + j * tileSize - (tileSize * addSize);
var tileStructure = tileDataProvider.GetTileStructure(x, y);
var frameStructure = tileDataProvider.GetFrameStructure(x, y, tileStructure, obstacleLight.layerData);
obstacleLight.ChangeTile(j, i, frameStructure.TileCollection, frameStructure.FrameX, frameStructure.FrameY, frameStructure.DeltaHeight);
ScreenUpdateManager.EndDrawObstacleLightTile(i, j);
}
}
obstacleLight.RenderMesh();
ScreenUpdateManager.SetChangeObstacleLight(false);
}
}
public bool AddItem(short id, Vector2 worldPos, bool useNeighbors = true)
{
var offset = tileDataProvider.WorldPosToOffsetTile(worldPos);
var rez = AddItem(id, offset.x, offset.y, useNeighbors);
//ebug.LogError(rez);
ScreenUpdateManager.RedrawFullScreenLight();
return(rez);
}
public void OnInject()
{
tileDataProvider = TileDataProvider;
//this.Inject();
UpdateScreenTiles();
Container.Inject(tileDataProvider);
tileDataProvider.Init(this, tileSize);
tixtuteGO = new GameObject("tixtuteGO");
foreach (var layer in LayerData.Layers)
{
GameObject layerGO = new GameObject(layer.Name);
layerGO.transform.SetParent(tixtuteGO.transform, false);
// layerGO.transform.localPosition = new Vector3(0, 0, /*-layer.Depth*/0);
layerGO.layer = LayerMask.NameToLayer(layer.LayerName);
IInfinityTileMap layerMesh = (IInfinityTileMap)Activator.CreateInstance(layer.RenderType);
Container.Inject(layerMesh);
if (layer == LayerData.ObstacleLightLayer)
{
obstacleLight = layerMesh;
}
else
if (layer == LayerData.LightLayer)
{
lightLayer = layerMesh;
}
else
{
}
if (layer != LayerData.ObstacleLightLayer)
{
layerMeshs.Add(layerMesh);
}
//
layerMesh.LoadMesh(layerGO, (int)(countTileX) + 2 * layer.SizeAdd, (int)(countTileY) + 2 * layer.SizeAdd, tileSize, layer);
layerMesh.SetLayer(layer.Depth);
layerGO.transform.localPosition = new Vector3(-layer.SizeAdd * tileSize, -layer.SizeAdd * tileSize, 0);
}
SpriteManager.SetTileMap(layerMeshs[0]);
var centerPos = MapGenerator.CenterPos;
camera.transform.position = new Vector3(centerPos.x * tileSize, centerPos.y * tileSize, camera.transform.position.z);
ScreenUpdateManager.Init((int)(countTileX), (int)(countTileY));
// Debug.LogErrorFormat("({0}, {1})",Screen.width, Screen.height);
}
void ApplayScreenUpdateLight()
{
//return;
if (ScreenUpdateManager.GetChangeLight())
{
LightRenderer.CalculateChangeScreen(ScreenUpdateManager.GetLightUptateWorldMin(), ScreenUpdateManager.GetLightUptateWorldMax());
LightLayerRender();
ScreenUpdateManager.EndUpdateLight();
}
}
void ApplayScreenUpdate()
{
if (ScreenUpdateManager.GetApplayChanges())
{
for (int i = 0; i < countTileX - 1; i++)
{
for (int j = 0; j < countTileY - 1; j++)
{
if (!ScreenUpdateManager.IsUpdateOffset(i, j))
{
continue;
}
var x = p1.x + i * tileSize;
var y = p1.y + j * tileSize;
var tileStructure = tileDataProvider.GetTileStructure(x, y);
for (int ii = 0; ii < layerMeshs.Count; ii++)
{
if (layerMeshs[ii] == lightLayer)
{
continue;
}
if (ScreenUpdateManager.IsUpdate(layerMeshs[ii].layerData.Id, i, j))
{
var frameStructure = tileDataProvider.GetFrameStructure(x, y, tileStructure, layerMeshs[ii].layerData);
layerMeshs[ii].ChangeTile(j, i, frameStructure.TileCollection, frameStructure.FrameX, frameStructure.FrameY, frameStructure.DeltaHeight);
ScreenUpdateManager.EndDrawScreenTile(layerMeshs[ii].layerData.Id, i, j);
}
}
}
}
for (int i = 0; i < layerMeshs.Count; i++)
{
if (layerMeshs[i] == lightLayer)
{
continue;
}
layerMeshs[i].RenderMesh();
}
ScreenUpdateManager.SetApplayChanges(false);
}
// ApplayObstacleLightUpdate();
}
public int RemoveItem(Vector2Int offset)
{
// Debug.LogError("RemoveItem");
var rez = RemoveItem(offset.x, offset.y);
if (rez != 0)
{
var worldPos = tileDataProvider.OffsetTileToWorldPos(offset);
ItemManager.CreateItem <TorchPoolItem>(worldPos);
ScreenUpdateManager.RedrawFullScreenLight();
}
return(rez);
}
//вернёт id предмета который удалили или 0
public int RemoveItem(Vector2 worldPos)
{
// Debug.LogError("RemoveItem");
var offset = GetItemCenter(worldPos);
if (offset.x < 0 && offset.y < 0)
{
return(0);
}
var rez = RemoveItem(offset.x, offset.y);
if (rez != 0)
{
ItemManager.CreateItem <TorchPoolItem>(worldPos);
ScreenUpdateManager.RedrawFullScreenLight();
}
return(rez);
}
//покачто используется только для удаления дерева
void SetTile(int x, int y, short type)
{
var map = mapGenerator.GetMap();
if (!mapGenerator.GetMap()[x, y].IsTreeTop() && mapGenerator.GetMap()[x, y].IsTree())
{
var block = ItemManager.CreateBlock(new Vector2(x * TileSize - 2f * TileSize, y * TileSize - 2f * TileSize),
SpriteData.Tiles_wood.Name);
block.blockLayer = 0;
block.blockType = SpriteData.Tiles_wood.TypeId;
block.blockTileCollection = SpriteData.Tiles_wood.Name;
map[x, y].randomTile = (short)Random.Range(0, 3);
}
map[x, y].type = type;
ScreenUpdateManager.RedrawWorldTile3X(0, x, y);
ScreenUpdateManager.RedrawWorldTile3X(1, x, y);
ScreenUpdateManager.RedrawWorldTile3X(2, x, y);
ScreenUpdateManager.RedrawWorldTile3X(4, x, y);
}
public void Update()
{
// return;
time += Time.fixedDeltaTime * dirTime;
if (time > maxTime)
{
// return;
}
if (time < 0)
{
time = 0;
dirTime = 1;
}
if (time > maxTime)
{
time = maxTime;
dirTime = -1;
}
// Debug.LogError(time);
var newTime = (byte)(ColorByte.white.A * (time / maxTime));
var oldTime = (byte)(ColorByte.white.A * (currTime));
if (newTime != oldTime)
{
//if (currTime != 0.9f){
currTime = time / maxTime;
ScreenUpdateManager.RedrawFullScreenLight();
}
//Debug.LogError(newTime);
float val = Mathf.Clamp(currTime, 0, 0.6f);
camera.backgroundColor = new Color(val, val, val, 1);
BackgroundManager.SetTime(currTime);
}
private void SetCount(Vector2Int pos, byte val)
{
if (mapGen.IsValidPoint(pos))
{
mapGen.GetMap()[pos.x, pos.y].count = val;
if (ScreenUpdateManager != null)
{
ScreenUpdateManager.RedrawWorldTile3X(1, pos.x, pos.y);
}
if (SwapItemManager != null && val != 0)
{
var id = mapGen.GetMap()[pos.x, pos.y].ItemId;
if (id != 0 && !ItemData.GetById(id).InWater)
{
SwapItemManager.RemoveItem(pos);
}
}
// if (mapGen.Map[pos.x, pos.y].count == Settings.WATER_COUNT) {
//mapGen.Map[pos.x, pos.y].lighted = false;
// }
}
}
public void ChangeTile(Vector2Int offset, short tileType, byte layer, byte liquidType = 0)
{
int offsetX = offset.x;
int offsetY = offset.y;
var currentPoint = new Vector2Int(offsetX, offsetY);
var upPoint = new Vector2Int(offsetX, offsetY + 1);
var downPoint = new Vector2Int(offsetX, offsetY - 1);
var map = mapGenerator.GetMap();
if (mapGenerator.IsValidPoint(currentPoint))
{
if (map[currentPoint.x, currentPoint.y].IsTreeTop())
{
return;
}
liquid.ChackNeighborInactive(currentPoint);
bool isChangeType = false;
bool isCurrentTree = map[currentPoint.x, currentPoint.y].type == (short)TileTypeEnum.Tree ||
map[currentPoint.x, currentPoint.y].type == (short)TileTypeEnum.TreeBody;
if (mapGenerator.IsValidPoint(upPoint))
{
if (!isCurrentTree && (map[upPoint.x, upPoint.y].type == (short)TileTypeEnum.Tree || map[upPoint.x, upPoint.y].type == (short)TileTypeEnum.TreeBody))
{
return;
}
}
//if (offsetX >= 0 && offsetY >= 0 && offsetX <= countTileMapX && offsetY <= countTileMapY) {
if (!isCurrentTree || liquidType != 0)
{
//удаляем заросли (если прямиком в джунгли попали)
if (Map[currentPoint.x, currentPoint.y].IsDecor())
{
mapGenerator.RemoveLineDown(currentPoint, new List <short>()
{
(short)TileTypeEnum.Jungle
});
mapGenerator.RemoveLineUp(currentPoint, new List <short>()
{
(short)TileTypeEnum.Grass1, (short)TileTypeEnum.Grass2
});
}
if (liquidType == 0)
{
/*if (tileType != 0 && isCurrentTree) {
* return;
* }*/
if (map[offsetX, offsetY].type == tileType)
{
return;
}
if (map[offsetX, offsetY].type != tileType)
{
isChangeType = true;
}
map[offsetX, offsetY].type = tileType;
map[offsetX, offsetY].layer = layer;
//map[offsetX, offsetY].count = 0;
ScreenUpdateManager.RedrawWorldTile3X(1, offsetX, offsetY);
ScreenUpdateManager.RedrawWorldTile3X(0, offsetX, offsetY);
ScreenUpdateManager.RedrawWorldTile3X(2, offsetX, offsetY);
ScreenUpdateManager.RedrawWorldTile3X(4, offsetX, offsetY);
}
else
{
if (map[offsetX, offsetY].IsWater())
{
map[offsetX, offsetY].count = (byte)Settings.WATER_COUNT;
if (ScreenUpdateManager != null)
{
ScreenUpdateManager.RedrawWorldTile3X(1, offsetX, offsetY);
}
return;
}
if (!map[offsetX, offsetY].CanPourWater())
{
map[offsetX, offsetY].type = 0;
isChangeType = true;
}
if (liquidType == 1)
{
map[offsetX, offsetY].ChackWater(true);
liquid.AddWater(new Vector2Int(offsetX, offsetY));
}
}
//удаляем заросли (если удалили не заросли а они на нём стояли)
if (isChangeType)
{
mapGenerator.RemoveLineDown(downPoint, new List <short>()
{
(short)TileTypeEnum.Jungle
});
mapGenerator.RemoveLineUp(upPoint, new List <short>()
{
(short)TileTypeEnum.Grass1, (short)TileTypeEnum.Grass2
});
}
}
else
if (isCurrentTree && tileType == 0)
{
if (map[currentPoint.x, currentPoint.y].type != (short)TileTypeEnum.Tree_Top &&
map[currentPoint.x, currentPoint.y].type != (short)TileTypeEnum.TreeTopNaked)
{
//изза особенности дерева не оставляем пенёк из одного тайла
int LenghtTree = mapGenerator.GetLenghtDown(currentPoint, (short)TileTypeEnum.Tree);
if (LenghtTree > 0)
{
mapGenerator.RemoveContactsUp(currentPoint,
new List <short>()
{
(short)TileTypeEnum.Tree, (short)TileTypeEnum.TreeBody, (short)TileTypeEnum.TreeTopNaked, (short)TileTypeEnum.Tree_Top
});
if (LenghtTree == 2)
{
mapGenerator.RemoveContactsDown(downPoint,
new List <short>()
{
(short)TileTypeEnum.Tree, (short)TileTypeEnum.TreeBody
});
}
}
}
}
}
}
void Update()
{
if (LightUvProvider != null)
{
LightUvProvider.LateUpdate();
}
if (tileDataProvider == null)
{
return;
}
if (Input.GetKeyUp(KeyCode.T))
{
LightRenderer.Test();
LightLayerRender(true);
}
if (Input.GetKeyUp(KeyCode.G))
{
MapGenerator.ChangeMap();
}
if (Input.GetKeyUp(KeyCode.Alpha0))
{
carrentMarkerType = 0;
carrentMarkerLayer = 0;
}
if (Input.GetKeyUp(KeyCode.Alpha8))
{
carrentMarkerType = 8;
carrentMarkerLayer = 3;
}
if (Is_Edit_mod)
{
if (Input.GetMouseButton(0))
{
countClick++;
var pos = camera.ScreenToWorldPoint(Input.mousePosition);
tileDataProvider.СircleDamageTile(pos.x + 1.5f * tileSize, pos.y + 1.5f * tileSize, carrentMarkerType,
carrentMarkerLayer, carrentMarkeLiquidType, 1);
lastP1 = new Vector3();
UpdateScreenTiles();
// Render();
}
if (Input.GetMouseButton(1))
{
var pos = camera.ScreenToWorldPoint(Input.mousePosition);
var tile = tileDataProvider.GetTileStructure(pos.x + 1.5f * tileSize, pos.y + 1.5f * tileSize);
// pos.x, pos.y);
carrentMarkerType = tile.type;
carrentMarkerLayer = tile.layer;
carrentMarkeLiquidType = tile.liquidType;
}
}
if (Input.GetKeyUp(KeyCode.R))
{
tileDataProvider.LoadNext();
lastP1 = new Vector3();
UpdateScreenTiles();
// Render();
}
//Profiler.BeginSample("1");
UpdateScreenTiles();
//Profiler.EndSample();
//Profiler.BeginSample("2");
ApplayScreenUpdate();
//Profiler.EndSample();
//Profiler.BeginSample("3");
Render();
//Profiler.EndSample();
//Profiler.BeginSample("4");
if (useLight)
{
ApplayScreenUpdateLight();
}
//Profiler.EndSample();
LightRenderer.Update();
ScreenUpdateManager.RedrawFullScreenLight();
}
public void Render()
{
p1 = camera.ViewportToWorldPoint(new Vector3(0, 0, camera.nearClipPlane));
int offsetX = Mathf.CeilToInt(p1.x / tileSize);
int offsetY = Mathf.CeilToInt(p1.y / tileSize);
Vector3 newPos = new Vector2(offsetX * tileSize - 2 * tileSize, offsetY * tileSize - 2 * tileSize);
int dist = (int)Vector2.Distance(lastP1, newPos);
if (dist >= tileSize)
{
Vector2 delta = newPos - lastP1;
var deltaX = (int)(Mathf.Sign(delta.x) * Mathf.CeilToInt(Mathf.Abs(delta.x / tileSize)));
var deltaY = (int)(Mathf.Sign(delta.y) * Mathf.CeilToInt(Mathf.Abs(delta.y / tileSize)));
lastP1 = newPos;
screenStart = new Vector2Int(Mathf.CeilToInt(p1.x / tileSize), Mathf.CeilToInt(p1.y / tileSize));
screenEnd = new Vector2Int((int)(screenStart.x + countTileX), (int)(screenStart.y + countTileY));
ScreenUpdateManager.SetScreenRect(screenStart, screenEnd);
LightRenderer.SetScreenRect(screenStart, screenEnd);
var add = obstacleLight.layerData.SizeAdd;
SwapItemManager.SetSize(screenEnd.x - screenStart.x + 2 * add, screenEnd.y - screenStart.y + 2 * add);
//SwapItemManager.SetStartPos(new Vector2Int(screenStart.x - add, screenStart.y - add));
//определяем свапнутую область
int swapStartX = 0;
int swapEndX = Mathf.CeilToInt(countTileX);
int swapStartY = 0;
int swapEndY = Mathf.CeilToInt(countTileY);
if (deltaX > 0)
{
swapStartX = 0;
swapEndX = Mathf.CeilToInt(countTileX - deltaX) - 3;
}
if (deltaX < 0)
{
swapStartX = -(int)deltaX;
swapEndX = Mathf.CeilToInt(countTileX);
}
if (deltaY > 0)
{
swapStartY = 0;
swapEndY = Mathf.CeilToInt(countTileY - deltaY) - 3;
}
if (deltaY < 0)
{
swapStartY = -(int)deltaY;
swapEndY = Mathf.CeilToInt(countTileY);
}
for (int ii = 0; ii < layerMeshs.Count; ii++)
{
layerMeshs[ii].ShiftCells((int)deltaX, (int)deltaY);
}
obstacleLight.ShiftCells((int)deltaX, (int)deltaY);
LightRenderer.Swap((int)deltaX, (int)deltaY); // -<
SwapItemManager.SetStartPos(new Vector2Int(screenStart.x - add, screenStart.y - add));
SwapItemManager.Swap((int)deltaX, (int)deltaY);
for (int i = 0; i < countTileX - 1; i++)
{
for (int j = 0; j < countTileY - 1; j++)
{
bool inSwapRect = i >= swapStartX && i <= swapEndX &&
j >= swapStartY && j <= swapEndY;
if (inSwapRect)
{
continue;
}
var x = p1.x + i * tileSize;
var y = p1.y + j * tileSize;
var tileStructure = tileDataProvider.GetTileStructure(x, y);
for (int ii = 0; ii < layerMeshs.Count; ii++)
{
var frameStructure = tileDataProvider.GetFrameStructure(x, y, tileStructure, layerMeshs[ii].layerData);
layerMeshs[ii].ChangeTile(j, i, frameStructure.TileCollection, frameStructure.FrameX, frameStructure.FrameY, frameStructure.DeltaHeight);
}
}
}
for (int i = 0; i < layerMeshs.Count; i++)
{
layerMeshs[i].RenderMesh();
}
// RenderLayerAddSize(obstacleLight, obstacleLight.layerData.SizeAdd, deltaX, deltaY); // -<
tixtuteGO.transform.position = newPos;
OnSwap.TryCall();
}
}
