public void SetAttackUnitDetail(AttackTask task)
{
if (grid.transform.childCount > 0)
{
Transform[] child = new Transform[grid.transform.childCount];
for (int i = 0; i < grid.transform.childCount; i++)
{
child[i] = grid.transform.GetChild(i);
}
for (int i = 0; i < child.Length; i++)
{
child[i].parent = null;
NGUITools.Destroy(child[i].gameObject);
}
}
foreach (CombatUnit unit in task.PlayerUnit.Keys)
{
GameObject go = NGUITools.AddChild(grid.gameObject, attackUnitRowPrefab);
UIAttackUnitRow rowDisplay = go.GetComponent <UIAttackUnitRow>();
rowDisplay.SetUnitInfo(unit.unitType, task.PlayerUnit[unit]);
}
grid.Reposition();
scrollview.ResetPosition();
}
private void OnRightClick()
{
GameObject hittedObj = GameObjectUnderMouse();
int hittedObjLayer = hittedObj.layer;
if (hittedObjLayer == layerMaskToLayer(TerrainLayerMask))
{
ClearDeadUnits();
SortByDistance(endDragRayHit.point);
for (int i = 0; i < SelectedUnits.Count; i++)
{
if (SelectedUnits[i].IsTaskAvailable <GoToTask>())
{
GoToTask goToTask = SelectedUnits[i].ChangeTask <GoToTask>();
goToTask.StartTask(endDragRayHit.point);
}
}
}
else if (hittedObjLayer == layerMaskToLayer(EnemyUnitsLayerMask) || hittedObjLayer == layerMaskToLayer(EnemyBuildingLayerMask))
{
ClearDeadUnits();
SortByDistance(hittedObj.transform.position);
for (int i = 0; i < SelectedUnits.Count; i++)
{
if (SelectedUnits[i].IsTaskAvailable <AttackTask>())
{
AttackTask attackTask = SelectedUnits[i].ChangeTask <AttackTask>();
attackTask.StartTask(hittedObj.transform);
}
}
}
}
public override void InitializeTasks()
{
base.InitializeTasks();
SiegeTask.Enable();
TimingAttackTask.Enable();
//WorkerScoutTask.Enable();
DefenseTask.Enable();
BunkerDefendersTask.Enable();
SupplyDepotTask.Enable();
ArmyRavenTask.Enable();
MechDestroyExpandsTask.Enable();
RepairTask.Enable();
ReplenishBuildingSCVTask.Enable();
ClearBlockedExpandsTask.Enable();
HomeRepairTask.Enable();
TransformTask.Enable();
ThorretTask.Enable();
HideBuildingTask.Enable();
HideUnitsTask.Enable();
//AttackTask.Enable();
AttackTask.Enable();
if (TankDefenseTasks.Count == 0)
{
foreach (Base b in Bot.Main.BaseManager.Bases)
{
if (b == Natural ||
b == Main)
{
continue;
}
TankDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.SIEGE_TANK)
{
MaxDefenders = 2
});
LiberatorDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.LIBERATOR)
{
MaxDefenders = 1
});
VikingDefenseTasks.Add(new DefenseSquadTask(b, UnitTypes.VIKING_FIGHTER)
{
MaxDefenders = 1
});
}
}
foreach (DefenseSquadTask task in TankDefenseTasks)
{
Task.Enable(task);
}
foreach (DefenseSquadTask task in LiberatorDefenseTasks)
{
Task.Enable(task);
}
foreach (DefenseSquadTask task in VikingDefenseTasks)
{
Task.Enable(task);
}
}
/// <summary>
/// Executes behavior with given context
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public override BehaviorReturnCode Behave(IBehaviorContext context)
{
UnitBehaviorContext unitContext = context as UnitBehaviorContext;
if (unitContext == null)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
StaticUnit unit = unitContext.Unit as StaticUnit;
if (unit == null ||
unit.Environment is Galaxy ||
unit.Target == null ||
unit.Environment != unit.Target.Environment ||
!unit.CanAttack ||
unit.Owner == unit.Target.Owner)
{
returnCode = BehaviorReturnCode.Failure;
return(returnCode);
}
context.AddLogMessage("Attacking Target - " + unit.Target.Name);
AttackTask task = new AttackTask(unit);
while (!task.IsTaskFinished)
{
task.Execute();
}
returnCode = BehaviorReturnCode.Success;
return(returnCode);
}
private IActorTask HandlePersiutMode()
{
var isAttackAllowed = CheckAttackAvailability(_targetIntruder);
if (isAttackAllowed)
{
var attackTask = new AttackTask(_actor, _targetIntruder, _actService);
return(attackTask);
}
else
{
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
//TODO Сделать тест аналогичный GetActorTasks_PatrolsTryToAttackEnemy_ReturnsMoveTask
if (_persuitCounter > 0 && _moveTask != null)
{
_persuitCounter--;
return(_moveTask);
}
else
{
RefreshPersuiteCounter();
_moveTask = new MoveTask(_actor, _targetIntruder.Node, _map);
return(_moveTask);
}
}
}
private Vec3 CalculateTargetPosition(AttackTask attackTask)
{
Dynamic target = attackTask.TargetEntity;
Vec3 targetPos = target != null ? target.Position : attackTask.TargetPosition;
//to consider speed of the target
if (target != null)
{
Gun gun = attackTask.Weapon as Gun;
if (gun != null)
{
BulletType bulletType = gun.Type.NormalMode.BulletType;
if (bulletType.Velocity != 0)
{
float flyTime = (targetPos - ControlledObject.Position).Length() /
bulletType.Velocity;
if (target.PhysicsModel != null && target.PhysicsModel.Bodies.Length != 0)
{
Body targetBody = target.PhysicsModel.Bodies[0];
targetPos += targetBody.LinearVelocity * flyTime;
}
}
}
}
return(targetPos);
}
private IActorTask HandlePersuitMode()
{
var isAttackAllowed = CheckAttackAvailability(_targetIntruder);
if (isAttackAllowed)
{
var attackTask = new AttackTask(Actor, _targetIntruder, _actService);
return(attackTask);
}
else
{
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
if (_pursuitCounter > 0 && _moveTask != null && _moveTask.CanExecute())
{
_pursuitCounter--;
return(_moveTask);
}
else
{
RefreshPursuitCounter();
_moveTask = new MoveTask(Actor, _targetIntruder.Node, Map);
return(_moveTask);
}
}
}
public async Task AttackTask_NoWall_NotThrowsInvalidOperationException()
{
// Подготовка. Два актёра через клетку. Радиус действия 1-2, достаёт.
_testMap = await SquareMapFactory.CreateAsync(3).ConfigureAwait(false);
var tacticalActMock = new Mock <ITacticalAct>();
tacticalActMock.SetupGet(x => x.Stats).Returns(new TestTacticalActStatsSubScheme
{
Range = new Range <int>(1, 2)
});
var tacticalAct = tacticalActMock.Object;
var combatActModuleMock = new Mock <ICombatActModule>();
combatActModuleMock.Setup(x => x.CalcCombatActs())
.Returns(new[] { tacticalAct });
var combatActModule = combatActModuleMock.Object;
var personMock = new Mock <IPerson>();
personMock.Setup(x => x.GetModule <ICombatActModule>(It.IsAny <string>())).Returns(combatActModule);
var person = personMock.Object;
var actorMock = new Mock <IActor>();
var actorNode = _testMap.Nodes.SelectByHexCoords(0, 0);
actorMock.SetupGet(x => x.Node).Returns(actorNode);
actorMock.SetupGet(x => x.Person).Returns(person);
actorMock.Setup(x => x.UseAct(It.IsAny <IGraphNode>(), It.IsAny <ITacticalAct>()))
.Raises <IGraphNode, ITacticalAct>(x => x.UsedAct += null,
(target1, act1) => new UsedActEventArgs(target1, act1));
_actor = actorMock.Object;
var targetMock = new Mock <IActor>();
var targetNode = _testMap.Nodes.SelectByHexCoords(2, 0);
targetMock.Setup(x => x.CanBeDamaged()).Returns(true);
targetMock.SetupGet(x => x.Node).Returns(targetNode);
var target = targetMock.Object;
var actServiceMock = new Mock <ITacticalActUsageService>();
var actService = actServiceMock.Object;
var taskContextMock = new Mock <IActorTaskContext>();
var taskContext = taskContextMock.Object;
// Создаём саму команду
_attackTask = new AttackTask(_actor, taskContext, target, tacticalAct, actService);
Action act = () =>
{
// ACT
_attackTask.Execute();
};
// ASSERT
act.Should().NotThrow <InvalidOperationException>();
}
void ResetAttackTask(AttackTask task)
{
if (task.TargetEntity != null)
{
RemoveRelationship(task.TargetEntity);
}
attackTasks.Remove(task);
}
private void ResetAttackTask(AttackTask task)
{
if (task.TargetEntity != null)
{
UnsubscribeToDeletionEvent(task.TargetEntity);
}
attackTasks.Remove(task);
}
/// <summary>
/// Start track attack task.
/// </summary>
/// <param name="task">Task.</param>
public void TrackAttackTask(AttackTask task)
{
attackTaskId = task.TaskId;
attackTask = task;
task.Evt_OnTimeLeftToComplete += OnUpdateProgress;
task.Evt_OnAttackComplete += OnAttackTaskComplete;
}
public override IActorTask GetTask(IActor actor, ISectorTaskSourceContext context,
ILogicStrategyData strategyData)
{
var triggerTarget = strategyData.TriggerIntuder;
if (triggerTarget == null)
{
throw new InvalidOperationException(
$"Assign {nameof(strategyData.TriggerIntuder)} with not null valie in related trigger.");
}
var targetCanBeDamaged = triggerTarget.CanBeDamaged();
if (!targetCanBeDamaged)
{
Complete = true;
return(null);
}
var attackParams = CheckAttackAvailability(actor, triggerTarget, context.Sector.Map);
if (attackParams.IsAvailable)
{
var act = attackParams.CombatAct;
var taskContext = new ActorTaskContext(context.Sector);
var attackTask = new AttackTask(actor, taskContext, triggerTarget, act, _actService);
return(attackTask);
}
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)
{
_refreshCounter--;
return(_moveTask);
}
var map = context.Sector.Map;
_refreshCounter = REFRESH_COUNTER_VALUE;
var targetIsOnLine = map.TargetIsOnLine(actor.Node, triggerTarget.Node);
if (targetIsOnLine)
{
var taskContext = new ActorTaskContext(context.Sector);
var moveModule = actor.Person.GetModule <IMovingModule>();
var moveCost = moveModule.CalculateCost();
_moveTask = new MoveTask(actor, taskContext, triggerTarget.Node, map, moveCost);
return(_moveTask);
}
// Цел за пределами видимости. Считается потерянной.
return(null);
}
public static AttackTask CreateTask(string taskId, string targetId, string targetName, Dictionary <CombatUnit, int> targetUnit,
Dictionary <CombatUnit, int> playerUnit, OnAttackComplete completeCallBack = null,
OnTimeLeftToComplete timeLeftCallBack = null, int duration = 1)
{
AttackTask task = new AttackTask();
task.InitTask(taskId, targetId, targetName, targetUnit, playerUnit, completeCallBack, timeLeftCallBack, duration);
return(task);
}
private bool FindAutomaticTask()
{
Mech controlledObj = ControlledObject;
float maximalPriority = 0;
MapObject needAttackObject = null;
//find object. units only.
Map.Instance.GetObjects(new Sphere(controlledObj.Position, controlledObj.ViewRadius),
MapObjectSceneGraphGroups.UnitGroupMask, delegate(MapObject mapObject)
{
Unit unit = (Unit)mapObject;
//check distance
Vec3 diff = unit.Position - controlledObj.Position;
float objDistanceSqr = diff.LengthSqr();
if (objDistanceSqr <= controlledObj.ViewRadius * controlledObj.ViewRadius)
{
float priority;
//Attack task
if (weapons.Length != 0)
{
priority = GetTaskAttackObjectPriority(unit);
if (priority != 0 && priority > maximalPriority)
{
maximalPriority = priority;
needAttackObject = unit;
}
}
}
});
//do task
if (needAttackObject != null)
{
MapObject currentAttackedUnit = null;
{
AttackTask currentAttackTask = currentTask as AttackTask;
if (currentAttackTask != null)
{
currentAttackedUnit = currentAttackTask.TaskEntity;
}
}
if (needAttackObject != currentAttackedUnit)
{
DoTask(new AttackTask(this, needAttackObject), false);
}
return(true);
}
return(false);
}
/// <summary>
/// Handle attack task complete event.
/// </summary>
/// <param name="task">Task.</param>
void OnAttackTaskComplete(AttackTask task)
{
transform.parent = null;
NGUITools.Destroy(gameObject);
if (Evt_OnAttackProgressDestroy != null)
{
Evt_OnAttackProgressDestroy();
}
}
public AttackDataManager(AttackData attackData, ActiveUnitData activeUnitData, AttackTask attackTask, TargetPriorityService targetPriorityService, TargetingData targetingData, MacroData macroData, BaseData baseData, DebugService debugService)
{
AttackData = attackData;
ActiveUnitData = activeUnitData;
AttackTask = attackTask;
TargetPriorityService = targetPriorityService;
TargetingData = targetingData;
MacroData = macroData;
BaseData = baseData;
DebugService = debugService;
}
/*
* public bool AttackPlayer(string playerId, int sentUnit)
* {
* AIPlayer aiPlayer = GetAIPlayer (playerId);
*
* if(aiPlayer != null)
* {
* AttackManagerMetaData data = AttackManagerMetaData.Load();
*
* string taskId = GenerateTaskId();
*
* if(data.AddAttackTask(taskId, aiPlayer.playerId, aiPlayer.playerName, aiPlayer.totalCombatUnit, sentUnit, aiPlayer.attackDuration))
* {
* AttackTask task = AttackTask.CreateTask(taskId, aiPlayer.playerId, aiPlayer.playerName, aiPlayer.totalCombatUnit, OnAttackTaskComplete, null, aiPlayer.attackDuration);
*
* _attackTasks.Add(task);
*
* TaskManager.Instance.AddTask(task);
*
* EventManager.GetInstance().ExecuteEvent<EventNewAttack>(new EventNewAttack(task));
*
* return true;
* }
* }
* else
* {
* Debug.LogError("Attack player with id "+playerId+" not exist");
* }
*
* return false;
* }
*/
/// <summary>
/// Attacks player.
/// </summary>
/// <returns><c>true</c>, if player was attacked, <c>false</c> otherwise.</returns>
/// <param name="playerId">Player identifier.</param>
/// <param name="sentUnit">Sent unit.</param>
public bool AttackPlayer(string playerId, Dictionary <CombatUnitType, int> sentUnit)
{
//todo:send unit
AIPlayer aiPlayer = GetAIPlayer(playerId);
if (aiPlayer != null)
{
AttackManagerMetaData data = AttackManagerMetaData.Load();
string taskId = GenerateTaskId();
//attacker(player) unit
Dictionary <CombatUnit, int> dic = new Dictionary <CombatUnit, int>();
foreach (CombatUnitType type in sentUnit.Keys)
{
if (sentUnit[type] > 0)
{
CombatUnit unit = CombatUnitManager.Instance.GetCombatUnitInfoByType(type);
dic.Add(unit, sentUnit[type]);
}
}
Dictionary <ResourceType, float> resoruceAward = new Dictionary <ResourceType, float>();
for (int i = 0; i < aiPlayer.resourceAwardType.Count; i++)
{
resoruceAward.Add(aiPlayer.resourceAwardType[i], aiPlayer.resourceAwardAmount[i]);
}
if (data.AddAttackTask(taskId, aiPlayer.playerId, aiPlayer.playerName, aiPlayer.GetPlayerCombatUnitInfo(), dic, aiPlayer.attackDuration, resoruceAward))
{
AttackTask task = AttackTask.CreateTask(taskId, aiPlayer.playerId, aiPlayer.playerName, aiPlayer.GetPlayerCombatUnitInfo(), dic,
OnAttackTaskComplete, null, aiPlayer.attackDuration);
_attackTasks.Add(task);
TaskManager.Instance.AddTask(task);
EventManager.GetInstance().ExecuteEvent <EventNewAttack>(new EventNewAttack(task));
return(true);
}
}
else
{
Debug.LogError("Attack player with id " + playerId + " not exist");
}
return(false);
}
private bool IsWeaponDirectedToTarget(AttackTask attackTask)
{
Vec3 targetPos = CalculateTargetPosition(attackTask);
Weapon weapon = attackTask.Weapon;
//to check up a weapon angle
{
Vec3 needDirection = (targetPos - weapon.Position).GetNormalize();
Vec3 weaponDirection = weapon.Rotation.GetForward();
Radian angle = Math.Abs(MathFunctions.ACos(Vec3.Dot(needDirection, weaponDirection)));
Radian minimalDifferenceAngle = new Degree(2).InRadians();
if (angle > minimalDifferenceAngle)
{
return(false);
}
}
//to check up a line of fire
{
Ray ray = new Ray(weapon.Position, targetPos - weapon.Position);
RayCastResult[] piercingResult = PhysicsWorld.Instance.RayCastPiercing(
ray, (int)ContactGroup.CastOnlyContact);
foreach (RayCastResult result in piercingResult)
{
Dynamic dynamic = MapSystemWorld.GetMapObjectByBody(result.Shape.Body) as Dynamic;
if (dynamic != null)
{
Unit parentUnit = dynamic.GetParentUnit();
if (parentUnit != null)
{
if (parentUnit == attackTask.TargetEntity)
{
continue;
}
if (parentUnit == ControlledObject)
{
continue;
}
}
}
return(false);
}
}
return(true);
}
public override IActorTask GetTask(IActor actor, ILogicStrategyData strategyData)
{
if (_target == null)
{
_target = GetTarget(actor);
}
var targetCanBeDamaged = _target.CanBeDamaged();
if (!targetCanBeDamaged)
{
Complete = true;
return(null);
}
var attackParams = CheckAttackAvailability(actor, _target);
if (attackParams.IsAvailable)
{
var act = attackParams.TacticalAct;
var attackTask = new AttackTask(actor, _target, act, _actService);
return(attackTask);
}
else
{
// Маршрут до цели обновляем каждые 3 хода.
// Для оптимизации.
// Эффект потери цели.
if (_refreshCounter > 0 && _moveTask?.CanExecute() == true)
{
_refreshCounter--;
return(_moveTask);
}
else
{
_refreshCounter = REFRESH_COUNTER_VALUE;
var targetIsOnLine = _map.TargetIsOnLine(actor.Node, _target.Node);
if (targetIsOnLine)
{
_moveTask = new MoveTask(actor, _target.Node, _map);
return(_moveTask);
}
else
{
// Цел за пределами видимости. Считается потерянной.
return(null);
}
}
}
}
void TickAttackTasks()
{
if (unitWeapons == null)
{
FindUnitWeapons();
}
foreach (Weapon weapon in unitWeapons)
{
float radius = 0;
if (weapon.Type.WeaponNormalMode.IsInitialized)
{
radius = Math.Max(radius, weapon.Type.WeaponNormalMode.UseDistanceRange.Maximum);
}
if (weapon.Type.WeaponAlternativeMode.IsInitialized)
{
radius = Math.Max(radius, weapon.Type.WeaponAlternativeMode.UseDistanceRange.Maximum);
}
Dynamic enemy = FindEnemy(radius);
AttackTask task = attackTasks.Find(delegate(AttackTask t)
{
return(t.Weapon == weapon);
});
if (task != null)
{
if (task.TargetEntity != enemy)
{
if (enemy != null)
{
DoAttackTask(weapon, enemy);
}
else
{
ResetAttackTask(task);
}
}
}
else
{
if (enemy != null)
{
DoAttackTask(weapon, enemy);
}
}
}
}
private void DoAttackTask(Weapon weapon, Vec3 target)
{
AttackTask task = attackTasks.Find(delegate(AttackTask t)
{
return(t.Weapon == weapon);
});
if (task != null && task.TargetPosition == target)
{
return;
}
ResetAttackTask(task);
task = new AttackTask(weapon, target);
attackTasks.Add(task);
}
AIBehaviour m_aibehaviourThis; //The Behaviour to be used for this AI
// Use this for initialization
void Start()
{
m_aimodelThis = GetComponent <AIModel>(); //Initialize the model
#pragma warning disable 0219
//From here on the Behaviourtree is constructed; For more info on this you can find a graphic of the tree:
m_aibehaviourThis = new AIBehaviour(m_aimodelThis);
{
Selector selectorIdleOrAction = new Selector(m_aibehaviourThis);
{
Sequence sequenceConditionsOrIdle = new Sequence(selectorIdleOrAction);
{
//if the player is dead => idle
//if the player is not dead and not in range => idle
//if the payer is not dead and in range => idle
Selector selectorDeadOrNotInRange = new Selector(sequenceConditionsOrIdle);
Condition_PlayerDead conditionDead = new Condition_PlayerDead(selectorDeadOrNotInRange, m_aibehaviourThis);
Inverter inverterNotInRange = new Inverter(selectorDeadOrNotInRange);
Condition_InDetectionRange conditionInRange = new Condition_InDetectionRange(inverterNotInRange, m_aibehaviourThis);
IdleTask idleTask = new IdleTask(sequenceConditionsOrIdle, m_aibehaviourThis);
}
Selector selectorFleeOrFight = new Selector(selectorIdleOrAction);
{
Sequence sequenceConditionsThenFlee = new Sequence(selectorFleeOrFight);
{
Selector selectorTimerOrHealth = new Selector(sequenceConditionsThenFlee);
{
Condition_FleeTimerRunning conditionFleeDelay = new Condition_FleeTimerRunning(selectorTimerOrHealth, m_aibehaviourThis);
Condition_HealthLow conditionHealthHighEnough = new Condition_HealthLow(selectorTimerOrHealth, m_aibehaviourThis);
}
FleeTask fleetask = new FleeTask(sequenceConditionsThenFlee, m_aibehaviourThis);
}
AttackTask attackTask = new AttackTask(selectorFleeOrFight, m_aibehaviourThis);
}
}
}
#pragma warning restore 0219
m_aibehaviourThis.StartBehaviour(); //After constructing the Behaviour, start it
InvokeRepeating("UpdateAIBehaviour", m_fTickRate, m_fTickRate); //Start regularly updating the AI after one "tick"
//Subscribe to the Model to see if it is Dead in order to stop ticking
m_aimodelThis.m_modelstateCurrent
.Where(m_modelstateCurrent => m_modelstateCurrent == ModelState.Dead)
.Subscribe(m_modelstateCurrent => CancelInvoke());
}
/// <summary>
/// Fetch data from meta data.
/// </summary>
void DoFetchData()
{
AttackManagerMetaData data = AttackManagerMetaData.Load(true);
AttackInfo[] infos = data.GetAttackInfo();
for (int i = 0; i < infos.Length; i++)
{
AttackInfo info = infos[i];
AttackTask task = AttackTask.CreateTask(info.taskId, info.targetId, info.targetName, info.targetUnit, info.attackerUnit,
OnAttackTaskComplete, null, info.duration);
_attackTasks.Add(task);
TaskManager.Instance.AddTask(task);
EventManager.GetInstance().ExecuteEvent <EventNewAttack>(new EventNewAttack(task));
}
}
private void DoAttackTask(Weapon weapon, Dynamic target)
{
AttackTask task = attackTasks.Find(delegate(AttackTask t)
{
return(t.Weapon == weapon);
});
if (task != null && task.TargetEntity == target)
{
return;
}
if (task != null)
{
ResetAttackTask(task);
}
task = new AttackTask(weapon, target);
SubscribeToDeletionEvent(target);
attackTasks.Add(task);
}
void DoAttackTask(Weapon weapon, Dynamic target)
{
AttackTask task = attackTasks.Find(delegate(AttackTask t)
{
return(t.Weapon == weapon);
});
if (task != null && task.TargetEntity == target)
{
return;
}
if (task != null)
{
ResetAttackTask(task);
}
task = new AttackTask(weapon, target);
AddRelationship(target);
attackTasks.Add(task);
}
void DispalyAttackTask()
{
if (_target.AllAttackTask == null)
{
return;
}
EditorGUILayout.BeginVertical();
for (int i = 0; i < _target.AllAttackTask.Count; i++)
{
AttackTask task = _target.AllAttackTask[i];
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(task.TargetPlayerName));
EditorGUILayout.LabelField(new GUIContent(task.CurrentDuration.ToString()));
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
}
/// <summary>
/// Handle attack task complete.
/// </summary>
/// <param name="task">Task.</param>
void OnAttackTaskComplete(AttackTask task)
{
_attackTasks.Remove(task);
}
public void AttackTaskTest()
{
// ARRANGE
// Подготовка. Два актёра через клетку. Радиус действия 1-2, достаёт.
var testMap = new TestGridGenMap(3);
var actMock = new Mock <ITacticalAct>();
actMock.SetupGet(x => x.Stats).Returns(new TacticalActStatsSubScheme
{
Range = new Range <int>(1, 2)
});
var act = actMock.Object;
var actCarrierMock = new Mock <ITacticalActCarrier>();
actCarrierMock.SetupGet(x => x.Acts)
.Returns(new ITacticalAct[] { act });
var actCarrier = actCarrierMock.Object;
var personMock = new Mock <IPerson>();
personMock.SetupGet(x => x.TacticalActCarrier).Returns(actCarrier);
var person = personMock.Object;
var actorMock = new Mock <IActor>();
var actorNode = testMap.Nodes.OfType <HexNode>().SelectBy(0, 0);
actorMock.SetupGet(x => x.Node).Returns(actorNode);
actorMock.SetupGet(x => x.Person).Returns(person);
actorMock.Setup(x => x.UseAct(It.IsAny <IAttackTarget>(), It.IsAny <ITacticalAct>()))
.Raises <IAttackTarget, ITacticalAct>(x => x.UsedAct += null, (target1, act1) => new UsedActEventArgs(target1, act1));
var actor = actorMock.Object;
var targetMock = new Mock <IActor>();
var targetNode = testMap.Nodes.OfType <HexNode>().SelectBy(2, 0);
targetMock.Setup(x => x.CanBeDamaged()).Returns(true);
targetMock.SetupGet(x => x.Node).Returns(targetNode);
var target = targetMock.Object;
var actServiceMock = new Mock <ITacticalActUsageService>();
var actService = actServiceMock.Object;
// Создаём саму команду
var attackTask = new AttackTask(actor, target, actService);
using (var monitor = actor.Monitor())
{
// ACT
attackTask.Execute();
// ASSERT
monitor.Should().Raise(nameof(IActor.UsedAct));
}
}
void ResetAttackTask( AttackTask task )
{
if( task.TargetEntity != null )
RemoveRelationship( task.TargetEntity );
attackTasks.Remove( task );
}
private void DoAttackTask(Weapon weapon, Dynamic target)
{
AttackTask task = attackTasks.Find(delegate(AttackTask t)
{
return t.Weapon == weapon;
});
if (task != null && task.TargetEntity == target)
return;
if (task != null)
ResetAttackTask(task);
task = new AttackTask(weapon, target);
SubscribeToDeletionEvent(target);
attackTasks.Add(task);
}
void DoAttackTask( Weapon weapon, Dynamic target )
{
AttackTask task = attackTasks.Find( delegate( AttackTask t )
{
return t.Weapon == weapon;
} );
if( task != null && task.TargetEntity == target )
return;
if( task != null )
ResetAttackTask( task );
task = new AttackTask( weapon, target );
AddRelationship( target );
attackTasks.Add( task );
}
bool IsWeaponDirectedToTarget( AttackTask attackTask )
{
Vec3 targetPos = CalculateTargetPosition( attackTask );
Weapon weapon = attackTask.Weapon;
//to check up a weapon angle
{
Vec3 needDirection = ( targetPos - weapon.Position ).GetNormalize();
Vec3 weaponDirection = weapon.Rotation.GetForward();
Radian angle = Math.Abs( MathFunctions.ACos( Vec3.Dot( needDirection, weaponDirection ) ) );
Radian minimalDifferenceAngle = new Degree( 2 ).InRadians();
if( angle > minimalDifferenceAngle )
return false;
}
//to check up a line of fire
{
Ray ray = new Ray( weapon.Position, targetPos - weapon.Position );
RayCastResult[] piercingResult = PhysicsWorld.Instance.RayCastPiercing(
ray, (int)ContactGroup.CastOnlyContact );
foreach( RayCastResult result in piercingResult )
{
Dynamic dynamic = MapSystemWorld.GetMapObjectByBody( result.Shape.Body ) as Dynamic;
if( dynamic != null )
{
Unit parentUnit = dynamic.GetParentUnit();
if( parentUnit != null )
{
if( parentUnit == attackTask.TargetEntity )
continue;
if( parentUnit == ControlledObject )
continue;
}
}
return false;
}
}
return true;
}
void DoAttackTask( Weapon weapon, Vec3 target )
{
AttackTask task = attackTasks.Find( delegate( AttackTask t )
{
return t.Weapon == weapon;
} );
if( task != null && task.TargetPosition == target )
return;
ResetAttackTask( task );
task = new AttackTask( weapon, target );
attackTasks.Add( task );
}
Vec3 CalculateTargetPosition( AttackTask attackTask )
{
Dynamic target = attackTask.TargetEntity;
Vec3 targetPos = target != null ? target.Position : attackTask.TargetPosition;
//to consider speed of the target
if( target != null )
{
Gun gun = attackTask.Weapon as Gun;
if( gun != null )
{
BulletType bulletType = gun.Type.NormalMode.BulletType;
if( bulletType.Velocity != 0 )
{
float flyTime = ( targetPos - ControlledObject.Position ).LengthFast() /
bulletType.Velocity;
if( target.PhysicsModel != null && target.PhysicsModel.Bodies.Length != 0 )
{
Body targetBody = target.PhysicsModel.Bodies[ 0 ];
targetPos += targetBody.LinearVelocity * flyTime;
}
}
}
}
return targetPos;
}
public EventNewAttack(AttackTask task)
{
newAttackTask = task;
}
void ResetAttackTask( AttackTask task )
{
if( task.TargetEntity != null )
UnsubscribeToDeletionEvent( task.TargetEntity );
attackTasks.Remove( task );
}
void OnEnable()
{
attackTask = GetComponent <AttackTask>();
RunAllTheTime = true;
}
