public override void OnCombatEvent(CombatEvent Event)
{
if (Event is NpcDieEvent)
{
Fsm.ChangeToState(FsmStateName.Die, Event);
}
}
private void HandleFarmCombatEvent(CombatEvent ce_)
{
switch (ce_)
{
case CombatEvent.PlayerDied:
{
Player p = References.Instance._currentPlayer;
p._health = p._maxHealth;
p._isDead = false;
}
break;
case CombatEvent.ClearWave:
{
Combat c = References.Instance._combat;
c.TriggerNewWave();
Player p = References.Instance._currentPlayer;
p.Heal(p._maxHealth);
}
break;
default:
break;
}
}
public void CheckHit(Ray current, Ray previous, float range)
{
var hits = Physics.RaycastAll(current, range, LayerMask.GetMask("Actor", "PhysicsObject"));
foreach (var hit in hits)
{
var go = hit.collider.gameObject;
var entity = go.GetComponentInChildren <Entity>() ?? go.GetComponentInParent <Entity>();
if (entity)
{
go = entity.gameObject;
}
if (_hitGameObjects.Contains(go))
{
continue;
}
if (entity && entity != _user.Actor)
{
var deltaOrigin = current.origin - previous.origin;
var directionAtOrigin = deltaOrigin.normalized;
var directionAtEnd = (current.direction - previous.direction).normalized;
var t = Vector3.Dot(hit.point - current.origin, current.direction * range);
var hitDirection = Vector3.Slerp(directionAtOrigin, directionAtEnd, t);
var combatEvent = new CombatEvent(_user.Actor, entity, hit.point, hitDirection, _currentAttackData);
_user.OnHitSomething(combatEvent);
}
_hitGameObjects.Add(go);
}
}
// Check all units to handle spells triggered by a combat event.
internal void HandleCombatEvent(CombatEvent combatEvent)
{
CombatEventDispatcher dispatcher = new CombatEventDispatcher(this);
foreach (PartyPosition position in SkillUsageOrder)
{
Skill offenseSkill = OffenseParty.GetAssignedSkill(position);
if (offenseSkill != null && offenseSkill.SkillDefinition.PerformedPhase == CombatPhase.ReactionPhase)
{
ISkillTriggering triggering = offenseSkill.SkillDefinition.Triggering;
if (triggering != null && triggering.CanReact(dispatcher, offenseSkill.Owner, combatEvent))
{
// Trigger skill.
ResolveSkill(GetCombatUnit(CombatPartyType.Offense, position));
}
}
Skill defenseSkill = DefenseParty.GetAssignedSkill(position);
if (defenseSkill != null && defenseSkill.SkillDefinition.PerformedPhase == CombatPhase.ReactionPhase)
{
ISkillTriggering triggering = defenseSkill.SkillDefinition.Triggering;
if (triggering != null && triggering.CanReact(dispatcher, defenseSkill.Owner, combatEvent))
{
// Trigger skill.
ResolveSkill(GetCombatUnit(CombatPartyType.Defense, position));
}
}
}
}
private void ResolveExecuteEvent(CombatSkillExecuter executer)
{
Skill userSkill = executer.ExecutedSkill;
// Execute effects on all targets.
if (userSkill != null && userSkill.SkillDefinition.Effect != null)
{
CombatEventDispatcher dispatcher = new CombatEventDispatcher(this);
CombatUnit userUnit = executer.Owner;
foreach (CombatUnit target in executer.Targets)
{
CombatEventLog log = new CombatEventLog(userSkill);
log.LogValues.Add("user", userUnit.Unit.Profile.Name);
log.LogValues.Add("target", target.Unit.Profile.Name);
log.LogValues.Add("skillname", userSkill.SkillDefinition.DisplayedName);
userSkill.SkillDefinition.Effect.Apply(dispatcher, userUnit, target, log);
_CombatEventLog.Add(log);
}
// Trigger execute event after skill usage.
CombatEvent executeEvent = new CombatEvent(executer, CombatEventType.Apply, userUnit);
HandleCombatEvent(executeEvent);
}
}
private void ResolveDeclareEvent(CombatSkillExecuter executer)
{
Skill userSkill = executer.ExecutedSkill;
CombatUnit user = executer.Owner;
// Check if the skill can be used (user is alive, skill is not used up, etc.)
if (user == null || user.CombatStatus.SkillUsed)
{
executer.Interrupt();
}
else if (user.Unit == null || user.Unit.IsDead)
{
executer.Interrupt();
}
else if (userSkill == null || userSkill.SkillCurrentUsage == 0)
{
executer.Interrupt();
}
if (!executer.IsInterrupted)
{
executer.GenerateSkillTargets();
// If we don't have valid targets, then this skill will not be triggered.
if (executer.Targets.Count == 0)
{
executer.Interrupt();
}
}
if (!executer.IsInterrupted)
{
// The skill is now triggered. Decrement skill usage times right now.
// If another reaction skill cancels this skill, the skill will still be consumed.
--userSkill.SkillCurrentUsage;
user.CombatStatus.SkillUsed = true;
// Check if any reactions are triggered.
// Reactions may modify declareEvent, causing the attempt to use this skill to fail.
// If this happens, the IsValid field on the event shall also be set to false.
// React to declare event first.
CombatEvent declareEvent = new CombatEvent(executer, CombatEventType.Declare, user);
HandleCombatEvent(declareEvent);
// Then react to targeting event for each target, if the skill execution is still valid.
if (!executer.IsInterrupted)
{
foreach (CombatUnit targetUnit in executer.Targets)
{
CombatEvent targetingEvent = new CombatEvent(executer, CombatEventType.Target, targetUnit);
HandleCombatEvent(targetingEvent);
}
}
}
}
void Die()
{
if (currentHealth <= 0)
{
GiveExp();
drop.ItemDropDeath(this.transform.position);
CombatEvent.EnemyDied(this);
Destroy(this.gameObject);
}
}
protected Entity(Dependencies dep)
{
Log = dep.Log;
_hitState = new CombatEvent(this);
_attackState = new CombatEvent(this);
_battleState = new CombatEvent(this);
_healStage = new CombatEvent(this);
State = new BattleState(this);
Name = "";
}
public void OnCombatEvent(CombatEvent Event)
{
foreach (var Handler in HandlerList_)
{
if (Handler.OnCombatEvent(Event))
{
return;
}
}
CurrentState_?.OnCombatEvent(Event);
}
public void AddEvent()
{
Player player1 = new Player(1);
Rft map = new Rft(3000, 3000);
Outpost outpost = new Outpost(new RftVector(map, 0, 0), player1, OutpostType.Generator);
outpost.AddDrillers(10);
Sub sub = new Sub(outpost, outpost, new GameTick(), 10, player1);
CombatEvent arriveEvent = new CombatEvent(sub, outpost, new GameTick(), outpost.GetTargetPosition(sub.GetCurrentPosition(), sub.GetSpeed()));
Game.TimeMachine.AddEvent(arriveEvent);
Assert.AreEqual(1, Game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, Game.TimeMachine.GetQueuedEvents()[0]);
}
private void HandleTutorialCombatEvent(CombatEvent ce_)
{
switch (ce_)
{
case CombatEvent.PlayerDied:
break;
case CombatEvent.ClearWave:
break;
default:
break;
}
}
public void AddEvent()
{
Player player1 = new Player("1");
Rft map = new Rft(3000, 3000);
Outpost outpost = new Outpost("0", new RftVector(map, 0, 0), player1, OutpostType.Generator);
outpost.AddDrillers(10);
Sub sub = new Sub("1", outpost, outpost, new GameTick(), 10, player1);
CombatEvent arriveEvent = new CombatEvent(sub, outpost, new GameTick());
game.TimeMachine.AddEvent(arriveEvent);
Assert.AreEqual(1, game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, game.TimeMachine.GetQueuedEvents()[0]);
}
public override void OnEnter(CombatEvent Event)
{
if (Fsm.Master.IsStatic)
{
Fsm.ChangeToIdleState();
return;
}
BeginPos_ = Fsm.Master.Position;
EndPos_ = (Event as NpcWalkEvent).TargetPos;
MoveTime_ = 0;
MoveTotalTime_ = (EndPos_ - BeginPos_).magnitude / Fsm.Master.CalcFinalAttr(NpcAttrIndex.Speed);
IsMove_ = true;
Fsm.Master.Actor.PlayAnimation("Walk", true);
Fsm.Master.Actor.SetDirection(CombatHelper.CalcDirection(BeginPos_, EndPos_));
}
public override void OnEnter(CombatEvent Event)
{
if (Fsm.Master.IsStatic)
{
Fsm.ChangeToIdleState();
return;
}
Fsm.Master.Actor.PlayAnimation("Idle", true);
var Evt = (Event as NpcBackEvent);
StartPos_ = Fsm.Master.Position;
BackPos_ = Evt.BackPos;
BackTime_ = Evt.BackTime;
Time_ = 0;
IsEnd_ = false;
}
public bool CanReact(CombatEventDispatcher dispatcher, Unit skillOwner, CombatEvent combatEvent)
{
// Triggered by Declare event.
if (combatEvent.Event != CombatEventType.Declare)
{
return(false);
}
if (combatEvent.Party == dispatcher.GetUnitParty(skillOwner))
{
return(false);
}
bool isCastSkill = combatEvent.Skill.SkillDefinition.HasTag(SkillTag.Cast);
// TODO: can only interrupt spells up to a certain level?
return(isCastSkill);
}
public void CanRemoveEvents()
{
Player player1 = new Player("1");
Rft map = new Rft(3000, 3000);
Outpost outpost = new Generator("0", new RftVector(map, 0, 0), player1);
outpost.GetComponent <DrillerCarrier>().AddDrillers(10);
Sub sub = new Sub("1", outpost, outpost, new GameTick(), 10, player1);
CombatEvent arriveEvent = new CombatEvent(sub, outpost, new GameTick(5));
_game.TimeMachine.AddEvent(arriveEvent);
Assert.AreEqual(2, _game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, _game.TimeMachine.GetQueuedEvents()[0]);
_game.TimeMachine.RemoveEvent(arriveEvent);
Assert.AreEqual(1, _game.TimeMachine.GetQueuedEvents().Count);
}
public void EventsSwitchQueuesWhenPassedForward()
{
Player player1 = new Player(1);
Rft map = new Rft(3000, 3000);
Outpost outpost = new Outpost(new RftVector(map, 0, 0), player1, OutpostType.Generator);
outpost.AddDrillers(10);
Sub sub = new Sub(outpost, outpost, new GameTick(), 10, player1);
CombatEvent arriveEvent = new CombatEvent(sub, outpost, GameTick.FromTickNumber(5), outpost.GetTargetPosition(sub.GetCurrentPosition(), sub.GetSpeed()));
Game.TimeMachine.AddEvent(arriveEvent);
Assert.AreEqual(1, Game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, Game.TimeMachine.GetQueuedEvents()[0]);
// Go past the tick
Game.TimeMachine.Advance(6);
Assert.AreEqual(0, Game.TimeMachine.GetQueuedEvents().Count);
}
public void AddTargetToRecentlyHitList(CombatEvent combatEvent)
{
var trackable = combatEvent.Target.GetComponent <Trackable>();
if (!trackable || !trackable.Health)
{
return;
}
if (RecentlyHit.TryAdd(trackable, Time.time))
{
ChangedRecentlyHitList?.Invoke();
}
else
{
RecentlyHit[trackable] = Time.time;
}
}
public void SubLaunchCreatesCombatEvents()
{
Outpost outpost1 = Game.TimeMachine.GetState().GetOutposts()[0];
Outpost outpost2 = Game.TimeMachine.GetState().GetOutposts()[2];
int outpostOneInitial = outpost1.GetDrillerCount();
int outpostTwoInitial = outpost2.GetDrillerCount();
LaunchEvent launch1 = new LaunchEvent(new GameTick(), outpost1, 1, outpost2);
LaunchEvent launch2 = new LaunchEvent(new GameTick(), outpost2, 1, outpost1);
Assert.AreEqual(true, launch1.ForwardAction());
Assert.AreEqual(true, launch2.ForwardAction());
// Ensure the sub was launched, outpost lost drillers, etc.
Assert.AreEqual(2, Game.TimeMachine.GetState().GetSubList().Count);
Assert.AreEqual(outpostOneInitial - 1, outpost1.GetDrillerCount());
Assert.AreEqual(outpostTwoInitial - 1, outpost2.GetDrillerCount());
// Ensure a combat event has been added that includes both subs.
int subToSubBattles = 0;
int subToOutpostBattles = 0;
GameEvent arriveEvent = null;
CombatEvent combatEvent = null;
foreach (GameEvent gameEvent in Game.TimeMachine.GetQueuedEvents())
{
if (gameEvent is CombatEvent)
{
combatEvent = (CombatEvent)gameEvent;
if (combatEvent.GetCombatants()[0] is Sub && combatEvent.GetCombatants()[1] is Sub)
{
subToSubBattles++;
}
else
{
subToOutpostBattles++;
arriveEvent = gameEvent;
}
}
}
// There should be 3 combats, one on each outpost, one on both subs.
Assert.AreEqual(1, subToSubBattles);
Assert.AreEqual(2, subToOutpostBattles);
}
public override void OnCombatEvent(CombatEvent Event)
{
if (Event is NpcWalkEvent)
{
Fsm.ChangeToState(FsmStateName.Walk, Event);
}
else if (Event is NpcSkillEvent)
{
Fsm.ChangeToState(FsmStateName.Skill, Event);
}
else if (Event is NpcDieEvent)
{
Fsm.ChangeToState(FsmStateName.Die, Event);
}
else if (Event is NpcBackEvent)
{
Fsm.ChangeToState(FsmStateName.Back, Event);
}
}
public void HandleCombatEvent(CombatEvent ce_)
{
switch (_gameMode)
{
case GameMode.Quest:
HandleQuestCombatEvent(ce_);
break;
case GameMode.Farm:
HandleFarmCombatEvent(ce_);
break;
case GameMode.Tutorial:
HandleTutorialCombatEvent(ce_);
break;
default:
break;
}
}
public void GetNextEvent()
{
//Debug.Log("GetNextEvent()");
if (m_PriorityEvent != null)
{
m_CurrentCombatEvent = m_PriorityEvent;
m_PriorityEvent = null;
}
else if (m_EventQueue.Count > 0)
{
m_CurrentCombatEvent = m_EventQueue.Dequeue();
}
else
{
m_CurrentCombatEvent = m_CombatManager.GetNextCharacterTurn();
}
Debug.Log("Initializing next event.");
m_CurrentCombatEvent.Init();
}
public void Combat()
{
IWowPlayer weakestPlayer = Bot.GetNearEnemies <IWowPlayer>(Bot.Player.Position, 30.0f).OrderBy(e => e.Health).FirstOrDefault();
if (weakestPlayer != null)
{
double distance = weakestPlayer.Position.GetDistance(Bot.Player.Position);
double threshold = Bot.CombatClass.IsMelee ? 3.0 : 28.0;
if (distance > threshold)
{
Bot.Movement.SetMovementAction(MovementAction.Move, weakestPlayer.Position);
}
else if (CombatEvent.Run())
{
// StateMachine.Get<StateCombat>().Mode = CombatMode.Force;
Bot.Wow.ChangeTarget(weakestPlayer.Guid);
}
}
else
{
}
}
public void EventsSwitchQueuesWhenRewind()
{
Player player1 = new Player("1");
Rft map = new Rft(3000, 3000);
Outpost outpost = new Outpost("0", new RftVector(map, 0, 0), player1, OutpostType.Generator);
outpost.AddDrillers(10);
Sub sub = new Sub("1", outpost, outpost, new GameTick(), 10, player1);
CombatEvent arriveEvent = new CombatEvent(sub, outpost, new GameTick(5));
game.TimeMachine.AddEvent(arriveEvent);
Assert.AreEqual(1, game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, game.TimeMachine.GetQueuedEvents()[0]);
// Go past the tick
game.TimeMachine.Advance(6);
Assert.AreEqual(0, game.TimeMachine.GetQueuedEvents().Count);
// Rewind back
game.TimeMachine.Rewind(6);
Assert.AreEqual(1, game.TimeMachine.GetQueuedEvents().Count);
Assert.AreEqual(arriveEvent, game.TimeMachine.GetQueuedEvents()[0]);
}
public void Combat()
{
WowPlayer weakestPlayer = WowInterface.ObjectManager.GetNearEnemies <WowPlayer>(WowInterface.ObjectManager.Player.Position, 30.0).OrderBy(e => e.Health).FirstOrDefault();
if (weakestPlayer != null)
{
double distance = weakestPlayer.Position.GetDistance(WowInterface.ObjectManager.Player.Position);
double threshold = WowInterface.CombatClass.IsMelee ? 3.0 : 28.0;
if (distance > threshold)
{
WowInterface.MovementEngine.SetMovementAction(MovementAction.Move, weakestPlayer.Position);
}
else if (CombatEvent.Run())
{
WowInterface.Globals.ForceCombat = true;
WowInterface.HookManager.WowTargetGuid(weakestPlayer.Guid);
}
}
else
{
}
}
public override bool OnCombatEvent(CombatEvent Event)
{
/*var Evt = Event as NpcHitTargetEvent;
* if (Evt == null)
* {
* return false;
* }
*
* var Attacker = NpcManager.FindNpc(Evt.MasterTeam, Evt.MasterID);
* if (Attacker == null)
* {
* return false;
* }
*
* if (Evt.TargetList == null || Evt.TargetList.Count == 0)
* {
* return false;
* }
*
* var Skill = Attacker.GetSkill(Evt.SkillID);
* if (!(Skill is NpcSkill))
* {
* return false;
* }
*
* if ((Skill as NpcSkill).Use(new Dictionary<string, object>(){{"HitSfx", Evt.HitSfx}, {"TargetList", Evt.TargetList}}))
* {
* if (Skill.SkillID != 3001)
* {
* LabelManager.AddStringLabel(Attacker.Position, Skill.Name, Color.green, 30);
* }
*
* return true;
* }*/
return(false);
}
public override void OnEnter(CombatEvent Event)
{
var Evt = Event as NpcSkillEvent;
SkillID_ = Evt.SkillID;
Skill_ = Fsm.Master.Skill.GetSkill(SkillID_) as NpcSkill;
if (Skill_ == null)
{
Fsm.ChangeToIdleState();
return;
}
Args_ = Evt.Args ?? Fsm.Master.Skill.CreateSkillArgs(SkillID_);
if (Fsm.Master.Actor.HasAnimation("Attack"))
{
Fsm.Master.Actor.PlayAnimation("Attack", false);
if (!Mathf.Approximately(0, Args_.Direction.sqrMagnitude))
{
Fsm.Master.Actor.FaceToPosition(Fsm.Master.Position + Args_.Direction);
}
else if (!Mathf.Approximately(0, Args_.Position.sqrMagnitude))
{
Fsm.Master.Actor.FaceToPosition(Args_.Position);
}
else if (Fsm.Master.Action.IsValidTarget())
{
Fsm.Master.Actor.FaceToPosition(Fsm.Master.Action.TargetNpc.Position);
}
}
else
{
OnAtkMsg();
Fsm.ChangeToIdleState();
}
}
public void Add(CombatEvent action)
{
events.Add(action);
}
public void AddCombatEvent(CombatEvent listn)
{
this.listener = listn;
}
public void QueueEvent(CombatEvent _combatEvent)
{
m_EventQueue.Enqueue(_combatEvent);
}
/// <summary>
/// Add an event immediately after the current event.
/// Useful for chaining events that are contingent on the current event, such as action and then target selection.
/// </summary>
/// <param name="_combatEvent">_combat event.</param>
public void QueuePriorityEvent(CombatEvent _combatEvent)
{
if (m_PriorityEvent != null)
//Debug.LogWarning("Overwriting previous priority event.");
m_PriorityEvent = _combatEvent;
}
public void LogEvent(CombatEvent attack)
{
savedData.Instance.Add(attack);
}
protected virtual void OnQueueEvent(CombatEvent _event)
{
QueueEventAction handler = QueueEvent;
if (handler != null)
handler(_event);
}
public void Die()
{
CombatEvent.EnemyDied(this);
Destroy(gameObject);
}
public void OnEventComplete()
{
m_CurrentCombatEvent = null;
}
