public virtual void BeginTurn()
{
isCharacterTurn = true;
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
tempMap.tileDataMap.GetTile(currentTileIndex).IsTraversable = true;
}
public void SetSelectedTile(int x, int z)
{
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
Component selectedTile = transform.FindChild("SelectedTile");
if (!showMarker)
{
selectedTile.GetComponent <Renderer>().enabled = false;
return;
}
else
{
selectedTile.GetComponent <Renderer>().enabled = true;
}
prevSelectedTileIndex = selectedTileIndex;
selectedTileIndex = (int)(x + (z * tileSizeX));
selectedTileData = tempMap.tileDataMap.GetTile(selectedTileIndex);
selectedTile.transform.position = new Vector3(x + 0.5f, tempMap.tileDataMap.GetTile(selectedTileIndex).Pos.y + 0.0001f, z + 0.5f);
if (selectedTileData.IsTraversable)
{
selectedTile.GetComponent <Renderer>().material.color = Color.white;
}
else
{
selectedTile.GetComponent <Renderer>().material.color = Color.red;
}
}
public virtual void InitializeCharacter(int tileIndex) // TODO: Change to protected when classes are inheriting
{
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
tempMap.tileDataMap.GetTile(tileIndex).IsTraversable = false;
transform.position = tempMap.tileDataMap.GetTile(tileIndex).Pos;
pathList = new List <TDTile>();
pathIndex = -1;
currentTileIndex = tileIndex;
skillsList = new List <BaseSkill>();
BaseSkill tempSkill = new BaseSkill();
tempSkill.SkillName = "Skill Number 1";
BaseSkill tempSkill2 = new BaseSkill();
tempSkill2.SkillName = "Skill Number 2";
skillsList.Add(tempSkill);
skillsList.Add(tempSkill2);
byte[] fileData;
fileData = File.ReadAllBytes("Assets/Resources/Character Portraits/Human.jpg");
Texture2D tex = new Texture2D(2, 2);
tex.LoadImage(fileData);
characterPortrait = Sprite.Create(tex, new Rect(0, 0, 50, 50), new Vector2(0.5f, 0.5f));
}
public override void StartAlgorithm(TDTile start, TDTile end, TGMap map)
{
algoSteps.Clear();
SimplePriorityQueue <TDTile> frontier = new SimplePriorityQueue <TDTile>();
frontier.Enqueue(start, 0);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
Dictionary <TDTile, float> costSoFar = new Dictionary <TDTile, float>();
costSoFar.Add(start, 0);
float priority = 0.0f;
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue;
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
algoTiles.Add(nextTile);
float newCost = costSoFar[currentTile] + map.GetCostByTileType(nextTile.GetTileType());
if (!costSoFar.ContainsKey(nextTile) || newCost < costSoFar[nextTile])
{
costSoFar[nextTile] = newCost;
priority = newCost;
frontier.Enqueue(nextTile, priority);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile);
}
}
}
GeneratePath(end, cameFrom);
}
// Use this for initialization
void Start()
{
_pathManager = (PathManager)FindObjectOfType(typeof(PathManager));
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
tileSize = tempMap.tileSize;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (GUILayout.Button("Regenerate"))
{
TGMap tileMap = (TGMap)target;
tileMap.BuildMesh();
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (GUILayout.Button("Regenerate"))
{
TGMap map = (TGMap)target;
map.BuildMesh();
}
}
IEnumerator Start()
{
coll = GetComponent <Collider>();
_tileMap = GetComponent <TGMap>();
while (Grid_creator.instance == null || !Grid_creator.instance.Loaded)
{
yield return(new WaitForSeconds(5 * Time.deltaTime));
}
v *= Grid_creator.instance.node_radius;
}
public override void StartAlgorithm(TDTile start, TDTile end, TGMap map)
{
algoSteps.Clear();
SimplePriorityQueue <TDTile> frontier = new SimplePriorityQueue <TDTile>();
frontier.Enqueue(start, 0);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
float priority = 0.0f;
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
Debug.Log("Dequeue Tile: " + currentTile.GetHashCode());
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue;
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
algoTiles.Add(nextTile);
if (!cameFrom.ContainsKey(nextTile))
{
priority = Heuristic(end, nextTile) + ComputeVectorCrossProduct(start, end, nextTile); // TODO: add priority field to TDTile? to debug and or display priority in game
frontier.Enqueue(nextTile, priority);
//Debug.Log("Enqueue Tile: " + nextTile.GetHashCode() + " - priority: " + priority);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile); // WRONG! WE NEED TO LOOK AT THE TILE WITH LOWEST HEURISTIC FIRST
}
}
}
GeneratePath(end, cameFrom);
}
protected bool IsDiagonalStepAllowed()
{
TGMap tgm = GameObject.Find("TileMap").GetComponent <TGMap>();
if (tgm == null || !tgm.allowDiagonalStep)
{
return(false);
}
return(true);
}
public virtual void EndTurn()
{
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
tempMap.tileDataMap.GetTile(currentTileIndex).IsTraversable = false;
PathManager tempPathManager = (PathManager)FindObjectOfType(typeof(PathManager));
tempPathManager.ClearPath();
moveCharacter = false;
isCharacterTurn = false;
}
// float v = 0.5f;
public override void OnInspectorGUI()
{
DrawDefaultInspector();
// EditorGUILayout.BeginVertical ();
// v = EditorGUILayout.Slider (v, 0, 2.0f);
// EditorGUILayout.EndVertical ();
if (GUILayout.Button("Regenerate"))
{
TGMap tileMap = (TGMap)target;
tileMap.BuildMesh();
}
}
void Update()
{
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
CharacterManager tempCharacterManager = (CharacterManager)FindObjectOfType(typeof(CharacterManager));
if (prevSelectedTileIndex != selectedTileIndex)
{
myPathSearch.AStar(tempMap.tileDataMap.GetTile(tempCharacterManager.GetCurrentCharacterTileIndex()), tempMap.tileDataMap.GetTile(selectedTileIndex));
pathSolution = myPathSearch.GetSolution();
tempCharacterManager.SetCharacterPath(pathSolution);
PathMarkerMaintence();
}
}
protected float ComputeVectorCrossProduct(TDTile start, TDTile goal, TDTile current)
{
TGMap tgm = GameObject.Find("TileMap").GetComponent <TGMap>();
if (tgm == null || !tgm.computeVectorCrossProduct)
{
return(0.0f);
}
float dx1 = current.GetX() - goal.GetX();
float dy1 = current.GetY() - goal.GetY();
float dx2 = start.GetX() - goal.GetX();
float dy2 = start.GetY() - goal.GetY();
return(System.Math.Abs(dx1 * dy2 - dx2 * dy1) * 0.001f);
}
public override void StartAlgorithm(TDTile start, TDTile end, TGMap map = null)
{
algoSteps.Clear();
Queue <TDTile> frontier = new Queue <TDTile>();
frontier.Enqueue(start);
Dictionary <TDTile, TDTile> cameFrom = new Dictionary <TDTile, TDTile>();
cameFrom.Add(start, null);
while (frontier.Count > 0)
{
TDTile currentTile = frontier.Dequeue();
if (currentTile.GetTileType() == (int)TILE_TYPE.ENDPOINT)
{
break;
}
AlgorithmStep algoStep = new AlgorithmStep(currentTile);
algoSteps.Add(algoStep);
foreach (TDTile nextTile in currentTile.neighbours)
{
if (nextTile == null || nextTile.GetTileType() == (int)TILE_TYPE.WATER || nextTile.GetTileType() == (int)TILE_TYPE.WALL)
{
continue; // || == START TYLE !?
}
// diagonal step check: if neighbour is diagonal but diagonal step not allowed --> we skip
if (IsDiagonalNeighbour(currentTile, nextTile) && !IsDiagonalStepAllowed())
{
continue;
}
if (!cameFrom.ContainsKey(nextTile))
{
frontier.Enqueue(nextTile);
cameFrom.Add(nextTile, currentTile);
algoStep.NeighbourTiles.Add(nextTile);
}
}
}
GeneratePath(end, cameFrom);
}
void Start()
{
selectedTileIndex = 0;
TGMap tempMap = (TGMap)FindObjectOfType(typeof(TGMap));
tileSizeX = tempMap.size_x;
myPathSearch = GetComponent <PathSearch>();
pathSolution = new List <TDTile>();
pathMarkerList = new List <GameObject>();
Component selectedTile = transform.FindChild("SelectedTile");
selectedTile.GetComponent <Renderer>().enabled = false;
showMarker = false;
moveCharacter = false;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (GUILayout.Button("Reconstruct"))
{
TGMap tilemap = (TGMap)target;
tilemap.ConstructMesh();
}
if (GUILayout.Button("Build Walls"))
{
TGMap tilemap = (TGMap)target;
tilemap.ConstructWalls();
}
if (GUILayout.Button("Delete Walls"))
{
TGMap tilemap = (TGMap)target;
tilemap.RemoveWallsEditor();
}
}
// Use this for initialization
void Start()
{
_TGMap = GetComponent<TGMap>();
}
public void SetMap(TGMap map)
{
this.map = map;
}
public void SetTGMap(TGMap map)
{
_map = map;
}
public void StartAlgorithm()
{
TGMap tgmap = tileMap.GetComponent <TGMap>();
tgmap.StartAlgorithm(algorithms[dropdown.value]);
}
public void Clear()
{
TGMap tgmap = tileMap.GetComponent <TGMap>();
tgmap.ClearAlgorithm();
}
// Use this for initialization
void Start()
{
_instance = this;
_map = GetComponent <TGMap>();
_dispatcher = new EDDispatcher();
}
void Start()
{
_instance = this;
_map = gameObject.GetComponent <TGMap> ();
endGameDialog.gameObject.SetActive(false);
}
// Update is called once per frame
public void BuildMesh()
{
instance = this;
MapCreated = false;
MapWorldSize = new Vector2(size_x * tileSize, size_y * tileSize);
if (grid != null)
{
grid.node_radius = tileSize / 2;
grid.GridWorldSize = MapWorldSize;
}
CalcTex();
Global_TDMap = new TDMap(size_x, size_y, MapTerrainType, TileChance, MaxHeightForPlants, MaxHeightLeap);
int numTiles = size_x * size_y;
int numTris = numTiles * 2;
int vsize_x = size_x * 2;
int vsize_y = size_y * 2;
int numVerts = vsize_x * vsize_y;
if (vsize_x * vsize_y > 65000)
{
size_x = 125;
size_y = 125;
return;
}
Vector3[] vertices = new Vector3[numVerts];
Vector3[] normals = new Vector3[numVerts];
Vector2[] uv = new Vector2[numVerts];
int[] triangles = new int[numTris * 3];
int x, y;
Vector3 sp = Vector3.zero;
sp.x -= tileSize * size_x / 2;
sp.y -= tileSize * size_x / 2;
float r = Random.Range(-2f, 2f);
for (y = 0; y < vsize_y; y++)
{
for (x = 0; x < vsize_x; x++)
{
vertices[y * vsize_x + x] = new Vector3((x + 1) / 2 * tileSize, (y + 1) / 2 * tileSize, 0) + sp;
normals[y * vsize_x + x] = new Vector3(0, 0, -1);
uv[y * vsize_x + x] = GetTexture(Global_TDMap.GetTile(x / 2, y / 2).type, x, y);
}
}
if (Heights)
{
for (y = 1; y < vsize_y - 1; y += 2)
{
for (x = 1; x < vsize_x - 1; x += 2)
{
r = Random.Range(0, 0);
if (Global_TDMap.GetIfWater(x / 2, y / 2))
{
r = -Random.Range(-8f, -10f);
}
else
{
r = Global_TDMap.GetIfMountine((x + 0) / 2, (y + 0) / 2);
}
vertices[y * vsize_x + x].z = r;
vertices[y * vsize_x + x + 1].z = r;
vertices[(y + 1) * vsize_x + x].z = r;
vertices[(y + 1) * vsize_x + x + 1].z = r;
}
}
for (y = 0; y < vsize_y; y++)
{
vertices[y * vsize_x].z = vertices[y * vsize_x + 1].z;
vertices[y * vsize_x + vsize_x - 1].z = vertices[y * vsize_x + vsize_x - 2].z;
}
for (x = 0; x < vsize_x; x++)
{
vertices[x].z = vertices[vsize_x + x].z;
vertices[(vsize_y - 1) * vsize_x + x].z = vertices[(vsize_y - 2) * vsize_x + x].z;
}
print("End OF Heights!");
}
for (y = 0; y < size_y; y++)
{
for (x = 0; x < size_x; x++)
{
//x = 1
int squareIndex = y * size_x + x;
int triOffset = squareIndex * 6;
triangles[triOffset + 0] = (y * 2) * vsize_x + (x * 2) + 0;
triangles[triOffset + 1] = (y * 2) * vsize_x + (x * 2) + vsize_x + 0;
triangles[triOffset + 2] = (y * 2) * vsize_x + (x * 2) + vsize_x + 1;
triangles[triOffset + 3] = (y * 2) * vsize_x + (x * 2) + 0;
triangles[triOffset + 4] = (y * 2) * vsize_x + (x * 2) + vsize_x + 1;
triangles[triOffset + 5] = (y * 2) * vsize_x + (x * 2) + 1;
}
}
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uv;
mesh.triangles = triangles;
MeshFilter mesh_filter = GetComponent <MeshFilter>();
MeshRenderer mesh_renderer = GetComponent <MeshRenderer>();
MeshCollider mesh_collider = GetComponent <MeshCollider>();
mesh_filter.mesh = mesh;
mesh_collider.sharedMesh = mesh;
Debug.Log("Done Mesh!");
//BuildTexture();
OnMapGenerator GenerateTrees = new OnMapGenerator(Global_TDMap, size_x, size_y, tileSize, MapHolder);
StartCoroutine(GenerateTreesEI(GenerateTrees));
//MapCreated = true;
}
void Start()
{
_tileMap = GetComponent <TGMap>();
}
public abstract void StartAlgorithm(TDTile start, TDTile end, TGMap map);
