public void RemoveTarget(Targettable target)
{
if (selectedTargets != null)
{
selectedTargets.Remove(target);
}
}
public void AddTarget(Targettable target)
{
if (CanSelectMoreTargets())
{
selectedTargets.Add(target);
}
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
Effect effectTarget = target as Effect;
if (effectTarget)
{
GameUtils.GetGameSession().ServerRemoveEffect(effectTarget);
}
}
public bool IsValidTarget(Targettable target)
{
if (Type == null)
{
return(true);
}
return(target.GetComponent(Type.GetSerializedType()) != null);
}
public bool AppliesToTargettable(PlayerController player, Targettable target)
{
TargetXDescription targetDescription = new TargetXDescription(targetType, GetPlayerAlignment());
targetDescription.amount = 1;
targetDescription.qualifier = qualifier;
TargettingQuery query = new TargettingQuery(targetDescription, player, false);
return(target.IsTargettable(query));
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
PlayerController targetPlayer = target as PlayerController;
if (targetPlayer)
{
GameSession gameSession = GameUtils.GetGameSession();
CardGenerationFlags flags = CardGenerationFlags.NONE;
if (cardQualifier != null)
{
switch (cardQualifier.qualifierType)
{
case QualifierType.CARD_TYPE:
{
CardTypeQualifierDescription cardTypeQualifier = cardQualifier as CardTypeQualifierDescription;
flags |= EffectConstants.GetGenerationFlags(cardTypeQualifier.cardType);
}
break;
case QualifierType.CREATURE_TYPE:
{
CreatureTypeQualifierDescription creatureTypeQualifier = cardQualifier as CreatureTypeQualifierDescription;
flags |= EffectConstants.GetGenerationFlags(creatureTypeQualifier.creatureType);
}
break;
}
}
for (int i = 0; i < amount; i++)
{
switch (drawModifier)
{
case DrawModifier.RANDOM:
gameSession.ServerPlayerDrawCard(targetPlayer, targetPlayer, flags, true);
break;
case DrawModifier.SELF:
gameSession.ServerPlayerDrawCard(targetPlayer, targetPlayer, flags);
break;
case DrawModifier.OPPONENT_RANDOM:
gameSession.ServerPlayerDrawCard(targetPlayer, GameUtils.GetGameSession().GetOpponents(targetPlayer)[0], flags, true);
break;
case DrawModifier.OPPONENT:
gameSession.ServerPlayerDrawCard(targetPlayer, GameUtils.GetGameSession().GetOpponents(targetPlayer)[0], flags);
break;
}
}
}
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
GameSession gameSession = GameUtils.GetGameSession();
if (effectType == EffectType.HEAL_DAMAGE)
{
gameSession.ServerHealDamage(target, amount);
}
else
{
gameSession.ServerApplyDamage(target, amount);
}
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
PlayerController targetPlayer = target as PlayerController;
if (targetPlayer)
{
GameSession gameSession = GameUtils.GetGameSession();
for (int i = 0; i < amount; i++)
{
gameSession.ServerCreateToken(targetPlayer, tokenType);
}
}
}
/// <summary>
/// When an entity enters the trigger, apply damage and knockback, and mark it as processed.
/// </summary>
private void OnTriggerEnter(Collider other)
{
Targettable t = other.GetComponent <Targettable>();
if (t != null)
{
if (!affectedEnemies.Contains(t))
{
affectedEnemies.Add(t);
t.DoDamage(damage, knockback, FindObjectOfType <PlayerCombatController>().transform.position);
}
}
}
public override Queue <EffectResolutionTask> GetEffectTasksWithTargets(IEffectDescription effect, Targettable[] targets, PlayerController player, Targettable source)
{
Queue <EffectResolutionTask> tasks = new Queue <EffectResolutionTask>();
TargetXDescription targetDescription = new TargetXDescription(targetType, GetPlayerAlignment());
targetDescription.amount = 1;
targetDescription.qualifier = qualifier;
TargettingQuery query = new TargettingQuery(targetDescription, player, false);
GameSession gameSession = GameUtils.GetGameSession();
List <Targettable> possibleTargets = gameSession.GetPotentialTargets();
foreach (Targettable t in possibleTargets)
{
if (t.IsTargettable(query))
{
Targettable targetableEntity = t.GetTargettableEntity();
bool valid = true;
foreach (Targettable t2 in targets)
{
if (targetableEntity == t2)
{
valid = false;
break;
}
}
if (valid)
{
EffectResolutionTask task = new EffectResolutionTask();
task.effect = effect;
task.target = targetableEntity;
task.player = player;
task.source = source;
tasks.Enqueue(task);
}
}
}
return(tasks);
}
private void UpdateDisplay()
{
if (currentTarget != null)
{
currentTarget.BroadcastMessage("OnTargetted", false);
}
Targettable targetable = targetingComputer.GetCurrentTarget();
if (targetable != null)
{
currentTarget = GameObject.Find(targetable.Name);
currentTarget.BroadcastMessage("OnTargetted", true);
followingTargetCamera.target = currentTarget;
targetNameText.text = targetable.Name;
if (targetable.ShipFaction == ShipFaction.Alliance)
{
targetNameText.color = Color.green;
}
else if (targetable.ShipFaction == ShipFaction.Empire)
{
targetNameText.color = Color.red;
}
else
{
targetNameText.color = Color.white;
}
targetHullText.text = targetable.HullPoints + "%";
targetShieldText.text = targetable.ShieldPoints + "%";
targetContentsText.text = targetable.Contents;
}
else
{
targetNameText.text = "";
targetHullText.text = "";
targetShieldText.text = "";
targetDistanceText.text = "";
targetContentsText.text = "";
}
}
// Update is called once per frame
void Update()
{
//Apply targetting
foreach (Targettable t in FindObjectsOfType <Targettable>())
{
t.isTargetted = false;
}
Targettable currentTarget = GetTarget();
if (currentTarget != null)
{
currentTarget.isTargetted = true;
}
//Set player rotation
if (currentTarget != null)
{
//Point towards target
Vector3 targetPos = currentTarget.transform.position;
targetPos.y = gameObject.transform.position.y;
gameObject.transform.rotation = Quaternion.LookRotation((targetPos - gameObject.transform.position).normalized);
}
else
{
//Point towards mouse
Ray r = playerCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(r.origin, r.direction, out hit))
{
Vector3 targetPos = hit.point;
targetPos.y = gameObject.transform.position.y;
gameObject.transform.rotation = Quaternion.LookRotation((targetPos - gameObject.transform.position).normalized);
}
}
//Try to input an attack into the state machine
if (Input.GetButtonDown("Fire1"))
{
TryInputAttack();
}
}
public void SetData(Targettable entity, Card c, TriggerCondition trigger, Targettable[][] targets = null)
{
source.cardData = c.cardData.Clone();
source.controller = c.controller;
sourceEntity = entity;
if (c.cardData.GetImage() && icon)
{
Sprite[] sprites = Resources.LoadAll <Sprite>(GameConstants.PATHS.CARD_IMAGES + c.cardData.GetImage().name);
icon.sprite = sprites[1];
}
if (textPrompt != null)
{
string effectMessage = "";
int targetsIndex = 0;
foreach (CardEffectDescription desc in source.cardData.GetEffectsOnTrigger(trigger))
{
if (desc.targettingType.RequiresSelection())
{
effectMessage += "<sprite=" + targetsIndex + "> ";
targetsIndex++;
}
effectMessage += desc.CardText() + '\n';
}
textPrompt.SetText(effectMessage);
}
triggerCondition = trigger;
targetList = targets;
if (source.controller.isLocalPlayer)
{
border.color = allyColor;
}
else
{
border.color = enemyColor;
}
}
private bool TargetShipInReticle()
{
const float TargetingDistance = 1000;
bool targetUpdated = false;
RaycastHit hit;
if (Physics.Raycast(transform.position, transform.forward, out hit, TargetingDistance))
{
try
{
GameObject shipInReticle = GameObjects.GetParentShip(hit.transform.gameObject);
Targettable previousTarget = targetingComputer.GetCurrentTarget();
targetingComputer.SelectTargetByName(shipInReticle.name);
targetUpdated = previousTarget != targetingComputer.GetCurrentTarget();;
}
catch (ArgumentException)
{
// Perfectly valid: the ray may have hit something that's not a ship
}
}
return(targetUpdated);
}
/// <summary>
/// Get the entity that the player is currently targetting (cursor). If player is not targetting anything, returns null.
/// </summary>
/// <returns></returns>
public Targettable GetTarget()
{
Targettable[] possibleTargets = FindObjectsOfType <Targettable>();
if (possibleTargets.Length < 1)
{
return(null);
}
Vector3 mousePos = Input.mousePosition;
//Find closest targettable
Targettable closest = possibleTargets[0];
Vector3 closestOnScreen = playerCamera.WorldToScreenPoint(closest.transform.position); closestOnScreen.z = 0;
foreach (Targettable t in possibleTargets)
{
Vector3 onScreen = playerCamera.WorldToScreenPoint(t.transform.position);
onScreen.z = 0;
//If closer than output, and within lockon range
if (Vector3.Distance(onScreen, mousePos) < Vector3.Distance(closestOnScreen, mousePos) && Vector3.Distance(onScreen, mousePos) <= t.maximumLockonRange * screenDiagonal)
{
closest = t;
closestOnScreen = onScreen;
}
}
//If output is within lockon range, return it
if (Vector3.Distance(closestOnScreen, mousePos) <= closest.maximumLockonRange * screenDiagonal)
{
return(closest);
}
else
{
return(null);
}
}
public bool IsValidTarget(Targettable target)
{
var requirements = GetComponents <RequiresTarget>();
if (!requirements.Any())
{
return(true);
}
if (target == null)
{
return(false);
}
foreach (var component in requirements)
{
if (component.IsValidTarget(target))
{
return(true);
}
}
return(false);
}
public abstract void ApplyToTarget(Targettable target, PlayerController player, Targettable source);
public CurrentTargetAbilityFilter(Targettable target)
{
Target = target;
}
public override Queue <EffectResolutionTask> GetEffectTasksWithTargets(IEffectDescription effect, Targettable[] targets, PlayerController player, Targettable source)
{
Queue <EffectResolutionTask> tasks = new Queue <EffectResolutionTask>();
foreach (Targettable target in targets)
{
EffectResolutionTask task = new EffectResolutionTask();
task.effect = effect;
task.target = target.GetTargettableEntity();
task.player = player;
task.source = source;
tasks.Enqueue(task);
}
return(tasks);
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
GameSession gameSession = GameUtils.GetGameSession();
gameSession.ServerDestroyCard(target);
}
public abstract Queue <EffectResolutionTask> GetEffectTasksWithTargets(IEffectDescription effect, Targettable[] targets, PlayerController player, Targettable source);
public TargetClicked(Targettable target)
{
Target = target;
}
public void SetTrapContext(Trap trap)
{
isSetTrap = true;
targettableUI = trap;
}
public void ResetTrapContext()
{
isSetTrap = false;
targettableUI = null;
}
public override Queue <EffectResolutionTask> GetEffectTasksWithTargets(IEffectDescription effect, Targettable[] targets, PlayerController player, Targettable source)
{
EffectResolutionTask task = new EffectResolutionTask();
task.effect = effect;
task.target = player;
task.player = player;
task.source = source;
return(new Queue <EffectResolutionTask>(new EffectResolutionTask[] { task }));
}
public void AddTarget(Targettable target)
{
targets.Add(target);
}
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source)
{
GameSession gameSession = GameUtils.GetGameSession();
gameSession.ServerApplyModifier(target, modifierDescription.GetModifier(source as Creature));
}
public Queue <EffectResolutionTask> GetEffectTasks(Targettable[] targets, PlayerController player, Targettable source)
{
return(targettingType.GetEffectTasksWithTargets(effectType, targets, player, source));
}
private void HandleTargetEvent(TargetSelectionEvent targetEvent)
{
// Validate all targets
Card card = gameSession.GetPendingCard(targetEvent.playerId.GetComponent <PlayerController>());
bool isValid = false;
if (card != null && targetEvent.playerId == gameSession.GetWaitingOnPlayer().netIdentity)
{
PlayerController player = gameSession.GetWaitingOnPlayer();
TriggerCondition triggerCondition = gameSession.GetPendingTriggerCondition();
NetworkIdentity[][] targets = targetEvent.ReconstructTargets();
List <ITargettingDescription> selectableTargetDescriptions = null;
GameSession.PendingType pendingType = gameSession.GetPendingActionType();
if (pendingType == GameSession.PendingType.REPLACE_CREATURE)
{
selectableTargetDescriptions = GameUtils.ReplaceCreatureTargetDescriptions();
}
else
{
switch (card.cardData.GetCardType())
{
case CardType.CREATURE:
selectableTargetDescriptions = card.cardData.GetSelectableTargets(triggerCondition);
break;
case CardType.SPELL:
case CardType.TRAP:
selectableTargetDescriptions = card.cardData.GetSelectableTargets(TriggerCondition.NONE);
break;
}
}
if (selectableTargetDescriptions != null && selectableTargetDescriptions.Count == targets.Length)
{
isValid = true;
for (int i = 0; i < selectableTargetDescriptions.Count; i++)
{
ITargettingDescription desc = selectableTargetDescriptions[i];
if (desc.targettingType == TargettingType.EXCEPT)
{
ExceptTargetDescription exceptDesc = (ExceptTargetDescription)desc;
desc = exceptDesc.targetDescription;
}
switch (desc.targettingType)
{
case TargettingType.TARGET:
{
TargetXDescription targetDesc = (TargetXDescription)desc;
if (targetDesc.amount == targets[i].Length)
{
TargettingQuery query = new TargettingQuery(targetDesc, player, pendingType != GameSession.PendingType.REPLACE_CREATURE);
for (int j = 0; j < targets[i].Length; j++)
{
Targettable targettable = targets[i][j].GetComponent <Targettable>();
if (!targettable.IsTargettable(query))
{
isValid = false;
break;
}
}
}
else
{
isValid = false;
}
break;
}
case TargettingType.UP_TO_TARGET:
{
UpToXTargetDescription targetDesc = (UpToXTargetDescription)desc;
if (targetDesc.amount >= targets[i].Length)
{
TargettingQuery query = new TargettingQuery(targetDesc, player, pendingType != GameSession.PendingType.REPLACE_CREATURE);
for (int j = 0; j < targets[i].Length; j++)
{
Targettable targettable = targets[i][j].GetComponent <Targettable>();
if (!targettable.IsTargettable(query))
{
isValid = false;
break;
}
}
}
else
{
isValid = false;
}
break;
}
}
if (!isValid)
{
break;
}
}
}
if (isValid)
{
switch (pendingType)
{
case GameSession.PendingType.PLAY_CARD:
PlayCardEvent playCardEvent = new PlayCardEvent(player, card, targetEvent.flattenedTargets, targetEvent.indexes);
gameSession.HandleEvent(playCardEvent);
gameSession.ServerPopState();
break;
case GameSession.PendingType.TRIGGER_EFFECT:
gameSession.ServerAddEffectToStack(gameSession.GetPendingCreature(player), card, triggerCondition, targetEvent.flattenedTargets, targetEvent.indexes);
gameSession.ResetPendingCreature();
gameSession.ServerPopState();
break;
case GameSession.PendingType.USE_TRAP:
UseTrapEvent trapEvent = new UseTrapEvent(player, card, targetEvent.flattenedTargets, targetEvent.indexes);
gameSession.HandleEvent(trapEvent);
gameSession.ServerPopState();
break;
case GameSession.PendingType.REPLACE_CREATURE:
// Replace creature should only have one target
Creature creatureToReplace = targets[0][0].GetComponent <Creature>();
// Destroying the creature makes it so we can't target it for the on enter effect of the replacing creature which is what we want
creatureToReplace.GetCreatureState().ServerDestroyCard();
gameSession.SetPendingCreature(creatureToReplace);
PlayCardEvent playReplaceCreatureEvent = new PlayCardEvent(player, card);
gameSession.HandleEvent(playReplaceCreatureEvent);
gameSession.ServerPopState();
break;
}
}
else
{
CancelPlayCard();
}
}
}
