public GameObject GenerateBlankTerrainView(Vector2DInt inPosition)
{
GameObject viewGO = GenerateBlank(inPosition);
viewGO.GetComponent <MeshRenderer>().material = _chunkTerrainMaterial;
return(viewGO);
}
public Chunk(Vector2DInt inPosition, Data inData, GameObject inViewGO)
{
position = inPosition;
data = inData;
viewGO = inViewGO;
}
void DebugCreature2Movement()
{
Vector2DInt moveDirection = Vector2DInt.Zero;
if (Input.GetKeyDown(KeyCode.W))
{
moveDirection.y += 1;
}
if (Input.GetKeyDown(KeyCode.S))
{
moveDirection.y -= 1;
}
if (Input.GetKeyDown(KeyCode.A))
{
moveDirection.x -= 1;
}
if (Input.GetKeyDown(KeyCode.D))
{
moveDirection.x += 1;
}
if (moveDirection.x != 0 || moveDirection.y != 0)
{
new Command.Server.MovePlayer(new Command.Server.MovePlayer.Data()
{
direction = moveDirection,
creatureGuid = user.ownedCreatureID[1],
}).Send(_networkManager.client, _networkManager.client.ServerConnection);
}
}
public Tile GetTile(Vector2DInt inWorldPosition)
{
Vector2DInt chunkPosition = WorldPosToChunkPos(inWorldPosition);
Vector2DInt tilePosition = WorldPosToLocalTilePos(inWorldPosition);
return(_chunks[chunkPosition].GetTile(tilePosition));
}
void SetNewTileReferences(Vector2DInt tile)
{
// remove old reference and set to new
currentTile.RemovePlayer();
currentTile = Match.instance.level.tileMap.GetTile(tile);
currentTile.SetCharacter(_character);
}
public void BinaryLoad()
{
using (FileStream stream = new FileStream(Path.Combine(Constants.TILEMAP_SAVE_FOLDER, name), FileMode.Open, FileAccess.Read))
using (BinaryReader reader = new BinaryReader(stream))
{
int gridSizeY = reader.ReadInt32(); // Read: Num tiles Vertical
int gridSizeX = reader.ReadInt32(); // Read: Num tiles Horizontal
int tileCount = gridSizeY * gridSizeX; // Num tiles in total
_gridSize = new Vector2DInt(gridSizeX, gridSizeY); // save gridsize if we need it later
for (int i = 0; i < tileCount; i++)
{
Vector2DInt tilePosition = Vector2DInt.Zero;
tilePosition.BinaryLoad(reader); // Read: Position
string typeName = reader.ReadString(); // Read: Tile type name
float yRot = reader.ReadSingle();
float tintStrength = reader.ReadSingle();
_tiles.Add(tilePosition, new Tile(tilePosition, typeName, yRot, tintStrength, _tilesFolder));
}
AddEdgeTiles(gridSizeX, gridSizeY);
}
}
public void HandleInput()
{
if (Input.GetMouseButtonDown(1))
{
Vector3 mouseWorldPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2DInt targetWorldPosition = new Vector2DInt((int)mouseWorldPosition.x, (int)mouseWorldPosition.z);
if (ownedCreatures.Length > 0)
{
ownedCreatures[_selectedCreatureID].movementComponent.MoveTo(targetWorldPosition);
}
}
if (Input.GetKeyDown(KeyCode.E))
{
if (_selectedCreatureID < ownedCreatures.Length - 1)
{
_selectedCreatureID++;
}
}
if (Input.GetKeyDown(KeyCode.Q))
{
if (_selectedCreatureID > 0)
{
_selectedCreatureID--;
}
}
}
public void GenerateGrid(int sizeX, int sizeY)
{
if (_grid)
{
Destroy(_grid);
}
// create gameobject and mesh
_grid = new GameObject("grid");
Mesh mesh = new Mesh();
float half = 0.5f;
// add mesh filter and meshrenderer and assign them
_grid.AddComponent <MeshFilter>().mesh = mesh;
_grid.AddComponent <MeshRenderer>().material = _gridmaterial;
// create vertex and index array
Vector3[] vertices = new Vector3[(sizeX * sizeY) * 4];
int[] indices = new int [(sizeX * sizeY) * 6];
int column = 0;
int tileCount = 0;
int indexVertex = 0;
int indexIndice = 0;
// loop over and set all vertices and indices
for (int i = 0; i < sizeY * sizeX; i++)
{
vertices[indexVertex + 0] = new Vector3(tileCount - half, -half, column + half); // top left
vertices[indexVertex + 1] = new Vector3(tileCount + half, -half, column + half); // top right
vertices[indexVertex + 2] = new Vector3(tileCount - half, -half, column - half); // bottom left
vertices[indexVertex + 3] = new Vector3(tileCount + half, -half, column - half); // bottom right
indices[indexIndice + 0] = indexVertex;
indices[indexIndice + 1] = indexVertex + 1;
indices[indexIndice + 2] = indexVertex + 2;
indices[indexIndice + 3] = indexVertex + 2;
indices[indexIndice + 4] = indexVertex + 1;
indices[indexIndice + 5] = indexVertex + 3;
tileCount++;
indexVertex += 4;
indexIndice += 6;
if (tileCount == sizeX)
{
column++;
tileCount = 0;
}
}
// assign vertices and indices
mesh.vertices = vertices;
mesh.triangles = indices;
_gridSize = new Vector2DInt(sizeX, sizeY);
GenerateTileData(sizeX, sizeY);
}
public MovementComponent(Mech inParentMech, Vector2DInt inSpawnPosition) : base(inParentMech)
{
moveSpeed = mech.mobilityType.data.movementModifier + mech.armorType.data.movementModifier;
currentTile = Program.world.GetTile(inSpawnPosition);
mech.OnComponentsInitialized += () => OnCurrentTileChange?.Invoke(new OnCurrentTileChangeArgs(currentTile));
}
public void Generate(Vector2DInt inPosition)
{
ChunkData newChunkData = new ChunkData(inPosition);
newChunkData.SetTiles(GenerateTiles(inPosition, GenerateNoiseMap(inPosition)));
newChunkData.WriteToDisk();
}
public GameObject GenerateBlankFurnitureView(Vector2DInt inPosition)
{
GameObject viewGO = GenerateBlank(inPosition);
viewGO.transform.position = viewGO.transform.position + Vector3.up;
viewGO.GetComponent <MeshRenderer>().material = _chunkFurnitureMaterial;
return(viewGO);
}
public Chunk.Data Generate(Vector2DInt inPosition)
{
Chunk.Data newChunkData = new Chunk.Data();
newChunkData.SetTiles(_tileMapGenerator.Generate(inPosition, _noiseGenerator.Generate(inPosition)).tiles);
return(newChunkData);
}
public Tile(Vector2DInt inLocalPosition, Vector2DInt inChunkPosition, Terrain inTerrain)
{
localPosition = inLocalPosition;
chunkPosition = inChunkPosition;
worldPosition = localPosition + (chunkPosition * Constants.TerrainGeneration.CHUNK_SIZE);
_terrain = inTerrain;
}
public Output Generate(Vector2DInt inOffset)
{
Output newOutput = new Output();
newOutput.heightMap = Noise.Generate((uint)_chunkSize, _noiseParamters[0], inOffset);
return(newOutput);
}
public void Show()
{
Clear();
if (File.Exists(Path.Combine(Constants.TILEMAP_SAVE_FOLDER, _tileMapToShow)))
{
using (FileStream stream = new FileStream(Path.Combine(Constants.TILEMAP_SAVE_FOLDER, _tileMapToShow), FileMode.Open, FileAccess.Read))
using (BinaryReader reader = new BinaryReader(stream))
{
int Y = reader.ReadInt32(); // Read: gridsize y
int X = reader.ReadInt32(); // Read: gridsize x
for (int y = 0; y < Y; y++)
{
for (int x = 0; x < X; x++)
{
Vector2DInt tilePosition = Vector2DInt.Zero;
tilePosition.BinaryLoad(reader); // Read: Position
string typeName = reader.ReadString(); // Read: Tile type name
float yRot = reader.ReadSingle();
float tintStrength = reader.ReadSingle();
// dont spawn any tile if it is empty
if (typeName == "empty")
{
continue;
}
GameObject model = null;
for (int i = 0; i < _tileDatabase.tilesToSerialize.Count; i++)
{
if (_tileDatabase.tilesToSerialize[i].typeName == typeName.ToLower())
{
model = _tileDatabase.tilesToSerialize[i].data.prefab;
}
}
// spawn new tile
if (model == null)
{
print("model does not exist in tiledatabase");
continue;
}
// spawn new tile
GameObject tile = Instantiate(model, new Vector3(x, 0, y), model.transform.rotation * Quaternion.Euler(0, yRot, 0), transform);
TintTile(tile, tintStrength);
}
}
}
}
else
{
Debug.LogError(string.Format("level {0} was not found", _tileMapToShow));
}
}
GameObject GenerateBlank(Vector2DInt inPosition)
{
GameObject viewGO = CreateGO(inPosition);
MeshFilter viewMeshFilter = viewGO.GetComponent <MeshFilter>();
ApplyMesh(viewMeshFilter);
return(viewGO);
}
public Tile TGetTile(Vector2DInt inLocalTilePosition)
{
while (_tiles == null)
{
Thread.Sleep(5);
}
return(GetTile(inLocalTilePosition));
}
public Chunk(Vector2DInt inPosition, Tile[,] inTiles, GameObject inViewGO)
{
position = inPosition;
_tiles = inTiles;
viewGO = inViewGO;
OnTilesChanged?.Invoke();
}
void AddWitnessToVisibleChunks(Vector2DInt inViewPosition)
{
Vector2DInt[] visibleChunksPositions = CalculateVisibleChunkPositions(inViewPosition);
foreach (Vector2DInt visibleChunkPos in visibleChunksPositions)
{
World.instance.chunkManager.GetChunk(visibleChunkPos).AddWitness(_user);
}
}
public Chunk GenerateChunk(Vector2DInt inPosition)
{
Chunk.Data chunkData = _dataGenerator.Generate(inPosition);
GameObject chunkView = _viewGenerator.Generate(inPosition, chunkData);
Chunk newChunk = new Chunk(inPosition, chunkData, chunkView);
return(newChunk);
}
public Tile(Vector2DInt inLocalPosition, Vector2DInt inChunkPosition, Terrain inTerrain)
{
node = new Node(this);
localPosition = inLocalPosition;
chunkPosition = inChunkPosition;
worldPosition = localPosition + (chunkPosition * Constants.Terrain.CHUNK_SIZE); // TODO: Read from file ONCE
terrain = inTerrain;
}
public CreatureViewComponent(Creature inCreature, Vector2DInt inSpawnPosition)
{
_creature = inCreature;
_viewGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
_viewGO.transform.position = new Vector3(inSpawnPosition.x, 0, inSpawnPosition.y) + (Vector3.one * 0.5f);
_creature.movementComponent.OnTileEnter += (Tile newTile) =>
_viewGO.transform.position = new Vector3(newTile.worldPosition.x, 0, newTile.worldPosition.y) + (Vector3.one * 0.5f);
}
public GameObject GenerateBlank(Vector2DInt inPosition)
{
GameObject newGO = Object.Instantiate(_templateGO);
newGO.GetComponent <MeshFilter>().mesh = Object.Instantiate(_templateMesh);
newGO.transform.position = new Vector3(inPosition.x, 0, inPosition.y) * _chunkSize;
return(newGO);
}
public Tile(Vector2DInt position, string tileName, float yRotation, float tintStrength, Transform tilesFolder)
{
_tileDB = TileDatabase.instance;
model = _tileDB.GetTile(tileName);
this.position = position;
currentHealth = model.data.health;
CreateView(position, yRotation, tintStrength, tilesFolder);
CreateSounds();
}
int GetTextureIDFromPart(Vector2DInt inFurniturePart)
{
if (!inFurniturePart.IsWithinZeroAnd(_size))
{
Debug.LogError("Tried getting part of furniture that is outside of the furniture");
return(0);
}
return(1); // TODO: Change this for a lookup against a static collection of exmple furniture or smth
}
public bool IsWithinZeroAnd(Vector2DInt inOtherVector) // TODO: Change this, this is kinda ugly
{
if (x > inOtherVector.x ||
y > inOtherVector.y ||
x < 0 || y < 0)
{
return(false);
}
return(true);
}
public GameObject CreateGO(Vector2DInt inPosition)
{
GameObject newChunkGO = new GameObject("Chunk");
newChunkGO.AddComponent <MeshFilter>();
newChunkGO.AddComponent <MeshRenderer>();
newChunkGO.transform.position = new Vector3(inPosition.x, 0, inPosition.y) * _chunkSize;
return(newChunkGO);
}
public void GenerateWorld()
{
for (int y = 0; y < Constants.Terrain.WORLD_SIZE; y++)
{
for (int x = 0; x < Constants.Terrain.WORLD_SIZE; x++)
{
Vector2DInt chunkPosition = new Vector2DInt(x, y);
_dataGenerator.Generate(chunkPosition);
}
}
}
public Chunk GenerateChunk(Vector2DInt inPosition)
{
Chunk newChunk = new Chunk(inPosition);
NoiseGenerator.Output noiseData = _noiseGenerator.Generate(inPosition);
TileMapGenerator.Output tileMap = _tileMapGenerator.Generate(inPosition, noiseData);
newChunk.SetTiles(tileMap.tiles);
return(newChunk);
}
public Creature SpawnCreature(Guid inGuid, Vector2DInt inSpawnWorldPosition)
{
GameObject debugCreatureView = GameObject.CreatePrimitive(PrimitiveType.Cube);
Creature newCreature = new Creature(inGuid, debugCreatureView);
_creatures.Add(newCreature.guid, newCreature);
newCreature.viewGO.transform.position = new Vector3(inSpawnWorldPosition.x, 0, inSpawnWorldPosition.y) + Vector3.one * 0.5f;
return(newCreature);
}