public static HexCoordinates WorldCoordsFromGlobalPosition(HexTerrain terrain, Vector3 position)
{
position -= terrain.transform.position;
float x = position.x / ((HexMetrics.innerRadius * terrain.transform.localScale.x) * 2f);
float y = -x;
float offset = position.z / ((HexMetrics.outerRadius * terrain.transform.localScale.z) * 3f);
x -= offset;
y -= offset;
int iX = Mathf.RoundToInt(x);
int iY = Mathf.RoundToInt(y);
int iZ = Mathf.RoundToInt(-x - y);
if (iX + iY + iZ != 0)
{
float dX = Mathf.Abs(x - iX);
float dY = Mathf.Abs(y - iY);
float dZ = Mathf.Abs(-x - y - iZ);
if (dX > dY && dX > dZ)
{
iX = -iY - iZ;
}
else if (dZ > dY)
{
iZ = -iX - iY;
}
}
return(new HexCoordinates(iX, iZ));
}
public ITile[] GenerateTiles(int sizeX, int sizeY)
{
sizeX = 40;
sizeY = 20;
char[] tileChars = tiles.ToCharArray();
ITile[] generated = new TileInfo[sizeX * sizeY];
for (int i = 0; i < tileChars.Length; i++)
{
char c = tileChars[i];
int elevation = 0;
if (c == 'M')
{
elevation = 15;
}
else if (c == 'F')
{
elevation = 3;
}
else if (c == 'W')
{
elevation = -3;
}
generated[i] = new TileInfo(HexTerrain.GetTerrainFromChar(c), elevation);
}
return(generated);
}
void DisplayAddMainArea()
{
newItemName = EditorGUILayout.TextField(new GUIContent("Name: "), newItemName);
biomeId = EditorGUILayout.IntField("Biome ID", biomeId);
type = (TerrainType)EditorGUILayout.EnumPopup("Type of terrain:", type);
moveInCostModifier = EditorGUILayout.FloatField("Move in cost modifier", moveInCostModifier);
elevation = EditorGUILayout.FloatField("Elevation", elevation);
_material = (Material)EditorGUILayout.ObjectField(_material, typeof(Material), true);
EditorGUILayout.Space();
if (GUILayout.Button("Done", GUILayout.Width(100)))
{
HexTerrain newHexTerrain = new HexTerrain(itemID, newItemName, type, moveInCostModifier, elevation, _material, biomeId);
//string dataPath = ASSET_PATH + newHexTerrain.Name + ".asset";
itemID = terrainDatabase.COUNT;
terrainDatabase.Add(newHexTerrain);
newItemName = string.Empty;
EditorUtility.SetDirty(terrainDatabase);
state = State.BLANK;
}
}
public void UpdateTile()
{
if (HexTerrain.exists)
{
currentTile = HexTerrain.GetClosestTile(transform.position);
lastPosition = transform.position;
}
}
public Hex(HexMap map, int col, int row, int cost, HexTerrain terr, HexFeatures feat)
{
HexMap = map;
Col = col;
Row = row;
Terrain = terr;
Features = feat;
Neighbours = HexMap.FindValidNeighbours(col, row);
}
public virtual void UpdateCombatControls()
{
if (!positionMarker)
{
positionMarker = HexTerrain.CreateTileSelector(color);
}
positionMarker.transform.position = character.currentTile.position;
}
// Use this for initialization
void Start()
{
InitGhostCell();
InitPointer();
if (terrain == null)
{
terrain = FindObjectOfType <HexTerrain>();
}
}
public void BindMap(HexTerrain hexTerrain, Vector2i chunkGridOffset, Vector2i size)
{
_hexTerrain = hexTerrain;
_chunkGridOffset = chunkGridOffset;
_width = size.x;
_height = size.y;
// event is bound in BindMap on asset creation and on Awake after serialization.
_hexTerrain.Types.MaterialModified += OnMaterialModified;
}
public Hex(HexMap hexMap, HexTerrain hexTerrain, int q, int r)
{
this.hexTerrain = hexTerrain;
this.HexMap = hexMap;
Q = q;
R = r;
S = -(q + r);
initCurrencies();
recalculateCurrencyPerTurn();
}
// terrain features (plants, etc.)
// terrain status (e.g. fire, poison)
public HexState(HexTile tile)
{
_terrain = tile.terrain;
_elevation = tile.elevation;
_unit = null;
if (tile.occupant != null)
{
_unit = new UnitState(tile.occupant.GetComponent <Unit>());
}
}
static bool MakeHexTerrain(string name, HexTerrainData terrainData, HexagonTypeData typeData)
{
GameObject gameObject = new GameObject(name);
HexTerrain hexTerrain = gameObject.AddComponent <HexTerrain>();
hexTerrain.HexData = terrainData;
hexTerrain.Types = typeData;
hexTerrain.BuildChunks();
return(true);
}
/// <summary>
/// Fetch the target array for this cursor. This highly depends on the target mode
/// </summary>
private void updateTargets()
{
HexTile tile = character.currentTile;
List <HexTile> tilesInRange = HexTerrain.GetTilesInRange(tile, maxRange, false);
targets = tilesInRange.Where(t => t.currentFrame)
.Select(t => t.currentFrame)
.Where(t => isValidTarget(t))
.ToArray();
}
public void Init(HexTerrain parent, float[,] heightMap, float[,] treeMap, Vector2Int origin)
{
terrain = parent;
size = parent.chunkSize;
offsetOrigin = origin;
collisionMesh = GetComponent <TerrainCollisionMesh>();
collisionMesh.Init();
renderMesh = GetComponent <TerrainRenderMesh>();
renderMesh.Init();
transform.parent = parent.transform;
transform.position = parent.transform.position;
transform.localPosition = new Vector3(HexMetrics.innerRadius * 2 * origin.x, 0, HexMetrics.outerRadius * 1.5f * origin.y);
if (showCoordinates)
{
InitCanvas();
}
cellStacks = new CellStack[size, size];
// First pass generates terrain from heightmap
for (int z = 0, i = 0; z < size; z++)
{
for (int x = 0; x < size; x++)
{
int stackHeight = (int)(heightMap[x, z] * terrain.maxHeight);
cellStacks[x, z] = CreateCellStack(x, z, stackHeight);
}
}
terrainObjects = new TerrainObject[size, size];
bool[,] trees = new bool[size, size];
// Second pass adds trees and sand
for (int z = 0, i = 0; z < size; z++)
{
for (int x = 0; x < size; x++)
{
AddSand(cellStacks[x, z]);
float treeChance = treeMap[x, z];
if (treeChance > (1 - terrain.treeChance))
{
AddTree(cellStacks[x, z]);
}
}
}
GenerateMeshes();
initialized = true;
}
protected override void OnInitializeCursor()
{
startTile = character.currentTile;
_selector = HexTerrain.CreateTileSelector(controller.color, 1.5f, 0.9f);
AlphaPingPong anim = _selector.AddComponent <AlphaPingPong>();
anim.intensity = 0.5f;
_selectorTransform = _selector.transform;
_selectorTransform.position = Vector3.forward * 10000.0f;
}
public static void Spawn(Node node, Transform parent,
GameObject tilePrefab, HexTerrain terrain)
{
GameObject hexObj = Instantiate(tilePrefab);
hexObj.transform.parent = parent;
hexObj.transform.localPosition = Map.Position(node.coords);
HexTile tile = hexObj.GetComponent <HexTile>();
tile.terrain = terrain;
node.tile = tile;
tile._node = node;
}
public Vector3 ToWorldPosition(HexTerrain terrain)
{
Vector2 offset = ToOffsetCoordinates();
Vector3 position = new Vector3();
position.x = offset.x * (HexMetrics.ScaledInnerRadius(terrain) * 2f) + (offset.y % 2) * HexMetrics.ScaledInnerRadius(terrain);;
position.y = 0f;
position.z = offset.y * (HexMetrics.ScaledOuterRadius(terrain) * 1.5f);
position += terrain.transform.position;
return(position);
}
protected override void OnCharacterActionStart(Character actor)
{
transform = actor.transform;
HexTile startTile = HexTerrain.GetClosestTile(character.position);
if (startTile == null)
{
Done();
return;
}
List <HexTile> path = Pathfinder.FindPath(startTile, targetTile, ignoreTarget ? PathFindingMode.ExcludeTarget : PathFindingMode.None);
if (path == null)
{
Done();
return;
}
if (actor.remainingSteps == 0)
{
Done();
return;
}
if (!includeLast)
{
path.Remove(targetTile);
}
while (path.Count > actor.remainingSteps + 1)
{
path.RemoveAt(path.Count - 1);
}
targetTile = path[path.Count - 1];
actor.remainingSteps -= path.Count - 1;
Vector3[] line = NeverdawnUtility.PathAlongTiles(path, 0.1f, 10);
float pathLength = NeverdawnUtility.GetPathLength(line);
action = new CharacterMoveAlongPathAction(line, 1000.0f, 1.0f, run);
action.ActionStart(actor);
}
/// <summary>
/// Init the cursor
/// </summary>
protected override void OnInitializeCursor()
{
selector = HexTerrain.CreateTileSelector(controller.color, 1.5f, 0.9f);
AlphaPingPong anim = selector.AddComponent <AlphaPingPong>();
anim.intensity = 0.5f;
selector.transform.position = Vector3.forward * 10000.0f;
if (GameController.state == GameState.Exploration)
{
HexCamera.ShowMask(character, maxRange);
}
updateTargets();
updateSelector();
}
// Scale the terrain so it fits on the pedestal
private void ScaleTerrain()
{
terrain = GameObject.FindObjectOfType <HexTerrain>();
float terrainWidth = terrain.GetWidth();
float terrainDepth = terrain.GetDepth();
Vector3 scale = terrain.transform.localScale;
scale.z = (pedestalDepth - pedestalRimSize * 2) * scale.z / terrainDepth;
scale.x = (pedestalWidth - pedestalRimSize * 2) * scale.x / terrainWidth;
scale.y = (scale.x + scale.z) / 2;
terrain.transform.localScale = scale;
float terrainX = pedestal.transform.position.x - (terrain.GetWidth() / 2);
float terrainZ = pedestal.transform.position.z - (terrain.GetDepth() / 2);
terrain.transform.position = new Vector3(terrainX, pedestalHeight, terrainZ);
}
//there's probably a better of doing this but that's a problem for Tomorrow's Kathleen
private Color GetHexColour(HexTerrain terr)
{
switch (terr)
{
case HexTerrain.MOUNTAIN:
return(Colors.AntiqueWhite);
case HexTerrain.HILLS:
return(Colors.YellowGreen);
case HexTerrain.GRASSLAND:
return(Colors.LawnGreen);
case HexTerrain.LAKE:
return(Colors.DeepSkyBlue);
default:
return(Colors.Magenta);
}
}
public void UpdatePlacementControls()
{
if (!positionMarker)
{
positionMarker = HexTerrain.CreateTileSelector(color);
positionMarker.transform.position = character.currentTile.position;
}
if (currentAbility == null)
{
if (!characterMenu.isOpen)
{
UIQuickMenuPlacement placementPage = Instantiate(UIFactory.uiQuickMenuPlacementPrefab);
characterMenu.Open(placementPage);
}
}
else
{
updateAbility();
}
}
protected virtual void GenerateMap()
{
_hexToGameObjectMap = new Dictionary <Hex, GameObject>();
_gameObjectToHexMap = new Dictionary <GameObject, Hex>();
hexes = new Hex[MapColumns, MapRows];
hexesGameObjects = new GameObject[MapColumns, MapRows];
for (int column = 0; column < MapColumns; column++)
{
for (int row = 0; row < MapRows; row++)
{
HexTerrain chosenTerrain =
HexTerrainDatabase.Terrain(UnityEngine.Random.Range(0, HexTerrainDatabase.COUNT));
Hex h = new Hex(this, chosenTerrain, column, row);
hexes[column, row] = h;
GameObject hexInstance = (GameObject)Instantiate(
_hexPrefab,
h.Position(),
Quaternion.AngleAxis(-90, new Vector3(1, 0, 0)),
this.transform
);
hexInstance.AddComponent <MeshCollider>();
hexInstance.name = "hex" + "_" + column + "_" + row;
hexInstance.GetComponent <HexComponent>().Hex = h;
hexInstance.GetComponent <HexComponent>().HexMap = this;
hexInstance.AddComponent <MeshCollider>();
//TODO: comment this after debugging
hexInstance.GetComponentInChildren <TextMesh>().text = column + "-" + row;
MeshRenderer mr = hexInstance.GetComponent <MeshRenderer>();
mr.material = chosenTerrain.Material;
hexesGameObjects[column, row] = hexInstance;
_hexToGameObjectMap[h] = hexInstance;
_gameObjectToHexMap[hexInstance] = h;
}
}
}
public void AddArea(HexTile center, int range)
{
List <HexTile> tiles = HexTerrain.GetTilesInRange(center, range, true);
foreach (HexTile tile in tiles)
{
tiles.Add(tile);
}
areas.Add(new BattlefieldArea()
{
center = center.position,
radius = range * HexTerrain.tileSize
});
int i = 0;
foreach (BattlefieldArea area in areas)
{
maskArray[i++] = area.mask;
}
maskLength = i;
}
public static float ScaledInnerRadius(HexTerrain terrain)
{
return(innerRadius * terrain.transform.localScale.x);
}
public void Remove(HexTerrain hexTerrain)
{
database.Remove(hexTerrain);
}
public static float ScaledHeight(HexTerrain terrain)
{
return(height * terrain.transform.localScale.y);
}
public static Vector3 ScaledHeightVector(HexTerrain terrain)
{
return(new Vector3(0, ScaledHeight(terrain), 0));
}
public HexState(HexState state)
{
_terrain = state._terrain;
_elevation = state._elevation;
_unit = new UnitState(state._unit);
}
void OnEnable()
{
_instance = this;
}
public static float ScaledOuterRadius(HexTerrain terrain)
{
return(outerRadius * terrain.transform.localScale.z);
}
