// Update is called once per frame
void Update()
{
if (powered == false)
{
current.sprite = nopower;
}
else
{
current.sprite = power;
}
if (main == true && changed == false)
{
if (target1.GetComponent <ControlStone> ().powered == true &&
target2.GetComponent <ControlStone> ().powered == true &&
target3.GetComponent <ControlStone> ().powered == true &&
target4.GetComponent <ControlStone> ().powered == true &&
target5.GetComponent <ControlStone> ().powered == true &&
target6.GetComponent <ControlStone> ().powered == true)
{
powered = true;
MyAutoTileMap.SetAutoTile(24, 31, 35, 0, true);
MyAutoTileMap.SetAutoTile(24, 32, 35, 0, true);
MyAutoTileMap.SetAutoTile(24, 30, 35, 0, true);
Destroy(GameObject.FindGameObjectWithTag("Knight"));
knight = Instantiate(knight);
knight.transform.position = new Vector3(7.84f, -8.8f, -0.4f);
changed = true;
RpgMapEditor.RpgMapHelper.RemoveFogOfWar(transform.position, 25);
}
}
}
public void DoAction(AutoTileMap _autoTileMap)
{
int tileMinX = _autoTileMap.MapTileWidth - 1;
int tileMinY = _autoTileMap.MapTileHeight - 1;
int tileMaxX = 0;
int tileMaxY = 0;
for (int i = 0; i < aTileData.Count; ++i)
{
TileData tileData = aTileData[i];
// save prev tile type for undo action
tileData.Tile_type_prev = _autoTileMap.GetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer).Id;
_autoTileMap.SetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_type, tileData.Tile_layer);
tileMinX = Mathf.Min(tileMinX, tileData.Tile_x);
tileMinY = Mathf.Min(tileMinY, tileData.Tile_y);
tileMaxX = Mathf.Max(tileMaxX, tileData.Tile_x);
tileMaxY = Mathf.Max(tileMaxY, tileData.Tile_y);
}
if (_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled)
{
_autoTileMap.RefreshMinimapTexture(tileMinX, tileMinY, (tileMaxX - tileMinX) + 1, (tileMaxY - tileMinY) + 1);
}
_autoTileMap.UpdateChunks();
}
/// <summary>
/// Load map serialized data into a map
/// </summary>
/// <param name="_autoTileMap"></param>
public IEnumerator LoadToMap(AutoTileMap _autoTileMap)
{
_autoTileMap.Initialize();
_autoTileMap.ClearMap();
if (!Metadata.IsVersionAboveOrEqual("1.2.4"))
{
_applyFixVersionBelow124(_autoTileMap);
}
int totalMapTiles = TileMapWidth * TileMapHeight;
for (int iLayer = 0; iLayer < TileData.Count; ++iLayer)
{
TileLayer tileData = TileData[iLayer];
_autoTileMap.MapLayers.Add(
new AutoTileMap.MapLayer()
{
Name = tileData.Name,
Visible = tileData.Visible,
LayerType = tileData.LayerType,
SortingOrder = tileData.SortingOrder,
SortingLayer = tileData.SortingLayer,
Depth = tileData.Depth,
TileLayerIdx = iLayer,
});
_autoTileMap.TileLayers.Add(new AutoTile[TileMapWidth * TileMapHeight]);
int iTileRepetition = 1;
int iTileIdx = 0;
for (int i = 0; i < tileData.Tiles.Count; ++i)
{
int iType = tileData.Tiles[i];
//see compression notes in CreateFromTilemap
if (iType < -1)
{
iTileRepetition = -iType;
}
else
{
//+++fix: FogOfWar tiles could be < -1, and this is not good for compress system, excepting ids >= -1
if (tileData.LayerType == eLayerType.FogOfWar)
{
iType = (iType << 1); //restore value so the lost bit was the less significant of last byte
}
//---
if (iTileRepetition > totalMapTiles)
{
Debug.LogError("Error uncompressing layer " + tileData.Name + ". The repetition of a tile was higher than map tiles " + iTileRepetition + " > " + totalMapTiles);
iTileRepetition = 0;
}
for (; iTileRepetition > 0; --iTileRepetition, ++iTileIdx)
{
if (iTileIdx % 10000 == 0)
{
//float loadingPercent = ((float)(iTileIdx + iLayer * TileMapWidth * TileMapHeight)) / (TileMapWidth * TileMapHeight * TileData.Count);
//Debug.Log(" Loading " + (int)(loadingPercent * 100) + "%");
yield return(null);
}
int tile_x = iTileIdx % TileMapWidth;
int tile_y = iTileIdx / TileMapWidth;
if (iType >= 0 || tileData.LayerType == eLayerType.FogOfWar)
{
_autoTileMap.SetAutoTile(tile_x, tile_y, iType, iLayer, false);
}
}
iTileRepetition = 1;
}
}
}
_autoTileMap.RefreshAllTiles();
_autoTileMap.UpdateChunkLayersData();
_autoTileMap.RefreshMinimapTexture();
}
void OnTriggerStay(Collider other)
{
PlayerController player = other.GetComponent <PlayerController>();
if (player != null && Input.GetKey(ActivationKey) && !changed)
{
//print (MyAutoTileMap.GetAutoTile (22, 19, 0).Id);
if (MyAutoTileMap.GetAutoTile(20, 19, 0).Id == 163)
{
MyAutoTileMap.SetAutoTile(20, 19, 94, 0, true);
MyAutoTileMap.SetAutoTile(20, 18, 94, 0, true);
MyAutoTileMap.SetAutoTile(19, 19, 94, 0, true);
MyAutoTileMap.SetAutoTile(19, 18, 94, 0, true);
MyAutoTileMap.SetAutoTile(21, 19, 94, 0, true);
MyAutoTileMap.SetAutoTile(21, 18, 94, 0, true);
}
else
{
MyAutoTileMap.SetAutoTile(20, 19, 163, 0, true);
MyAutoTileMap.SetAutoTile(20, 18, 163, 0, true);
MyAutoTileMap.SetAutoTile(19, 19, 163, 0, true);
MyAutoTileMap.SetAutoTile(19, 18, 163, 0, true);
MyAutoTileMap.SetAutoTile(21, 19, 163, 0, true);
MyAutoTileMap.SetAutoTile(21, 18, 163, 0, true);
}
changed = true;
StartCoroutine(wait());
}
}
//Return only 1 TileData has change
public TileData DoAction(AutoTileMap _autoTileMap)
{
TileData onlyChange = null;
//Check is ok with Size Large
{
var brush = aTileData[0];
int tile_id = brush.Tile_id;
if (_autoTileMap.Tileset.IsExitSlot(tile_id))
{
var slot = _autoTileMap.Tileset.GetSlot(tile_id);
if (slot.Size.x > 1 || slot.Size.y > 1)
{
if (brush.Tile_x < 0)
{
Debug.Log("Out Left Map");
return(onlyChange);
}
if (brush.Tile_y < 0)
{
Debug.Log("Out Top Map");
return(onlyChange);
}
if (brush.Tile_x + slot.Size.x > (_autoTileMap.MapTileWidth))
{
Debug.Log("Out Right Map");
return(onlyChange);
}
if (brush.Tile_y + slot.Size.x > (_autoTileMap.MapTileWidth))
{
Debug.Log("Out Bot Map");
return(onlyChange);
}
//Check all tile will be brush don't have other Size Large
for (int x = brush.Tile_x; x < brush.Tile_x + slot.Size.x; x++)
{
for (int y = brush.Tile_y; y < brush.Tile_y + slot.Size.y; y++)
{
int idCheck = _autoTileMap.GetAutoTile(x, y, brush.Tile_layer).Id;
if (_autoTileMap.Tileset.IsExitSlot(idCheck))
{
var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck);
if (slotCheck.Size.x > 1 || slotCheck.Size.y > 1)
{
Debug.Log("Have other Size Large");
return(onlyChange);
}
}
}
}
}
}
}
//
int tileMinX = _autoTileMap.MapTileWidth - 1;
int tileMinY = _autoTileMap.MapTileHeight - 1;
int tileMaxX = 0;
int tileMaxY = 0;
bool HasChangedTile = false;
for (int i = 0; i < aTileData.Count; ++i)
{
TileData tileData = aTileData[i];
// save prev tile type for undo action
// tileData.Tile_type_prev = _autoTileMap.GetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer ).Id;
// if(!_autoTileMap.Tileset.IsExitSlot(tileData.Tile_id)){
// continue;
// }
int idCheck = _autoTileMap.GetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer).Id;
if (_autoTileMap.Tileset.IsExitSlot(idCheck))
{
var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck);
if (!slotCheck.IsCanCopyWhenDraw)
{
continue;
}
}
if (tileData.Tile_id >= -1)
{
bool isUpdate = _autoTileMap.SetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer, true);
if (isUpdate)
{
HasChangedTile = true;
}
}
if (tileData.Tile_high >= 0)
{
bool isUpdate = _autoTileMap.MapSelect.SetHighRef(tileData.Tile_x, tileData.Tile_y, tileData.Tile_high);
if (isUpdate)
{
HasChangedTile = true;
int tile_layer_high = (int)eSlotAonTypeLayer.Trigger;
_autoTileMap.RefreshTile(tileData.Tile_x, tileData.Tile_y, tile_layer_high);
}
}
if (aTileData.Count == 1)
{
onlyChange = tileData;
}
// if(slot.Size.x == 1 && slot.Size.y == 1){
// }else{
// // _autoTileMap.SetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer );
// for(int x = tileData.Tile_x; x < tileData.Tile_x + slot.Size.x; x++){
// for(int y = tileData.Tile_y; y < tileData.Tile_y + slot.Size.y; y++){
// // _autoTileMap.SetAutoTile( x, y, -2, tileData.Tile_layer );
// _autoTileMap.SetAutoTile( x, y, tileData.Tile_id, tileData.Tile_layer );
// }
// }
// }
if (HasChangedTile)
{
tileMinX = Mathf.Min(tileMinX, tileData.Tile_x);
tileMinY = Mathf.Min(tileMinY, tileData.Tile_y);
tileMaxX = Mathf.Max(tileMaxX, tileData.Tile_x);
tileMaxY = Mathf.Max(tileMaxY, tileData.Tile_y);
}
}
if (HasChangedTile)
{
// if (_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled)
{
_autoTileMap.RefreshMinimapTexture(tileMinX, tileMinY, (tileMaxX - tileMinX) + 1, (tileMaxY - tileMinY) + 1);
}
_autoTileMap.UpdateChunks();
}
return(onlyChange);
}