public void AddLight(LevelTilemap level, BaseLevelTile lightSource)
{
//lightSources.Add(lightSource.x + lightSource.y * level.sizeX, lightSource as LevelTile_Dig);
light += CalcuateLight(lightSource as LevelTile_Dig);
viewNeedUpdate = true;
lightSource.onRemove += RemoveLight;
}
public override void ActionOnTile(BaseLevelTile tile)
{
base.ActionOnTile(tile);
var digTilemap = target as Tilemap_Dig;
digTilemap.ApplyDamage(tile.pos, Vector3.up, type, damage);
}
public override void UpdateViewTile(BaseLevelTile tile)
{
base.UpdateViewTile(tile);
var backgroundTile = (tile.data as Tile_SideViewData).backgroundTile;
background.SetTile(vec3IntTemp, backgroundTile);
}
public void RemoveLight(LevelTilemap level, BaseLevelTile lightSource)
{
//lightSources.Remove(lightSource.x + lightSource.y * level.sizeX);
light -= CalcuateLight(lightSource as LevelTile_Dig);
viewNeedUpdate = true;
lightSource.onRemove -= RemoveLight;
}
public override void Init(LevelTilemap map, BaseLevelTile tile)
{
base.Init(map, tile);
if (go != null)
{
map.AddGameObjectToTile(tile, go);
}
}
public override void UpdateViewTile(BaseLevelTile tile)
{
if (tile.viewNeedUpdate == false)
{
return;
}
base.UpdateViewTile(tile);
}
public override string TileText(BaseLevelTile tile)
{
var digTile = tile as LevelTile_Dig;
if (digTile == null)
{
return(base.TileText(tile));
}
return("Light: " + digTile.GetLight().ToString() + " InSunLight: " + digTile.inSunLight.ToString());
}
public override void LoadTileFirstTime(BaseLevelTile tile)
{
base.LoadTileFirstTime(tile);
vec3IntTemp.x = tile.pos.x;
vec3IntTemp.y = tile.pos.y;
vec3IntTemp.z = 0;
var backgroundTile = (tile.data as Tile_SideViewData).backgroundTile;
background.SetTile(vec3IntTemp, backgroundTile);
}
public override string TileText(BaseLevelTile tile)
{
var digTile = tile as LevelTile_Dig;
if (digTile == null)
{
return(base.TileText(tile));
}
return("Heat: " + digTile.GetHeat().ToString());
}
public virtual void LoadTileFirstTime(BaseLevelTile tile)
{
if (useLUT)
{
UpdateRenderTexutre(tile);
}
if (onLoadTileFirstTime != null)
{
onLoadTileFirstTime(this, tile);
}
}
public override Color GetLookUpTextureColor(BaseLevelTile tile)
{
var water = (float)(tile as LevelTile_Dig).GetWaterAmount() / LevelTile_Dig.maxWater;
if (IsPosOutOfBound(tile.x, tile.y + 1) == false && (tile as LevelTile_Dig).isWalkable == false && GetTile <LevelTile_Dig>(tile.x, tile.y + 1).HasWater())
{
water = 1;
}
return(new Color(1, water, (tile as LevelTile_Dig).sunLight, (tile as LevelTile_Dig).GetLight(true)));
}
public virtual void ChangedTile(BaseLevelTile tile)
{
if (tile.HaveBehaviorUpdate())
{
updateTiles.Add(tile);
}
if (tile.HaveBehaviorViewUpdate())
{
updateTilesInView.Add(tile);
}
}
public virtual void LoadChunkFirstTime(int cx, int cy)
{
var chunk = GetTileMap(cx, cy);
if (chunk.isLoaded == true)
{
return;
}
var tiles = new TileBase[chunkSize * chunkSize];
var pos = new Vector3Int[chunkSize * chunkSize];
BaseLevelTile tileTemp = null;
TileBase tileViewTemp = null;
LevelTileData dataTemp = null;
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
vec3IntTemp.x = x + cx * chunkSize;
vec3IntTemp.y = y + cy * chunkSize;
tileTemp = GetITile(vec3IntTemp.x, vec3IntTemp.y);
if (tileTemp != null)
{
dataTemp = tileTemp.data;
}
if (dataTemp != null)
{
tileViewTemp = tileTemp.data.tile;
LoadTileFirstTime(tileTemp);
}
if (tileViewTemp != null)
{
tiles[x + y * chunkSize] = tileViewTemp;
pos[x + y * chunkSize] = vec3IntTemp;
}
else
{
tiles[x + y * chunkSize] = null;
pos[x + y * chunkSize] = vec3IntTemp;
}
dataTemp = null;
tileViewTemp = null;
}
}
chunk.isLoaded = true;
SetTiles(pos, tiles);
}
public override void DestroyTile(BaseLevelTile tile)
{
base.DestroyTile(tile);
LevelTile_Dig tileAbove = GetTile <LevelTile_Dig>(tile.pos.x, tile.pos.y + 1);
if (tileAbove.inSunLight == true)
{
LightOnPos(tile.pos.x, tile.pos.y, true);
}
else
{
ShadowOnPos(tile.pos.x, tile.pos.y);
}
}
public override void ActionOnTile(BaseLevelTile tile)
{
base.ActionOnTile(tile);
var digTilemap = target as Tilemap_Dig;
var digTile = tile as LevelTile_Dig;
if (waterAmout > 0)
{
digTile.AddWater(target, waterAmout);
}
else
{
digTile.RemoveWater(target, -waterAmout);
}
}
public override void LoadTileFirstTime(LevelTilemap levelTilemap, BaseLevelTile tile)
{
base.LoadTileFirstTime(levelTilemap, tile);
var chunkPos = levelTilemap.PosToChunk(tile.x, tile.y);
var inChunkPos = levelTilemap.PosToPosInChunk(tile.x, tile.y);
var data = tile.data;
var fluidData = data as IFluidData;
collisionDrawer.SetInt("_CollisionTilePosX", inChunkPos.x);
collisionDrawer.SetInt("_CollisionTilePosY", inChunkPos.y);
collisionDrawer.SetTexture("_CollisionTex", fluidData.Collision());
var targetRT = GetRenderAllTexutre(chunkPos.x, chunkPos.y);
Graphics.Blit(targetRT, chunkBufferRT, collisionDrawer);
Graphics.Blit(chunkBufferRT, targetRT);
}
public override void LoadTileFirstTime(BaseLevelTile tile)
{
base.LoadTileFirstTime(tile);
waterTileMap.SetTile(IndexToTilemap(tile.pos), waterTile);
lightMap.SetTile(IndexToTilemap(tile.pos), lightTile);
var data = tile.data;
if (data == null)
{
return;
}
var digData = data as LevelTileData_Dig;
if (digData == null)
{
return;
}
SetBackground(tile.x, tile.y, digData.GetBackgroundTile(this, tile.x, tile.y));
}
public override void Remove(LevelTilemap map, BaseLevelTile tile)
{
base.Remove(map, tile);
map.RemoveLinks(size, tile);
}
void RemoveHeat(LevelTilemap level, BaseLevelTile heatSource)
{
RemoveHeatPath(level, heatSource);
heatSource.onRemove -= RemoveHeat;
viewNeedUpdate = true;
}
int CalculateHeat(LevelTilemap level, BaseLevelTile heatSource, bool addActions = false, bool removeAction = false)
{
var sourceData = heatSource.data as LevelTileData_Dig;
if (sourceData == null)
{
return(0);
}
var heat = sourceData.emitHeat;
var dir = (new Vector2(x, y) - new Vector2(heatSource.x, heatSource.y));
var dist = dir.magnitude;
dir.Normalize();
var start = heatSource.pos;
BaseLevelTile pathTile = null;
if (addActions)
{
if (removeAction == false)
{
heatPreActions.Add(heatSource, (LevelTilemap, BaseLevelTile) => RecaclucateHeatPathPre(level, null, heatSource));
heatPostActions.Add(heatSource, (LevelTilemap, BaseLevelTile) => RecaclucateHeatPathPost(level, null, heatSource));
}
}
for (int i = 0; i < (int)dist; i++)
{
pathTile = level.GetITile((int)(start.x + .5f + dir.x * i), (int)(start.y + .5f + dir.y * i));
if (pathTile == this || pathTile == heatSource)
{
continue;
}
var pathData = pathTile.data as LevelTileData_Dig;
if (pathData == null)
{
continue;
}
if (addActions)
{
if (addActions)
{
if (removeAction)
{
pathTile.onRemove -= heatPreActions[heatSource];
pathTile.onInit -= heatPostActions[heatSource];
}
else
{
pathTile.onRemove += heatPreActions[heatSource];
pathTile.onInit += heatPostActions[heatSource];
}
}
}
heat = (int)(heat * 1 - pathData.heatAbsorption);
}
if (addActions)
{
if (removeAction)
{
heatPreActions.Remove(heatSource);
heatPostActions.Remove(heatSource);
}
}
return(heat);
}
void RemoveHeatPath(LevelTilemap level, BaseLevelTile heatSource)
{
heat -= CalculateHeat(level, heatSource, true, true);
}
public virtual void LoadTileFirstTime(LevelTilemap levelTilemap, BaseLevelTile tile)
{
}
void AddHeatPath(LevelTilemap level, BaseLevelTile heatSource)
{
heat += CalculateHeat(level, heatSource, true);
}
public void AddHeat(LevelTilemap level, BaseLevelTile heatSource)
{
heatSource.onRemove += RemoveHeat;
AddHeatPath(level, heatSource);
viewNeedUpdate = true;
}
public virtual void ActionOnTile(BaseLevelTile tile)
{
}
public override void ActionOnTile(BaseLevelTile tile)
{
base.ActionOnTile(tile);
target.OverrideTile(tile.pos, data);
}
public virtual void Remove(LevelTilemap map, BaseLevelTile tile)
{
}
public override void Init(LevelTilemap map, BaseLevelTile tile)
{
base.Init(map, tile);
map.SetLinks(size, tile);
}
void RecaclucateHeatPathPost(LevelTilemap level, BaseLevelTile dontNeeded, BaseLevelTile heatSource)
{
heat += CalculateHeat(level, heatSource);
}
public virtual void InitTile(LevelTilemap levelTilemap, BaseLevelTile tile)
{
}
