ActPlan Class Reference

Inheritance diagram for ActPlan:

Classes
class	Item
class	List

Public Member Functions
string	GetText (bool showName)
Func< bool >	GetAction ()
void	Order (string id)
void	ShowContextMenu ()
bool	TrySetAct (string lang, Func< bool > onPerform, Card tc, CursorInfo cursor=null, int dist=1, bool isHostileAct=false, bool localAct=true, bool canRepeat=false)
bool	TrySetAct (string lang, Func< bool > onPerform, CursorInfo cursor=null, int dist=1)
bool	TrySetAct (Act _act, Card _tc=null)
void	Clear ()
void	Update (PointTarget target)
void	_Update (PointTarget target)

Public Attributes
Point	pos = new Point()
ActInput	input
bool	performed
bool	altAction
bool	ignoreAddCondition
List	list = new List()
int	dist
Thing	tool
List< Thing >	listPick = new List<Thing>()
Act	lastAct

Static Public Attributes
static bool	warning
Static Public Attributes inherited from EClass
static Core	core

Properties
bool	IsSelf [get]
bool	IsSelfOrNeighbor [get]
bool	IsNeighborBlocked [get]
bool	canRepeat [get]
Chara	cc [get]
CursorInfo	CursorIcon [get]
bool	WillEndTurn [get]
bool	HideRightInfo [get]
bool	HasAct [get]
bool	ShowAct [get]
bool	HasMultipleTargets [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]

Private Attributes
bool	_canInteractNeighbor
bool	showOrder

Additional Inherited Members
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 (long _a, int start, int step, int rate=75)
static int	sqrt (int a)
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)

Detailed Description

Definition at line 7 of file ActPlan.cs.

Member Function Documentation

_Update()

void ActPlan._Update ( PointTarget  target )

inline

Definition at line 469 of file ActPlan.cs.

    {
        showOrder = false;
        performed = false;
        list.Clear();
        listPick.Clear();
        if (!pos.Equals(target.pos))
        {
            lastAct = null;
        }
        pos.Set(target.pos);
        dist = cc.pos.Distance(pos);
        if (!pos.IsValid || EClass.pc.isDead)
        {
            return;
        }
        Point _pos = new Point(pos);
        _ = target.pos.cell;
        List<Card> items = _pos.ListCards();
        bool isKey = input == ActInput.Key;
        altAction = (EInput.isShiftDown && !EInput.isAltDown && !isKey) || input == ActInput.AllAction;
        _canInteractNeighbor = dist == 0 || (dist == 1 && cc.CanInteractTo(_pos));
        if (EClass.pc.isBlind && !_pos.Equals(EClass.pc.pos) && !isKey && input != 0)
        {
            return;
        }
        if (isKey || input == ActInput.LeftMouse || input == ActInput.AllAction)
        {
            if (EClass.ui.IsDragging)
            {
                return;
            }
            if (_pos.cell.outOfBounds)
            {
                if (EClass.player.CanExitBorder(_pos))
                {
                    EClass.player.ExitBorder(this);
                }
                return;
            }
            if (!isKey && _pos.Equals(cc.pos) && EClass._zone.IsRegion)
            {
                TrySetAct("actNewZone", delegate
                {
                    EClass.player.EnterLocalZone();
                    return false;
                }, CursorSystem.MoveZone);
                if (input == ActInput.AllAction)
                {
                    TrySetAct("LayerTravel", delegate
                    {
                        EClass.ui.AddLayer<LayerTravel>();
                        return false;
                    }, null, CursorSystem.MoveZone, 1, isHostileAct: false, localAct: false);
                }
            }
            items.ForeachReverse(delegate(Card _c)
            {
                Chara c2 = _c.Chara;
                if (c2 != null && !c2.IsPC && EClass.pc.CanSee(c2))
                {
                    int num = c2.Dist(EClass.pc);
                    if (num <= 1 || !EClass.pc.isBlind)
                    {
                        if (c2.mimicry != null && !c2.IsPCParty)
                        {
                            if (num <= 1)
                            {
                                c2.mimicry.TrySetAct(this);
                            }
                        }
                        else
                        {
                            if (!EClass.pc.isBlind && !c2.IsHostile() && (input == ActInput.AllAction || !(c2.IsPCParty || c2.IsMinion || isKey)) && (input == ActInput.AllAction || !c2.IsNeutral() || c2.quest != null || EClass.game.quests.IsDeliverTarget(c2)) && c2.isSynced && num <= 2)
                            {
                                bool flag5 = !c2.HasCondition<ConSuspend>() && (!c2.isRestrained || !c2.IsPCFaction);
                                if (EClass._zone.instance is ZoneInstanceMusic && !c2.IsPCFactionOrMinion)
                                {
                                    flag5 = false;
                                }
                                if (flag5 || altAction)
                                {
                                    if (EClass.pc.HasElement(1216) && c2.HasCondition<ConSleep>())
                                    {
                                        TrySetAct(new AI_Fuck
                                        {
                                            target = c2,
                                            variation = AI_Fuck.Variation.Succubus
                                        }, c2);
                                    }
                                    TrySetAct(ACT.Chat, c2);
                                }
                            }
                            if (!c2.IsPC && num <= 2 && ((c2.IsPCFaction && !c2.IsDisabled) || EClass.debug.enable) && input == ActInput.AllAction)
                            {
                                TrySetAct("actTrade", delegate
                                {
                                    LayerInventory.CreateContainer(c2);
                                    return false;
                                }, c2, null, 2);
                            }
                            if (c2.host != EClass.pc)
                            {
                                TraitShackle traitShackle = c2.pos.FindThing<TraitShackle>();
                                if (c2.IsRestrainedResident)
                                {
                                    if (traitShackle != null && traitShackle.AllowTraining)
                                    {
                                        TrySetAct(new AI_PracticeDummy
                                        {
                                            target = c2
                                        });
                                    }
                                }
                                else if ((c2.IsHostile() || altAction || c2.isRestrained) && c2.IsAliveInCurrentZone)
                                {
                                    TrySetAct(ACT.Melee, c2);
                                }
                            }
                            if (c2.IsPCPartyMinion && !c2.Chara.IsEscorted() && altAction)
                            {
                                TrySetAct("ActBanishSummon", delegate
                                {
                                    c2.Banish(EClass.pc);
                                    return true;
                                }, c2, null, 99);
                                List<Chara> list2 = new List<Chara>();
                                foreach (Chara chara in EClass._map.charas)
                                {
                                    if (chara.IsPCFactionMinion && !chara.IsEscorted())
                                    {
                                        list2.Add(chara);
                                    }
                                }
                                if (list2.Count > 1)
                                {
                                    TrySetAct("ActBanishSummonAll", delegate
                                    {
                                        foreach (Chara item in list2)
                                        {
                                            item.Banish(EClass.pc);
                                        }
                                        return true;
                                    }, c2, null, 99);
                                }
                            }
                        }
                    }
                }
            });
            if (_pos.IsHidden)
            {
                return;
            }
            if (IsSelfOrNeighbor)
            {
                items.ForeachReverse(delegate(Card _c)
                {
                    Chara c = _c.Chara;
                    if (c != null && (c.mimicry == null || c.IsPCParty))
                    {
                        bool flag3 = EClass.pc.CanSee(c);
                        if (flag3)
                        {
                            if (input == ActInput.LeftMouse && c.IsPCFaction && !c.IsPC && pos.FindThing<TraitHitchingPost>() != null)
                            {
                                Chara ride = c;
                                List<string> list = EClass.core.pccs.sets["ride"].map["body"].map.Keys.ToList();
                                int index = list.IndexOf(ride.c_idRidePCC);
                                if (index == -1)
                                {
                                    index = 0;
                                }
                                TrySetAct("ActChangeRideSkin", delegate
                                {
                                    UIContextMenu uIContextMenu = EClass.ui.CreateContextMenuInteraction();
                                    uIContextMenu.AddSlider("rideSkin", (float a) => list[(int)a].Split('-')[0] ?? "", index, delegate(float a)
                                    {
                                        ride.c_idRidePCC = list[(int)a];
                                        ride._CreateRenderer();
                                    }, 0f, list.Count - 1, isInt: true, hideOther: false);
                                    uIContextMenu.Show();
                                    return false;
                                }, c);
                            }
                            if (c.host != null && EClass.pc.held != null && altAction)
                            {
                                bool flag4 = true;
                                if ((EClass.pc.held.trait is TraitThrown || EClass.pc.held.trait.IsTool) && !HotItemHeld.disableTool)
                                {
                                    flag4 = false;
                                }
                                if (!c.IsDisabled && flag4 && c.CanAcceptGift(EClass.pc, EClass.pc.held))
                                {
                                    string lang = "actGive";
                                    if (c.Evalue(1232) > 0 && EClass.pc.held.trait is TraitDrinkMilkMother)
                                    {
                                        lang = "actMilk";
                                    }
                                    TrySetAct(lang, delegate
                                    {
                                        if (!c.IsValidGiftWeight(EClass.pc.held, 1))
                                        {
                                            c.Talk("tooHeavy");
                                            return true;
                                        }
                                        if (EClass.core.config.game.confirmGive)
                                        {
                                            Dialog.YesNo("dialogGive".lang(EClass.pc.held.GetName(NameStyle.Full, 1)), func);
                                        }
                                        else
                                        {
                                            func();
                                        }
                                        return true;
                                    }, c);
                                }
                            }
                        }
                        if (input == ActInput.AllAction && EClass.pc.held != null && EClass.pc.held.trait is TraitDrink)
                        {
                            TrySetAct(c.IsPC ? "actPour" : "ActThrow", delegate
                            {
                                ActThrow.Throw(EClass.pc, c.pos, c, EClass.pc.held.Split(1));
                                return true;
                            }, (c.host != null) ? c : EClass.pc.held);
                        }
                        if (!c.IsPC && c.host == null && ((!EClass.pc.isBlind && flag3) || input != ActInput.AllAction))
                        {
                            if (c.isRestrained && (input == ActInput.AllAction || (!c.IsRestrainedResident && !c.IsHostile())))
                            {
                                TrySetAct("ActUnrestrain", delegate
                                {
                                    c.TryUnrestrain(force: true, EClass.pc);
                                    return true;
                                }, c);
                            }
                            if (!EClass.pc.isBlind && flag3 && input == ActInput.AllAction)
                            {
                                TrySetAct(ACT.Kick, c);
                                if (c.IsMofuable)
                                {
                                    TrySetAct("ActCuddle", delegate
                                    {
                                        EClass.pc.Cuddle(c);
                                        return true;
                                    }, c);
                                }
                                if (EClass.debug.showExtra)
                                {
                                    TrySetAct("inspect", delegate
                                    {
                                        c.Inspect();
                                        return false;
                                    }, c);
                                }
                            }
                        }
                    }
                    else if (_c.isThing)
                    {
                        if (!EClass.pc.isBlind)
                        {
                            Thing t = _c.Thing;
                            if (input == ActInput.AllAction)
                            {
                                if ((EClass.debug.enable || EClass.player.HasKeyItem("license_illumination")) && t.LightData != null)
                                {
                                    if (t.c_lightColor != 0)
                                    {
                                        TrySetAct("actClearLight", delegate
                                        {
                                            t.c_lightColor = 0;
                                            t.RecalculateFOV();
                                            t.renderer.GetTC<TCExtra>()?.RefreshColor();
                                            return false;
                                        }, t);
                                    }
                                    TrySetAct("actSetLight", delegate
                                    {
                                        Color lightColor = t.LightColor;
                                        EClass.ui.AddLayer<LayerColorPicker>().SetColor(lightColor, lightColor, delegate(PickerState state, Color _c)
                                        {
                                            if (state == PickerState.Cancel)
                                            {
                                                t.c_lightColor = 0;
                                            }
                                            else
                                            {
                                                t.c_lightColor = (byte)Mathf.Clamp(_c.r * 32f, 1f, 31f) * 1024 + (byte)Mathf.Clamp(_c.g * 32f, 1f, 31f) * 32 + (byte)Mathf.Clamp(_c.b * 32f, 1f, 31f);
                                            }
                                            t.RecalculateFOV();
                                            t.renderer.GetTC<TCExtra>()?.RefreshColor();
                                        });
                                        return false;
                                    }, t);
                                }
                                if (EClass.debug.enable && pos.cell.IsTopWater)
                                {
                                    TrySetAct("(debug) Toggle Float", delegate
                                    {
                                        t.isFloating = !t.isFloating;
                                        return false;
                                    }, t);
                                }
                                if (!EClass._zone.IsUserZone || !t.isNPCProperty)
                                {
                                    if (t.trait.CanEat(EClass.pc))
                                    {
                                        TrySetAct(new AI_Eat
                                        {
                                            target = t
                                        }, t);
                                    }
                                    if (t.trait.CanDrink(EClass.pc))
                                    {
                                        TrySetAct(new AI_Drink
                                        {
                                            target = t
                                        }, t);
                                    }
                                    if (t.trait.CanRead(EClass.pc))
                                    {
                                        TrySetAct(new AI_Read
                                        {
                                            target = t
                                        }, t);
                                    }
                                    if (t.trait.IsBlendBase)
                                    {
                                        TrySetAct("invBlend", delegate
                                        {
                                            LayerDragGrid.Create(new InvOwnerBlend(t));
                                            return true;
                                        }, t);
                                    }
                                    if (t.trait.CanName)
                                    {
                                        TrySetAct("changeName", delegate
                                        {
                                            Dialog.InputName("dialogChangeName", t.c_refText.IsEmpty(""), delegate(bool cancel, string text)
                                            {
                                                if (!cancel)
                                                {
                                                    t.c_refText = text;
                                                }
                                            });
                                            return false;
                                        }, t);
                                    }
                                }
                            }
                            if (isKey)
                            {
                                _ = t.trait.CanBeAttacked;
                            }
                            else
                            {
                                if (t.placeState == PlaceState.roaming && (_pos.cell.blocked || t.ignoreAutoPick || altAction || input == ActInput.AllAction || _pos.Equals(EClass.pc.pos)) && EClass.pc.CanPick(t))
                                {
                                    listPick.Add(t);
                                }
                                if (t.IsInstalled)
                                {
                                    t.trait.TrySetToggleAct(this);
                                    t.trait.TrySetAct(this);
                                }
                            }
                        }
                    }
                    void func()
                    {
                        EClass.pc.GiveGift(c, EClass.pc.SplitHeld(1) as Thing);
                    }
                });
                if (listPick.Count > 0)
                {
                    if (listPick.Count == 1)
                    {
                        Thing _t = listPick[0];
                        if (!EClass._zone.IsRegion || (!_t.ignoreAutoPick && _t.pos.Equals(EClass.pc.pos)) || altAction)
                        {
                            TrySetAct("actPickOne", delegate
                            {
                                EClass.pc.Pick(_t);
                                return true;
                            }, listPick[0], CursorSystem.Hand, 1, isHostileAct: false, localAct: false);
                        }
                    }
                    else
                    {
                        IList<Card> _cards = items.Copy();
                        TrySetAct("actPickAll", delegate
                        {
                            foreach (Card item2 in _cards)
                            {
                                if (item2.isThing && item2.placeState == PlaceState.roaming)
                                {
                                    EClass.pc.Pick(item2.Thing);
                                }
                            }
                            return true;
                        }, null, CursorSystem.Hand, 1, isHostileAct: false, localAct: false);
                    }
                }
                if (input == ActInput.AllAction && pos.IsSky && !EClass.game.IsSurvival)
                {
                    TrySetAct("actSkyJump", delegate
                    {
                        EClass.pc.FallFromZone();
                        return false;
                    });
                }
                if (_pos.Equals(cc.pos))
                {
                    if (cc.held != null && !cc.held.IsHotItem)
                    {
                        TrySetAct("actPick", delegate
                        {
                            _ = cc.held;
                            cc.PickHeld(msg: true);
                            ActionMode.AdvOrRegion.updatePlans = true;
                            return false;
                        }, cc.held, CursorSystem.Inventory, 1, isHostileAct: false, localAct: false);
                    }
                    else if (!HasAct && !cc.isRestrained)
                    {
                        TrySetAct(ACT.Wait);
                    }
                    if (EClass.debug.enable)
                    {
                        showOrder = true;
                    }
                    if (input == ActInput.AllAction && EClass.pc.held != null && !EClass.pc.held.trait.CanOnlyCarry)
                    {
                        TrySetAct("actDrop", delegate
                        {
                            EClass.pc.DropThing(EClass.pc.held.Thing);
                            return true;
                        });
                    }
                    if (cc.isRestrained)
                    {
                        TrySetAct("ActUnrestrain", delegate
                        {
                            cc.TryUnrestrain(force: true, EClass.pc);
                            return true;
                        }, cc);
                    }
                }
            }
            if (list.Count == 0 && input == ActInput.AllAction && EClass.pc.held == null && pos.cell.IsSnowTile && !pos.IsBlocked && !pos.HasObj && !pos.HasThing)
            {
                TrySetAct(new AI_Craft_Snowman
                {
                    pos = pos.Copy()
                });
            }
            if (list.Count != 0 && input != ActInput.AllAction)
            {
                return;
            }
            items.ForeachReverse(delegate(Card _c)
            {
                if (_c.isThing && _c.trait.CanBeAttacked && !(_c.trait is TraitTrainingDummy))
                {
                    TrySetAct(ACT.Melee, _c);
                }
            });
        }
        else
        {
            if (input != ActInput.RightMouse)
            {
                return;
            }
            if (pos.cell.outOfBounds || EClass.ui.IsDragging)
            {
                return;
            }
            HotItem hotItem = EClass.player.currentHotItem;
            if (!hotItem.IsGameAction)
            {
                TrySetAct(hotItem.Name, delegate
                {
                    hotItem.OnClick(hotItem.button, hotItem.hotbar);
                    return false;
                }, null, -1);
            }
            else
            {
                hotItem.TrySetAct(this);
            }
            bool flag = EClass.game.config.autoCombat.enable && EClass.scene.mouseTarget.TargetChara != null && EClass.scene.mouseTarget.TargetChara.mimicry == null;
            if (hotItem.Thing != null && hotItem.Thing.trait.DisableAutoCombat)
            {
                flag = false;
            }
            if (flag)
            {
                Chara targetChara = EClass.scene.mouseTarget.TargetChara;
                bool flag2 = true;
                if (targetChara.hostility >= Hostility.Friend)
                {
                    flag2 = false;
                }
                if (targetChara.hostility == Hostility.Neutral && EClass.game.config.autoCombat.bDontAutoAttackNeutral)
                {
                    flag2 = false;
                }
                if (list.Count >= 2)
                {
                    flag2 = false;
                }
                if (list.Count == 1)
                {
                    if (targetChara.hostility >= Hostility.Neutral)
                    {
                        flag2 = false;
                    }
                    if (!list[0].act.ShowAuto)
                    {
                        flag2 = false;
                    }
                    if (EClass.player.currentHotItem is HotItemNoItem && targetChara.hostility <= Hostility.Enemy)
                    {
                        flag2 = true;
                    }
                }
                if (flag2)
                {
                    list.Clear();
                    TrySetAct(new GoalAutoCombat(targetChara));
                }
            }
            if (list.Count == 0 && !EClass.core.config.test.toolNoPick)
            {
                HotItemNoItem._TrySetAct(this);
            }
            if ((bool)WidgetCurrentTool.Instance)
            {
                WidgetCurrentTool.Instance.placer.Refresh();
            }
        }
    }

References _canInteractNeighbor, Chara._CreateRenderer(), EClass._map, HotItemNoItem._TrySetAct(), EClass._zone, ActPlan.List.Add(), UIContextMenu.AddSlider(), TraitShackle.AllowTraining, altAction, Game.Config.autoCombat, Chara.Banish(), ConfigAutoCombat.bDontAutoAttackNeutral, Algorithms.WeightCell.blocked, Card.c_idRidePCC, Card.c_lightColor, Card.c_refText, Chara.CanAcceptGift(), Trait.CanBeAttacked, Trait.CanDrink(), Trait.CanEat(), Player.CanExitBorder(), Chara.CanInteractTo(), Trait.CanName, Trait.CanOnlyCarry, Chara.CanPick(), Trait.CanRead(), Chara.CanSee(), cc, Point.cell, Card.Chara, Map.charas, ACT.Chat, Color, Core.config, Game.config, CoreConfig.GameConfig.confirmGive, Point.Copy(), EClass.core, LayerDragGrid.Create(), LayerInventory.CreateContainer(), Chara.Cuddle(), Player.currentHotItem, EClass.debug, Trait.DisableAutoCombat, HotItemHeld.disableTool, dist, Card.Dist(), Point.Distance(), Chara.DropThing(), CoreDebug.enable, Player.EnterLocalZone(), Point.Equals(), Card.Evalue(), Player.ExitBorder(), Chara.FallFromZone(), Point.FindThing(), CoreConfig.game, EClass.game, CardRenderer.GetTC(), Chara.GiveGift(), CursorSystem.Hand, HasAct, Chara.HasCondition(), Card.HasElement(), Player.HasKeyItem(), Point.HasObj, Point.HasThing, Chara.held, Chara.host, Chara.hostility, if(), Card.ignoreAutoPick, input, Dialog.InputName(), Card.Inspect(), WidgetCurrentTool.Instance, Zone.instance, CursorSystem.Inventory, Chara.IsAliveInCurrentZone, Trait.IsBlendBase, Chara.isBlind, Point.IsBlocked, Chara.isDead, QuestManager.IsDeliverTarget(), Chara.IsDisabled, Chara.IsEscorted(), Card.isFloating, HotItem.IsGameAction, Point.IsHidden, Chara.IsHostile(), Card.IsHotItem, Card.IsInstalled, Chara.IsMinion, Chara.IsMofuable, Chara.IsNeutral(), Card.isNPCProperty, Chara.IsPC, Chara.IsPCFaction, Chara.IsPCFactionMinion, Card.IsPCFactionOrMinion, Chara.IsPCParty, Chara.IsPCPartyMinion, Spatial.IsRegion, Card.isRestrained, Card.IsRestrainedResident, IsSelfOrNeighbor, Point.IsSky, Cell.IsSnowTile, Game.IsSurvival, Chara.isSynced, Card.isThing, Trait.IsTool, Cell.IsTopWater, Zone.IsUserZone, Point.IsValid, Chara.IsValidGiftWeight(), item, ACT.Kick, lastAct, Card.LightColor, Card.LightData, list, Point.ListCards(), listPick, ACT.Melee, Chara.mimicry, Scene.mouseTarget, CursorSystem.MoveZone, UIButton.Item.Name, Cell.outOfBounds, EClass.pc, Core.pccs, performed, Chara.Pick(), Chara.PickHeld(), WidgetCurrentTool.placer, Card.placeState, EClass.player, pos, Card.pos, PointTarget.pos, Chara.quest, Game.quests, Card.RecalculateFOV(), UIPlaceHelper.Refresh(), TCExtra.RefreshColor(), Card.renderer, EClass.scene, Point.Set(), UIContextMenu.Show(), CoreDebug.showExtra, showOrder, Chara.SplitHeld(), PointTarget.TargetChara, CoreConfig.test, Card.Thing, HotItem.Thing, CoreConfig.Test.toolNoPick, Card.trait, ConTransmuteMimic.TrySetAct(), HotItem.TrySetAct(), Trait.TrySetAct(), TrySetAct(), Trait.TrySetToggleAct(), Card.TryUnrestrain(), EClass.ui, and ACT.Wait.

Referenced by Update().

Clear()

void ActPlan.Clear ( )

inline

Definition at line 429 of file ActPlan.cs.

    {
        list.Clear();
        pos.IsValid = false;
    }

References list.

Referenced by AM_Adv.ClearPlans().

GetAction()

Func< bool > ActPlan.GetAction ( )

inline

Definition at line 289 of file ActPlan.cs.

    {
        if (list.Count == 0)
        {
            return () => false;
        }
        if (list.Count > 1)
        {
            return delegate
            {
                if (pos.Equals(EClass.pc.pos) && ActWait.SearchMedal(EClass.pc, pos))
                {
                    return false;
                }
                ShowContextMenu();
                return false;
            };
        }
        Item item = list[0];
        return delegate
        {
            if (performed && !item.act.CanPressRepeat)
            {
                return false;
            }
            performed = true;
            lastAct = item.act;
            return item.Perform(performed);
        };
    }

References Point.Equals(), item, lastAct, list, EClass.pc, performed, pos, Card.pos, ActWait.SearchMedal(), and ShowContextMenu().

Referenced by AM_Adv.AxisMove(), and AM_Adv.PressedAction.SetPlan().

GetText()

string ActPlan.GetText ( bool  showName )

inline

Definition at line 276 of file ActPlan.cs.

    {
        if (list.Count == 0)
        {
            return "";
        }
        if (list.Count == 1)
        {
            return list[0].GetText(showName);
        }
        return "+" + list.Count + ((HasMultipleTargets || list[0].tc == null) ? ("\n<size=28>(" + "multipleTargets".lang() + ")</size>") : ("\n<size=28>" + list[0].tc.Name + list[0].tc.GetExtraName() + "</size>"));
    }

References HasMultipleTargets, and list.

Referenced by Update().

Order()

void ActPlan.Order ( string  id )

inline

Definition at line 320 of file ActPlan.cs.

    {
        EClass.player.forceTalk = true;
        EClass.pc.SayRaw(id.lang());
    }

References EClass.pc, and Card.SayRaw().

Referenced by ShowContextMenu().

ShowContextMenu()

void ActPlan.ShowContextMenu ( )

inline

Definition at line 326 of file ActPlan.cs.

    {
        UIContextMenu uIContextMenu = EClass.ui.CreateContextMenuInteraction();
        int num = 1;
        if (showOrder)
        {
            UIContextMenu uIContextMenu2 = uIContextMenu.AddChild("order_ally");
            uIContextMenu2.AddButton("order_fight", delegate
            {
                Order("order_fight");
            });
            uIContextMenu2.AddButton("order_heal", delegate
            {
                Order("order_heal");
            });
            uIContextMenu2.AddButton("order_wait", delegate
            {
                Order("order_wait");
            });
        }
        foreach (Item i in list)
        {
            string textContext = i.GetTextContext(HasMultipleTargets);
            textContext = textContext.Replace("\n", " ").Replace(Environment.NewLine, " ");
            uIContextMenu.AddButton(textContext, delegate
            {
                performed = true;
                if (i.Perform())
                {
                    EClass.player.EndTurn();
                }
            });
            num++;
            if (num >= 21)
            {
                break;
            }
        }
        uIContextMenu.Show();
        EClass.ui.hud.HideMouseInfo();
    }

References UIContextMenu.AddButton(), UIContextMenu.AddChild(), Player.EndTurn(), ActPlan.Item.GetTextContext(), HasMultipleTargets, list, Order(), ActPlan.Item.Perform(), performed, EClass.player, showOrder, and EClass.ui.

Referenced by GetAction(), and AM_Adv.ShowAllAction().

TrySetAct() [1/3]

bool ActPlan.TrySetAct ( Act  _act, Card  _tc = null  )

inline

Definition at line 391 of file ActPlan.cs.

    {
        if (!ignoreAddCondition && !_act.CanPerform(cc, _tc, pos))
        {
            return false;
        }
        Item item = new Item
        {
            act = _act,
            tc = _tc,
            pos = pos.Copy()
        };
        if (_tc != null && _tc.isChara)
        {
            int num = -1;
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].tc == _tc)
                {
                    num = i;
                }
            }
            if (num != -1)
            {
                list.Insert(num + 1, item);
            }
            else
            {
                list.Add(item);
            }
        }
        else
        {
            list.Add(item);
        }
        return true;
    }

References ActPlan.List.Add(), Act.CanPerform(), cc, Point.Copy(), ignoreAddCondition, item, list, and pos.

TrySetAct() [2/3]

bool ActPlan.TrySetAct ( string  lang, Func< bool >  onPerform, Card  tc, CursorInfo  cursor = null, int  dist = 1, bool  isHostileAct = false, bool  localAct = true, bool  canRepeat = false  )

inline

Definition at line 368 of file ActPlan.cs.

    {
        return TrySetAct(new DynamicAct(lang, onPerform)
        {
            id = lang,
            dist = dist,
            isHostileAct = isHostileAct,
            localAct = localAct,
            cursor = ((cursor == CursorSystem.Arrow) ? null : cursor),
            canRepeat = () => canRepeat
        }, tc);
    }

References CursorSystem.Arrow, canRepeat, dist, and TrySetAct().

Referenced by HotItemNoItem._TrySetAct(), _Update(), ConTransmuteMimic.TrySetAct(), HotItemAct.TrySetAct(), HotItemHeld.TrySetAct(), Trait.TrySetAct(), TraitAltar.TrySetAct(), TraitAltarChaos.TrySetAct(), TraitBath.TrySetAct(), TraitBed.TrySetAct(), TraitBuildBoard.TrySetAct(), TraitCanvas.TrySetAct(), TraitContainer.TrySetAct(), TraitCoreDefense.TrySetAct(), TraitCoreZone.TrySetAct(), TraitCrafter.TrySetAct(), TraitDeliveryChest.TrySetAct(), TraitDoor.TrySetAct(), TraitDrawingPaper.TrySetAct(), TraitEffect.TrySetAct(), TraitFactionBoard.TrySetAct(), TraitFigure.TrySetAct(), TraitGacha.TrySetAct(), TraitHoard.TrySetAct(), TraitHomeBoard.TrySetAct(), TraitHouseBoard.TrySetAct(), TraitMapBoard.TrySetAct(), TraitMirror.TrySetAct(), TraitNewspaper.TrySetAct(), TraitNewZone.TrySetAct(), TraitNote.TrySetAct(), TraitPaintBoard.TrySetAct(), TraitPillowStrange.TrySetAct(), TraitQuestBoard.TrySetAct(), TraitResearchBoard.TrySetAct(), TraitResidentBoard.TrySetAct(), TraitRoomPlate.TrySetAct(), TraitSpecialLantern.TrySetAct(), TraitSwitch.TrySetAct(), TraitTeleporter.TrySetAct(), TraitToolMusic.TrySetAct(), TraitToolMusicBig.TrySetAct(), TraitTrainingDummy.TrySetAct(), TraitWaystone.TrySetAct(), TraitWell.TrySetAct(), TrySetAct(), TraitBroom.TrySetHeldAct(), TraitCatalyst.TrySetHeldAct(), TraitDetector.TrySetHeldAct(), TraitFakeTile.TrySetHeldAct(), TraitGene.TrySetHeldAct(), TraitRod.TrySetHeldAct(), TraitSalesTag.TrySetHeldAct(), TraitShackle.TrySetHeldAct(), TraitSyringeBlood.TrySetHeldAct(), TraitSyringeGene.TrySetHeldAct(), TraitSyringeHeaven.TrySetHeldAct(), TraitSyringeUnicorn.TrySetHeldAct(), TraitToolBuild.TrySetHeldAct(), TraitToolSickle.TrySetHeldAct(), TraitToolTorch.TrySetHeldAct(), TraitToolWaterCan.TrySetHeldAct(), TraitToolWaterPot.TrySetHeldAct(), TraitWrench.TrySetHeldAct(), Trait.TrySetToggleAct(), and HotItemHeld.TrySetToolAct().

TrySetAct() [3/3]

bool ActPlan.TrySetAct ( string  lang, Func< bool >  onPerform, CursorInfo  cursor = null, int  dist = 1  )

inline

Definition at line 381 of file ActPlan.cs.

    {
        return TrySetAct(new DynamicAct(lang, onPerform)
        {
            id = lang,
            dist = dist,
            cursor = ((cursor == CursorSystem.Arrow) ? null : cursor)
        });
    }

References CursorSystem.Arrow, dist, and TrySetAct().

Update()

void ActPlan.Update ( PointTarget  target )

inline

Definition at line 435 of file ActPlan.cs.

    {
        if (warning)
        {
            return;
        }
        _Update(target);
        if (!HasAct)
        {
            return;
        }
        Color effectColor = ((list.Count == 1) ? list[0].act.GetActPlanColor() : EClass.Colors.colorAct);
        if (input == ActInput.LeftMouse || input == ActInput.Key)
        {
            EClass.ui.hud.textLeft.SetText(GetText(showName: true));
            Outline[] components = EClass.ui.hud.textLeft.GetComponents<Outline>();
            for (int i = 0; i < components.Length; i++)
            {
                components[i].effectColor = effectColor;
            }
        }
        else if (input == ActInput.RightMouse)
        {
            EClass.player.currentHotItem.SetImage(EClass.ui.hud.imageRight);
            EClass.ui.hud.imageRight.rectTransform.localScale = new Vector3(2f, 2f, 1f);
            EClass.ui.hud.textRight.SetText(GetText(showName: true));
            Outline[] components = EClass.ui.hud.textRight.GetComponents<Outline>();
            for (int i = 0; i < components.Length; i++)
            {
                components[i].effectColor = effectColor;
            }
        }
    }

References _Update(), Color, ColorProfile.colorAct, EClass.Colors, Player.currentHotItem, GetText(), HasAct, input, list, Outline, EClass.player, HotItem.SetImage(), EClass.ui, and warning.

Referenced by AM_Adv.AxisMove(), HotItemHeld.CanRotate(), AM_Adv.SetPressedAction(), AM_Adv.ShowAllAction(), and AM_Adv.UpdatePlans().

Member Data Documentation

_canInteractNeighbor

bool ActPlan._canInteractNeighbor

private

Definition at line 162 of file ActPlan.cs.

Referenced by _Update().

altAction

bool ActPlan.altAction

Definition at line 158 of file ActPlan.cs.

Referenced by _Update(), TraitDoor.TrySetAct(), TraitDrawingPaper.TrySetAct(), TraitNewspaper.TrySetAct(), TraitNote.TrySetAct(), TraitPaintBoard.TrySetAct(), and Trait.TrySetToggleAct().

dist

int ActPlan.dist

Definition at line 168 of file ActPlan.cs.

Referenced by _Update(), and TrySetAct().

ignoreAddCondition

bool ActPlan.ignoreAddCondition

Definition at line 160 of file ActPlan.cs.

Referenced by TrySetAct().

input

ActInput ActPlan.input

Definition at line 154 of file ActPlan.cs.

Referenced by _Update(), TraitEffect.TrySetAct(), TraitElevator.TrySetAct(), TraitFigure.TrySetAct(), TraitTeleporter.TrySetAct(), and Update().

lastAct

Act ActPlan.lastAct

Definition at line 174 of file ActPlan.cs.

Referenced by _Update(), and GetAction().

list

List ActPlan.list = new List()

Definition at line 166 of file ActPlan.cs.

Referenced by _Update(), AM_Adv.AxisMove(), Clear(), GetAction(), GetText(), AM_MoveInstalled.OnProcessTiles(), AM_Adv.PressedAction.SetPlan(), ShowContextMenu(), TrySetAct(), and Update().

listPick

List<Thing> ActPlan.listPick = new List<Thing>()

Definition at line 172 of file ActPlan.cs.

Referenced by _Update().

performed

bool ActPlan.performed

Definition at line 156 of file ActPlan.cs.

Referenced by _Update(), GetAction(), AM_Adv.OnUpdateCursor(), ShowContextMenu(), HotItemAct.TrySetAct(), and TraitCatalyst.TrySetHeldAct().

pos

Point ActPlan.pos = new Point()

Definition at line 152 of file ActPlan.cs.

Referenced by AM_Adv._OnUpdateInput(), HotItemNoItem._TrySetAct(), _Update(), GetAction(), AM_Adv.OnUpdateCursor(), AM_Adv.ShowAllAction(), TrySetAct(), HotItemAct.TrySetAct(), HotItemHeld.TrySetAct(), TraitNewZone.TrySetAct(), TraitBroom.TrySetHeldAct(), TraitCatalyst.TrySetHeldAct(), TraitEcoMark.TrySetHeldAct(), TraitFakeTile.TrySetHeldAct(), TraitGene.TrySetHeldAct(), TraitLeash.TrySetHeldAct(), TraitSalesTag.TrySetHeldAct(), TraitShackle.TrySetHeldAct(), TraitStethoscope.TrySetHeldAct(), TraitSyringeBlood.TrySetHeldAct(), TraitSyringeGene.TrySetHeldAct(), TraitSyringeHeaven.TrySetHeldAct(), TraitSyringeUnicorn.TrySetHeldAct(), TraitTicketFurniture.TrySetHeldAct(), TraitToolBrushStrip.TrySetHeldAct(), TraitToolHammerStrip.TrySetHeldAct(), TraitToolTorch.TrySetHeldAct(), TraitWhipEgg.TrySetHeldAct(), TraitWhipLove.TrySetHeldAct(), TraitWrench.TrySetHeldAct(), and HotItemHeld.TrySetToolAct().

showOrder

bool ActPlan.showOrder

private

Definition at line 164 of file ActPlan.cs.

Referenced by _Update(), and ShowContextMenu().

tool

Thing ActPlan.tool

Definition at line 170 of file ActPlan.cs.

warning

bool ActPlan.warning

static

Definition at line 150 of file ActPlan.cs.

Referenced by ActPlan.Item.Perform(), and Update().

Property Documentation

canRepeat

bool ActPlan.canRepeat

get

Definition at line 192 of file ActPlan.cs.

    {
        get
        {
            if (list.Count == 1)
            {
                return list[0].act.CanPressRepeat;
            }
            return false;
        }
    }

Referenced by AM_Adv.AxisMove(), AM_Adv.PressedAction.SetPlan(), and TrySetAct().

cc

Chara ActPlan.cc

get

Definition at line 204 of file ActPlan.cs.

Referenced by _Update(), TrySetAct(), HotItemHeld.TrySetAct(), and Trait.TrySetAct().

CursorIcon

CursorInfo ActPlan.CursorIcon

get

Definition at line 206 of file ActPlan.cs.

    {
        get
        {
            if (list.Count != 0)
            {
                if (list.Count <= 1)
                {
                    return list[0].act.GetCursorIcon(list[0].tc);
                }
                return CursorSystem.Notice;
            }
            return null;
        }
    }

Referenced by AM_Adv.OnUpdateCursor().

HasAct

bool ActPlan.HasAct

get

Definition at line 246 of file ActPlan.cs.

Referenced by _Update(), AM_Adv.AxisMove(), HotItemHeld.CanRotate(), AM_Adv.OnUpdateCursor(), AM_Adv.SetPressedAction(), AM_Adv.ShowAllAction(), HotItemHeld.TrySetAct(), HotItemHeld.TrySetToolAct(), Update(), and AM_Adv.UpdateLangWheel().

HasMultipleTargets

bool ActPlan.HasMultipleTargets

get

Definition at line 264 of file ActPlan.cs.

    {
        get
        {
            if (list.Count > 1)
            {
                return list[0].tc != list.LastItem().tc;
            }
            return false;
        }
    }

Referenced by GetText(), and ShowContextMenu().

HideRightInfo

bool ActPlan.HideRightInfo

get

Definition at line 234 of file ActPlan.cs.

    {
        get
        {
            if (list.Count > 0)
            {
                return list[0].act.HideRightInfo;
            }
            return false;
        }
    }

Referenced by AM_Adv.PressedAction.SetPlan().

IsNeighborBlocked

bool ActPlan.IsNeighborBlocked

get

Definition at line 180 of file ActPlan.cs.

    {
        get
        {
            if (!_canInteractNeighbor)
            {
                return dist == 1;
            }
            return false;
        }
    }

Referenced by HotItemNoItem._TrySetAct(), and HotItemHeld.TrySetToolAct().

IsSelf

bool ActPlan.IsSelf

get

Definition at line 176 of file ActPlan.cs.

Referenced by HotItemHeld.TrySetAct(), TraitHoard.TrySetAct(), TraitNewZone.TrySetAct(), TraitContainer.TrySetHeldAct(), TraitDetector.TrySetHeldAct(), TraitMirror.TrySetHeldAct(), TraitToolMusic.TrySetHeldAct(), and TraitToolTorch.TrySetHeldAct().

IsSelfOrNeighbor

bool ActPlan.IsSelfOrNeighbor

get

Definition at line 178 of file ActPlan.cs.

Referenced by HotItemNoItem._TrySetAct(), _Update(), HotItemHeld.TrySetAct(), TraitLeash.TrySetHeldAct(), TraitStethoscope.TrySetHeldAct(), TraitToolTorch.TrySetHeldAct(), TraitWhipEgg.TrySetHeldAct(), TraitWhipLove.TrySetHeldAct(), and Trait.TrySetToggleAct().

ShowAct

bool ActPlan.ShowAct

get

Definition at line 248 of file ActPlan.cs.

    {
        get
        {
            if (HasAct)
            {
                if (lastAct != list[0].act)
                {
                    return list[0].act.ShowMouseHint(list[0].tc);
                }
                return false;
            }
            return false;
        }
    }

Referenced by AM_Adv.OnUpdateCursor().

WillEndTurn

bool ActPlan.WillEndTurn

get

Definition at line 222 of file ActPlan.cs.

    {
        get
        {
            if (list.Count > 0)
            {
                return list[0].act.WillEndTurn;
            }
            return false;
        }
    }

Referenced by AM_Adv.AxisMove(), and AM_Adv.PressedAction.SetPlan().

---

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

• Elin/ActPlan.cs