public void CreateSurroundings(ConfigSurroundings configSurroundings)
{
if (configSurroundings.surroundingMaterial >= 0)
{
float SURROUNDING_PLANE_SIZE = 1000.0f;
float SURROUNDING_PLANE_SCALE = 10.0f;
float surroundingLevel = configSurroundings.surroundingLevel.EvaluateInt(gameManagerUnity.world);
surroundingLevel += configSurroundings.surroundingOffsetY;
CubeWorld.World.CubeWorld world = gameManagerUnity.world;
goContainer = new GameObject();
goContainer.name = "Surroundings";
goContainer.transform.position = new Vector3(0, 0, 0);
goContainer.transform.rotation = Quaternion.identity;
goContainer.transform.localScale = new Vector3(1, 1, 1);
GameObject goPlane1 = GameObject.CreatePrimitive(PrimitiveType.Plane);
goPlane1.name = "A1";
goPlane1.transform.parent = goContainer.transform;
GameObject goPlane2 = GameObject.CreatePrimitive(PrimitiveType.Plane);
goPlane2.name = "A2";
goPlane2.transform.parent = goContainer.transform;
GameObject goPlane3 = GameObject.CreatePrimitive(PrimitiveType.Plane);
goPlane3.name = "A3";
goPlane3.transform.parent = goContainer.transform;
GameObject goPlane4 = GameObject.CreatePrimitive(PrimitiveType.Plane);
goPlane4.name = "A4";
goPlane4.transform.parent = goContainer.transform;
goPlane1.renderer.material = new Material(materialSurrounding);
goPlane2.renderer.material = new Material(materialSurrounding);
goPlane3.renderer.material = new Material(materialSurrounding);
goPlane4.renderer.material = new Material(materialSurrounding);
Texture2D surroundingTexture = GraphicsUnity.GetTilesetTexture((Texture2D)gameManagerUnity.materialTransparent.mainTexture, configSurroundings.surroundingMaterial);
surroundingTexture.wrapMode = TextureWrapMode.Repeat;
goPlane1.renderer.material.mainTexture = surroundingTexture;
goPlane2.renderer.material.mainTexture = surroundingTexture;
goPlane3.renderer.material.mainTexture = surroundingTexture;
goPlane4.renderer.material.mainTexture = surroundingTexture;
goPlane1.transform.localScale = new Vector3(world.sizeX / SURROUNDING_PLANE_SCALE, 0, SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE);
goPlane1.transform.position = new Vector3(world.sizeX / 2.0f - 0.5f, surroundingLevel - 0.5f, -SURROUNDING_PLANE_SIZE / 2.0f - 0.5f);
goPlane1.renderer.material.mainTextureScale = new Vector2(goPlane1.transform.localScale.x * SURROUNDING_PLANE_SCALE, goPlane1.transform.localScale.z * SURROUNDING_PLANE_SCALE);
goPlane2.transform.localScale = new Vector3(world.sizeX / SURROUNDING_PLANE_SCALE, 0, SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE);
goPlane2.transform.position = new Vector3(world.sizeX / 2.0f - 0.5f, surroundingLevel - 0.5f, world.sizeZ - 0.5f + SURROUNDING_PLANE_SIZE / 2.0f);
goPlane2.renderer.material.mainTextureScale = new Vector2(goPlane2.transform.localScale.x * SURROUNDING_PLANE_SCALE, goPlane2.transform.localScale.z * SURROUNDING_PLANE_SCALE);
goPlane3.transform.localScale = new Vector3(SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE, 0, SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE * 2.0f + world.sizeX / SURROUNDING_PLANE_SCALE);
goPlane3.transform.position = new Vector3(world.sizeX + SURROUNDING_PLANE_SIZE / 2.0f - 0.5f, surroundingLevel - 0.5f, world.sizeZ / 2.0f - 0.5f);
goPlane3.renderer.material.mainTextureScale = new Vector2(goPlane3.transform.localScale.x * SURROUNDING_PLANE_SCALE, goPlane3.transform.localScale.z * SURROUNDING_PLANE_SCALE);
goPlane4.transform.localScale = new Vector3(SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE, 0, SURROUNDING_PLANE_SIZE / SURROUNDING_PLANE_SCALE * 2.0f + world.sizeX / SURROUNDING_PLANE_SCALE);
goPlane4.transform.position = new Vector3(-SURROUNDING_PLANE_SIZE / 2.0f - 0.5f, surroundingLevel - 0.5f, world.sizeZ / 2.0f - 0.5f);
goPlane4.renderer.material.mainTextureScale = new Vector2(goPlane4.transform.localScale.x * SURROUNDING_PLANE_SCALE, goPlane4.transform.localScale.z * SURROUNDING_PLANE_SCALE);
goSurroundings.Add(goPlane1);
goSurroundings.Add(goPlane2);
goSurroundings.Add(goPlane3);
goSurroundings.Add(goPlane4);
}
}
public void UpdateMesh()
{
if (visibleByPlayer == false)
{
willRequireMeshUpdate = true;
return;
}
mesh.Clear();
CubeWorld.World.CubeWorld world = gameManagerUnity.world;
TileManager tileManager = world.tileManager;
colors.Clear();
vertices.Clear();
uvs.Clear();
uvs2.Clear();
normals.Clear();
trianglesNormal.Clear();
trianglesTransparent.Clear();
trianglesTranslucid.Clear();
trianglesDamage.Clear();
trianglesAnimated.Clear();
int index = 0;
float uvdelta = 1.0f / GraphicsUnity.TILE_PER_MATERIAL_ROW;
int tileOffsetX = sector.tileOffset.x;
int tileOffsetY = sector.tileOffset.y;
int tileOffsetZ = sector.tileOffset.z;
float ambientLightIntensity = MeshUtils.luminanceMapper[world.dayCycleManager.ambientLightLuminance];
totalAmbientLuminance = 0;
for (int z = tileOffsetZ; z < SectorManager.SECTOR_SIZE + tileOffsetZ; z++)
{
for (int y = tileOffsetY; y < SectorManager.SECTOR_SIZE + tileOffsetY; y++)
{
for (int x = tileOffsetX; x < SectorManager.SECTOR_SIZE + tileOffsetX; x++)
{
TilePosition pos = new TilePosition(x, y, z);
Tile tile = tileManager.GetTile(pos);
totalAmbientLuminance += tile.AmbientLuminance;
if (tile.tileType == TileDefinition.EMPTY_TILE_TYPE || tile.Dynamic)
{
continue;
}
Vector3 offset = GraphicsUnity.TilePositionToVector3(x - tileOffsetX, y - tileOffsetY, z - tileOffsetZ);
TileDefinition tileDefinition = tileManager.GetTileDefinition(tile.tileType);
List <int> triangles;
Vector3[] faceVectors = MeshUtils.faceVectorsNormal;
TileDefinition.DrawMode drawMode = tileDefinition.drawMode;
if (drawMode == TileDefinition.DrawMode.SOLID ||
drawMode == TileDefinition.DrawMode.LIQUID && tileDefinition.solid)
{
if (tile.Energy == tileDefinition.energy)
{
triangles = trianglesNormal;
}
else
{
triangles = trianglesDamage;
}
}
else if (drawMode == TileDefinition.DrawMode.SOLID_ALPHA)
{
triangles = trianglesTranslucid;
}
else
{
triangles = trianglesTransparent;
}
if (tileDefinition.animated)
{
triangles = trianglesAnimated;
}
bool drawingLiquidSurface = false;
if (drawMode == TileDefinition.DrawMode.LIQUID &&
tileManager.IsValidTile(pos + new TilePosition(0, 1, 0)) &&
tileManager.GetTileType(pos + new TilePosition(0, 1, 0)) != tile.tileType)
{
drawingLiquidSurface = true;
}
float[] liquidVertexHeights = null;
for (int face = 0; face < 6; face++)
{
int material = tileDefinition.materials[face];
if (material < 0)
{
continue;
}
TileDefinition.DrawMode nearTileDrawMode = TileDefinition.DrawMode.NONE;
TilePosition normalInt = MeshUtils.faceNormalsTile[face];
TilePosition near = pos + normalInt;
if (tileManager.IsValidTile(near))
{
nearTileDrawMode = tileManager.GetTileDrawMode(near);
bool nearDynamic = tileManager.GetTileDynamic(near);
TilePosition nearAbove = near + new TilePosition(0, 1, 0);
bool drawingLiquidSurfaceBorder = (drawMode == nearTileDrawMode &&
drawMode == TileDefinition.DrawMode.LIQUID &&
drawingLiquidSurface == false &&
tileManager.IsValidTile(nearAbove) &&
tileManager.GetTileType(nearAbove) != tile.tileType &&
face != (int)CubeWorld.Utils.Graphics.Faces.Top &&
face != (int)CubeWorld.Utils.Graphics.Faces.Bottom);
if (drawMode != nearTileDrawMode ||
drawMode == TileDefinition.DrawMode.SOLID_ALPHA ||
nearDynamic ||
drawingLiquidSurfaceBorder)
{
float lightIntensity = ambientLightIntensity *
MeshUtils.luminanceMapper[tileManager.GetTileAmbientLuminance(near)] +
MeshUtils.luminanceMapper[tileManager.GetTileLightSourceLuminance(near)];
if (lightIntensity > 1.0f)
{
lightIntensity = 1.0f;
}
Color faceColor = new Color(lightIntensity * MeshUtils.faceBright[face],
lightIntensity * MeshUtils.faceBright[face],
lightIntensity * MeshUtils.faceBright[face]);
Vector3 faceNormal = MeshUtils.faceNormals[face];
if (tile.OnFire && MeshUtils.faceVectorsFireAvailable[face])
{
for (int i = 0; i < 4; i++)
{
vertices.Add(MeshUtils.faceVectorsFire[(face << 2) + i] + offset);
normals.Add(faceNormal);
colors.Add(faceColor);
}
trianglesTranslucid.Add(index + 0);
trianglesTranslucid.Add(index + 1);
trianglesTranslucid.Add(index + 2);
trianglesTranslucid.Add(index + 2);
trianglesTranslucid.Add(index + 3);
trianglesTranslucid.Add(index + 0);
int fireMaterial = gameManagerUnity.extraMaterials.fireMaterials[(x + y + z) % gameManagerUnity.extraMaterials.fireMaterials.Length];
float uvxFire = uvdelta * (fireMaterial % GraphicsUnity.TILE_PER_MATERIAL_ROW);
float uvyFire = 1.0f - uvdelta * (fireMaterial / GraphicsUnity.TILE_PER_MATERIAL_ROW);
uvs.Add(new Vector2(uvxFire, uvyFire - uvdelta));
uvs.Add(new Vector2(uvxFire, uvyFire));
uvs.Add(new Vector2(uvxFire + uvdelta, uvyFire));
uvs.Add(new Vector2(uvxFire + uvdelta, uvyFire - uvdelta));
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
index += 4;
}
if ((drawingLiquidSurface || drawingLiquidSurfaceBorder) && liquidVertexHeights == null)
{
liquidVertexHeights = GetLiquidVertexHeights(tileManager, pos, tile);
}
for (int i = 0; i < 4; i++)
{
if (drawingLiquidSurface || drawingLiquidSurfaceBorder)
{
Vector3 liquidVertex = faceVectors[(face << 2) + i];
if (drawingLiquidSurface && liquidVertex.y == CubeWorld.Utils.Graphics.HALF_TILE_SIZE ||
drawingLiquidSurfaceBorder && liquidVertex.y == -CubeWorld.Utils.Graphics.HALF_TILE_SIZE)
{
if (liquidVertex.x == CubeWorld.Utils.Graphics.HALF_TILE_SIZE)
{
//x = 1
if (liquidVertex.z == CubeWorld.Utils.Graphics.HALF_TILE_SIZE)
{
//z = 1
liquidVertex.y = liquidVertexHeights[0];
}
else
{
//z = -1
liquidVertex.y = liquidVertexHeights[1];
}
}
else
{
//x = -1
if (liquidVertex.z == CubeWorld.Utils.Graphics.HALF_TILE_SIZE)
{
//z = 1
liquidVertex.y = liquidVertexHeights[3];
}
else
{
//z = -1
liquidVertex.y = liquidVertexHeights[2];
}
}
}
vertices.Add(liquidVertex + offset);
}
else
{
vertices.Add(faceVectors[(face << 2) + i] + offset);
}
normals.Add(faceNormal);
colors.Add(faceColor);
}
triangles.Add(index + 0);
triangles.Add(index + 1);
triangles.Add(index + 2);
triangles.Add(index + 2);
triangles.Add(index + 3);
triangles.Add(index + 0);
float uvx = uvdelta * (material % GraphicsUnity.TILE_PER_MATERIAL_ROW);
float uvy = 1.0f - uvdelta * (material / GraphicsUnity.TILE_PER_MATERIAL_ROW);
uvs.Add(new Vector2(uvx, uvy - uvdelta));
uvs.Add(new Vector2(uvx, uvy));
uvs.Add(new Vector2(uvx + uvdelta, uvy));
uvs.Add(new Vector2(uvx + uvdelta, uvy - uvdelta));
if (drawMode == TileDefinition.DrawMode.SOLID && tile.Energy < tileDefinition.energy)
{
int materialDamageIndex = ((tileDefinition.energy - tile.Energy) * gameManagerUnity.extraMaterials.damageMaterials.Length) / tileDefinition.energy;
if (materialDamageIndex >= gameManagerUnity.extraMaterials.damageMaterials.Length)
{
materialDamageIndex = gameManagerUnity.extraMaterials.damageMaterials.Length - 1;
}
int materialDamage = gameManagerUnity.extraMaterials.damageMaterials[materialDamageIndex];
uvx = uvdelta * (materialDamage % GraphicsUnity.TILE_PER_MATERIAL_ROW);
uvy = 1.0f - uvdelta * (materialDamage / GraphicsUnity.TILE_PER_MATERIAL_ROW);
uvs2.Add(new Vector2(uvx, uvy - uvdelta));
uvs2.Add(new Vector2(uvx, uvy));
uvs2.Add(new Vector2(uvx + uvdelta, uvy));
uvs2.Add(new Vector2(uvx + uvdelta, uvy - uvdelta));
}
else
{
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
uvs2.Add(Vector2.zero);
}
index += 4;
}
}
}
}
}
}
mesh.vertices = vertices.ToArray();
mesh.colors = colors.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uvs.ToArray();
mesh.uv2 = uvs2.ToArray();
mesh.subMeshCount = 4;
mesh.bounds = new Bounds(new Vector3(SectorManager.SECTOR_SIZE / 2, SectorManager.SECTOR_SIZE / 2, SectorManager.SECTOR_SIZE / 2), new Vector3(SectorManager.SECTOR_SIZE + 1, SectorManager.SECTOR_SIZE + 1, SectorManager.SECTOR_SIZE + 1));
List <Material> materials = new List <Material>();
if (trianglesNormal.Count > 0)
{
materials.Add(gameManagerUnity.material);
}
if (trianglesTranslucid.Count > 0)
{
materials.Add(gameManagerUnity.materialTranslucid);
}
if (trianglesTransparent.Count > 0)
{
materials.Add(gameManagerUnity.materialTransparent);
}
if (trianglesDamage.Count > 0)
{
materials.Add(gameManagerUnity.materialDamaged);
}
if (trianglesAnimated.Count > 0)
{
materials.Add(gameManagerUnity.materialLiquidAnimated);
}
meshRenderer.sharedMaterials = materials.ToArray();
int trianglesGroupIndex = 0;
if (trianglesNormal.Count > 0)
{
mesh.SetTriangles(trianglesNormal.ToArray(), trianglesGroupIndex++);
}
if (trianglesTranslucid.Count > 0)
{
mesh.SetTriangles(trianglesTranslucid.ToArray(), trianglesGroupIndex++);
}
if (trianglesTransparent.Count > 0)
{
mesh.SetTriangles(trianglesTransparent.ToArray(), trianglesGroupIndex++);
}
if (trianglesDamage.Count > 0)
{
mesh.SetTriangles(trianglesDamage.ToArray(), trianglesGroupIndex++);
}
if (trianglesAnimated.Count > 0)
{
mesh.SetTriangles(trianglesAnimated.ToArray(), trianglesGroupIndex++);
}
willRequireMeshUpdate = false;
willRequireLightUpdate = false;
}
public virtual void Start()
{
Vector3 sizeInTiles = GraphicsUnity.TilePositionToVector3(((AvatarDefinition)avatar.definition).sizeInTiles);
//float halfX = sizeInTiles.x / 2.0f;
float halfY = sizeInTiles.y / 2.0f;
//float halfZ = sizeInTiles.z / 2.0f;
body = new GameObject();
body.name = "Body";
body.transform.parent = transform;
body.transform.localPosition = new Vector3(
0,
halfY - CubeWorld.Utils.Graphics.HALF_TILE_SIZE,
0);
body.transform.localRotation = Quaternion.identity;
body.transform.localScale = new Vector3(1, 1, 1);
foreach (AvatarPartDefinition avatarPart in ((AvatarDefinition)avatar.definition).parts)
{
Vector3 offset = new Vector3(
avatarPart.offset.x,
avatarPart.offset.y,
avatarPart.offset.z);
Vector3 rotation = GraphicsUnity.CubeWorldVector3ToVector3(avatarPart.rotation);
GameObject goPart = new GameObject();
goPart.name = avatarPart.id;
goPart.transform.parent = body.transform;
goPart.transform.localPosition = offset;
goPart.transform.localRotation = Quaternion.Euler(rotation);
goPart.transform.localScale = new Vector3(1, 1, 1);
VisualDefinitionRenderUnity visualDefinitionRenderer = goPart.AddComponent <VisualDefinitionRenderUnity>();
visualDefinitionRenderer.world = gameManagerUnity.world;
visualDefinitionRenderer.material = gameManagerUnity.materialItems;
visualDefinitionRenderer.visualDefinition = avatarPart.visualDefinition;
switch (avatarPart.id)
{
case "head":
heads.Add(goPart);
break;
case "arm":
arms.Add(goPart);
break;
case "leg":
legs.Add(goPart);
break;
}
goPart.GetComponent <Renderer>().enabled = bodyRenderEnabled;
parts.Add(goPart);
}
}
private void UpdateUserActions()
{
if (playerUnity.gameManagerUnity.State == GameManagerUnity.GameManagerUnityState.GAME ||
playerUnity.gameManagerUnity.State == GameManagerUnity.GameManagerUnityState.PAUSE)
{
Vector3 cameraPos = playerUnity.transform.position + playerUnity.GetLocalHeadPosition();
Vector3 cameraFwd = playerUnity.mainCamera.transform.forward;
CubeWorld.Utils.Graphics.RaycastTileResult raycastResult = CubeWorld.Utils.Graphics.RaycastTile(
playerUnity.player.world,
GraphicsUnity.Vector3ToCubeWorldVector3(cameraPos),
GraphicsUnity.Vector3ToCubeWorldVector3(cameraFwd),
10.0f,
true, false);
if (userActionCooldown > 0.0f)
{
userActionCooldown -= Time.deltaTime;
}
if (userActionCooldown <= 0.0f)
{
if (Input.GetMouseButton(0) || Input.GetMouseButton(1))
{
ExecuteHandUseAnimation();
userActionCooldown = 0.2f;
}
if (raycastResult.hit)
{
if (Input.GetMouseButton(0))
{
if (raycastResult.position.x > 0 && raycastResult.position.x < playerUnity.player.world.tileManager.sizeX - 1 &&
raycastResult.position.z > 0 && raycastResult.position.z < playerUnity.player.world.tileManager.sizeZ - 1 &&
raycastResult.position.y > 0)
{
if (playerUnity.player.world.tileManager.HasTileActions(
raycastResult.position,
TileActionRule.ActionType.CLICKED))
{
playerUnity.player.world.gameplay.TileClicked(raycastResult.position);
}
else
{
if (playerUnity.objectInHand != null)
{
switch (playerUnity.objectInHand.definition.type)
{
case CWDefinition.DefinitionType.Item:
{
playerUnity.gameManagerUnity.fxManagerUnity.PlaySound("hitmetal", playerUnity.player.position);
playerUnity.player.world.gameplay.TileHit(raycastResult.position, ((Item)playerUnity.objectInHand).itemDefinition);
break;
}
default:
playerUnity.gameManagerUnity.fxManagerUnity.PlaySound("hit", playerUnity.player.position);
playerUnity.player.world.tileManager.DamageTile(raycastResult.position, 1);
break;
}
}
}
}
}
else if (Input.GetMouseButton(1))
{
if (playerUnity.objectInHand != null && playerUnity.objectInHand.definition.type == CWDefinition.DefinitionType.Tile)
{
TileDefinition tileDefinition = (TileDefinition)playerUnity.objectInHand.definition;
TilePosition tileCreatePosition = raycastResult.position + CubeWorld.Utils.Graphics.GetFaceNormal(raycastResult.face);
//Don't create tile on top of the world, because no triangles are drawn on the border!
if (tileCreatePosition.y < playerUnity.player.world.tileManager.sizeY - 1 &&
playerUnity.player.world.tileManager.IsValidTile(tileCreatePosition) &&
playerUnity.player.world.tileManager.GetTileSolid(tileCreatePosition) == false)
{
if (playerUnity.player.world.avatarManager.IsTileBlockedByAnyAvatar(tileCreatePosition) == false)
{
playerUnity.player.world.gameplay.CreateTile(tileCreatePosition, tileDefinition.tileType);
playerUnity.player.inventory.RemoveFromDefinition(tileDefinition, 1);
if (playerUnity.player.inventory.HasMoreOfDefinition(tileDefinition) == false)
{
playerUnity.objectInHand = null;
}
}
}
}
}
}
}
}
}
