private void Start()
{
tileRenderer = GetComponent <TilemapRenderer>();
tileCollider = GetComponent <TilemapCollider2D>();
player.OnJump.AddListener(Switch);
}
private void Init(bool isEditor = false)
{
if (_isInitialized)
{
return;
}
_eventsMap = GetComponent <Tilemap>();
_lastMapBounds = _eventsMap.cellBounds;
_eventsRenderer = GetComponent <TilemapRenderer>();
// エディターじゃない場合は隠す
if (!isEditor)
{
_eventsRenderer.sortingLayerName = "Default";
_eventsRenderer.sortingOrder = -9999;
}
_eventsCollider = GetComponent <TilemapCollider2D>();
// イベントマップがプレイヤーの移動をブロックしなくなる
_eventsCollider.isTrigger = true;
_isInitialized = true;
}
void Start()
{
//hämtar komponenten CompositeCollider2D hos föräldern och ger cc det värdet
cc = GetComponentInParent <CompositeCollider2D>();
//hämtar komponenten TilemapRenderer hos föräldern och ger tmRend det värdet
tmRend = GetComponentInParent <TilemapRenderer>();
}
// Start is called before the first frame update
void Start()
{
floorTiles = GameObject.Find("SecretTilemap").GetComponent <TilemapRenderer>();
catSprite = GameObject.Find("cat").GetComponent <SpriteRenderer>();
floorTiles.enabled = false;
catSprite.enabled = false;
}
private void OnTriggerEnter2D(Collider2D collision)
{
tilemapRenderer = GetComponent <TilemapRenderer>();
if (collision.gameObject.CompareTag("Player"))
{
SetActiveRoof(false);
}
}
private void Start()
{
MyTileMap = transform.parent.parent.GetComponent<Tilemap>();
tilemapRenderer = transform.parent.parent.GetComponent<TilemapRenderer>();
defaultColor = MyTileMap.color;
fadedColor = defaultColor;
fadedColor.a = 0.7f;
}
/// <summary>
/// Instanciate new layer on grid
/// </summary>
public GridLayer(string _name, Transform _gridParent, int _sortingOrder)
{
GameObject gameObject = new GameObject(_name);
gameObject.transform.SetParent(_gridParent);
m_tilemap = gameObject.AddComponent <Tilemap>();
m_tilemapRenderer = gameObject.AddComponent <TilemapRenderer>();
m_tilemapRenderer.sortingOrder = _sortingOrder;
}
// Use this for initialization
void Start()
{
tc2d = GetComponent <TilemapCollider2D>();
tmr = GetComponent <TilemapRenderer>();
bossScript = GameObject.FindGameObjectWithTag("FinalBoss").GetComponent <FinalBossScript>();
camera = Camera.main.gameObject.GetComponent <CameraScript>();
}
internal Level(Transform transform)
{
_transform = transform;
Grid grid = transform.GetComponent <Grid>();
_tilemap = grid.GetComponentInChildren <Tilemap>();
_tilemapRenderer = grid.GetComponentInChildren <TilemapRenderer>();
}
// Start is called before the first frame update
void Start()
{
renderer1 = Dimension1.GetComponent <TilemapRenderer>();
renderer2 = Dimension2.GetComponent <TilemapRenderer>();
collider1 = Dimension1.GetComponent <CompositeCollider2D>();
collider2 = Dimension2.GetComponent <CompositeCollider2D>();
GrayscaleToggle(renderer2, collider2);
audioSource = GetComponent <AudioSource>();
}
// Start is called before the first frame update
void Start()
{
base.Start();
StartPos = transform.position; // start position to return it there when knight dies.
FullReset();
played = false;
audioreset = false;
GateRenderer = Gate.GetComponent <TilemapRenderer>();
GateCollider = Gate.GetComponent <TilemapCollider2D>();
}
void Start()
{
tr = GetComponent <TilemapRenderer>();
box = GetComponent <TilemapCollider2D>();
PlayerControl1.Instance.swap.OnSwap += HandleSwap;
if (!worldOne)
{
Hide();
}
}
private void Awake()
{
TilemapRenderer renderer = GetComponent <TilemapRenderer>();
if (renderer == null)
{
return;
}
renderer.enabled = false;
}
// Start is called before the first frame update
void Start()
{
bps = bpm / 60f;
secondsPerBeat = 1 / bps;
offsetTime = beatOffset * secondsPerBeat;
tmr = this.GetComponent <TilemapRenderer>();
mat = tmr.material;
mat.SetFloat("_Frequency", 0);
}
public string AssignTilemapSort(TilemapRenderer renderer)
{
var go = renderer.gameObject;
SortingLayerCheck(go);
renderer.sortingLayerName = m_CurrentSortLayerName;
renderer.sortingOrder = m_CurrentSortOrder;
return(m_CurrentSortLayerName);
}
public override bool Convert(ConvertOperation convert)
{
// If we already have a renderer in the result set, consider generating
// a tilemap to be not the right course of action.
if (convert.Result.OfType <ICmpRenderer>().Any())
{
return(false);
}
List <object> results = new List <object>();
List <Tileset> availData = convert.Perform <Tileset>().ToList();
// Generate objects
foreach (Tileset tileset in availData)
{
if (convert.IsObjectHandled(tileset))
{
continue;
}
// Retrieve previously generated GameObjects and Tilemaps for re-use
GameObject gameobj = convert.Result.OfType <GameObject>().FirstOrDefault();
Tilemap tilemap = convert.Result.OfType <Tilemap>().FirstOrDefault();
TilemapRenderer tilemapRenderer = convert.Result.OfType <TilemapRenderer>().FirstOrDefault();
if (tilemap == null && gameobj != null)
{
tilemap = gameobj.GetComponent <Tilemap>();
}
// Create a new Tilemap (and TilemapRenderer) if none did exist before
if (tilemap == null)
{
tilemap = new Tilemap();
TilemapsSetupUtility.SetupTilemap(tilemap, tileset);
// Add a renderer for this Tilemap to the result list, if there was none before
if (tilemapRenderer == null)
{
results.Add(new TilemapRenderer());
}
}
// Configure the Tilemap according to the Tileset we're converting
tilemap.Tileset = tileset;
// Add the Tilemap to our result set
results.Add(tilemap);
convert.SuggestResultName(tilemap, tileset.Name);
convert.MarkObjectHandled(tileset);
}
convert.AddResult(results);
return(false);
}
private void Awake()
{
grid = transform.parent.GetComponent <Grid>();
if (!grid)
{
Debug.LogError("[TilemapPrefabricator]: must have a Grid parent");
}
tilemap = GetComponent <Tilemap>();
tilemapRenderer = GetComponent <TilemapRenderer>();
instantiatedPrefabs = new List <GameObject>();
}
void ChangeLayerOpacity(GameObject layerRoot, float opaqueness)
{
// Get all tilemap renderer components in all the children of the layerRoot gameObject
TilemapRenderer[] tilemapRenderers = layerRoot.GetComponentsInChildren <TilemapRenderer>();
// for every tilemapRender component, set its material's "tint color" to be transparent (specifie by the opaqueness arguement)
for (int i = 0, tilemapRenderersLength = tilemapRenderers.Length; i < tilemapRenderersLength; i++)
{
TilemapRenderer mapRenderer = tilemapRenderers[i];
mapRenderer.material.color = new Color(mapRenderer.material.color.r, mapRenderer.material.color.g, mapRenderer.material.color.b, opaqueness);
}
}
// Start is called before the first frame update
void Awake()
{
//creates Tilemap hiearchy as if you created it in Unity inspector
layer = new GameObject("Stage Layer");
grid = layer.AddComponent <Grid>();
grid.cellSize = new Vector3(1.0f / 3.0f, 1.0f / 3.0f, 0.0f);
roomLayer = new GameObject("Stage Grid");
rooms = roomLayer.AddComponent <Tilemap>();
renderer = roomLayer.AddComponent <TilemapRenderer>();
roomLayer.transform.parent = layer.transform;
}
void Awake()
{
me = this;
//Have to set the floor to recive shadows here because it won't let us in the inspector
floor.gameObject.GetComponent <TilemapRenderer> ().receiveShadows = true;
calculateLighting();
TilemapRenderer t = lighting.gameObject.GetComponent <TilemapRenderer> ();
//lighting.transform.position = new Vector3 (lighting.transform.position.x - 0.2f, lighting.transform.position.y - 0.2f, lighting.transform.position.z);
t.sortingOrder = 99;
}
private void PlaceTile(GameObject goTilemap, Tilemap tilemap, TilemapRenderer tilemapRenderer, int cx, int cy, SuperTile tile, Vector3Int pos3, TileIdMath tileId)
{
if (m_TilesAsObjects)
{
PlaceTileAsObject(goTilemap, tile, cx, cy, tileId, pos3);
}
else
{
PlaceTileAsTile(goTilemap, tilemap, tilemapRenderer, tile, tileId, pos3);
}
}
private Renderer IsHit(Transform _transform, Vector3 hitPosition)
{
TilemapRenderer tilemapRenderer = _transform.GetComponent <TilemapRenderer>();
if (tilemapRenderer)
{
return(tilemapRenderer);
}
return(IsPixelHit(_transform, hitPosition));
}
public static void LoadSerializeHashtable(this TilemapRenderer self, Hashtable hashtable)
{
self.mode = hashtable.Get <int>(StringConst.String_mode).ToEnum <TilemapRenderer.Mode>();
self.detectChunkCullingBounds =
hashtable.Get <int>(StringConst.String_detectChunkCullingBounds)
.ToEnum <TilemapRenderer.DetectChunkCullingBounds>();
self.sortOrder = hashtable.Get <int>(StringConst.String_sortOrder).ToEnum <TilemapRenderer.SortOrder>();
self.sortingOrder = hashtable.Get <int>(StringConst.String_sortingOrder);
self.maskInteraction =
hashtable.Get <int>(StringConst.String_maskInteraction).ToEnum <SpriteMaskInteraction>();
}
private Renderer IsHit(Transform _transform)
{
TilemapRenderer tilemapRenderer = _transform.GetComponent <TilemapRenderer>();
if (tilemapRenderer)
{
return(tilemapRenderer);
}
return(IsPixelHit(_transform));
}
// Start is called before the first frame update
void Start()
{
instance = this;
chunks = new TilemapChunk[TerrainGenerator.instance.mapWidth / 100, TerrainGenerator.instance.mapHeight / 100];
oldCurrentPosition = viewer.transform.position;
playerXFloor = (int)Mathf.Round(oldCurrentPosition.x / 100) * 100;
playerYFloor = (int)Mathf.Round(oldCurrentPosition.y / 100) * 100;
LoadInitialTerrain(0, 0);
StartCoroutine(CreateChunks());
// StartCoroutine(CheckChange());
}
// Use this for initialization
void Awake()
{
game = GameObject.FindGameObjectWithTag("GameController").GetComponent <GameController>();
//CONVERT TILEMAP TO 3D
startTilemap = GetComponent <Tilemap>();
rend = GetComponent <TilemapRenderer>();
rend.enabled = false;
MapTilemap(startTilemap, true, spawningParent);
}
//private AudioManager audioManager;
void Start()
{
//audioManager = FindObjectOfType<AudioManager>();
tilemapRenderer = GetComponent <TilemapRenderer>();
tilemap = GetComponent <Tilemap>();
if (isExplored)
{
var color = tilemap.color;
tilemap.color = new Color(color.r, color.g, color.b, 0);
}
}
//mark and update each sprite's order in layer
void FixedUpdate()
{
SpriteRenderer[] spriteRenderers = FindObjectsOfType <SpriteRenderer>();
TilemapRenderer tilemapRenderers = FindObjectOfType <TilemapRenderer>();
foreach (SpriteRenderer renderer in spriteRenderers)
{
renderer.sortingOrder = (int)(renderer.transform.position.y * -10);
}
tilemapRenderers.sortingOrder = (int)(tilemapRenderers.transform.position.y * -10);
}
// Start is called before the first frame update
void Start()
{
PortalCollider = GetComponent <TilemapCollider2D>();
PortalRenderer = GetComponent <TilemapRenderer>();
GemRenderer = Gem.GetComponent <SpriteRenderer>();
GemCollider = Gem.GetComponent <BoxCollider2D>();
Timer = TeleportTimer;
Faded = false;
DisplayGem = false;
}
void RandomTileMap()
{
// validation
if (tiles == null || tiles.Length < 1)
{
Debug.LogError("Tiles not assigned", gameObject);
return;
}
var parent = transform.parent;
if (parent == null)
{
var go = new GameObject("grid");
go.AddComponent <Grid>();
transform.SetParent(go.transform);
}
else
{
if (parent.GetComponent <Grid>() == null)
{
parent.gameObject.AddComponent <Grid>();
}
}
TilemapRenderer tr = GetComponent <TilemapRenderer>();
if (tr == null)
{
tr = gameObject.AddComponent <TilemapRenderer>();
}
Tilemap map = GetComponent <Tilemap>();
if (map == null)
{
map = gameObject.AddComponent <Tilemap>();
}
// random map generation
Vector3Int tilePos = Vector3Int.zero;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
tilePos.x = x;
tilePos.y = y;
map.SetTile(tilePos, tiles[Random.Range(0, tiles.Length)]);
}
}
}
