public InvocationContext(TargetSelectionContext targetSelection, ActiveTarget target)
{
Context = targetSelection.Context;
ActiveAttribute = targetSelection.ActiveAttribute;
Target = target;
Doer = targetSelection.Doer;
}
//--------------------------------------------------
public void EarlyUpdate()
{
Status.EarlyUpdate(Move.DesiredVelocity);
Behaviour.EarlyUpdate(Status);
if (ActiveTarget != null && ActiveTarget.IsValidAndReady)
{
ActiveTarget.EarlyUpdate(OwnerComponent);
if (!Status.IsPerceptionForced && ActiveTarget.TargetMoveComplete)
{
Status.IsPerceptionForced = true;
}
if (!Status.IsReactionForced && ActiveTarget.TargetMoveComplete)
{
Status.IsReactionForced = true;
}
if (ActiveTarget.TargetMoveComplete)
{
if (OnTargetMoveComplete != null)
{
OnTargetMoveComplete(Owner, ActiveTarget);
}
}
}
SelectStandardBehaviour();
}
//--------------------------------------------------
public void FixedUpdate()
{
//TODO: obsolete
if (Missions.Outpost.TargetReady())
{
Missions.Outpost.Target.FixedUpdate();
}
if (Missions.Escort.TargetReady())
{
Missions.Escort.Target.FixedUpdate();
}
if (Missions.Patrol.TargetReady())
{
Missions.Patrol.Target.FixedUpdate();
}
if (Interaction.TargetReady())
{
Interaction.FixedUpdate();
}
if (ActiveTarget != null && ActiveTarget.IsValid)
{
ActiveTarget.FixedUpdate();
}
if (Behaviour.BehaviourMode != null && Behaviour.BehaviourMode.Rule != null && Behaviour.BehaviourMode.Rule.Influences.Enabled)
{
Status.AddDamage(Behaviour.BehaviourMode.Rule.Influences.Damage);
Status.AddStress(Behaviour.BehaviourMode.Rule.Influences.Stress);
Status.AddDebility(Behaviour.BehaviourMode.Rule.Influences.Debility);
Status.AddHunger(Behaviour.BehaviourMode.Rule.Influences.Hunger);
Status.AddThirst(Behaviour.BehaviourMode.Rule.Influences.Thirst);
}
if (Environment.SurfaceHandler.ActiveSurface != null && Environment.SurfaceHandler.ActiveSurface.Influences.Enabled == true)
{
Status.AddDamage(Environment.SurfaceHandler.ActiveSurface.Influences.Damage);
Status.AddStress(Environment.SurfaceHandler.ActiveSurface.Influences.Stress);
Status.AddDebility(Environment.SurfaceHandler.ActiveSurface.Influences.Debility);
Status.AddHunger(Environment.SurfaceHandler.ActiveSurface.Influences.Hunger);
Status.AddThirst(Environment.SurfaceHandler.ActiveSurface.Influences.Thirst);
}
Status.FixedUpdate();
if (Status.IsDead)
{
Behaviour.SetBehaviourModeByKey(Essentials.BehaviourModeDead);
Status.RespawnRequest();
}
if (Status.IsRespawnTime)
{
Status.Respawn();
}
}
public ActiveTarget CalcTarget(ActiveTarget target, int month, ref double reservedSum)
{
double reserve = target.CurrentSum + month * target.Spend;
if (reserve > target.TotalSum)
{
reserve = target.TotalSum;
}
target.CurrentSum = reserve;
reservedSum += reserve;
return(target);
}
public void LateUpdate()
{
if (!Status.LateUpdate())
{
return;
}
Essentials.Target.LateUpdate(Owner, Move.MoveSpeed);
Missions.Outpost.Target.LateUpdate(Owner, Move.MoveSpeed);
Missions.Escort.Target.LateUpdate(Owner, Move.MoveSpeed);
Missions.Patrol.LateUpdate(Owner, Move.MoveSpeed);
Interaction.LateUpdate(Owner, Move.MoveSpeed);
if (ActiveTarget != null)
{
ActiveTarget.LateUpdate(Owner, Move.MoveSpeed);
if (ActiveTarget.Influences.Update())
{
UpdateStatusInfluences(ActiveTarget.Influences);
}
}
Environment.SurfaceHandler.Update(this);
if (Environment.SurfaceHandler.ActiveSurface != null)
{
if (Environment.SurfaceHandler.ActiveSurface.Influences.Update())
{
UpdateStatusInfluences(Environment.SurfaceHandler.ActiveSurface.Influences);
}
if (Environment.SurfaceHandler.ActiveSurface.BehaviourModeKey != "")
{
SetActiveBehaviourModeByKey(Environment.SurfaceHandler.ActiveSurface.BehaviourModeKey);
}
}
if (Behaviour.LateUpdate(Status) && Behaviour.ActiveBehaviourModeRule.Influences.Update())
{
UpdateStatusInfluences(Behaviour.ActiveBehaviourModeRule.Influences);
}
}
/// <summary>
/// Sets the active target.
/// </summary>
/// <param name="_target">_target.</param>
public void SetActiveTarget(TargetObject _target)
{
if (Status.IsDead || Status.IsSpawning)
{
return;
}
if (Move.Deadlock.Deadlocked)
{
Move.Deadlock.Reset(Owner.transform);
if (Move.Deadlock.Action == DeadlockActionType.BEHAVIOUR)
{
SetActiveBehaviourModeByKey(Move.Deadlock.Behaviour);
return;
}
else if (Move.Deadlock.Action == DeadlockActionType.UPDATE && m_ActiveTarget != null)
{
m_ActiveTarget.Move.UpdateRandomOffset();
}
else
{
Status.Kill();
return;
}
}
if (_target == null || !_target.IsValidAndReady || Status.RecreationRequired)
{
_target = Essentials.PrepareTarget(OwnerComponent);
}
if (_target == null || !_target.IsValidAndReady)
{
if (DebugLogIsEnabled)
{
PrintDebugLog(this, "Sorry, the creature have no valid target!");
}
return;
}
m_TargetChanged = false;
if (IsTargetUpdatePermitted(_target))
{
// update target
if (!_target.CompareTarget(m_ActiveTarget, m_ActiveTargetID))
{
// handle previous target
ResetActiveTarget();
// handle new target
m_ActiveTarget = _target;
m_ActiveTargetGameObject = _target.TargetGameObject;
m_ActiveTargetID = _target.TargetID;
m_ActiveTargetName = _target.TargetName;
m_ActiveTargetKey = _target.TargetName + _target.TargetID.ToString();
if (m_ActiveTarget != null)
{
m_ActiveTarget.SetActive(OwnerComponent);
if (m_ActiveTarget.EntityComponent != null)
{
m_ActiveTarget.EntityComponent.AddActiveCounterpart(OwnerComponent as ICECreatureEntity);
}
if (m_ActiveTarget.GroupMessage.Type != BroadcastMessageType.NONE)
{
/*
* BroadcastMessageDataObject _data = new BroadcastMessageDataObject();
*
* _data.Type = m_ActiveTarget.GroupMessage.Type;
* _data.TargetGameObject = m_ActiveTarget.TargetGameObject;
* _data.Command = m_ActiveTarget.GroupMessage.Command;*/
ICECreatureEntity _entity = OwnerComponent as ICECreatureEntity;
if (_entity != null)
{
_entity.Message.SendGroupMessage(new BroadcastMessageDataObject(m_ActiveTarget.GroupMessage.Type, m_ActiveTarget.TargetGameObject, m_ActiveTarget.GroupMessage.Command));
}
}
}
if (DebugLogIsEnabled)
{
string _previus = (m_PreviousTargetName != "" ? m_PreviousTargetName + " (" + m_PreviousTargetID + ")": "unknown");
string _active = (m_ActiveTargetName != "" ? m_ActiveTargetName + " (" + m_ActiveTargetID + ")": "unknown");
PrintDebugLog(this, "SetActiveTarget - creature changed active target from " + _previus + " to " + _active + ".");
}
Move.UpdateTargets(m_ActiveTarget, Essentials.Target);
m_TargetChanged = true;
}
// update target behaviour
if (m_ActiveTarget != null)
{
string _key = ActiveTarget.Behaviour.CurrentBehaviourModeKey;
if (string.IsNullOrEmpty(_key))
{
// if the active target is not a HOME or if the creature outside the max range it have to travel to reach its target
if (!ActiveTarget.TargetInMaxRange(Owner.transform.position))
{
_key = Essentials.BehaviourModeRun;
}
// if the creature reached the TargetMovePosition it should do the rendezvous behaviour
else if (ActiveTarget.TargetMoveComplete)
{
_key = Essentials.BehaviourModeIdle;
}
// in all other case the creature should be standby and do some leisure activities
else //if( Target.TargetRandomRange > 0 )
{
_key = Essentials.BehaviourModeWalk;
}
}
SetActiveBehaviourModeByKey(_key);
}
}
}
