public void PrepareBestDirection(ShotPrepareEvent evt, UnblockedWeaponNode weaponNode, [JoinByTank] SingleNode <TankSyncComponent> tankNode)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
base.ScheduleEvent(new TargetingEvent(targetingData), weaponNode);
base.ScheduleEvent(new SendShotToServerEvent(targetingData), weaponNode);
}
public BuildingService(MapData mapData, ActiveUnitData activeUnitData, TargetingData targetingData, BaseData baseData)
{
MapData = mapData;
ActiveUnitData = activeUnitData;
TargetingData = targetingData;
BaseData = baseData;
}
// 리미트 거리가 없는 것.
public bool canPlayerHeroTargetingType2WithOutDistCheck(Monster p, bool checkTargetOnly, TargetingDecal decal)
{
_target = TargetingData.getAutomaticTarget(p, targetType, targetAttr, canUseThisSkillOnThisType);
if (_target == null)
{
return(false);
}
if (checkTargetOnly == false)
{
p.setSkillTarget(_target);
p.targetHeight = _target.hitObject.height;
p.targetPosition = _target.cTransformPosition;
p.targetUniqueId = _target.stat.uniqueId;
}
//if(p.isPlayer)
{
_v = _target.cTransformPosition;
_v.y = 1.0f;
decal.setPosition(_v);
}
_target = null;
return(true);
}
public void PrepareTargeting(TargetingEvent evt, WeaponNode weapon, [JoinByTank] TankNode tank)
{
TargetingData targetingData = evt.TargetingData;
VerticalSectorsTargetingComponent verticalSectorsTargeting = weapon.verticalSectorsTargeting;
MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance);
targetingData.Origin = accessor.GetBarrelOriginWorld();
targetingData.Dir = accessor.GetFireDirectionWorld();
targetingData.FullDistance = verticalSectorsTargeting.WorkDistance;
targetingData.MaxAngle = (verticalSectorsTargeting.VAngleUp <= verticalSectorsTargeting.VAngleDown) ? verticalSectorsTargeting.VAngleDown : verticalSectorsTargeting.VAngleUp;
LinkedList <TargetSector> instance = BattleCache.targetSectors.GetInstance();
instance.Clear();
CollectTargetSectorsEvent eventInstance = BattleCache.collectTargetSectorsEvent.GetInstance().Init();
eventInstance.TargetSectors = instance;
TargetingCone cone = new TargetingCone {
VAngleUp = verticalSectorsTargeting.VAngleUp,
VAngleDown = verticalSectorsTargeting.VAngleDown,
HAngle = verticalSectorsTargeting.HAngle,
Distance = verticalSectorsTargeting.WorkDistance
};
eventInstance.TargetingCone = cone;
base.ScheduleEvent(eventInstance, weapon);
CollectSectorDirectionsEvent event3 = BattleCache.collectSectorDirectionsEvent.GetInstance().Init();
event3.TargetSectors = instance;
event3.TargetingData = targetingData;
base.ScheduleEvent(event3, weapon);
base.ScheduleEvent(BattleCache.collectTargetsEvent.GetInstance().Init(targetingData), weapon);
base.ScheduleEvent(BattleCache.targetEvaluateEvent.GetInstance().Init(targetingData), weapon);
}
// 리미트 거리가 있는 것.
public bool canPlayerHeroTargetingType2(Monster p, bool checkTargetOnly, TargetingDecal decal)
{
//데미지 범위. exeData.attr[1];
_target = TargetingData.getAutomaticTarget(p, targetType, targetAttr, canUseThisSkillOnThisType);
if (_target == null)
{
return(false);
}
//단순히 현재 상태에서 검사!
if (VectorUtil.DistanceXZ(_target.cTransformPosition, p.cTransformPosition) < _targetDistanceLimit)
{
if (checkTargetOnly == false)
{
p.setSkillTarget(_target);
p.targetHeight = _target.hitObject.height;
p.targetPosition = _target.cTransformPosition;
p.targetUniqueId = _target.stat.uniqueId;
}
_v = _target.cTransformPosition;
_v.y = 1.0f;
decal.setPosition(_v);
_target = null;
return(true);
}
_target = null;
return(false);
}
// 리미트 거리가 있는 것.
public bool canMonsterHeroTargetingType2(Monster attacker, int targetIndex = -1)
{
//데미지 범위. exeData.attr[1];
_target = TargetingData.getAutomaticTarget(attacker, targetType, targetAttr, canUseThisSkillOnThisType);
if (_target == null)
{
return(false);
}
// 타겟이 같은 편일때는 그냥 움직여서 쏘면 되니까 상관 없음.
// 근데 타겟이 다른 편일때는 전방 거리까지 움직여서 쏠 수 있는지 확인을 해야할 것.
if (_target.isPlayerSide) // 적히어로몬스터가 우리편에게 쏘는거면...
{
if (GameManager.me.characterManager.targetZonePlayerLine - _target.cTransformPosition.x > _targetDistanceLimit)
{
_target = null;
return(false);
}
}
attacker.setSkillTarget(_target);
attacker.skillTargetChecker = ctAutoByTargetDistance;
attacker.skillMove = ctMoveAuto;
_target = null;
return(true);
}
public static TargetingData getTargetingData(int type, params object[] args)
{
int len = 0;
switch (type)
{
case FIXED_1:
len = 2;
break;
case AUTOMATIC_2:
len = 1;
break;
}
TargetingData td = new TargetingData();
td.attr = new int[len];
for (int i = 0; i < len; ++i)
{
Util.parseObject(args[i], out td.attr[i], true, 0);
}
return(td);
}
public void Targeting(UnitSelectTargetEvent evt, UnitTargetingNode unit, [JoinSelf] Optional <SingleNode <UnitTargetComponent> > unitTargetNode)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
TargetingEvent eventInstance = BattleCache.targetingEvent.GetInstance().Init(targetingData);
base.ScheduleEvent(eventInstance, unit);
if ((targetingData.BestDirection != null) && targetingData.BestDirection.HasTargetHit())
{
Entity targetEntity = targetingData.BestDirection.Targets[0].TargetEntity;
Entity targetIncorantionEntity = targetingData.BestDirection.Targets[0].TargetIncorantionEntity;
if (targetEntity.HasComponent <EnemyComponent>())
{
if (unitTargetNode.IsPresent())
{
if (unitTargetNode.Get().component.Target.Equals(targetEntity))
{
return;
}
unit.Entity.RemoveComponent <UnitTargetComponent>();
}
UnitTargetComponent component = new UnitTargetComponent {
Target = targetEntity,
TargetIncarnation = targetIncorantionEntity
};
unit.Entity.AddComponent(component);
}
}
}
public void Collect(TargetValidator validator, TargetingData targetingData, int layerMask = 0)
{
foreach (DirectionData data in targetingData.Directions)
{
this.Collect(validator, targetingData.FullDistance, data, layerMask);
}
}
private bool IsTargetVisable(SelfDroneWeapon droneWeapon)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
TargetingEvent eventInstance = BattleCache.targetingEvent.GetInstance().Init(targetingData);
base.ScheduleEvent(eventInstance, droneWeapon);
if (targetingData.HasTargetHit())
{
using (List <DirectionData> .Enumerator enumerator = targetingData.Directions.GetEnumerator())
{
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
DirectionData current = enumerator.Current;
if (current.HasTargetHit() && current.Targets[0].ValidTarget)
{
return(true);
}
}
}
}
return(false);
}
public MacroManager(MacroSetup macroSetup, ActiveUnitData activeUnitData, SharkyUnitData sharkyUnitData, IBuildingBuilder buildingBuilder, SharkyOptions sharkyOptions, BaseData baseData, TargetingData targetingData, AttackData attackData, IBuildingPlacement warpInPlacement, MacroData macroData, Morpher morpher, BuildOptions buildOptions,
BuildPylonService buildPylonService, BuildDefenseService buildDefenseService, BuildProxyService buildProxyService, UnitCountService unitCountService, BuildingCancelService buildingCancelService)
{
MacroSetup = macroSetup;
ActiveUnitData = activeUnitData;
SharkyUnitData = sharkyUnitData;
BuildingBuilder = buildingBuilder;
SharkyOptions = sharkyOptions;
BaseData = baseData;
TargetingData = targetingData;
AttackData = attackData;
WarpInPlacement = warpInPlacement;
MacroData = macroData;
Morpher = morpher;
BuildOptions = buildOptions;
BuildPylonService = buildPylonService;
BuildDefenseService = buildDefenseService;
BuildProxyService = buildProxyService;
UnitCountService = unitCountService;
BuildingCancelService = buildingCancelService;
MacroData.DesiredUpgrades = new Dictionary <Upgrades, bool>();
LastRunFrame = -10;
RunFrequency = 5;
}
public SupportAttackTask(AttackData attackData, TargetingData targetingData, ActiveUnitData activeUnitData, MicroTaskData microTaskData,
IMicroController microController,
DebugService debugService, ChatService chatService, TargetingService targetingService, DefenseService defenseService, DistractionSquadService distractionSquadService, EnemyCleanupService enemyCleanupService,
ArmySplitter armySplitter,
List <UnitTypes> mainAttackerTypes,
float priority, bool enabled = true)
{
AttackData = attackData;
TargetingData = targetingData;
ActiveUnitData = activeUnitData;
MicroTaskData = microTaskData;
MicroController = microController;
DebugService = debugService;
ChatService = chatService;
TargetingService = targetingService;
DefenseService = defenseService;
DistractionSquadService = distractionSquadService;
EnemyCleanupService = enemyCleanupService;
ArmySplitter = armySplitter;
MainAttackers = mainAttackerTypes;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
public TargetingService(ActiveUnitData activeUnitData, MapDataService mapDataService, BaseData baseData, TargetingData targetingData)
{
ActiveUnitData = activeUnitData;
MapDataService = mapDataService;
BaseData = baseData;
TargetingData = targetingData;
}
public BuildingBuilder(ActiveUnitData activeUnitData, TargetingData targetingData, IBuildingPlacement buildingPlacement, SharkyUnitData sharkyUnitData, BaseData baseData)
{
ActiveUnitData = activeUnitData;
TargetingData = targetingData;
BuildingPlacement = buildingPlacement;
SharkyUnitData = sharkyUnitData;
BaseData = baseData;
}
public void PrepareTargetsByUnblockedWeapon(ShotPrepareEvent evt, UnblockedWeaponNode weaponNode)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
base.ScheduleEvent(new TargetingEvent(targetingData), weaponNode);
base.ScheduleEvent(new SendShotToServerEvent(targetingData), weaponNode);
base.ScheduleEvent(new SendHitToServerIfNeedEvent(targetingData), weaponNode);
}
private void PrepareQuickShotTargets(Entity weapon)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
base.ScheduleEvent(new TargetingEvent(targetingData), weapon);
base.ScheduleEvent(new SendShotToServerEvent(targetingData), weapon);
base.ScheduleEvent(new SendHitToServerEvent(targetingData), weapon);
}
public ProxyLocationService(BaseData baseData, TargetingData targetingData, IPathFinder pathFinder, MapDataService mapDataService, AreaService areaService)
{
BaseData = baseData;
TargetingData = targetingData;
PathFinder = pathFinder;
MapDataService = mapDataService;
AreaService = areaService;
}
public void Check(UpdateEvent e, CheckingNode weapon)
{
if (weapon.Entity.HasComponent <StreamHitComponent>() || ((weapon.streamHitChecking.LastCheckTime + weapon.streamHitConfig.LocalCheckPeriod) <= UnityTime.time))
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
base.ScheduleEvent(new TargetingEvent(targetingData), weapon.Entity);
base.ScheduleEvent(new StreamHitResultEvent(targetingData), weapon.Entity);
}
}
public HallucinationScoutTask(TargetingData targetingData, BaseData baseData, bool enabled, float priority)
{
TargetingData = targetingData;
BaseData = baseData;
Priority = priority;
UnitCommanders = new List <UnitCommander>();
Enabled = enabled;
}
public WallOffPlacement(ActiveUnitData activeUnitData, SharkyUnitData sharkyUnitData, DebugService debugService, MapData mapData, BuildingService buildingService, TargetingData targetingData)
{
ActiveUnitData = activeUnitData;
SharkyUnitData = sharkyUnitData;
DebugService = debugService;
MapData = mapData;
BuildingService = buildingService;
TargetingData = targetingData;
}
public Proxy(EnemyStrategyHistory enemyStrategyHistory, ChatService chatService, ActiveUnitData activeUnitData, SharkyOptions sharkyOptions, TargetingData targetingData, DebugService debugService, UnitCountService unitCountService)
{
EnemyStrategyHistory = enemyStrategyHistory;
ChatService = chatService;
ActiveUnitData = activeUnitData;
SharkyOptions = sharkyOptions;
TargetingData = targetingData;
DebugService = debugService;
UnitCountService = unitCountService;
}
public void FillTargetingData(ShaftAimingStraightTargetingEvent evt, ShaftAimingStraightTargetingNode weapon)
{
TargetingData targetingData = evt.TargetingData;
targetingData.Origin = new MuzzleLogicAccessor(weapon.muzzlePoint, weapon.weaponInstance).GetBarrelOriginWorld();
targetingData.Dir = evt.WorkingDirection;
targetingData.FullDistance = weapon.verticalSectorsTargeting.WorkDistance;
base.ScheduleEvent(new ShaftAimingCollectDirectionEvent(targetingData), weapon);
base.ScheduleEvent(new ShaftAimingCollectTargetsEvent(targetingData), weapon);
}
public ReaperWorkerHarassTask(BaseData baseData, TargetingData targetingData, IIndividualMicroController microController, int desiredCount = 2, bool enabled = false, float priority = -1f)
{
BaseData = baseData;
TargetingData = targetingData;
MicroController = microController;
DesiredCount = desiredCount;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
// TODO: if 5 dts have died, end the task
public DarkTemplarHarassTask(BaseData baseData, TargetingData targetingData, MapDataService mapDataService, DarkTemplarMicroController darkTemplarMicroController, int desiredCount = 5, bool enabled = true, float priority = -1f)
{
BaseData = baseData;
TargetingData = targetingData;
MapDataService = mapDataService;
DarkTemplarMicroController = darkTemplarMicroController;
DesiredCount = desiredCount;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
public MyBansheeHarassTask(BaseData baseManager, TargetingData targetingData, MapDataService mapDataService, MyBansheeMicroController bansheeController, int desiredCount = 1, bool enabled = true, float priority = -1f)
{
BaseData = baseManager;
TargetingData = targetingData;
MapDataService = mapDataService;
BansheeMicroController = bansheeController;
DesiredCount = desiredCount;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
public LateGameOracleHarassTask(BaseData baseData, TargetingData targetingData, MapDataService mapDataService, OracleMicroController oracleMicroController, int desiredCount = 2, bool enabled = true, float priority = -1f)
{
BaseData = baseData;
TargetingData = targetingData;
MapDataService = mapDataService;
OracleMicroController = oracleMicroController;
DesiredCount = desiredCount;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
public FindHiddenBaseTask(BaseData baseData, TargetingData targetingData, MapDataService mapDataService, IIndividualMicroController individualMicroController, int desiredCount = 15, bool enabled = true, float priority = -1f)
{
BaseData = baseData;
TargetingData = targetingData;
MapDataService = mapDataService;
IndividualMicroController = individualMicroController;
DesiredCount = desiredCount;
Priority = priority;
Enabled = enabled;
UnitCommanders = new List <UnitCommander>();
}
public BuildPylonService(MacroData macroData, IBuildingBuilder buildingBuilder, SharkyUnitData sharkyUnitData, ActiveUnitData activeUnitData, BaseData baseData, TargetingData targetingData, BuildingService buildingService)
{
MacroData = macroData;
BuildingBuilder = buildingBuilder;
SharkyUnitData = sharkyUnitData;
ActiveUnitData = activeUnitData;
BaseData = baseData;
TargetingData = targetingData;
BuildingService = buildingService;
defensivePointLastFailFrame = 0;
}
public void PrepareTargetsAtFirstFrame(NodeAddedEvent e, BulletNode bulletNode, [JoinByTank] WeaponNode weaponNode)
{
MuzzleLogicAccessor accessor = new MuzzleLogicAccessor(weaponNode.muzzlePoint, weaponNode.weaponInstance);
Vector3 barrelOriginWorld = accessor.GetBarrelOriginWorld();
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
targetingData.Origin = barrelOriginWorld;
targetingData.Dir = bulletNode.bullet.Direction;
targetingData.FullDistance = (accessor.GetWorldPosition() - barrelOriginWorld).magnitude * 1.2f;
base.ScheduleEvent(BattleCache.targetingEvent.GetInstance().Init(targetingData), bulletNode);
base.ScheduleEvent(BattleCache.updateBulletEvent.GetInstance().Init(targetingData), bulletNode);
}
private void PrepareAimingTargets(Entity weapon, Vector3 workingDir)
{
TargetingData targetingData = BattleCache.targetingData.GetInstance().Init();
ShaftAimingStraightTargetingEvent eventInstance = new ShaftAimingStraightTargetingEvent {
TargetingData = targetingData,
WorkingDirection = workingDir
};
base.ScheduleEvent(eventInstance, weapon);
base.ScheduleEvent(new SendShotToServerEvent(targetingData), weapon);
base.ScheduleEvent(new SendShaftAimingHitToServerEvent(targetingData), weapon);
}
