private List <RLBaseTile> LineHigh(Vector2Int fromPosition, Vector2Int toPosition, DungeonFloor floor)
{
List <RLBaseTile> line = new List <RLBaseTile>();
float deltaX = toPosition.x - fromPosition.x;
float deltaY = toPosition.y - fromPosition.y;
float deltaErr = 0;
if (deltaY != 0)
{
deltaErr = Mathf.Abs(deltaX / deltaY);
}
float error = 0;
int x = fromPosition.x;
int i = 0;
for (int y = fromPosition.y; i < Mathf.Abs(deltaY); y += ((int)Mathf.Sign(deltaY)), i++)
{
RLBaseTile tile = floor.GetTileAt(x, y);
if (tile == null)
{
return(line);
}
line.Add(tile);
error += deltaErr;
while (error >= .5)
{
x += ((int)Mathf.Sign(deltaX));
error--;
}
}
return(line);
}
private void DoSkillEffect(int index, RLBaseActor user, RLBaseTile targetTile)
{
if (index < skillEffects.Length)
{
skillEffects[index].DoEffect(user, targetTile, () => { DoSkillEffect(index + 1, user, targetTile); });
}
}
public virtual void TryBasicMoveToTile(RLBaseTile tile)
{
if (BasicMoveSkill != null && BasicMoveSkill.IsTargetValid(this, tile))
{
DoSkill(BasicMoveSkill, tile);
}
}
public override List <RLBaseTile> FindPath(RLBaseTile fromTile,
RLBaseTile to,
DungeonFloor floor,
CanMoveDelegate canMove,
PathCostDelegate pathCost)
{
return(AStarPathfind(floor, fromTile, to, canMove, pathCost));
}
public override void SetTile(RLSimpleTile tile)
{
this._tile = tile;
if (OnPositionChanged != null)
{
OnPositionChanged();
}
UpdateVision();
}
public List <RLBaseTile> GetOrthogonalNeighborTiles(RLBaseTile tile)
{
List <Vector2Int> neighborDirections = new List <Vector2Int>
{
Vector2Int.up, Vector2Int.right, Vector2Int.down, Vector2Int.left
};
return(GetNeighborTiles(tile, neighborDirections));
}
private void ShowEffects(string[] effects, RLBaseActor actor, RLBaseTile target, Action onComplete)
{
RLVisualEffect.VisualEffectParams effectParams = new RLVisualEffect.VisualEffectParams()
{
From = actor.GetTile(),
Targets = new List <RLBaseTile>(new[] { target }),
ActorController = this
};
effectRenderer.ShowEffects(effects, effectParams, onComplete);
}
private static List <RLBaseTile> ReconstructPath(RLBaseTile finish, IDictionary <RLBaseTile, RLBaseTile> cameFrom)
{
List <RLBaseTile> path = new List <RLBaseTile> {
finish
};
while (cameFrom.ContainsKey(finish))
{
finish = cameFrom[finish];
path.Add(finish);
}
return(path);
}
private List <RLBaseTile> GetNeighborTiles(RLBaseTile tile, List <Vector2Int> directions)
{
int x = tile.GetDisplayPosition().x;
int y = tile.GetDisplayPosition().y;
List <RLBaseTile> neighbors = new List <RLBaseTile>();
foreach (Vector2Int direction in directions)
{
int nX = x + direction.x;
int nY = y + direction.y;
if (nX >= 0 && nX < Tiles.GetLength(0) && nY >= 0 && nY < Tiles.GetLength(1))
{
neighbors.Add(Tiles[nX, nY]);
}
}
return(neighbors);
}
public bool IsTargetValid(RLBaseActor skillUser, RLBaseTile targetTile)
{
if (!IsTargetInRange(skillUser, targetTile))
{
return(false);
}
switch (Target)
{
case TargetType.None:
return(false);
case TargetType.Any:
return(true);
case TargetType.EmptyTile:
return(!targetTile.GetTileType().BlocksMovement&& targetTile.GetActor() == null);
case TargetType.Self:
return(true);
case TargetType.AnyCreature:
return(targetTile.GetActor() != null);
case TargetType.Enemy:
return(targetTile.GetActor() != null && skillUser.IsEnemyOf(targetTile.GetActor()));
case TargetType.Ally:
return(targetTile.GetActor() != null && skillUser.IsAllyOf(targetTile.GetActor()));
case TargetType.Custom:
return(IsCustomTargetValid(skillUser, targetTile));
default:
throw new ArgumentOutOfRangeException();
}
}
public override void DoEffect(RLBaseActor actor, RLBaseTile target, Action onComplete)
{
actor.ShowEffects(vfx, target, onComplete);
}
public void DoSkill(RLBaseActor user, RLBaseTile targetTile)
{
DoSkillEffect(0, user, targetTile);
}
public virtual bool IsTargetInRange(RLBaseActor skillUser, RLBaseTile targetTile)
{
return(range <= 0 || Vector3.Distance(skillUser.GetTile().GetDisplayPosition(), targetTile.GetDisplayPosition()) <= range);
}
/**
* If the skill needs custom targeting logic not covered by one of the enumerated cases in TargetType,
* override this method to return true for valid targets.
*/
protected virtual bool IsCustomTargetValid(RLBaseActor skillUser, RLBaseTile targetTile)
{
return(false);
}
protected bool CanSeeThrough(RLBaseTile tile)
{
return(!tile.GetTileType().BlocksVision);
}
private static List <RLBaseTile> AStarPathfind(DungeonFloor level, RLBaseTile start, RLBaseTile finish, CanMoveDelegate canMove, PathCostDelegate pathCost)
{
// A* Pathfinding
Debug.Log("Connecting " + start.GetDisplayPosition() + " to " + finish.GetDisplayPosition() + " in " + level);
List <RLBaseTile> closedSet = new List <RLBaseTile>();
List <RLBaseTile> openSet = new List <RLBaseTile>();
openSet.Add(start);
Dictionary <RLBaseTile, RLBaseTile> cameFrom = new Dictionary <RLBaseTile, RLBaseTile>();
Dictionary <RLBaseTile, float> gScore = new Dictionary <RLBaseTile, float>();
gScore[start] = 0;
Dictionary <RLBaseTile, float> fScore = new Dictionary <RLBaseTile, float>();
fScore[start] = Mathf.Abs(start.GetDisplayPosition().x - finish.GetDisplayPosition().x) + Mathf.Abs(start.GetDisplayPosition().y - finish.GetDisplayPosition().y);
int length = 0;
while (openSet.Count > 0)
{
length++;
openSet.Sort((first, second) =>
{
float firstScore;
float secondScore;
if (!fScore.TryGetValue(first, out firstScore))
{
firstScore = float.PositiveInfinity;
}
if (!fScore.TryGetValue(second, out secondScore))
{
secondScore = float.PositiveInfinity;
}
if (firstScore < secondScore)
{
return(-1);
}
else if (firstScore > secondScore)
{
return(1);
}
return(0);
});
RLBaseTile current = openSet[0];
if (current == finish)
{
// write and return path
List <RLBaseTile> hallTiles = ReconstructPath(current, cameFrom);
Debug.Log("Successful path from " + start.GetDisplayPosition() + " to " + finish.GetDisplayPosition());
return(hallTiles);
}
openSet.Remove(current);
closedSet.Add(current);
List <RLBaseTile> neighbors = level.GetOrthogonalNeighborTiles(current);
neighbors.RemoveAll((tile) => closedSet.Contains(tile) || !canMove(current, tile));
foreach (RLBaseTile neighbor in neighbors)
{
if (!openSet.Contains(neighbor))
{
openSet.Add(neighbor);
}
float neighborGscore;
if (!gScore.TryGetValue(neighbor, out neighborGscore))
{
neighborGscore = float.PositiveInfinity;
}
// currently using 1 as dist_between
float tentativeGScore = gScore[current] + pathCost(current, neighbor);
if (tentativeGScore >= neighborGscore)
{
continue;
}
cameFrom[neighbor] = current;
gScore[neighbor] = tentativeGScore;
fScore[neighbor] = gScore[neighbor] + Mathf.Abs(neighbor.GetDisplayPosition().x - finish.GetDisplayPosition().x) + Mathf.Abs(neighbor.GetDisplayPosition().y - finish.GetDisplayPosition().y);
}
}
Debug.Log("Connection failed.");
return(new List <RLBaseTile>());
}
private void DisplayTile(RLBaseTile tile)
{
environmentTilemap.SetTile(tile.GetDisplayPosition(), tileset[tile.GetDisplayType()]);
memoryFogTilemap.SetTile(tile.GetDisplayPosition(), tile.IsCurrentlyVisibleToPlayer() ? null : tileset.memoryFogTile);
fogOfWarTilemap.SetTile(tile.GetDisplayPosition(), tile.HasEverBeenSeenByPlayer() ? null : tileset.fogOfWarTile);
}
public void BindTile(RLBaseTile tile)
{
tile.TileDisplayRefresh = DisplayTile;
}
public abstract void DoEffect(RLBaseActor actor, RLBaseTile target, Action onComplete);
public void DoSkill(RLSkill skill, RLBaseTile target)
{
skill.DoSkill(this, target);
}
public override void DoEffect(RLBaseActor user, RLBaseTile target, Action onComplete)
{
target.SetActor(user);
onComplete();
}
public abstract List <RLBaseTile> FindPath(RLBaseTile fromTile, RLBaseTile to, DungeonFloor floor, CanMoveDelegate canMove, PathCostDelegate pathCost);
