ActPlan.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x020001DC RID: 476
public class ActPlan : EClass
{
    // Token: 0x17000364 RID: 868
    // (get) Token: 0x06000D67 RID: 3431 RVA: 0x0006828B File Offset: 0x0006648B
    public bool IsSelf
    {
        get
        {
            return this.dist == 0;
        }
    }
 
    // Token: 0x17000365 RID: 869
    // (get) Token: 0x06000D68 RID: 3432 RVA: 0x00068296 File Offset: 0x00066496
    public bool IsSelfOrNeighbor
    {
        get
        {
            return this._canInteractNeighbor;
        }
    }
 
    // Token: 0x17000366 RID: 870
    // (get) Token: 0x06000D69 RID: 3433 RVA: 0x0006829E File Offset: 0x0006649E
    public bool IsNeighborBlocked
    {
        get
        {
            return !this._canInteractNeighbor && this.dist == 1;
        }
    }
 
    // Token: 0x17000367 RID: 871
    // (get) Token: 0x06000D6A RID: 3434 RVA: 0x000682B3 File Offset: 0x000664B3
    public bool canRepeat
    {
        get
        {
            return this.list.Count == 1 && this.list[0].act.CanPressRepeat;
        }
    }
 
    // Token: 0x17000368 RID: 872
    // (get) Token: 0x06000D6B RID: 3435 RVA: 0x000682DB File Offset: 0x000664DB
    public Chara cc
    {
        get
        {
            return EClass.pc;
        }
    }
 
    // Token: 0x06000D6C RID: 3436 RVA: 0x000682E4 File Offset: 0x000664E4
    public string GetText(bool showName)
    {
        if (this.list.Count == 0)
        {
            return "";
        }
        if (this.list.Count == 1)
        {
            return this.list[0].GetText(showName);
        }
        return "+" + this.list.Count.ToString() + ((this.HasMultipleTargets || this.list[0].tc == null) ? ("\n<size=28>(" + "multipleTargets".lang() + ")</size>") : ("\n<size=28>" + this.list[0].tc.Name + this.list[0].tc.GetExtraName() + "</size>"));
    }
 
    // Token: 0x17000369 RID: 873
    // (get) Token: 0x06000D6D RID: 3437 RVA: 0x000683B4 File Offset: 0x000665B4
    public CursorInfo CursorIcon
    {
        get
        {
            if (this.list.Count == 0)
            {
                return null;
            }
            if (this.list.Count <= 1)
            {
                return this.list[0].act.GetCursorIcon(this.list[0].tc);
            }
            return CursorSystem.Notice;
        }
    }
 
    // Token: 0x1700036A RID: 874
    // (get) Token: 0x06000D6E RID: 3438 RVA: 0x0006840B File Offset: 0x0006660B
    public bool WillEndTurn
    {
        get
        {
            return this.list.Count > 0 && this.list[0].act.WillEndTurn;
        }
    }
 
    // Token: 0x1700036B RID: 875
    // (get) Token: 0x06000D6F RID: 3439 RVA: 0x00068433 File Offset: 0x00066633
    public bool HideRightInfo
    {
        get
        {
            return this.list.Count > 0 && this.list[0].act.HideRightInfo;
        }
    }
 
    // Token: 0x1700036C RID: 876
    // (get) Token: 0x06000D70 RID: 3440 RVA: 0x0006845B File Offset: 0x0006665B
    public bool HasAct
    {
        get
        {
            return this.list.Count > 0;
        }
    }
 
    // Token: 0x1700036D RID: 877
    // (get) Token: 0x06000D71 RID: 3441 RVA: 0x0006846C File Offset: 0x0006666C
    public bool ShowAct
    {
        get
        {
            return this.HasAct && this.lastAct != this.list[0].act && this.list[0].act.ShowMouseHint(this.list[0].tc);
        }
    }
 
    // Token: 0x1700036E RID: 878
    // (get) Token: 0x06000D72 RID: 3442 RVA: 0x000684C5 File Offset: 0x000666C5
    public bool HasMultipleTargets
    {
        get
        {
            return this.list.Count > 1 && this.list[0].tc != this.list.LastItem<ActPlan.Item>().tc;
        }
    }
 
    // Token: 0x06000D73 RID: 3443 RVA: 0x00068500 File Offset: 0x00066700
    public Func<bool> GetAction()
    {
        if (this.list.Count == 0)
        {
            return () => false;
        }
        if (this.list.Count > 1)
        {
            return delegate()
            {
                if (this.pos.Equals(EClass.pc.pos) && ActWait.SearchMedal(EClass.pc, this.pos))
                {
                    return false;
                }
                this.ShowContextMenu();
                return false;
            };
        }
        ActPlan.Item item = this.list[0];
        return delegate()
        {
            if (this.performed && !item.act.CanPressRepeat)
            {
                return false;
            }
            this.performed = true;
            this.lastAct = item.act;
            return item.Perform(this.performed);
        };
    }
 
    // Token: 0x06000D74 RID: 3444 RVA: 0x00068580 File Offset: 0x00066780
    public void ShowContextMenu()
    {
        UIContextMenu uicontextMenu = EClass.ui.CreateContextMenuInteraction();
        int num = 1;
        bool flag = this.showOrder;
        using (List<ActPlan.Item>.Enumerator enumerator = this.list.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                ActPlan.Item i = enumerator.Current;
                string text = i.GetTextContext(this.HasMultipleTargets);
                text = text.Replace("\n", " ").Replace(Environment.NewLine, " ");
                uicontextMenu.AddButton(text, delegate()
                {
                    this.performed = true;
                    if (i.Perform(false))
                    {
                        EClass.player.EndTurn(true);
                    }
                }, true);
                num++;
                if (num >= 21)
                {
                    break;
                }
            }
        }
        uicontextMenu.Show();
        EClass.ui.hud.HideMouseInfo();
    }
 
    // Token: 0x06000D75 RID: 3445 RVA: 0x00068660 File Offset: 0x00066860
    public bool TrySetAct(string lang, Func<bool> onPerform, Card tc, CursorInfo cursor = null, int dist = 1, bool isHostileAct = false, bool localAct = true, bool canRepeat = false)
    {
        return this.TrySetAct(new DynamicAct(lang, onPerform, false)
        {
            id = lang,
            dist = dist,
            isHostileAct = isHostileAct,
            localAct = localAct,
            cursor = ((cursor == CursorSystem.Arrow) ? null : cursor),
            canRepeat = (() => canRepeat)
        }, tc);
    }
 
    // Token: 0x06000D76 RID: 3446 RVA: 0x000686CF File Offset: 0x000668CF
    public bool TrySetAct(string lang, Func<bool> onPerform, CursorInfo cursor = null, int dist = 1)
    {
        return this.TrySetAct(new DynamicAct(lang, onPerform, false)
        {
            id = lang,
            dist = dist,
            cursor = ((cursor == CursorSystem.Arrow) ? null : cursor)
        }, null);
    }
 
    // Token: 0x06000D77 RID: 3447 RVA: 0x00068704 File Offset: 0x00066904
    public bool TrySetAct(Act _act, Card _tc = null)
    {
        if (!this.ignoreAdddCondition && !_act.CanPerform(this.cc, _tc, this.pos))
        {
            return false;
        }
        this.list.Add(new ActPlan.Item
        {
            act = _act,
            tc = _tc,
            pos = this.pos.Copy()
        });
        return true;
    }
 
    // Token: 0x06000D78 RID: 3448 RVA: 0x00068760 File Offset: 0x00066960
    public void Clear()
    {
        this.list.Clear();
        this.pos.IsValid = false;
    }
 
    // Token: 0x06000D79 RID: 3449 RVA: 0x0006877C File Offset: 0x0006697C
    public void Update(PointTarget target)
    {
        if (ActPlan.warning)
        {
            return;
        }
        this._Update(target);
        if (this.HasAct)
        {
            Color effectColor = (this.list.Count == 1) ? this.list[0].act.GetActPlanColor() : EClass.Colors.colorAct;
            if (this.input == ActInput.LeftMouse || this.input == ActInput.Key)
            {
                EClass.ui.hud.textLeft.SetText(this.GetText(true));
                Outline[] components = EClass.ui.hud.textLeft.GetComponents<Outline>();
                for (int i = 0; i < components.Length; i++)
                {
                    components[i].effectColor = effectColor;
                }
                return;
            }
            if (this.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(this.GetText(true));
                Outline[] components = EClass.ui.hud.textRight.GetComponents<Outline>();
                for (int i = 0; i < components.Length; i++)
                {
                    components[i].effectColor = effectColor;
                }
            }
        }
    }
 
    // Token: 0x06000D7A RID: 3450 RVA: 0x000688CC File Offset: 0x00066ACC
    public void _Update(PointTarget target)
    {
        this.showOrder = false;
        this.performed = false;
        this.list.Clear();
        this.listPick.Clear();
        if (!this.pos.Equals(target.pos))
        {
            this.lastAct = null;
        }
        this.pos.Set(target.pos);
        this.dist = this.cc.pos.Distance(this.pos);
        if (!this.pos.IsValid || EClass.pc.isDead)
        {
            return;
        }
        Point _pos = new Point(this.pos);
        Cell cell = target.pos.cell;
        bool flag = this.input == ActInput.Key;
        this.altAction = ((EInput.isShiftDown && !EInput.isAltDown && !flag) || this.input == ActInput.AllAction);
        this._canInteractNeighbor = (this.dist == 0 || (this.dist == 1 && this.cc.CanInteractTo(_pos)));
        if (EClass.pc.isBlind && !_pos.Equals(EClass.pc.pos) && !flag && this.input != ActInput.LeftMouse)
        {
            return;
        }
        if (!flag && this.input != ActInput.LeftMouse && this.input != ActInput.AllAction)
        {
            if (this.input == ActInput.RightMouse)
            {
                if (this.pos.cell.outOfBounds || EClass.ui.IsDragging)
                {
                    return;
                }
                HotItem hotItem = EClass.player.currentHotItem;
                if (!hotItem.IsGameAction)
                {
                    this.TrySetAct(hotItem.Name, delegate()
                    {
                        hotItem.OnClick(hotItem.button, hotItem.hotbar);
                        return false;
                    }, null, -1);
                }
                else
                {
                    hotItem.TrySetAct(this);
                }
                bool flag2 = EClass.game.config.autoCombat.enable && EClass.scene.mouseTarget.TargetChara != null;
                Thing thing = hotItem.Thing;
                if (((thing != null) ? thing.trait : null) is TraitToolShears)
                {
                    flag2 = false;
                }
                if (flag2)
                {
                    Chara targetChara = EClass.scene.mouseTarget.TargetChara;
                    bool flag3 = true;
                    if (targetChara.hostility >= Hostility.Friend)
                    {
                        flag3 = false;
                    }
                    if (targetChara.hostility == Hostility.Neutral && EClass.game.config.autoCombat.bDontAutoAttackNeutral)
                    {
                        flag3 = false;
                    }
                    if (this.list.Count >= 2)
                    {
                        flag3 = false;
                    }
                    if (this.list.Count == 1)
                    {
                        if (targetChara.hostility >= Hostility.Neutral)
                        {
                            flag3 = false;
                        }
                        if (!this.list[0].act.ShowAuto)
                        {
                            flag3 = false;
                        }
                        if (EClass.player.currentHotItem is HotItemNoItem && targetChara.hostility <= Hostility.Enemy)
                        {
                            flag3 = true;
                        }
                    }
                    if (flag3)
                    {
                        this.list.Clear();
                        this.TrySetAct(new GoalAutoCombat(targetChara), null);
                    }
                }
                if (this.list.Count == 0)
                {
                    HotItemNoItem._TrySetAct(this);
                }
                if (WidgetCurrentTool.Instance)
                {
                    WidgetCurrentTool.Instance.placer.Refresh();
                }
            }
            return;
        }
        if (EClass.ui.IsDragging)
        {
            return;
        }
        if (_pos.cell.outOfBounds)
        {
            if (EClass.player.CanExitBorder(_pos))
            {
                EClass.player.ExitBorder(this);
            }
            return;
        }
        if (!flag && _pos.Equals(this.cc.pos) && EClass._zone.IsRegion)
        {
            this.TrySetAct("actNewZone", delegate()
            {
                EClass.player.EnterLocalZone(false);
                return false;
            }, CursorSystem.MoveZone, 1);
            if (this.input == ActInput.AllAction)
            {
                this.TrySetAct("LayerTravel", delegate()
                {
                    EClass.ui.AddLayer<LayerTravel>();
                    return false;
                }, null, CursorSystem.MoveZone, 1, false, false, false);
            }
        }
        foreach (Card card in _pos.ListCards(false))
        {
            Chara chara = card.Chara;
            if (chara != null && !chara.IsPC && EClass.pc.CanSee(chara))
            {
                int num = chara.Dist(EClass.pc);
                if (num <= 1 || !EClass.pc.isBlind)
                {
                    if (!EClass.pc.isBlind && !chara.IsHostile() && (this.input == ActInput.AllAction || (!chara.IsPCParty && !chara.IsMinion && !flag)) && (this.input == ActInput.AllAction || !chara.IsNeutral() || chara.quest != null || EClass.game.quests.IsDeliverTarget(chara)) && chara.isSynced && num <= 2 && ((!chara.HasCondition<ConSuspend>() && (!chara.isRestrained || !chara.IsPCFaction)) || this.altAction))
                    {
                        if (EClass.pc.HasElement(1216, 1) && chara.HasCondition<ConSleep>())
                        {
                            this.TrySetAct(new AI_Fuck
                            {
                                target = chara,
                                succubus = true
                            }, chara);
                        }
                        this.TrySetAct(ACT.Chat, chara);
                    }
                    if (chara.host != EClass.pc)
                    {
                        if (chara.IsRestrainedResident)
                        {
                            this.TrySetAct(new AI_PracticeDummy
                            {
                                target = chara
                            }, null);
                        }
                        else if ((chara.IsHostile() || this.altAction || chara.isRestrained) && chara.IsAliveInCurrentZone)
                        {
                            this.TrySetAct(ACT.Melee, chara);
                        }
                    }
                }
            }
        }
        if (_pos.IsHidden || !this.IsSelfOrNeighbor)
        {
            return;
        }
        foreach (Card card2 in _pos.ListCards(false))
        {
            Chara c = card2.Chara;
            if (c != null)
            {
                bool flag4 = EClass.pc.CanSee(c);
                if (flag4)
                {
                    if (this.input == ActInput.LeftMouse && c.IsPCFaction && !c.IsPC && this.pos.FindThing<TraitHitchingPost>() != null)
                    {
                        Chara ride = c;
                        List<string> list = EClass.core.pccs.sets["ride"].map["body"].map.Keys.ToList<string>();
                        int index = list.IndexOf(ride.c_idRidePCC);
                        if (index == -1)
                        {
                            index = 0;
                        }
                        Func<float, string> <>9__14;
                        Action<float> <>9__15;
                        this.TrySetAct("ActChangeRideSkin", delegate()
                        {
                            UIContextMenu uicontextMenu = EClass.ui.CreateContextMenuInteraction();
                            string text = "rideSkin";
                            Func<float, string> textFunc;
                            if ((textFunc = <>9__14) == null)
                            {
                                textFunc = (<>9__14 = ((float a) => list[(int)a].Split('-', StringSplitOptions.None)[0] ?? ""));
                            }
                            float value = (float)index;
                            Action<float> action;
                            if ((action = <>9__15) == null)
                            {
                                action = (<>9__15 = delegate(float a)
                                {
                                    ride.c_idRidePCC = list[(int)a];
                                    ride._CreateRenderer();
                                });
                            }
                            uicontextMenu.AddSlider(text, textFunc, value, action, 0f, (float)(list.Count - 1), true, false, false);
                            uicontextMenu.Show();
                            return false;
                        }, c, null, 1, false, true, false);
                    }
                    if (!c.IsPC && ((c.IsPCFaction && !c.IsDisabled) || EClass.debug.enable) && this.input == ActInput.AllAction)
                    {
                        this.TrySetAct("actTrade", delegate()
                        {
                            LayerInventory.CreateContainer(c);
                            return false;
                        }, c, null, 1, false, true, false);
                    }
                }
                if (this.input == ActInput.AllAction && EClass.pc.held != null && EClass.pc.held.trait is TraitDrink)
                {
                    this.TrySetAct(c.IsPC ? "actPour" : "ActThrow", delegate()
                    {
                        ActThrow.Throw(EClass.pc, c.pos, c, EClass.pc.held.Split(1), ThrowMethod.Default);
                        return true;
                    }, EClass.pc.held, null, 1, false, true, false);
                }
                if (!c.IsPC && c.host == null && ((!EClass.pc.isBlind && flag4) || this.input != ActInput.AllAction))
                {
                    if (c.isRestrained && (this.input == ActInput.AllAction || (!c.IsRestrainedResident && !c.IsHostile())))
                    {
                        this.TrySetAct("ActUnrestrain", delegate()
                        {
                            c.TryUnrestrain(true, EClass.pc);
                            return true;
                        }, c, null, 1, false, true, false);
                    }
                    if (!EClass.pc.isBlind && flag4 && this.input == ActInput.AllAction)
                    {
                        this.TrySetAct(ACT.Kick, c);
                        if (c.IsMofuable)
                        {
                            this.TrySetAct("ActCuddle", delegate()
                            {
                                EClass.pc.Cuddle(c, false);
                                return true;
                            }, c, null, 1, false, true, false);
                        }
                        if (EClass.debug.showExtra)
                        {
                            this.TrySetAct("inspect", delegate()
                            {
                                c.Inspect();
                                return false;
                            }, c, null, 1, false, true, false);
                        }
                        if (c.IsPCPartyMinion && !c.Chara.IsEscorted())
                        {
                            this.TrySetAct("ActBanishSummon", delegate()
                            {
                                EClass.pc.Say("summon_vanish", c, null, null);
                                c.pos.PlayEffect("vanish");
                                c.pos.PlaySound("vanish", true, 1f, true);
                                c.pos.PlayEffect("teleport");
                                c.Destroy();
                                return true;
                            }, c, null, 1, false, true, false);
                        }
                    }
                }
            }
            else if (card2.isThing)
            {
                if (!EClass.pc.isBlind)
                {
                    Thing t = card2.Thing;
                    if (this.input == ActInput.AllAction)
                    {
                        if (EClass.debug.enable)
                        {
                            if (t.LightData != null)
                            {
                                if (t.c_lightColor != 0)
                                {
                                    this.TrySetAct("(debug) Clear Light", delegate()
                                    {
                                        t.c_lightColor = 0;
                                        t.RecalculateFOV();
                                        TCExtra tc = t.renderer.GetTC<TCExtra>();
                                        if (tc != null)
                                        {
                                            tc.RefreshColor();
                                        }
                                        return false;
                                    }, t, null, 1, false, true, false);
                                }
                                Action<PickerState, Color> <>9__20;
                                this.TrySetAct("(debug) Set Light", delegate()
                                {
                                    Color lightColor = t.LightColor;
                                    LayerColorPicker layerColorPicker = EClass.ui.AddLayer<LayerColorPicker>();
                                    Color startColor = lightColor;
                                    Color resetColor = lightColor;
                                    Action<PickerState, Color> onChangeColor;
                                    if ((onChangeColor = <>9__20) == null)
                                    {
                                        onChangeColor = (<>9__20 = delegate(PickerState state, Color _c)
                                        {
                                            t.c_lightColor = (int)((byte)Mathf.Clamp(_c.r * 32f, 1f, 31f)) * 1024 + (int)((byte)Mathf.Clamp(_c.g * 32f, 1f, 31f) * 32) + (int)((byte)Mathf.Clamp(_c.b * 32f, 1f, 31f));
                                            t.RecalculateFOV();
                                            TCExtra tc = t.renderer.GetTC<TCExtra>();
                                            if (tc == null)
                                            {
                                                return;
                                            }
                                            tc.RefreshColor();
                                        });
                                    }
                                    layerColorPicker.SetColor(startColor, resetColor, onChangeColor);
                                    return false;
                                }, t, null, 1, false, true, false);
                            }
                            if (this.pos.cell.IsTopWater)
                            {
                                this.TrySetAct("(debug) Toggle Float", delegate()
                                {
                                    t.isFloating = !t.isFloating;
                                    return false;
                                }, t, null, 1, false, true, false);
                            }
                        }
                        if (t.trait.CanEat(EClass.pc))
                        {
                            this.TrySetAct(new AI_Eat
                            {
                                target = t
                            }, t);
                        }
                        if (t.trait.CanDrink(EClass.pc))
                        {
                            this.TrySetAct(new AI_Drink
                            {
                                target = t
                            }, t);
                        }
                        if (t.trait.CanRead(EClass.pc))
                        {
                            this.TrySetAct(new AI_Read
                            {
                                target = t
                            }, t);
                        }
                        if (t.trait.IsBlendBase)
                        {
                            this.TrySetAct("invBlend", delegate()
                            {
                                LayerDragGrid.Create(new InvOwnerBlend(t, null, CurrencyType.None), false);
                                return true;
                            }, t, null, 1, false, true, false);
                        }
                    }
                    if (flag)
                    {
                        if (t.trait.CanBeAttacked)
                        {
                        }
                    }
                    else
                    {
                        if (t.placeState == PlaceState.roaming && (_pos.cell.blocked || t.ignoreAutoPick || this.altAction || this.input == ActInput.AllAction || _pos.Equals(EClass.pc.pos)) && EClass.pc.CanPick(t))
                        {
                            this.listPick.Add(t);
                        }
                        if (t.IsInstalled)
                        {
                            if (t.trait.IsFactory && !EClass.game.altCraft)
                            {
                                Thing _t = t;
                                this.TrySetAct("craft", delegate()
                                {
                                    if (EClass.player.recipes.ListSources(_t, null).Count > 0)
                                    {
                                        EClass.ui.AddLayer<LayerCraft>().SetFactory(_t);
                                    }
                                    else
                                    {
                                        Msg.Say("noRecipes");
                                    }
                                    return false;
                                }, _t, CursorSystem.Craft, 1, false, true, false);
                            }
                            bool canBeAttacked = t.trait.CanBeAttacked;
                            t.trait.TrySetToggleAct(this);
                            t.trait.TrySetAct(this);
                        }
                    }
                }
            }
        }
        if (this.listPick.Count > 0)
        {
            if (this.listPick.Count == 1)
            {
                Thing _t = this.listPick[0];
                if (!EClass._zone.IsRegion || (!_t.ignoreAutoPick && _t.pos.Equals(EClass.pc.pos)) || this.altAction)
                {
                    this.TrySetAct("actPickOne", delegate()
                    {
                        EClass.pc.Pick(_t, true, true);
                        return true;
                    }, this.listPick[0], CursorSystem.Hand, 1, false, false, false);
                }
            }
            else
            {
                this.TrySetAct("actPickAll", delegate()
                {
                    foreach (Card card3 in _pos.ListCards(false))
                    {
                        if (card3.isThing && card3.placeState == PlaceState.roaming)
                        {
                            EClass.pc.Pick(card3.Thing, true, true);
                        }
                    }
                    return true;
                }, null, CursorSystem.Hand, 1, false, false, false);
            }
        }
        if (this.input == ActInput.AllAction && this.pos.IsSky)
        {
            this.TrySetAct("actSkyJump", delegate()
            {
                EClass.pc.FallFromZone();
                return false;
            }, null, 1);
        }
        if (_pos.Equals(this.cc.pos))
        {
            if (this.cc.held != null && !this.cc.held.IsHotItem)
            {
                this.TrySetAct("actPick", delegate()
                {
                    Card held = this.cc.held;
                    this.cc.PickHeld(true);
                    return false;
                }, this.cc.held, CursorSystem.Inventory, 1, false, false, false);
            }
            else if (!this.HasAct && !this.cc.isRestrained)
            {
                this.TrySetAct(ACT.Wait, null);
            }
            if (EClass.pc.party.members.Count > 1)
            {
                this.showOrder = true;
            }
            if (this.input == ActInput.AllAction && EClass.pc.held != null)
            {
                this.TrySetAct("actDrop", delegate()
                {
                    EClass.pc.DropThing(EClass.pc.held.Thing, -1);
                    return true;
                }, null, 1);
            }
            if (this.cc.isRestrained)
            {
                this.TrySetAct("ActUnrestrain", delegate()
                {
                    this.cc.TryUnrestrain(true, EClass.pc);
                    return true;
                }, this.cc, null, 1, false, true, false);
            }
        }
    }
 
    // Token: 0x04000D0A RID: 3338
    public static bool warning;
 
    // Token: 0x04000D0B RID: 3339
    public Point pos = new Point();
 
    // Token: 0x04000D0C RID: 3340
    public ActInput input;
 
    // Token: 0x04000D0D RID: 3341
    public bool performed;
 
    // Token: 0x04000D0E RID: 3342
    public bool altAction;
 
    // Token: 0x04000D0F RID: 3343
    public bool ignoreAdddCondition;
 
    // Token: 0x04000D10 RID: 3344
    private bool _canInteractNeighbor;
 
    // Token: 0x04000D11 RID: 3345
    private bool showOrder;
 
    // Token: 0x04000D12 RID: 3346
    public ActPlan.List list = new ActPlan.List();
 
    // Token: 0x04000D13 RID: 3347
    public int dist;
 
    // Token: 0x04000D14 RID: 3348
    public Thing tool;
 
    // Token: 0x04000D15 RID: 3349
    public List<Thing> listPick = new List<Thing>();
 
    // Token: 0x04000D16 RID: 3350
    public Act lastAct;
 
    // Token: 0x020008BE RID: 2238
    public class List : List<ActPlan.Item>
    {
        // Token: 0x06003ADA RID: 15066 RVA: 0x00137944 File Offset: 0x00135B44
        public void Add(Act a, string s = "")
        {
            base.Add(new ActPlan.Item
            {
                act = a
            });
        }
    }
 
    // Token: 0x020008BF RID: 2239
    public class Item
    {
        // Token: 0x17001152 RID: 4434
        // (get) Token: 0x06003ADC RID: 15068 RVA: 0x00137960 File Offset: 0x00135B60
        public Chara cc
        {
            get
            {
                return EClass.pc;
            }
        }
 
        // Token: 0x17001153 RID: 4435
        // (get) Token: 0x06003ADD RID: 15069 RVA: 0x00137967 File Offset: 0x00135B67
        public bool HideHint
        {
            get
            {
                return EClass.pc.isBlind || (this.tc != null && this.tc.isChara && !EClass.pc.CanSee(this.tc));
            }
        }
 
        // Token: 0x06003ADE RID: 15070 RVA: 0x001379A4 File Offset: 0x00135BA4
        public string GetText(bool showName)
        {
            return this.act.GetText("") + ((showName && this.act.GetTextSmall(this.tc) != null) ? ("\n<size=28>" + this.act.GetTextSmall(this.tc) + "</size>") : "");
        }
 
        // Token: 0x06003ADF RID: 15071 RVA: 0x00137A04 File Offset: 0x00135C04
        public string GetTextContext(bool showName)
        {
            return this.act.GetText("") + ((showName && this.tc != null && !this.HideHint) ? ("<size=13> (" + this.tc.Name + ")</size>") : "");
        }
 
        // Token: 0x06003AE0 RID: 15072 RVA: 0x00137A5C File Offset: 0x00135C5C
        public bool Perform(bool repeated = false)
        {
            if (AM_Adv.actCount == 0 && !Dialog.warned)
            {
                ActPlan.warning = true;
                Chara _CC = Act.CC;
                Card _TC = Act.TC;
                Point _TP = new Point(Act.TP);
                if (EClass._zone.IsCrime(EClass.pc, this.act) && this.act.ID != "actContainer")
                {
                    Dialog.TryWarnCrime(delegate
                    {
                        Act.CC = _CC;
                        Act.TC = _TC;
                        Act.TP.Set(_TP);
                        if (this.Perform(false))
                        {
                            EClass.player.EndTurn(true);
                        }
                    });
                    return false;
                }
                if (this.act is TaskHarvest && (this.act as TaskHarvest).mode == BaseTaskHarvest.HarvestType.Disassemble)
                {
                    Dialog.TryWarnDisassemble(delegate
                    {
                        Act.CC = _CC;
                        Act.TC = _TC;
                        Act.TP.Set(_TP);
                        if (this.Perform(false))
                        {
                            EClass.player.EndTurn(true);
                        }
                    });
                    return false;
                }
            }
            ActPlan.warning = false;
            int num = this.cc.pos.Distance(this.pos);
            bool flag = num == 1 && this.cc.CanInteractTo(this.pos);
            AIAct aiact = this.act as AIAct;
            if (!this.act.IsAct)
            {
                if (repeated)
                {
                    if (this.cc.ai.GetType() == this.act.GetType() && this.cc.ai.IsRunning)
                    {
                        return false;
                    }
                    aiact.Reset();
                    if (!this.act.CanPerform())
                    {
                        this.cc.SetAI(Chara._NoGoalRepeat);
                        return false;
                    }
                    Task task = aiact as Task;
                    if (task != null)
                    {
                        task.isDestroyed = false;
                        TaskPoint taskPoint = task as TaskPoint;
                        if (EClass.scene.mouseTarget.isValid && taskPoint != null)
                        {
                            taskPoint.isRepeated = true;
                            taskPoint.pos = EClass.scene.mouseTarget.pos.Copy();
                        }
                    }
                }
                this.cc.SetAIImmediate(aiact);
                ActionMode.Adv.SetTurbo(aiact.UseTurbo ? -1 : 0);
                return false;
            }
            if (this.act.PerformDistance != -1 && (num > this.act.PerformDistance || (num == 1 && !flag)))
            {
                this.cc.SetAIImmediate(new DynamicAIAct(this.act.GetText(""), () => this.act.Perform(this.cc, this.tc, this.pos), false)
                {
                    pos = this.pos.Copy()
                });
                return false;
            }
            bool flag2 = this.act.Perform(this.cc, this.tc, this.pos);
            if (flag2 && !EClass.pc.HasNoGoal)
            {
                ActionMode.Adv.SetTurbo(-1);
            }
            return flag2 && EClass.pc.HasNoGoal;
        }
 
        // Token: 0x04002535 RID: 9525
        public Act act;
 
        // Token: 0x04002536 RID: 9526
        public Card tc;
 
        // Token: 0x04002537 RID: 9527
        public Point pos;
    }
}