public AbilityData(AbilityDataJsonWrapper wrapper)
{
name = wrapper.name;
isCalm = wrapper.isCalm;
calmReq = wrapper.calmReq;
strifeReq = wrapper.strifeReq;
calmGen = wrapper.calmGen;
strifeGen = wrapper.strifeGen;
// Filter to find this ability's effects
effects = new List <EffectData>();
foreach (string effectName in wrapper.effectNames)
{
effects.Add(allEffects.Find(d => d.name.ToUpperInvariant() == effectName.ToUpperInvariant()));
}
// Filter to find this ability's auras
auras = new List <AuraData>();
foreach (string auraName in wrapper.auraNames)
{
auras.Add(allAuras.Find(d => d.name.ToUpperInvariant() == auraName.ToUpperInvariant()));
}
// Discern this ability's targeting mode
targetingMode = (wrapper.targetingMode.ToLowerInvariant()) switch
{
"single" => TargetingMode.SINGLE,
"party" => TargetingMode.PARTY,
"opposition" => TargetingMode.OPPOSITION,
_ => throw new System.Exception("Could not discern ability's targeting mode"),
};
}
public static Player GetTarget(TargetingMode targetingMode, float worldDistance)
{
var enemies = EntitiesManager.EnemyTeam;
var player = LocalPlayer.Instance;
var aliveEnemies = enemies.Where(e =>
!e.IsDead &&
e.Distance(LocalPlayer.Instance) <= worldDistance);
switch (targetingMode)
{
case TargetingMode.LowestHealth:
return(aliveEnemies.OrderBy(e => e.Health).FirstOrDefault(Helper.IsValidTarget));
case TargetingMode.NearLocalPlayer:
return(aliveEnemies.OrderBy(e => e.Distance(player.WorldPosition))
.FirstOrDefault(Helper.IsValidTarget));
case TargetingMode.NearMouse:
return(aliveEnemies.OrderBy(e => e.Distance(InputManager.MousePosition))
.FirstOrDefault(Helper.IsValidTarget));
default:
return(null);
}
}
public static void Targetlist(TargetingMode TMode)
{
int i1, i2;
Obj_AI_Hero Buf;
{
if (Targets.Count != ObjectManager.Get<Obj_AI_Hero>().Where(hero => hero.Team != ObjectManager.Player.Team).Count())
foreach (var enemy in ObjectManager.Get<Obj_AI_Hero>().Where(hero => hero.Team != ObjectManager.Player.Team))
{
Targets.Add(enemy);
}
for (i1 = 0; i1 < Targets.Count; i1++)
for (i2 = 0; i2 < Targets.Count; i2++)
if (FindPrioForTarget(Targets[i1], TMode) > FindPrioForTarget(Targets[i2], TMode))
{
Buf = Targets[i2];
Targets[i1] = Targets[i1];
Targets[i2] = Buf;
}
else if (FindPrioForTarget(Targets[i1], TMode) < FindPrioForTarget(Targets[i2], TMode))
{
Buf = Targets[i1];
Targets[i1] = Targets[i2];
Targets[i2] = Buf;
}
}
}
private static void Targetlist(TargetingMode TMode)
{
int i1, i2;
Obj_AI_Hero Buf;
{
if (Targets.Count != ObjectManager.Get <Obj_AI_Hero>().Where(hero => hero.Team != ObjectManager.Player.Team).Count())
{
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(hero => hero.Team != ObjectManager.Player.Team))
{
Targets.Add(enemy);
}
}
for (i1 = 0; i1 < Targets.Count; i1++)
{
for (i2 = 0; i2 < Targets.Count; i2++)
{
if (FindPrioForTarget(Targets[i1], TMode) > FindPrioForTarget(Targets[i2], TMode))
{
Buf = Targets[i2];
Targets[i1] = Targets[i1];
Targets[i2] = Buf;
}
else if (FindPrioForTarget(Targets[i1], TMode) < FindPrioForTarget(Targets[i2], TMode))
{
Buf = Targets[i1];
Targets[i1] = Targets[i2];
Targets[i2] = Buf;
}
}
}
}
}
public TargetSelector(float range, TargetingMode mode)
{
_range = range;
_mode = mode;
Game.OnGameUpdate += Game_OnGameUpdate;
Drawing.OnDraw += Drawing_OnDraw;
}
// ==
public WorstSelector(float range = 1135f, TargetingMode mode = TargetingMode.PRIORITY)
{
this.range = range;
this.mode = mode;
Game.OnGameUpdate += onGameUpdate;
Game.OnWndProc += onWndProc;
}
public TargetSelector(float range, TargetingMode mode)
{
_range = range;
_mode = mode;
Game.OnGameUpdate += Game_OnGameUpdate;
Drawing.OnDraw += Drawing_OnDraw;
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="old">AbilityData object being copied from.</param>
public AbilityData(AbilityData old)
{
name = old.name;
isCalm = old.isCalm;
calmReq = old.calmReq;
strifeReq = old.strifeReq;
calmGen = old.calmGen;
strifeGen = old.strifeGen;
effects = new List <EffectData>(old.effects);
auras = new List <AuraData>(old.auras);
targetingMode = old.targetingMode;
}
public Action PickupCard(CardButton card)
{
return () => {
if (Selected != null || TargetingMode != TargetingMode.Inactive) {
return;
}
TargetingMode = TargetingMode.Transitional;
Selected = card;
Selected.OnPickup();
ActiveCard = card.GetCard();
StartCoroutine(Select());
};
}
public void SwitchTargetingMode()
{
string[] targetingModes = Enum.GetNames(typeof(TargetingModes));
int currentIndex = targetingModes.IndexOf(TargetingMode.ToString());
if (currentIndex < targetingModes.Length - 1)
{
UpdateTargetingMode((TargetingModes)Enum.Parse(typeof(TargetingModes), targetingModes[currentIndex + 1]));
}
else
{
UpdateTargetingMode((TargetingModes)Enum.Parse(typeof(TargetingModes), targetingModes[0]));
}
}
private IEnumerator Reset()
{
yield return(new WaitForSeconds(0.2f));
if (isChoosingTarget)
{
isChoosingTarget = false;
}
if (selectionComplete)
{
selectionComplete = false;
}
targetingMode = TargetingMode.CombatTargeting;
}
/// <summary>
/// Shoot Method that uses the Coordinates that the AI saved as possible Coordinates of the Ship that got hit
/// </summary>
/// <returns>Coordinates of the shot that got chosen by the AI</returns>
public Coordinates ShootDeliberately( )
{
try
{
Coordinates shot;
if (this._shipCoordinates.Count == 0)
{
// Debug.WriteLine( "Ship coordinates missing" );
}
List <Coordinates> mostLikelyShotCoordinates = new List <Coordinates>( );
mostLikelyShotCoordinates = this._shipCoordinates.Where(w => (w.X == this._lastHit.X + 1 && w.Y == this._lastHit.Y) ||
(w.X == this._lastHit.X - 1 && w.Y == this._lastHit.Y) ||
(w.Y == this._lastHit.Y + 1 && w.X == this._lastHit.X) ||
(w.Y == this._lastHit.Y - 1 && w.X == this._lastHit.X)).ToList( );
int index;
if (mostLikelyShotCoordinates.Count == 0)
{
//Debug.WriteLine( "Using inital Shot" );
this._initialHit.PointOfAim = this._lastHit.PointOfAim;
this._lastHit = this._initialHit;
RemoveRedundantHeadings( );
mostLikelyShotCoordinates = this._shipCoordinates.Where(w => (w.X == this._initialHit.X + 1 && w.Y == this._lastHit.Y) ||
(w.X == this._initialHit.X - 1 && w.Y == this._initialHit.Y) ||
(w.Y == this._initialHit.Y + 1 && w.X == this._initialHit.X) ||
(w.Y == this._initialHit.Y - 1 && w.X == this._initialHit.X)).ToList( );
if (mostLikelyShotCoordinates.Count == 0)
{
//Debug.WriteLine( "Random Shot" );
this._shipCoordinates.Clear( );
Mode = TargetingMode.ByChance;
shot = ShootByChance( );
this._lastShot = shot;
return(shot);
}
}
index = this._rnd.Next(0, mostLikelyShotCoordinates.Count( ));
shot = mostLikelyShotCoordinates.ElementAt(index);
this._lastShot = shot;
return(shot);
}
catch (Exception)
{
throw;
}
}
private static double FindPrioForTarget(Obj_AI_Hero enemy, TargetingMode TMode)
{
switch (TMode)
{
case TargetingMode.AutoPriority:
{
if (p1.Contains(enemy.CharData.BaseSkinName))
{
return(4);
}
else if (p2.Contains(enemy.CharData.BaseSkinName))
{
return(3);
}
else if (p3.Contains(enemy.CharData.BaseSkinName))
{
return(2);
}
else if (p4.Contains(enemy.CharData.BaseSkinName))
{
return(1);
}
else
{
return(5);
}
}
case TargetingMode.FastKill:
{
if (enemy.IsValid && enemy != null && enemy.IsVisible && !enemy.IsDead)
{
return(enemy.Health / Player.GetSpellDamage(enemy, SpellSlot.E));
}
else
{
return(1000000);
}
}
default:
return(0);
}
}
private static double FindPrioForTarget(AIHeroClient enemy, TargetingMode TMode)
{
switch (TMode)
{
case TargetingMode.AutoPriority:
{
if (p1.Contains(enemy.BaseSkinName))
{
return(4);
}
else if (p2.Contains(enemy.BaseSkinName))
{
return(3);
}
else if (p3.Contains(enemy.BaseSkinName))
{
return(2);
}
else if (p4.Contains(enemy.BaseSkinName))
{
return(1);
}
else
{
return(5);
}
}
case TargetingMode.FastKill:
{
if (enemy.IsValid && enemy != null && enemy.IsVisible && !enemy.IsDead)
{
return(enemy.Health / Player.GetSpellDamage(enemy, XDSharp.Champions.Main.TSSpell()));
}
else
{
return(1000000);
}
}
default:
return(0);
}
}
// Monitors if the Targeting Mode has to be forced to change
private void MonitorTargetingMode( )
{
if (this._shipCoordinates.Count == 0 && Mode == TargetingMode.Deliberately)
{
//if ( this._removedShipCoordinates.Count != 0 )
//{
// Debug.WriteLine( "Monitor overrides '_shipCoordinates' " );
// this._shipCoordinates = this._removedShipCoordinates;
//}
//else
//{
// Debug.WriteLine( "Monitor forces By Chance Mode" );
this._shipCoordinates.Clear( );
Mode = TargetingMode.ByChance;
//}
}
else
{
Mode = TargetingMode.Deliberately;
}
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
//Version 0
if (version >= 0)
{
m_MultiID = reader.ReadInt();
m_Offset = reader.ReadPoint3D();
int coOwnerCount = reader.ReadInt();
for (int a = 0; a < coOwnerCount; a++)
{
m_CoOwners.Add(reader.ReadMobile());
}
int friendCount = reader.ReadInt();
for (int a = 0; a < friendCount; a++)
{
m_Friends.Add(reader.ReadMobile());
}
GuildAsFriends = reader.ReadBool();
HitPoints = reader.ReadInt();
SailPoints = reader.ReadInt();
GunPoints = reader.ReadInt();
m_Owner = reader.ReadMobile();
m_ShipName = reader.ReadString();
m_TargetingMode = (TargetingMode)reader.ReadInt();
m_TimeLastRepaired = reader.ReadDateTime();
m_NextTimeRepairable = reader.ReadDateTime();
}
}
private static void currentMode(object sender, OnValueChangeEventArgs e)
{
switch (e.GetNewValue <StringList>().SelectedIndex)
{
case 0:
default:
_Mode = TargetingMode.LowHP;
break;
case 1:
_Mode = TargetingMode.MostAD;
break;
case 2:
_Mode = TargetingMode.MostAP;
break;
case 3:
_Mode = TargetingMode.Closest;
break;
case 4:
_Mode = TargetingMode.NearMouse;
break;
case 5:
_Mode = TargetingMode.AutoPriority;
break;
case 6:
_Mode = TargetingMode.LessAttack;
break;
case 7:
_Mode = TargetingMode.LessCast;
break;
}
}
private void Update()
{
if (playerStat.lockControls)
{
return;
}
x = guiHud.joyStick.Horizontal;
y = guiHud.joyStick.Vertical;
//if (Input.GetKeyDown(KeyCode.Z)) StartCoroutine(Attack());
if (Input.GetKey(KeyCode.Z))
{
//print("pressed");
//playerStat.chargeStrength = 0;
playerStat.isCharging = true;
playerStat.shield = true;
}
if (Input.GetKeyUp(KeyCode.Z))
{
playerStat.isCharging = false;
playerStat.attack = true;
playerStat.shield = false;
_Attack();
}
if (Input.GetKeyDown(KeyCode.X))
{
if (target == TargetingMode.PLAYER)
{
target = TargetingMode.BOMB;
}
else if (target == TargetingMode.BOMB)
{
target = TargetingMode.PLAYER;
}
print(target);
}
}
public static Player GetAlly(TargetingMode targetingMode, float worldDistance)
{
var allies = EntitiesManager.LocalTeam;
var player = LocalPlayer.Instance;
var aliveAlies = allies.Where(e => !e.IsDead && e.Distance(LocalPlayer.Instance) <= worldDistance && !Helper.IsColliding(player, e));
switch (targetingMode)
{
case TargetingMode.LowestHealth:
return(aliveAlies.OrderByDescending(e => e.MaxRecoveryHealth - e.Health)
.FirstOrDefault());
case TargetingMode.NearLocalPlayer:
return(aliveAlies.OrderBy(e => e.Distance(player.WorldPosition))
.FirstOrDefault());
case TargetingMode.NearMouse:
return(aliveAlies.OrderBy(e => e.Distance(InputManager.MousePosition))
.FirstOrDefault());
default:
return(null);
}
}
public void SetTargetingMode(TargetingMode mode)
{
_mode = mode;
}
public bool HasTargetingMode(TargetingMode tm)
{
return this.TargetSettings.Any(t => t.targetingMode == tm);
}
private static double FindPrioForTarget(Obj_AI_Hero enemy, TargetingMode TMode)
{
switch (TMode)
{
case TargetingMode.AutoPriority:
{
if (p1.Contains(enemy.CharData.BaseSkinName))
{
return 4;
}
else if (p2.Contains(enemy.CharData.BaseSkinName))
{
return 3;
}
else if (p3.Contains(enemy.CharData.BaseSkinName))
{
return 2;
}
else if (p4.Contains(enemy.CharData.BaseSkinName))
{
return 1;
}
else
{
return 5;
}
}
case TargetingMode.FastKill:
{
if (enemy.IsValid && enemy != null && enemy.IsVisible && !enemy.IsDead)
return (enemy.Health / Player.GetSpellDamage(enemy, SpellSlot.E));
else
return 1000000;
}
default:
return 0;
}
}
protected IEnumerator Select()
{
Region testRegion = new Region () {
Left = (int)Input.mousePosition.x - DRAG_SIZE,
Top = Screen.height - (int)Input.mousePosition.y - DRAG_SIZE,
Width = DRAG_SIZE * 2,
Height = DRAG_SIZE * 2
};
float startTime = DRAG_TIMER;
while (true) {
startTime -= Time.deltaTime;
if (!Input.GetMouseButton(0)) {
TargetingMode = TargetingMode.ClickTargeting;
break;
}
if (testRegion.ContainsMouse() == null || startTime <= 0) {
TargetingMode = TargetingMode.DragTargeting;
break;
}
yield return 0;
}
bool cancel = false;
while (
(Input.GetMouseButton(0) && TargetingMode == TargetingMode.DragTargeting) ||
(!Input.GetMouseButton(0) && TargetingMode == TargetingMode.ClickTargeting)
) {
if (Input.GetMouseButton(1)) {
cancel = true;
break;
}
yield return 0;
if (ActiveCard.TargetingType == TargetingType.All ||
ClickRaycast.MouseOverThis(LeftSide)
) {
ReticleController.Shown = false;
Selected.SuspendDrag = false;
} else {
ReticleController.Shown = true;
Selected.SuspendDrag = true;
}
}
if (ClickRaycast.MouseOverThis(LeftSide)) {
cancel = true;
}
foreach (SelectionRegion pickedRegion in Sprites
.Where(x => typeof(SelectionRegion).IsAssignableFrom(x.GetType()))
.Cast<SelectionRegion>()
.Where(x => x.ContainsMouse())
) {
Target.SetTarget(pickedRegion);
if (
!cancel &&
Selected.GetCard().Cost <= Morphid.LocalPlayer.Morphium &&
ActiveCard.TargetableGuids != null &&
((ActiveCard.TargetableGuids.Contains(Target.GUID)) || ActiveCard.TargetingType != TargetingType.Single)
) {
Morphid.PlayLocalCard(Selected.GetCard(), Target.GUID);
break;
}
}
Selected.SuspendDrag = false;
ReticleController.Shown = false;
TargetingMode = TargetingMode.Inactive;
ActiveCard = null;
Selected.OnDrop();
Selected.Enabled = true;
Selected = null;
}
public void OnFixedUpdate()
{
float targetPitchAngle = human.controls.targetPitchAngle;
float targetYawAngle = human.controls.targetYawAngle;
float leftExtend = human.controls.leftExtend;
float rightExtend = human.controls.rightExtend;
bool grab = human.controls.leftGrab;
bool grab2 = human.controls.rightGrab;
bool onGround = human.onGround;
if ((ragdoll.partLeftHand.transform.position - ragdoll.partChest.transform.position).sqrMagnitude > 6f)
{
grab = false;
}
if ((ragdoll.partRightHand.transform.position - ragdoll.partChest.transform.position).sqrMagnitude > 6f)
{
grab2 = false;
}
Quaternion rotation = Quaternion.Euler(targetPitchAngle, targetYawAngle, 0f);
Quaternion rotation2 = Quaternion.Euler(0f, targetYawAngle, 0f);
Vector3 worldPos = Vector3.zero;
Vector3 worldPos2 = Vector3.zero;
float num = 0f;
float z = 0f;
if (targetPitchAngle > 0f && onGround)
{
z = 0.4f * targetPitchAngle / 90f;
}
TargetingMode targetingMode = (!(ragdoll.partLeftHand.sensor.grabJoint != null)) ? this.targetingMode : grabTargetingMode;
TargetingMode targetingMode2 = (!(ragdoll.partRightHand.sensor.grabJoint != null)) ? this.targetingMode : grabTargetingMode;
switch (targetingMode)
{
case TargetingMode.Shoulder:
worldPos = ragdoll.partLeftArm.transform.position + rotation * new Vector3(0f, 0f, leftExtend * ragdoll.handLength);
break;
case TargetingMode.Chest:
worldPos = ragdoll.partChest.transform.position + rotation2 * new Vector3(-0.2f, 0.15f, 0f) + rotation * new Vector3(0f, 0f, leftExtend * ragdoll.handLength);
break;
case TargetingMode.Hips:
if (targetPitchAngle > 0f)
{
num = -0.3f * targetPitchAngle / 90f;
}
worldPos = ragdoll.partHips.transform.position + rotation2 * new Vector3(-0.2f, 0.65f + num, z) + rotation * new Vector3(0f, 0f, leftExtend * ragdoll.handLength);
break;
case TargetingMode.Ball:
if (targetPitchAngle > 0f)
{
num = -0.2f * targetPitchAngle / 90f;
}
if (ragdoll.partLeftHand.sensor.grabJoint != null)
{
z = ((!human.isClimbing) ? 0f : (-0.2f));
}
worldPos = ragdoll.partBall.transform.position + rotation2 * new Vector3(-0.2f, 0.7f + num, z) + rotation * new Vector3(0f, 0f, leftExtend * ragdoll.handLength);
break;
}
switch (targetingMode2)
{
case TargetingMode.Shoulder:
worldPos2 = ragdoll.partRightArm.transform.position + rotation * new Vector3(0f, 0f, rightExtend * ragdoll.handLength);
break;
case TargetingMode.Chest:
worldPos2 = ragdoll.partChest.transform.position + rotation2 * new Vector3(0.2f, 0.15f, 0f) + rotation * new Vector3(0f, 0f, rightExtend * ragdoll.handLength);
break;
case TargetingMode.Hips:
if (targetPitchAngle > 0f)
{
num = -0.3f * targetPitchAngle / 90f;
}
worldPos2 = ragdoll.partHips.transform.position + rotation2 * new Vector3(0.2f, 0.65f + num, z) + rotation * new Vector3(0f, 0f, rightExtend * ragdoll.handLength);
break;
case TargetingMode.Ball:
if (targetPitchAngle > 0f)
{
num = -0.2f * targetPitchAngle / 90f;
}
if (ragdoll.partRightHand.sensor.grabJoint != null)
{
z = ((!human.isClimbing) ? 0f : (-0.2f));
}
worldPos2 = ragdoll.partBall.transform.position + rotation2 * new Vector3(0.2f, 0.7f + num, z) + rotation * new Vector3(0f, 0f, rightExtend * ragdoll.handLength);
break;
}
ProcessHand(leftMem, ragdoll.partLeftArm, ragdoll.partLeftForearm, ragdoll.partLeftHand, worldPos, leftExtend, grab, motion.legs.legPhase + 0.5f, right: false);
ProcessHand(rightMem, ragdoll.partRightArm, ragdoll.partRightForearm, ragdoll.partRightHand, worldPos2, rightExtend, grab2, motion.legs.legPhase, right: true);
}
public void SetTargetingMode(TargetingMode mode)
{
_mode = mode;
}
public List <BaseEnemy> FindEnemiesInRange(Vector3 turretPosition, float range, int count, TargetingMode mode)
{
List <BaseEnemy> ret = new List <BaseEnemy>();
List <BaseEnemy> list = new List <BaseEnemy>(Enemies);
foreach (BaseEnemy obj in list)
{
if (Vector3.Distance(turretPosition, obj.transform.position) <= range)
{
ret.Add(obj);
}
}
switch (mode)
{
case TargetingMode.Farthest:
ret.Sort((x, y) => Vector3.Distance(x.transform.position, Base.transform.position).CompareTo(Vector3.Distance(y.transform.position, Base.transform.position)));
break;
case TargetingMode.Nearest:
ret.Sort((x, y) => Vector3.Distance(x.transform.position, turretPosition).CompareTo(Vector3.Distance(y.transform.position, turretPosition)));
break;
case TargetingMode.MaxHP:
ret.Sort((x, y) => y.stats.health.CompareTo(x.stats.health));
break;
case TargetingMode.MinHP:
ret.Sort((x, y) => x.stats.health.CompareTo(y.stats.health));
break;
}
ret = new List <BaseEnemy>(ret.GetRange(0, Mathf.Min(count, ret.Count)));
return(ret);
}
public void SetText(TargetingMode mode)
{
transform.GetChild(0).gameObject.GetComponent <Text>().text = mode.ToString();
currentModeIndex = Array.FindIndex(targetModeArray, w => w == mode);
}
public static void SetTargetingMode(TargetingMode mode) => Call(SET_PLAYER_TARGETING_MODE, mode);
public void ActivateSpellTargeting()
{
targetingMode = TargetingMode.SpellAbilityTargetng;
}
public static PokemonCard AskForTargetFromTargetingMode(TargetingMode targetingMode, GameField game, Player caster, Player opponent, PokemonCard pokemonOwner, string info = "", string nameFilter = "")
{
PokemonCard target;
NetworkMessage message;
NetworkId selectedId;
IDeckFilter filter = !string.IsNullOrEmpty(nameFilter) ? new PokemonWithNameOrTypeFilter(nameFilter, EnergyTypes.All) : null;
switch (targetingMode)
{
case TargetingMode.Self:
target = pokemonOwner;
break;
case TargetingMode.YourActive:
target = caster.ActivePokemonCard;
break;
case TargetingMode.YourBench:
if (caster.BenchedPokemon.Count == 0)
{
return(null);
}
else if (caster.BenchedPokemon.Count == 1)
{
return(caster.BenchedPokemon.GetFirst());
}
message = new SelectFromYourBenchMessage(1)
{
Info = info, Filter = filter
}.ToNetworkMessage(game.Id);
selectedId = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.First();
target = (PokemonCard)game.Cards[selectedId];
break;
case TargetingMode.YourPokemon:
message = new SelectFromYourPokemonMessage()
{
Info = info, Filter = filter
}.ToNetworkMessage(game.Id);
selectedId = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.First();
target = (PokemonCard)game.Cards[selectedId];
break;
case TargetingMode.OpponentActive:
target = opponent.ActivePokemonCard;
break;
case TargetingMode.OpponentBench:
if (opponent.BenchedPokemon.Count == 0)
{
return(null);
}
else if (opponent.BenchedPokemon.Count == 1)
{
return(opponent.BenchedPokemon.GetFirst());
}
message = new SelectFromOpponentBenchMessage(1)
{
Info = info, Filter = filter
}.ToNetworkMessage(game.Id);
selectedId = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.First();
target = (PokemonCard)game.Cards[selectedId];
break;
case TargetingMode.OpponentPokemon:
message = new SelectOpponentPokemonMessage(1)
{
Info = info, Filter = filter
}.ToNetworkMessage(game.Id);
selectedId = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message).Cards.First();
target = (PokemonCard)game.Cards[selectedId];
break;
case TargetingMode.LastEffectTarget:
target = game.LastTarget;
break;
case TargetingMode.AnyPokemon:
throw new NotImplementedException("TargetingMode.AnyPokemon not implemented in Targeting");
default:
target = caster.ActivePokemonCard;
break;
}
if (game != null)
{
game.LastTarget = target;
}
return(target);
}
public static bool IsYours(TargetingMode mode)
{
return(mode == TargetingMode.YourBench || mode == TargetingMode.YourPokemon);
}
public void StartAttackTargeting()
{
targetingMode = TargetingMode.AttackMove;
Cursor.SetCursor(attackCursorTexture, hotSpot, cursorMode);
}
protected void Start()
{
targetingMode = TargetingMode.None;
}
public void ExitTargeting()
{
targetingMode = TargetingMode.None;
Cursor.SetCursor(null, Vector2.zero, cursorMode);
}
public void Process(GameField game, Player caster, Player opponent, PokemonCard pokemonSource)
{
PokemonCard source;
while (true)
{
source = Targeting.AskForTargetFromTargetingMode(Source, game, caster, opponent, pokemonSource, "Select a pokemon to move energy from");
if (FromAnother && source == pokemonSource)
{
continue;
}
break;
}
if (source == null)
{
return;
}
var availableEnergyCards = source.AttachedEnergy
.Where(energy => !OnlyBasic || (OnlyBasic && energy.IsBasic))
.Where(energy => EnergyType == EnergyTypes.All || EnergyType == EnergyTypes.None || energy.EnergyType == EnergyType)
.ToList();
PokemonCard target;
bool first = true;
if (availableEnergyCards.Count <= Amount)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
while (source.AttachedEnergy.Count > 0)
{
var energyCard = source.AttachedEnergy[0];
source.AttachedEnergy.RemoveAt(0);
game.SendEventToPlayers(new AttachedEnergyDiscardedEvent {
DiscardedCard = energyCard, FromPokemonId = source.Id
});
if (DifferentTargetForEachCard && !first)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
}
target.AttachedEnergy.Add(energyCard);
game.SendEventToPlayers(new EnergyCardsAttachedEvent {
EnergyCard = energyCard, AttachedTo = target
});
first = false;
}
return;
}
var message = new PickFromListMessage(availableEnergyCards.OfType <Card>().ToList(), 1, Amount);
var ids = caster.NetworkPlayer.SendAndWaitForResponse <CardListMessage>(message.ToNetworkMessage(game.Id)).Cards;
var cards = source.AttachedEnergy.Where(x => ids.Contains(x.Id)).ToList();
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
foreach (var card in cards)
{
if (DifferentTargetForEachCard && !first)
{
target = Targeting.AskForTargetFromTargetingMode(Target, game, caster, opponent, pokemonSource, "Select a pokemon to move energy to");
}
source.AttachedEnergy.Remove(card);
game.SendEventToPlayers(new AttachedEnergyDiscardedEvent {
DiscardedCard = card, FromPokemonId = source.Id
});
target.AttachedEnergy.Add(card);
game.SendEventToPlayers(new EnergyCardsAttachedEvent {
EnergyCard = card, AttachedTo = target
});
first = false;
}
}
protected virtual void SetArgsFromTarget(
Target t,
TargetSettings ts,
string prefix,
Vector3?start = null
)
{
TargetingMode tm = TargetingMode.Custom;
if (ts != null)
{
tm = ts.targetingMode;
}
else
{
if (t.path != null)
{
tm = TargetingMode.Pick;
}
else if (t.character != null)
{
tm = TargetingMode.Pick;
}
else if (t.facing != null)
{
tm = TargetingMode.Radial;
}
else if (t.subregion != -1)
{
tm = TargetingMode.SelectRegion;
}
}
Vector3 pos = character.TilePosition;
switch (tm)
{
case TargetingMode.Self:
case TargetingMode.Pick:
case TargetingMode.Path:
pos = t.Position;
SetArgsFrom(pos, t.facing, prefix, start);
break;
case TargetingMode.Cardinal:
case TargetingMode.Radial:
//FIXME: wrong for selectRegion
case TargetingMode.SelectRegion:
if (t.character != null)
{
pos = t.character.TilePosition;
}
else if (t.path != null)
{
pos = t.Position;
}
SetArgsFrom(pos, t.facing, prefix, start);
break;
default:
Debug.LogError("Unrecognized targeting mode");
break;
}
}
public static List <PokemonCard> GetPossibleTargetsFromMode(TargetingMode targetingMode, GameField game, Player caster, Player opponent, PokemonCard pokemonOwner, string nameFilter = "")
{
var pokemons = new List <PokemonCard>();
switch (targetingMode)
{
case TargetingMode.YourActive:
pokemons.Add(caster.ActivePokemonCard);
break;
case TargetingMode.YourBench:
pokemons = caster.BenchedPokemon.ValidPokemonCards.ToList();
break;
case TargetingMode.YourPokemon:
pokemons = caster.GetAllPokemonCards();
break;
case TargetingMode.OpponentActive:
{
if (game.CurrentDefender != null && game.CurrentDefender.Owner.Id.Equals(opponent.Id))
{
pokemons.Add(game.CurrentDefender);
}
else
{
pokemons.Add(opponent.ActivePokemonCard);
}
break;
}
case TargetingMode.OpponentBench:
pokemons = opponent.BenchedPokemon.ValidPokemonCards.ToList();
break;
case TargetingMode.OpponentPokemon:
pokemons = opponent.GetAllPokemonCards();
break;
case TargetingMode.AnyPokemon:
pokemons = caster.GetAllPokemonCards();
pokemons.AddRange(opponent.GetAllPokemonCards());
break;
case TargetingMode.AttachedTo:
pokemons.Add(pokemonOwner);
break;
case TargetingMode.Self:
pokemons.Add(pokemonOwner);
break;
default:
pokemons.Add(pokemonOwner);
break;
}
if (!string.IsNullOrEmpty(nameFilter))
{
return(pokemons.Where(p => p.Name.ToLower().Contains(nameFilter.ToLower())).ToList());
}
return(pokemons);
}
