ActMelee Class Reference

Inheritance diagram for ActMelee:

Public Member Functions
bool	HideHint (Card c)
override string	GetHintText (string str="")
override string	GetTextSmall (Card c)
override CursorInfo	GetCursorIcon (Card c)
override bool	ShowMouseHint (Card c)
override bool	CanPerform ()
override bool	Perform ()
bool	Attack (float dmgMulti=1f)
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 int	GetSourceValue (int 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)

Properties
virtual bool	AllowCounter [get]
virtual bool	AllowParry [get]
virtual bool	ShouldRollMax [get]
virtual float	BaseDmgMTP [get]
virtual bool	UseWeaponDist [get]
override int	PerformDistance [get]
override bool	ResetAxis [get]
override bool	CanPressRepeat [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 }
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)
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 4 of file ActMelee.cs.

Member Function Documentation

Attack()

bool ActMelee.Attack ( float  dmgMulti = 1f )

inline

Definition at line 105 of file ActMelee.cs.

    {
        Act.CC.combatCount = 10;
        Act.CC.LookAt(Act.TC);
        Act.CC.renderer.NextFrame();
        if (Act.CC.HasCondition<ConFear>())
        {
            Act.CC.Say("fear", Act.CC, Act.TC);
            if (Act.CC.IsPC)
            {
                EInput.Consume(consumeAxis: true);
            }
            return true;
        }
        Act.CC.renderer.PlayAnime(AnimeID.Attack, Act.TC);
        bool intercepted = (Act.TC?.Chara?.RequestProtection(Act.CC, delegate(Chara c)
        {
            Act.TC = c;
        })).GetValueOrDefault();
        Act.TP.Set(Act.TC.pos);
        CellEffect effect = Act.TP.cell.effect;
        if (effect != null && effect.id == 6 && EClass.rnd(2) == 0)
        {
            Act.CC.PlaySound("miss");
            Act.CC.Say("abMistOfDarkness_miss", Act.CC);
            return true;
        }
        bool hasHit = false;
        bool hasMissed = false;
        bool usedWeapon = false;
        bool usedTalisman = false;
        bool maxRoll = ShouldRollMax;
        int count = 0;
        int dist = Act.CC.Dist(Act.TC);
        Point orgPos = Act.TC.pos.Copy();
        Chara cC = Act.CC;
        Card orgTC = Act.TC;
        bool safety = Act.CC.HasElement(486) && Act.CC.IsPCFactionOrMinion;
        bool parried = false;
        foreach (BodySlot slot in Act.CC.body.slots)
        {
            _Attack(slot);
            if (parried)
            {
                break;
            }
        }
        if (!usedWeapon)
        {
            _Attack(null);
        }
        if (EClass.core.config.game.waitOnMelee)
        {
            EClass.Wait(0.25f, Act.CC);
        }
        if (EClass.rnd(2) == 0)
        {
            Act.CC.RemoveCondition<ConInvisibility>();
        }
        if (orgTC.isChara && orgTC.ExistsOnMap && orgTC != cC && !orgTC.IsRestrainedResident && !orgTC.IsDisabled && ACT.Melee.CanPerform(orgTC.Chara, cC) && (!orgTC.IsPCFactionOrMinion || !EClass._zone.isPeace))
        {
            if (parried)
            {
                new ActMeleeParry().Perform(orgTC.Chara, cC);
            }
            else if (AllowCounter && hasMissed && !cC.HasElement(439) && orgTC.HasElement(380))
            {
                orgTC.Say((orgTC.isChara && orgTC.Chara.IsHostile()) ? "counter_enemy" : "counter");
                new ActMeleeCounter().Perform(orgTC.Chara, cC);
            }
        }
        Act.TC = orgTC;
        Act.CC = cC;
        if (!hasHit)
        {
            Act.CC.PlaySound("miss");
        }
        return true;
        void _Attack(BodySlot slot)
        {
            Act.TC = orgTC;
            Act.TP = orgPos;
            Thing w;
            int splash;
            int chaser;
            int flurry;
            int frustration;
            int feint;
            int knockback;
            int mod_talisman;
            if (Act.TC != null && Act.TC.IsAliveInCurrentZone)
            {
                w = null;
                if (slot != null)
                {
                    if (slot.thing == null || slot.elementId != 35 || slot.thing.source.offense.Length < 2)
                    {
                        return;
                    }
                    w = slot.thing;
                }
                int num = 1 + Mathf.Max(Act.CC.Evalue(666), (w != null) ? w.Evalue(666) : 0);
                if (!UseWeaponDist || dist <= 1 || dist <= num || intercepted)
                {
                    int num2 = GetWeaponEnc(606, addSelfEnc: false);
                    int scatter = GetWeaponEnc(607, addSelfEnc: false);
                    splash = GetWeaponEnc(608, addSelfEnc: true);
                    chaser = GetWeaponEnc(620, addSelfEnc: true);
                    flurry = GetWeaponEnc(621, addSelfEnc: true);
                    frustration = GetWeaponEnc(624, addSelfEnc: true);
                    int num3 = GetWeaponEnc(622, addSelfEnc: true);
                    feint = GetWeaponEnc(623, addSelfEnc: true);
                    knockback = Act.CC.Evalue(603);
                    mod_talisman = GetWeaponEnc(609, addSelfEnc: true);
                    List<Point> list2 = EClass._map.ListPointsInLine(Act.CC.pos, Act.TC.pos, num2 / 10 + ((num2 % 10 > EClass.rnd(10)) ? 1 : 0) + 1);
                    if (w != null)
                    {
                        if (safety)
                        {
                            if (!w.HasElement(486))
                            {
                                return;
                            }
                            num2 = (scatter = (splash = (num3 = 0)));
                        }
                        usedWeapon = true;
                        if (w.IsMeleeWithAmmo && Act.CC.IsPC && w.c_ammo <= 0 && !Act.CC.HasCondition<ConReload>())
                        {
                            ActRanged.TryReload(w);
                        }
                    }
                    AttackWithFlurry(Act.TC, Act.TP, 1f, subAttack: false);
                    if (!parried)
                    {
                        if (num2 > 0)
                        {
                            foreach (Point item in list2)
                            {
                                if (!item.Equals(orgPos))
                                {
                                    Chara firstChara = item.FirstChara;
                                    if (firstChara != null && firstChara.IsHostile(Act.CC))
                                    {
                                        AttackWithFlurry(firstChara, item, 1f, subAttack: false);
                                    }
                                }
                            }
                        }
                        else if (scatter > 0)
                        {
                            Act.TP.ForeachNeighbor(delegate(Point p)
                            {
                                if (!p.Equals(orgPos))
                                {
                                    Chara firstChara2 = p.FirstChara;
                                    if (firstChara2 != null && firstChara2.IsHostile(Act.CC))
                                    {
                                        AttackWithFlurry(firstChara2, p, Mathf.Min(0.5f + 0.05f * Mathf.Sqrt(scatter), 1f + 0.01f * Mathf.Sqrt(scatter)), subAttack: true);
                                    }
                                }
                            });
                        }
                        else if (num3 > 0)
                        {
                            List<Point> list = new List<Point>();
                            Act.TP.ForeachNeighbor(delegate(Point p)
                            {
                                if (!p.Equals(Act.TP))
                                {
                                    list.Add(p.Copy());
                                }
                            });
                            list.Shuffle();
                            int num4 = 0;
                            for (int i = 0; i < 9 && num3 > EClass.rnd(10 + (int)Mathf.Pow(3f, i + 2)); i++)
                            {
                                num4++;
                            }
                            foreach (Point item2 in list)
                            {
                                foreach (Card item3 in item2.ListCards().Copy())
                                {
                                    if (num4 <= 0 || !Act.CC.IsAliveInCurrentZone)
                                    {
                                        break;
                                    }
                                    if (item3.trait.CanBeAttacked || (item3.isChara && item3.Chara.IsHostile(Act.CC)))
                                    {
                                        AttackWithFlurry(item3, item2, 1f, subAttack: true);
                                        if (parried)
                                        {
                                            break;
                                        }
                                        num4--;
                                    }
                                }
                            }
                        }
                    }
                    count++;
                }
            }
            void Attack(Card _tc, Point _tp, float mtp, bool subAttack)
            {
                Act.TC = _tc;
                Act.TP = _tp;
                AttackProcess.Current.Prepare(Act.CC, w, Act.TC, Act.TP, count);
                if (AllowParry && !Act.TC.IsDisabled && !Act.TC.IsRestrainedResident)
                {
                    int num5 = Act.TC.Evalue(437);
                    if (num5 > 0 && !Act.CC.HasElement(439))
                    {
                        int num6 = EClass.curve(5 + num5 / 3, 10, 3, 70);
                        int ele2 = 123;
                        int num7 = Act.TC.Evalue(ele2);
                        if (Act.TC.isChara)
                        {
                            foreach (BodySlot slot2 in Act.TC.Chara.body.slots)
                            {
                                if (slot2.thing != null && slot2.thing.HasElement(437) && Act.TC.Evalue(slot2.thing.category.skill) > num7)
                                {
                                    ele2 = slot2.thing.category.skill;
                                    num7 = Act.TC.Evalue(ele2);
                                }
                            }
                        }
                        num6 = num6 * 100 / (int)Mathf.Clamp((float)AttackProcess.Current.weaponSkill.Value / (float)num7 * 100f, 50f, 150f);
                        if (EClass.rnd(100) < num6)
                        {
                            Act.TC.Say((Act.TC.isChara && Act.TC.Chara.IsHostile()) ? "parry_enemy" : "parry");
                            Act.TC.PlaySound("parry");
                            Act.TC.ModExp(ele2, 20);
                            parried = true;
                            return;
                        }
                    }
                }
                int num8 = 1;
                if (chaser > 0)
                {
                    for (int j = 0; j < 10; j++)
                    {
                        if (chaser > EClass.rnd(4 + (int)Mathf.Pow(4f, j + 2)))
                        {
                            num8++;
                        }
                    }
                }
                bool flag = false;
                for (int k = 0; k < num8; k++)
                {
                    if (!Act.CC.IsAliveInCurrentZone)
                    {
                        break;
                    }
                    if (!Act.TC.IsAliveInCurrentZone)
                    {
                        break;
                    }
                    if (k > 0)
                    {
                        Act.CC.Say(Act.CC.IsHostile() ? "attack_chaser_enemy" : "attack_chaser");
                    }
                    flag = AttackProcess.Current.Perform(count, hasHit, dmgMulti * mtp * BaseDmgMTP, maxRoll, subAttack);
                    if (!flag && frustration > 0 && !Act.TC.HasElement(439) && 10f + 2f * Mathf.Sqrt(frustration) > (float)EClass.rnd(100))
                    {
                        AttackProcess.Current.critFury = true;
                        flag = AttackProcess.Current.Perform(count, hasHit, dmgMulti * mtp, maxRoll, subAttack);
                        AttackProcess.Current.critFury = false;
                    }
                    if (flag || !Act.CC.IsAliveInCurrentZone || !Act.TC.IsAliveInCurrentZone)
                    {
                        break;
                    }
                }
                if (flag)
                {
                    hasHit = true;
                }
                else
                {
                    hasMissed = true;
                }
                Act.TC = _tc;
                Act.TP = _tp;
                if (w != null && w.c_ammo > 0 && !Act.CC.HasCondition<ConReload>() && !safety)
                {
                    bool flag2 = true;
                    TraitAmmo traitAmmo = ((w.ammoData == null) ? null : (w.ammoData.trait as TraitAmmo));
                    if (traitAmmo != null && traitAmmo is TraitAmmoTalisman traitAmmoTalisman)
                    {
                        flag2 = false;
                        if (flag && !usedTalisman && Act.TC != null && Act.TC.IsAliveInCurrentZone)
                        {
                            Act act = Act.CC.elements.GetElement(traitAmmoTalisman.owner.refVal)?.act ?? ACT.Create(traitAmmoTalisman.owner.refVal);
                            Act.powerMod = traitAmmo.owner.encLV;
                            if (act.Perform(Act.CC, Act.TC, Act.TP))
                            {
                                usedTalisman = true;
                                flag2 = true;
                                if (mod_talisman > 0 && Mathf.Min(10f + Mathf.Sqrt(mod_talisman) * 5f, 90f) > (float)EClass.rnd(100))
                                {
                                    flag2 = false;
                                }
                                int spellExp = Act.CC.elements.GetSpellExp(Act.CC, act, 200);
                                Act.CC.ModExp(act.id, spellExp);
                            }
                            Act.powerMod = 100;
                        }
                    }
                    if (flag2)
                    {
                        w.c_ammo--;
                        if (w.ammoData != null)
                        {
                            w.ammoData.Num = w.c_ammo;
                        }
                        if (w.c_ammo <= 0)
                        {
                            w.c_ammo = 0;
                            w.ammoData = null;
                        }
                        LayerInventory.SetDirty(w);
                    }
                }
                Act.TC = _tc;
                if (Act.TC.IsAliveInCurrentZone && Act.TC.isChara)
                {
                    Act.CC.DoHostileAction(Act.TC);
                    if (feint > 0 && 10f + 4f * Mathf.Sqrt(feint) > (float)EClass.rnd(100))
                    {
                        Act.TC.Chara.AddCondition<ConSupress>(100 + 5 * (int)Mathf.Sqrt(feint));
                    }
                }
                if (splash > 0)
                {
                    Act.TP.ForeachNeighbor(delegate(Point p)
                    {
                        if (p.Equals(Act.TP) || p.Equals(Act.CC.pos))
                        {
                            return;
                        }
                        if (!p.IsBlocked)
                        {
                            p.PlayEffect("smoke_shockwave");
                            p.Copy().Animate(AnimeID.QuakeMini, animeBlock: true);
                        }
                        foreach (Card item4 in p.ListCards().Copy())
                        {
                            if ((item4.trait.CanBeAttacked || (item4.isChara && item4.Chara.IsHostile(Act.CC))) && !item4.HasElement(430))
                            {
                                long rawDamage2 = AttackProcess.Current.GetRawDamage(0.1f + 0.05f * Mathf.Sqrt(splash), crit: false, maxRoll: false);
                                rawDamage2 = item4.ApplyProtection(rawDamage2);
                                item4.DamageHP(rawDamage2, 0, 100, AttackSource.Shockwave, Act.CC);
                            }
                        }
                    });
                }
                if (Act.TC.isChara && !Act.TC.HasCondition<ConGravity>() && Act.TC.ExistsOnMap && knockback > 0 && knockback * 2 + 15 > EClass.rnd(100) && !Act.TC.isRestrained)
                {
                    Card.MoveResult num9 = Act.TC.Chara.TryMoveFrom(Act.CC.pos);
                    bool flag3 = Act.CC.id == "tsunami";
                    if (num9 == Card.MoveResult.Success)
                    {
                        Act.TC.renderer.SetFirst(first: true);
                        Act.TC.PlaySound("wave_hit_small");
                        if (flag3)
                        {
                            Act.TC.Chara.AddCondition<ConParalyze>(20, force: true);
                            Act.TC.Chara.AddCondition<ConSuffocation>(100, force: true);
                        }
                    }
                    else if (flag3)
                    {
                        Act.TC.PlaySound("wave_hit");
                        Act.TC.pos.PlayEffect("wave_hit");
                        Act.TC.Chara.AddCondition<ConSuffocation>(200, force: true);
                        if (!Act.TC.HasElement(430))
                        {
                            long rawDamage = AttackProcess.Current.GetRawDamage(1f, crit: false, maxRoll: false);
                            rawDamage = Act.TC.ApplyProtection(rawDamage);
                            Act.TC.DamageHP(rawDamage, 0, 100, AttackSource.Shockwave, Act.CC);
                        }
                        Act.CC.Die();
                    }
                }
            }
            void AttackWithFlurry(Card _tc, Point _tp, float mtp, bool subAttack)
            {
                int num10 = 1;
                if (flurry > 0)
                {
                    for (int l = 0; l < 10 && flurry > EClass.rnd(25 + (int)Mathf.Pow(5f, l + 2)); l++)
                    {
                        num10++;
                    }
                }
                for (int m = 0; m < num10; m++)
                {
                    if (!Act.CC.IsAliveInCurrentZone)
                    {
                        break;
                    }
                    if (!_tc.IsAliveInCurrentZone)
                    {
                        break;
                    }
                    if (m > 0)
                    {
                        Act.CC.Say(Act.CC.IsHostile() ? "attack_flurry_enemy" : "attack_flurry");
                    }
                    Attack(_tc, _tp, mtp, subAttack);
                    if (parried)
                    {
                        break;
                    }
                }
            }
            int GetWeaponEnc(int ele, bool addSelfEnc)
            {
                return AttackProcess.GetWeaponEnc(Act.CC, w, ele, addSelfEnc);
            }
        }
    }

References EClass._map, EClass._zone, Element.act, Chara.AddCondition(), AllowCounter, AllowParry, Point.Animate(), Card.ApplyProtection(), Attack, BaseDmgMTP, Chara.body, Card.c_ammo, Trait.CanBeAttacked, CanPerform(), Card.category, Act.CC, Point.cell, Card.Chara, Core.config, EInput.Consume(), Point.Copy(), EClass.core, ACT.Create(), AttackProcess.Current, EClass.curve(), Card.DamageHP(), Chara.Die(), Card.Dist(), Chara.DoHostileAction(), Cell.effect, BodySlot.elementId, Card.elements, Card.encLV, Point.Equals(), Card.Evalue(), Point.ForeachNeighbor(), CoreConfig.game, ElementContainer.GetElement(), AttackProcess.GetRawDamage(), ElementContainer.GetSpellExp(), AttackProcess.GetWeaponEnc(), Chara.HasCondition(), Card.HasElement(), CellEffect.id, Element.id, Card.IsAliveInCurrentZone, Chara.IsAliveInCurrentZone, Point.IsBlocked, Card.isChara, Card.IsDisabled, Chara.IsHostile(), Thing.IsMeleeWithAmmo, Chara.IsPC, Card.IsPCFactionOrMinion, Spatial.isPeace, Card.isRestrained, Card.IsRestrainedResident, item, Point.ListCards(), Map.ListPointsInLine(), Chara.LookAt(), ACT.Melee, Card.ModExp(), CardRenderer.NextFrame(), Trait.owner, Act.Perform(), Perform(), AttackProcess.Perform(), CardRenderer.PlayAnime(), Point.PlayEffect(), Card.PlaySound(), Card.pos, AttackProcess.Prepare(), Card.renderer, Chara.RequestProtection(), EClass.rnd(), safety, Card.Say(), Point.Set(), LayerInventory.SetDirty(), CardRenderer.SetFirst(), ShouldRollMax, CharaBody.slots, Thing.source, Act.TC, BodySlot.thing, Act.TP, Card.trait, Chara.TryMoveFrom(), ActRanged.TryReload(), UseWeaponDist, EClass.Wait(), and CoreConfig.GameConfig.waitOnMelee.

CanPerform()

override bool ActMelee.CanPerform ( )

inlinevirtual

Reimplemented from Act.

Reimplemented in ActRush.

Definition at line 73 of file ActMelee.cs.

    {
        if (Act.TC == null || !Act.TC.IsAliveInCurrentZone)
        {
            return false;
        }
        if (UseWeaponDist && Act.CC.Dist(Act.TC) > PerformDistance)
        {
            return false;
        }
        if (PerformDistance == 1)
        {
            if (!Act.CC.CanInteractTo(Act.TC))
            {
                return false;
            }
        }
        else if (!Act.CC.CanSeeLos(Act.TC))
        {
            return false;
        }
        return base.CanPerform();
    }

References Chara.CanInteractTo(), Chara.CanSeeLos(), Act.CC, Card.Dist(), Card.IsAliveInCurrentZone, PerformDistance, Act.TC, and UseWeaponDist.

Referenced by Attack(), ActMultihit.CanPerform(), and ActWhirlwind.CanPerform().

GetCursorIcon()

override CursorInfo ActMelee.GetCursorIcon ( Card  c )

inlinevirtual

Reimplemented from Act.

Definition at line 59 of file ActMelee.cs.

    {
        if (!HideHint(c))
        {
            return CursorSystem.IconMelee;
        }
        return null;
    }

References HideHint(), and CursorSystem.IconMelee.

GetHintText()

override string ActMelee.GetHintText ( string  str = "" )

inlinevirtual

Reimplemented from Act.

Definition at line 45 of file ActMelee.cs.

    {
        return "";
    }

GetTextSmall()

override string ActMelee.GetTextSmall ( Card  c )

inlinevirtual

Reimplemented from Act.

Definition at line 50 of file ActMelee.cs.

    {
        if (!HideHint(c))
        {
            return base.GetTextSmall(c);
        }
        return null;
    }

References HideHint().

HideHint()

bool ActMelee.HideHint ( Card  c )

inline

Definition at line 32 of file ActMelee.cs.

    {
        if (!EClass.pc.isBlind && c != null)
        {
            if (c.isChara)
            {
                return !EClass.pc.CanSee(c);
            }
            return false;
        }
        return true;
    }

References Chara.CanSee(), Chara.isBlind, Card.isChara, and EClass.pc.

Referenced by GetCursorIcon(), GetTextSmall(), and ShowMouseHint().

Perform()

override bool ActMelee.Perform ( )

inlinevirtual

Reimplemented from Act.

Reimplemented in ActRush.

Definition at line 97 of file ActMelee.cs.

    {
        Act.CurrentAct = this;
        bool result = Attack();
        Act.CurrentAct = null;
        return result;
    }

References Attack.

Referenced by Attack(), AI_PracticeDummy.CreateProgress(), TraitTrainingDummy.IdleUse(), ActMultihit.Perform(), ActSwarm.Perform(), and ActWhirlwind.Perform().

ShowMouseHint()

override bool ActMelee.ShowMouseHint ( Card  c )

inlinevirtual

Reimplemented from Act.

Definition at line 68 of file ActMelee.cs.

    {
        return !HideHint(c);
    }

References HideHint().

Property Documentation

AllowCounter

virtual bool ActMelee.AllowCounter

get

Definition at line 6 of file ActMelee.cs.

Referenced by Attack().

AllowParry

virtual bool ActMelee.AllowParry

get

Definition at line 8 of file ActMelee.cs.

Referenced by Attack().

BaseDmgMTP

virtual float ActMelee.BaseDmgMTP

get

Definition at line 12 of file ActMelee.cs.

Referenced by Attack().

CanPressRepeat

override bool ActMelee.CanPressRepeat

get

Definition at line 30 of file ActMelee.cs.

PerformDistance

override int ActMelee.PerformDistance

get

Definition at line 16 of file ActMelee.cs.

    {
        get
        {
            if (Act.CC != null)
            {
                return Act.CC.body.GetMeleeDistance();
            }
            return 1;
        }
    }

Referenced by CanPerform().

ResetAxis

override bool ActMelee.ResetAxis

get

Definition at line 28 of file ActMelee.cs.

ShouldRollMax

virtual bool ActMelee.ShouldRollMax

get

Definition at line 10 of file ActMelee.cs.

Referenced by Attack().

UseWeaponDist

virtual bool ActMelee.UseWeaponDist

get

Definition at line 14 of file ActMelee.cs.

Referenced by Attack(), and CanPerform().

---

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

• Elin/ActMelee.cs