/// <summary>
/// Adds an attack command to the player's units via the
/// party manager when an input is pressed.
/// </summary>
public override IEnumerator ExecuteAction()
{
Ray r = Camera.main.ScreenPointToRay(Input.mousePosition);
int layerMask = 1 << _enemyLayer;
RaycastHit hit;
Debug.DrawRay(r.origin, r.direction * RAYCAST_LENGTH, Color.red, 5f);
if (Physics.Raycast(r, out hit, RAYCAST_LENGTH, layerMask))
{
//Get targetted unit
Unit enemy = hit.transform.GetComponent <Unit>();
for (int i = 0; i < GameManager.Instance.PlayerParty.ActiveUnits.Count; i++)
{
//Queue attack command from unit to target
Unit unit = GameManager.Instance.PlayerParty.ActiveUnits[i];
AttackHandler attackHandler = unit.GetComponent <AttackHandler>();
if (attackHandler && !attackHandler.isAttacking)
{
GameManager.Instance.PlayerParty.AddCommand(new AttackCmd(unit, enemy));
}
}
yield return(new WaitForEndOfFrame());
}
yield return(null);
}
internal void AttackMobs()
{
if (MobsPanel.CheckedIndices.Count < 1)
{
LogPanel.Log("E: Choose at least 1 mob to attack");
return;
}
// sort by value - ie., sort by room number
List <AttackHandler.MobArg> mobs = new List <AttackHandler.MobArg>();
foreach (int i in MobsPanel.CheckedIndices)
{
int id = int.Parse(MobsPanel.Mobs[i].SubItems[1].Text);
int room = int.Parse(MobsPanel.Mobs[i].SubItems[2].Text);
string name = MobsPanel.Mobs[i].SubItems[0].Text;
AttackHandler.MobArg arg = new AttackHandler.MobArg(id, room, name);
if (!mobs.Contains(arg))
{
mobs.Add(arg);
}
}
mobs.Sort(
delegate(
AttackHandler.MobArg first,
AttackHandler.MobArg second)
{
return(second.RoomId.CompareTo(first.RoomId));
}
);
SetUpHandler();
AttackHandler.BeginMobs(mobs);
}
public RangedAttacks RangedAttack(AttackHandler handler, ref RangedAttacks prefab, RangedAttacks currentAttack, InputAction.CallbackContext ctx)
{
if (handler.playerManager.energy.currentEnergy - energyCost > 0 && !prefab.coolingdown)
{
if (ctx.started)
{
GameObject attack = ObjectPooler.SharedInstance.GetPooledObject(tag);
attack.transform.position = handler.transform.position;
attack.transform.rotation = handler.transform.rotation;
attack.SetActive(true);
currentAttack = attack.GetComponent <RangedAttacks>();
currentAttack.performer = handler.caster;
return(currentAttack);
}
if (currentAttack != null)
{
if (ctx.performed)
{
currentAttack.OnTriggered(handler.caster);
return(currentAttack);
}
if (ctx.canceled)
{
currentAttack.OnReleased();
}
}
return(currentAttack);
}
return(null);
}
// Callback function invoked when the cooldown timer is finished.
private void CooldownFinished(float secondsOverflow)
{
// Choose a random attack.
AttackHandler attack = UtilRandom.GetRandomElement(attacks);
// Execute the attack.
attack(boss);
}
private void Awake()
{
_attackHandler = GetComponent <AttackHandler>();
_stats = GetComponent <StatsBehaviour>();
Item.OnPickUp += AddItem;
}
void Awake()
{
Player player = FindObjectOfType <Player>();
_attackHandler = player.GetComponent <AttackHandler>();
_attackHandler.OnProjectileFired += ShakeCamera;
}
protected virtual void raiseOnAttack()
{
AttackHandler handler = onAttack;
if (handler != null)
{
handler();
}
}
public void StartHandler(Handlers Handler, out IBotHandler HandlerOut, params object[] Params)
{
HandlerOut = null;
#region Null checks
if (this == null)
{
return;
}
if (this.DRoomUser == null)
{
return;
}
Room Room = this.DRoom;
if (Room == null)
{
return;
}
#endregion
if (this.ActiveHandlers.ContainsKey(Handler))
{
IBotHandler I;
this.ActiveHandlers.TryRemove(Handler, out I);
}
switch (Handler)
{
case Handlers.TELEPORT:
HandlerOut = new TeleportHandler(this, (Item)Params[0]);
this.Teleporting = true;
break;
case Handlers.ATTACK:
HandlerOut = new AttackHandler(this, (GameClient)Params[0]);
this.Attacking = true;
break;
case Handlers.DELIVERY:
HandlerOut = new DeliveryHandler(this);
break;
case Handlers.FOODSERVE:
HandlerOut = new FoodServeHandler(this, (GameClient)Params[0], (Food.Food)Params[1], (Point)Params[2], (Point)Params[3]);
break;
default:
break;
}
this.ActiveHandlers.TryAdd(Handler, HandlerOut);
}
public override void OnGroundClick(Vector3 target)
{
AttackHandler attackHandler = GetComponent <AttackHandler>();
if (attackHandler != null)
{
GetComponent <AttackHandler>().AbortAttack();
}
Walk(target);
}
public static AttackHandler getAttackHandler()
{
try {
AttackHandler attackHandler = GameObject.Find("Event Handler").GetComponent <AttackHandler>();
return(attackHandler);
}
catch (Exception e) {
GameObject eventHandler = new GameObject("Event Handler");
eventHandler.transform.SetParent(GameObject.Find("MapGenerator").transform);
return(eventHandler.AddComponent <AttackHandler>());
}
}
internal void AttackRooms()
{
List <int> rooms = new List <int>();
foreach (int i in RoomsPanel.CheckedIndices)
{
rooms.Add(int.Parse(RoomsPanel.Rooms[i].SubItems[1].Text));
}
rooms.Sort();
SetUpHandler();
AttackHandler.BeginRooms(rooms);
}
void Start()
{
Transform transform = GetComponent <Transform>();
tankTurretTransform = GetChildTransform(transform, "UpperBody");
if (tankTurretTransform == null)
{
tankTurretTransform = GetChildTransform(transform, "Turret_Body");
}
defaultRotation = tankTurretTransform.eulerAngles;
attackHandler = gameObject.GetComponent <AttackHandler>();
SetTargetRotation(transform.root.eulerAngles.y);
}
public void attack(BaseUnit defender)
{
if (defender.ownerID == this.ownerID)
{
return;
}
int dist = System.Math.Abs(defender.xPos - this.xPos) + System.Math.Abs(defender.yPos - this.yPos);
if (dist <= this.RNG && this.currAP >= this.attackCost)
{
AttackHandler.Instance().attackEvent.raise(0, this, new Dictionary <string, object> {
{ "Attacker", this },
{ "Defender", defender }
});
this.currAP -= attackCost;
}
}
internal void AttackAreas()
{
if (RoomsPanel.CheckedRooms.Count < 1)
{
LogPanel.Log("E: Choose at least 1 area to cover");
return;
}
Dictionary <int, string> rooms = new Dictionary <int, string>();
foreach (int i in RoomsPanel.CheckedIndices)
{
rooms.Add(int.Parse(RoomsPanel.Rooms[i].SubItems[1].Text), RoomsPanel.Rooms[i].Text);
}
SetUpHandler();
AttackHandler.BeginMultiArea(rooms);
}
public void ExecuteAction(AIUnit u)
{
AttackHandler attackHandler = u.GetComponent <AttackHandler>();
if (attackHandler && attackHandler.isAttacking)
{
}
else
{
float performActionValue = Random.Range(0f, 1f);
if (performActionValue >= dontPerformActionRange)
{
if (u.Movement != null)
{
Vector2 newMovePoint = Random.insideUnitCircle * u.Character.lineOfSight;
Vector3 newPosition = transform.position + new Vector3(newMovePoint.x, transform.position.y, newMovePoint.y);
u.Movement.Move(newPosition);
u.IsIdle = false;
}
}
}
}
private void SetUpHandler()
{
List <Account> accounts = new List <Account>();
if (AccountsPanel.CheckedIndices.Count > 0)
{
foreach (int i in AccountsPanel.CheckedIndices)
{
accounts.Add(AccountsPanel.Engine[i]);
}
}
else if (AccountsPanel.FocusedAccount != null)
{
accounts.Add(AccountsPanel.Engine[AccountsPanel.FocusedAccount.Index]);
}
else if (AccountsPanel.Engine.Count > 0)
{
accounts.Add(AccountsPanel.Engine[0]);
}
AttackHandler.Set(accounts, Settings.AttackMode);
}
private static void OnAttackMissed(Unit attacker, Unit attackedEnemy, bool ranged = false, bool overClockedAttack = false)
{
AttackHandler attackHandler = getAttackHandler();
attackHandler.OnAttackMissed(attacker, attackedEnemy, ranged, overClockedAttack);
}
private void Start()
{
attackHandler = transform.parent.GetComponent <AttackHandler>();
}
public void AddAttack(AttackBase attack)
{
_skillList.Add(attack);
_AddTime += attack.AddElapsedTime;
}
private static void OnAttackHit(Unit attacker, Unit attackedEnemy, int damage, bool ranged = false, bool crit = false, bool overClockedAttack = false)
{
AttackHandler attackHandler = getAttackHandler();
attackHandler.OnAttackHit(attacker, attackedEnemy, damage, ranged, crit, overClockedAttack);
}
internal void AttackArea()
{
SetUpHandler();
AttackHandler.BeginArea();
}
public void Attack()
{
AttackHandler?.Invoke();
}
private void Awake()
{
health = GetComponent <Health> ();
controller = GetComponent <CharacterMovement> ();
attacks = GetComponent <AttackHandler> ();
}
public void Attack(Warrior warrior)
{
AttackHandler.Execute(this, warrior);
}
void Awake()
{
instance = this;
}
public void ResetAttackHandler()
{
p1 = BossAttackP1;
p2 = BossAttackP2;
}
// Use this for initialization
void Start()
{
attackHandler = GetComponent <AttackHandler>();
}
public void AddAttack(AttackHandler attack)
{
attacks.Add(attack);
}
