public override bool CheckTileValidity(Vector2 pTileWorldPos)
{
if (CheckTileNotOccupied(pTileWorldPos) == false)
{
return(false);
}
STETilemap affectedLayer = GetTileAffectedLayer(pTileWorldPos);
if (affectedLayer == null)
{
return(false);
}
STETilemap lowerLayer = GetLowerLayer(affectedLayer);
if (lowerLayer == null)
{
return(false);
}
uint rawTileData = GetTileData(pTileWorldPos, lowerLayer);
TileData tileData = new TileData(rawTileData);
if (tileData.tileId == 65535)
{
return(false);
}
return(true);
}
void Start()
{
subsets = new List <List <TileBehaviour> > ();
tilemap = GameObject.Find("Grid").GetComponent <STETilemap>();
SetMatrix();
SetInteractuables();
}
protected void DoColorPaintAction()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
Vector2 center;
if ((ePositionType)positionType.Value == ePositionType.LocalPosition)
{
center = position.Value;
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
center = TilemapUtils.GetTileCenterPosition(tilemap, (int)position.Value.x, (int)position.Value.y);
}
if (applyToTilemapGroup.Value && tilemap.ParentTilemapGroup)
{
tilemap.ParentTilemapGroup.IterateTilemapWithAction(
(STETilemap tmap) =>
{
TilemapVertexPaintUtils.VertexPaintCircle(tmap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve);
tmap.UpdateMesh();
}
);
}
else
{
TilemapVertexPaintUtils.VertexPaintCircle(tilemap, center, radius.Value, tileColor.Value, (eBlendMode)blendingMode.Value, (eTileColorPaintMode)tileColorPaintMode.Value == eTileColorPaintMode.Vertex, intensityCurve.curve);
tilemap.UpdateMesh();
}
}
}
protected override void DrawDebugPoints()
{
if (m_debugPoints.Count == 0)
{
return;
}
STETilemap tilemap = GetTargetTilemap();
Vector2 cellSizeDiv2 = tilemap.CellSize / 2f;
Vector2 realCellSizeDiv2 = tilemap.transform.TransformPoint(cellSizeDiv2);
float size = Mathf.Min(realCellSizeDiv2.x, realCellSizeDiv2.y);
Vector2 s0 = m_action.startPaintingPosition.Value;
Vector2 s1 = m_action.endPaintingPosition.Value;
Vector2 dir0 = s1 - s0;
Vector2 dir1 = m_debugPoints[m_debugPoints.Count - 1] - m_debugPoints[0];
int idx = Mathf.Sign(dir0.x) != Mathf.Sign(dir1.x) || Mathf.Sign(dir0.y) != Mathf.Sign(dir1.y) ?
m_debugPoints.Count - 1
:
0;
Vector2 c0 = tilemap.transform.TransformPoint(m_debugPoints[idx]);
for (int i = 0; i < m_debugPoints.Count; ++i)
{
Vector2 p0 = tilemap.transform.TransformPoint(m_debugPoints[i]);
EditorCompatibilityUtils.CircleCap(0, p0, Quaternion.identity, size);
//Handles.Label(p0, i.ToString());
if (i != idx)
{
EditorCompatibilityUtils.CircleCap(0, 2 * c0 - p0, Quaternion.identity, size);
}
}
}
private void Awake()
{
if (thisTilemap == null)
{
thisTilemap = GetComponent <STETilemap>();
}
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
Tile tile = null;
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
if ((ePositionType)positionType.Value == ePositionType.LocalPosition)
{
tile = tilemap.GetTile(position.Value);
}
else// if ((ePositionType)positionType.Value == ePositionType.GridPosition)
{
tile = tilemap.GetTile((int)position.Value.x, (int)position.Value.y);
}
if (tile == null)
{
parameterValue.Value = defaultValue.Value;
}
else
{
parameterValue.Value = tile.paramContainer.GetObjectParam(parameterName.Value, defaultValue.Value);
}
}
Finish();
}
protected virtual void RecalculateDebugPoints(Vector2 startPoint, Vector2 endPoint, DrawingFunction drawingFunc)
{
STETilemap tilemap = GetTargetTilemap();
if (!tilemap)
{
return;
}
Vector2 cellSizeDiv2 = tilemap.CellSize / 2f;
m_debugPoints.Clear();
int x0, y0, x1, y1;
if ((ePositionType)m_action.positionType.Value == ePositionType.LocalPosition)
{
x0 = TilemapUtils.GetGridX(tilemap, startPoint);
y0 = TilemapUtils.GetGridY(tilemap, startPoint);
x1 = TilemapUtils.GetGridX(tilemap, endPoint);
y1 = TilemapUtils.GetGridY(tilemap, endPoint);
}
else //if ((ePositionType)m_action.positionType.Value == ePositionType.GridPosition)
{
x0 = (int)startPoint.x;
y0 = (int)startPoint.y;
x1 = (int)endPoint.x;
y1 = (int)endPoint.y;
}
drawingFunc(x0, y0, x1, y1,
(x, y) =>
{
m_debugPoints.Add(new Vector2(x * tilemap.CellSize.x + cellSizeDiv2.x, y * tilemap.CellSize.y + cellSizeDiv2.y));
return(true);
});
}
public SpaceShipEnvironmentTicker(TilemapGroup shipTilemapGroup)
{
_doodadsBackgroundTilemap = shipTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsBackground");
_shipBackgroundTilemap = shipTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "ShipBackground");
SetDirtiableTiles();
}
void OnEnable()
{
OccupiedLayer = GameObject.FindWithTag("Occupied Tiles").GetComponent <STETilemap>();
if (OccupyOnStart)
{
OccupyTiles();
}
}
//Assign references attached to this object and generate the level upon initialisation
private void Start()
{
drunkManWalking = GetComponent <PCG.DrunkManWalking>();
tileMap = GetComponent <STETilemap>();
tileSize = tileMap.CellSize.x;
GenerateLevel();
}
public static void MakeMaterialInstancedIfNecessary(STETilemap tileMap)
{
// TODO: this feels kidn of kludgey
if (!tileMap.Material.name.Contains("Instance"))
{
tileMap.Material = new Material(tileMap.Material);
}
}
private void SetMaterialDistance(STETilemap actualTilemap, float distance)
{
if (mReverse)
{
distance = -distance;
}
actualTilemap.Material.SetFloat("_Distance", distance);
}
public void OnTilePrefabCreation(TilemapChunk.OnTilePrefabCreationData data)
{
Debug.Assert(data.ParentTilemap.name.Equals("DoodadsBackground"), "Captains chair must be on DoodadsBackground");
LeftTilePosition = new Vector2(data.GridX, data.GridY);
RightTilePosition = new Vector2(data.GridX + 1, data.GridY);
DoodadsForeground = data.ParentTilemap.ParentTilemapGroup.FindTilemapByName("DoodadsForeground");
DoodadsBackground = data.ParentTilemap.ParentTilemapGroup.FindTilemapByName("DoodadsBackground");
gameObject.name = $"CptnChair\n{LeftTilePosition}";
}
private void Start()
{
if (SceneManager.GetActiveScene().buildIndex != 0)
{
StartCoroutine(SetUpBlink());
}
StartCoroutine(EnableJump());
// Change this pls
tilemap = FindObjectOfType <STETilemap>();
}
public void GenerateBackgroundTilemap(STETilemap existingTilemap)
{
//Clear the current background tilemap
thisTilemap.ClearMap();
//If background type chosen is perlin, run the perlin background generation functionality
if (backgroundType == BackgroundType.perlin)
{
//random seed for variation
float rand = Random.Range(0f, 999999f);
//Loop through and assign tiles based on whether their perlin value at the given tile (with the seed/scale taken into account) is above a set threshold
//If its above the threshold, set it as a tile, if not, leave it blank
//This leads to organic and natural looking curves of tiles and a nice looking randomised background
for (int x = 0; x < existingTilemap.GridWidth; x++)
{
for (int y = 0; y < existingTilemap.GridHeight; y++)
{
float xCoord = rand + (float)x / (float)existingTilemap.GridWidth * perlinScale;
float yCoord = rand + (float)y / (float)existingTilemap.GridHeight * perlinScale;
float p = Mathf.PerlinNoise(xCoord, yCoord);
if (p > perlinThreshold)
{
thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None);
}
}
}
}
//If the background mode is set from the main map, set any tile behind a foreground tile to a rubbly/destroyed tile, and the rest to regular background tiles
else if (backgroundType == BackgroundType.fromMainMap)
{
for (int x = 0; x < existingTilemap.GridWidth; x++)
{
for (int y = 0; y < existingTilemap.GridHeight; y++)
{
uint raw = existingTilemap.GetTileData(x, y);
TileData processed = new TileData(raw);
if (processed.tileId != 65535)
{
thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None);
}
else
{
thisTilemap.SetTile(x, y, 0, brushId, eTileFlags.None);
}
}
}
}
//Update the background mesh after all generation is complete
thisTilemap.UpdateMesh();
}
void OnTileChanged(STETilemap tilemap, int gridX, int gridY, uint tileData)
{
//Find chunk
var chunk = FindChunk(gridX, gridY);
if (chunk != null)
{
var collider = UpdateCollider(chunk);
collider.DirtyCollider();
}
}
public static void DeserializeTilemap(TilemapSerializedData data, STETilemap tilemap)
{
foreach (TilemapSerializedData.TileData dataItem in data.tileDataList)
{
tilemap.SetTileData(dataItem.gridX, dataItem.gridY, dataItem.tileData); // NOT SURE ABOUT THIS LINE.
}
tilemap.UpdateMesh();
//TilemapUtils.IterateTilemapWithAction(tilemap, action);
//return data;
}
protected void DoColorPaintAction()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.RemoveColorChannel();
tilemap.UpdateMesh();
}
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.Refresh(refreshRenderMesh.Value, refreshColliderMesh.Value, refreshTileObjects.Value, invalidateBrushes.Value);
}
Finish();
}
// RecordData() is called when saving. It returns a string representation of the save data.
public override string RecordData()
{
STETilemap tilemap = GetComponent <STETilemap>();
if (tilemap == null)
{
return(string.Empty);
}
TilemapSerializedData data = SerializeTilemap(tilemap);
return(SaveSystem.Serialize(data));
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.TintColor = tintColor.Value;
}
Finish();
}
// Start is called before the first frame update
private void Start()
{
Debug.Assert(ParentTilemapGroup != null);
_currentCapacity = DefaultRoombaCapacity;
navMeshAgent2D = GetComponent <NavMeshAgent2D>();
_doodadsBackgroundTilemap = ParentTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsBackground");
_doodadsForegroundTilemap = ParentTilemapGroup.Tilemaps.First(tilemap => tilemap.name == "DoodadsForeground");
Debug.Assert(_doodadsBackgroundTilemap != null);
Debug.Assert(_doodadsForegroundTilemap != null);
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.ColliderType = eColliderType.None;
tilemap.Refresh(false, true);
}
Finish();
}
public static TilemapSerializedData SerializeTilemap(STETilemap tilemap)
{
TilemapSerializedData data = new TilemapSerializedData();
System.Action <STETilemap, int, int, uint> action = (tmap, gridX, gridY, tileData) =>
{
data.tileDataList.Add(new TilemapSerializedData.TileData()
{
gridX = gridX, gridY = gridY, tileData = tileData
});
};
TilemapUtils.IterateTilemapWithAction(tilemap, action);
return(data);
}
private void LoadMap(int mapIndex)
{
// Load Objects
var map = Maps[mapIndex];
// Create objs
Transform obj;
foreach (var item in map.NormalObjs)
_mapPool.Spawn(item.Prefab, item.Position, Quaternion.identity);
// Create platform
foreach (var item in map.Platforms)
{
obj = _mapPool.Spawn(item.Prefab);
obj.GetComponent<Platform>().Init(item);
}
// Load tile ground
_tileMap = _mapPool.Spawn(TileGrounds[mapIndex]).GetChild(0).GetComponent<STETilemap>();
SetBounds();
// Load background
Transform bgContain = transform.Find("Background");
SpriteRenderer render;
foreach (var bg in map.Bgs)
{
obj = _bgPool.Spawn(BgPrefab, bgContain);
obj.position = bg.Position;
render = obj.GetComponent<SpriteRenderer>();
render.sprite = bg.Sprite;
render.sortingOrder = bg.Order;
render.sortingLayerName = bg.LayerName;
render.drawMode = bg.DrawMode;
render.size = bg.Size;
#if UNITY_EDITOR
render.name = render.sprite.name;
#endif
obj.localScale = bg.Scale;
}
// Load pipe
foreach (var pipe in map.PipeObjs)
{
obj = _mapPool.Spawn(pipe.Prefab, pipe.Position, pipe.Rotation);
obj.GetComponent<Pipe>().Init(pipe);
}
}
public override bool OnGUI()
{
if (!m_tilemap)
{
m_tilemap = GetTargetTilemap();
}
bool isDirty = DrawDefaultInspector();
if (isDirty && !m_tilemap)
{
m_tileset = GuessTileset();
}
return(isDirty);
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.ColliderType = eColliderType._2D;
tilemap.Collider2DType = (e2DColliderType)collider2DType.Value;
tilemap.PhysicMaterial2D = physicMaterial2D.Value as PhysicsMaterial2D;
tilemap.IsTrigger = isTrigger.Value;
tilemap.Refresh(false, true);
}
Finish();
}
bool CheckTileNotOccupied(Vector2 pTileWorldPos)
{
STETilemap occupiedLayer = GameObject.FindGameObjectWithTag("Occupied Tiles").GetComponent <STETilemap>();
uint rawTileData = GetTileData(pTileWorldPos, occupiedLayer);
TileData tileData = new TileData(rawTileData);
//if tile is already occupied
if (tileData.tileId != 65535)
{
return(false);
}
else
{
return(true);
}
}
public override bool CheckTileValidity(Vector2 pTileWorldPos)
{
FarmPlot plot = GetPlot(pTileWorldPos);
if (CheckTileNotOccupied(pTileWorldPos) == false && plot == null || plot != null && plot.Crop == null)
{
return(false);
}
STETilemap affectedLayer = GetTileAffectedLayer(pTileWorldPos);
if (affectedLayer == null && plot == null)
{
return(false);
}
return(true);
}
public override void OnEnter()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (UpdateCache(go))
{
STETilemap tilemap = cachedComponent as STETilemap;
tilemap.CellSize = cellSize.Value;
if (refreshTilemap.Value)
{
tilemap.Refresh();
}
}
Finish();
}
