644 lines
25 KiB
C#
644 lines
25 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
using UnityEngine;
|
|
|
|
namespace FIMSpace.Generating.Rules
|
|
{
|
|
public enum ESR_Space { Empty, Occupied, OutOfGrid, InGrid }
|
|
|
|
public enum ESR_NeightbourCondition
|
|
{
|
|
[Tooltip("All selected cells must met node rule")]
|
|
AllNeeded,
|
|
[Tooltip("Just one cell need to met node rule then condition is completed")]
|
|
AtLeastOne
|
|
}
|
|
|
|
|
|
public enum ESR_DirectionMode { NoOffset, WorldDirection, CellRotateDirection }
|
|
public enum ESR_OffsetSpace { WorldDirection, CellRotateDirection }
|
|
|
|
public enum ESR_AngleRemovalMode { Any, OnTheLeft, OnTheRight, InFront, Behind, Below, Above }
|
|
|
|
public enum ESR_DistanceRule { Lower, Greater, Equal }
|
|
|
|
public enum ESR_Measuring { Units, Cells }
|
|
public enum ESR_Transforming { Position, Rotation, Scale }
|
|
public enum ESR_RotationOrScale { Rotation, Scale }
|
|
public enum ESR_TileScaleAxis { X, Y, Z }
|
|
|
|
public enum ESR_Origin
|
|
{
|
|
[Tooltip("Measure distance using prefabs origin positions")]
|
|
SpawnPosition,
|
|
[Tooltip("Measure distance using first-mesh model bounds center position")]
|
|
BoundsCenter,
|
|
[Tooltip("Measure distance using first found renderer bounds center position")]
|
|
RendererCenter
|
|
}
|
|
|
|
public enum ESR_Details { Tag, SpawnStigma, CellData, Name }
|
|
|
|
|
|
public static class SpawnRules
|
|
{
|
|
static readonly Quaternion Q0 = Quaternion.Euler(0, 0, 0);
|
|
static readonly Quaternion Q90 = Quaternion.Euler(0, 90, 0);
|
|
static readonly Quaternion Q180 = Quaternion.Euler(0, 180, 0);
|
|
static readonly Quaternion Q270 = Quaternion.Euler(0, 270, 0);
|
|
static readonly Quaternion QX90 = Quaternion.Euler(90, 0, 0);
|
|
static readonly Quaternion QX270 = Quaternion.Euler(270, 0, 0);
|
|
public static Quaternion GetRemovalAngle(ESR_AngleRemovalMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case ESR_AngleRemovalMode.OnTheLeft: return Q270;
|
|
case ESR_AngleRemovalMode.OnTheRight: return Q90;
|
|
case ESR_AngleRemovalMode.InFront: return Q0;
|
|
case ESR_AngleRemovalMode.Behind: return Q180;
|
|
case ESR_AngleRemovalMode.Below: return QX90;
|
|
case ESR_AngleRemovalMode.Above: return QX270;
|
|
}
|
|
|
|
return Q0;
|
|
}
|
|
|
|
public static Vector3 GetAxis(ESR_AngleRemovalMode angleMode)
|
|
{
|
|
if (angleMode == ESR_AngleRemovalMode.Above || angleMode == ESR_AngleRemovalMode.Below)
|
|
return Vector3.right;
|
|
else
|
|
return Vector3.up;
|
|
}
|
|
|
|
|
|
public static bool IsNull(this FieldCell data)
|
|
{ return FGenerators.CheckIfIsNull(data); }
|
|
|
|
public static bool NotNull(this FieldCell data)
|
|
{ return FGenerators.CheckIfExist_NOTNULL(data); }
|
|
|
|
public static bool IsNull(this SpawnData data)
|
|
{ return FGenerators.CheckIfIsNull(data); }
|
|
|
|
public static bool NotNull(this SpawnData data)
|
|
{ return FGenerators.CheckIfExist_NOTNULL(data); }
|
|
|
|
private static bool CheckCellAllowOR(FieldCell cell, string occupyTags, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
if (useStateORTag == false)
|
|
return false;
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty(occupyTags)) return false;
|
|
else
|
|
return CheckNeightbourCellAllow(ESR_Space.Occupied, cell, occupyTags, checkMode);
|
|
}
|
|
}
|
|
|
|
public static bool CheckNeightbourCellAllow(this ESR_Space check, FieldCell cell, string occupyTags, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
if (cell == null)
|
|
{
|
|
if (check == ESR_Space.OutOfGrid)
|
|
return true;
|
|
else
|
|
{
|
|
// Not occupied at all (no cell) - so false
|
|
return false;
|
|
|
|
//if (checkMode == ESR_Details.CellData)
|
|
//{
|
|
// if (occupyTags.Length > 0) if (occupyTags[0] == '!') return true;
|
|
//}
|
|
//return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (check == ESR_Space.InGrid)
|
|
{
|
|
if (cell.InTargetGridArea)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (check == ESR_Space.Occupied)
|
|
{
|
|
if (checkMode == ESR_Details.CellData)
|
|
{
|
|
if (FGenerators.CheckIfExist_NOTNULL(SpawnRuleBase.CellSpawnsHaveSpecifics(cell, occupyTags, ESR_Details.CellData)))
|
|
//if (SpawnRuleBase.CellHaveData(cell, occupyTags))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(occupyTags))
|
|
{
|
|
if (cell.CollectSpawns().Count > 0) return true;
|
|
}
|
|
else
|
|
{
|
|
if (cell.CollectSpawns().Count <= 0) return false;
|
|
else
|
|
{
|
|
if (FGenerators.CheckIfExist_NOTNULL(SpawnRuleBase.CellSpawnsHaveSpecifics(cell, occupyTags, checkMode)))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if (check == ESR_Space.Empty)
|
|
{
|
|
if (cell.CollectSpawns().Count < 1) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
|
|
}
|
|
else if (check == ESR_Space.OutOfGrid)
|
|
{
|
|
if (cell.InTargetGridArea == false) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
else if (check == ESR_Space.InGrid)
|
|
{
|
|
if (cell.InTargetGridArea) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool CheckNeightbourCellAllowAngled(this ESR_Space check, FieldCell cell, string occupyTags, Vector3 checkDirection, float ignoreAboveAngle, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
if (cell == null)
|
|
{
|
|
if (check == ESR_Space.OutOfGrid)
|
|
return true;
|
|
else
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
else
|
|
{
|
|
if (check == ESR_Space.InGrid) if (cell.InTargetGridArea)
|
|
return true;
|
|
else
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
|
|
}
|
|
|
|
if (check == ESR_Space.Occupied)
|
|
{
|
|
|
|
if (string.IsNullOrEmpty(occupyTags))
|
|
{
|
|
if (cell.CollectSpawns().Count > 0)
|
|
{
|
|
if (ignoreAboveAngle > 0f)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
for (int i = 0; i < spawns.Count; i++)
|
|
{
|
|
var spawn = spawns[i];
|
|
float angle = Vector3.Angle(checkDirection, spawn.GetFullOffset().normalized);
|
|
|
|
//float angle = Quaternion.Angle(checkDirection, Quaternion.Euler(spawn.LocalRotationOffset + spawn.RotationOffset));
|
|
if (angle <= ignoreAboveAngle) return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (cell.CollectSpawns().Count <= 0)
|
|
return false;
|
|
else
|
|
{
|
|
if (ignoreAboveAngle > 0f)
|
|
{
|
|
var spawns = SpawnRuleBase.GetAllSpecificSpawns(cell, occupyTags, checkMode);
|
|
for (int i = 0; i < spawns.Count; i++)
|
|
{
|
|
var spawn = spawns[i];
|
|
float angle = Vector3.Angle(checkDirection, spawn.GetFullOffset().normalized);
|
|
//UnityEngine.Debug.Log("Angle " + angle + " " + cell.FlatPosInt);
|
|
//float angle = Quaternion.Angle(checkDirection, Quaternion.Euler(spawn.LocalRotationOffset + spawn.RotationOffset));
|
|
if (angle <= ignoreAboveAngle) return true;
|
|
}
|
|
}
|
|
else
|
|
|
|
if (FGenerators.CheckIfExist_NOTNULL(SpawnRuleBase.CellSpawnsHaveSpecifics(cell, occupyTags, checkMode)))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (check == ESR_Space.Empty)
|
|
{
|
|
if (cell.CollectSpawns().Count < 1) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
else if (check == ESR_Space.OutOfGrid)
|
|
{
|
|
if (cell.InTargetGridArea == false) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
else if (check == ESR_Space.InGrid)
|
|
{
|
|
if (cell.InTargetGridArea) return true;
|
|
return CheckCellAllowOR(cell, occupyTags, checkMode, useStateORTag);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary> Get all neightbours around cell with option to generate ghost cells </summary>
|
|
public static List<FieldCell> GetTargetNeightboursAround(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, ESR_Space targetState, string tags, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
if (SpawnRules.CheckNeightbourCellAllow(targetState, nCell, tags, checkMode, useStateORTag) == false) continue;
|
|
|
|
if (nCell != null)
|
|
cells.Add(nCell);
|
|
else
|
|
if (targetState == ESR_Space.OutOfGrid)
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z), InTargetGridArea = false });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
/// <summary> Get all neightbours around cell and generate ghost cells instead of nulls </summary>
|
|
public static List<FieldCell> Get3x3Square(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
|
|
if (nCell != null)
|
|
cells.Add(nCell);
|
|
else
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z), InTargetGridArea = false });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
public static List<FieldCell> GetTargetNeightboursDiagonal(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
if (x == 0 || z == 0) continue;
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
|
|
if (nCell != null)
|
|
cells.Add(nCell);
|
|
else
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z) });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
|
|
public static List<FieldCell> GetTargetNeightboursDiagonal(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, ESR_Space targetState, string tags, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
if (x == 0 || z == 0) continue;
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
if (SpawnRules.CheckNeightbourCellAllow(targetState, nCell, tags, checkMode, useStateORTag) == false) continue;
|
|
|
|
if (nCell != null)
|
|
cells.Add(nCell);
|
|
else
|
|
if (targetState == ESR_Space.OutOfGrid)
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z) });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
public static SpawnData GetSpawnRotated(FieldCell cell, Quaternion targetRot, float tolerance = 1f)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
|
|
for (int i = 0; i < spawns.Count; i++)
|
|
{
|
|
var s = spawns[i];
|
|
if (Quaternion.Angle(Quaternion.Euler(s.RotationOffset), targetRot) < tolerance)
|
|
return s;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static SpawnData GetNearest(FieldCell cell, Vector3 wpos, FieldSetup forNearestCheck, float maxDistance = 1000f, System.Func<SpawnData, bool> iterationCondition = null)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
|
|
float nearest = float.MaxValue;
|
|
float maxDistSqrt = maxDistance * maxDistance;
|
|
SpawnData nesrSp = null;
|
|
//if (spawn.PreviewMesh)
|
|
// wpos = cell.WorldPos(forNearestCheck) + spawn.GetMeshFilterOrColliderBounds().center;
|
|
|
|
for (int i = 0; i < spawns.Count; i++)
|
|
{
|
|
var s = spawns[i];
|
|
if (s.DontSpawnMainPrefab) continue;
|
|
//if (Quaternion.Angle(Quaternion.Euler(s.RotationOffset), targetRot) < tolerance)
|
|
{
|
|
Vector3 refPos;
|
|
float dist;
|
|
|
|
//if (s.PreviewMesh)
|
|
// refPos = cell.WorldPos(forNearestCheck) + s.GetMeshFilterOrColliderBounds().center;
|
|
//else
|
|
refPos = (s.GetWorldPositionWithFullOffset(forNearestCheck));
|
|
|
|
dist = (refPos - wpos).sqrMagnitude;
|
|
if (dist > maxDistSqrt) continue;
|
|
|
|
if (iterationCondition != null)
|
|
{
|
|
if (iterationCondition.Invoke(s) == false) continue;
|
|
}
|
|
|
|
if (dist < nearest)
|
|
{
|
|
nearest = dist;
|
|
nesrSp = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nesrSp;
|
|
}
|
|
|
|
|
|
public static SpawnData GetSpawnRotated(FieldCell cell, Quaternion targetRot, FieldModification mustHaveMod, string cantHaveStigma, float tolerance = 1f)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
for (int i = 0; i < spawns.Count; i++)
|
|
{
|
|
var s = spawns[i];
|
|
bool mod = false;
|
|
|
|
if (mustHaveMod != null) mod = s.OwnerMod == mustHaveMod;
|
|
if (mod) if (!string.IsNullOrEmpty(cantHaveStigma)) if (s.GetCustomStigma(cantHaveStigma)) mod = false;
|
|
|
|
if (mod)
|
|
if (Quaternion.Angle(Quaternion.Euler(s.RotationOffset), targetRot) < tolerance)
|
|
return s;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static SpawnData GetSpawnWithStigma(FieldCell cell, string stigma, FieldModification onlyMod = null)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
|
|
if (onlyMod == null)
|
|
{
|
|
for (int i = 0; i < spawns.Count; i++) if (spawns[i].GetCustomStigma(stigma)) return spawns[i];
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < spawns.Count; i++) if (spawns[i].OwnerMod == onlyMod) if (spawns[i].GetCustomStigma(stigma)) return spawns[i];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static SpawnData GetSpawnWithExactMod(FieldCell cell, FieldModification mod = null)
|
|
{
|
|
var spawns = cell.CollectSpawns();
|
|
|
|
if (mod == null)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < spawns.Count; i++) if (spawns[i].OwnerMod == mod) return spawns[i];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static bool IsSpawnRotated(SpawnData spawn, Quaternion targetRotation)
|
|
{
|
|
if (Quaternion.Angle(Quaternion.Euler(spawn.RotationOffset), targetRotation) < 1f) return true;
|
|
return false;
|
|
}
|
|
|
|
public static List<FieldCell> GetTargetNeightboursPLUS(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
if (x != 0 && z != 0) continue; // Ignore diagonals
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
|
|
if (FGenerators.CheckIfExist_NOTNULL(nCell))
|
|
{
|
|
cells.Add(nCell);
|
|
}
|
|
else // null cell but it's desired state
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z) });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
public static List<FieldCell> GetTargetNeightboursPLUS(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, ESR_Space targetState, string tags, ESR_Details checkMode, bool useStateORTag = false)
|
|
{
|
|
List<FieldCell> cells = new List<FieldCell>();
|
|
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int z = -1; z <= 1; z++)
|
|
{
|
|
if (x == 0 && z == 0) continue; // Ignore self
|
|
if (x != 0 && z != 0) continue; // Ignore diagonals
|
|
|
|
FieldCell nCell = grid.GetCell(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z, false);
|
|
if (SpawnRules.CheckNeightbourCellAllow(targetState, nCell, tags, checkMode, useStateORTag) == false) continue;
|
|
|
|
if (FGenerators.CheckIfExist_NOTNULL(nCell))
|
|
{
|
|
cells.Add(nCell);
|
|
}
|
|
else // null cell but it's desired state
|
|
if (targetState == ESR_Space.OutOfGrid)
|
|
cells.Add(new FieldCell() { Pos = new Vector3Int(cell.Pos.x + x, cell.Pos.y, cell.Pos.z + z) });
|
|
}
|
|
|
|
return cells;
|
|
}
|
|
|
|
|
|
public static readonly Quaternion Step0 = Quaternion.Euler(0f, 0f, 0f);
|
|
public static readonly Quaternion Step45 = Quaternion.Euler(0f, 45f, 0f);
|
|
public static readonly Quaternion Step90 = Quaternion.Euler(0f, 90f, 0f);
|
|
public static readonly Quaternion Step135 = Quaternion.Euler(0f, 135f, 0f);
|
|
public static readonly Quaternion Step180 = Quaternion.Euler(0f, 180f, 0f);
|
|
public static readonly Quaternion Step225 = Quaternion.Euler(0f, 225, 0f);
|
|
public static readonly Quaternion Step270 = Quaternion.Euler(0f, 270f, 0f);
|
|
public static readonly Quaternion Step315 = Quaternion.Euler(0f, 315f, 0f);
|
|
|
|
public enum CellOffset
|
|
{
|
|
Angle0, Angle90, Angle180, Angle270, Angle45, Angle135, Angle225, Angle315
|
|
}
|
|
|
|
public static Vector3Int GetCellOffset(CellOffset off)
|
|
{
|
|
switch (off)
|
|
{
|
|
case CellOffset.Angle0: return new Vector3Int(0, 0, 1);
|
|
case CellOffset.Angle90: return new Vector3Int(1, 0, 0);
|
|
case CellOffset.Angle180: return new Vector3Int(0, 0, -1);
|
|
case CellOffset.Angle270: return new Vector3Int(-1, 0, 0);
|
|
case CellOffset.Angle45: return new Vector3Int(1, 0, 1);
|
|
case CellOffset.Angle135: return new Vector3Int(-1, 0, 1);
|
|
case CellOffset.Angle225: return new Vector3Int(-1, 0, -1);
|
|
case CellOffset.Angle315: return new Vector3Int(1, 0, -1);
|
|
default: return Vector3Int.zero;
|
|
}
|
|
}
|
|
|
|
|
|
//public static Vector3 GetCellOffsetV3(CellOffset off)
|
|
//{
|
|
// return V2toV3(GetCellOffset(off));
|
|
//}
|
|
|
|
public static Quaternion GetCellOffsetQ(CellOffset off)
|
|
{
|
|
switch (off)
|
|
{
|
|
case CellOffset.Angle0: return Step0;
|
|
case CellOffset.Angle45: return Step45;
|
|
case CellOffset.Angle90: return Step90;
|
|
case CellOffset.Angle135: return Step135;
|
|
case CellOffset.Angle180: return Step180;
|
|
case CellOffset.Angle225: return Step225;
|
|
case CellOffset.Angle270: return Step270;
|
|
case CellOffset.Angle315: return Step315;
|
|
default: return Step0;
|
|
}
|
|
}
|
|
|
|
public static CellOffset GetCellOffset45Step(int id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case 0: return CellOffset.Angle0;
|
|
case 1: return CellOffset.Angle45;
|
|
case 2: return CellOffset.Angle90;
|
|
case 3: return CellOffset.Angle135;
|
|
case 4: return CellOffset.Angle180;
|
|
case 5: return CellOffset.Angle225;
|
|
case 6: return CellOffset.Angle270;
|
|
case 7: return CellOffset.Angle315;
|
|
default: return CellOffset.Angle0;
|
|
}
|
|
}
|
|
|
|
public static Vector3 V2toV3(Vector2 flat)
|
|
{
|
|
return new Vector3(flat.x, 0, flat.y);
|
|
}
|
|
|
|
public static Vector3Int V2toV3Int(Vector2 flat)
|
|
{
|
|
return new Vector3Int(Mathf.RoundToInt(flat.x), 0, Mathf.RoundToInt(flat.y));
|
|
}
|
|
|
|
public static Vector2Int V2toV2Int(Vector2 flat)
|
|
{
|
|
return new Vector2Int(Mathf.RoundToInt(flat.x), Mathf.RoundToInt(flat.y));
|
|
}
|
|
|
|
public static CellOffset Get90Offset(int step)
|
|
{
|
|
if (step == 0) return CellOffset.Angle0;
|
|
else if (step == 1) return CellOffset.Angle90;
|
|
else if (step == 2) return CellOffset.Angle180;
|
|
else return CellOffset.Angle270;
|
|
}
|
|
|
|
public static FieldCell GetAngledNeightbour(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, CellOffset angle)
|
|
{
|
|
FieldCell c = grid.GetCell(cell.Pos + GetCellOffset(angle), false);
|
|
|
|
if (FGenerators.CheckIfIsNull(c))
|
|
|
|
c = new FieldCell() { Pos = cell.Pos + (GetCellOffset(angle)), InTargetGridArea = false };
|
|
return c;
|
|
}
|
|
|
|
public static FieldCell GetAngledNeightbour45(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, int angleId)
|
|
{
|
|
if (angleId > 7) angleId -= 8;
|
|
if (angleId < 0) angleId += 8;
|
|
FieldCell c = grid.GetCell(cell.Pos + GetCellOffset(GetCellOffset45Step(angleId)), false);
|
|
|
|
if (FGenerators.CheckIfIsNull(c))
|
|
c = new FieldCell() { Pos = cell.Pos + (GetCellOffset(GetCellOffset45Step(angleId))), InTargetGridArea = false };
|
|
return c;
|
|
}
|
|
|
|
public static FieldCell GetAngledNeightbour90(FieldCell cell, FGenGraph<FieldCell, FGenPoint> grid, int angleId)
|
|
{
|
|
if (angleId > 3) angleId -= 4;
|
|
if (angleId < 0) angleId += 4;
|
|
FieldCell c = grid.GetCell(cell.Pos + GetCellOffset(SpawnRules.Get90Offset(angleId)), false);
|
|
|
|
if (FGenerators.CheckIfIsNull(c))
|
|
c = new FieldCell() { Pos = cell.Pos + (GetCellOffset(SpawnRules.Get90Offset(angleId))), InTargetGridArea = false };
|
|
return c;
|
|
}
|
|
|
|
}
|
|
} |