void Update()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo))
{
var ourHitObject = hitInfo.collider.transform.parent.gameObject;
if (ourHitObject.GetComponentInChildren <HexData>() != null)
{
if (Input.GetMouseButtonDown(0))
{
selectedHex = ourHitObject.GetComponentInChildren <HexData>();
}
if (selectedHex != null && Input.GetMouseButtonDown(0))
{
MoveUnit(selectedHex);
}
if (Input.GetMouseButtonDown(1))
{
Debug.Log("Click!");
var neigh = mapData.GenerateNeighboursData(ourHitObject.name);
foreach (var n in neigh)
{
Debug.Log(n);
}
}
}
}
}
private void LoadStuff(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
Stats.Current = Stats.LoadFromFile("statistics");
worker.ReportProgress(20);
Settings.Current = Settings.LoadFromFile("settings");
worker.ReportProgress(40);
HexData.LoadData(@"Resources\HexData");
worker.ReportProgress(60);
if (ClientManager.Connect())
{
ClientManager.Login();
ClientManager.CompareVersion();
}
else
{
Notification.Show("Konnte nicht mit Server verbinden");
}
worker.ReportProgress(80);
if (Stats.Current.FirstStart.Ticks == 0)
{
Stats.Current.FirstStart = DateTime.Now;
}
WindowState = Settings.Current.Fullscreen ? WindowState.Fullscreen : WindowState.Normal;
worker.ReportProgress(100);
}
void TriangulateBoundaryTriangle(
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 boundary, Color boundaryColor
)
{
Vector3 v2 = HexData.AddRealismNoiseToBaseMesh(HexData.StepOffset(begin, left, 1));
Color c2 = HexData.StepOffset(beginCell.Colour, leftCell.Colour, 1);
terrain.AddTriangleUnperturbed(HexData.AddRealismNoiseToBaseMesh(begin), v2, boundary);
terrain.AddTriangleColor(beginCell.Colour, c2, boundaryColor);
for (int i = 2; i < HexData.terraceSteps; i++)
{
Vector3 v1 = v2;
Color c1 = c2;
v2 = HexData.AddRealismNoiseToBaseMesh(HexData.StepOffset(begin, left, i));
c2 = HexData.StepOffset(beginCell.Colour, leftCell.Colour, i);
terrain.AddTriangleUnperturbed(v1, v2, boundary);
terrain.AddTriangleColor(c1, c2, boundaryColor);
}
terrain.AddTriangleUnperturbed(v2, HexData.AddRealismNoiseToBaseMesh(left), boundary);
terrain.AddTriangleColor(c2, leftCell.Colour, boundaryColor);
}
private void Awake()
{
HexData = new HexData(Game.GameConfig.hexSize);
Chunks = new Dictionary <Vector3, Chunk>();
//Tiles = new Dictionary<Vector3, HexTile>();
Generator = new WorldGenerator(Chunks);
}
public void SetData(HexData data)
{
// Destroy existing entity.
foreach (GameObject child in this.children)
{
Destroy(child);
}
this.children.Clear();
this.entityType = data.entityType;
this.entityData = data.entityData;
switch (data.entityType)
{
case EntityType.Vacant:
this.children.Add(Instantiate(PrefabBank.instance.greenHex, this.transform.position, Quaternion.identity));
break;
case EntityType.Obstacle:
this.children.Add(Instantiate(PrefabBank.instance.redHex, this.transform.position, Quaternion.identity));
break;
case EntityType.Player:
this.InstantiatePlayer(data.entityData);
break;
case EntityType.Item:
this.InstantiateItem(data.entityData);
break;
}
}
public CH34xSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface) : base(device, connection)
{
hexData = new HexData();
rtsCtsEnabled = false;
dtrDsrEnabled = false;
mInterface = device.GetInterface(iface >= 0 ? iface : 0);
}
void TriangulateCornerTerraces(
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
)
{
Vector3 v3 = HexData.StepOffset(begin, left, 1);
Vector3 v4 = HexData.StepOffset(begin, right, 1);
Color c3 = HexData.StepOffset(beginCell.Colour, leftCell.Colour, 1);
Color c4 = HexData.StepOffset(beginCell.Colour, rightCell.Colour, 1);
terrain.AddTriangle(begin, v3, v4);
terrain.AddTriangleColor(beginCell.Colour, c3, c4);
for (int i = 2; i < HexData.terraceSteps; i++)
{
Vector3 v1 = v3;
Vector3 v2 = v4;
Color c1 = c3;
Color c2 = c4;
v3 = HexData.StepOffset(begin, left, i);
v4 = HexData.StepOffset(begin, right, i);
c3 = HexData.StepOffset(beginCell.Colour, leftCell.Colour, i);
c4 = HexData.StepOffset(beginCell.Colour, rightCell.Colour, i);
terrain.AddQuad(v1, v2, v3, v4);
terrain.AddQuadColour(c1, c2, c3, c4);
}
terrain.AddQuad(v3, v4, left, right);
terrain.AddQuadColour(c3, c4, leftCell.Colour, rightCell.Colour);
}
public void CreateHex(int h, int w, int matIndex, Vector3 pos = new Vector3())
{
float shift;
if (IsOdd (h)){
shift = rowShift;
}
else{
shift = 0f;
}
var mat = hexGroup.hexes [matIndex].mat;
hexGraph [h, w] = new HexData ();
hexGraph [h, w].tile = Instantiate (hex) as GameObject;
var tile = hexGraph[h, w].tile;
tile.transform.parent = this.transform;
//Debug.Log (pos);
if (pos != new Vector3()) {
tile.transform.position = pos;
}
else{
tile.transform.position = new Vector3((w * 1.0f) + shift, 0f, (h * 0.87f));
}
tile.gameObject.GetComponent<MeshRenderer>().material = mat;
//hexGraph[h, w].mat = mat;
hexGraph[h, w].matIndex = matIndex;
hexGraph[h, w].position = tile.transform.position;
hexGraph[h, w].rotation = tile.transform.rotation;
}
private StageData GenerateRandomStage(int seed)
{
Random.InitState(seed);
int stripCount = Random.Range((this.minStrips - 1) / 2, (this.maxStrips - 1) / 2) * 2 + 1; // Should be odd?
int min = Mathf.Max(this.minLongestStripLength, stripCount / 2 + 1);
int maxStripLength = Random.Range(min, this.maxLongestStripLength + 1);
HoneycombData honey = HoneycombData.Generate(stripCount, maxStripLength);
// For each hex, give it random contents.
foreach (StripData stripData in honey.strips)
{
foreach (HexData data in stripData.hexes)
{
this.RandomizeHex(data);
}
}
// Pick a random starting location.
// Do this last so it replaces whatever was at the hex's location.
int strip = Random.Range(0, stripCount);
int hex = Random.Range(0, honey.GetStripLength(strip));
HexData hexData = honey.strips[strip].hexes[hex];
hexData.entityType = EntityType.Player;
hexData.entityData = HexData.PLAYER_DATA_HEAD;
StageData stageData = new StageData();
stageData.name = "Random stage from seed " + seed;
stageData.growthPerSegment = this.possibleGrowthPerSegment[Random.Range(0, this.possibleGrowthPerSegment.Length)];
stageData.honeycomb = honey;
return(stageData);
}
public void GenerateNew(List <TileData> tileDatas)
{
HexData hexData = new HexData(Game.instance.gameConfig.hexSize);
tiles = new Dictionary <Vector3, Tile>();
for (int r = -Game.instance.gameConfig.chunkSize / 2; r <= Game.instance.gameConfig.chunkSize / 2; r++)
{
for (int q = -Game.instance.gameConfig.chunkSize / 2; q <= Game.instance.gameConfig.chunkSize / 2; q++)
{
Vector3 pos = new Vector3(
r * hexData.Width() + q * (.5f * hexData.Width()),
0,
q * (hexData.Height() * .75f)
);
GameObject tileGO = Instantiate(tilePrefab, transform);
tileGO.transform.localPosition = pos;
tileGO.transform.localScale = tileGO.transform.localScale * hexData.Size();
tileGO.name = "Tile (" + q + ", " + r + ")";
Tile tile = tileGO.GetComponent <Tile>();
tile.coords = new Vector3(r, q, -r - q) + this.coords;
tile.chunk = this;
tile.biome = tileDatas[0].biome;
tile.tileType = tileDatas[0].tileType;
tileDatas.RemoveAt(0);
tile.SetColor(new Color(0, .5f, 0, .5f));
tiles.Add(new Vector3(r, q, -r - q), tile);
}
}
hasGenerated = true;
}
public Hex(int c, int r)
{
hexData = new HexData();
hexData.column = c;
hexData.row = r;
hexData.sum = -(c + r);
hexData.terrain = Terrain.Plains;
}
void HexInstantiation(GameObject Hex, float x, float y, int ID)
{
GameObject HexChild = Instantiate(Hex, new Vector3(x, y, 0), Quaternion.identity); //Create the hex given to it
HexChild.transform.parent = HexParent.transform; //Set the just-created hex as a child
HexDataScript = HexChild.GetComponent <HexData>(); //Get the HexData script from the newly instantiated child
HexDataScript.HexID = ID; //Give it an ID
HexChild.name = ID.ToString();
}
public void Parse183SessionProgress()
{
const string HexData =
"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";
var binaryData = HexData.ToByteArray().ToArray();
SipMessage.Parse(binaryData);
}
void MoveUnit(HexData target)
{
var source = GameObject.Find("Hex_" + selectedUnit.GetComponent <MoveableUnit>().tileX + "_" + selectedUnit.GetComponent <MoveableUnit>().tileY);
if (Input.GetMouseButtonDown(0))
{
movementControls.LoadPath(selectedUnit.GetComponent <MoveableUnit>().maxMoves, source.name, target.transform.parent.name);
}
}
public PL2303SerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface) : base(device, connection)
{
hexData = new HexData();
if (iface > 1)
{
throw new ArgumentException("Multi-interface PL2303 devices not supported!");
}
mInterface = device.GetInterface(iface >= 0 ? iface : 0);
}
void Awake()
{
instance = this;
gameConfig = JsonConvert.DeserializeObject <GameConfig>(File.ReadAllText(Directory.GetParent(Application.dataPath).FullName + "/Game/GameConfig.json").Replace(@"\", "/"));
hexData = new HexData(Game.instance.gameConfig.hexSize);
world = GameObject.Find("World").GetComponent <World>();
ChunkManagement.OnChunksManaged += SpawnPlayer;
}
private void RandomizeHex(HexData data)
{
if (Random.value < this.itemChance)
{
// Make item.
data.entityType = EntityType.Item;
if (Random.value < this.plusOneChance)
{
data.entityData = 1;
return;
}
if (Random.value < this.thenPlusTwoChance)
{
data.entityData = 2;
return;
}
if (Random.value < this.thenPlusThreeChance)
{
data.entityData = 3;
return;
}
if (Random.value < this.thenPlusSixChance)
{
data.entityData = 6;
return;
}
if (Random.value < this.thenMinusOneChance)
{
data.entityData = -1;
return;
}
if (Random.value < this.thenMinusTwoChance)
{
data.entityData = -2;
return;
}
if (Random.value < this.thenMinusThreeChance)
{
data.entityData = -3;
return;
}
data.entityData = -6;
return;
}
if (Random.value < this.thenObstacleChance)
{
// Make obstacle.
data.entityType = EntityType.Obstacle;
data.entityData = 0;
return;
}
// Make vacant.
data.entityType = EntityType.Vacant;
data.entityData = HexData.VACANT_DATA;
}
private void Awake()
{
instance = this;
hexData = new HexData(Game.instance.gameConfig.hexSize);
chunks = new Dictionary <Vector3, Chunk>();
hexCalc = new HexCalc();
seed = Random.Range(1, 1000000);
simplex = new Simplex(seed);
}
void Start()
{
if (!Game.instance.gameConfig.DEBUG)
{
Destroy(gameObject);
}
hexCalc = new HexCalc();
hexData = new HexData(Game.instance.gameConfig.hexSize);
textMesh = GetComponent <TextMesh>();
tile = GetComponentInParent <Tile>();
}
public void AddTriangle(Vector3 v1, Vector3 v2, Vector3 v3)
{
int vertexIndex = vertices.Count;
vertices.Add(HexData.AddRealismNoiseToBaseMesh(v1));
vertices.Add(HexData.AddRealismNoiseToBaseMesh(v2));
vertices.Add(HexData.AddRealismNoiseToBaseMesh(v3));
triangles.Add(vertexIndex);
triangles.Add(vertexIndex + 1);
triangles.Add(vertexIndex + 2);
}
public static LevelData GenerateLevel(DataTypes.BiomeType biome)
{
LevelData levelData = new LevelData()
{
levelId = -1,
levelName = "RandomLevel",
biomeType = biome,
gridCellSize = new Vector3(1.2f, 1, 1),
gridCellPosition = Vector3.zero,
pointMultiplier = 1,
isBossLevel = false,
movementType = BossMovement.None
};
int childCount = (int)(55f / chanceOfSpawn);//UnityEngine.Random.Range(30, 12 * 26);
Debug.Log("childCount" + childCount);
for (int i = 0; i < childCount; i++)
{
if (UnityEngine.Random.value > chanceOfSpawn || Mathf.FloorToInt((float)i / (float)xRange) - 5 > 13)
{
continue;
}
hexType = getBiomeHexType(biome, 0.15f);//getRandomHexType();
if (DataTypes.IsBiome(hexType))
{
health = Mathf.FloorToInt(UnityEngine.Random.Range(1, 4));
}
else if (hexType == DataTypes.HexType.Growth)
{
health = 3;
}
else
{
health = 1;
}
HexData hexData = new HexData()
{
hexType = hexType,
health = health,
points = 50,
hexScaleFactor = Vector3.one,
cellLocation = getCellLocation(i)
};
levelData.hexData.Add(hexData);
}
return(levelData);
}
public static EdgeVertices TerraceLerp(
EdgeVertices a, EdgeVertices b, int step)
{
EdgeVertices result;
result.v1 = HexData.StepOffset(a.v1, b.v1, step);
result.v2 = HexData.StepOffset(a.v2, b.v2, step);
result.v3 = HexData.StepOffset(a.v3, b.v3, step);
result.v4 = HexData.StepOffset(a.v4, b.v4, step);
result.v5 = HexData.StepOffset(a.v5, b.v5, step);
return(result);
}
public Vector2i?RegisterPawn(PawnControler pawnControler)
{
Vector2i gridCoordinate = HexagonUtils.ConvertOrthonormalToHexaSpace(pawnControler.transform.position);
if (HexData.Contains(gridCoordinate))
{
HexData[gridCoordinate].LocalPawns.Add(pawnControler);
return(gridCoordinate);
}
return(null);
}
public void SetData(StripData data)
{
if (this.hexes.Count != data.hexes.Length)
{
Debug.LogError("Cannot set strip data: data has wrong number of hexes.");
return;
}
for (int i = 0; i < this.hexes.Count; ++i)
{
HexData hexData = data.hexes[i];
this.hexes[i].SetData(hexData);
}
}
HexData copyHexData(HexData hexData)
{
HexData returnable = new HexData();
returnable.hexType = hexData.hexType;
returnable.health = hexData.health;
returnable.points = hexData.points;
returnable.hexScaleFactor = new Vector2(hexData.hexScaleFactor.x, hexData.hexScaleFactor.y);
returnable.cellLocation = new Vector3Int(hexData.cellLocation.x, hexData.cellLocation.y, hexData.cellLocation.z);
return(returnable);
}
public void LoadHexMap()
{
foreach (GameObject hex in hexGameObjects)
{
DestroyImmediate(hex);
}
string fullFilePath = Application.dataPath + "/Maps/" + "WarMap" + ".hexmap";
if (!File.Exists(fullFilePath))
{
fullFilePath = Application.persistentDataPath + "/Maps/" + "WarMap" + ".hexmap";
}
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.OpenRead(fullFilePath);
MapData mapData = (MapData)bf.Deserialize(file);
hexData = new Hex[mapWidth, mapHeight];
hexGameObjects = new GameObject[mapWidth, mapHeight];
int widthStart = 0;
for (int j = 0; j < mapHeight; ++j)
{
for (int i = widthStart; i < mapWidth + widthStart; ++i)
{
HexData loadedHex = mapData.hexData[i - widthStart, j];
Hex h = new Hex(loadedHex.column, loadedHex.row);
h.SetTerrain(mapData.hexData[i - widthStart, j].terrain);
GameObject hex = Instantiate(HexPrefab, h.Position(), Quaternion.identity, this.transform);
MeshRenderer mesh = hex.GetComponentInChildren <MeshRenderer>();
mesh.material = HexMaterials[(int)loadedHex.terrain];
hexData[i - widthStart, j] = h;
hexGameObjects[i - widthStart, j] = hex;
}
if (j % 2 != 0)
{
widthStart -= 1;
}
}
file.Close();
}
public static HexData SaveHexModel(HexModel hexModel)
{
HexData hexData = new HexData
{
Column = hexModel.Column,
Row = hexModel.Row,
TileData = new TileData(
new TileColorData(hexModel.TileColorModel.GetDrawingColor()),
new TileImageData(hexModel.TileImageModel.Id)),
DegreExploration = hexModel.DegreExploration,
Description = hexModel.Description
};
return(hexData);
}
private void MovePlayerSegmentOntoHex(Hex hex, bool isHead)
{
HexData data = this.currentData.strips[hex.stripNumber].hexes[hex.hexNumber];
// Check if the hex has an item. If so, apply its effects.
if (data.entityType == EntityType.Item)
{
this.currentData.player.totalGrowth = System.Math.Max(0, this.currentData.player.totalGrowth + data.entityData);
this.currentData.player.itemsCollected += 1;
}
// Turn the hex into a player hex.
data.entityType = EntityType.Player;
data.entityData = (isHead ? HexData.PLAYER_DATA_HEAD : HexData.PLAYER_DATA_BODY);
}
public void DecodeHex()
{
string hex = HexData?.Trim();
if (!string.IsNullOrWhiteSpace(hex))
{
hex = hex.Replace(" ", "").Replace("-", "").Replace("\r", "").Replace("\n", "");
int len = hex.Length / 2;
var tmp = new byte[len];
for (int i = 0; i < len; i++)
{
tmp[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
}
Data = tmp;
}
}
//Return true if entity is visible(enemy_visibility_range) to enemy based on enemies current x and z
public bool canSeeHex(HexData hex)
{
Debug.Log(hex + " = hex | " + hex.x + " | " + hex.z);
foreach(HexData h in hexManagerS.getAdjacentHexes(hex, sight_range)){
if(h.x == hex.x && h.z == hex.z)
{
//opponent is in sight range of enemy
Debug.Log ("canSeeHex: opponent is in sight range");
return true;
}
//Debug.Log ("...checking hex...");
}
//opponent isn't in sight range of enemy
Debug.Log ("canSeeHex: opponent is not in sight range");
return false;
}
private void Turn(bool isClockwise)
{
List <int> orderedIndex = new List <int>();
List <HexGUI> orderedSelectedHexGUIs = new List <HexGUI>();
for (int a = 0; a < selectedCoordinates.Count; a++)
{
float x = a == 0 ? int.MinValue : int.MaxValue;
float y = int.MaxValue;
int index = -1;
for (int i = 0; i < selectedCoordinates.Count; i++)
{
if (orderedIndex.Contains(i))
{
continue;
}
if ((a == 0 && selectedCoordinates[i].x > x || a > 0 && selectedCoordinates[i].x < x) || selectedCoordinates[i].x == x && selectedCoordinates[i].y < y)
{
x = selectedCoordinates[i].x;
y = selectedCoordinates[i].y;
index = i;
}
}
orderedIndex.Add(index);
}
for (int i = 0; i < orderedIndex.Count; i++)
{
orderedSelectedHexGUIs.Add(Utility.guiManager.mapGUI.getHex(selectedCoordinates[orderedIndex[i]]));
}
if (!isClockwise)
{
orderedSelectedHexGUIs.Reverse();
}
HexData thirdHexData = orderedSelectedHexGUIs[2].getHexData();
orderedSelectedHexGUIs[2].ChangeHexa(orderedSelectedHexGUIs[1].getHexData());
orderedSelectedHexGUIs[1].ChangeHexa(orderedSelectedHexGUIs[0].getHexData());
orderedSelectedHexGUIs[0].ChangeHexa(thirdHexData);
}
// Removes the player from the given hex. If the player's head is removed, a body segment will become their head.
// Assumes the shrinkage is valid and the player has at least one other segment remaining.
public void ShrinkPlayer(Hex hex)
{
this.PushUndoData();
HexData hexData = this.currentData.strips[hex.stripNumber].hexes[hex.hexNumber];
// Check if we are shrinking the head.
if (hexData.entityType == EntityType.Player && hexData.entityData == HexData.PLAYER_DATA_HEAD)
{
// Make a body segment the new head.
this.SetNewPlayerHead();
}
// Remove the player from the hex.
this.RemovePlayerFromHexData(hexData);
this.UpdateGameFromData();
}
//Find path from start node to destination node
//Distance function returns distance between two adjacent nodes
//Estimate function returns distance between any node and destination node
//Neighbors function returns adjacent traversible hexes for given hex input (Very hefty method)
public static Path FindPath(HexData start,
HexData destination, EntityE entity,
Func<HexData, HexData, double> distance,
Func<HexData, HexData, double> estimate,
Func<HexData, HexData, EntityE, List<HexData>> neighbours)
{
//set of already checked HexData
var closed = new HashSet<HexData>();
//queued HexData in open set
var queue = new PriorityQueue<double, Path>();
//start by adding enemy's hex to queue
queue.Enqueue(0, new Path (start));
while (!queue.IsEmpty)
{
//get first element on list
var path = queue.Dequeue();
//check to see if this element is in the set of already checked hexes, i.o the closed set
if (closed.Contains(path.ThisStep))
continue;
//check to see if this element is our destination hex
if (path.ThisStep.Equals(destination))
return path; //return full path to destination
//if element isn't the destination hex and isn't in closed set, add it to closed set
closed.Add(path.ThisStep);
//Go through neighbors (adjacent hexes) of current element
foreach(HexData n in neighbours(path.ThisStep, destination, entity))
{
//compute distance between current element and it's neighbor
double d = distance(path.ThisStep, n);
//New step added without modifying current path
var newPath = path.AddStep(n, d);
//add new path to queue
queue.Enqueue(newPath.TotalCost + estimate(n, destination), newPath);
}
}
return null;
}
public static void updateHexVisionState(HexData in_hex, Vision in_vision)
{
hexes[in_hex.x, in_hex.z].vision_state = in_vision;
}
public static VectorLine outlineHex(HexData hex)
{
MeshFilter ms = (MeshFilter)hex.hex_object.GetComponent("MeshFilter");
Vector3[] verts = new Vector3[(ms.mesh.vertices.Length + 1)];
// VectorLine
for(int i = 0; i < ms.mesh.vertices.Length; ++i)
verts[i] = ms.mesh.vertices[i] + y_adj_hex + hex.hex_object.transform.position;
verts[ms.mesh.vertices.Length] = ms.mesh.vertices[0] + y_adj_hex + hex.hex_object.transform.position;
for(int i = 0; i < verts.Length; ++i)
verts[i].y = 1;
return new VectorLine("border", verts, null, 8F,LineType.Continuous, Joins.Weld);
// VectorLine.MakeLine("border", verts).Draw3DAuto();
}
//True if enemy can can get to specified opponent
bool canGetToOpponent(HexData enemy, HexData opponent, EntityE entity_opponent, bool knows_opponents_location, ref List<HexData> path_to_opp)
{
if(knows_opponents_location){
//if enemy already "knows opponents location" then don't worry about visibility just get path to opponent
Debug.Log ("canGetToOpponent: knows enemy location, get path:" + entity_opponent);
path_to_opp = extractPath(hexManagerS.getTraversablePath(enemy, opponent, EntityE.Node, getTraverseAPCostPathVersion, getAdjacentTraversableHexes));
if(path_to_opp.Count == 0){
Debug.Log ("canGetToOpponent: knows enemy location, but can't find path");
return false;
}else{
Debug.Log ("canGetToOpponent: knows enemy location, and found path");
return true;
}
}
else
{
Debug.Log ("canGetToOpponent: doesn't know enemy location, see if enemy is visible in sight range: " + entity_opponent);
//TODO: TESTING****using old method*********
if(canSeeHex(opponent)){
//if(canSeeHex(opponent)){ ****
Debug.Log ("canGetToOpponent: doesn't know enemy location, get path to " + entity_opponent);
path_to_opp = extractPath(hexManagerS.getTraversablePath(enemy, opponent, EntityE.Node, getTraverseAPCostPathVersion, getAdjacentTraversableHexes));
if(path_to_opp.Count == 0){
Debug.Log ("canGetToOpponent: enemy is visible, but can't find path");
return false;
}else{
Debug.Log ("canGetToOpponent: enemy is visible, and found path");
return true;
}
}else{
Debug.Log ("canGetToOpponent: doesn't know enemy location, and enemy not visible");
return false;
}
}
}
public Path getPathFromMechTo(HexData destination)
{
Debug.LogWarning("getPathFromMechTo");
return hexManagerS.getTraversablePath(
hexManagerS.getHex(x, z),
hexManagerS.getHex(destination.x, destination.z),
EntityE.Player,
getTraverseAPCostPathVersion,
getAdjacentTraversableHexesPathVersion);
}
public bool makeMove(HexData hex)
{
if(!canTraverse(hex))
throw new MissingComponentException("Can't move to this spot, invalid location!");
//TODO add visual engine.move hooks
//update players hex tags
x = hex.x;
z = hex.z;
return true;
}
//Return adjacent hexes for the given entity position
public static HexData[] getAdjacentHexes(int x, int z)
{
//if we're out of bounds or if we're trying to get adjacency from a perimeter hex, return false
if(x < 0 || x > x_max || z < 0 || z > z_max || getHex(x, z).hex_type == Hex.Perimeter)
{
throw new KeyNotFoundException("Accessing out of bounds!");
}
//ALWAYS BUILD THIS ARRAY "CLOCKWISE" STARTING AT NORTH
HexData[] output = new HexData[6];
//Get North //Get Northeast
output[0] = hexes[x, z +1]; output[1] = hexes[x+1, z];
output[0].direction_from_central_hex = Facing.North;
output[1].direction_from_central_hex = Facing.NorthEast;
//Get Southeast //Get South
output[2] = hexes[x+1, z-1]; output[3] = hexes[x, z-1];
output[2].direction_from_central_hex = Facing.SouthEast;
output[3].direction_from_central_hex = Facing.South;
//Get Southwest //Get Northwest
output[4] = hexes[x-1, z]; output[5] = hexes[x-1, z+1];
output[4].direction_from_central_hex = Facing.SouthWest;
output[5].direction_from_central_hex = Facing.NorthWest;
return output;
}
public bool canTraverse(HexData hex)
{
return canTraverse(hex.x, hex.z);
}
public void updateFoWState()
{
hex_data = hexManagerS.getHex(hex_data.x, hex_data.z);
switch(hex_data.vision_state)
{
case Vision.Live:
renderer.material.SetColor("_Color", Color.white);
break;
case Vision.Visited:
renderer.material.SetColor("_Color", Color.gray);
break;
case Vision.Unvisted:
renderer.material.SetColor("_Color", Color.black);
break;
}
}
//Get path to base
public static Path getTraversablePath(HexData start, HexData destination, EntityE ignore_entity,
Func<HexData, HexData, double> traversal_cost_func,
Func<HexData, HexData, EntityE, List<HexData>> neighbor_hex_func)
{
//Send hex of base and hex of enemy to aStar
var path = aStar.FindPath(start, destination, ignore_entity, traversal_cost_func, calcCostToDestinationHex, neighbor_hex_func);
// if(path != null){
// last_path_cost = path.TotalCost;
// Debug.Log ("getTraversablePath: path cost = " + last_path_cost);
// }
return path;
}
public static HexData fillEntityData(HexData hex)
{
hex.added_occupier = EntityE.None;
if(isEntityPos(hex, EntityE.Player))
hex.added_occupier = EntityE.Player;
else if(isEntityPos(hex, EntityE.Base))
hex.added_occupier = EntityE.Base;
else if(isEntityPos(hex, EntityE.Enemy))
hex.added_occupier = EntityE.Enemy;
else
foreach(entityNodeS node in resource_node_list)
if(hex.x == node.x && hex.z == node.z)
{
hex.added_occupier = EntityE.Node;
}
return hex;
}
//Same has other canTraversHex except check to see if the indicated hex can be moved onto without considering excluded entity into calculations
//assumption is that if you send in "null" you will get to default case otherwise send it NODE
public static bool canTraverseHex(HexData hex, EntityE exclude)
{
return canTraverseHex(hex.x, hex.z, exclude);
}
//Check to see if the indicated hex can be moved onto, ie, its not occupied by an enemy, player, or base
public static bool canTraverseHex(HexData hex)
{
return canTraverseHex(hex.x, hex.z);
}
public static bool isEntityPos(HexData hex, EntityE entity)
{
return isEntityPos(hex.x, hex.z, entity);
}
public static Combatable getCombatableAt(HexData hex)
{
return getCombatableAt(hex.x, hex.z);
}
public static void setRoute(PathDisplay in_path, string _display_text, HexData _display_text_at)
{
display_text_at = _display_text_at;
display_text = _display_text;
if(current_path_display != null)
{
if(!current_path_display.Equals(in_path))
{
current_path_display.hidePath();
current_path_display.destroySelf();
}
}
current_path_display = in_path;
if(current_path_display != null)
{
current_path_display.displayPath();
}
}
public HexData[,] ResizeMD(HexData[,] hD, int h, int w)
{
HexData[,] newHexGraph = new HexData[h, w];
//Debug.Log ("New Size: " + newHexGraph.GetLength (0) + ", " + newHexGraph.GetLength (1)+"\nOld Size: "+hexGraph.GetLength(0)+", "+hexGraph.GetLength(1));
int hG0 = hD.GetLength (0);
int hG1 = hD.GetLength (1);
int nHG0 = newHexGraph.GetLength (0);
int nHG1 = newHexGraph.GetLength (1);
int iLength = Math.Max (hG0, nHG0);
int kLength = Math.Max (hG1, nHG1);
for (int i = 0; i < iLength; i++) {
for (int k = 0; k < kLength; k++){
//Debug.Log (i+" : "+k);
if(i < hG0 && i < nHG0 && k < hG1 && k < nHG1){
newHexGraph[i, k] = hD[i, k];
//Debug.Log ("Keep: "+i+":"+k+" : ");//+newHexGraph[i, k].tile.name);//.mat);
}
else{
if(i < hG0 && k < hG1){
//Debug.Log ("Destroy: "+i+":"+k+" : "+hD[i,k].tile.name);
Destroy (hD[i, k].tile);
}
}
}
}
//Debug.Log (newHexGraph.GetLength (0) + " " + newHexGraph.GetLength (1));
return hD = newHexGraph;
}
public static bool LoadFromString(string level_data)
{
string[] level_lines = level_data.Split(new string[] {"\n","\r\n"},StringSplitOptions.None);
int index = 0;
//INITIALIZE FILE TO READ\
// StreamReader reader;
// FileInfo filer = new FileInfo(Application.dataPath + "/Level_Files/" + level_name + ".pcl");
// if(filer != null && filer.Exists)
// {
// reader = filer.OpenText(); // returns StreamReader
// }
// else
// {
// print ("FILE DOES NOT EXIST!");
// return false;
// }
//BEGIN PARSING DATA
//PARSE HEADER INFO
print ("DEBUG " + level_lines[index]);
if(!level_lines[index++].Equals("LEVEL{"))
{
print("l1 ILL FORMATED!");
return false;
}
if(getIntR(level_lines[index++]) != level_editor_format_version) //EDITOR VER
{
print ("EDITOR VERSION MISMATCH!");
return false;
}
hexManagerS.level_name = getStringR(level_lines[index++]); //NAME
int version = getIntR(level_lines[index++]); //VERSION
int total_count, game_count, border_count;
hexManagerS.x_max = getIntR(level_lines[index++]);
hexManagerS.z_max = getIntR(level_lines[index++]);
int load_x_min = getIntR(level_lines[index++]);
int load_x_max = getIntR(level_lines[index++]);
int load_z_min = getIntR(level_lines[index++]);
int load_z_max = getIntR(level_lines[index++]);
hexManagerS.hexes = new HexData[hexManagerS.x_max, hexManagerS.z_max];
--hexManagerS.x_max;
--hexManagerS.z_max;
total_count = getIntR(level_lines[index++]); //total count
game_count = getIntR(level_lines[index++]); //game count
border_count = getIntR(level_lines[index++]); //border count
//BEGIN PARSING hexManagerS.hexes
if(!level_lines[index++].Contains("HEXES{"))
{
print("hexManagerS.hexes ILL FORMATED");
return false;
}
while(getHexR(level_lines[index++])) //next line is a HEX{
{
int x = getIntR(level_lines[index++]) - load_x_min;
int z = getIntR(level_lines[index++]) - load_z_min;
Vector3 pos = hexManagerS.CoordsGameTo3D(x,z);
GameObject new_hex = (GameObject) Instantiate(hexManagerS.hex_display, pos, Quaternion.identity);
engineHexS new_hex_script = (engineHexS) new_hex.GetComponent("engineHexS");
// print ("making hex: " + x + ", " + z);
Hex hex_type = (Hex) Enum.Parse(typeof(Hex), getStringR(level_lines[index++]));
HexData new_hex_data = new HexData(x, z, hex_type, new_hex, new_hex_script, Vision.Unvisted);
new_hex_script.assignHexData_IO_LOADER_ONLY(new_hex_data);
new_hex_script.SetVisiual();
hexManagerS.hexes[x, z] = new_hex_data;
new_hex_script.updateFoWState();
if(pos.x < enginePlayerS.camera_min_x_pos)
enginePlayerS.camera_min_x_pos = pos.x;
if(pos.x > enginePlayerS.camera_max_x_pos)
enginePlayerS.camera_max_x_pos = pos.x;
if(pos.z > enginePlayerS.camera_max_z_pos)
enginePlayerS.camera_max_z_pos = pos.z;
if(pos.z < enginePlayerS.camera_min_z_pos)
enginePlayerS.camera_min_z_pos = pos.z;
if(!getCBR(level_lines[index++]))
{
print("MALFORMED HEX!");
return false;
}
}
// print (reader.ReadLine());
//BEGIN PARSING ENTITES
if(!level_lines[index++].Contains("ENTITIES{"))
{
print("ENTITIES ILL FORMATED");
return false;
}
while(getEntR(level_lines[index++])) //next line is a HEX{
{
int x = getIntR(level_lines[index++]) - load_x_min;
int z = getIntR(level_lines[index++]) - load_z_min;
EntityE ent_type = (EntityE) Enum.Parse(typeof(EntityE), getStringR(level_lines[index++]));
print (ent_type);
if(ent_type == EntityE.Player)
{
// print ("MOVING CAMERA ONTO PLAYER!");
GameObject maincam = GameObject.FindGameObjectWithTag("MainCamera");
maincam.transform.position = new Vector3(hexManagerS.CoordsGameTo3D(x,z).x, 60, hexManagerS.CoordsGameTo3D(x,z).z);
}
switch(ent_type)
{
case EntityE.Base:
// print("base case");
int base_starting_health_percentage = getIntR(level_lines[index++]);
if(!entityManagerS.instantiateBase(x, z, base_starting_health_percentage))
throw new System.Exception("There is already one base, cannot have two! D: Go edit the level file you're loading to only have one!");
break;
case EntityE.Player:
// print("player case");
int mech_starting_health_percentage = getIntR(level_lines[index++]);
if(!entityManagerS.instantiatePlayer(x, z, mech_starting_health_percentage))
throw new System.Exception("There is already one player mech, cannot have two! D: Go edit the level file you're loading to only have one!");
// hexManagerS.getAdjacentHexes(entityManagerS.getBase().sentityManagerS.getBase().sight_range)updateFoWState()
break;
case EntityE.Enemy:
// print("enemy case");
bool enemy_knows_base_loc = getBoolR(level_lines[index++]);
bool enemy_knows_mech_loc = getBoolR(level_lines[index++]);
if(!entityManagerS.instantiateEnemy(x, z, enemy_knows_base_loc, enemy_knows_mech_loc))
throw new System.Exception("Issue adding enemy!");
break;
case EntityE.Node:
// print("node case");
Node node_type = getNodeR(level_lines[index++]);
NodeLevel node_starting_level = getNodeLevelR(level_lines[index++]);
entityManagerS.instantiateResourceNode(x, z, node_type, node_starting_level);
break;
}
if(!getCBR(level_lines[index++]))
{
print("MALFORMED HEX!");
return false;
}
enginePlayerS.setMech();
}
//
// Component[] meshFilters = GetComponentsInChildren<MeshFilter>();
// CombineInstance[] combine = new CombineInstance[meshFilters.length];
// int i = 0;
// while (i < meshFilters.length) {
// combine[i].mesh = meshFilters[i].sharedMesh;
// combine[i].transform = meshFilters[i].transform.localToWorldMatrix;
// meshFilters[i].gameObject.active = false;
// i++;
// }
// transform.GetComponent<MeshFilter>().mesh = new Mesh();
// transform.GetComponent<MeshFilter>().mesh.CombineMeshes(combine);
// transform.gameObject.active = true;
hexManagerS.setNodePresenseOnHexes();
return true;
}
void OnMouseOver()
{
if(hex_data.vision_state != Vision.Unvisted)
{
draw_mode = true;
if(!border.active)
border.active = true;
if(!glow.active)
glow.active = true;
border.SetColor(enginePlayerS.select_color);
border.Draw3DAuto();
glow.Draw3DAuto();
HexData mech_hex = hexManagerS.getHex(entityManagerS.getMech().x, entityManagerS.getMech().z);
//if mech standing on this hex
if(mech_hex.Equals(hex_data))
{
//if the mech is on this hex, and this hex has a node as well
if(node_occupier)
{
// Debug.LogWarning("STANDING ON HEX WITH NODE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
genTextString(SelectLevel.Scavenge, entityManagerS.getMech().getScavengeAPCost());
if(entityManagerS.getMech().current_ap > entityManagerS.getMech().getScavengeAPCost() && node_data.node_level != NodeLevel.Empty)
border.SetColor(enginePlayerS.scavenge_color);
else
{
genTextString(SelectLevel.Scavenge, -999);
border.SetColor(enginePlayerS.disable_color);
}
enginePlayerS.setRoute(null, display_text, hex_data);
return;
}
enginePlayerS.setRoute(null, "", hex_data);
return;
}
// if()
//if the path is no longer starting from where the player mechu currently is...
if(!mech_location_when_path_made.Equals(mech_hex) || path_display == null || path_display.path_line == null)
{
if(path_display != null)
path_display.destroySelf();
path_from_mech = entityManagerS.getMech().getPathFromMechTo(hexManagerS.getHex (hex_data.x, hex_data.z));
path_display = pathDrawS.getPathLine(path_from_mech);
mech_location_when_path_made = mech_hex;
}
//if the mech could possibly walk here
if(path_display != null && entityManagerS.getMech().canTraverse(hex_data))
{
genTextString(SelectLevel.Travel, (int) path_from_mech.TotalCost);
enginePlayerS.setRoute(path_display, display_text, hex_data);
}
else
{
genTextString(SelectLevel.Disabled, -1);
enginePlayerS.setRoute(null, display_text, hex_data);
}
}
}
public List<HexData> getAdjacentTraversableHexesPathVersion(HexData hex, HexData destination, EntityE entity)
{
List<HexData> result_hexes = new List<HexData>(); //hold resulting hexes
//Get adjacent tiles around player mech
HexData[] adjacent_hexes = hexManagerS.getAdjacentHexes(hex.x, hex.z);
//Debug.Log(adjacent_hexes.Length + " found adjacent");
//See which of the adjacent hexes are traversable
for(int i = 0; i < adjacent_hexes.Length; i++){
if(entityManagerS.isEntityPos(adjacent_hexes[i], entity) || (canTraverse(adjacent_hexes[i]) && adjacent_hexes[i].vision_state != Vision.Unvisted))
{
//add hex to traversable array
result_hexes.Add(adjacent_hexes[i]);
}
}
//Debug.Log ("Number of result_hexes " + result_hexes.Count);
return result_hexes;
// return getAdjacentTraversableHexes();
}
public bool makeMove(HexData hex)
{
facing_direction = hex.direction_from_central_hex;
if(!canTraverse(hex))
throw new MissingComponentException("Can't move to this spot, invalid location!");
//subtract ap cost from total
current_ap -= getTraverseAPCost(hex.hex_type);
//update enemy hex tags
moveInWorld(hex.x, hex.z, 2F);
x = hex.x;
z = hex.z;
return true;
}
public double getTraverseAPCostPathVersion(HexData hex_start, HexData hex_end)
{
return (double) getTraverseAPCost(hex_end.hex_type);
}
public static List<HexData> getAdjacentHexes(HexData center, int sight_range)
{
List<HexData> hexes_in_range = new List<HexData>();
//get the hex standing on
HexData current_hex = center;
hexes_in_range.Add(current_hex);
//enter loop for surrounding hexes
for(int ring = 1; ring <= sight_range; ring++)
{
//draw the first "northeast" edge hex
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.NorthEast);
hexes_in_range.Add(current_hex);
//draw the "northeast" portion
for(int edge_hexes_drawn = 1; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.SouthEast);// = AddHexSE(overwrite, border_mode, clicked_hex_type, brush_size, current_hex.transform.position, draw_hex_type, xcrd(current_hex), zcrd(current_hex));
hexes_in_range.Add(current_hex);
}
//draw the "southeast" portion
for(int edge_hexes_drawn = 0; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.South);
hexes_in_range.Add(current_hex);
}
//draw the "south" portion
for(int edge_hexes_drawn = 0; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.SouthWest);
hexes_in_range.Add(current_hex);
}
//draw the "southwest" portion
for(int edge_hexes_drawn = 0; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.NorthWest);
hexes_in_range.Add(current_hex);
}
//draw the "northwest" portion
for(int edge_hexes_drawn = 0; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.North);
hexes_in_range.Add(current_hex);
}
//draw the "north" portion
for(int edge_hexes_drawn = 0; edge_hexes_drawn < ring; ++edge_hexes_drawn)
{
current_hex = hexManagerS.getHex(current_hex.x, current_hex.z, Facing.NorthEast);
hexes_in_range.Add(current_hex);
}
}
Debug.LogWarning("hexes_in_range size = " + hexes_in_range.Count);
return hexes_in_range;
}
public void moveToHex(HexData location, bool _standing_on_top_of_node)
{
current_ap -= location.traversal_cost;
setLocation(location.x, location.z);
moveInWorld(location.x, location.z, 6F);
setFacingDirection(location.direction_from_central_hex);
updateFoWStates();
is_standing_on_node = _standing_on_top_of_node;
}
//Get path to base
// public static Path getTraversablePathAsListRemoveFrontBack (HexData start, HexData destination, EntityE ignore_entity,
// Func<HexData, HexData, double> traversal_cost_func,
//// Func<HexData, HexData, double> destination_cost_estimate_func,
// Func<HexData, HexData, EntityE, List<HexData>> neighbor_hex_func)
// {
// //Send hex of base and hex of enemy to aStar
// var path = aStar.FindPath(start, destination, ignore_entity, traversal_cost_func, calcEstimate, neighbor_hex_func);
// }
// #region IPathFind implementation
public static double calcCostToDestinationHex(HexData hex_start, HexData hex_end)
{
//TODO: may need to be adjusted later
return Math.Abs(hex_start.x - hex_end.x) + Math.Abs(hex_start.z - hex_end.z);
}
public void assignHexData_IO_LOADER_ONLY(HexData _hex_data)
{
hex_data = _hex_data;
}
//alternative can traverse methods where an entity can be excluded from search
public bool canTraverse(HexData hex, EntityE entity)
{
return canTraverse(hex.x, hex.z, entity);
}
