public void CreatePathDebug(TerrainManager TerrainManager_, ja2.TerrainTile From, ja2.TerrainTile To)
{
if (actualTask != null)
actualTask.Stop();
actualTask = new utils.Task(CreatePathDebug_CoRo(TerrainManager_, From, To));
}
public void CreateTerrain(ja2.Map Map_, ja2.TerrainMaterialManager MatManager)
{
if(Map_.width % ja2.TerrainPartition.PARTITION_WIDTH != 0 || Map_.width % ja2.TerrainPartition.PARTITION_WIDTH != 0)
throw new System.ArgumentException("Map width/height must be normalized to terrain partition width/height.");
// Create component
mapInstance = ScriptableObject.CreateInstance<MapInstance>();
mapInstance.map = Map_;
// Need to create terrain partitions
int partition_width = Map_.width / ja2.TerrainPartition.PARTITION_WIDTH;
int partition_height = Map_.height / ja2.TerrainPartition.PARTITION_HEIGHT;
for (int i = 0; i < partition_height; ++i)
{
for (int j = 0; j < partition_width; ++j)
{
// Create terrain GO
GameObject terrain_go = new GameObject(PARTITION_NAME + j + "_" + i);
terrain_go.isStatic = true;
// Set parent
terrain_go.transform.parent = transform;
// Update position
Vector3 tile_vertex_0 = ja2.TerrainPartition.TileVertex(j * ja2.TerrainPartition.PARTITION_WIDTH, i * ja2.TerrainPartition.PARTITION_HEIGHT, 0);
Vector3 tile_vertex_1 = ja2.TerrainPartition.TileVertex(j * ja2.TerrainPartition.PARTITION_WIDTH, i * ja2.TerrainPartition.PARTITION_HEIGHT, 1);
terrain_go.transform.position = new Vector3(tile_vertex_0.x, 0, tile_vertex_1.z);
// Set layer
terrain_go.layer = Terrain.LAYER;
// Create component
var terrain = terrain_go.AddComponent<Terrain>();
terrain.CreatePartition(j, i, mapInstance, MatManager);
}
}
}
//! Create A* path.
public ja2.TerrainTile[] CreatePath(TerrainManager TerrainManager_, ja2.TerrainTile From, ja2.TerrainTile To)
{
lastPath = new ja2.AStarPathMap(TerrainManager_, From, To);
while (lastPath.RunOnce() == ja2.AStarPathMap.State.WAIT)
;
return lastPath.Path();
}
//! Update soldier GO.
public void UpdateSoldier(ja2.Soldier Soldier_, GameObject SoldierGO)
{
var combined_mesh_com = SoldierGO.GetComponent<SoldierController>();
// Remove old combined mesh
Destroy(combined_mesh_com.combinedMesh);
// Create new
combined_mesh_com.combinedMesh = charEntityManager.Create(Soldier_.character(), SoldierGO);
// Must use task here because of unity bug - When mesh is replaced,
// animation stops to play and is shown in T-pose
new utils.Task(RebuildCharacterWorkaround(SoldierGO));
}
//! Get tile position for given tile.
public Vector3 GetPosition(ja2.TerrainTile Tile, short Vertex)
{
// Get the partition used
int partition_x = Tile.x / ja2.TerrainPartition.PARTITION_WIDTH;
int partition_y = Tile.y / ja2.TerrainPartition.PARTITION_HEIGHT;
// Compute normalized terrain tile position
int normalized_x = Tile.x - ja2.TerrainPartition.PARTITION_WIDTH * partition_x;
int normalized_y = Tile.y - ja2.TerrainPartition.PARTITION_HEIGHT * partition_y;
GameObject terrain_go = GameObject.Find(PARTITION_NAME + partition_x + "_" + partition_y);
return terrain_go.transform.TransformPoint(terrain_go.GetComponent<Terrain>().GetTilePosition(normalized_x, normalized_y, Vertex));
}
//! Create full mercenary GO.
public GameObject CreateSoldier(ja2.Soldier Soldier_)
{
// Load prefab of soldier
var soldier_go = utils.PrefabManager.Create("Soldier");
// Associate solder
soldier_go.GetComponent<SoldierController>().SetMercenary(Soldier_);
// Create skinned mesh on parameters and save it
soldier_go.GetComponent<SoldierController>().combinedMesh = charEntityManager.Create(Soldier_.character(), soldier_go);
// Activate now, because now is everything set up and we won't get
// any errors from bones mismatch etc
soldier_go.SetActive(true);
return soldier_go;
}
public SoldierPathManager(SoldierController Soldier, ja2.TerrainTile[] Tiles)
{
ja2.TerrainTile previous = null;
// Move distance
ushort move_distance = 0;
// Last direction
ja2.Map.Direction last_direction = ja2.Map.Direction.NONE;
// Create action controller
soldierActions = new ja2.SoldierActionController(Soldier);
// Actual vertex
foreach (var tile in Tiles)
{
// Not first tile
if (previous != null)
{
// Get actual direction
ja2.Map.Direction dir = ja2.Map.GetDirection(previous, tile);
// Direction change
if (last_direction != dir)
{
// Queue move first if needed
if (move_distance > 0)
{
var action = new ja2.SoldierActionMove(move_distance);
soldierActions.Add(action);
move_distance = 0;
}
// Set rotation
soldierActions.Add(new ja2.SoldierActionRotate(ja2.LookDirectionConverter.Convert(dir)));
}
// byte rot = (byte)ja2.LookDirectionConverter.Convert(dir);
// Must be move
++move_distance;
// Update last direction
last_direction = dir;
}
// Update previous tile
previous = tile;
}
// Queue move if was any
if (move_distance != 0)
{
var action = new ja2.SoldierActionMove(move_distance);
soldierActions.Add(action);
}
}
//! Create path visualization.
public void CreatePath(ja2.TerrainTile[] Tiles)
{
// Mesh for path visualizer
Mesh mesh = new Mesh();
// Create arrays needed
var vertices = new Vector3[(Tiles.Length - 1) * 4];
var uv1 = new Vector2[vertices.Length];
var triangles = new int[(vertices.Length / 4) * 2 * 3];
// Vertex iterator
int vertex_iterator = vertices.Length - 4;
ja2.TerrainTile previous = null;
// Actual vertex
foreach (var tile in Tiles)
{
// Actual vertex
int actual_vertex = vertex_iterator;
// Not first tile
if (previous != null)
{
// Get actual direction
ja2.Map.Direction dir = ja2.Map.GetDirection(previous, tile);
// Set vertices
vertices[actual_vertex++] = new Vector3(terrainManager.GetPosition(tile, 0).x, 0, terrainManager.GetPosition(tile, 0).z);
vertices[actual_vertex++] = new Vector3(terrainManager.GetPosition(tile, 1).x, 0, terrainManager.GetPosition(tile, 1).z);
vertices[actual_vertex++] = new Vector3(terrainManager.GetPosition(tile, 2).x, 0, terrainManager.GetPosition(tile, 2).z);
vertices[actual_vertex++] = new Vector3(terrainManager.GetPosition(tile, 3).x, 0, terrainManager.GetPosition(tile, 3).z);
// Hardcoded for now, need to change
float texel_step = 0.125f;
byte rot = (byte)ja2.LookDirectionConverter.Convert(dir);
uv1[actual_vertex - 4] = new Vector2(texel_step * rot + texel_step / 2, 1);
uv1[actual_vertex - 3] = new Vector2(texel_step * rot, 0.5f);
uv1[actual_vertex - 2] = new Vector2(texel_step * rot + texel_step / 2, 0);
uv1[actual_vertex - 1] = new Vector2(texel_step * rot + texel_step, 0.5f);
int triangle_index = (((actual_vertex / 4) - 1) * 3 * 2);
triangles[triangle_index++] = actual_vertex - 4;
triangles[triangle_index++] = actual_vertex - 1;
triangles[triangle_index++] = actual_vertex - 3;
triangles[triangle_index++] = actual_vertex - 3;
triangles[triangle_index++] = actual_vertex - 1;
triangles[triangle_index++] = actual_vertex - 2;
// Go backwards
vertex_iterator -= 4;
}
// Update previous tile
previous = tile;
}
// Visualize path
mesh.vertices = vertices;
mesh.uv = uv1;
mesh.triangles = triangles;
mesh.RecalculateNormals();
meshFilter.sharedMesh = mesh;
renderer.sharedMaterial = (Material)Resources.Load("Materials/Steps", typeof(Material));
}
//! Get position of center of tile.
public Vector3 GetPosition(ja2.TerrainTile Tile)
{
return new Vector3(GetPosition(Tile, 1).x, 0, GetPosition(Tile, 0).z);
}
public System.Collections.IEnumerator CreatePathDebug_CoRo(TerrainManager TerrainManager_, ja2.TerrainTile From, ja2.TerrainTile To)
{
lastPath = new ja2.AStarPathMap(TerrainManager_, From, To);
ja2.AStarPathMap.State state;
do
{
yield return new WaitForSeconds(time);
state = lastPath.RunOnce();
} while (state == ja2.AStarPathMap.State.WAIT);
}
//! Convert look direction to move direction.
protected static ja2.Map.Direction LookDirToMoveDir(ja2.LookDirection Direction)
{
ja2.Map.Direction move_dir = ja2.Map.Direction.NONE;
switch(Direction)
{
case ja2.LookDirection.EAST:
move_dir = ja2.Map.Direction.EAST;
break;
case ja2.LookDirection.SOUTHEAST:
move_dir = ja2.Map.Direction.SOUTH_EAST;
break;
case ja2.LookDirection.SOUTH:
move_dir = ja2.Map.Direction.SOUTH;
break;
case ja2.LookDirection.SOUTHWEST:
move_dir = ja2.Map.Direction.SOUTH_WEST;
break;
case ja2.LookDirection.WEST:
move_dir = ja2.Map.Direction.WEST;
break;
case ja2.LookDirection.NORTHWEST:
move_dir = ja2.Map.Direction.NORTH_WEST;
break;
case ja2.LookDirection.NORTH:
move_dir = ja2.Map.Direction.NORTH;
break;
case ja2.LookDirection.NORTHEAST:
move_dir = ja2.Map.Direction.NORTH_EAST;
break;
}
return move_dir;
}
//! Set mercenary.
public void SetMercenary(ja2.Soldier Mercenary)
{
mercenary = Mercenary;
}
//! Rotate as coroutine
public IEnumerator Rotate_CoRo(ja2.LookDirection Direction)
{
isRotating = true;
float time_to_pass = 0.1f * Mathf.Abs((byte)mercenary.lookDirection - (byte)Direction);
float start = Time.time;
Quaternion start_rotation = transform.rotation;
Quaternion end_rotation = ja2.LookDirectionConverter.DirectionToRotation(Direction);
while (Time.time - start < time_to_pass)
{
// Update rotation of GO
transform.rotation = Quaternion.Lerp(start_rotation, end_rotation, (Time.time - start) / time_to_pass);
// Compute actual direction
mercenary.lookDirection = OrientationFromAngle(transform.rotation);
yield return null;
}
mercenary.lookDirection = Direction;
UpdateOrientation();
isRotating = false;
}
//! Rotate.
public void Rotate(ja2.LookDirection Direction)
{
StartCoroutine(Rotate_CoRo(Direction));
}
