Inheritance diagram for AM_Adv:

Classes
class	PressedAction

Public Member Functions
override bool	HighlightWall (Point p)

override void	OnActivate ()

override void	OnDeactivate ()

override void	OnRenderTile (Point point, HitResult result, int dir)

override int	GetDefaultTile (Point p)

override void	OnBeforeUpdate ()

override void	OnAfterUpdate ()

override void	OnUpdateCursor ()

void	UpdatePlans ()

void	UpdateLangWheel ()

void	ClearPlans ()

void	OnBecomeNoGoal ()

override void	_OnUpdateInput ()

void	ShowAllAction ()

void	SetTurbo (int mtp=-1)

void	EndTurbo ()

void	ToggleZoom ()

bool	TryCancelInteraction (bool sound=true)

bool	CanAct ()

void	AxisMove ()

void	SetManualMove ()

void	SetPressedAction (ButtonState button)

bool	PressedActionMove (Point pos)

virtual void	RefreshArrow ()

Public Member Functions inherited from AM_BaseGameMode
override void	OnUpdateInput ()

override string	GetHintText ()

virtual void	_OnUpdateInput ()

override void	OnCancel ()

override HitResult	HitTest (Point point, Point start)

Public Member Functions inherited from ActionMode
virtual int	TopHeight (Point p)

virtual void	SEExecuteSummary ()

virtual bool	HighlightWall (Point p)

virtual void	OnClickSubMenu (int a)

virtual string	OnSetSubMenuButton (int a, UIButton b)

virtual bool	IsRoofEditMode (Card c=null)

virtual bool	IsFillMode ()

virtual int	GetDefaultTile (Point p)

virtual void	OnShowExtraHint (UINote n)

void	Activate (bool toggle=true, bool forceActivate=false)

virtual void	OnActivate ()

void	RefreshTexts ()

virtual string	GetSimpleText (Card c)

void	ClearSimpleTexts ()

void	Deactivate ()

virtual void	OnDeactivate ()

virtual void	OnCancel ()

virtual void	OnBeforeUpdate ()

virtual void	OnAfterUpdate ()

virtual void	OnUpdateCursor ()

void	OnRotate ()

void	SetCursorOnMap (CursorInfo cursor)

void	UpdateInput ()

void	InputMovement ()

virtual void	InputWheel (int wheel)

virtual void	OnUpdateInput ()

void	DoFunc (CoreConfig.GameFuncBuild func)

bool	IsFuncPressed (CoreConfig.GameFunc func)

void	DoFunc (CoreConfig.GameFunc func)

virtual void	OnScroll ()

void	TryRightClickCloseWidget ()

bool	TryShowWidgetMenu ()

HitResult	_HitTest (Point point, Point start)

virtual HitResult	HitTest (Point point, Point start)

virtual void	OnSelectStart (Point point)

virtual void	OnSelectEnd (bool cancel)

virtual MeshPass	GetGuidePass (Point point)

virtual void	OnRenderTile (Point point, HitResult result, int dir)

void	OnRenderTileFloor (Point point, HitResult result)

virtual bool	CanProcessTiles ()

virtual void	OnBeforeProcessTiles ()

virtual void	OnProcessTiles (Point point, int dir)

virtual void	OnAfterProcessTiles (Point start, Point end)

virtual void	OnFinishProcessTiles ()

virtual void	OnRefreshSummary (Point point, HitResult result, HitSummary summary)

void	ShowLayer ()

virtual Layer	OnShowLayer ()

void	HideLayer ()

virtual void	OnHideLayer ()

virtual string	GetHintText ()

virtual void	RotateUnderMouse ()

virtual ref string	SetMouseInfo (ref string s)

void	TogglePause ()

void	Pause (bool sound=false)

void	UnPause (bool sound=false)

void	ChangeGameSpeed (int a, bool sound=false)

Public Attributes
bool	zoomOut

bool	zoomOut2

bool	movedByKey

int	itemLost

PressedAction	pressedAction = new PressedAction()

PointTarget	axisTarget

ActPlan	planLeft

ActPlan	planRight

ActPlan	planKeyboard

ActPlan	planAll

string	textWheel

string	textMiddle

bool	updatePlans

bool	isMoving

float	rightMouseTimer

Public Attributes inherited from AM_BaseGameMode
bool	isMouseOnMap

Public Attributes inherited from ActionMode
Layer	layer

int	brushRadius = 4

Static Public Attributes
static float	turbo

static int	actCount

Static Public Attributes inherited from ActionMode
static ActionMode	DefaultMode

static AM_Title	Title = new AM_Title()

static AM_Sim	Sim

static AM_ViewZone	View

static AM_Adv	Adv

static AM_Region	Region

static AM_ADV_Target	AdvTarget

static AM_EloMap	EloMap

static AM_Inspect	Inspect

static AM_NoMap	NoMap

static AM_MiniGame	MiniGame

static AM_NewZone	NewZone

static AM_Bird	Bird

static AM_Mine	Mine

static AM_Dig	Dig

static AM_Harvest	Harvest

static AM_Cut	Cut

static AM_StateEditor	StateEditor

static AM_Picker	Picker

static AM_Copy	Copy

static AM_Blueprint	Blueprint

static AM_Build	Build

static AM_CreateArea	CreateArea

static AM_EditArea	EditArea

static AM_ExpandArea	ExpandArea

static AM_Deconstruct	Deconstruct

static AM_Select	Select

static AM_RemoveDesignation	RemoveDesignation

static AM_ViewMap	ViewMap

static AM_Terrain	Terrain

static AM_Populate	Populate

static AM_EditMarker	EditMarker

static AM_Visibility	Visibility

static AM_Cinema	Cinema

static AM_Paint	Paint

static AM_FlagCell	FlagCell

static ActionMode	LastBuildMode

static SourceMaterial.Row	lastEditorMat

static bool	ignoreSound

static float[]	GameSpeeds = new float[4] { 0f, 1f, 2f, 5f }

static List< TCSimpleText >	simpleTexts = new List<TCSimpleText>()

static float	hotElementTimer

Static Public Attributes inherited from EClass
static Core	core

Protected Attributes
int	arrowIndex

float	timerStartRunning

bool	cursorMove

bool	keepWalking

Vector3	posOrigin

Vector3	posArrow

Vector2	vArrow

Vector3	clickPos

Properties
PointTarget	mouseTarget `[get]`

bool	autorun `[get]`

bool	ShouldHideTile `[get]`

override float	gameSpeed `[get]`

override bool	FixFocus `[get]`

override bool	ShouldPauseGame `[get]`

override bool	AllowWheelZoom `[get]`

override float	TargetZoom `[get]`

Properties inherited from AM_BaseGameMode
override AreaHighlightMode	AreaHihlight `[get]`

override bool	ShowActionHint `[get]`

override bool	HideSubWidgets `[get]`

override BaseTileSelector.HitType	hitType `[get]`

override BaseTileSelector.SelectType	selectType `[get]`

override BaseGameScreen	TargetGameScreen `[get]`

Point	hit `[get]`

Properties inherited from ActionMode
static AM_Adv	AdvOrRegion `[get]`

static bool	IsAdv `[get]`

virtual float	gameSpeed `[get]`

bool	IsActive `[get]`

virtual BaseTileSelector.HitType	hitType `[get]`

virtual BaseTileSelector.SelectType	selectType `[get]`

virtual BaseTileSelector.BoxType	boxType `[get]`

virtual bool	ContinuousClick `[get]`

virtual int	hitW `[get]`

virtual int	hitH `[get]`

HitSummary	Summary `[get]`

bool	Multisize `[get]`

virtual string	id `[get]`

virtual CursorInfo	DefaultCursor `[get]`

virtual string	idHelpTopic `[get]`

virtual string	idSound `[get]`

virtual bool	enableMouseInfo `[get]`

virtual bool	hideBalloon `[get]`

virtual string	textHintTitle `[get]`

virtual bool	AllowAutoClick `[get]`

virtual bool	ShowActionHint `[get]`

virtual bool	ShowMouseoverTarget `[get]`

virtual AreaHighlightMode	AreaHihlight `[get]`

virtual bool	CanSelectTile `[get]`

virtual bool	CanTargetOutsideBounds `[get]`

virtual bool	ShouldPauseGame `[get]`

virtual bool	FixFocus `[get]`

virtual bool	HideSubWidgets `[get]`

virtual bool	IsBuildMode `[get]`

virtual bool	ShowBuildWidgets `[get]`

virtual BuildMenu.Mode	buildMenuMode `[get]`

virtual bool	ShouldHideBuildMenu `[get]`

virtual bool	CanTargetFog `[get]`

virtual int	CostMoney `[get]`

virtual bool	AllowBuildModeShortcuts `[get]`

virtual bool	AllowMiddleClickFunc `[get]`

virtual bool	AllowHotbar `[get]`

virtual bool	AllowGeneralInput `[get]`

virtual bool	ShowMaskedThings `[get]`

virtual int	SelectorHeight `[get]`

virtual bool	AllowWheelZoom `[get]`

virtual float	TargetZoom `[get]`

virtual BaseTileMap.CardIconMode	cardIconMode `[get]`

virtual BaseGameScreen	TargetGameScreen `[get]`

virtual bool	IsNoMap `[get]`

virtual bool	UseSubMenu `[get]`

virtual bool	UseSubMenuSlider `[get]`

virtual bool	SubMenuAsGroup `[get]`

virtual int	SubMenuModeIndex `[get]`

virtual bool	ShowExtraHint `[get]`

BaseTileSelector	tileSelector `[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
float	gearAngle

Vector3	lastCamPos

bool	startedRun

Additional Inherited Members
Static Public Member Functions inherited from ActionMode
static void	OnGameInstantiated ()

Static Public Member Functions inherited from EClass
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)

Static Protected Attributes inherited from ActionMode
static Vector3	mpos

Detailed Description

Definition at line 5 of file AM_Adv.cs.

Member Function Documentation

◆ _OnUpdateInput()

override void AM_Adv._OnUpdateInput ( )

inlinevirtual

Reimplemented from AM_BaseGameMode.

Reimplemented in AM_ADV_Target.

Definition at line 474 of file AM_Adv.cs.

    {
        if (EClass.debug.enable)
        {
            EClass.player.flags.debugEnabled = true;
        }
        if (EClass.player.willAutoSave)
        {
            EClass.game.Save(isAutoSave: true);
            EClass.player.willAutoSave = false;
        }
        if (RecipeUpdater.dirty)
        {
            RecipeUpdater.dirty = false;
            EClass.game.updater.recipe.Build(EClass.pc.pos);
        }
        if (!EInput.rightMouse.pressing)
        {
            actCount = 0;
        }
        if (EInput.rightMouse.pressing && EInput.rightMouse.pressedLong && !EInput.leftMouse.down && EClass.pc.ai is TaskDesignation && (EClass.pc.ai as TaskDesignation).isRepeated)
        {
            if (!EInput.rightMouse.pressing || !EInput.leftMouse.pressing)
            {
                rightMouseTimer = 2.5f;
            }
        }
        else
        {
            rightMouseTimer -= Core.delta;
        }
        EClass.player.waitingInput = false;
        if (EClass.pc.ai is GoalAutoCombat && EClass.pc.ai.IsRunning)
        {
            if (!EClass.debug.enable && (EClass.pc.IsCriticallyWounded() || (EClass.game.config.autoCombat.abortOnHalfHP && ((EClass.pc.Evalue(1421) > 0) ? (EClass.pc.hp + EClass.pc.mana.value) : EClass.pc.hp) < EClass.player.autoCombatStartHP / 2)))
            {
                Msg.Say("abort_lowHP");
                EClass.pc.ai.Cancel();
            }
            else if (!EClass.debug.enable && EClass.game.config.autoCombat.abortOnAllyDying && EClass.pc.party.IsCriticallyWounded())
            {
                Msg.Say("abort_allyDying");
                EClass.pc.ai.Cancel();
            }
            else if (EClass.game.config.autoCombat.abortOnItemLoss && itemLost > 0)
            {
                Msg.Say("abort_itemLoss");
                EClass.pc.ai.Cancel();
            }
        }
        itemLost = 0;
        if (EClass.pc.HasNoGoal)
        {
            if (EClass.pc.WillConsumeTurn())
            {
                EClass.player.EndTurn();
                EClass.player.invlunerable = false;
                return;
            }
            if (EClass.player.lastTurn != EClass.pc.turn)
            {
                EClass.player.lastTurn = EClass.pc.turn;
                EClass.player.invlunerable = false;
                EClass.pc.RemoveCondition<ConInvulnerable>();
                OnBecomeNoGoal();
                if (!EClass.pc.HasNoGoal)
                {
                    return;
                }
            }
            EClass.player.waitingInput = true;
            if (AI_PlayMusic.keepPlaying)
            {
                Thing playingTool = AI_PlayMusic.playingTool;
                if (EInput.IsAnyKeyDown() || (playingTool.GetRootCard() != EClass.pc && (!playingTool.ExistsOnMap || playingTool.Dist(EClass.pc) > 1)))
                {
                    AI_PlayMusic.CancelKeepPlaying();
                    return;
                }
                UISong instance = UISong.Instance;
                if (!instance || instance.ratio > 0.85f)
                {
                    EClass.pc.SetAIImmediate(new AI_PlayMusic
                    {
                        tool = playingTool
                    });
                    return;
                }
            }
        }
        if (EClass.player.returnInfo != null && EClass.player.returnInfo.askDest)
        {
            EClass.player.returnInfo.askDest = false;
            int uidDest = 0;
            List<Zone> list = EClass.game.spatials.ListReturnLocations();
            if (list == null || list.Count == 0)
            {
                EClass.player.returnInfo = null;
                Msg.Say("returnAbort");
                return;
            }
            EClass.ui.AddLayer<LayerList>().SetList2(list, (Zone a) => a.NameWithDangerLevel, delegate(Zone a, ItemGeneral b)
            {
                uidDest = a.uid;
                if (a is Zone_Dungeon)
                {
                    uidDest = a.FindDeepestZone().uid;
                }
                EClass.player.returnInfo = new Player.ReturnInfo
                {
                    turns = EClass.rnd(10) + 10,
                    uidDest = uidDest
                };
                if (EClass.debug.instaReturn)
                {
                    EClass.player.returnInfo.turns = 1;
                    EClass.player.EndTurn();
                }
            }, delegate(Zone a, ItemGeneral b)
            {
                string lang = ((a is Zone_Dungeon) ? a.TextDeepestLv : "surface".lang());
                b.SetSubText(lang, 200, FontColor.Default, TextAnchor.MiddleRight);
                b.Build();
                b.button1.mainText.rectTransform.sizeDelta = new Vector2(350f, 20f);
            }).SetSize(500f)
                .SetOnKill(delegate
                {
                    if (uidDest == 0)
                    {
                        EClass.player.returnInfo = null;
                        Msg.Say("returnAbort");
                    }
                })
                .SetTitles("wReturn");
            return;
        }
        if (EClass.player.haltMove)
        {
            EClass.player.haltMove = false;
            TryCancelInteraction(sound: false);
            EInput.Consume(1);
            return;
        }
        if (keepWalking && (EInput.leftMouse.down || EInput.rightMouse.down))
        {
            keepWalking = false;
            EInput.Consume(1);
            return;
        }
        if (EClass.player.showShippingResult && !EClass.ui.IsActive)
        {
            EClass.player.showShippingResult = false;
            EClass.ui.AddLayer<LayerShippingResult>().Show();
        }
        if (pressedAction.IsPressing() || keepWalking)
        {
            pressedAction.timer += Core.delta;
            if (pressedAction.action != null)
            {
                if (pressedAction.canTurbo && ((autorun && pressedAction.timer > 0.45f) || Input.GetKey(KeyCode.LeftShift)))
                {
                    SetTurbo();
                }
                if (pressedAction.waitForTurn && !CanAct())
                {
                    return;
                }
                if (pressedAction.count == 1 && !pressedAction.ignoreCount)
                {
                    pressedAction.timerRepeat += Core.delta;
                    if (pressedAction.timerRepeat < 0.3f)
                    {
                        return;
                    }
                }
                pressedAction.count++;
                if (pressedAction.action())
                {
                    if (pressedAction.willEndTurn)
                    {
                        EClass.player.EndTurn(consume: false);
                        if (!pressedAction.repeat)
                        {
                            pressedAction.action = null;
                        }
                    }
                }
                else if (!pressedAction.repeat)
                {
                    pressedAction.action = null;
                }
            }
            else if ((autorun && pressedAction.timer > 0.5f) || Input.GetKey(KeyCode.LeftShift))
            {
                SetTurbo();
            }
            return;
        }
        if (pressedAction.button != null || EInput.hasShiftChanged)
        {
            updatePlans = true;
        }
        cursorMove = false;
        EClass.player.nextMove = Vector2.zero;
        if (EClass.pc.HasNoGoal)
        {
            EndTurbo();
        }
        pressedAction.button = null;
        pressedAction.axis = Vector2.zero;
        pressedAction.count = 0;
        pressedAction.timerRepeat = 0f;
        if (EClass.player.willEndTurn)
        {
            EClass.player.willEndTurn = false;
            EClass.player.EndTurn();
            return;
        }
        if (EInput.axis != Vector2.zero)
        {
            AxisMove();
            return;
        }
        timerStartRunning = 0f;
        startedRun = false;
        if (movedByKey && EClass.pc.ai is GoalManualMove)
        {
            EClass.pc.ai.Cancel();
        }
        movedByKey = false;
        CoreConfig.InputSetting input = EClass.core.config.input;
        if (EInput.leftMouse.down)
        {
            if (TryCancelInteraction())
            {
                return;
            }
            CursorSystem.ignoreCount = 5;
            SetPressedAction(EInput.leftMouse);
        }
        if (EInput.rightMouse.down)
        {
            if (TryCancelInteraction())
            {
                return;
            }
            CursorSystem.ignoreCount = 5;
            SetPressedAction(EInput.rightMouse);
        }
        if (EInput.middleMouse.pressing || EInput.isShiftDown)
        {
            if (HotItemHeld.CanChangeHeightByWheel())
            {
                if (EInput.wheel != 0)
                {
                    ActionMode.Build.ModAltitude(EInput.wheel);
                    SE.Tab();
                    WidgetCurrentTool.Instance.placer.Refresh();
                    EInput.wheel = 0;
                }
                if (EInput.middleMouse.pressedTimer > EInput.middleMouse.clickDuration)
                {
                    EInput.middleMouse.pressedTimer = 100f;
                }
            }
            else if (EClass.scene.mouseTarget.CanCycle())
            {
                if (EInput.wheel != 0)
                {
                    EClass.scene.mouseTarget.CycleTarget(EInput.wheel);
                    EInput.wheel = 0;
                }
                if (EInput.middleMouse.pressedTimer > EInput.middleMouse.clickDuration)
                {
                    EInput.middleMouse.pressedTimer = 100f;
                }
            }
        }
        if ((EInput.middleMouse.down || EInput.middleMouse.clicked || EInput.middleMouse.pressedLong) && !EClass.ui.contextMenu.isActive)
        {
            if (EInput.middleMouse.clicked)
            {
                if (HotItemHeld.CanRotate())
                {
                    HotItemHeld.taskBuild.recipe.Rotate();
                    SE.Rotate();
                }
                else
                {
                    DoFunc(input.middleClick);
                }
            }
            else if (EInput.middleMouse.pressedLong)
            {
                DoFunc(input.middlePressLong);
            }
        }
        if (EInput.mouse3.clicked)
        {
            DoFunc(input.mouse3Click);
        }
        else if (EInput.mouse3.pressedLong)
        {
            DoFunc(input.mouse3PressLong);
        }
        if (EInput.mouse4.clicked)
        {
            if (zoomOut)
            {
                ToggleZoom();
            }
            else
            {
                DoFunc(input.mouse4Click);
            }
        }
        else if (EInput.mouse4.pressedLong)
        {
            DoFunc(input.mouse4PressLong);
        }
        if (EInput.wheel != 0)
        {
            if (EClass.scene.mouseTarget.pos.Distance(EClass.pc.pos) <= 1 && HotItemHeld.CanChangeHeightByWheel())
            {
                if (EInput.wheel != 0)
                {
                    ActionMode.Build.ModAltitude(EInput.wheel);
                    SE.Tab();
                    WidgetCurrentTool.Instance.placer.Refresh();
                    EInput.wheel = 0;
                }
            }
            else
            {
                WidgetCurrentTool.Instance.ModSelected(-EInput.wheel);
                UpdatePlans();
            }
        }
        if (EClass.pc.HasNoGoal && EClass.player.currentHotItem.LookAtMouse)
        {
            EClass.pc.LookAt(planLeft.pos);
        }
        if (Input.GetKey(KeyCode.LeftControl))
        {
            if (Input.GetKeyDown(KeyCode.F))
            {
                EClass.ui.widgets.Toggle("Search")?.SoundActivate();
            }
            return;
        }
        switch (EInput.action)
        {
        case EAction.Search:
            EClass.ui.widgets.Toggle("Search")?.SoundActivate();
            break;
        case EAction.Meditate:
            if (EClass.pc.HasNoGoal)
            {
                EClass.pc.UseAbility("AI_Meditate", EClass.pc);
            }
            break;
        case EAction.Dump:
            TaskDump.TryPerform();
            break;
        case EAction.EmptyHand:
            if ((bool)WidgetCurrentTool.Instance)
            {
                WidgetCurrentTool.Instance.Select(-1);
            }
            break;
        case EAction.AutoCombat:
        {
            if (!EClass.scene.mouseTarget.isValid || !EClass.player.CanAcceptInput())
            {
                break;
            }
            List<Chara> list2 = EClass.scene.mouseTarget.pos.ListCharas();
            list2.Sort((Chara a, Chara b) => a.hostility - b.hostility);
            foreach (Chara item in list2)
            {
                if (item.hostility < Hostility.Friend)
                {
                    EClass.pc.SetAIImmediate(new GoalAutoCombat(item));
                    return;
                }
            }
            Msg.Say("noTargetFound");
            break;
        }
        case EAction.QuickSave:
            if (EClass.debug.enable || !EClass.game.principal.disableManualSave)
            {
                if (!EClass.pc.HasNoGoal)
                {
                    SE.Beep();
                }
                else
                {
                    EClass.game.Save();
                }
            }
            break;
        case EAction.QuickLoad:
        {
            if (!EClass.debug.enable && EClass.game.principal.disableManualSave)
            {
                SE.Beep();
                break;
            }
            string slot = Game.id;
            bool isCloud = EClass.game.isCloud;
            Game.TryLoad(slot, isCloud, delegate
            {
                EClass.core.WaitForEndOfFrame(delegate
                {
                    EClass.scene.Init(Scene.Mode.None);
                    Game.Load(slot, isCloud);
                });
            });
            break;
        }
        case EAction.Report:
            if (!EClass.debug.enable)
            {
                EClass.ui.ToggleFeedback();
            }
            break;
        case EAction.Wait:
        {
            if (EClass.debug.boradcast)
            {
                EClass.debug.BroadcastNext();
                break;
            }
            if (!EClass.pc.HasNoGoal)
            {
                if (EClass.pc.ai.CanManualCancel())
                {
                    EClass.pc.ai.Cancel();
                }
                break;
            }
            if (EClass._zone.IsRegion)
            {
                EClass.player.EnterLocalZone();
                break;
            }
            TraitNewZone traitNewZone = EClass.pc.pos.FindThing<TraitNewZone>();
            if (traitNewZone != null && traitNewZone.CanAutoEnter())
            {
                traitNewZone.MoveZone();
                EInput.WaitReleaseKey();
            }
            else
            {
                ACT.Wait.Perform(EClass.pc);
                EClass.player.EndTurn();
            }
            break;
        }
        case EAction.Fire:
            if (!EClass.player.HasValidRangedTarget() || EInput.isShiftDown)
            {
                EClass.player.TargetRanged();
                if (EClass.player.HasValidRangedTarget())
                {
                    SE.Play("lock_on");
                }
                if (EInput.keyFire.IsRepeating)
                {
                    EInput.keyFire.Consume();
                }
            }
            else
            {
                if (!EClass.pc.HasNoGoal)
                {
                    break;
                }
                Thing thing = EClass.player.currentHotItem.Thing;
                bool reloading = EClass.pc.HasCondition<ConReload>();
                if (thing == null || !thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                {
                    foreach (UIList.ButtonPair button in WidgetCurrentTool.Instance.list.buttons)
                    {
                        if (button.obj is Thing thing2 && thing2.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                        {
                            thing = thing2;
                            break;
                        }
                    }
                }
                if (thing == null || !thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                {
                    thing = EClass.pc.things.Find((Thing _t) => _t.isEquipped && _t.CanAutoFire(EClass.pc, EClass.player.target, reloading));
                }
                if (thing == null || !thing.CanAutoFire(EClass.pc, EClass.player.target, reloading))
                {
                    break;
                }
                if (thing.HasTag(CTAG.throwWeapon))
                {
                    _ = EClass.player.target.pos;
                    if (ActThrow.CanThrow(EClass.pc, thing, EClass.player.target))
                    {
                        ACT.Throw.target = thing;
                        ACT.Throw.Perform(EClass.pc, EClass.player.target, EClass.player.target.pos);
                        EClass.player.EndTurn(consume: false);
                        SetTurbo();
                    }
                }
                else if (thing.trait is TraitAbility traitAbility)
                {
                    if (traitAbility.act.CanPerform(EClass.pc, EClass.player.target, EClass.player.target.pos) && EClass.pc.UseAbility(traitAbility.act.source.alias, EClass.player.target, EClass.player.target.pos))
                    {
                        EClass.player.EndTurn(consume: false);
                    }
                }
                else
                {
                    if (!(thing.trait is TraitToolRange))
                    {
                        break;
                    }
                    EClass.pc.ranged = thing;
                    if (ACT.Ranged.CanPerform(EClass.pc, EClass.player.target))
                    {
                        EClass.player.renderThing = thing;
                        if (ACT.Ranged.Perform(EClass.pc, EClass.player.target))
                        {
                            EClass.player.EndTurn(consume: false);
                            SetTurbo();
                        }
                    }
                }
            }
            break;
        }
    }

◆ AxisMove()

void AM_Adv.AxisMove ( )

inline

Definition at line 1092 of file AM_Adv.cs.

    {
        Vector2 vector = ((EClass.core.config.input.altKeyAxis && !EClass._zone.IsRegion) ? Util.ConvertAxis(EInput.axis) : EInput.axis);
        if (!startedRun)
        {
            if ((autorun && timerStartRunning >= 0.7f) || Input.GetKey(KeyCode.LeftShift))
            {
                SetTurbo();
                startedRun = true;
            }
        }
        else if (Input.GetKeyDown(KeyCode.LeftShift))
        {
            SetTurbo((turbo == 0f) ? (-1) : 0);
        }
        if (EClass.core.config.test.alwaysRun)
        {
            SetTurbo((!Input.GetKey(KeyCode.LeftShift)) ? (-1) : 0);
        }
        timerStartRunning += Core.delta;
        EClass.player.nextMove.x = 0f;
        EClass.player.nextMove.y = 0f;
        Point point = EClass.pc.pos.Copy();
        point.x += (int)vector.x;
        point.z += (int)vector.y;
        if (EClass.pc.HasNoGoal && !point.IsValid && EClass.player.CanExitBorder(point))
        {
            EClass.player.ExitBorder();
            return;
        }
        axisTarget.Update(point);
        pressedAction.Init(Vector3.zero);
        planKeyboard.Update(axisTarget);
        if (planKeyboard.HasAct)
        {
            if (planKeyboard.list[0].act.ResetAxis && EClass.pc.ai is GoalManualMove)
            {
                EInput.forbidAxis = EInput.axis;
                EClass.pc.ai.Cancel();
            }
            else
            {
                pressedAction.axis = EInput.axis;
                pressedAction.SetAction(planKeyboard.GetAction(), _canTurbo: true, planKeyboard.WillEndTurn, _waitForTurn: true, planKeyboard.canRepeat);
            }
            return;
        }
        EClass.player.nextMove.x = vector.x;
        EClass.player.nextMove.y = vector.y;
        if (!(EClass.pc.ai is GoalManualMove) && EClass.pc.HasNoGoal && GoalManualMove.CanMove())
        {
            SetManualMove();
        }
        movedByKey = true;
    }

References EClass._zone, Chara.ai, CoreConfig.Test.alwaysRun, autorun, EInput.axis, axisTarget, AIAct.Cancel(), Player.CanExitBorder(), GoalManualMove.CanMove(), ActPlan.canRepeat, Core.config, Point.Copy(), EClass.core, Core.delta, Player.ExitBorder(), ActPlan.GetAction(), ActPlan.HasAct, Chara.HasNoGoal, AM_Adv.PressedAction.Init(), Spatial.IsRegion, Point.IsValid, ActPlan.list, movedByKey, EClass.pc, planKeyboard, EClass.player, Card.pos, pressedAction, AM_Adv.PressedAction.SetAction(), SetManualMove(), SetTurbo(), startedRun, CoreConfig.test, timerStartRunning, turbo, PointTarget.Update(), ActPlan.Update(), Util, ActPlan.WillEndTurn, Point.x, and Point.z.

Referenced by _OnUpdateInput().

◆ CanAct()

bool AM_Adv.CanAct ( )

inline

Definition at line 1087 of file AM_Adv.cs.

    {
        return EClass.pc.HasNoGoal;
    }

References Chara.HasNoGoal, and EClass.pc.

Referenced by _OnUpdateInput().

◆ ClearPlans()

void AM_Adv.ClearPlans ( )

inline

Definition at line 436 of file AM_Adv.cs.

    {
        planLeft.Clear();
        planRight.Clear();
        updatePlans = true;
    }

References ActPlan.Clear(), planLeft, planRight, and updatePlans.

Referenced by Chara.Kick(), and ToggleZoom().

◆ EndTurbo()

void AM_Adv.EndTurbo ( )

inline

Definition at line 1055 of file AM_Adv.cs.

    {
        turbo = 0f;
    }

References turbo.

Referenced by _OnUpdateInput(), OnDeactivate(), and PressedActionMove().

◆ GetDefaultTile()

override int AM_Adv.GetDefaultTile ( Point p )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 318 of file AM_Adv.cs.

    {
        if (!p.IsSync)
        {
            return 30;
        }
        return 0;
    }

References Point.IsSync.

◆ HighlightWall()

override bool AM_Adv.HighlightWall ( Point p )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 252 of file AM_Adv.cs.

    {
        if (EClass.pc.held != null)
        {
            return TaskMine.CanMine(p, EClass.pc.held);
        }
        return false;
    }

References TaskMine.CanMine(), Chara.held, and EClass.pc.

◆ OnActivate()

override void AM_Adv.OnActivate ( )

inlinevirtual

Reimplemented from ActionMode.

Reimplemented in AM_ADV_Target.

Definition at line 261 of file AM_Adv.cs.

    {
        if ((bool)WidgetMouseover.Instance)
        {
            WidgetMouseover.Instance.Hide();
        }
        ActionMode.DefaultMode = this;
        pressedAction.Init();
        EClass.pc.ai.Cancel();
        EClass.screen.tileMap.RefreshHeight();
        (EClass.pc.renderer as CharaRenderer).first = true;
        EClass.pc.renderer.SetFirst(first: true, EClass.pc.pos.PositionCenter());
        EClass.screen.FocusPC();
        EClass.screen.RefreshPosition();
    }

References Chara.ai, AIAct.Cancel(), BaseGameScreen.FocusPC(), WidgetMouseover.Hide(), AM_Adv.PressedAction.Init(), WidgetMouseover.Instance, EClass.pc, Card.pos, Point.PositionCenter(), pressedAction, BaseTileMap.RefreshHeight(), BaseGameScreen.RefreshPosition(), Card.renderer, EClass.screen, CardRenderer.SetFirst(), and BaseGameScreen.tileMap.

◆ OnAfterUpdate()

override void AM_Adv.OnAfterUpdate ( )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 339 of file AM_Adv.cs.

    {
        Vector3 position = (mouseTarget.pos.IsValid ? mouseTarget.pos.PositionAuto() : EClass.pc.pos.PositionAuto());
        position = Camera.main.WorldToScreenPoint(position);
        position.z = 0f;
        position += EClass.ui.hud.transRightPos * Mathf.Min(0f, EClass.screen.Zoom - 1f);
        EClass.ui.hud.transRight.position = position;
        EClass.player.MarkMapHighlights();
    }

References Player.MarkMapHighlights(), mouseTarget, EClass.pc, EClass.player, Card.pos, PointTarget.pos, Point.PositionAuto(), EClass.screen, and BaseGameScreen.Zoom.

◆ OnBecomeNoGoal()

void AM_Adv.OnBecomeNoGoal ( )

inline

Definition at line 443 of file AM_Adv.cs.

    {
        EClass.player.renderThing = null;
        if (EClass.player.hotItemToRestore != null)
        {
            if (EClass.player.currentHotItem != EClass.player.hotItemToRestore)
            {
                EClass.player.SetCurrentHotItem(null);
            }
            EClass.player.hotItemToRestore = null;
        }
        if (!EClass.core.config.game.alwaysUpdateRecipe)
        {
            EClass.game.updater.recipe.Build(EClass.pc.pos);
        }
        if (EClass.rnd(30) == 0 && EClass.pc.HasElement(1559))
        {
            List<Thing> list = EClass.pc.things.List((Thing a) => a.trait is TraitPotion, onlyAccessible: true);
            if (list.Count > 0)
            {
                EClass.pc.Drink(list.RandomItem());
                EClass.player.EndTurn();
            }
        }
        if ((int)(Time.timeSinceLevelLoad / 60f / 60f) > Player.realHour)
        {
            EClass.player.OnAdvanceRealHour();
        }
        Tutorial.TryPlayReserve();
    }

References CoreConfig.GameConfig.alwaysUpdateRecipe, RecipeUpdater.Build(), Core.config, EClass.core, Player.currentHotItem, Chara.Drink(), Player.EndTurn(), CoreConfig.game, EClass.game, Card.HasElement(), Player.hotItemToRestore, ThingContainer.List(), Player.OnAdvanceRealHour(), EClass.pc, EClass.player, Card.pos, Player.realHour, GameUpdater.recipe, EClass.rnd(), Player.SetCurrentHotItem(), Card.things, Card.trait, Tutorial.TryPlayReserve(), and Game.updater.

Referenced by _OnUpdateInput().

◆ OnBeforeUpdate()

override void AM_Adv.OnBeforeUpdate ( )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 327 of file AM_Adv.cs.

    {
        if (EClass.pc.renderer.IsMoving)
        {
            isMoving = true;
        }
        else
        {
            isMoving = false;
        }
    }

References isMoving, CardRenderer.IsMoving, EClass.pc, and Card.renderer.

◆ OnDeactivate()

override void AM_Adv.OnDeactivate ( )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 277 of file AM_Adv.cs.

    {
        EndTurbo();
    }

References EndTurbo().

◆ OnRenderTile()

override void AM_Adv.OnRenderTile	(	Point	point,
		HitResult	result,
		int	dir
	)

inlinevirtual

Reimplemented from ActionMode.

Reimplemented in AM_Region.

Definition at line 282 of file AM_Adv.cs.

    {
        if (ShouldHideTile)
        {
            return;
        }
        EClass.player.currentHotItem.OnRenderTile(point, result, dir);
        base.OnRenderTile(point, result, dir);
        if (EClass.game.config.highlightArea && point.Installed != null && (EClass._zone.IsPCFaction || EClass._zone is Zone_Tent))
        {
            point.Installed.trait.OnRenderTile(point, result, dir);
        }
        if (!EClass.core.config.game.highlightEnemy)
        {
            return;
        }
        foreach (Chara item in point.ListCharas())
        {
            if (!item.IsHostile(EClass.pc))
            {
                continue;
            }
            {
                foreach (Chara chara in EClass._map.charas)
                {
                    if (chara.isSynced && chara.IsHostile(EClass.pc) && !chara.IsMultisize)
                    {
                        Vector3 vector = chara.pos.Position();
                        EClass.screen.guide.passGuideFloor.Add(vector.x, vector.y, vector.z - 0.01f, 23f, 0.3f);
                    }
                }
                break;
            }
        }
    }

References EClass._map, EClass._zone, MeshPass.Add(), Map.charas, Core.config, Game.config, EClass.core, Player.currentHotItem, CoreConfig.game, EClass.game, BaseGameScreen.guide, Game.Config.highlightArea, CoreConfig.GameConfig.highlightEnemy, Point.Installed, Chara.IsHostile(), Chara.IsMultisize, Zone.IsPCFaction, Chara.isSynced, item, HotItem.OnRenderTile(), Trait.OnRenderTile(), ScreenGuide.passGuideFloor, EClass.pc, EClass.player, Card.pos, Point.Position(), EClass.screen, ShouldHideTile, and Card.trait.

◆ OnUpdateCursor()

override void AM_Adv.OnUpdateCursor ( )

inlinevirtual

Reimplemented from ActionMode.

Definition at line 349 of file AM_Adv.cs.

    {
        RefreshArrow();
        CursorInfo info = ((EClass.ui.layers.Count == 0 && !EClass.ui.isPointerOverUI) ? CursorSystem.Instance.arrows[arrowIndex] : null);
        CursorSystem.leftIcon = null;
        bool flag = (EClass.pc.ai.IsRunning || turbo != 0f || pressedAction.action != null) && !EClass.pc.HasNoGoal && !(EClass.pc.ai is GoalManualMove);
        if (flag && !EClass.ui.isPointerOverUI)
        {
            CursorSystem.leftIcon = CursorSystem.IconGear;
            CursorSystem.leftIconAngle = (int)(gearAngle / 45f) * 45;
        }
        if (!cursorMove && (mouseTarget.hasTargetChanged || !mouseTarget.pos.Equals(planLeft.pos) || planLeft.performed || planRight.performed))
        {
            updatePlans = true;
        }
        if (!ShouldHideTile)
        {
            if (planLeft.HasAct)
            {
                info = planLeft.CursorIcon;
            }
            else if (planRight.HasAct)
            {
                info = planRight.CursorIcon;
            }
        }
        gearAngle += Core.gameDelta * 200f;
        CursorSystem.SetCursor(info);
        if ((updatePlans && !flag) || EClass.pc.IsDisabled)
        {
            UpdatePlans();
        }
        if (CursorSystem.ignoreCount < 0)
        {
            UpdateLangWheel();
            EClass.ui.hud.transRight.SetActive(enable: true);
            bool flag2 = !ShouldHideTile && !pressedAction.hideRightInfo && !EClass.ui.contextMenu.isActive;
            EClass.ui.hud.textLeft.SetActive(flag2 && planLeft.ShowAct);
            EClass.ui.hud.textRight.SetActive(flag2 && planRight.ShowAct);
            EClass.ui.hud.textMiddle.SetActive(flag2 && textMiddle != null);
            EClass.ui.hud.textWheel.SetActive(flag2 && textWheel != null);
            if (EClass.ui.hud.textLeft.gameObject.activeSelf)
            {
                EClass.ui.hud.textLeft.rectTransform.anchoredPosition = EClass.ui.hud.leftTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textRight.gameObject.activeSelf)
            {
                EClass.ui.hud.textRight.rectTransform.anchoredPosition = EClass.ui.hud.rightTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textMiddle.gameObject.activeSelf)
            {
                EClass.ui.hud.textMiddle.rectTransform.anchoredPosition = EClass.ui.hud.wheelTextPos * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            if (EClass.ui.hud.textWheel.gameObject.activeSelf)
            {
                EClass.ui.hud.textWheel.rectTransform.anchoredPosition = (EClass.ui.hud.textMiddle.gameObject.activeSelf ? EClass.ui.hud.wheelTextPos2 : EClass.ui.hud.wheelTextPos) * Mathf.Max(1f, EClass.screen.Zoom) / EClass.core.uiScale;
            }
            EClass.ui.hud.imageRight.SetActive(flag2 && planRight.HasAct);
        }
    }

References Chara.ai, arrowIndex, CursorSystem.arrows, EClass.core, ActPlan.CursorIcon, cursorMove, Point.Equals(), gearAngle, ActPlan.HasAct, Chara.HasNoGoal, PointTarget.hasTargetChanged, CursorSystem.IconGear, CursorSystem.ignoreCount, CursorSystem.Instance, Chara.IsDisabled, mouseTarget, EClass.pc, ActPlan.performed, planLeft, planRight, ActPlan.pos, PointTarget.pos, RefreshArrow(), EClass.screen, CursorSystem.SetCursor(), ShouldHideTile, ActPlan.ShowAct, textMiddle, textWheel, turbo, EClass.ui, Core.uiScale, UpdateLangWheel(), updatePlans, UpdatePlans(), and BaseGameScreen.Zoom.

◆ PressedActionMove()

bool AM_Adv.PressedActionMove ( Point pos )

inline

Definition at line 1205 of file AM_Adv.cs.

    {
        if (EClass.player.TooHeavyToMove())
        {
            return false;
        }
        if (pos != null)
        {
            if (EInput.leftMouse.clicked)
            {
                if (EClass.pc.pos.Equals(pos) || !pos.IsValid)
                {
                    EClass.player.nextMove = Vector2.zero;
                    EClass.pc.ai.Cancel();
                }
                else if (PathManager.Instance.RequestPathImmediate(EClass.pc.pos, pos, EClass.pc).HasPath && (zoomOut || (!pos.Equals(GoalManualMove.lastPoint) && !pos.Equals(GoalManualMove.lastlastPoint))))
                {
                    if (!EClass.pc.IsEnemyOnPath(pos))
                    {
                        EClass.pc.SetAIImmediate(new AI_Goto(pos, 0));
                    }
                }
                else
                {
                    EClass.player.nextMove = Vector2.zero;
                    EClass.pc.ai.Cancel();
                }
                return false;
            }
            if (EInput.rightMouse.down && EClass.core.config.input.autowalk)
            {
                keepWalking = true;
            }
        }
        if (autorun)
        {
            if (Vector2.Distance(posOrigin, posArrow) > EClass.core.config.game.runDistance)
            {
                SetTurbo();
            }
            else if (turbo != 0f && !Input.GetKey(KeyCode.LeftShift) && !EClass.core.config.input.keepRunning && !zoomOut && Vector2.Distance(posOrigin, posArrow) < 1.2f)
            {
                EndTurbo();
            }
        }
        if (pos != null && !cursorMove)
        {
            Vector2Int vector2Int = new Vector2Int(pos.x - EClass.pc.pos.x, pos.z - EClass.pc.pos.z);
            if (Mathf.Abs(vector2Int.x) > 1 || Mathf.Abs(vector2Int.y) > 1)
            {
                int num = Mathf.Max(Mathf.Abs(vector2Int.x), Mathf.Abs(vector2Int.y));
                vector2Int.x /= num;
                vector2Int.y /= num;
            }
            EClass.player.nextMove = vector2Int;
            Point.shared.Set(EClass.pc.pos.x + vector2Int.x, EClass.pc.pos.z + vector2Int.y);
        }
        else
        {
            EClass.player.nextMove = vArrow;
            Point.shared.Set(EClass.pc.pos.x + (int)vArrow.x, EClass.pc.pos.z + (int)vArrow.y);
        }
        if (EClass.pc.IsEnemyOnPath(Point.shared))
        {
            if (EClass.pc.ai is GoalManualMove)
            {
                EClass.pc.ai.Cancel();
            }
            return true;
        }
        if (!Point.shared.IsInBounds)
        {
            if (EClass.pc.HasNoGoal && EClass.player.CanExitBorder(Point.shared))
            {
                EClass.player.ExitBorder();
                return false;
            }
            if (EClass.pc.ai is GoalManualMove)
            {
                EClass.pc.ai.Cancel();
            }
            return true;
        }
        if (!(EClass.pc.ai is GoalManualMove))
        {
            if (EClass.pc.HasNoGoal)
            {
                if (GoalManualMove.CanMove())
                {
                    SetTurbo(EInput.isShiftDown ? (-1) : 0);
                    EClass.pc.SetAIImmediate(new GoalManualMove());
                }
                cursorMove = true;
            }
        }
        else
        {
            cursorMove = true;
        }
        return true;
    }

References Chara.ai, autorun, CoreConfig.InputSetting.autowalk, AIAct.Cancel(), Player.CanExitBorder(), GoalManualMove.CanMove(), ButtonState.clicked, Core.config, EClass.core, cursorMove, ButtonState.down, EndTurbo(), Point.Equals(), Player.ExitBorder(), CoreConfig.game, Chara.HasNoGoal, CoreConfig.input, PathManager.Instance, Chara.IsEnemyOnPath(), Point.IsInBounds, EInput.isShiftDown, Point.IsValid, CoreConfig.InputSetting.keepRunning, keepWalking, GoalManualMove.lastlastPoint, GoalManualMove.lastPoint, EInput.leftMouse, EClass.pc, EClass.player, Card.pos, posArrow, posOrigin, PathManager.RequestPathImmediate(), EInput.rightMouse, CoreConfig.GameConfig.runDistance, Point.Set(), Chara.SetAIImmediate(), SetTurbo(), Point.shared, Player.TooHeavyToMove(), turbo, vArrow, Point.x, Point.z, and zoomOut.

Referenced by SetPressedAction().

◆ RefreshArrow()

virtual void AM_Adv.RefreshArrow ( )

inlinevirtual

Reimplemented in AM_Region.

Definition at line 1307 of file AM_Adv.cs.

    {
        bool flag = zoomOut || EInput.rightMouse.pressedLong;
        if (flag && mouseTarget.pos.Equals(EClass.pc.pos))
        {
            vArrow = Vector2.zero;
            EClass.player.nextMove = vArrow;
            return;
        }
        posOrigin = (flag ? EClass.pc.pos.PositionCenter() : CursorSystem.posOrigin);
        posArrow = CursorSystem.position;
        float num;
        if (cursorMove || EClass.pc.pos.Distance(base.hit) > 1)
        {
            num = Util.GetAngle(posArrow.x - posOrigin.x, posArrow.y - posOrigin.y) + 90f + 22.5f;
        }
        else
        {
            num = Util.GetAngle(EClass.pc.pos.x - base.hit.x, EClass.pc.pos.z - base.hit.z) - 22.5f;
            if (num < 0f)
            {
                num = 360f + num;
            }
        }
        if ((bool)WidgetUnityChan.Instance)
        {
            WidgetUnityChan.Instance.Refresh(num);
        }
        if (clickPos != Vector3.zero)
        {
            if (Vector3.Distance(Input.mousePosition, clickPos) < EClass.core.config.game.angleMargin)
            {
                return;
            }
            clickPos = Vector3.zero;
        }
        vArrow = Vector2.zero;
        int _angle = 0;
        Action<int, int, int, int> action = delegate(int x, int y, int i, int a)
        {
            vArrow.x = x;
            vArrow.y = y;
            arrowIndex = i;
            _angle = -a;
        };
        if (num < 45f || num >= 360f)
        {
            action(-1, -1, 0, 0);
        }
        else if (num < 90f)
        {
            action(-1, 0, 1, 35);
        }
        else if (num < 135f)
        {
            action(-1, 1, 2, 90);
        }
        else if (num < 180f)
        {
            action(0, 1, 3, 145);
        }
        else if (num < 225f)
        {
            action(1, 1, 4, 180);
        }
        else if (num < 270f)
        {
            action(1, 0, 5, 215);
        }
        else if (num < 315f)
        {
            action(1, -1, 6, 270);
        }
        else
        {
            action(0, -1, 7, 325);
        }
    }

References CoreConfig.GameConfig.angleMargin, arrowIndex, clickPos, Core.config, EClass.core, cursorMove, Point.Distance(), Point.Equals(), CoreConfig.game, WidgetUnityChan.Instance, mouseTarget, EClass.pc, Card.pos, PointTarget.pos, posArrow, CursorSystem.position, Point.PositionCenter(), posOrigin, CursorSystem.posOrigin, ButtonState.pressedLong, WidgetUnityChan.Refresh(), EInput.rightMouse, Util, vArrow, Point.x, Point.z, and zoomOut.

Referenced by Scene.Init(), and OnUpdateCursor().

◆ SetManualMove()

void AM_Adv.SetManualMove ( )

inline

Definition at line 1148 of file AM_Adv.cs.

    {
        if (!EClass.player.TooHeavyToMove())
        {
            SetTurbo(EInput.isShiftDown ? (-1) : 0);
            EClass.pc.SetAIImmediate(new GoalManualMove());
            cursorMove = true;
        }
    }

References cursorMove, EInput.isShiftDown, EClass.pc, EClass.player, Chara.SetAIImmediate(), SetTurbo(), and Player.TooHeavyToMove().

Referenced by AxisMove(), and Scene.Init().

◆ SetPressedAction()

void AM_Adv.SetPressedAction ( ButtonState button )

inline

Definition at line 1158 of file AM_Adv.cs.

    {
        if (updatePlans)
        {
            UpdatePlans();
        }
        bool flag = button == EInput.leftMouse;
        pressedAction.Init(button);
        if (isMouseOnMap)
        {
            if (!flag)
            {
                if (planRight.HasAct)
                {
                    pressedAction.SetPlan(planRight);
                }
                else
                {
                    SE.Play("noAction");
                }
                return;
            }
            if (planLeft.HasAct)
            {
                pressedAction.SetPlan(planLeft);
                return;
            }
        }
        if (!flag)
        {
            return;
        }
        Point pos = ((!isMouseOnMap) ? null : base.hit.Copy());
        if (pos != null && (EClass.pc.pos.Equals(pos) || (EClass.pc.pos.Distance(pos) == 1 && pos.cell.blocked)))
        {
            return;
        }
        planLeft.Update(mouseTarget);
        if (!planLeft.HasAct)
        {
            clickPos = Input.mousePosition;
            pressedAction.SetAction(() => PressedActionMove(pos), _canTurbo: false, _willEndTurn: false, _waitForTurn: false);
            pressedAction.repeat = zoomOut;
            pressedAction.ignoreCount = true;
        }
    }

References Algorithms.WeightCell.blocked, Point.cell, clickPos, Point.Distance(), Point.Equals(), ActPlan.HasAct, AM_Adv.PressedAction.Init(), AM_BaseGameMode.isMouseOnMap, EInput.leftMouse, mouseTarget, EClass.pc, planLeft, planRight, Card.pos, pressedAction, PressedActionMove(), AM_Adv.PressedAction.SetAction(), AM_Adv.PressedAction.SetPlan(), ActPlan.Update(), updatePlans, UpdatePlans(), and zoomOut.

Referenced by _OnUpdateInput(), and Scene.Init().

◆ SetTurbo()

void AM_Adv.SetTurbo ( int mtp = -1 )

inline

Definition at line 1040 of file AM_Adv.cs.

    {
        if (mtp == -1)
        {
            if (turbo <= EClass.setting.defaultTurbo)
            {
                turbo = EClass.setting.defaultTurbo;
            }
        }
        else
        {
            turbo = mtp;
        }
    }

References GameSetting.defaultTurbo, EClass.setting, and turbo.

Referenced by _OnUpdateInput(), AxisMove(), Thing.DoAct(), UIInventory.DoAct(), LayerCraft.OnClickCraft(), HotItemFocusPos.Perform(), ActPlan.Item.Perform(), PressedActionMove(), LayerCraftFloat.RefreshCraft(), WidgetSearch.RefreshList(), AIProgress.Run(), GoalCombat.Run(), SetManualMove(), AIAct.Start(), Chara.Tick(), and AI_Goto.TryGoTo().

◆ ShowAllAction()

void AM_Adv.ShowAllAction ( )

inline

Definition at line 1014 of file AM_Adv.cs.

    {
        planAll.Update(mouseTarget);
        if (planAll.HasAct)
        {
            planAll.ShowContextMenu();
            return;
        }
        if (EClass._zone.IsRegion)
        {
            EClass.ui.ToggleLayer<LayerTravel>();
            return;
        }
        if (EClass.debug.godBuild)
        {
            Thing lastThing = planAll.pos.LastThing;
            if (lastThing != null && EClass.pc.pos.Distance(planAll.pos) > 1 && lastThing.W == lastThing.H)
            {
                lastThing.Rotate();
                SE.Rotate();
                return;
            }
        }
        SE.BeepSmall();
    }

References EClass._zone, EClass.debug, Point.Distance(), CoreDebug.godBuild, Card.H, ActPlan.HasAct, Spatial.IsRegion, Point.LastThing, mouseTarget, EClass.pc, planAll, ActPlan.pos, Card.pos, Card.Rotate(), ActPlan.ShowContextMenu(), EClass.ui, and ActPlan.Update().

Referenced by ActionMode.DoFunc().

◆ ToggleZoom()

void AM_Adv.ToggleZoom ( )

inline

Definition at line 1060 of file AM_Adv.cs.

    {
        EClass.screen.focusPos = null;
        zoomOut2 = !zoomOut2;
        SE.Play(zoomOut2 ? "zoomOut" : "zoomIn");
        EClass.ui.widgets.OnChangeActionMode();
        ClearPlans();
    }

References ClearPlans(), EClass.ui, and zoomOut2.

Referenced by _OnUpdateInput(), and ActionMode.DoFunc().

◆ TryCancelInteraction()

bool AM_Adv.TryCancelInteraction ( bool sound = true )

inline

Definition at line 1069 of file AM_Adv.cs.

    {
        if (!EClass.pc.HasNoGoal && EClass.pc.ai.IsRunning)
        {
            if (EClass.pc.ai.CanManualCancel())
            {
                EClass.pc.ai.Cancel();
                if (sound)
                {
                    SE.CancelAction();
                }
            }
            EInput.Consume(consumeAxis: true);
            return true;
        }
        return false;
    }

References Chara.ai, AIAct.Cancel(), AIAct.CanManualCancel(), EInput.Consume(), Chara.HasNoGoal, AIAct.IsRunning, and EClass.pc.

Referenced by _OnUpdateInput(), and Chara.Tick().

◆ UpdateLangWheel()

void AM_Adv.UpdateLangWheel ( )

inline

Definition at line 417 of file AM_Adv.cs.

    {
        textWheel = null;
        textMiddle = null;
        if (planRight.HasAct)
        {
            if (EClass.scene.mouseTarget.pos.Distance(EClass.pc.pos) <= 1 && HotItemHeld.CanChangeHeightByWheel())
            {
                textWheel = "textWheel_changeHeight".lang();
            }
            else if (HotItemHeld.CanRotate())
            {
                textMiddle = "textMiddle_rotate".lang(EInput.keys.mouseMiddle.key.ToString() ?? "");
            }
            EClass.ui.hud.textWheel.SetText(textWheel.IsEmpty(""));
            EClass.ui.hud.textMiddle.SetText(textMiddle.IsEmpty(""));
        }
    }

References HotItemHeld.CanChangeHeightByWheel(), HotItemHeld.CanRotate(), Point.Distance(), ActPlan.HasAct, EInput.KeyMap.key, EInput.keys, EInput.KeyMapManager.mouseMiddle, Scene.mouseTarget, EClass.pc, planRight, Card.pos, PointTarget.pos, EClass.scene, textMiddle, textWheel, and EClass.ui.

Referenced by OnUpdateCursor().

◆ UpdatePlans()

void AM_Adv.UpdatePlans ( )

inline

Definition at line 410 of file AM_Adv.cs.

    {
        planLeft.Update(mouseTarget);
        planRight.Update(mouseTarget);
        updatePlans = false;
    }

References mouseTarget, planLeft, planRight, ActPlan.Update(), and updatePlans.

Referenced by _OnUpdateInput(), OnUpdateCursor(), WidgetCurrentTool.Select(), SetPressedAction(), and ActionMode.UpdateInput().

Member Data Documentation

◆ actCount

int AM_Adv.actCount

static

Definition at line 101 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), TaskBuild.GetHitResult(), ActPlan.Item.Perform(), and TaskPoint.Run().

◆ arrowIndex

int AM_Adv.arrowIndex

protected

Definition at line 111 of file AM_Adv.cs.

Referenced by OnUpdateCursor(), RefreshArrow(), and AM_Region.RefreshArrow().

◆ axisTarget

PointTarget AM_Adv.axisTarget

Initial value:

= new PointTarget
    {
        mouse = false
    }

Definition at line 127 of file AM_Adv.cs.

Referenced by AxisMove().

◆ clickPos

Vector3 AM_Adv.clickPos

protected

Definition at line 168 of file AM_Adv.cs.

Referenced by RefreshArrow(), AM_Region.RefreshArrow(), and SetPressedAction().

◆ cursorMove

bool AM_Adv.cursorMove

protected

Definition at line 115 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), OnUpdateCursor(), PressedActionMove(), RefreshArrow(), AM_Region.RefreshArrow(), and SetManualMove().

◆ gearAngle

float AM_Adv.gearAngle

private

Definition at line 156 of file AM_Adv.cs.

Referenced by OnUpdateCursor().

◆ isMoving

bool AM_Adv.isMoving

Definition at line 160 of file AM_Adv.cs.

Referenced by OnBeforeUpdate().

◆ itemLost

int AM_Adv.itemLost

Definition at line 109 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and Map.TryShatter().

◆ keepWalking

bool AM_Adv.keepWalking

protected

Definition at line 117 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and PressedActionMove().

◆ lastCamPos

Vector3 AM_Adv.lastCamPos

private

Definition at line 162 of file AM_Adv.cs.

◆ movedByKey

bool AM_Adv.movedByKey

Definition at line 107 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and AxisMove().

◆ planAll

ActPlan AM_Adv.planAll

Initial value:

= new ActPlan
    {
        input = ActInput.AllAction
    }

Definition at line 147 of file AM_Adv.cs.

Referenced by HotItemHeld.CanRotate(), and ShowAllAction().

◆ planKeyboard

ActPlan AM_Adv.planKeyboard

Initial value:

= new ActPlan
    {
        input = ActInput.Key
    }

Definition at line 142 of file AM_Adv.cs.

Referenced by AxisMove().

◆ planLeft

ActPlan AM_Adv.planLeft

Initial value:

= new ActPlan
    {
        input = ActInput.LeftMouse
    }

Definition at line 132 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), ClearPlans(), OnUpdateCursor(), SetPressedAction(), and UpdatePlans().

◆ planRight

ActPlan AM_Adv.planRight

Initial value:

= new ActPlan
    {
        input = ActInput.RightMouse
    }

Definition at line 137 of file AM_Adv.cs.

Referenced by ClearPlans(), OnUpdateCursor(), SetPressedAction(), UpdateLangWheel(), and UpdatePlans().

◆ posArrow

Vector3 AM_Adv.posArrow

protected

Definition at line 121 of file AM_Adv.cs.

Referenced by PressedActionMove(), RefreshArrow(), and AM_Region.RefreshArrow().

◆ posOrigin

Vector3 AM_Adv.posOrigin

protected

Definition at line 119 of file AM_Adv.cs.

Referenced by PressedActionMove(), RefreshArrow(), and AM_Region.RefreshArrow().

◆ pressedAction

PressedAction AM_Adv.pressedAction = new PressedAction()

Definition at line 125 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), AxisMove(), OnActivate(), and SetPressedAction().

◆ rightMouseTimer

float AM_Adv.rightMouseTimer

Definition at line 164 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and BaseGameScreen.RefreshPosition().

◆ startedRun

bool AM_Adv.startedRun

private

Definition at line 166 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and AxisMove().

◆ textMiddle

string AM_Adv.textMiddle

Definition at line 154 of file AM_Adv.cs.

Referenced by OnUpdateCursor(), and UpdateLangWheel().

◆ textWheel

string AM_Adv.textWheel

Definition at line 152 of file AM_Adv.cs.

Referenced by OnUpdateCursor(), and UpdateLangWheel().

◆ timerStartRunning

float AM_Adv.timerStartRunning

protected

Definition at line 113 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), and AxisMove().

◆ turbo

float AM_Adv.turbo

static

Definition at line 99 of file AM_Adv.cs.

Referenced by AxisMove(), EndTurbo(), OnUpdateCursor(), PressedActionMove(), and SetTurbo().

◆ updatePlans

bool AM_Adv.updatePlans

Definition at line 158 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), ClearPlans(), OnUpdateCursor(), SetPressedAction(), and UpdatePlans().

◆ vArrow

Vector2 AM_Adv.vArrow

protected

Definition at line 123 of file AM_Adv.cs.

Referenced by PressedActionMove(), RefreshArrow(), and AM_Region.RefreshArrow().

◆ zoomOut

bool AM_Adv.zoomOut

Definition at line 103 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), ActionMode.InputMovement(), Widget.Config.IsInRightMode(), PressedActionMove(), RefreshArrow(), and SetPressedAction().

◆ zoomOut2

bool AM_Adv.zoomOut2

Definition at line 105 of file AM_Adv.cs.

Referenced by HotItemContext.Show(), and ToggleZoom().

Property Documentation

◆ AllowWheelZoom

override bool AM_Adv.AllowWheelZoom

get

Definition at line 238 of file AM_Adv.cs.

◆ autorun

bool AM_Adv.autorun

get

Definition at line 172 of file AM_Adv.cs.

Referenced by _OnUpdateInput(), AxisMove(), and PressedActionMove().

◆ FixFocus

override bool AM_Adv.FixFocus

get

Definition at line 198 of file AM_Adv.cs.

    {
        get
        {
            if (!zoomOut)
            {
                if (!EClass.core.config.test.alwaysFixCamera && !EInput.leftMouse.pressing)
                {
                    if (EInput.rightMouse.pressing && actCount > 0)
                    {
                        if (EClass.pc.ai != Chara._NoGoalRepeat)
                        {
                            if (EClass.pc.ai is TaskDesignation)
                            {
                                return !(EClass.pc.ai as TaskDesignation).isRepeated;
                            }
                            return true;
                        }
                        return false;
                    }
                    return true;
                }
                return true;
            }
            return false;
        }
    }

◆ gameSpeed

override float AM_Adv.gameSpeed

get

Definition at line 186 of file AM_Adv.cs.

    {
        get
        {
            if (!ShouldPauseGame)
            {
                return ActionMode.GameSpeeds[EClass.game.gameSpeedIndex] * ((turbo != 0f) ? turbo : 1f);
            }
            return 1f;
        }
    }

◆ mouseTarget

PointTarget AM_Adv.mouseTarget

get

Definition at line 170 of file AM_Adv.cs.

Referenced by OnAfterUpdate(), OnUpdateCursor(), RefreshArrow(), TaskPoint.Run(), SetPressedAction(), ShowAllAction(), and UpdatePlans().

◆ ShouldHideTile

bool AM_Adv.ShouldHideTile

get

Definition at line 174 of file AM_Adv.cs.

    {
        get
        {
            if (EClass.ui.layers.Count <= 0 && (!EClass.pc.renderer.IsMoving || EInput.rightMouse.pressing) && !(EClass.pc.ai.Current is AI_Goto) && !cursorMove && !EClass.ui.isPointerOverUI)
            {
                return EInput.axis != Vector2.zero;
            }
            return true;
        }
    }

Referenced by OnRenderTile(), and OnUpdateCursor().

◆ ShouldPauseGame

override bool AM_Adv.ShouldPauseGame

get

Definition at line 226 of file AM_Adv.cs.

    {
        get
        {
            if (EClass.core.config.game.autopause)
            {
                return EClass.pc.HasNoGoal;
            }
            return false;
        }
    }

◆ TargetZoom

override float AM_Adv.TargetZoom

get

Definition at line 240 of file AM_Adv.cs.

    {
        get
        {
            if (!zoomOut2)
            {
                return 0.01f * (float)EClass.game.config.defaultZoom;
            }
            return 0.01f * (float)EClass.game.config.zoomedZoom;
        }
    }

Referenced by BaseGameScreen.RefreshPosition().

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

Elin/AM_Adv.cs

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Protected Attributes

Properties

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ _OnUpdateInput()

◆ AxisMove()

◆ CanAct()

◆ ClearPlans()

◆ EndTurbo()

◆ GetDefaultTile()

◆ HighlightWall()

◆ OnActivate()

◆ OnAfterUpdate()

◆ OnBecomeNoGoal()

◆ OnBeforeUpdate()

◆ OnDeactivate()

◆ OnRenderTile()

◆ OnUpdateCursor()

◆ PressedActionMove()

◆ RefreshArrow()

◆ SetManualMove()

◆ SetPressedAction()

◆ SetTurbo()

◆ ShowAllAction()

◆ ToggleZoom()

◆ TryCancelInteraction()

◆ UpdateLangWheel()

◆ UpdatePlans()

Member Data Documentation

◆ actCount

◆ arrowIndex

◆ axisTarget

◆ clickPos

◆ cursorMove

◆ gearAngle

◆ isMoving

◆ itemLost

◆ keepWalking

◆ lastCamPos

◆ movedByKey

◆ planAll

◆ planKeyboard

◆ planLeft

◆ planRight

◆ posArrow

◆ posOrigin

◆ pressedAction

◆ rightMouseTimer

◆ startedRun

◆ textMiddle

◆ textWheel

◆ timerStartRunning

◆ turbo

◆ updatePlans

◆ vArrow

◆ zoomOut

◆ zoomOut2

Property Documentation

◆ AllowWheelZoom

◆ autorun

◆ FixFocus

◆ gameSpeed

◆ mouseTarget

◆ ShouldHideTile

◆ ShouldPauseGame

◆ TargetZoom