public void Control(FixedUpdateEvent e, AutopilotTankNode tank, [JoinByTank] WeaponNode weapon)
{
if (tank.rigidbody.Rigidbody)
{
Vector3 destination;
if (!tank.autopilotMovementController.MoveToTarget)
{
destination = tank.autopilotMovementController.Destination;
}
else
{
Entity target = tank.autopilotMovementController.Target;
if ((target == null) && tank.autopilotMovementController.MoveToTarget)
{
return;
}
if (!target.HasComponent <RigidbodyComponent>() || !target.HasComponent <TankCollidersComponent>())
{
return;
}
AutopilotMovementControllerComponent autopilotMovementController = tank.autopilotMovementController;
destination = target.GetComponent <RigidbodyComponent>().Rigidbody.position;
}
if (tank.navigationData.PathData == null)
{
PathData data = new PathData {
timeToRecalculatePath = Time.timeSinceLevelLoad
};
tank.navigationData.PathData = data;
}
this.ControlMove(tank, destination);
}
}
public void SelfDestroy(FixedUpdateEvent e, AutopilotTankNode tank, [JoinByTank] SingleNode <WeaponUndergroundComponent> weapon)
{
if (Random.value < SELF_DESTRUCT_ON_UNDEGROUND_PROBABILITY)
{
tank.Entity.AddComponentIfAbsent <SelfDestructionComponent>();
}
}
private void CheckChassisChange(AutopilotTankNode tank)
{
ChassisComponent chassis = tank.chassis;
if ((chassis.MoveAxis != tank.navigationData.LastMove) || (chassis.TurnAxis != tank.navigationData.LastTurn))
{
base.ScheduleEvent <ChassisControlChangedEvent>(tank);
tank.navigationData.LastMove = chassis.MoveAxis;
tank.navigationData.LastTurn = chassis.TurnAxis;
}
}
private void ControlMove(AutopilotTankNode tank, Vector3 targetPosition)
{
TankAutopilotComponent tankAutopilot = tank.tankAutopilot;
Rigidbody rigidbody = tank.rigidbody.Rigidbody;
Vector3 position = rigidbody.transform.position;
bool flag = rigidbody.velocity.magnitude < 0.5f;
if (tank.autopilotMovementController.Moving)
{
this.MoveToTarget(tank.navigationData, position, targetPosition, rigidbody);
}
}
private void CheckIsTargetAchievable(AutopilotTankNode tank, WeaponNode weapon)
{
Vector3 position = tank.autopilotWeaponController.TargetRigidbody.position;
Vector3 origin = weapon.weaponInstance.WeaponInstance.transform.position;
Vector3 normalized = (position - origin).normalized;
bool flag = !weapon.targetCollector.Collect(origin, new Vector3(normalized.x, 0f, normalized.z), Vector3.Distance(origin, position), 0).HasTargetHit();
if (tank.autopilotWeaponController.TragerAchievable != flag)
{
tank.autopilotWeaponController.TragerAchievable = flag;
tank.autopilotWeaponController.OnChange();
}
}
private void CalculateRotation(AutopilotTankNode tank)
{
Vector3 movePosition = tank.navigationData.MovePosition;
ChassisComponent chassis = tank.chassis;
chassis.TurnAxis = 0f;
Vector3 vector2 = tank.rigidbody.Rigidbody.transform.InverseTransformPoint(movePosition);
if (vector2.x > 0.2)
{
chassis.TurnAxis = 1f;
}
if (vector2.x < -0.2)
{
chassis.TurnAxis = -1f;
}
}
private void ApplyMissBehaviour(AutopilotTankNode tank, WeaponNode weapon)
{
Vector3 vector2 = weapon.weaponInstance.WeaponInstance.transform.InverseTransformPoint(tank.autopilotWeaponController.TargetRigidbody.position);
WeaponRotationControlComponent weaponRotationControl = weapon.weaponRotationControl;
weaponRotationControl.Centering = false;
if (Math.Abs(vector2.x) > 3f)
{
tank.autopilotWeaponController.Fire = true;
weaponRotationControl.Control = 0f;
}
else
{
tank.autopilotWeaponController.Fire = false;
weaponRotationControl.Control = -this.ToDiscrete(vector2.x, 0f);
}
}
public void Control(UpdateEvent e, AutopilotTankNode tank)
{
if (tank.rigidbody.Rigidbody && (tank.navigationData.BehavouTree != null))
{
Entity target = tank.autopilotMovementController.Target;
if (!tank.autopilotMovementController.MoveToTarget || (target != null))
{
if (target != null)
{
if (!target.HasComponent <RigidbodyComponent>())
{
return;
}
if (tank.autopilotWeaponController.TargetRigidbody != target.GetComponent <RigidbodyComponent>().Rigidbody)
{
tank.autopilotWeaponController.TargetRigidbody = target.GetComponent <RigidbodyComponent>().Rigidbody;
}
}
tank.navigationData.BehavouTree.Update();
this.CheckChassisChange(tank);
}
}
}
public void StartShotIfPossible(EarlyUpdateEvent evt, DiscreteWeaponMagazineControllerNode discreteWeaponMagazineController, [JoinByTank] AutopilotTankNode autopilotTank)
{
if (autopilotTank.autopilotWeaponController.Fire && (discreteWeaponMagazineController.cooldownTimer.CooldownTimerSec <= 0f))
{
base.ScheduleEvent <BeforeShotEvent>(discreteWeaponMagazineController);
base.ScheduleEvent <ShotPrepareEvent>(discreteWeaponMagazineController);
}
}
public void StartShotIfPossible(EarlyUpdateEvent evt, DiscreteWeaponControllerNode discreteWeaponEnergyController, [JoinByTank] AutopilotTankNode autopilotTank)
{
float unloadEnergyPerShot = discreteWeaponEnergyController.discreteWeaponEnergy.UnloadEnergyPerShot;
float energy = discreteWeaponEnergyController.weaponEnergy.Energy;
CooldownTimerComponent cooldownTimer = discreteWeaponEnergyController.cooldownTimer;
if ((autopilotTank.autopilotWeaponController.Fire && (energy >= unloadEnergyPerShot)) && (cooldownTimer.CooldownTimerSec <= 0f))
{
base.ScheduleEvent <BeforeShotEvent>(discreteWeaponEnergyController);
base.ScheduleEvent <ShotPrepareEvent>(discreteWeaponEnergyController);
base.ScheduleEvent <PostShotEvent>(discreteWeaponEnergyController);
}
}
public void BuildBot(NodeAddedEvent evt, AutopilotTankNode botTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
this.BuildWeapon(botTank.Entity, weaponNode);
}
private bool CheckAccuracy(AutopilotTankNode tank) => tank.autopilotWeaponController.Accurasy < Random.value;
public void CreateBehaviourTree(NodeAddedEvent e, AutopilotTankNode tank, [JoinByTank] WeaponNode weapon)
{
public void BuildBot(NodeAddedEvent evt, AutopilotTankNode botTank, [Context, JoinByUser] ThunderNode weaponNode, [Context, JoinByUser] SingleNode <UserComponent> userNode)
{
this.BuildWeapon(botTank.Entity, weaponNode);
}
