Inheritance diagram for ActRanged:

Public Member Functions
override string	GetText (string str="")

override bool	CanPerform ()

override bool	Perform ()

Public Member Functions inherited from ActThrow
override string	GetText (string str="")

override bool	CanPerform ()

override bool	Perform ()

Public Member Functions inherited from Act
virtual CursorInfo	GetCursorIcon (Card c)

virtual MultiSprite	GetStateIcon ()

override Sprite	GetSprite ()

virtual bool	ShowMouseHint (Card c)

virtual bool	IsValidTC (Card c)

virtual string	GetHintText (string str="")

virtual string	GetText (string str="")

virtual string	GetTextSmall (Card c)

bool	IsTargetHostileParty ()

virtual Color	GetActPlanColor ()

virtual bool	Perform ()

virtual bool	CanPerform ()

bool	Perform (Chara _cc, Card _tc=null, Point _tp=null)

bool	CanPerform (Chara _cc, Card _tc=null, Point _tp=null)

virtual bool	IsToolValid ()

new void	SetImage (Image image)

virtual void	OnMarkMapHighlights ()

virtual bool	ShouldMapHighlight (Point p)

Public Member Functions inherited from Element
virtual SourceElement.Row	GetSource ()

virtual int	GetSourcePotential (int v)

virtual Sprite	GetSprite ()

int	GetMaterialSourceValue (Thing t, int v)

virtual long	GetSourceValue (long v, int lv, SourceValueType type)

virtual Sprite	GetIcon (string suffix="")

bool	IsActive (Card c)

int	SortVal (bool charaSheet=false)

virtual bool	CanLink (ElementContainer owner)

bool	HasTag (string tag)

void	SetImage (Image i)

virtual string	GetDetail ()

bool	IsFactionElement (Chara c)

Element	GetParent (Card c)

void	WriteNote (UINote n, ElementContainer owner=null, Action< UINote > onWriteNote=null)

void	WriteNoteWithRef (UINote n, ElementContainer owner, Action< UINote > onWriteNote, Element refEle)

void	_WriteNote (UINote n, Chara c, Act act)

void	AddHeaderAbility (UINote n)

void	_WriteNote (UINote n, ElementContainer owner, Action< UINote > onWriteNote, bool isRef, bool addHeader=true)

void	AddEncNote (UINote n, Card Card, ElementContainer.NoteMode mode=ElementContainer.NoteMode.Default, Func< Element, string, string > funcText=null, Action< UINote, Element > onAddNote=null)

virtual void	OnWriteNote (UINote n, ElementContainer owner)

virtual void	OnChangeValue ()

void	CheckLevelBonus (ElementContainer owner, UINote n=null)

int	GetSortVal (UIList.SortMode m)

virtual Act.Cost	GetCost (Chara c)

virtual int	GetPower (Card c)

virtual void	SetTextValue (UIText text)

virtual bool	IsPurchaseFeatReqMet (ElementContainer owner, int lv=-1)

virtual void	WritePurchaseReq (UINote n, int lv=1)

Static Public Member Functions
static bool	TryReload (Thing weapon, Thing ammo=null)

Static Public Member Functions inherited from ActThrow
static bool	CanThrow (Chara c, Thing t, Card target, Point p=null)

static EffectIRenderer	Throw (Card c, Point p, Thing t, ThrowMethod method=ThrowMethod.Default, float failChance=0f)

static EffectIRenderer	Throw (Card c, Point p, Card target, Thing t, ThrowMethod method=ThrowMethod.Default)

Static Public Member Functions inherited from Act
static void	SetReference (Chara _cc, Card _tc=null, Point _tp=null)

static void	SetTool (Thing t)

Static Public Member Functions inherited from Element
static string	GetName (string alias)

static SourceElement.Row	Get (int id)

static Dictionary< int, int >	GetElementMap (int[] list)

static Dictionary< int, int >	GetElementMap (int[] list, Dictionary< int, int > map)

static SourceElement.Row	GetRandomElement (int lv=1, bool useWeight=true)

static Element	Create (int id, int v=0)

static Element	Create (string id, int v=1)

static int	GetId (string alias)

static int	GetResistLv (int v)

static int	GetResistDamage (int dmg, int v, int power=0)

Static Public Member Functions inherited from EClass
static int	rndSeed (int a, int seed)

static int	rnd (long a)

static int	rnd (int a)

static int	curve (int a, int start, int step, int rate=75)

static int	rndHalf (int a)

static float	rndf (float a)

static int	rndSqrt (int a)

static void	Wait (float a, Card c)

static void	Wait (float a, Point p)

static int	Bigger (int a, int b)

static int	Smaller (int a, int b)

Properties
bool	IsReload `[get]`

override CursorInfo	CursorIcon `[get]`

override int	PerformDistance `[get]`

override string	Name `[get]`

Properties inherited from ActThrow
override bool	CanPressRepeat `[get]`

override TargetType	TargetType `[get]`

override int	PerformDistance `[get]`

Properties inherited from Act
override bool	ShowPotential `[get]`

override bool	UsePotential `[get]`

override bool	ShowRelativeAttribute `[get]`

virtual CursorInfo	CursorIcon `[get]`

virtual string	ID `[get]`

virtual bool	IsAct `[get]`

virtual bool	WillEndTurn `[get]`

virtual bool	CloseLayers `[get]`

virtual int	LeftHand `[get]`

virtual int	RightHand `[get]`

virtual int	ElementPowerMod `[get]`

virtual bool	ShowMapHighlight `[get]`

virtual bool	ShowMapHighlightBlock `[get]`

virtual bool	PickHeldOnStart `[get]`

virtual bool	DropHeldOnStart `[get]`

virtual bool	CanPressRepeat `[get]`

virtual bool	CanAutofire `[get]`

virtual bool	ResetAxis `[get]`

virtual bool	RequireTool `[get]`

virtual bool	IsHostileAct `[get]`

virtual bool	HideRightInfo `[get]`

virtual bool	HaveLongPressAction `[get]`

virtual float	Radius `[get]`

virtual int	PerformDistance `[get]`

virtual int	MaxRadius `[get]`

virtual TargetType	TargetType `[get]`

virtual bool	LocalAct `[get]`

virtual bool	CanRapidFire `[get]`

virtual float	RapidDelay `[get]`

virtual bool	ShowAuto `[get]`

virtual bool	IsCrime `[get]`

Properties inherited from Element
SourceElement.Row	source `[get]`

virtual int	DisplayValue `[get]`

virtual int	MinValue `[get]`

int	Value `[get]`

int	ValueWithoutLink `[get]`

virtual int	MinPotential `[get]`

int	Potential `[get]`

virtual bool	CanGainExp `[get]`

bool	IsFlag `[get]`

virtual string	Name `[get]`

virtual string	FullName `[get]`

virtual int	ExpToNext `[get]`

virtual bool	UseExpMod `[get]`

virtual int	CostTrain `[get]`

virtual int	CostLearn `[get]`

virtual bool	ShowXP `[get]`

virtual bool	ShowMsgOnValueChanged `[get]`

virtual bool	ShowValue `[get]`

virtual bool	ShowPotential `[get]`

virtual bool	UsePotential `[get]`

virtual bool	PotentialAsStock `[get]`

virtual bool	ShowRelativeAttribute `[get]`

virtual bool	ShowBonuses `[get]`

virtual string	ShortName `[get]`

bool	IsGlobalElement `[get]`

bool	IsFactionWideElement `[get]`

bool	IsPartyWideElement `[get]`

virtual bool	ShowEncNumber `[get]`

bool	IsTrait `[get]`

bool	IsFoodTrait `[get]`

bool	IsFoodTraitMain `[get]`

bool	IsMainAttribute `[get]`

Act	act `[get]`

Properties inherited from EClass
static Game	game `[get]`

static bool	AdvMode `[get]`

static Player	player `[get]`

static Chara	pc `[get]`

static UI	ui `[get]`

static Map	_map `[get]`

static Zone	_zone `[get]`

static FactionBranch	Branch `[get]`

static FactionBranch	BranchOrHomeBranch `[get]`

static Faction	Home `[get]`

static Faction	Wilds `[get]`

static Scene	scene `[get]`

static BaseGameScreen	screen `[get]`

static GameSetting	setting `[get]`

static GameData	gamedata `[get]`

static ColorProfile	Colors `[get]`

static World	world `[get]`

static SourceManager	sources `[get]`

static SourceManager	editorSources `[get]`

static SoundManager	Sound `[get]`

static CoreDebug	debug `[get]`

Additional Inherited Members
Public Types inherited from Act
enum	CostType { None , MP , SP }

Public Attributes inherited from ActThrow
Thing	target

Chara	pcTarget

Public Attributes inherited from Element
SourceElement.Row	_source

int	id

int	vBase

int	vExp

int	vPotential

int	vTempPotential

int	vLink

int	vSource

int	vSourcePotential

ElementContainer	owner

Static Public Attributes inherited from Act
static Chara	CC

static Card	TC

static Point	TP = new Point()

static Thing	TOOL

static int	powerMod = 100

static bool	forcePt

static Act	CurrentAct

Static Public Attributes inherited from Element
const int	Div = 5

static Element	Void = new Element()

static int[]	List_MainAttributes = new int[9] { 70, 72, 71, 77, 74, 75, 76, 73, 79 }

static int[]	List_MainAttributesMajor = new int[8] { 70, 72, 71, 77, 74, 75, 76, 73 }

static int[]	List_Body = new int[4] { 70, 72, 71, 77 }

static int[]	List_Mind = new int[4] { 74, 75, 76, 73 }

static List< SourceElement.Row >	ListElements = new List<SourceElement.Row>()

static List< SourceElement.Row >	ListAttackElements = new List<SourceElement.Row>()

Static Public Attributes inherited from EClass
static Core	core

Detailed Description

Definition at line 5 of file ActRanged.cs.

Member Function Documentation

◆ CanPerform()

override bool ActRanged.CanPerform ( )

inlinevirtual

Reimplemented from Act.

Definition at line 44 of file ActRanged.cs.

    {
        if (Act.CC.isRestrained)
        {
            return false;
        }
        if (Act.CC.HasCondition<ConReload>())
        {
            return false;
        }
        if (Act.TC == null)
        {
            return Act.CC.CanSeeLos(Act.TP);
        }
        if (!Act.TC.IsAliveInCurrentZone)
        {
            return false;
        }
        return Act.CC.CanSeeLos(Act.TC.pos);
    }

References Chara.CanSeeLos(), Act.CC, Chara.HasCondition(), Card.IsAliveInCurrentZone, Card.isRestrained, Card.pos, Act.TC, and Act.TP.

Referenced by AM_Adv._OnUpdateInput(), and AI_PracticeDummy.CreateProgress().

◆ GetText()

override string ActRanged.GetText ( string str = "" )

inlinevirtual

Reimplemented from Act.

Definition at line 35 of file ActRanged.cs.

    {
        if (!IsReload)
        {
            return base.GetText(str);
        }
        return Name;
    }

References IsReload, and Name.

◆ Perform()

override bool ActRanged.Perform ( )

inlinevirtual

Reimplemented from Act.

Definition at line 65 of file ActRanged.cs.

    {
        if (Act.TC == null)
        {
            Act.TC = Act.TP.FindAttackTarget();
        }
        if (Act.TC != null)
        {
            Act.TP.Set(Act.TC.pos);
        }
        if (Act.TC != null && Act.CC == EClass.pc && !(Act.CC.ai is AI_PracticeDummy) && (Act.TC.trait is TraitTrainingDummy || Act.TC.IsRestrainedResident))
        {
            Act.CC.SetAI(new AI_PracticeDummy
            {
                target = Act.TC,
                range = true
            });
            return true;
        }
        Act.CC.renderer.NextFrame();
        if (!Act.CC.IsPC)
        {
            Act.CC.TryEquipRanged();
        }
        Thing weapon = Act.CC.ranged;
        if (weapon != null && Act.CC.IsPC && Act.CC.body.IsTooHeavyToEquip(weapon))
        {
            Msg.Say("tooHeavyToEquip", weapon);
            return false;
        }
        if (weapon == null || !weapon.CanAutoFire(Act.CC, Act.TC))
        {
            return false;
        }
        TraitToolRange traitRange = weapon.trait as TraitToolRange;
        bool flag = weapon.trait is TraitToolRangeCane;
        GameSetting.EffectData effectData = EClass.setting.effect.guns.TryGetValue(weapon.id) ?? EClass.setting.effect.guns[flag ? "cane" : ((weapon.trait is TraitToolRangeGun) ? "gun" : "bow")];
        bool hasHit = false;
        int numFire = effectData.num;
        int numFireWithoutDamageLoss = numFire;
        int num = GetWeaponEnc(602);
        int drill = GetWeaponEnc(606);
        int scatter = GetWeaponEnc(607);
        int chaser = GetWeaponEnc(620);
        if (num > 0)
        {
            numFire += Mathf.Min(num / 10 + ((num % 10 > EClass.rnd(10)) ? 1 : 0), 10);
            numFireWithoutDamageLoss += num / 100 + ((num % 100 > EClass.rnd(100)) ? 1 : 0);
        }
        numFire += Act.CC.Evalue(1652);
        int num2 = numFire;
        int num3 = 1 + weapon.material.hardness / 30 + EClass.rnd(3);
        int num4 = weapon.Evalue(604);
        if (num4 > 0)
        {
            for (int i = 0; i < numFire; i++)
            {
                if (Mathf.Sqrt(num4) * 5f + 10f > (float)EClass.rnd(100))
                {
                    num2--;
                }
            }
            num3 = Mathf.Max(1, num3 * 100 / (100 + num4 * 5));
        }
        string missSound = ((weapon.trait is TraitToolRangeGun) ? "miss_bullet" : "miss_arrow");
        if (flag)
        {
            foreach (Element item in weapon.elements.dict.Values.Where((Element e) => e.source.categorySub == "eleAttack"))
            {
                num3 += item.source.LV / 15;
            }
            if (Act.CC.IsPC)
            {
                if (Act.CC.mana.value < num3)
                {
                    if (!Act.CC.ai.IsNoGoal)
                    {
                        return false;
                    }
                    if (!Dialog.warned && !EClass.debug.godMode)
                    {
                        ActPlan.warning = true;
                        Dialog.TryWarnMana(delegate
                        {
                            if (Perform())
                            {
                                EClass.player.EndTurn();
                            }
                        });
                        return false;
                    }
                }
                EClass.ui.CloseLayers();
            }
        }
        else
        {
            if (IsReload)
            {
                return TryReload(weapon);
            }
            if (weapon.c_ammo <= 0)
            {
                if (!TryReload(weapon))
                {
                    if (Act.CC.IsPC)
                    {
                        EInput.Consume();
                    }
                    return false;
                }
                if (Act.CC.HasCondition<ConReload>())
                {
                    return true;
                }
            }
            if (Act.CC.HasCondition<ConFear>())
            {
                Act.CC.Say("fear", Act.CC, Act.TC);
                if (Act.CC.IsPC)
                {
                    EInput.Consume(consumeAxis: true);
                }
                return true;
            }
        }
        Act.TC?.Chara?.RequestProtection(Act.CC, delegate(Chara c)
        {
            Act.TC = c;
        });
        Act.CC.LookAt(Act.TP);
        int index = 0;
        Point orgTP = Act.TP.Copy();
        List<Point> points = new List<Point>();
        if (drill > 0)
        {
            points = EClass._map.ListPointsInLine(Act.CC.pos, Act.TP, drill / 10 + ((drill % 10 > EClass.rnd(10)) ? 1 : 0) + 1);
        }
        else if (scatter > 0)
        {
            Act.TP.ForeachNeighbor(delegate(Point _p)
            {
                points.Add(_p.Copy());
            });
        }
        if (EClass.core.config.game.waitOnRange)
        {
            EClass.Wait(0.25f, Act.CC);
        }
        Shoot(Act.TC, Act.TP, subAttack: false);
        if (points.Count > 0)
        {
            Point obj = Act.TP.Copy();
            foreach (Point item2 in points)
            {
                if (item2.Equals(obj))
                {
                    continue;
                }
                Chara firstChara = item2.FirstChara;
                if (firstChara != null && !firstChara.IsHostile(Act.CC))
                {
                    continue;
                }
                if (scatter > 0)
                {
                    if (EClass.rnd(EClass.rnd(100) + 1) > scatter)
                    {
                        continue;
                    }
                }
                else if (firstChara == null)
                {
                    continue;
                }
                Shoot(item2.FirstChara ?? item2.FindThing<TraitTrainingDummy>()?.owner, item2, subAttack: true);
            }
        }
        if (!(weapon.trait is TraitToolRangeCane))
        {
            weapon.c_ammo -= num2;
            if (weapon.ammoData != null)
            {
                weapon.ammoData.Num = weapon.c_ammo;
            }
            if (weapon.c_ammo <= 0)
            {
                weapon.c_ammo = 0;
                weapon.ammoData = null;
            }
        }
        if (Act.CC.IsPC)
        {
            LayerInventory.SetDirty(weapon);
        }
        if (Act.TC != null && !hasHit)
        {
            Act.CC.PlaySound(missSound);
        }
        if (!Act.CC.isDead)
        {
            if (EClass.rnd(2) == 0)
            {
                Act.CC.RemoveCondition<ConInvisibility>();
            }
            if (weapon.trait is TraitToolRangeCane)
            {
                Act.CC.mana.Mod(-num3 * numFire);
            }
        }
        return true;
        int GetWeaponEnc(int ele)
        {
            return weapon.Evalue(ele) + (Act.CC.IsPCFactionOrMinion ? EClass.pc.faction.charaElements.Value(ele) : 0);
        }
        void Prepare()
        {
            AttackProcess.Current.Prepare(Act.CC, weapon, Act.TC, Act.TP);
            AttackProcess.Current.numFire = numFire;
            AttackProcess.Current.numFireWithoutDamageLoss = numFireWithoutDamageLoss;
            AttackProcess.Current.posRangedAnime = Act.TP.Copy();
            AttackProcess.Current.ignoreAnime = index > 1;
            AttackProcess.Current.ignoreAttackSound = false;
            if (drill > 0 && points.Count > 0)
            {
                AttackProcess.Current.posRangedAnime = points.LastItem();
            }
            else if (scatter > 0)
            {
                AttackProcess.Current.ignoreAnime = false;
                AttackProcess.Current.ignoreAttackSound = index > 1;
            }
        }
        void Shoot(Card _tc, Point _tp, bool subAttack)
        {
            float dmgMulti = 1f;
            index++;
            Act.TC = _tc;
            Act.TP = _tp;
            CellEffect effect = Act.TP.cell.effect;
            if (effect != null && effect.id == 6 && EClass.rnd(2) == 0)
            {
                Prepare();
                AttackProcess.Current.PlayRangedAnime(numFire);
                Act.CC.PlaySound(missSound);
                Act.CC.Say("abMistOfDarkness_miss", Act.CC);
            }
            else
            {
                if (scatter > 0)
                {
                    dmgMulti = Mathf.Clamp(1.2f - 0.2f * (float)Act.CC.Dist(Act.TP) - (Act.TP.Equals(orgTP) ? 0f : 0.4f), 0.2f, 1f);
                }
                for (int j = 0; j < numFire; j++)
                {
                    Act.TC = _tc;
                    Card tC = Act.TC;
                    Chara cC = Act.CC;
                    Point point = Act.TP.Copy();
                    if (traitRange.ChanceMissAim > 0 && EClass.rnd(traitRange.ChanceMissAim) == 0)
                    {
                        Act.TP.Set(Act.TP.GetRandomNeighbor());
                    }
                    Prepare();
                    int num5 = 0;
                    if (weapon.trait is TraitToolRangeGunEnergy && Act.TC != null && Act.TC.isChara && Act.TC.HasElement(383))
                    {
                        if (weapon.id == "gun_laser")
                        {
                            num5 = 50;
                        }
                        num5 += Mathf.Max(25 * Act.TC.PER / Mathf.Max(1, Act.CC.PER), 50);
                        if (Act.CC.IsPowerful)
                        {
                            num5 /= 2;
                        }
                    }
                    if (num5 > EClass.rnd(100))
                    {
                        List<Chara> list = Act.TC.pos.ListCharasInRadius(Act.TC.Chara, Act.TC.GetSightRadius(), (Chara c) => c.IsHostile(Act.TC.Chara));
                        Chara chara = ((list.Count > 0) ? list.RandomItem() : Act.CC?.Chara);
                        Act.TC.Say((Act.TC.isChara && Act.TC.Chara.IsHostile()) ? "attack_reflect_enemy" : "attack_reflect");
                        Act.TC.PlaySound("attack_gun_laser_parry");
                        AttackProcess.Current.PlayRangedAnime(numFire, 0.1f);
                        AttackProcess.Current.CC = Act.TC?.Chara;
                        AttackProcess.Current.TC = chara;
                        AttackProcess.Current.TP.Set(chara.pos);
                        AttackProcess.Current.posRangedAnime = chara.pos;
                        AttackProcess.Current.Perform(j, hasHit, chara.IsPCFactionOrMinion ? 0.1f : 2.5f, maxRoll: true, subAttack: true);
                    }
                    else if (AttackProcess.Current.Perform(j, hasHit, dmgMulti, maxRoll: false, subAttack))
                    {
                        hasHit = true;
                    }
                    else if (chaser > 0)
                    {
                        for (int k = 0; k < 10; k++)
                        {
                            if (chaser > EClass.rnd(4 + (int)Mathf.Pow(4f, k + 2 + j)))
                            {
                                Act.CC.Say(Act.CC.IsHostile() ? "attack_chaser_enemy" : "attack_chaser");
                                if (AttackProcess.Current.Perform(j, hasHit, dmgMulti, maxRoll: false, subAttack))
                                {
                                    hasHit = true;
                                    break;
                                }
                            }
                        }
                    }
                    switch (traitRange.GroundHitEffect)
                    {
                    case TraitToolRange.HitEffect.Rocket:
                        ActEffect.ProcAt(EffectId.Rocket, AttackProcess.Current.GetRocketPower(), BlessedState.Normal, Act.CC, null, Act.TP, isNeg: true, new ActRef
                        {
                            origin = Act.CC.Chara,
                            refThing = weapon,
                            aliasEle = "eleImpact"
                        });
                        break;
                    case TraitToolRange.HitEffect.Gravity:
                        ActEffect.ProcAt(EffectId.GravityGun, AttackProcess.Current.GetRocketPower() / 2, BlessedState.Normal, Act.CC, null, Act.TP, isNeg: true, new ActRef
                        {
                            origin = Act.CC.Chara,
                            refThing = weapon,
                            aliasEle = "eleImpact",
                            refVal = j
                        });
                        break;
                    }
                    Act.TC = tC;
                    Act.CC = cC;
                    Act.TP.Set(point);
                    if (traitRange.GroundHitEffect == TraitToolRange.HitEffect.None && (Act.TC == null || !Act.TC.IsAliveInCurrentZone))
                    {
                        break;
                    }
                }
                if (Act.TC != null)
                {
                    Act.CC.DoHostileAction(Act.TC);
                }
            }
        }
    }

References EClass._map, Chara.ai, Chara.body, Act.CC, Point.cell, TraitToolRange.ChanceMissAim, Card.Chara, Faction.charaElements, Core.config, EInput.Consume(), Point.Copy(), EClass.core, AttackProcess.Current, EClass.debug, Card.Dist(), Chara.DoHostileAction(), Cell.effect, GameSetting.effect, Player.EndTurn(), Point.Equals(), Card.Evalue(), Chara.faction, Point.FindAttackTarget(), Point.FindThing(), Point.FirstChara, Point.ForeachNeighbor(), CoreConfig.game, Point.GetRandomNeighbor(), AttackProcess.GetRocketPower(), Card.GetSightRadius(), CoreDebug.godMode, TraitToolRange.GroundHitEffect, GameSetting.EffectSetting.guns, Chara.HasCondition(), Card.HasElement(), CellEffect.id, Card.IsAliveInCurrentZone, Card.isChara, Chara.isDead, Chara.IsHostile(), AIAct.IsNoGoal, Chara.IsPC, Card.IsPCFactionOrMinion, Card.IsPowerful, IsReload, Card.IsRestrainedResident, CharaBody.IsTooHeavyToEquip(), item, Point.ListCharasInRadius(), Map.ListPointsInLine(), Chara.LookAt(), Chara.mana, Stats.Mod(), CardRenderer.NextFrame(), GameSetting.EffectData.num, Trait.owner, EClass.pc, Card.PER, Perform(), AttackProcess.Perform(), EClass.player, AttackProcess.PlayRangedAnime(), Card.PlaySound(), Card.pos, AttackProcess.Prepare(), ActEffect.ProcAt(), Chara.ranged, Card.renderer, Chara.RequestProtection(), EClass.rnd(), Msg.Say(), Card.Say(), Point.Set(), Chara.SetAI(), LayerInventory.SetDirty(), EClass.setting, ActThrow.target, Act.TC, Act.TP, AttackProcess.TP, Card.trait, Chara.TryEquipRanged(), UDictionary< TKey, TValue >.TryGetValue(), TryReload(), Dialog.TryWarnMana(), EClass.ui, ElementContainer.Value(), Stats.value, EClass.Wait(), CoreConfig.GameConfig.waitOnRange, Dialog.warned, and weapon.

Referenced by AM_Adv._OnUpdateInput(), AI_PracticeDummy.CreateProgress(), TraitTrainingDummy.IdleUse(), Perform(), GoalAutoCombat.TryUseRanged(), and GoalCombat.TryUseRanged().

◆ TryReload()

static bool ActRanged.TryReload	(	Thing	weapon,
		Thing	ammo = `null`
	)

inlinestatic

Definition at line 410 of file ActRanged.cs.

    {
        TraitToolRange traitToolRange = weapon.trait as TraitToolRange;
        if (Act.CC.IsPC)
        {
            LayerInventory.SetDirty(weapon);
        }
        if (weapon.ammoData != null)
        {
            if (weapon.ammoData.Num > 0)
            {
                Act.CC.Pick(weapon.ammoData);
            }
            weapon.ammoData = null;
        }
        int num = 0;
        if (ammo == null)
        {
            ammo = Act.CC.FindAmmo(weapon);
        }
        if (ammo == null)
        {
            if (Act.CC.IsPC && !traitToolRange.AutoRefillAmmo)
            {
                if (!weapon.IsMeleeWithAmmo)
                {
                    Msg.Say("noAmmo", weapon);
                }
                return false;
            }
            num = traitToolRange.MaxAmmo;
        }
        else
        {
            num = Mathf.Min(ammo.Num, traitToolRange.MaxAmmo);
            Thing thing = ammo.Split(num);
            Act.CC.Say("takeAmmo", thing);
            if (thing.GetRootCard() == Act.CC)
            {
                thing.parent.RemoveCard(thing);
            }
            weapon.ammoData = thing;
        }
        weapon.c_ammo = num;
        int reloadTurn = traitToolRange.ReloadTurn;
        reloadTurn = reloadTurn * 100 / (100 + Act.CC.Evalue(1652) * 100);
        if (traitToolRange.NeedReload && reloadTurn > 0)
        {
            Act.CC.AddCondition<ConReload>(reloadTurn * 10);
        }
        return true;
    }

References Chara.AddCondition(), ammo, TraitToolRange.AutoRefillAmmo, Act.CC, Card.Evalue(), Chara.FindAmmo(), Card.GetRootCard(), Chara.IsPC, TraitToolRange.MaxAmmo, TraitToolRange.NeedReload, Card.parent, Chara.Pick(), TraitToolRange.ReloadTurn, ICardParent.RemoveCard(), Msg.Say(), Card.Say(), LayerInventory.SetDirty(), and weapon.

Referenced by ActMelee.Attack(), TraitAmmo.OnUse(), and Perform().

Property Documentation

◆ CursorIcon

override CursorInfo ActRanged.CursorIcon

get

Definition at line 19 of file ActRanged.cs.

◆ IsReload

bool ActRanged.IsReload

get

Definition at line 7 of file ActRanged.cs.

    {
        get
        {
            if (Act.CC.IsPC && Act.TC == Act.CC && !Act.CC.HasCondition<ConReload>() && EClass.player.currentHotItem.Thing != null)
            {
                return !(EClass.player.currentHotItem.Thing.trait is TraitToolRangeCane);
            }
            return false;
        }
    }

Referenced by GetText(), and Perform().

◆ Name

override string ActRanged.Name

get

Definition at line 23 of file ActRanged.cs.

    {
        get
        {
            if (!IsReload)
            {
                return base.Name;
            }
            return "ActReload".lang();
        }
    }

Referenced by GetText().

◆ PerformDistance

override int ActRanged.PerformDistance

get

Definition at line 21 of file ActRanged.cs.

The documentation for this class was generated from the following file:

Elin/ActRanged.cs

Public Member Functions

Static Public Member Functions

Properties

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ CanPerform()

◆ GetText()

◆ Perform()

◆ TryReload()

Property Documentation

◆ CursorIcon

◆ IsReload

◆ Name

◆ PerformDistance