public void refreshRecipes()
{
for (int i = 0; i < gridParent.childCount; i++)
{
Transform child = gridParent.GetChild(i);
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.CRAFTING_ICON, child.gameObject);
}
List <ItemStack> items = new List <ItemStack>();
if (inventory != null)
{
items.AddRange(inventory.getItems());
}
if (inventory2 != null)
{
items.AddRange(inventory2.getItems());
}
foreach (CraftingRecipe recipe in GameManager.database.getCraftingRecipes(recipeType))
{
GameObject o = GameManager.spawnPrefab(GameManager.UIHandler.UICraftingIcon, Vector3.zero, ReuseableGameObject.CRAFTING_ICON);
o.transform.SetParent(gridParent);
UICraftingIcon icon = o.GetComponent <UICraftingIcon>();
currentIcons.Add(icon);
icon.setRecipe(recipe);
if (CraftingHandler.canCraftRecipe(recipe, items))
{
icon.setCanCraft(true);
}
else
{
icon.setCanCraft(false);
}
}
}
public virtual void remove()
{
GameManager.getEntitiesByType(reuseableGameObject).Remove(this);
GameObject.Destroy(gameObject.GetComponent <EntityUltility>());
ReuseGameObjectHandler.putToRecycle(reuseableGameObject, gameObject, recycleCustomName);
gameObject = null;
ir = true;
}
public static GameObject spawnPrefab(GameObject prefab, Vector3 position, ReuseableGameObject ReuseableGameObject, string customName = "")
{
GameObject o = ReuseGameObjectHandler.getObject(ReuseableGameObject + "", position);
if (o == null)
{
o = spawnPrefab(prefab, position);
}
return(o);
}
public void unload(bool async)
{
if (reflectionProbe != null)
{
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.REFLECTION_PROBE, reflectionProbe.gameObject);
reflectionProbe = null;
}
foreach (GameObject c in childs)
{
childList.Remove(c);
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.CHUNK_CHILD, c);
}
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.CHUNK, chunkHolder);
int x = (int)chunkLocation.getX() + GameManager.halfMaxChunkCount;
int y = (int)chunkLocation.getY();
int z = (int)chunkLocation.getZ() + GameManager.halfMaxChunkCount;
displayedChunks.Remove(this);
GameManager.chunks[x, y, z] = null;
Bounds b = new Bounds();
List <Entity> itemEntities = GameManager.getEntitiesByType(ReuseableGameObject.ITEM_ENTITY);
b.min = getChunkStartLocation().getVector3();
b.max = getChunkStartLocation().getVector3() + new Vector3(GameManager.chunkSize, GameManager.chunkSize, GameManager.chunkSize);
this.entities = new List <Item>();
foreach (Entity e in itemEntities.ToArray())
{
if (b.Contains(e.getLocation().getVector3()))
{
e.remove();
entities.Add((Item)e);
needSave = true;
}
}
if (needSave || damagedBlocksIndexs.Count > 0)
{
string filePath = ChunkLoader.getChunkSaveFilePath(chunkLocation);
if (async)
{
Scheduler.runTaskAsynchronously(() => {
Serializer.serializeAndSave <Chunk>(this, filePath);
});
}
else
{
Serializer.serializeAndSave <Chunk>(this, filePath);
}
needSave = false;
}
//blocks = new Block[0, 0, 0];
}
public void displayDamage()
{
if (damagedValue > 0)
{
if (damageOverlay == null)
{
GameObject o = GameManager.spawnPrefab(GameManager.getGameManager()._BlcokDamageOverlayPrefab, getLocation().getVector3(), ReuseableGameObject.BLOCK_DAMAGE_OVERLAY);
damageOverlay = o.GetComponent <BlockDamageOverlay>();;
getChunk().damagedBlocksIndexs.Add(Chunk.getIndex(getVectorInChunk()));
}
damageOverlay.setStage(damagedValue, getType().getSetting().blockHealth);
}
else if (damageOverlay != null)
{
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.BLOCK_DAMAGE_OVERLAY, damageOverlay.gameObject);
getChunk().damagedBlocksIndexs.Remove(Chunk.getIndex(getVectorInChunk()));
damageOverlay = null;
}
}
public void display()
{
childs.Clear();
int matCount = materialTriangles.Count;
if (chunkHolder != null)
{
while (chunkHolder.transform.childCount > matCount)
{
GameObject o = chunkHolder.transform.GetChild(0).gameObject;
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.CHUNK_CHILD, o);
childList.Remove(o);
}
}
if (matCount > 0)
{
displayedChunks.Add(this);
if (chunkHolder == null)
{
if (materialTriangles.Count == 0)
{
return;
}
chunkHolder = createChunkGameObject();
chunkHolder.transform.SetParent(GameManager.getGameManager().mapHolder.transform, true);
meshCollider = chunkHolder.GetComponent <MeshCollider>();
}
while (chunkHolder.transform.childCount < matCount)
{
GameObject o = GameManager.spawnPrefab(GameManager.getGameManager()._chunkChildPrefab, Vector3.zero, ReuseableGameObject.CHUNK_CHILD);
o.transform.SetParent(chunkHolder.transform, false);
}
int index = 0;
foreach (Material mat in materialVertices.Keys)
{
GameObject child = chunkHolder.transform.GetChild(index).gameObject;
MeshFilter meshFilter = child.GetComponent <MeshFilter>();
MeshRenderer meshRenderer = child.GetComponent <MeshRenderer>();
Mesh mesh = new Mesh();
List <int> triangles;
materialTriangles.TryGetValue(mat, out triangles);
List <Vector3> vertices;
materialVertices.TryGetValue(mat, out vertices);
List <Vector2> uvs;
materialUVs.TryGetValue(mat, out uvs);
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.uv = uvs.ToArray();
mesh.RecalculateNormals();
//mesh.RecalculateBounds();
mesh.Optimize();
meshFilter.sharedMesh = mesh;
meshRenderer.sharedMaterial = mat;
childList.Add(child);
childs.Add(child);
index++;
}
Mesh colliderMesh = new Mesh();
colliderMesh.vertices = this.colliderVerices;
colliderMesh.triangles = this.colliderTriangles;
meshCollider.sharedMesh = colliderMesh;
//Initiate Reflection Probes
if (GameManager.useReflection)
{
if (reflectionProbe == null)
{
Vector chunlLoc = getChunkStartLocation();
Vector3 probePos = chunlLoc.add(new Vector(GameManager.chunkHalfSize, GameManager.chunkHalfSize, GameManager.chunkHalfSize)).getVector3();
for (int y = GameManager.chunkHalfSize; y < GameManager.chunkSize; y++)
{
if (getBlock(GameManager.chunkHalfSize, y, GameManager.chunkHalfSize).getType() == MyMaterial.AIR)
{
probePos.y = y + chunlLoc.getY() + 2;
//Debug.Log(probePos + " " + y);
break;
}
}
GameObject rpo = GameManager.spawnPrefab(GameManager.getGameManager()._reflectionProbePrefab, probePos, ReuseableGameObject.REFLECTION_PROBE);
rpo.transform.SetParent(GameManager.getGameManager().reflectionProbeHolder.transform);
reflectionProbe = rpo.GetComponent <ReflectionProbe>();
}
reflectionProbe.RenderProbe();
}
}
//Initiate ItemEntities
if (entities != null)
{
foreach (Item e in entities)
{
e.init();
}
}
entities = null;
//Initiate DamageOverlay
for (int i = 0; i < damagedBlocksIndexs.Count; i++)
{
int index = damagedBlocksIndexs[i];
Block block = getBlock(index);
block.displayDamage();
}
changed++;
}
public static void hideUI()
{
ReuseGameObjectHandler.putToRecycle(ReuseableGameObject.WORLD_SPACE_UI, currentUI.gameObject);
currentUI = null;
}
