/// <summary>
/// FORMAT = [I : Pn : x,y; ... ;x,y : x,y; ... ;x,y : x,y; ... ;x,y#]
/// </summary>
/// <param name="command">Command.</param>
private void GameInitExec(string command)
{
try {
var data = command.Substring(2).Split(':');
// Set player number variable (Does not update tanks dictionary)
playerNo = int.Parse(data [0].Substring(1));
// Cells Initiation
cells.Clear();
for (var i = 1; i <= 3; i++)
{
foreach (var coordinatePair in data[i].Split(';'))
{
var coordinates = coordinatePair.Split(',');
cells.Add(new Cell(int.Parse(coordinates [0]), int.Parse(coordinates [1]), i - 1, 0));
}
}
// Generate All Cells
GenerateGameObjects.GetInstance().GenerateCells(cells);
} catch (Exception ex) {
Debug.LogException(ex);
}
}
public override void OnInspectorGUI()
{
GenerateGameObjects genGO = (GenerateGameObjects)target;
if (GUILayout.Button("Delete Objects"))
{
genGO.RemovePreviousObjects();
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero);
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(mapData.heightMap));
}
else if (drawMode == DrawMode.ColourMap)
{
display.DrawTexture(TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD), TextureGenerator.TextureFromColourMap(mapData.colourMap, mapChunkSize, mapChunkSize));
if (generateGameObjects)
{
GenerateGameObjects genGOScript = display.meshRenderer.transform.gameObject.GetComponent <GenerateGameObjects>();
if (genGOScript == null)
{
genGOScript = display.meshRenderer.transform.gameObject.AddComponent <GenerateGameObjects>();
}
genGOScript.seed = seed;
genGOScript.StartGenerateObjects();
genGOScript.offset = offset;
genGOScript.levelOfDetail = editorPreviewLOD;
genGOScript.mapData = mapData;
genGOScript.genClouds = generateClouds;
}
}
else if (drawMode == DrawMode.Falloff)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize)));
}
if (generateWater)
{
bool genNewWater = true;
foreach (Transform child in gameObject.transform)
{
if (child.tag == "Water")
{
genNewWater = false;
}
}
if (genNewWater)
{
EndlessTerrain endTer = GetComponent <EndlessTerrain>();
GameObject waterIns = GameObject.Instantiate(endTer.waterPlane, new Vector3(0, -0.22f * EndlessTerrain.scale, 0), Quaternion.identity);
waterIns.transform.parent = gameObject.transform;
waterIns.AddComponent <DisableOnStartup>();
}
}
}
void Start()
{
genGOs = GetComponent <GenerateGameObjects>();
mapGenerator = FindObjectOfType <MapGenerator>();
maxViewDst = detailLevels[detailLevels.Length - 1].visibleDstThreshold;
chunkSize = MapGenerator.mapChunkSize - 1;
chunksVisibleInViewDst = Mathf.RoundToInt(maxViewDst / chunkSize);
UpdateVisibleChunks();
}
void RemoveConsumedPacks(List <CoinPack> consumedCoinPacks, List <LifePack> consumedLifePacks)
{
GenerateGameObjects.GetInstance().DestroyCoinPacks(consumedCoinPacks);
foreach (var pack in consumedCoinPacks)
{
coinpacks.Remove(pack);
}
GenerateGameObjects.GetInstance().DestroyLifePacks(consumedLifePacks);
foreach (var pack in consumedLifePacks)
{
lifepacks.Remove(pack);
}
}
/// <summary>
/// FORMAT = [L:x,y:lt#]
/// </summary>
/// <param name="command">Command.</param>
private void LifepackSpawnExec(string command)
{
try {
var lifes = command.Substring(2).Split(':');
var location = lifes [0].Split(',');
var lifePack = new LifePack(int.Parse(location [0]), int.Parse(location [1]), int.Parse(lifes [1]));
lifepacks.Add(lifePack);
// Generate Life Packs
GenerateGameObjects.GetInstance().GenerateLifePacks(lifePack);
} catch (Exception ex) {
Debug.LogException(ex);
}
}
/// <summary>
/// FORMAT = [C:x,y:lt:val#]
/// </summary>
/// <param name="command">Command.</param>
private void CoinSpawnExec(string command)
{
try {
var coins = command.Substring(2).Split(':');
var location = coins [0].Split(',');
var coinPack = new CoinPack(int.Parse(location [0]), int.Parse(location [1]), int.Parse(coins [1]),
int.Parse(coins [2]));
coinpacks.Add(coinPack);
// Generate Coin Packs
GenerateGameObjects.GetInstance().GenerateCoinPacks(coinPack);
} catch (Exception ex) {
Debug.LogException(ex);
}
}
/// <summary>
/// Remove expired coin packs from list and update UI
/// </summary>
void RemoveExpiredPacks()
{
var expiredCoinPacks = coinpacks.Where(p => p.isExpired());
var expiredLifePacks = lifepacks.Where(p => p.isExpired());
GenerateGameObjects.GetInstance().DestroyCoinPacks(expiredCoinPacks);
foreach (var pack in expiredCoinPacks)
{
coinpacks.Remove(pack);
}
GenerateGameObjects.GetInstance().DestroyLifePacks(expiredLifePacks);
foreach (var pack in expiredLifePacks)
{
lifepacks.Remove(pack);
}
}
/// <summary>
/// FORMAT = [S : Pn;x,y;d : Pn;x,y;d#]
/// </summary>
/// <param name="command">Command.</param>
private void GameAcceptanceExec(string command)
{
try {
var positions = command.Substring(2).Split(':');
foreach (var position in positions)
{
var fields = position.Split(';');
var number = int.Parse(fields [0].Substring(1));
tanks [number] = new Tank(number, number == playerNo, int.Parse(fields [1].Split(',') [0]),
int.Parse(fields [1].Split(',') [1]), int.Parse(fields [2]));
}
// Generate All Tanks
GenerateGameObjects.GetInstance().GenerateTanks(tanks);
} catch (Exception ex) {
Debug.LogException(ex);
}
}
/// <summary>
/// FORMAT = [G : Pn;x,y;d;shot;health;coins;points : ... : Pn;x,y;d;shot;health;coins;points : x,y,damage; ...
/// ;x,y,damage#]
/// </summary>
/// <param name="command">Command.</param>
private void GameUpdateExec(string command)
{
try {
var data = command.Substring(2).Split(':');
var consumedCoinPacks = new List <CoinPack>();
var consumedLifePacks = new List <LifePack>();
foreach (var d in data)
{
if (d [0] == 'P')
{
// Tank Status Update [Pn;x,y;d;shot;health;coins;points]
var state = d.Split(';');
var tank = tanks [int.Parse(state [0].Substring(1))];
tank.x = int.Parse(state [1].Split(',') [0]);
tank.y = int.Parse(state [1].Split(',') [1]);
tank.direction = (Direction)int.Parse(state [2]);
tank.isShot = int.Parse(state [3]) == 1;
tank.health = int.Parse(state [4]);
tank.coins = int.Parse(state [5]);
tank.points = int.Parse(state [6]);
consumedCoinPacks.AddRange(coinpacks.Where(p => p.x == tank.x && p.y == tank.y));
consumedLifePacks.AddRange(lifepacks.Where(p => p.x == tank.x && p.y == tank.y));
}
else
{
// Cell status update [x,y,damage ; ... ; x,y,damage]
foreach (var locationupdate in d.Split(';'))
{
var info = locationupdate.Split(',');
var cell = cells.FirstOrDefault(c => c.x == int.Parse(info [0]) && c.y == int.Parse(info [1]));
if (cell != null)
{
cell.damage = (CellDamage)int.Parse(info [2]);
}
}
}
}
// Generate all Tanks and Cells
GenerateGameObjects.GetInstance().GenerateCells(cells);
GenerateGameObjects.GetInstance().GenerateTanks(tanks);
RemoveExpiredPacks();
RemoveConsumedPacks(consumedCoinPacks, consumedLifePacks);
ScoreManager.GetInstance().updateScore(tanks);
var thread = new System.Threading.Thread(() =>
{
var nextMove = new AI(playerNo.Value, 2).GetNextBestMove(tanks, cells, lifepacks, coinpacks).ToString();
Debug.LogWarning("Result for next Move - " + nextMove.ToString());
ServerConnect.MakeC2SRequest(nextMove.ToString().ToUpper() + "#");
});
thread.Priority = System.Threading.ThreadPriority.Highest;
thread.Start();
} catch (Exception ex) {
Debug.LogException(ex);
}
}
void Start()
{
instance = this;
}
public void UpdateTerrainChunk()
{
float viewerDstFromNearestEdge = Mathf.Sqrt(bounds.SqrDistance(viewerPosition));
bool visible = viewerDstFromNearestEdge <= maxViewDst;
meshObject.transform.position.y.Equals(-44f);
if (mapDataRecieved)
{
if (visible)
{
int lodIndex = 0;
for (int i = 0; i < detailLevels.Length - 1; i++)
{
if (viewerDstFromNearestEdge > detailLevels[i].visibleDstThreshold)
{
lodIndex = i + 1;
}
else
{
break;
}
}
if (lodIndex != previousLODIndex)
{
if (genGO != null)
{
genGO.levelOfDetail = lodIndex;
}
LODMesh lodMesh = lodMeshes[lodIndex];
if (lodMesh.hasMesh)
{
previousLODIndex = lodIndex;
meshFilter.mesh = lodMesh.mesh;
if (mapGenerator.generateGameObjects && doneGOGen == false)
{
genGO = meshObject.AddComponent <GenerateGameObjects>();
genGO.seed = mapGenerator.seed;
genGO.offset = position;
genGO.mapData = mapData;
genGO.scale = scale;
genGO.genClouds = mapGenerator.generateClouds;
genGO.genWater = mapGenerator.generateWater;
genGO.isIsland = isIsland;
genGO.waterPlane = waterPlane;
genGO.StartGenerateObjects();
if (previousLODIndex != -1)
{
genGO.levelOfDetail = previousLODIndex;
}
else
{
genGO.levelOfDetail = 0;
}
doneGOGen = true;
}
if (doneGOGen)
{
genGO.StartGenerateObjects();
}
}
else if (!lodMesh.hasRequestedMesh)
{
lodMesh.RequestMesh(mapData);
}
}
if (lodIndex == 0)
{
if (collisionMesh.hasMesh)
{
meshCollider.sharedMesh = collisionMesh.mesh;
}
else if (collisionMesh.hasRequestedMesh)
{
collisionMesh.RequestMesh(mapData);
}
}
terrainChunksVisibleLastUpdate.Add(this);
}
}
SetVisible(visible);
}
public TerrainChunk(Vector2 coord, int size, LODInfo[] detailLevels, Transform parent, Material material, GameObject _waterPlane, GenerateGameObjects genGOs)
{
waterPlane = _waterPlane;
this.detailLevels = detailLevels;
position = coord * size;
if (mapGenerator.randomIslands)
{
float noise = Noise.GenerateNoise(mapGenerator.seed, new Vector2(position.x + mapGenerator.offset.x + mapGenerator.seed, position.y + mapGenerator.offset.y / mapGenerator.seed));
//print(noise);
if (noise >= mapGenerator.islandChance)
{
//It is just water and not an island
isIsland = false;
}
else
{
isIsland = true;
}
}
bounds = new Bounds(position, Vector2.one * size);
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
meshObject = new GameObject("Terrain Chunk, X: " + position.x + ", Y: " + position.y);
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshRenderer.material = material;
meshCollider = meshObject.AddComponent <MeshCollider>();
if (waterIns == null && mapGenerator.generateWater)
{
Vector3 _position = new Vector3(0, -0.22f * scale, 0);
if (isIsland)
{
_position.y = -6.6f;
}
waterIns = GameObject.Instantiate(waterPlane, _position, Quaternion.identity);
waterIns.transform.parent = meshObject.transform;
}
meshObject.transform.position = positionV3 * scale;
meshObject.transform.parent = parent;
if (isIsland == false)
{
meshObject.AddComponent <FixHeights>();
}
meshObject.transform.localScale = Vector3.one * scale;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod, UpdateTerrainChunk);
if (detailLevels[i].useForCollider)
{
collisionMesh = lodMeshes[i];
}
}
mapGenerator.RequestMapData(position, OnMapDataReceived);
}
