public bool DoesMyRegionHasWaterCrystal(Vector3 pos)
{
pos = U2D.FromV3ToV2(pos);
var regionIndex = ReturnMyRegion(pos);
return(false);
}
/// <summary>
/// if crystal in _eval further than _curr towards _two, then are removed and added to the end of _eval
/// </summary>
private void PushAwayToLastOnEval()
{
List <Crystal> temp = new List <Crystal>();
for (int i = 0; i < _eval.Count; i++)
{
_eval[i].CalculateDistance(U2D.FromV3ToV2(_two.Position));
}
var distFromCurr = Vector2.Distance(_curr.Position, U2D.FromV3ToV2(_two.Position));
for (int i = 0; i < _eval.Count; i++)
{
//if the distance is bigger tht the distace from Curr then will be removed
if (_eval[i].Distance > distFromCurr)
{
temp.Add(_eval[i]);
_eval.RemoveAt(i);
i--;
}
}
//will add the ones tht are fuehter to last on _eval so are checked last
_eval.AddRange(temp);
}
private bool ReturnBridgeRoadEquality()
{
if (UMath.nearEqualByDistance(_curr.Position, U2D.FromV3ToV2(_two.Position), .1f))
{
return(true);
}
return(false);
}
public Line(Vector3 a, Vector3 b, float duration, bool debugRender = true)
{
_a = U2D.FromV3ToV2(a);
_b = U2D.FromV3ToV2(b);
if (debugRender)
{
DebugRender(duration);
}
}
/// <summary>
/// Bz they needs to be moved a bit away from Buildign
/// </summary>
/// <returns></returns>
private Crystal ReturnCrystalFurtherTo(Crystal crystal, Vector3 closerTo)
{
float moveBy = 0.1f;
var moved = Vector3.MoveTowards(U2D.FromV2ToV3(crystal.Position), Current, moveBy);
crystal.Position = U2D.FromV3ToV2(moved);
return(crystal);
}
/// <summary>
/// Assign the first lot of regions
/// </summary>
private void AssignUnlockRegionsToNewGame()
{
if (_unlockRegions.Count > 0)
{
return;
}
var middleOfTown = BuildingPot.Control.Registro.AverageOfAllBuildingsNow();
var first1x1Regions = MeshController.CrystalManager1.ReturnMySurroundRegions(U2D.FromV3ToV2(middleOfTown), 1);
_unlockRegions.AddRange(first1x1Regions);
}
/// <summary>
/// Center of the region the camera is on top of now
/// </summary>
/// <param name="camPos"></param>
/// <returns></returns>
internal Vector3 CurrentRegionPos(Vector3 camPos)
{
var v2 = U2D.FromV3ToV2(camPos);
var index = ReturnMyRegion(v2);
if (index == -1)
{
return(camPos);
}
return(U2D.FromV2ToV3(CrystalRegions[index].Region.center));
}
/// <summary>
/// Will return the region index where all the Structure points are
/// </summary>
/// <param name="building"></param>
/// <returns></returns>
private List <int> ReturnRegionsOfPointsInStillElement(StillElement still)
{
var points = PassAnchorsGetPositionForCrystals(still.Anchors);
List <int> res = new List <int>();
for (int i = 0; i < points.Count; i++)
{
res.Add(ReturnMyRegion(U2D.FromV3ToV2(points[i])));
}
return(res.Distinct().ToList());
}
/// <summary>
/// Will say if 'newPos' is on the route already
/// </summary>
/// <param name="newPos"></param>
/// <returns></returns>
bool IsOnTheRoute(Vector2 newPos)
{
for (int i = 0; i < _checkPoints.Count; i++)
{
var v2 = U2D.FromV3ToV2(_checkPoints[i].Point);
if (newPos == v2)
{
return(true);
}
}
return(false);
}
public bool DoesMyRegionHasTerraCrystal(Vector3 pos)
{
pos = U2D.FromV3ToV2(pos);
var regionIndex = ReturnMyRegion(pos);
//tht the pos didnt fall inside any region
if (regionIndex == -1)
{
//will act as if will have terraCrystals on it
return(true);
}
return(_crystalRegions[regionIndex].ItHasATerraCristal());
}
/// <summary>
/// Return the regions surrouding each point of the poly
/// </summary>
/// <param name="poly"></param>
/// <returns></returns>
private List <int> ReturnPolySurroundingRegions(List <Vector3> poly)
{
List <int> res = new List <int>();
for (int i = 0; i < poly.Count; i++)
{
var currRegion = ReturnMyRegion(U2D.FromV3ToV2(poly[i]));
res.AddRange(ReturnCurrentSurroundIndexRegions(currRegion, 3));
}
return(res.Distinct().ToList());
}
public string WhatAudioIPlay(Vector3 camPos)
{
//todo make sure they start with out ForSaleRegionGO
var v2 = U2D.FromV3ToV2(camPos);
var index = ReturnMyRegion(v2);
if (index == -1)
{
return("OutOfTerrain");
}
return(CrystalRegions[index].WhatAudioIReport);
}
/// <summary>
/// Will init the process to gathering all crystals in surrouding areas and from this position
/// will try to link to 3 rectlinks in the surrouding areas
/// </summary>
/// <param name="position"></param>
private void InitCrystalPoll(Vector3 position)
{
var crysSurroInt = ReturnMySurroundRegions(U2D.FromV3ToV2(position));
var crystals = GiveAllTerraCrystalsInTheseRegions(crysSurroInt);
crystals = RefineCrystalsForType(crystals, H.LinkRect);
Crystal cryPoll = new Crystal(position, H.Poll, "");
_bounds.AddRange(crystals);
_bounds.Insert(0, cryPoll);
RegularLinking();
}
/// <summary>
/// So the position passed is added in the historical regions so it can be
/// looked at when examinating if intersecting
/// </summary>
/// <param name="position"></param>
void AddToHistoricalRegions(Vector3 position)
{
var newRegions = MeshController.CrystalManager1.ReturnMySurroundRegions(U2D.FromV3ToV2(position));
for (int i = 0; i < newRegions.Count; i++)
{
if (!_historicRegions.Contains(newRegions[i]))
{
_historicRegions.Add(newRegions[i]);
//AddRegionToHistoCrystals(i);
// //Debug.Log("added: _historicRegions.ct:" + _historicRegions.Count);
}
}
}
private void Init()
{
_timeStamp = Time.time;
//Debug.Log("init route:" + _person.MyId);
_curr.Position = U2D.FromV3ToV2(_one.Position);
loop = true;
//ClearDebugLocal();
_finCrystal = new Crystal(_two.Position, H.Door, _fin.MyId, true, false);
// NavMesh();
return;
}
private Vector2 FindClosestToMe(Vector2 dot, List <Vector3> poly)
{
List <VectorM> lis = new List <VectorM>();
for (int i = 0; i < poly.Count; i++)
{
lis.Add(new VectorM(poly[i], U2D.FromV2ToV3(dot)));
}
lis = lis.OrderBy(a => a.Distance).ToList();
var closest = lis[0].Point;
return(U2D.FromV3ToV2(closest));
}
/// <summary>
/// Will return the landing zone of the 'position'
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
public string ReturnLandingZone(Vector3 position)
{
var regs = ReturnMySurroundRegions(U2D.FromV3ToV2(position));
var regionsLandZoneId = ReturnRegionsLandZones(regs);
if (!string.IsNullOrEmpty(regionsLandZoneId))
{
return(regionsLandZoneId);
}
InitCrystalPoll(position);
return(pollResult);
}
/// <summary>
/// Will return the region index where all the Structure points are
/// </summary>
/// <param name="building"></param>
/// <returns></returns>
List <int> ReturnRegionsOfPointsInStructure(Building building)
{
//nt for Trails
List <Vector3> points = new List <Vector3>();
if (!building.MyId.Contains("Trail"))
{
points = PassAnchorsGetPositionForCrystals(building.Anchors);
}
//for buildings
if (!building.MyId.Contains("Bridge") && !building.MyId.Contains("Trail"))
{
Structure st = (Structure)building;
if (st.SpawnPoint != null)
{
points.Add(st.SpawnPoint.transform.position);
}
}
//for bridges
if (building.MyId.Contains("Bridge"))
{
var entries = GetBridgeEntries((Bridge)building);
points.Add(U2D.FromV2ToV3(entries[0].Position));
points.Add(U2D.FromV2ToV3(entries[1].Position));
}
//for Ways that are Trails
if (building.MyId.Contains("Trail"))
{
var obstas = _allObstas.Where(a => a.ParentId == building.MyId).ToList();
for (int i = 0; i < obstas.Count; i++)
{
points.Add(U2D.FromV2ToV3(obstas[i].Position));
_allObstas.Remove(obstas[i]);
}
}
List <int> res = new List <int>();
for (int i = 0; i < points.Count; i++)
{
res.Add(ReturnMyRegion(U2D.FromV3ToV2(points[i])));
}
return(res.Distinct().ToList());
}
public void AddGen(General go)
{
if (IsABrandNewTerrain())
{
return;
}
//todo address if Road, Bridge
if (go.Category == Ca.Spawn || go.HType == H.Plant)
{
var i = MeshController.CrystalManager1.ReturnMyRegion(U2D.FromV3ToV2(go.transform.position));
if (!_semiIndeces.ContainsKey(i))
{
//destroy and remove GO
Debug.Log("go out:" + go.MyId);
return;
}
var id = _semiIndeces[i];
_batchRegions[id].AddToRegion(go);
}
else if (go.Category == Ca.Structure)
{
return;
Structure st = (Structure)go;
if (st.StartingStage != H.Done && st.CurrentStage != 4)
{
//only will add fully finished buildings
return;
}
HandleCurrentOpenRegion("Opaque");
_batchRegions[_openOpaque].AddToRegion(go);
}
else if (go.Category == Ca.DraggableSquare)
{
//adding only the blocks that contain the roads
if (!go.MyId.Contains("Create_Plane"))
{
return;
}
HandleCurrentOpenRegion("Road");
_batchRegions[_openOpaque].AddToRegion(go);
}
}
/// <summary>
/// The line facing spawnPoint wil be removed
/// </summary>
void RemoveSpwnPointLine()
{
var st = (Structure)_building;
//moveing the spwn point away from building . assuimng is fallin inside building
var spwPoint = Vector3.MoveTowards(st.SpawnPoint.transform.position, _building.transform.position, -.75f);
var spwnLine = new Line(U2D.FromV3ToV2(spwPoint), U2D.FromV3ToV2(_building.transform.position));
for (int i = 0; i < _lines.Count; i++)
{
if (_lines[i].IsIntersecting(spwnLine))
{
_lines.RemoveAt(i);
break;
}
}
}
/// <summary>
/// Will define roughly wht is the river and sea path
///
/// tht list is just the whole shore order by distance from a point
/// </summary>
public void DefineSeaPath(List <Vector3> list)
{
int local = 0;
Vector2 accum = new Vector3();
for (int i = 0; i < list.Count; i++)
{
if (local == 25)//10
{
_seaPath.Add(accum / 25);
accum = new Vector3();
local = 0;
}
accum = accum + U2D.FromV3ToV2(list[i]);
local++;
}
//UVisHelp.CreateHelpers(_seaPath, Root.blueCube);
}
/// <summary>
/// Will return the region index where all the StillElement points are
/// </summary>
/// <param name="still"></param>
/// <returns></returns>
private List <int> ReturnRegionsOfPointsInStructure(StillElement still)
{
List <Vector3> points = new List <Vector3>();
var obstas = _allObstas.Where(a => a.ParentId == still.MyId).ToList();
for (int i = 0; i < obstas.Count; i++)
{
points.Add(U2D.FromV2ToV3(obstas[i].Position));
_allObstas.Remove(obstas[i]);
}
List <int> res = new List <int>();
for (int i = 0; i < points.Count; i++)
{
res.Add(ReturnMyRegion(U2D.FromV3ToV2(points[i])));
}
return(res.Distinct().ToList());
}
internal bool AreAnchorsOnUnlockRegions(List <UnityEngine.Vector3> anchors)
{
var anchorRegions = new List <int>();
for (int i = 0; i < anchors.Count; i++)
{
anchorRegions.Add(MeshController.CrystalManager1.ReturnMyRegion(U2D.FromV3ToV2(anchors[i])));
}
anchorRegions = anchorRegions.Distinct().ToList();
for (int i = 0; i < anchorRegions.Count; i++)
{
//if doest contain one is false
if (!_unlockRegions.Contains(anchorRegions[i]))
{
return(false);
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="ini"></param>
/// <param name="end"></param>
/// <param name="minimuSize">must have one side with a mimunum side like 10f
/// this is to allow Mountain Routing to happen</param>
/// <param name="grow">The grow of the rect on scale to make sure contain first and last </param>
public CryRect(Vector3 ini, Vector3 end, float grow, bool minimuSize = true, float debugDuration = 20f)
{
_a = U2D.FromV3ToV2(ini);
var poly = Registro.FromALotOfVertexToPolyMathCenterY(new List <Vector3>()
{
ini, end
});
poly = UPoly.ScalePoly(poly, grow);
_theRect = Registro.FromALotOfVertexToRect(poly);
_c = U2D.FromV3ToV2(end);
_b = FindB();
_d = FindD();
//so Rect Grows
//so way routing works
//PushThemAway();
if (minimuSize)
{
//when calling this is really importat bz this solved the Mountain Routing problem
//Dec 26 2015
ApplyMinimumSize();
}
var newPoly =
new List <Vector3>()
{
U2D.FromV2ToV3(_a), U2D.FromV2ToV3(_b),
U2D.FromV2ToV3(_c), U2D.FromV2ToV3(_d)
};
_theRect = Registro.FromALotOfVertexToRect(newPoly);
//RectifyCorners(poly);
UVisHelp.CreateDebugLines(TheRect, Color.magenta, debugDuration);
SetCrystals();
}
public int ReturnMyRegion(Vector3 v3)
{
return(ReturnMyRegion(U2D.FromV3ToV2(v3)));
}
