Inheritance diagram for HotItemHeld:

Public Member Functions
	HotItemHeld ()

	HotItemHeld (Thing t)

override void	OnSetCurrentItem ()

override void	OnUnselect ()

Act	GetAct ()

Act	GetSelfAct ()

override bool	TrySetAct (ActPlan p)

bool	TrySetToolAct (ActPlan p)

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

Public Member Functions inherited from HotItemThing
override Sprite	GetSprite ()

override void	SetImage (Image icon)

override void	SetSubText (UIText t)

Public Member Functions inherited from HotItemGameAction
override void	OnClick (ButtonHotItem b, Hotbar h)

override void	OnRightClick (ButtonHotItem b)

override void	OnMarkMapHighlights ()

Public Member Functions inherited from HotItem
string	TextHotkey ()

virtual void	OnClick (ButtonHotItem b, Hotbar h)

virtual void	OnRightClick (ButtonHotItem b)

virtual bool	CanAutoFire (Chara tg)

virtual void	OnSetCurrentItem ()

virtual void	OnUnsetCurrentItem ()

virtual void	OnUnselect ()

virtual void	SetImage (Image icon)

virtual bool	TrySetAct (ActPlan p)

virtual void	OnMarkMapHighlights ()

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

Public Member Functions inherited from UIButton.Item
virtual Sprite	GetSprite ()

virtual Sprite	GetSprite (bool highlight)

virtual bool	ShouldHighlight ()

virtual void	OnAddedToBar ()

virtual void	OnShowContextMenu (UIContextMenu m)

virtual void	OnHover (UIButton b)

virtual void	OnClick (UIButton b)

virtual void	OnSetItem (UIButton b)

virtual void	SetSubText (UIText t)

Static Public Member Functions
static bool	CanChangeHeightByWheel ()

static bool	CanRotate ()

Static Public Attributes
static Thing	lastHeld

static TaskBuild	taskBuild

static Recipe	recipe

static bool	disableTool

Properties
override Act	act `[get]`

Properties inherited from HotItemThing
override Act	act `[get]`

override string	Name `[get]`

override bool	IsSelectable `[get]`

override Thing	Thing `[get]`

override bool	UseUIObjMaterial `[get]`

Properties inherited from HotItemGameAction
virtual Act	act `[get]`

override bool	IsGameAction `[get]`

Properties inherited from HotItem
override Sprite	SpriteHighlight `[get]`

override bool	IsSelectable `[get]`

override string	TextTip `[get]`

virtual Thing	RenderThing `[get]`

virtual Thing	Thing `[get]`

virtual Thing	Tool `[get]`

virtual bool	IsTool `[get]`

virtual bool	LookAtMouse `[get]`

virtual bool	IsGameAction `[get]`

virtual bool	UseUIObjMaterial `[get]`

Properties inherited from UIButton.Item
virtual string	TextTip `[get]`

virtual string	Name `[get]`

virtual Sprite	SpriteHighlight `[get]`

virtual string	pathSprite `[get]`

virtual bool	IsSelectable `[get]`

virtual bool	AdjustImageSize `[get]`

virtual bool	UseIconForHighlight `[get]`

virtual bool	KeepVisibleWhenHighlighted `[get]`

virtual Color	SpriteColor `[get]`

virtual Vector3	SpriteScale `[get]`

virtual bool	Hidden `[get]`

virtual Transition	Transition `[get]`

Additional Inherited Members
Public Attributes inherited from HotItemThing
Thing	thing

bool	lost

Act	_act

Public Attributes inherited from HotItem
ButtonHotItem	button

Hotbar	hotbar

bool	disabled

Public Attributes inherited from UIButton.Item
bool	always

Detailed Description

Definition at line 3 of file HotItemHeld.cs.

Constructor & Destructor Documentation

◆ HotItemHeld() [1/2]

HotItemHeld.HotItemHeld ( )

inline

Definition at line 58 of file HotItemHeld.cs.

59 {

60 }

◆ HotItemHeld() [2/2]

HotItemHeld.HotItemHeld ( Thing t )

inline

Definition at line 62 of file HotItemHeld.cs.

    {
        thing = t;
    }

References HotItemThing.thing.

Member Function Documentation

◆ CanChangeHeightByWheel()

static bool HotItemHeld.CanChangeHeightByWheel ( )

inlinestatic

Definition at line 15 of file HotItemHeld.cs.

    {
        if (EClass.core.config.input.altChangeHeight && !EClass.scene.actionMode.IsBuildMode && !EInput.isShiftDown)
        {
            return false;
        }
        if (!EClass._zone.IsRegion && EClass.pc.held != null && EClass.pc.held.trait.CanChangeHeight && taskBuild != null && recipe.MaxAltitude != 0)
        {
            return taskBuild.CanPerform();
        }
        return false;
    }

References EClass._zone, Scene.actionMode, CoreConfig.InputSetting.altChangeHeight, Trait.CanChangeHeight, TaskPoint.CanPerform(), Core.config, EClass.core, Chara.held, CoreConfig.input, ActionMode.IsBuildMode, Spatial.IsRegion, EInput.isShiftDown, Recipe.MaxAltitude, EClass.pc, recipe, EClass.scene, taskBuild, and Card.trait.

Referenced by AM_Adv._OnUpdateInput(), and AM_Adv.UpdateLangWheel().

◆ CanRotate()

static bool HotItemHeld.CanRotate ( )

inlinestatic

Definition at line 28 of file HotItemHeld.cs.

    {
        if (EClass._zone.IsRegion || EClass.pc.held == null)
        {
            return false;
        }
        if (!(EClass._zone is Zone_Tent) && !EClass._zone.IsPCFactionOrTent && EClass.pc.held.trait.CanBeOnlyBuiltInHome)
        {
            return false;
        }
        if (EClass._zone.RestrictBuild && !EClass.pc.held.trait.CanBuildInTown)
        {
            return false;
        }
        if (taskBuild == null)
        {
            return false;
        }
        if (EClass.pc.held.trait is TraitTile)
        {
            return true;
        }
        if (!taskBuild.CanPerform())
        {
            return false;
        }
        ActionMode.Adv.planAll.Update(EClass.scene.mouseTarget);
        return !ActionMode.Adv.planAll.HasAct;
    }

References EClass._zone, ActionMode.Adv, Trait.CanBeOnlyBuiltInHome, Trait.CanBuildInTown, TaskPoint.CanPerform(), ActPlan.HasAct, Chara.held, Zone.IsPCFactionOrTent, Spatial.IsRegion, Scene.mouseTarget, EClass.pc, AM_Adv.planAll, Zone.RestrictBuild, EClass.scene, taskBuild, Card.trait, and ActPlan.Update().

Referenced by AM_Adv._OnUpdateInput(), and AM_Adv.UpdateLangWheel().

◆ GetAct()

Act HotItemHeld.GetAct ( )

inline

Definition at line 103 of file HotItemHeld.cs.

    {
        if (thing.trait is TraitRod)
        {
            return new ActZap();
        }
        if (thing.trait is TraitToolRange)
        {
            return ACT.Ranged;
        }
        if (thing.HasElement(241))
        {
            return new AI_PlayMusic();
        }
        if (thing.HasElement(225))
        {
            return new TaskCut();
        }
        if (thing.HasElement(220))
        {
            return new TaskMine();
        }
        if (thing.HasElement(230))
        {
            return new TaskDig
            {
                mode = TaskDig.Mode.RemoveFloor
            };
        }
        if (thing.HasElement(286))
        {
            return new TaskPlow();
        }
        if (thing.HasElement(245))
        {
            return new AI_Fish();
        }
        if (thing.HasElement(237))
        {
            return new AI_TendAnimal();
        }
        return _act;
    }

References HotItemThing._act, Card.HasElement(), ACT.Ranged, HotItemThing.thing, and Card.trait.

◆ GetSelfAct()

Act HotItemHeld.GetSelfAct ( )

inline

Definition at line 147 of file HotItemHeld.cs.

    {
        if (lost)
        {
            return null;
        }
        if (thing.trait.CanDrink(EClass.pc))
        {
            return new AI_Drink
            {
                target = thing
            };
        }
        if (thing.trait.CanEat(EClass.pc))
        {
            return new AI_Eat
            {
                cook = false
            };
        }
        if (thing.trait.CanRead(EClass.pc))
        {
            return new AI_Read
            {
                target = thing
            };
        }
        return null;
    }

References Trait.CanDrink(), Trait.CanEat(), Trait.CanRead(), cook, HotItemThing.lost, EClass.pc, HotItemThing.thing, and Card.trait.

Referenced by TrySetAct().

◆ OnRenderTile()

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

inlinevirtual

Reimplemented from HotItem.

Definition at line 427 of file HotItemHeld.cs.

    {
        if (EClass.game.config.showGuideGrid)
        {
            for (int i = point.z - 1; i < point.z + 2; i++)
            {
                for (int j = point.x - 1; j < point.x + 2; j++)
                {
                    EClass.screen.guide.passGuideFloor.Add(Point.shared.Set(j, i), 1f);
                }
            }
        }
        if (taskBuild == null || !taskBuild.IsRunning || (!recipe.MultiSize && !taskBuild.CanProgress()) || !taskBuild.CanPerform(EClass.pc, null, point))
        {
            return;
        }
        EClass.screen.guide.isActive = false;
        ActionMode.Build.OnRenderTile(point, HitResult.Valid, taskBuild.recipe._dir);
        EClass.screen.guide.isActive = true;
        if (recipe.MultiSize)
        {
            point.ForeachMultiSize(recipe.W, recipe.H, delegate(Point pos, bool main)
            {
                Vector3 v = pos.Position();
                v.z -= 0.01f;
                EClass.screen.guide.passGuideFloor.Add(ref v);
            });
        }
    }

References Recipe._dir, MeshPass.Add(), ActionMode.Build, TaskPoint.CanPerform(), Task.CanProgress(), Game.config, Point.ForeachMultiSize(), EClass.game, BaseGameScreen.guide, Recipe.H, AIAct.IsRunning, Recipe.MultiSize, AM_Build.OnRenderTile(), ScreenGuide.passGuideFloor, EClass.pc, Point.Position(), recipe, TaskBuild.recipe, EClass.screen, Point.Set(), Point.shared, Game.Config.showGuideGrid, taskBuild, Recipe.W, Point.x, and Point.z.

◆ OnSetCurrentItem()

override void HotItemHeld.OnSetCurrentItem ( )

inlinevirtual

Reimplemented from HotItem.

Definition at line 67 of file HotItemHeld.cs.

    {
        ActionMode.Build.altitude = 0;
        disableTool = false;
        if (EClass.pc.held != thing)
        {
            EClass.pc.HoldCard(thing);
        }
        taskBuild = null;
        RecipeManager.BuildList();
        recipe = thing.trait.GetRecipe();
        if (thing.trait is TraitCatalyst)
        {
            _act = (thing.trait as TraitCatalyst).CreateAct();
        }
        if (lastHeld != thing)
        {
            thing.trait.OnHeld();
        }
        lastHeld = thing;
        if (thing.trait is TraitToolRange)
        {
            EClass.pc.ranged = thing;
        }
    }

References HotItemThing._act, RecipeManager.BuildList(), disableTool, Trait.GetRecipe(), Chara.held, Chara.HoldCard(), lastHeld, Trait.OnHeld(), EClass.pc, recipe, taskBuild, HotItemThing.thing, and Card.trait.

◆ OnUnselect()

override void HotItemHeld.OnUnselect ( )

inlinevirtual

Reimplemented from HotItem.

Definition at line 93 of file HotItemHeld.cs.

    {
        taskBuild = null;
        recipe = null;
        if (EClass.pc.held == thing)
        {
            EClass.pc.PickHeld();
        }
    }

References Chara.held, EClass.pc, Chara.PickHeld(), recipe, taskBuild, and HotItemThing.thing.

◆ TrySetAct()

override bool HotItemHeld.TrySetAct ( ActPlan p )

inlinevirtual

Reimplemented from HotItem.

Definition at line 177 of file HotItemHeld.cs.

    {
        taskBuild = null;
        if (!disableTool)
        {
            if (p.IsSelf && thing.trait.CanUse(EClass.pc))
            {
                return p.TrySetAct(thing.trait.LangUse, () => thing.trait.OnUse(p.cc), thing, null, -1);
            }
            if (EClass.scene.mouseTarget.target is Card && thing.trait.CanUse(EClass.pc, EClass.scene.mouseTarget.target as Card))
            {
                return p.TrySetAct(thing.trait.LangUse, () => thing.trait.OnUse(p.cc, EClass.scene.mouseTarget.target as Card), thing, null, -1);
            }
            if (thing.trait.CanUse(EClass.pc, p.pos))
            {
                return p.TrySetAct(thing.trait.LangUse, () => thing.trait.OnUse(p.cc, p.pos), thing, null, -1);
            }
            if (thing.trait.IsTool)
            {
                if (TrySetToolAct(p))
                {
                    return true;
                }
            }
            else
            {
                thing.trait.TrySetHeldAct(p);
            }
            if (p.HasAct || thing.trait.IsTool)
            {
                return true;
            }
        }
        if (p.pos.Equals(EClass.pc.pos))
        {
            Act selfAct = GetSelfAct();
            if (selfAct != null)
            {
                p.TrySetAct(selfAct, thing);
                return true;
            }
        }
        bool flag = true;
        if (thing.trait is TraitThrown && !disableTool)
        {
            flag = false;
        }
        if (thing.trait is TraitTent && EClass._zone is Zone_Tent)
        {
            flag = false;
        }
        Chara tg;
        if (flag)
        {
            if (p.IsSelfOrNeighbor)
            {
                _ = p.pos.Installed?.trait;
                tg = p.pos.FirstVisibleChara();
                if (tg != null && tg != EClass.pc && !tg.IsDisabled && tg.IsNeutralOrAbove() && EClass.pc.held != null && tg.CanAcceptGift(EClass.pc, EClass.pc.held))
                {
                    string lang = "actGive";
                    if (tg.Evalue(1232) > 0 && EClass.pc.held.trait is TraitDrinkMilkMother)
                    {
                        lang = "actMilk";
                    }
                    p.TrySetAct(lang, delegate
                    {
                        if (!tg.IsValidGiftWeight(EClass.pc.held, 1))
                        {
                            tg.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;
                    }, thing);
                }
            }
            if (p.HasAct)
            {
                return true;
            }
            if (!thing.c_isImportant && (p.IsSelfOrNeighbor || thing.trait.CanExtendBuild))
            {
                Chara chara = p.pos.FirstVisibleChara();
                if ((chara == null || chara == EClass.pc || chara.IsNeutralOrAbove()) && recipe != null && (!thing.trait.IsThrowMainAction || EInput.isShiftDown || disableTool))
                {
                    taskBuild = new TaskBuild
                    {
                        recipe = recipe,
                        held = EClass.pc.held,
                        pos = p.pos.Copy()
                    };
                    AM_Build build = ActionMode.Build;
                    build.bridgeHeight = -1;
                    build.recipe = taskBuild.recipe;
                    build.mold = taskBuild;
                    build.SetAltitude(recipe.tileType.AltitudeAsDir ? recipe._dir : build.altitude);
                    p.TrySetAct(taskBuild);
                }
            }
        }
        if (p.HasAct)
        {
            return true;
        }
        if (ActThrow.CanThrow(EClass.pc, thing, null, p.pos) && p.TrySetAct(new ActThrow
        {
            target = thing,
            pcTarget = p.pos.FindAttackTarget()?.Chara
        }, thing))
        {
            return true;
        }
        return false;
        void func()
        {
            EClass.pc.GiveGift(tg, EClass.pc.SplitHeld(1) as Thing);
        }
    }

References Recipe._dir, EClass._zone, TileType.AltitudeAsDir, ActionMode.Build, build, Card.c_isImportant, Chara.CanAcceptGift(), Trait.CanExtendBuild, ActThrow.CanThrow(), Trait.CanUse(), ActPlan.cc, Core.config, CoreConfig.GameConfig.confirmGive, Point.Copy(), EClass.core, disableTool, Point.Equals(), Card.Evalue(), Point.FirstVisibleChara(), CoreConfig.game, GetSelfAct(), Chara.GiveGift(), ActPlan.HasAct, Chara.held, if(), Point.Installed, Chara.IsDisabled, Chara.IsNeutralOrAbove(), ActPlan.IsSelf, ActPlan.IsSelfOrNeighbor, EInput.isShiftDown, Trait.IsThrowMainAction, Trait.IsTool, Chara.IsValidGiftWeight(), Trait.LangUse, Scene.mouseTarget, Trait.OnUse(), EClass.pc, ActPlan.pos, Card.pos, recipe, TaskBuild.recipe, EClass.scene, Chara.SplitHeld(), PointTarget.target, taskBuild, HotItemThing.thing, Recipe.tileType, Card.trait, ActPlan.TrySetAct(), Trait.TrySetHeldAct(), and TrySetToolAct().

◆ TrySetToolAct()

bool HotItemHeld.TrySetToolAct ( ActPlan p )

inline

Definition at line 304 of file HotItemHeld.cs.

    {
        thing.trait.TrySetHeldAct(p);
        if (p.HasAct)
        {
            return true;
        }
        Cell cell = p.pos.cell;
        Point pos = p.pos;
        if (cell.HasBlock && (!cell.HasObj || cell.sourceObj.tileType.IsMountBlock) && TaskMine.CanMine(pos, thing) && p.TrySetAct(new TaskMine
        {
            pos = pos.Copy()
        }))
        {
            return true;
        }
        if (pos.IsHidden)
        {
            return true;
        }
        if (thing.trait is TraitToolRange)
        {
            if (!EClass.pc.CanSeeSimple(pos))
            {
                return true;
            }
            Card tc = null;
            foreach (Chara item in pos.ListVisibleCharas())
            {
                if (item.isSynced && item.IsAliveInCurrentZone)
                {
                    tc = item;
                    break;
                }
            }
            EClass.pc.ranged = thing;
            p.TrySetAct(ACT.Ranged, tc);
            return true;
        }
        if (cell.IsTopWaterAndNoSnow && thing.HasElement(245) && p.TrySetAct(new AI_Fish
        {
            pos = pos.Copy()
        }))
        {
            return true;
        }
        if (p.IsNeighborBlocked)
        {
            return true;
        }
        TaskHarvest taskHarvest = TaskHarvest.TryGetAct(EClass.pc, pos);
        if (taskHarvest != null && p.TrySetAct(taskHarvest))
        {
            return true;
        }
        TraitToolWaterPot traitToolWaterPot = thing.trait as TraitToolWaterPot;
        if (cell.IsTopWaterAndNoSnow)
        {
            if (traitToolWaterPot != null && traitToolWaterPot.owner.c_charges < traitToolWaterPot.MaxCharge && p.TrySetAct(new TaskDrawWater
            {
                pot = traitToolWaterPot,
                pos = pos.Copy()
            }))
            {
                return true;
            }
        }
        else
        {
            if (traitToolWaterPot != null && !p.pos.HasBridge && traitToolWaterPot.owner.c_charges > 0 && pos.cell.sourceSurface.tag.Contains("soil") && p.TrySetAct(new TaskPourWater
            {
                pot = traitToolWaterPot,
                pos = pos.Copy()
            }))
            {
                return true;
            }
            if (thing.HasElement(230) && p.TrySetAct(new TaskDig
            {
                pos = pos.Copy(),
                mode = TaskDig.Mode.RemoveFloor
            }))
            {
                return true;
            }
            if (thing.HasElement(286) && p.TrySetAct(new TaskPlow
            {
                pos = pos.Copy()
            }))
            {
                return true;
            }
        }
        if (TaskMine.CanMine(pos, thing) && p.TrySetAct(new TaskMine
        {
            pos = pos.Copy()
        }))
        {
            return true;
        }
        if (thing.HasElement(225) && p.TrySetAct(new TaskChopWood
        {
            pos = pos.Copy()
        }))
        {
            return true;
        }
        if (pos.HasChara)
        {
            _ = pos.FirstChara;
            _ = EClass.pc;
        }
        if (thing.HasTag(CTAG.throwWeapon) && ActThrow.CanThrow(EClass.pc, thing, null, p.pos) && p.TrySetAct(new ActThrow
        {
            target = thing,
            pcTarget = p.pos.FindAttackTarget()?.Chara
        }, thing))
        {
            return true;
        }
        return false;
    }

References Card.c_charges, TaskMine.CanMine(), Chara.CanSeeSimple(), ActThrow.CanThrow(), Point.cell, Point.FirstChara, ActPlan.HasAct, Cell.HasBlock, Point.HasBridge, Point.HasChara, Card.HasElement(), Cell.HasObj, Card.HasTag(), Point.IsHidden, ActPlan.IsNeighborBlocked, Cell.IsTopWaterAndNoSnow, item, Point.ListVisibleCharas(), TraitToolWaterPot.MaxCharge, Trait.owner, EClass.pc, ActPlan.pos, ACT.Ranged, Cell.sourceObj, Cell.sourceSurface, HotItemThing.thing, Card.trait, TaskHarvest.TryGetAct(), ActPlan.TrySetAct(), and Trait.TrySetHeldAct().

Referenced by TrySetAct().

Member Data Documentation

◆ disableTool

bool HotItemHeld.disableTool

static

Definition at line 11 of file HotItemHeld.cs.

Referenced by ActPlan._Update(), CharaRenderer.Draw(), Thing.GetSubPassData(), CharaActorPCC.OnRender(), OnSetCurrentItem(), UIPlaceHelper.Refresh(), and TrySetAct().

◆ lastHeld

Thing HotItemHeld.lastHeld

static

Definition at line 5 of file HotItemHeld.cs.

Referenced by OnSetCurrentItem().

◆ recipe

Recipe HotItemHeld.recipe

static

Definition at line 9 of file HotItemHeld.cs.

Referenced by CanChangeHeightByWheel(), OnRenderTile(), OnSetCurrentItem(), OnUnselect(), UIPlaceHelper.Refresh(), and TrySetAct().

◆ taskBuild

TaskBuild HotItemHeld.taskBuild

static

Definition at line 7 of file HotItemHeld.cs.

Referenced by AM_Adv._OnUpdateInput(), CanChangeHeightByWheel(), CanRotate(), OnRenderTile(), OnSetCurrentItem(), OnUnselect(), TrySetAct(), and ActionMode.UpdateInput().

Property Documentation

◆ act

override Act HotItemHeld.act

get

Definition at line 13 of file HotItemHeld.cs.

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

Elin/HotItemHeld.cs

Public Member Functions

Static Public Member Functions

Static Public Attributes

Properties

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HotItemHeld() [1/2]

◆ HotItemHeld() [2/2]

Member Function Documentation

◆ CanChangeHeightByWheel()

◆ CanRotate()

◆ GetAct()

◆ GetSelfAct()

◆ OnRenderTile()

◆ OnSetCurrentItem()

◆ OnUnselect()

◆ TrySetAct()

◆ TrySetToolAct()

Member Data Documentation

◆ disableTool

◆ lastHeld

◆ recipe

◆ taskBuild

Property Documentation

◆ act