public static IEnumerable <Vector2i> GetLine(Vector2i initialGridCoordinate, Vector2i endGridCoordinate)
{
List <Vector2i> line = new List <Vector2i>();
int distance = initialGridCoordinate.Distance(endGridCoordinate) * 2;
// Debug.Log(initialGridCoordinate + " " + endGridCoordinate + " " + distance);
// TODO: Reduce complexity. (now 1 iteration in GetLine then an interation in the calling function).
for (int i = 0; i < distance; i++)
{
line.Add(Vector2i.Lerp(initialGridCoordinate, endGridCoordinate, (float)i / distance));
}
return(line);
}
public void destroy()
{
Vector2i pos = GLOBAL.worldToGrid(transform.position);
Unit unit = CombatSequence.Instance.attacker;//PlayerManager.Instance.getCurrentPlayer().selectedObject.GetComponent<Unit>();
if (pos.Distance(unit.pos) == max)
{
// last shot, administer damage (TODO: only administer once regardless of how many max distance tiles there are)
CombatSequence.Instance.AoEDamage();
}
Destroy(gameObject);
}
/// <summary>
/// Get chunk positions order by valuable
/// </summary>
/// <returns></returns>
public IEnumerable <ChunkPositionValue> ValuableChunkPos(float range)
{
var chunkCenterPos = Chunk.GetPositionFromWorld(new Vector2(Position.x, Position.z));
var chunkRange = (int)(range / Chunk.Size);
var result = new List <ChunkPositionValue>();
//Get all chunk positions in a range
foreach (var chunkPos in new Bounds2i(chunkCenterPos, chunkRange))
{
if (Vector2i.Distance(chunkCenterPos, chunkPos) * Chunk.Size < range)
{
result.Add(new ChunkPositionValue()
{
Position = chunkPos,
Value = GetChunkPositionValue(chunkPos, range)
});
}
}
result.Sort();
return(result);
}
// finds the closest room and returns its index
private int findClosestRoom(int room, List <int> ignoreRooms)
{
Vector2i sourceRoomCenter = roomCenters[room];
float smallestDistance = float.MaxValue;
int index = 0;
for (int i = 0; i < roomCenters.Count; i++)
{
if (i == room || ignoreRooms.Contains(i))
{
continue;
}
Vector2i curRoomCenter = roomCenters[i];
float curDist = Vector2i.Distance(sourceRoomCenter, curRoomCenter);
if (curDist < smallestDistance)
{
smallestDistance = curDist;
index = i;
}
}
return(index);
}
/// <summary>
/// Attempts to move towards a position. This function will perform pathfinding logic and take into consideration move distance
/// to try and smoothly move towards a point.
/// </summary>
/// <param name="position">The position to move towards.</param>
/// <param name="user">A user object passed.</param>
/// <returns>true if the position was moved towards, and false if there was a pathfinding error.</returns>
public bool MoveTowards(Vector2i position, params dynamic[] user)
{
var myPosition = LokiPoe.MyPosition;
if (
_cmd == null || // No command yet
_cmd.Path == null ||
_cmd.EndPoint != position || // Moving to a new position
LokiPoe.CurrentWorldArea.IsTown || // In town, always generate new paths
(_sw.IsRunning && _sw.ElapsedMilliseconds > OldPlayerMoverSettings.Instance.PathRefreshRateMs) || // New paths on interval
_cmd.Path.Count <= 2 || // Not enough points
_cmd.Path.All(p => myPosition.Distance(p) > 7))
// Try and find a better path to follow since we're off course
{
_cmd = new PathfindingCommand(myPosition, position, 3, OldPlayerMoverSettings.Instance.AvoidWallHugging);
if (!ExilePather.FindPath(ref _cmd))
{
_sw.Restart();
Log.ErrorFormat("[OldPlayerMover.MoveTowards] ExilePather.FindPath failed from {0} to {1}.",
myPosition, position);
return(false);
}
//Log.InfoFormat("[OldPlayerMover.MoveTowards] Finding new path.");
_sw.Restart();
//_originalPath = new IndexedList<Vector2i>(_cmd.Path);
}
// Eliminate points until we find one within a good moving range.
while (_cmd.Path.Count > 1)
{
if (_cmd.Path[0].Distance(myPosition) < OldPlayerMoverSettings.Instance.MoveRange)
{
_cmd.Path.RemoveAt(0);
}
else
{
break;
}
}
var point = _cmd.Path[0];
point += new Vector2i(LokiPoe.Random.Next(-2, 3), LokiPoe.Random.Next(-2, 3));
if (_useForceAdjustments)
{
var negX = 0;
var posX = 0;
var tmp1 = point;
var tmp2 = point;
for (var i = 0; i < 10; i++)
{
tmp1.X--;
if (!ExilePather.IsWalkable(tmp1))
{
negX++;
}
tmp2.X++;
if (!ExilePather.IsWalkable(tmp2))
{
posX++;
}
}
if (negX > 5 && posX == 0)
{
point.X += 10;
if (OldPlayerMoverSettings.Instance.DebugAdjustments)
{
Log.WarnFormat("[OldPlayerMover.MoveTowards] X-Adjustments being made!");
}
_cmd.Path[0] = point;
}
else if (posX > 5 && negX == 0)
{
point.X -= 10;
if (OldPlayerMoverSettings.Instance.DebugAdjustments)
{
Log.WarnFormat("[OldPlayerMover.MoveTowards] X-Adjustments being made!");
}
_cmd.Path[0] = point;
}
var negY = 0;
var posY = 0;
tmp1 = point;
tmp2 = point;
for (var i = 0; i < 10; i++)
{
tmp1.Y--;
if (!ExilePather.IsWalkable(tmp1))
{
negY++;
}
tmp2.Y++;
if (!ExilePather.IsWalkable(tmp2))
{
posY++;
}
}
if (negY > 5 && posY == 0)
{
point.Y += 10;
if (OldPlayerMoverSettings.Instance.DebugAdjustments)
{
Log.WarnFormat("[OldPlayerMover.MoveTowards] Y-Adjustments being made!");
}
_cmd.Path[0] = point;
}
else if (posY > 5 && negY == 0)
{
point.Y -= 10;
if (OldPlayerMoverSettings.Instance.DebugAdjustments)
{
Log.WarnFormat("[OldPlayerMover.MoveTowards] Y-Adjustments being made!");
}
_cmd.Path[0] = point;
}
}
// Le sigh...
if (_useAct3TownAdjustments)
{
var seed = LokiPoe.LocalData.AreaHash;
if (_tgtSeed != seed || _tgts == null)
{
Log.InfoFormat("[OldPlayerMover.MoveTowards] Now building TGT info.");
_tgts = LokiPoe.TerrainData.TgtEntries;
_tgtSeed = seed;
}
if (TgtUnderPlayer.TgtName.Equals("Art/Models/Terrain/Act3Town/Act3_town_01_01_c16r7.tgt"))
{
Log.InfoFormat("[OldPlayerMover.MoveTowards] Act 3 Town force adjustment being made!");
point.Y += 5;
}
}
var move = LokiPoe.InGameState.SkillBarHud.LastBoundMoveSkill;
if (move == null)
{
Log.ErrorFormat("[OldPlayerMover.MoveTowards] Please assign the \"Move\" skill to your skillbar!");
return(false);
}
if ((LokiPoe.ProcessHookManager.GetKeyState(move.BoundKeys.Last()) & 0x8000) != 0 &&
LokiPoe.Me.HasCurrentAction)
{
if (myPosition.Distance(position) < OldPlayerMoverSettings.Instance.SingleUseDistance)
{
LokiPoe.ProcessHookManager.ClearAllKeyStates();
LokiPoe.InGameState.SkillBarHud.UseAt(move.Slots.Last(), false, point);
if (OldPlayerMoverSettings.Instance.DebugInputApi)
{
Log.WarnFormat("[SkillBarHud.UseAt] {0}", point);
}
_lastPoint = point;
}
else
{
if (OldPlayerMoverSettings.Instance.UseMouseSmoothing)
{
var d = _lastPoint.Distance(point);
if (d >= OldPlayerMoverSettings.Instance.MouseSmoothDistance)
{
MouseManager.SetMousePos("OldPlayerMover.MoveTowards", point, false);
if (OldPlayerMoverSettings.Instance.DebugInputApi)
{
Log.WarnFormat("[MouseManager.SetMousePos] {0} [{1}]", point, d);
}
_lastPoint = point;
}
else
{
if (OldPlayerMoverSettings.Instance.DebugInputApi)
{
Log.WarnFormat("[MouseManager.SetMousePos] Skipping moving mouse to {0} because [{1}] < [{2}]", point, d, OldPlayerMoverSettings.Instance.MouseSmoothDistance);
}
}
}
else
{
MouseManager.SetMousePos("OldPlayerMover.MoveTowards", point, false);
}
}
}
else
{
LokiPoe.ProcessHookManager.ClearAllKeyStates();
if (myPosition.Distance(position) < OldPlayerMoverSettings.Instance.SingleUseDistance)
{
LokiPoe.InGameState.SkillBarHud.UseAt(move.Slots.Last(), false, point);
if (OldPlayerMoverSettings.Instance.DebugInputApi)
{
Log.WarnFormat("[SkillBarHud.UseAt] {0}", point);
}
}
else
{
LokiPoe.InGameState.SkillBarHud.BeginUseAt(move.Slots.Last(), false, point);
if (OldPlayerMoverSettings.Instance.DebugInputApi)
{
Log.WarnFormat("[BeginUseAt] {0}", point);
}
}
}
return(true);
}
/// <summary>Get the closest distance between this <see cref="Box2i"/> and the <see cref="Vector2i"/>.</summary>
public double Distance( ref Vector2i point)
{
Vector2i nearest;
NearestPointTo(ref point, out nearest);
return point.Distance(ref nearest);
}
public static float Distance(Vector2i a, Vector2i b)
{
return(Vector2i.Distance(a, b));
}
// marks PURPLE TILES of all possible coverages for selection
public override void markAoEAim(Vector2i root)
{
TileMarker tileMarker = TileMarker.Instance;
unit.calcCombatStats();
int range = Mathf.Max((int)(unit.combatEnergyAtk * 0.5f), 3); // minimum beam size is 3x3 (length extendable)
// mark left beam
for (int i = -1; i <= 1; i++)
{
if (unit.pos.y + i < 0 || unit.pos.y + i > MapScript.Instance.mapHeight)
{
continue; // don't process tiles outside of map
}
for (int j = Mathf.Max(root.x - range, 0); j < root.x; j++)
{
Vector2i mark = new Vector2i(j, root.y + i);
if (mark.Distance(unit.pos) == 2 && mark.x != unit.pos.x && mark.y != unit.pos.y)
{
if (!tileMarker.attackTiles.ContainsKey(mark))
{
//tiles directly diagonal to unit are ambiguous; mark with attack tile instead of AoE
tileMarker.addAttackTile(mark);
}
}
else
{
tileMarker.addAoETile(mark);
}
}
}
// mark right beam
for (int i = -1; i <= 1; i++)
{
if (unit.pos.y + i < 0 || unit.pos.y + i > MapScript.Instance.mapHeight)
{
continue; // don't process tiles outside of map
}
for (int j = Mathf.Min(root.x + range, MapScript.Instance.mapWidth); j > root.x; j--)
{
Vector2i mark = new Vector2i(j, root.y + i);
if (mark.Distance(unit.pos) == 2 && mark.x != unit.pos.x && mark.y != unit.pos.y)
{
//tiles directly diagonal to unit are ambiguous; mark with attack tile instead of AoE
if (!tileMarker.attackTiles.ContainsKey(mark))
{
//tiles directly diagonal to unit are ambiguous; mark with attack tile instead of AoE
tileMarker.addAttackTile(mark);
}
}
else
{
tileMarker.addAoETile(mark);
}
}
}
// mark up beam
for (int i = -1; i <= 1; i++) // i represents x now instead of y
{
if (unit.pos.x + i < 0 || unit.pos.x + i > MapScript.Instance.mapWidth)
{
continue; // don't process tiles outside of map
}
for (int j = Mathf.Min(root.y + 1, MapScript.Instance.Width); j <= root.y + range; j++)
{
Vector2i mark = new Vector2i(root.x + i, j);
if (mark.Distance(unit.pos) == 2 && mark.x != unit.pos.x && mark.y != unit.pos.y)
{
if (!tileMarker.attackTiles.ContainsKey(mark))
{
//tiles directly diagonal to unit are ambiguous; mark with attack tile instead of AoE
tileMarker.addAttackTile(mark);
}
}
else
{
tileMarker.addAoETile(mark);
}
}
}
// mark down beam
for (int i = -1; i <= 1; i++) // i represents x now instead of y
{
if (unit.pos.x + i < 0 || unit.pos.x + i > MapScript.Instance.mapWidth)
{
continue; // don't process tiles outside of map
}
for (int j = Mathf.Max(root.y - 1, 0); j >= root.y - range; j--)
{
Vector2i mark = new Vector2i(root.x + i, j);
if (mark.Distance(unit.pos) == 2 && mark.x != unit.pos.x && mark.y != unit.pos.y)
{
if (!tileMarker.attackTiles.ContainsKey(mark))
{
//tiles directly diagonal to unit are ambiguous; mark with attack tile instead of AoE
tileMarker.addAttackTile(mark);
}
}
else
{
tileMarker.addAoETile(mark);
}
}
}
}
public override void markAoEPattern(Vector2i root) // root is redundant (always this weapon's unit)
{
TileMarker tileMarker = TileMarker.Instance;
//mark all diagonal tiles from unit
Vector2i curr = new Vector2i(unit.pos.x - 1, unit.pos.y + 1);
// up left
while (curr.x >= 0 && curr.y < MapScript.Instance.mapHeight)
{
if (curr.Distance(unit.pos) > max)
{ // keep track of maximum distance attack
max = curr.Distance(unit.pos);
}
tileMarker.addAttackTile(curr);
curr.x--;
curr.y++;
}
// up right
curr = new Vector2i(unit.pos.x + 1, unit.pos.y + 1);
while (curr.x < MapScript.Instance.mapWidth && curr.y < MapScript.Instance.mapHeight)
{
if (curr.Distance(unit.pos) > max)
{ // keep track of maximum distance attack
max = curr.Distance(unit.pos);
}
tileMarker.addAttackTile(curr);
curr.x++;
curr.y++;
}
// down left
curr = new Vector2i(unit.pos.x - 1, unit.pos.y - 1);
while (curr.x >= 0 && curr.y >= 0)
{
if (curr.Distance(unit.pos) > max)
{ // keep track of maximum distance attack
max = curr.Distance(unit.pos);
}
tileMarker.addAttackTile(curr);
curr.x--;
curr.y--;
}
// down right
curr = new Vector2i(unit.pos.x + 1, unit.pos.y - 1);
while (curr.x < MapScript.Instance.mapWidth && curr.y >= 0)
{
if (curr.Distance(unit.pos) > max)
{ // keep track of maximum distance attack
max = curr.Distance(unit.pos);
}
tileMarker.addAttackTile(curr);
curr.x++;
curr.y--;
}
}
public override Blocks GenerateBlock2(Vector2i position, Heights macroHeight)
{
var block = base.GenerateBlock2(position, macroHeight);
if (Zone.Biome.Type == BiomeType.TestWaves)
{
var height = Mathf.Sin(position.X / 5f) * 5;
var heights = new Heights(macroHeight.Main + height, macroHeight.Underground + height, macroHeight.Base + height);
block = block.MutateHeight(heights);
}
else if (Zone.Biome.Type == BiomeType.TestBaseOreAndGround)
{
var baseHeight = _generator.GetSimplex(position.X / 20f, position.Z / 20f) * 3 + macroHeight.Base;
var resourcesHeight = Interpolation.SmoothestStep(Mathf.Clamp01((float)_generator.GetSimplex(position.X / 10f, position.Z / 10f))) * 10 + macroHeight.Underground - 1;
var groundHeight = Interpolation.SmoothestStep((_generator.GetSimplex(position.Z / 40f, position.X / 40f) + 1) / 2) * 10 - 12 + macroHeight.Main;
//var groundHeight = -1;
//var underground = resourcesHeight > baseHeight ? BlockType.GoldOre : BlockType.Empty;
var underground = BlockType.GoldOre;
BlockType ground;
/*
* if (groundHeight > resourcesHeight && groundHeight > baseHeight)
* ground = BlockType.Grass;
* else
* ground = BlockType.Empty;
*/
ground = BlockType.Grass;
block = new Blocks(ground, underground, new Heights((float)groundHeight, resourcesHeight, (float)baseHeight));
}
else if (Zone.Biome.Type == BiomeType.TestBaseCavesAndGround)
{
//"Hourglass" shaped hole to the base layer
//
//-\ /---
// \ /
// \ /
// / \
// / \
//-/--------\--
var distance = Vector2.Distance(Vector2.Zero, position);
if (distance < 15)
{
var baseHeight = -10;
var underHeight = distance < 10 ? -10 + (10 - distance) : -10;
var groundHeight = distance < 10 ? -10 + distance : 0;
/*
* var baseHeight = _generator.GetSimplex(position.X / 30f, position.Z / 30f) * 3 + macroHeight.BaseHeight;
* var undergroundHeight = (_generator.GetSimplex(position.X / 20f, position.Z / 20f) + 1);
* undergroundHeight = Math.Pow(undergroundHeight, 4) + macroHeight.UndergroundHeight;
* var groundHeight = _generator.GetSimplex(position.X / 5f, position.Z / 5f) + macroHeight.Layer1Height;
*/
BlockType underground;
if (underHeight > groundHeight || underHeight <= baseHeight)
{
underground = BlockType.Empty;
}
else
{
underground = BlockType.Cave;
}
BlockType ground = groundHeight >= underHeight ? BlockType.Grass : BlockType.Empty;
block = new Blocks(ground, underground, new Heights(groundHeight, underHeight, baseHeight));
}
else
{
block = Blocks.Empty;
}
}
else if (Zone.Biome.Type == BiomeType.TestBaseOreGroundColumn)
{
//Column made from ground and ore, to test very steep slopes (vertical)
//Column has half-circle form
if (position.X < 0 && Vector2i.Distance(position, Vector2i.Zero) < 5)
{
//All blocks the same
//blocks = new Blocks(BlockType.Grass, BlockType.GoldOre, new Heights(10, 5, -5));
//All block has different heights
var baseHeight = _random.Range(0, 5);
var underHeight = baseHeight + _random.Range(0, 5);
var groundHeight = underHeight + _random.Range(0, 5);
block = new Blocks(BlockType.Grass, BlockType.GoldOre,
new Heights(groundHeight, underHeight, baseHeight));
}
else
{
block = new Blocks(BlockType.Empty, BlockType.Empty, new Heights(-10, -10, -10));
}
}
else if (Zone.Biome.Type == BiomeType.TestBaseOrePyramidGround)
{
//Special test case
if (position == (3, -21))
{
return(new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(0, 1, -5)));
}
if (position == (-15, -13) || position == (-15, -14))
{
return(new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(0, 1, -5)));
}
if (position == (-18, 12) || position == (-18, 13) || position == (-17, 13))
{
return(new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(0, 1, -5)));
}
if (position == (13, 14) || position == (13, 15) || position == (12, 14) || position == (12, 15))
{
return(new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(0, 1, -5)));
}
var distance = Vector2.Distance(Vector2.Zero, position);
var baseHeight = -5f;
var oreHeight = 7 - distance;
var grassHeight = 0;
block = new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(grassHeight, oreHeight, baseHeight));
}
else
{
if (Zone.Biome.Type == BiomeType.TestTunnel)
{
//Tunnel is line defined by ax + by + c = 0
const float a = 2f, b = -1f, c = 5f;
const float tunnelWidth = 15;
const float tunnelCenterHeight = 0;
//Mountain defined as cone
Vector2 mountCenter = Vector2.Zero;
const float mountSize = 20;
var distanceToTunnel = Mathf.Abs(a * position.X + b * position.Z + c) / Mathf.Sqrt(a * a + b * b);
var distanceToMount = Vector2.Distance(position, mountCenter);
var tunnelTurbulence = (float)(_generator.GetSimplex(position.X / 10d, position.Z / 10d) * 2
+ _generator.GetSimplex(position.Z / 70d, position.X / 70d) * 5);
//Make tunnel floor
var baseHeight = 0f;
if (distanceToTunnel < tunnelWidth)
{
baseHeight += tunnelCenterHeight - Mathf.Sqrt(tunnelWidth * tunnelWidth - distanceToTunnel * distanceToTunnel) + tunnelTurbulence;
}
var underHeight = 0f;
if (distanceToTunnel < tunnelWidth)
{
underHeight += tunnelCenterHeight + Mathf.Sqrt(tunnelWidth * tunnelWidth - distanceToTunnel * distanceToTunnel) + tunnelTurbulence;
}
var groundHeight = 5f;
if (distanceToMount < mountSize)
{
groundHeight += mountSize - distanceToMount;
}
block = new Blocks(Zone.Biome.DefaultMainBlock.Block, Zone.Biome.DefaultUndergroundBlock.Block,
new Heights(groundHeight, underHeight, baseHeight));
}
}
return(block);
}
