CharaBody.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;
 
// Token: 0x020002A6 RID: 678
public class CharaBody : EClass
{
    // Token: 0x17000622 RID: 1570
    // (get) Token: 0x060015FC RID: 5628 RVA: 0x00094AB6 File Offset: 0x00092CB6
    public int[] rawSlots
    {
        get
        {
            return this.owner.rawSlots;
        }
    }
 
    // Token: 0x060015FD RID: 5629 RVA: 0x00094AC4 File Offset: 0x00092CC4
    public void SetOwner(Chara chara, bool deserialized = false)
    {
        this.owner = chara;
        if (deserialized)
        {
            if (this.rawSlots != null)
            {
                for (int i = 0; i < this.rawSlots.Length; i++)
                {
                    this.AddBodyPart(this.rawSlots[i], null);
                }
            }
            foreach (Thing thing in this.owner.things)
            {
                if (thing.isEquipped)
                {
                    int num = thing.c_equippedSlot - 1;
                    if (num < 0 || num >= this.slots.Count)
                    {
                        thing.c_equippedSlot = 0;
                    }
                    else
                    {
                        this.slots[num].thing = thing;
                        thing.elements.SetParent(this.owner);
                    }
                }
            }
        }
    }
 
    // Token: 0x060015FE RID: 5630 RVA: 0x00094B9C File Offset: 0x00092D9C
    public void Unequip(Thing thing, bool refresh = true)
    {
        if (!thing.isEquipped)
        {
            return;
        }
        this.Unequip(this.slots[thing.c_equippedSlot - 1], refresh);
    }
 
    // Token: 0x060015FF RID: 5631 RVA: 0x00094BC4 File Offset: 0x00092DC4
    public void UnequipAll(int idSlot)
    {
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.elementId == idSlot)
            {
                this.Unequip(bodySlot, true);
            }
        }
    }
 
    // Token: 0x06001600 RID: 5632 RVA: 0x00094C24 File Offset: 0x00092E24
    public void Unequip(BodySlot slot, bool refresh = true)
    {
        if (slot.thing == null)
        {
            return;
        }
        Thing thing = slot.thing;
        if (EClass.pc != null)
        {
            EClass.pc.faction.charaElements.OnUnequip(this.owner, thing);
        }
        thing.elements.SetParent(null);
        thing.c_equippedSlot = 0;
        slot.thing = null;
        if (this.owner.IsPC)
        {
            LayerChara.Refresh();
            LayerInventory.SetDirty(thing);
            WidgetEquip.SetDirty();
        }
        if (slot.elementId == 45 && EClass.core.IsGameStarted)
        {
            this.owner.RecalculateFOV();
        }
        if (refresh && this.owner.isCreated && EClass.core.IsGameStarted)
        {
            this.owner.Refresh(false);
            if (slot.elementId == 37 && this.owner.HasElement(1209, 1))
            {
                this.owner.Say("tail_free", this.owner, null, null);
            }
        }
    }
 
    // Token: 0x06001601 RID: 5633 RVA: 0x00094D18 File Offset: 0x00092F18
    public bool IsEquippable(Thing thing, BodySlot slot, bool text = true)
    {
        CharaBody.<>c__DisplayClass11_0 CS$<>8__locals1;
        CS$<>8__locals1.text = text;
        CS$<>8__locals1.slot = slot;
        if (CS$<>8__locals1.slot == null)
        {
            return false;
        }
        int elementId = CS$<>8__locals1.slot.elementId;
        if (elementId != 31)
        {
            if (elementId != 33)
            {
                if (elementId == 39)
                {
                    if (this.owner.HasElement(1552, 1))
                    {
                        return CharaBody.<IsEquippable>g__CannotEquip|11_0(ref CS$<>8__locals1);
                    }
                }
            }
            else if (this.owner.HasElement(1554, 1))
            {
                return CharaBody.<IsEquippable>g__CannotEquip|11_0(ref CS$<>8__locals1);
            }
        }
        else if (this.owner.HasElement(1555, 1))
        {
            return CharaBody.<IsEquippable>g__CannotEquip|11_0(ref CS$<>8__locals1);
        }
        if (this.IsTooHeavyToEquip(thing))
        {
            if (EClass.core.IsGameStarted && this.owner.IsPC && CS$<>8__locals1.text)
            {
                Msg.Say("tooHeavyToEquip", thing, null, null, null);
            }
            return false;
        }
        return true;
    }
 
    // Token: 0x06001602 RID: 5634 RVA: 0x00094DE9 File Offset: 0x00092FE9
    public bool IsTooHeavyToEquip(Thing thing)
    {
        return this.owner.HasElement(1204, 1) && thing.ChildrenAndSelfWeight > 1000 && thing.category.slot != 44;
    }
 
    // Token: 0x06001603 RID: 5635 RVA: 0x00094E20 File Offset: 0x00093020
    public void UnqeuipIfTooHeavy(Thing t)
    {
        if (t.isEquipped)
        {
            BodySlot bodySlot = this.slots[t.c_equippedSlot - 1];
            if (this.IsTooHeavyToEquip(t))
            {
                this.owner.Say("tooHeavyToEquip", t, null, null);
                this.Unequip(t, true);
            }
        }
        if (!this.owner.IsPC && !t.isEquipped)
        {
            this.owner.TryEquip(t, false);
        }
    }
 
    // Token: 0x06001604 RID: 5636 RVA: 0x00094E90 File Offset: 0x00093090
    public bool Equip(Thing thing, BodySlot slot = null, bool msg = true)
    {
        BodySlot bodySlot;
        if ((bodySlot = slot) == null)
        {
            bodySlot = (this.GetSlot(thing.category.slot, true, false) ?? this.GetSlot(thing.category.slot, false, false));
        }
        slot = bodySlot;
        if (slot == this.slotMainHand || slot == this.slotOffHand)
        {
            this.owner.combatCount = 10;
        }
        if (slot == null || slot.elementId != thing.category.slot)
        {
            string[] array = new string[6];
            array[0] = "could not equip:";
            array[1] = ((thing != null) ? thing.ToString() : null);
            array[2] = "/";
            int num = 3;
            BodySlot bodySlot2 = slot;
            array[num] = ((bodySlot2 != null) ? bodySlot2.ToString() : null);
            array[4] = "/";
            int num2 = 5;
            Chara chara = this.owner;
            array[num2] = ((chara != null) ? chara.ToString() : null);
            Debug.LogWarning(string.Concat(array));
            return false;
        }
        if (!this.IsEquippable(thing, slot, true))
        {
            return false;
        }
        if (slot.thing != null)
        {
            if (slot.thing == thing)
            {
                this.Unequip(slot, true);
                return false;
            }
            this.Unequip(slot, false);
        }
        this.Unequip(thing, false);
        if (thing.parent != this.owner)
        {
            if (msg && this.owner.IsPC && thing.parent is Thing)
            {
                Msg.Say("movedToEquip", thing, thing.parent as Thing, null, null);
            }
            this.owner.AddCard(thing);
        }
        slot.thing = thing;
        thing.c_equippedSlot = slot.index + 1;
        thing.elements.SetParent(this.owner);
        if (EClass.pc != null)
        {
            EClass.pc.faction.charaElements.OnEquip(this.owner, thing);
        }
        this.owner.SetTempHand(0, 0);
        if (this.owner.IsPC)
        {
            LayerChara.Refresh();
            LayerInventory.SetDirty(thing);
            WidgetEquip.SetDirty();
        }
        if (slot.elementId == 45 && EClass.core.IsGameStarted)
        {
            this.owner.RecalculateFOV();
        }
        if (this.owner.isCreated && EClass.core.IsGameStarted)
        {
            this.owner.Refresh(false);
        }
        if (this.owner.isCreated)
        {
            if (thing.Evalue(656) > 0)
            {
                thing.blessedState = BlessedState.Cursed;
            }
            if (thing.blessedState <= BlessedState.Cursed)
            {
                this.owner.Say("equipCursed", this.owner, null, null);
                this.owner.PlaySound("curse3", 1f, true);
            }
        }
        if (slot.elementId == 37 && this.owner.HasElement(1209, 1))
        {
            this.owner.Say("tail_covered", this.owner, null, null);
        }
        return true;
    }
 
    // Token: 0x06001605 RID: 5637 RVA: 0x00095134 File Offset: 0x00093334
    public void AddBodyPart(int ele, Thing thing = null)
    {
        BodySlot item = new BodySlot
        {
            elementId = ele,
            thing = thing,
            index = this.slots.Count
        };
        if (ele == 35)
        {
            if (this.slotMainHand == null)
            {
                this.slotMainHand = item;
            }
            else if (this.slotOffHand == null)
            {
                this.slotOffHand = item;
            }
        }
        if (ele == 41)
        {
            this.slotRange = item;
        }
        this.slots.Add(item);
    }
 
    // Token: 0x06001606 RID: 5638 RVA: 0x000951A4 File Offset: 0x000933A4
    public void RefreshBodyParts()
    {
        foreach (BodySlot bodySlot in this.slots)
        {
            int elementId = bodySlot.elementId;
            if (elementId == 35)
            {
                if (this.slotMainHand == null)
                {
                    this.slotMainHand = bodySlot;
                }
                else if (this.slotOffHand == null)
                {
                    this.slotOffHand = bodySlot;
                }
            }
            if (elementId == 41)
            {
                this.slotRange = bodySlot;
            }
        }
    }
 
    // Token: 0x06001607 RID: 5639 RVA: 0x00095228 File Offset: 0x00093428
    public void RemoveBodyPart(int ele)
    {
        int num = this.slots.FindIndex((BodySlot a) => a.elementId == ele);
        if (num != -1)
        {
            BodySlot bodySlot = this.slots[num];
            if (bodySlot.thing != null)
            {
                this.Unequip(bodySlot, true);
            }
            if (this.slotMainHand == bodySlot)
            {
                this.slotMainHand = null;
            }
            if (this.slotOffHand == bodySlot)
            {
                this.slotOffHand = null;
            }
            if (this.slotRange == bodySlot)
            {
                this.slotRange = null;
            }
            this.slots.RemoveAt(num);
        }
    }
 
    // Token: 0x06001608 RID: 5640 RVA: 0x000952B8 File Offset: 0x000934B8
    public BodySlot GetSlot(Thing t, bool onlyEmpty = false, bool secondSlot = false)
    {
        BodySlot slot = this.GetSlot(t.category.slot, true, secondSlot);
        if (slot != null)
        {
            return slot;
        }
        if (!onlyEmpty)
        {
            return this.GetSlot(t.category.slot, false, secondSlot);
        }
        return null;
    }
 
    // Token: 0x06001609 RID: 5641 RVA: 0x000952F8 File Offset: 0x000934F8
    public BodySlot GetSlot(int elementId, bool onlyEmpty = true, bool secondSlot = false)
    {
        bool flag = true;
        foreach (BodySlot bodySlot in this.slots)
        {
            if (elementId == bodySlot.elementId && (!onlyEmpty || bodySlot.thing == null))
            {
                if (!secondSlot || !flag)
                {
                    return bodySlot;
                }
                flag = false;
            }
        }
        return null;
    }
 
    // Token: 0x0600160A RID: 5642 RVA: 0x0009536C File Offset: 0x0009356C
    public Thing GetEquippedThing(int elementId)
    {
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.elementId == elementId && bodySlot.thing != null)
            {
                return bodySlot.thing;
            }
        }
        return null;
    }
 
    // Token: 0x0600160B RID: 5643 RVA: 0x000953D8 File Offset: 0x000935D8
    public int GetWeight(bool armorOnly = false)
    {
        int num = 0;
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.thing != null && (!armorOnly || (bodySlot.elementId != 44 && bodySlot.elementId != 45)))
            {
                num += bodySlot.thing.ChildrenAndSelfWeight;
            }
        }
        return num;
    }
 
    // Token: 0x0600160C RID: 5644 RVA: 0x00095454 File Offset: 0x00093654
    public int GetAttackIndex(Thing t)
    {
        int num = 0;
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.thing != null && bodySlot.elementId == 35 && bodySlot.thing.source.offense.Length >= 2)
            {
                if (bodySlot.thing == t)
                {
                    return num;
                }
                num++;
            }
        }
        return -1;
    }
 
    // Token: 0x0600160D RID: 5645 RVA: 0x000954E0 File Offset: 0x000936E0
    public int GetMeleeDistance()
    {
        int num = this.owner.Evalue(666);
        if (num == 0)
        {
            return 1;
        }
        num = 0;
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.elementId == 35 && bodySlot.thing != null && bodySlot.thing.Evalue(666) > num)
            {
                num = bodySlot.thing.Evalue(666);
            }
        }
        return 1 + num;
    }
 
    // Token: 0x0600160E RID: 5646 RVA: 0x00095580 File Offset: 0x00093780
    public AttackStyle GetAttackStyle()
    {
        bool flag = false;
        int num = 0;
        foreach (BodySlot bodySlot in this.slots)
        {
            if (bodySlot.elementId == 35 && bodySlot.thing != null)
            {
                if (bodySlot.thing.IsMeleeWeapon)
                {
                    num++;
                }
                else
                {
                    flag = true;
                }
            }
        }
        if (num > 1)
        {
            return AttackStyle.TwoWield;
        }
        if (flag)
        {
            return AttackStyle.Shield;
        }
        if (num == 1)
        {
            return AttackStyle.TwoHand;
        }
        return AttackStyle.Default;
    }
 
    // Token: 0x0600160F RID: 5647 RVA: 0x0009560C File Offset: 0x0009380C
    public int GetAttackStyleElement(AttackStyle style)
    {
        if (style == AttackStyle.TwoHand)
        {
            return 130;
        }
        if (style != AttackStyle.TwoWield)
        {
            return 0;
        }
        return 131;
    }
 
    // Token: 0x06001611 RID: 5649 RVA: 0x00095638 File Offset: 0x00093838
    [CompilerGenerated]
    internal static bool <IsEquippable>g__CannotEquip|11_0(ref CharaBody.<>c__DisplayClass11_0 A_0)
    {
        if (A_0.text)
        {
            Msg.Say("cannnotEquip", A_0.slot.element.GetName().ToLower(), null, null, null);
        }
        return false;
    }
 
    // Token: 0x04001028 RID: 4136
    public Chara owner;
 
    // Token: 0x04001029 RID: 4137
    public List<BodySlot> slots = new List<BodySlot>();
 
    // Token: 0x0400102A RID: 4138
    public BodySlot slotMainHand;
 
    // Token: 0x0400102B RID: 4139
    public BodySlot slotOffHand;
 
    // Token: 0x0400102C RID: 4140
    public BodySlot slotRange;
}