protected override int UseAction(GameManager gameManager, AutoControllerState state)
{
int x = m_target.Item2, y = m_target.Item3;
gameManager.SetMainPlayerFacingDirection(x, y);
gameManager.HandlePlayerAttack();
return(gameManager.GetMainPlayerAttackSpeed() + 50);
}
protected override int UseAction(GameManager gameManager, AutoControllerState state) // Todo create data object to keep track of slot / playerId
{
if (m_target != null)
{
int x = m_target.Item2, y = m_target.Item3;
gameManager.SetMainPlayerFacingDirection(x, y);
}
CastSpell(gameManager, m_slot, m_playerId);
return(m_aether);
}
void Start()
{
m_cts = new CancellationTokenSource();
m_controllerState = new AutoControllerState();
m_taskList = new ConcurrentQueue <AutoTask>();
m_actionList = new List <AutoAction>();
RefreshAutomation();
m_pathManager = PathManager.Instance;
m_pathManager.InitializeCache(m_gameManager);
}
protected override bool CanUseAction(GameManager gameManager, AutoControllerState state)
{
if (!gameManager.IsMainPlayerMoving())
{
MapTile start = GetPlayerPosition(gameManager);
int map = start.Item1;
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (simpleDistance <= 1)
{
m_target = goal;
return(true);
}
}
}
}
return(false);
}
public override async Task <bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
MapTile start = GetPlayerPosition(gameManager);
int map = start.Item1, minDistance = Int32.MaxValue;
bool targetFound = false;
// TODO Sort players based on DistanceHeuristic first and loop through until the heuristic distance is more than the min actual distance.
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (simpleDistance < minDistance)
{
LinkedList <MapTile> walkPath = null;
if (await pathManager.TryGetWalkPath(gameManager, start, goal, player, value => walkPath = value))
{
int distance = walkPath.Count;
if (distance < minDistance)
{
minDistance = distance;
state.SetTargetTile(goal);
state.SetTarget(player);
targetFound = true;
}
}
}
}
}
return(targetFound);
}
// TODO Consider simply returning WalkToTile if samearea is true.
protected async Task MoveToMapTile(GameManager gameManager, PathManager pathManager, AutoControllerState state, MapTile goal, PlayerManager player, int distanceFromGoal = 0)
{
MapTile start = GetPlayerPosition(gameManager);
Tuple <LinkedList <MapTile>, WarpDevice, int> mapPathInfo = await pathManager.GetMapPath(gameManager, start, goal);
if (mapPathInfo != null)
{
LinkedList <MapTile> mapPath = mapPathInfo.Item1;
WarpDevice warpDevice = mapPathInfo.Item2;
int pathDistance = mapPathInfo.Item3;
bool sameArea = await pathManager.IsSameArea(gameManager, start, goal);
if (!sameArea || pathDistance > distanceFromGoal)
{
if (warpDevice != default(WarpDevice))
{
// Use spell/item
}
else if (mapPath.Count > 1)
{
MapTile targetTile = mapPath.ElementAt(1);
await WalkToTile(gameManager, pathManager, state, start, targetTile, player);
}
}
}
}
public AttackAction(GameManager gameManager, AutoControllerState state, CancellationToken token) : base(gameManager, state, token)
{
}
public override async Task Move(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
MapTile goal = state.GetTargetTile();
PlayerManager player = state.GetTarget();
int distance = (player == null ? 3 : 0);
if (goal != null)
{
await MoveToMapTile(gameManager, pathManager, state, goal, player, distance);
}
}
protected async Task WalkToTile(GameManager gameManager, PathManager pathManager, AutoControllerState state, MapTile start, MapTile goal, PlayerManager player, int distanceFromGoal = 0)
{
LinkedList <MapTile> walkPath = null;
if (await pathManager.TryGetWalkPath(gameManager, start, goal, player, value => walkPath = value))
{
if (walkPath.Count > 1 && PathManager.DistanceHeuristic(start, goal) > distanceFromGoal)
{
MapTile nextTile = walkPath.ElementAt(1);
Vector3 direction = new Vector3(nextTile.Item2 - start.Item2, -(nextTile.Item3 - start.Item3), 0);
gameManager.HandlePlayerPosition(direction, false);
Vector3 previous = default(Vector3);
foreach (MapTile tile in walkPath)
{
Vector3 current = gameManager.WorldPosition(tile.Item2, tile.Item3, true) + Vector3.forward;
if (!previous.Equals(default(Vector3)))
{
Debug.DrawLine(previous, current, Color.red, 1f, false);
}
previous = current;
}
}
}
}
protected override int DelayAction(GameManager gameManager, AutoControllerState state)
{
return(m_aether);
}
public override async Task Move(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
await Task.Yield();
}
public AutoAction(GameManager gameManager, AutoControllerState state, CancellationToken token)
{
m_manager = gameManager;
m_controllerState = state;
LoopAction(token);
}
protected override bool CanUseAction(GameManager gameManager, AutoControllerState state)
{
return(true);
}
public override async Task Move(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
MapTile start = GetPlayerPosition(gameManager);
MapTile goal = state.GetTargetTile();
PlayerManager player = state.GetTarget();
if (goal != null)
{
await WalkToTile(gameManager, pathManager, state, start, goal, player);
}
}
protected override bool CanUseAction(GameManager gameManager, AutoControllerState state)
{
m_target = null;
if (!String.IsNullOrEmpty(m_type))
{
gameManager.GetMainPlayerHP(out int curHp, out int maxHp);
gameManager.GetMainPlayerMP(out int curMp, out int maxMp);
int hpPercent = GetPercent(curHp, maxHp);
int mpPercent = GetPercent(curMp, maxMp);
if (m_type.Equals("Healing"))
{
int targetPlayerId = 0;
if (hpPercent < 90)
{
targetPlayerId = gameManager.GetMainPlayerId();
}
else
{
if (mpPercent > 20)
{
foreach (PartyPlayerUI partyPlayer in gameManager.GetAllPartyPlayers())
{
if (partyPlayer.GetHPBar() < 90)
{
targetPlayerId = partyPlayer.GetPlayerId();
break;
}
}
}
}
if (targetPlayerId > 0)
{
m_playerId = targetPlayerId;
return(true);
}
}
else if (m_type.Equals("Sacrifice"))
{
if (hpPercent > 50)
{
int targetPlayerId = 0;
if (mpPercent < 50)
{
targetPlayerId = gameManager.GetMainPlayerId();
}
else
{
foreach (PartyPlayerUI partyPlayer in gameManager.GetAllPartyPlayers())
{
if (partyPlayer.GetMPBar() < 90)
{
targetPlayerId = partyPlayer.GetPlayerId();
break;
}
}
}
if (targetPlayerId > 0)
{
m_playerId = targetPlayerId;
return(true);
}
}
}
else if (m_type.Equals("Regeneration"))
{
m_playerId = gameManager.GetMainPlayerId();
return(true);
}
else if (m_type.Equals("Blast"))
{
if (mpPercent == 100)
{
int maxDistance = Int32.MinValue, maxPlayerId = 0;
bool targetFound = false;
MapTile start = GetPlayerPosition(gameManager);
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (maxDistance < simpleDistance)
{
maxDistance = simpleDistance;
maxPlayerId = player.GetPlayerId();
targetFound = true;
}
}
}
if (targetFound)
{
m_playerId = maxPlayerId;
return(true);
}
}
}
else if (m_type.Equals("Assault"))
{
if (mpPercent > 90)
{
int maxDistance = Int32.MinValue, maxPlayerId = 0;
bool targetFound = false;
MapTile start = GetPlayerPosition(gameManager);
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (maxDistance < simpleDistance)
{
maxDistance = simpleDistance;
maxPlayerId = player.GetPlayerId();
targetFound = true;
}
}
}
if (targetFound)
{
m_playerId = maxPlayerId;
return(true);
}
}
}
else if (m_type.Equals("Spirit Strike"))
{
if (!gameManager.IsMainPlayerMoving())
{
if (hpPercent > 90)
{
m_playerId = gameManager.GetMainPlayerId();
MapTile start = GetPlayerPosition(gameManager);
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (simpleDistance <= 1)
{
m_target = goal;
return(true);
}
}
}
}
}
}
else if (m_type.Equals("Critical Strike"))
{
if (!gameManager.IsMainPlayerMoving())
{
if (hpPercent > 90)
{
m_playerId = gameManager.GetMainPlayerId();
MapTile start = GetPlayerPosition(gameManager);
foreach (PlayerManager player in gameManager.GetAllPlayerManagers())
{
if (player.IsPlayerMob())
{
MapTile goal = GetPlayerPosition(gameManager, player);
int simpleDistance = PathManager.DistanceHeuristic(start, goal);
if (simpleDistance <= 1)
{
m_target = goal;
return(true);
}
}
}
}
}
}
else if (m_type.Equals("Covenant"))
{
if (hpPercent > 90 && mpPercent < 90)
{
m_playerId = gameManager.GetMainPlayerId();
return(true);
}
}
}
return(false);
}
protected abstract bool CanUseAction(GameManager gameManager, AutoControllerState state);
public CastAction(GameManager gameManager, AutoControllerState state, CancellationToken token, SlotUI slot, int aether, string type) : base(gameManager, state, token)
{
m_slot = slot;
m_aether = aether;
m_type = type;
}
protected abstract int DelayAction(GameManager gameManager, AutoControllerState state);
public MessageAction(GameManager gameManager, AutoControllerState state, CancellationToken token, int aether, string message) : base(gameManager, state, token)
{
m_aether = aether;
m_message = message;
}
/*public async override Task<bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state) {
* int distanceFromTarget = pathManager.GetDistanceToPlayer();
* MapTile start = GetPlayerPosition(gameManager);
* List<int> playerIdList = new List<int>();
* int map = start.Item1;
* float totalX = 0f, totalY = 0f, followPositionScale = 0f;
* foreach(GameManager manager in ClientManager.GetAllGameManagers()) {
* if(!manager.Equals(gameManager)) {
* int playerId = manager.GetMainPlayerId();
* MapTile goal = GetPlayerPosition(manager);
* if(await pathManager.IsSameArea(gameManager, start, goal)) {
* int distance = PathManager.DistanceHeuristic(start, goal);
* float scale = (float) distance / distanceFromTarget * 2;
* if(!playerIdList.Contains(playerId)) {
* totalX += goal.Item2 * scale;
* totalY += goal.Item3 * scale;
* followPositionScale+=scale;
* playerIdList.Add(playerId);
* }
* }
* }
* }
* foreach(PartyPlayerUI partyPlayer in gameManager.GetAllPartyPlayers()) {
* int playerId = partyPlayer.GetPlayerId();
* PlayerManager player = gameManager.GetPlayerManager(playerId);
* if(player != null) {
* MapTile goal = GetPlayerPosition(gameManager, player);
* int distance = PathManager.DistanceHeuristic(start, goal);
* float scale = (float) distance / distanceFromTarget * 2;
* int x = goal.Item2, y = goal.Item3;
* if(!playerIdList.Contains(playerId)) {
* totalX += x * scale;
* totalY += y * scale;
* followPositionScale+=scale;
* playerIdList.Add(playerId);
* }
* }
* }
* if(playerIdList.Count > 0) {
* int x = (int) Mathf.Round(totalX / followPositionScale);
* int y = (int) Mathf.Round(totalY / followPositionScale);
* state.SetTargetTile(Tuple.Create(map, x, y));
* }
* return playerIdList.Count > 0;
* }*/
public override async Task Move(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
MapTile start = GetPlayerPosition(gameManager);
MapTile goal = state.GetTargetTile();
if (goal != null)
{
int distanceFromTarget = pathManager.GetDistanceToPlayer();
await WalkToTile(gameManager, pathManager, state, start, goal, null, distanceFromTarget);
}
}
protected override int UseAction(GameManager gameManager, AutoControllerState state) // Todo create data object to keep track of slot / playerId
{
gameManager.HandleChatInput(m_message);
return(m_aether);
}
public async override Task <bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
await Task.Yield();
GameManager currentManager = ClientManager.GetCurrentGameManager();
if (!currentManager.Equals(gameManager))
{
PlayerManager player = currentManager.GetMainPlayerManager();
state.SetTarget(player);
state.SetTargetTile(GetPlayerPosition(currentManager, player));
return(true);
}
return(false);
}
public abstract Task <bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state);
public abstract Task Move(GameManager gameManager, PathManager pathManager, AutoControllerState state);
public async override Task <bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
await Task.Yield();
return(false);
}
public override async Task <bool> IsActive(GameManager gameManager, PathManager pathManager, AutoControllerState state)
{
GameManager closestGameManager = ClientManager.GetCurrentGameManager();
int minDistance = Int32.MaxValue;
bool regroupRequired = false;
bool allWithinRange = true;
MapTile start = GetPlayerPosition(gameManager);
foreach (GameManager manager in ClientManager.GetAllGameManagers())
{
if (!manager.Equals(gameManager))
{
MapTile goal = GetPlayerPosition(manager);
Tuple <LinkedList <MapTile>, WarpDevice, int> mapPathInfo = await pathManager.GetMapPath(gameManager, start, goal);
int distance = mapPathInfo.Item3;
bool sameArea = await pathManager.IsSameArea(gameManager, start, goal);
if (distance > REGROUP_REQUIRED_DISTANCE)
{
if (distance < minDistance)
{
minDistance = distance;
closestGameManager = manager;
}
allWithinRange = false;
}
if (distance > REGROUP_REQUIRED_DISTANCE || !sameArea)
{
regroupRequired = true;
}
}
}
if (closestGameManager != null)
{
PlayerManager player = closestGameManager.GetMainPlayerManager();
state.SetTargetTile(GetPlayerPosition(closestGameManager, player));
state.SetTarget(player);
}
if (regroupRequired && !allWithinRange)
{
MapTile safePoint = pathManager.GetSafePoint();
Tuple <LinkedList <MapTile>, WarpDevice, int> mapPathInfo = await pathManager.GetMapPath(gameManager, start, safePoint);
int distance = mapPathInfo.Item3;
if (distance < minDistance)
{
state.SetTargetTile(safePoint);
state.SetTarget(null);
}
}
return(regroupRequired);
}
