public IEnumerator PlaySkillRoutine(BattleUnit actor, Result <bool> executeResult)
{
actor.battle.Log(actor + " casts " + skillName + "...", true);
Targeter targeter = Object.Instantiate(data.targeter);
Effector effect = Object.Instantiate(data.effect);
effect.actor = actor;
targeter.actor = actor;
effect.skill = this;
targeter.skill = this;
yield return(targeter.ExecuteRoutine(effect, executeResult));
if (!executeResult.canceled)
{
if (costMP > 0)
{
actor.unit.stats.Sub(StatTag.MP, costMP);
}
if (costCD > 0)
{
actor.unit.stats.Add(StatTag.CD, costCD);
actor.maxCD = costCD;
}
}
}
public void AddToRange(int Range, Targeter targeter)
{
switch (Range)
{
case LONG_RANGE:
if (!LongRangeTargeters.Contains(targeter))
{
LongRangeTargeters.Add(targeter);
}
break;
case MID_RANGE:
if (!MidRangeTargeters.Contains(targeter))
{
MidRangeTargeters.Add(targeter);
}
break;
case CLOSE_RANGE:
if (!CloseRangeTargeters.Contains(targeter))
{
CloseRangeTargeters.Add(targeter);
}
break;
}
}
public override void ProcessInput(Event ev)
{
Action <LocalTargetInfo> actionToInput = delegate(LocalTargetInfo x)
{
this.action(x.Thing);
};
if (this.CurActivateSound != null)
{
this.CurActivateSound.PlayOneShotOnCamera();
}
SoundDefOf.TickTiny.PlayOneShotOnCamera();
Targeter targeter = Find.Targeter;
if (this.verb.CasterIsPawn && targeter.targetingVerb != null && targeter.targetingVerb.verbProps == this.verb.verbProps)
{
Pawn casterPawn = this.verb.CasterPawn;
if (!targeter.IsPawnTargeting(casterPawn))
{
targeter.targetingVerbAdditionalPawns.Add(casterPawn);
}
}
else
{
Find.Targeter.BeginTargeting(this.verb);
//AccessTools.Field(typeof(Targeter), "action").SetValue(Find.Targeter, new Action<LocalTargetInfo>((LocalTargetInfo x) =>
//this.action(x.Thing)));
}
}
private void Awake()
{
targeter = GetComponent <Targeter>();
targetRotation = GetComponent <TargetRotation>();
enemyMovement = GetComponent <EnemyMovement>();
rb = GetComponent <Rigidbody2D>();
}
// Use this for initialization
void Start()
{
enManager = GameObject.Find("EnemyManager").GetComponent <EnemyManager>();
towersTargeter = GameObject.Find("Targeter").GetComponent <Targeter>();
rb = GetComponent <Rigidbody>();
wayPointList = enManager.GetWayPoints();
}
void Start()
{
_agent = GetComponent <NavMeshAgent>();
stats = GetComponent <CharacterStats>();
_animator = GetComponentInChildren <Animator>();
targeter = GetComponent <Targeter>();
}
public virtual void ProcessInput(Event ev)
{
base.ProcessInput(ev);
if (this.multiVerb == null)
{
return;
}
this.multiVerb.currentVerbIndex = this.index;
Targeter targeter = Find.get_Targeter();
if (targeter.get_IsTargeting())
{
if (this.verb.get_CasterIsPawn() && targeter.targetingVerb != null && ((Verb)targeter.targetingVerb).verbProps == this.verb.verbProps)
{
Pawn casterPawn = this.verb.get_CasterPawn();
if (!targeter.IsPawnTargeting(casterPawn))
{
((List <Pawn>)targeter.targetingVerbAdditionalPawns).Add(casterPawn);
}
}
else
{
List <Pawn> pawnList = new List <Pawn>((IEnumerable <Pawn>)targeter.targetingVerbAdditionalPawns);
targeter.BeginTargeting(this.verb);
((List <Pawn>)targeter.targetingVerbAdditionalPawns).AddRange((IEnumerable <Pawn>)pawnList);
}
}
Log.Message(this.defaultLabel.ToString() + "; index=" + (object)this.index, false);
}
private static void Targeter_TargeterUpdatePostfix(Targeter __instance)
{
if (__instance.targetingVerb != null && __instance.targetingVerb.verbProps is VEF_VerbProperties_Explode verbPropsExplode)
{
verbPropsExplode.DrawExplodeRadiusRing(__instance.targetingVerb.caster.Position);
}
}
public void ApplyTo(Targeter targeter, float accuracy)
{
foreach (var(effect, targetType) in effects)
{
effect.ApplyTo(targeter[targetType], accuracy);
}
}
private void Awake()
{
TargetLocator = GameObject.FindObjectOfType <Targeter>();
Blast = Instantiate(Spell);
MyProjectile = Blast.GetComponent <Projectile>();
MyProjectile.ResetPosition();
}
// Token: 0x06000046 RID: 70 RVA: 0x00003300 File Offset: 0x00001500
public override void ProcessInput(Event ev)
{
base.ProcessInput(ev);
bool flag = this.multiVerb != null;
if (flag)
{
this.multiVerb.currentVerbIndex = this.index;
Targeter targeter = Find.Targeter;
bool isTargeting = targeter.IsTargeting;
if (isTargeting)
{
bool flag2 = this.verb.CasterIsPawn && targeter.targetingSource != null && targeter.targetingSource == this.verb.verbProps;
if (flag2)
{
Pawn casterPawn = this.verb.CasterPawn;
bool flag3 = !targeter.IsPawnTargeting(casterPawn);
if (flag3)
{
targeter.targetingSourceAdditionalPawns.Add(casterPawn);
}
}
else
{
List <Pawn> collection = new List <Pawn>(targeter.targetingSourceAdditionalPawns);
targeter.BeginTargeting(this.verb);
targeter.targetingSourceAdditionalPawns.AddRange(collection);
}
}
Log.Message(this.defaultLabel + "; index=" + this.index, false);
}
}
public static void Postfix(ref Targeter __instance)
{
if (!Main.Instance.IsModEnabled())
{
return;
}
Main.Instance.UpdateFireConeOverlay(false);
if (__instance.targetingVerb == null)
{
return;
}
if (__instance.targetingVerb.verbProps.IsMeleeAttack)
{
return;
}
bool dummy;
if (__instance.targetingVerb.HighlightFieldRadiusAroundTarget(out dummy) > 0.2f)
{
return;
}
Main.Instance.UpdateFireConeOverlay(true);
}
public static void Postfix(ref Targeter __instance)
{
if (!Main.Instance.IsModEnabled())
{
return;
}
Main.Instance.UpdateFireConeOverlay(false);
if (__instance.targetingSource == null)
{
return;
}
if (__instance.targetingSource.IsMeleeAttack)
{
return;
}
if (!(__instance.targetingSource is Verb verb))
{
return;
}
if (verb.HighlightFieldRadiusAroundTarget(out _) > 0.2f)
{
return;
}
Main.Instance.UpdateFireConeOverlay(true);
}
public override void enter(CombatManager mgr)
{
Ability a = Unit.current.currentAbility;
targeter = a.Targeter(Unit.current.currentTile.coords, Unit.current);
targeter.FindSelectable();
FieldMap.current.showSelectable();
}
private void Awake()
{
thingsToAvoid = new List <string>();
avoidList = new List <Avoider>();
avoidVector = Vector3.zero;
targeter = transform.root.GetComponent <Targeter>();
hasTargeter = targeter != null;
}
/*
*
* public void OnEnable() {
* if (mainInput == null) {
* mainInput = new MainInput();
* // Tell the "gameplay" action map that we want to get told about
* // when actions get triggered.
* mainInput.Player.SetCallbacks(this);
* }
* mainInput.Player.Enable();
* }
*
*
*/
private void Awake()
{
Debug.Assert(_charController != null, $"CharController not assigned in playerController {name}");
if (_targeter == null)
{
_targeter = GetComponentInChildren <Targeter>();
}
}
public bool ChoseWorldTarget(GlobalTargetInfo target)
{
if (!target.IsValid)
{
Messages.Message("SWeaponTargetInvalid".Translate(), MessageTypeDefOf.RejectInput, true);
return(false);
}
/*
* int num = Find.WorldGrid.TraversalDistanceBetween(base.Map.Tile, target.Tile, true, int.MaxValue);
* if (this.MaxLaunchDistance < 200 && num > this.MaxLaunchDistance)
* {
* Messages.Message("MissileRangeBad".Translate(), MessageTypeDefOf.RejectInput, true);
* return false;
* }
*/
MapParent mapParent = target.WorldObject as MapParent;
if (mapParent != null && mapParent.HasMap)
{
Map map = mapParent.Map;
Current.Game.CurrentMap = map;
Targeter targeter = Find.Targeter;
Action actionWhenFinished = delegate
{
if (Find.Maps.Contains(base.Map))
{
Current.Game.CurrentMap = base.Map;
}
};
/*
* int range = 0;
* switch (getType()) {
* case SuperWeaponType.Soviet:range = 56;break;
* case SuperWeaponType.Allied: range = 30; break;
* default:range=10;break;
* }
*/
Texture2D ic = ContentFinder <Texture2D> .Get("ra2/World/ra2_SuperWeaponIcon_" + getType());
TargetingParameters tg = new TargetingParameters();
tg.canTargetLocations = true;
tg.canTargetItems = true;
tg.canTargetBuildings = true;
tg.canTargetPawns = true;
tg.canTargetFires = true;
targeter.BeginTargeting(tg, delegate(LocalTargetInfo x)
{
//GenDraw.DrawRadiusRing(UI.MouseCell(), range);
this.TryLaunch(x.ToGlobalTargetInfo(map));
}, null, actionWhenFinished, ic);
return(true);
}
this.TryLaunch(target);
return(true);
}
public IEnumerator <bool> Init()
{
cannonSettings = new INISerializer("CannonSettings");
cannonSettings.AddValue("referenceName", x => x, "RCReference");
cannonSettings.AddValue("speedCap", x => double.Parse(x), 104.38);
cannonSettings.AddValue("launchVelocity", x => double.Parse(x), 100.0);
cannonSettings.AddValue("sourceRotorTName", x => x, "[OrbitalCannonBase]_[Azimuth]");
cannonSettings.AddValue("elevationTag", x => x, "[Elevation]");
cannonSettings.AddValue("timerName", x => x, "CannonTimer");
if (Me.CustomData == "")
{
string temp = Me.CustomData;
cannonSettings.FirstSerialization(ref temp);
Me.CustomData = temp;
}
else
{
cannonSettings.DeSerialize(Me.CustomData);
}
yield return(true);
ingameTime = new IngameTime();
GTSUtils = new GridTerminalSystemUtils(Me, GridTerminalSystem);
yield return(true);
IMyShipController reference = GridTerminalSystem.GetBlockWithName((string)cannonSettings.GetValue("referenceName")) as IMyShipController;
IMyMotorStator sourceRotor = GridTerminalSystem.GetBlockWithName((string)cannonSettings.GetValue("sourceRotorTName")) as IMyMotorStator;
IMyTimerBlock timer = GridTerminalSystem.GetBlockWithName((string)cannonSettings.GetValue("timerName")) as IMyTimerBlock;
Echo($"Getting blocks status:...\nreference: {reference != null}\nsourceRotor: {sourceRotor != null}");
if (reference == null || sourceRotor == null)
{
throw new Exception("cant get blocks!");
}
yield return(true);
targeter = new Targeter
(
(double)cannonSettings.GetValue("speedCap"),
(double)cannonSettings.GetValue("launchVelocity"),
reference
);
targeter.directionFoundCallback += TargetCalculatedCallback;
yield return(true);
cannon = Cannon.CreateCannon(sourceRotor, GTSUtils, ingameTime, reference, (string)cannonSettings.GetValue("sourceRotorTName"), (string)cannonSettings.GetValue("elevationTag"));
cannon.Timer = timer;
yield return(true);
Echo("Initialized!");
initialized = true;
}
// Update is called once per frame
void Update()
{
if (!isIdle)
{
Targeter targeter = GetComponent <Targeter>();
targeter.FindTarget();
GetComponent <AimMode>().AimAt(targeter.GetTargetTransform());
}
}
protected virtual void Awake()
{
Targeter = GetComponent <Targeter>();
if (Targeter == null)
{
Debug.LogError("Gun needs a Targeter component to work properly", this);
}
}
public override void Tick(float deltaTime)
{
base.Tick(deltaTime);
if (Targeter != null && Targeter.GetDistance() < FireTreshold)
{
Weapon.Target = Provider?.GetTarget();
TryFire();
}
}
private void Awake()
{
targeter = GetComponent <Targeter>();
if (!rotateTransform)
{
rotateTransform = transform;
}
}
public SteeringAlgorithm(Targeter tag)
{
this.targeter = tag;
maxConstraintSteps = 10.0f; //alterar dps consoante
validPath = false;
goal = new Goal();
smoothpath = new GlobalPath();
this.goal.updateChannels(targeter.getGoal());
}
public List <ICommand> FindMoves(BoardState boardState)
{
List <ICommand> moves = new List <ICommand>();
Unit unit = Unit.current;
List <HexCoords> movement = Unit.current.moveTargeter.FindSelectable();
HexCoords nearestUnit = boardState.NearestUnit(unit.currentTile.coords);
switch (_type)
{
case AIMove.SHORT_RANGE:
{
List <HexCoords> inRange = Targeter.TilesAt(Map.current.TileAt(nearestUnit).node, unit.MinRange());
foreach (HexCoords coords in inRange)
{
if (movement.Contains(coords))
{
moves.Add(new MoveCommand(unit, unit.currentTile.coords, coords));
}
}
break;
}
case AIMove.LONG_RANGE:
{
List <HexCoords> inRange = Targeter.TilesAt(Map.current.TileAt(nearestUnit).node, unit.MaxRange());
Debug.Log(inRange.Count);
foreach (HexCoords coords in inRange)
{
if (movement.Contains(coords))
{
moves.Add(new MoveCommand(unit, unit.currentTile.coords, coords));
}
}
break;
}
default:
break;
}
if (moves.Count == 0)
{
HexCoords nearest = unit.currentTile.coords;
int dist = (nearestUnit - nearest).radius();
foreach (HexCoords coords in movement)
{
int d = (nearestUnit - coords).radius();
if (d < dist)
{
dist = d;
nearest = coords;
}
}
moves.Add(new MoveCommand(unit, unit.currentTile.coords, nearest));
}
return(moves);
}
private void Start()
{
_targeter = GetComponent <Targeter>();
_navMeshAgent = GetComponent <NavMeshAgent>();
if (isServer)
{
SetDest(NavArea.GetNextPoint());
InvokeRepeating("Navigate", 0, 0.1f);
}
}
public override void OnInspectorGUI()
{
Targeter targeter = target as Targeter;
Limiter limits = targeter.GetComponent <Limiter>();
m_switchIfInvalid.Enabled = (limits != null) && limits.enabled;
m_editHelp.EditProperties(targeter);
}
// Use this for initialization
void Start()
{
moveHandler = GetComponent <MoveHandler>();
moveHandler.GenericStateEvent += StopTargeting;
targeter = GetComponent <Targeter>();
hasTargeter = (targeter != null);
attatchedEffects = new List <VisualEffects.IVisualEffect>();
}
private bool ChoseWorldTarget(GlobalTargetInfo target)
{
bool result;
if (!this.ReadyToTransport)
{
result = true;
}
else if (!target.IsValid)
{
Messages.Message("MessageTransportPodsDestinationIsInvalid".Translate(), MessageTypeDefOf.RejectInput);
result = false;
}
else
{
MapParent mapParent = target.WorldObject as MapParent;
if (mapParent != null && mapParent.HasMap)
{
Map myMap = this.parent.Map;
Map map = mapParent.Map;
Current.Game.CurrentMap = map;
Targeter targeter = Find.Targeter;
Action actionWhenFinished = delegate()
{
if (Find.Maps.Contains(myMap))
{
Current.Game.CurrentMap = myMap;
}
};
TargetingParameters targetParams = new TargetingParameters
{
canTargetPawns = true,
canTargetItems = false,
canTargetSelf = false,
canTargetLocations = false,
canTargetBuildings = false,
canTargetFires = false
};
targeter.BeginTargeting(targetParams, delegate(LocalTargetInfo x)
{
if (this.ReadyToTransport)
{
this.TryTransport(x.ToGlobalTargetInfo(map));
}
}, null, actionWhenFinished, CompTeleporter.TargeterMouseAttachment);
result = true;
}
else
{
Messages.Message("RD_YouCannotLock".Translate(), MessageTypeDefOf.RejectInput); //"You cannot lock onto anything there."
result = false;
}
}
return(result);
}
public static Actor Build(Characters cardChoice, short cardId)
{
// gathering character information
var associations = CharacterLegend[cardChoice];
var originStats = OriginStats[associations.origin];
var classStats = ClassStats[associations.@class];
var rarityStats = RarityStats[associations.rarity];
Attribute health = new Attribute();
Attribute defense = new Attribute();
Attribute attack = new Attribute();
Attribute speed = new Attribute();
Attribute precision = new Attribute();
Attribute manaCost = new Attribute();
// attaching stats
string name = associations.name;
string origin = originStats.origin;
string @class = classStats.@class;
string rarity = rarityStats.rarity;
health.BaseValue = (short)(originStats.health + classStats.health + rarityStats.health);
health.CurrentValue = (short)(originStats.health + classStats.health + rarityStats.health);
defense.BaseValue = (short)(originStats.defense + classStats.defense + rarityStats.defense);
defense.CurrentValue = (short)(originStats.defense + classStats.defense + rarityStats.defense);
attack.BaseValue = (short)(originStats.attack + classStats.attack + rarityStats.attack);
attack.CurrentValue = (short)(originStats.attack + classStats.attack + rarityStats.attack);
speed.BaseValue = (short)(originStats.speed + classStats.speed + rarityStats.speed);
speed.CurrentValue = (short)(originStats.speed + classStats.speed + rarityStats.speed);
precision.BaseValue = (short)(originStats.precision + classStats.precision + rarityStats.precision);
precision.CurrentValue = (short)(originStats.precision + classStats.precision + rarityStats.precision);
manaCost.BaseValue = rarityStats.manaCost;
manaCost.CurrentValue = rarityStats.manaCost;
short characterId = (short)cardChoice;
// attaching effects
List <Effect> actorEffects = new List <Effect>();
var characterEffectDetailsList = CharacterEffects[cardChoice];
foreach (var effectDetailsReference in characterEffectDetailsList)
{
var effectDetails = Effects[effectDetailsReference];
Targeter targeter = effectDetails.targeter;
AppliedEffect appliedEffect = effectDetails.appliedEffect;
string animation = effectDetails.animation;
Effect effect = new Effect(targeter, appliedEffect, animation);
actorEffects.Add(effect);
}
Effect[] effectArray = actorEffects.ToArray();
ActorAction2 actorAction = new ActorAction2(effectArray);
Actor actor = new Actor(cardId, origin, @class, name, health, defense, attack, speed, precision, manaCost, rarity, actorAction, characterId);
return(actor);
}
public Task <Turn> PlayTurn(PlayTurnRequest request)
{
var avoidCombat = false;
return(Strategic());
Task <Turn> Strategic()
{
return(request.IsCombat ? StrategicCombat() : StrategicNonCombat());
}
Task <Turn> StrategicCombat()
{
if (!request.IsCombat)
{
return(Task.FromResult(new Turn(TurnAction.Attack)));
}
if (HealthChecker.NeedsToChug(request.PartyMember) && request.PossibleActions.Contains(TurnAction.DrinkPotion))
{
return(Task.FromResult(new Turn(TurnAction.DrinkPotion)));
}
return(Task.FromResult(new Turn(TurnAction.Attack, Targeter.GetPriorityTarget(request.PossibleTargets))));
}
Task <Turn> StrategicNonCombat()
{
if (request.PossibleActions.Contains(TurnAction.Attack) && _random.NextDouble() > 0.5)
{
return(StrategicCombat());
}
var movements = MovementTracker.GetMovementActions();
if (request.PossibleActions.Contains(TurnAction.Loot))
{
return(Task.FromResult(new Turn(TurnAction.Loot)));
}
if (request.PossibleActions.Contains(TurnAction.Open))
{
return(Task.FromResult(new Turn(TurnAction.Open)));
}
var movementoptions =
request.PossibleActions.Where(s => movements.Contains(s));
var direction = movetracker.GetNextDirection(movementoptions.ToList(), request.PartyLocation);
Debug.WriteLine(direction);
return(Task.FromResult(new Turn(direction)));
}
}
protected virtual void Start()
{
moveHandler = GetComponent <MoveHandler>();
targeter = GetComponent <Targeter>();
entityController = GetComponent <EntityControllerComp>();
hasEntityController = (entityController != null);
flagHandler = GetComponent <FlagHandler>();
avoider = GetComponentInChildren <Avoider>();
hasAvoider = (avoider != null);
linksToAttempt = new List <MoveLink>();
}
// Use this for initialization
private void Awake()
{
this.draw = true;
NavMeshPathGraph navMesh = NavigationManager.Instance.NavMeshGraphs[0];
this.character = new DynamicCharacter(this.characterAvatar);
this.Pedestrians = new List<GameObject>(GameObject.FindGameObjectsWithTag("Pedestrian")).ConvertAll(p => new Pedestrian(p));
// Targeter
TargeterComponent = new Targeter(this);
// Decomposer
DecomposerComponent = new Decomposer(this, navMesh, this.character);
// TargetCollisionConstraint
PathConstraints = new List<IConstraint>();
PathConstraints.Add(new PedestrianAvoidanceConstraint(this, character, this.Pedestrians));
PathConstraints.Add(new PathValidityCheckConstraint(this.character));
// Movement Constraints
MovementConstraints = new List<IConstraint>();
StaticObstacleConstraint obsConstraint = new StaticObstacleConstraint(character)
{
AvoidMargin = 10f
};
MovementConstraints.Add(obsConstraint);
if (CharacterInUse.Equals(CharacterType.Car))
{
Actuator = new CarActuator(this.character);
}
else if (CharacterInUse.Equals(CharacterType.Human))
{
Actuator = new HumanActuator(this.character);
}
}
// Update is called once per frame
void Update()
{
Vector3 position;
NavigationGraphNode node;
if (Input.GetMouseButtonDown(0))
{
//if there is a valid position
if (this.MouseClickPosition(out position))
{
//we're setting the end point
//this is just a small adjustment to better see the debug sphere
this.endDebugSphere.transform.position = position + Vector3.up;
this.endDebugSphere.SetActive(true);
//this.currentClickNumber = 1;
this.endPosition = position;
Targeter endGoal = new Targeter(position);
this.draw = true;
//initialize the search algorithm
this.decomposer.InitializeSearch(this.character.KinematicData.position, endGoal.getTarget());
}
}
//call the pathfinding method if the user specified a new goal
if (this.decomposer.searchAlgorithm.InProgress)
{
this.decomposer.Search(this.character.KinematicData);
this.currentSmoothedSolution = this.decomposer.getSmoothSolution();
constraint = new Constraint
{
character = this.character,
bots = this.bots
};
if(this.currentSmoothedSolution != null)
{
this.character.Movement = new Actuator()
{
character = this.character,
constraint = this.constraint,
maxConstraintSteps = 20,
currentSmoothedSolution = this.currentSmoothedSolution
};
}
}
this.character.Update();
}
public SteeringPipeline InitializeSteeringPipeline(DynamicCharacter orig, KinematicData dest)
{
//Pipeline
SteeringPipeline pipe = new SteeringPipeline(orig.KinematicData)
{
MaxAcceleration = 15.0f
};
//Targeter
Targeter MouseClickTargeter = new Targeter()
{
Target = dest
};
pipe.Targeters.Add(MouseClickTargeter);
//Decomposer
pathfindingDecomposer = new PathfindingDecomposer()
{
Graph = this.navMesh,
Heuristic = new EuclideanDistanceHeuristic()
};
pipe.Decomposers.Add(pathfindingDecomposer);
//Actuator - Default: Car behaviour
Actuator actuator = new CarActuator()
{
MaxAcceleration = 15.0f,
Character = orig.KinematicData
};
if (orig.GameObject.tag.Equals("Enemies"))
{
actuator = new TrollActuator()
{
MaxAcceleration = 10.0f,
Character = orig.KinematicData
};
}
pipe.Actuator = actuator;
//Constraints
foreach (DynamicCharacter troll in enemies)
{
TrollConstraint trollConstraint = new TrollConstraint()
{
Troll = troll,
margin = 1.0f
};
pipe.Constraints.Add(trollConstraint);
}
MapConstraint mapConstraint = new MapConstraint()
{
chars = character,
navMeshP = navMesh,
margin = 1.0f
};
pipe.Constraints.Add(mapConstraint);
return pipe;
}
