public MovePart(TargettingType target, MoveDirection direction, int distance, Vector2Int center, bool forced = false, int chance = 100) : base(target, chance)
{
this.direction = direction;
amount = distance;
this.forced = forced;
this.center = center;
}
public static SpellTargetInfoView Deserialize(System.IO.StreamReader input)
{
SpellTargetInfoView _obj = new SpellTargetInfoView();
// Type
TargettingType _obj_Type = (TargettingType)Int32.Parse(input.ReadLine());
_obj.Type = (TargettingType)_obj_Type;
// Range
float _obj_Range = Single.Parse(input.ReadLine());
_obj.Range = (float)_obj_Range;
// Duration
float _obj_Duration = Single.Parse(input.ReadLine());
_obj.Duration = (float)_obj_Duration;
// AoeRadius
float _obj_AoeRadius = Single.Parse(input.ReadLine());
_obj.AoeRadius = (float)_obj_AoeRadius;
// DieOnCollision
bool _obj_DieOnCollision = Int32.Parse(input.ReadLine()) == 0 ? false : true;
_obj.DieOnCollision = (bool)_obj_DieOnCollision;
// AllowedTargetTypes
EntityTypeRelative _obj_AllowedTargetTypes = (EntityTypeRelative)Int32.Parse(input.ReadLine());
_obj.AllowedTargetTypes = (EntityTypeRelative)_obj_AllowedTargetTypes;
return(_obj);
}
public override ITargettingDescription Generate()
{
ExceptTargetDescription desc = new ExceptTargetDescription(targetType, alignment);
TargettingType exceptTargetting = TargettingType.TARGET;
switch (desc.GetPlayerAlignment())
{
case Alignment.POSITIVE:
exceptTargetting = TargettingType.TARGET_ALLY;
break;
case Alignment.NEGATIVE:
exceptTargetting = TargettingType.TARGET_ENEMY;
break;
}
IProceduralTargettingGenerator targetGen = ProceduralUtils.GetProceduralGenerator(exceptTargetting);
targetGen.SetupParameters(targetType, random, model, minAllocatedBudget, maxAllocatedBudget);
desc.targetDescription = targetGen.Generate();
if (desc.targetDescription is IQualifiableTargettingDescription qualifiableDesc)
{
qualifiableDesc.qualifier = desc.qualifier;
}
return(desc);
}
/// <summary>
/// Creates a new damage part with the corresponding damage values
/// </summary>
/// <param name="modifiedByValue">If this is affected by a numerical value (EX. healing based on healing recieved), how much is it affectd</param>
public HealingPart(TargettingType target, int heal, int flatHeal, int maxHPHeal, int chance = 100, float modifiedByValue = 0) : base(target, chance)
{
healing = heal;
flatHealing = flatHeal;
maxHpPercent = maxHPHeal;
this.modifiedByValue = modifiedByValue;
}
public override void NowPrimaried(object request)
{
TargettingKeystrokeRequest targettingRequest = (TargettingKeystrokeRequest)request;
m_targetablePoints = targettingRequest.TargetablePoints;
m_selectionDelegate = targettingRequest.SelectionDelegate;
if (m_selectionDelegate == null)
throw new ArgumentNullException("Selection delegate for targetting must not be null");
m_alternateSelectionKey = targettingRequest.AlternateSelectionKey;
m_targettingType = targettingRequest.TargettingType;
SelectionPoint = SetTargettingInitialSpot(m_engine);
EnablePlayerTargeting enableRequest = new EnablePlayerTargeting(true, m_targetablePoints);
if (targettingRequest.HaloDelegate != null)
enableRequest.HaloDelegate = x => targettingRequest.HaloDelegate(x);
m_gameInstance.SendPaintersRequest(enableRequest);
m_gameInstance.SendPaintersRequest(new EnableMapCursor(true, SelectionPoint));
// If we have no targetable points, just exit now
if (m_targetablePoints.Count == 0)
Escape();
m_gameInstance.UpdatePainters();
}
public AddTriggerPart(TargettingType target, TriggeredEffect effect, int maxTimesThisBattle = -1, int turnCooldown = -1, int maxActiveTurns = -1, int chance = 100) : base(target, chance)
{
this.effect = effect;
this.maxTimesThisBattle = maxTimesThisBattle;
this.turnCooldown = turnCooldown;
this.maxActiveTurns = maxActiveTurns;
}
/// <summary>
/// Creates a new damage part with the corresponding damage values
/// </summary>
/// <param name="modifiedByValue">If this is affected by a numerical value (EX. dealing damage based on damage taken), how much is it affectd</param>
public DamagePart(TargettingType target, DamageType damageType, int damage, int flatDamage, int maxHpDamage, int remainingHpDamage, int chance = 100, float modifiedByValue = 0) : base(target, chance)
{
this.damageType = damageType;
this.damage = damage;
this.flatDamage = flatDamage;
maxHpPercent = maxHpDamage;
missingHpPercent = remainingHpDamage;
this.modifiedByValue = modifiedByValue;
}
static public IProceduralTargettingGenerator GetProceduralGenerator(TargettingType type)
{
if (proceduralTargettingGenerators.ContainsKey(type))
{
return(proceduralTargettingGenerators[type]);
}
Assert.IsTrue(false);
return(null);
}
public BattleItemBase(TargettingType targetType, bool outOfBattleUse, List <SkillPartBase> effects, int maxStack, int sellPrice, string flavorText = "") : base(maxStack, sellPrice, flavorText)
{
this.targetType = targetType;
usableOutOfBattle = outOfBattleUse;
if (effects != null)
{
foreach (SkillPartBase part in effects)
{
partList.Add(part);
}
}
}
public Skill(string name, TargettingType target, int cost, int targetRange, int xAOE, int yAOE, int unlockCost, int unlockLvl, string flavorText = "")
{
this.name = name;
targetType = target;
aEtherCost = cost;
targettingRange = targetRange;
xRange = xAOE;
yRange = yAOE;
this.unlockCost = unlockCost;
unlockLevel = unlockLvl;
this.flavorText = flavorText;
}
public TargettingModeKeyboardHandler(TargettingType targettingType, IGameEngine engine, Map map, List<EffectivePoint> targetablePoints)
{
m_targetablePoints = targetablePoints;
m_targettingType = targettingType;
map.InTargettingMode = true;
map.TargetPoint = SetTargettingInitialSpot(engine);
if (m_targetablePoints != null)
map.TargetablePoints = m_targetablePoints;
m_lastTargetted = null;
}
static private void RegisterProceduralGenerator(TargettingType type, IProceduralTargettingGenerator generator)
{
Assert.IsFalse(proceduralTargettingGenerators.ContainsKey(type));
Assert.AreEqual(type, generator.GetTargettingType());
proceduralTargettingGenerators[type] = generator;
double minCost = generator.GetMinCost();
int i;
for (i = 0; i < targettingMinCosts.Count; i++)
{
if (minCost <= targettingMinCosts[i].Item1)
{
break;
}
}
targettingMinCosts.Insert(i, new Tuple <double, TargettingType>(minCost, type));
targettingByAlignment[generator.GetDescriptionType().GetAlignment()].Add(type);
}
public static SpellCastTargetInfoView Deserialize(System.IO.StreamReader input)
{
SpellCastTargetInfoView _obj = new SpellCastTargetInfoView();
// Type
TargettingType _obj_Type = (TargettingType)Int32.Parse(input.ReadLine());
_obj.Type = (TargettingType)_obj_Type;
// TargetPosition
Vector2 _obj_TargetPosition = Vector2.Deserialize(input);
_obj.TargetPosition = (Vector2)_obj_TargetPosition;
// TargetDirection
Vector2 _obj_TargetDirection = Vector2.Deserialize(input);
_obj.TargetDirection = (Vector2)_obj_TargetDirection;
// TargetId
int _obj_TargetId = Int32.Parse(input.ReadLine());
_obj.TargetId = (int)_obj_TargetId;
return(_obj);
}
public TargettingInfo(TargettingType type, Action <int> onTargetSelected)
{
Type = type;
OnTargetSelected = onTargetSelected;
}
void EnableTargetting(TargettingType type, Action <int> action)
{
TargetInfo = new TargettingInfo(type, action);
CombatView.EnableTargetting(type);
}
public void EnableTargetting(TargettingType type)
{
Enabled = true;
Type = type;
SetDefaultTarget();
}
public SkillPartBase(TargettingType targetType, int chanceToProc)
{
this.targetType = targetType;
this.chanceToProc = chanceToProc;
}
protected IQualifiableTargettingDescription(TargetType target, TargettingType targetting, Alignment alignment) : base(target, targetting)
{
playerAlignment = alignment;
}
/// <summary>
/// Gets a target from the player. false showed an escape. otherwise target is the target selected.
/// </summary>
/// <param name="?"></param>
/// <returns></returns>
private bool GetTargetFromPlayer(Point start, out Point target, TargettingType type, int range, double spreadAngle, char confirmChar, CreatureFOV currentFOV)
{
//Turn targetting mode on the screen
Screen.Instance.TargettingModeOn();
Screen.Instance.Target = start;
Screen.Instance.TargetType = type;
Screen.Instance.TargetRange = range;
Screen.Instance.TargetPermissiveAngle = spreadAngle;
if ((range == -1 && currentFOV.CheckTileFOV(start.x, start.y))
|| Utility.TestRangeFOVForWeapon(Game.Dungeon.Player, start, range, currentFOV))
{
Screen.Instance.SetTargetInRange = true;
SquareContents sqC = SetViewPanelToTargetAtSquare(start);
}
else
{
Screen.Instance.SetTargetInRange = false;
}
Game.MessageQueue.AddMessage("Find a target. " + confirmChar + " to confirm. ESC to exit.");
Screen.Instance.Update();
bool keepLooping = true;
bool validFire = false;
target = start;
do
{
//Get direction from the user or 'z' to fire
KeyPress userKey = Keyboard.WaitForKeyPress(true);
Point direction = new Point();
KeyModifier mod = KeyModifier.Arrow;
bool validDirection = false;
if (GetDirectionFromKeypress(userKey, out direction, out mod))
{
//Valid direction
validDirection = true;
}
else
{
//Look for firing
if (userKey.KeyCode == KeyCode.TCODK_CHAR)
{
char keyCode = (char)userKey.Character;
if(keyCode == confirmChar) {
validFire = true;
keepLooping = false;
}
}
if (userKey.KeyCode == KeyCode.TCODK_ESCAPE)
{
keepLooping = false;
}
}
//If direction, update the location and redraw
if (validDirection)
{
Point newPoint = new Point(target.x + direction.x, target.y + direction.y);
int level = Game.Dungeon.Player.LocationLevel;
if (newPoint.x < 0 || newPoint.x >= Game.Dungeon.Levels[level].width || newPoint.y < 0 || newPoint.y >= Game.Dungeon.Levels[level].height)
continue;
//Otherwise OK
target = newPoint;
if ((range == -1 && currentFOV.CheckTileFOV(newPoint.x, newPoint.y))
|| Utility.TestRangeFOVForWeapon(Game.Dungeon.Player, newPoint, range, currentFOV))
{
Screen.Instance.SetTargetInRange = true;
SquareContents sqC = SetViewPanelToTargetAtSquare(target);
}
else
Screen.Instance.SetTargetInRange = false;
//Update screen
Screen.Instance.Target = newPoint;
Game.MessageQueue.AddMessage("Find a target. " + confirmChar + " to confirm. ESC to exit.");
Screen.Instance.Update();
}
} while (keepLooping);
//Turn targetting mode off
Screen.Instance.TargettingModeOff();
Screen.Instance.Update();
return validFire;
}
public TargetingInfo(TargettingType targetingType, int range)
{
Type = targetingType;
Range = range;
}
/// <summary>
/// Let the user target something
/// </summary>
/// <returns></returns>
private bool TargetAttack(out Point target, int range, TargettingType targetType, double spreadAngle, char confirmChar, CreatureFOV currentFOV)
{
Player player = Game.Dungeon.Player;
//Start on the nearest creature
Creature closeCreature = Game.Dungeon.FindClosestHostileCreatureInFOV(player);
if (closeCreature == null)
{
var allCreatures = Game.Dungeon.FindClosestCreaturesInPlayerFOV();
if (allCreatures.Any())
closeCreature = allCreatures.First();
}
//If no nearby creatures, start on the player
if (closeCreature == null)
closeCreature = Game.Dungeon.Player;
Point startPoint;
if (Utility.TestRange(Game.Dungeon.Player, closeCreature, range) || range == -1)
{
startPoint = new Point(closeCreature.LocationMap.x, closeCreature.LocationMap.y);
}
else
{
startPoint = new Point(player.LocationMap.x, player.LocationMap.y);
}
/*
//Get the FOV from Dungeon (this also updates the map creature FOV state)
TCODFov currentFOV = Game.Dungeon.CalculateCreatureFOV(player);
Point startPoint;
//Is that creature in FOV
if (currentFOV.CheckTileFOV(closeCreature.LocationMap.x, closeCreature.LocationMap.y))
{
//If so, target
startPoint = new Point(closeCreature.LocationMap.x, closeCreature.LocationMap.y);
}
else
{
//If not, target the PC
startPoint = new Point(player.LocationMap.x, player.LocationMap.y);
}
*/
//Get the desired target from the player
return GetTargetFromPlayer(startPoint, out target, targetType, range, spreadAngle, confirmChar, currentFOV);
}
public StatChangePart(TargettingType target, Stats affectedStat, int flatChange, float multiplier, int duration, int chance = 100) : base(target, chance)
{
statMod = new StatMod(affectedStat, flatChange, multiplier, duration);
}
public ConnectedChancePart(TargettingType target, List <ConnectedChanceEffect> effects, int chanceOutOf, int chance = 100) : base(target, chance)
{
this.effects = effects;
this.chanceOutOf = chanceOutOf;
}
public StatusEffectPart(TargettingType target, string status, bool removeIt, int chance = 100) : base(target, chance)
{
this.status = status;
remove = removeIt;
}
public TargetingInfo(TargettingType targetingType)
: this(targetingType, -1)
{
}
static private bool GenerateCardEffect(System.Random random, IHistogram model, CreatureModelIndex creatureModels, CardEffectDescription effectDesc, EffectType effect, double minBudget, double maxBudget, bool positive)
{
IProceduralEffectGenerator effectGen = ProceduralUtils.GetProceduralGenerator(effect);
effectGen.SetupParameters(random, model, creatureModels, minBudget, maxBudget);
effectDesc.effectType = effectGen.Generate();
// Adjust budgets
minBudget /= effectDesc.effectType.PowerLevel();
maxBudget /= effectDesc.effectType.PowerLevel();
if (minBudget > maxBudget)
{
double temp = minBudget;
minBudget = maxBudget;
maxBudget = temp;
}
// Always allow for default targetting (multiplier 1.0x)
if (maxBudget < 1.0)
{
maxBudget = 1.0;
}
TargetType targetType = TargetType.CREATURES;
SortedSet <TargetType> validTargets = CardEnums.GetValidFlags <TargetType>(effect);
SortedSet <TargettingType> allowableTargetting = new SortedSet <TargettingType>();
SortedSet <QualifierType> allowableQualifiers = new SortedSet <QualifierType>();
while (validTargets.Count > 0 && allowableTargetting.Count == 0)
{
targetType = ProceduralUtils.GetRandomValue(random, model, validTargets);
validTargets.Remove(targetType);
switch (effectDesc.effectType.GetAlignment())
{
case Alignment.POSITIVE:
if (positive)
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.POSITIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEUTRAL);
allowableQualifiers.UnionWith(ProceduralUtils.GetQualifiersByAlignment(Alignment.POSITIVE));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
else
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.NEGATIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEGATIVE);
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
break;
case Alignment.NEGATIVE:
if (positive)
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.NEGATIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.NEUTRAL);
allowableQualifiers.UnionWith(ProceduralUtils.GetQualifiersByAlignment(Alignment.NEGATIVE));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
else
{
allowableTargetting = ProceduralUtils.GetTargettingByAlignment(Alignment.POSITIVE);
allowableQualifiers = ProceduralUtils.GetQualifiersByAlignment(Alignment.POSITIVE);
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
if (allowableQualifiers.Count > 0)
{
allowableTargetting.UnionWith(ProceduralUtils.GetTargettingByAlignment(Alignment.NEUTRAL));
}
}
break;
default:
if (positive)
{
allowableTargetting = new SortedSet <TargettingType>((TargettingType[])Enum.GetValues(typeof(TargettingType)));
allowableQualifiers = new SortedSet <QualifierType>((QualifierType[])Enum.GetValues(typeof(QualifierType)));
allowableQualifiers.IntersectWith(CardEnums.GetValidFlags <QualifierType>(targetType));
}
else
{
allowableTargetting = new SortedSet <TargettingType>();
}
break;
}
allowableTargetting.IntersectWith(CardEnums.GetValidFlags <TargettingType>(targetType));
allowableTargetting.IntersectWith(CardEnums.GetValidFlags <TargettingType>(effectDesc.triggerCondition));
// Special case
// Up to can never be a downside because you can choose 0 targets
if (!positive)
{
allowableTargetting.Remove(TargettingType.UP_TO_TARGET);
allowableTargetting.Remove(TargettingType.UP_TO_TARGET_ALLY);
allowableTargetting.Remove(TargettingType.UP_TO_TARGET_ENEMY);
}
}
// Could not find any valid targetting to achieve the desired alignment
if (allowableTargetting.Count == 0)
{
SortedSet <TargetType> targets = CardEnums.GetValidFlags <TargetType>(effect);
Debug.Log("Wasn't able to generate targets for effect <" + effect.ToString() + ">");
return(false);
}
// Attempt to narrow down the targetting pool
SortedSet <TargettingType> targettingWithinBudget = new SortedSet <TargettingType>(allowableTargetting.Intersect(ProceduralUtils.GetTargettingWithinBudget(maxBudget)));
if (targettingWithinBudget.Count > 0)
{
allowableTargetting = targettingWithinBudget;
}
else
{
Debug.Log("Unable to narrow down targetting types for <" + effect.ToString() + ", " + targetType.ToString() + "> for budget " + maxBudget);
}
TargettingType targettingType = ProceduralUtils.GetRandomValue(random, model, allowableTargetting);
IProceduralTargettingGenerator targettingGen = ProceduralUtils.GetProceduralGenerator(targettingType);
targettingGen.SetupParameters(targetType, random, model, minBudget, maxBudget);
effectDesc.targettingType = targettingGen.Generate();
// Adjust budgets
minBudget /= effectDesc.targettingType.PowerLevel();
maxBudget /= effectDesc.targettingType.PowerLevel();
if (minBudget > maxBudget)
{
double temp = minBudget;
minBudget = maxBudget;
maxBudget = temp;
}
if (effectDesc.targettingType is IQualifiableTargettingDescription qualifiable)
{
// Generate a possible qualifier
// Attempt to narrow down the qualifier pool
SortedSet <QualifierType> qualifiersWithinBudget = new SortedSet <QualifierType>(allowableQualifiers.Intersect(ProceduralUtils.GetQualifiersWithinBudget(maxBudget)));
if (targettingWithinBudget.Count > 0)
{
allowableQualifiers = qualifiersWithinBudget;
}
else
{
Debug.Log("Unable to narrow down qualifier types for <" + effect.ToString() + ", " + targetType.ToString() + "> for budget " + maxBudget);
}
QualifierType qualifier = ProceduralUtils.GetRandomValue(random, model, allowableQualifiers);
if (qualifier != QualifierType.NONE)
{
IProceduralQualifierGenerator qualifierGen = ProceduralUtils.GetProceduralGenerator(qualifier);
qualifierGen.SetupParameters(random, model, minBudget, maxBudget);
qualifiable.qualifier = qualifierGen.Generate();
}
}
return(true);
}
public TargettingKeystrokeHandler()
{
m_targettingType = TargettingType.None;
m_lastTargetted = null;
}
public TargettingModeKeyboardHandler(TargettingType targettingType, IGameEngine engine, Map map, OnTargetSelect selectionAction, List<EffectivePoint> targetablePoints)
: this(targettingType, engine, map, targetablePoints)
{
m_action = selectionAction;
}
public void EnableTargetting(TargettingType type) => TargetView.EnableTargetting(type);
protected ITargettingDescription(TargetType target, TargettingType targetting)
{
targetType = target;
targettingType = targetting;
}
public UniqueEffectPart(TargettingType target, UniqueEffects effect, int chance = 100) : base(target, chance)
{
this.effect = effect;
}
private bool TargetAttack(out Point target, TargettingType targetType, double spreadAngle, char confirmChar, CreatureFOV currentFOV)
{
return TargetAttack(out target, -1, targetType, spreadAngle, confirmChar, currentFOV);
}
