Card.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Text;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x02000289 RID: 649
public class Card : BaseCard, IReservable, ICardParent, IRenderSource, IGlobalValue, IInspect
{
    // Token: 0x06001164 RID: 4452 RVA: 0x00077FFC File Offset: 0x000761FC
    public override string ToString()
    {
        string[] array = new string[5];
        array[0] = this.Name;
        array[1] = "/";
        int num = 2;
        Point point = this.pos;
        array[num] = ((point != null) ? point.ToString() : null);
        array[3] = "/";
        int num2 = 4;
        ICardParent cardParent = this.parent;
        array[num2] = ((cardParent != null) ? cardParent.ToString() : null);
        return string.Concat(array);
    }
 
    // Token: 0x06001165 RID: 4453 RVA: 0x00078057 File Offset: 0x00076257
    public bool CanReserve(AIAct act)
    {
        return this.reservedAct == null || this.reservedAct == act || !this.reservedAct.IsRunning;
    }
 
    // Token: 0x06001166 RID: 4454 RVA: 0x0007807A File Offset: 0x0007627A
    public bool TryReserve(AIAct act)
    {
        if (this.CanReserve(act))
        {
            this.reservedAct = act;
            return true;
        }
        return false;
    }
 
    // Token: 0x1700049E RID: 1182
    // (get) Token: 0x06001167 RID: 4455 RVA: 0x0007808F File Offset: 0x0007628F
    public Card parentCard
    {
        get
        {
            return this.parent as Card;
        }
    }
 
    // Token: 0x1700049F RID: 1183
    // (get) Token: 0x06001168 RID: 4456 RVA: 0x0007809C File Offset: 0x0007629C
    public Thing parentThing
    {
        get
        {
            return this.parent as Thing;
        }
    }
 
    // Token: 0x170004A0 RID: 1184
    // (get) Token: 0x06001169 RID: 4457 RVA: 0x000780A9 File Offset: 0x000762A9
    public int colorInt
    {
        get
        {
            if (this._colorInt == 0)
            {
                this.RefreshColor();
            }
            return this._colorInt;
        }
    }
 
    // Token: 0x170004A1 RID: 1185
    // (get) Token: 0x0600116A RID: 4458 RVA: 0x000780BF File Offset: 0x000762BF
    public bool IsHotItem
    {
        get
        {
            return this.invY == 1;
        }
    }
 
    // Token: 0x170004A2 RID: 1186
    // (get) Token: 0x0600116B RID: 4459 RVA: 0x000780CA File Offset: 0x000762CA
    // (set) Token: 0x0600116C RID: 4460 RVA: 0x000780D4 File Offset: 0x000762D4
    public int uid
    {
        get
        {
            return this._ints[1];
        }
        set
        {
            this._ints[1] = value;
        }
    }
 
    // Token: 0x170004A3 RID: 1187
    // (get) Token: 0x0600116D RID: 4461 RVA: 0x000780DF File Offset: 0x000762DF
    // (set) Token: 0x0600116E RID: 4462 RVA: 0x000780E9 File Offset: 0x000762E9
    public int idMaterial
    {
        get
        {
            return this._ints[4];
        }
        set
        {
            this._ints[4] = value;
        }
    }
 
    // Token: 0x170004A4 RID: 1188
    // (get) Token: 0x0600116F RID: 4463 RVA: 0x000780F4 File Offset: 0x000762F4
    // (set) Token: 0x06001170 RID: 4464 RVA: 0x000780FE File Offset: 0x000762FE
    public int dir
    {
        get
        {
            return this._ints[5];
        }
        set
        {
            this._ints[5] = value;
        }
    }
 
    // Token: 0x170004A5 RID: 1189
    // (get) Token: 0x06001171 RID: 4465 RVA: 0x00078109 File Offset: 0x00076309
    // (set) Token: 0x06001172 RID: 4466 RVA: 0x00078113 File Offset: 0x00076313
    public int Num
    {
        get
        {
            return this._ints[6];
        }
        set
        {
            this._ints[6] = value;
        }
    }
 
    // Token: 0x170004A6 RID: 1190
    // (get) Token: 0x06001173 RID: 4467 RVA: 0x0007811E File Offset: 0x0007631E
    // (set) Token: 0x06001174 RID: 4468 RVA: 0x00078128 File Offset: 0x00076328
    public int _x
    {
        get
        {
            return this._ints[7];
        }
        set
        {
            this._ints[7] = value;
        }
    }
 
    // Token: 0x170004A7 RID: 1191
    // (get) Token: 0x06001175 RID: 4469 RVA: 0x00078133 File Offset: 0x00076333
    // (set) Token: 0x06001176 RID: 4470 RVA: 0x0007813E File Offset: 0x0007633E
    public int _z
    {
        get
        {
            return this._ints[9];
        }
        set
        {
            this._ints[9] = value;
        }
    }
 
    // Token: 0x170004A8 RID: 1192
    // (get) Token: 0x06001177 RID: 4471 RVA: 0x0007814A File Offset: 0x0007634A
    // (set) Token: 0x06001178 RID: 4472 RVA: 0x00078155 File Offset: 0x00076355
    public int refVal
    {
        get
        {
            return this._ints[11];
        }
        set
        {
            this._ints[11] = value;
        }
    }
 
    // Token: 0x170004A9 RID: 1193
    // (get) Token: 0x06001179 RID: 4473 RVA: 0x00078161 File Offset: 0x00076361
    // (set) Token: 0x0600117A RID: 4474 RVA: 0x0007816C File Offset: 0x0007636C
    public int decay
    {
        get
        {
            return this._ints[12];
        }
        set
        {
            this._ints[12] = value;
        }
    }
 
    // Token: 0x170004AA RID: 1194
    // (get) Token: 0x0600117B RID: 4475 RVA: 0x00078178 File Offset: 0x00076378
    // (set) Token: 0x0600117C RID: 4476 RVA: 0x00078183 File Offset: 0x00076383
    public int altitude
    {
        get
        {
            return this._ints[13];
        }
        set
        {
            this._ints[13] = value;
        }
    }
 
    // Token: 0x170004AB RID: 1195
    // (get) Token: 0x0600117D RID: 4477 RVA: 0x0007818F File Offset: 0x0007638F
    // (set) Token: 0x0600117E RID: 4478 RVA: 0x0007819A File Offset: 0x0007639A
    public int hp
    {
        get
        {
            return this._ints[14];
        }
        set
        {
            this._ints[14] = value;
        }
    }
 
    // Token: 0x170004AC RID: 1196
    // (get) Token: 0x0600117F RID: 4479 RVA: 0x000781A6 File Offset: 0x000763A6
    // (set) Token: 0x06001180 RID: 4480 RVA: 0x000781B8 File Offset: 0x000763B8
    public float fx
    {
        get
        {
            return 0.001f * (float)this._ints[15];
        }
        set
        {
            this._ints[15] = (int)(value * 1000f);
        }
    }
 
    // Token: 0x170004AD RID: 1197
    // (get) Token: 0x06001181 RID: 4481 RVA: 0x000781CB File Offset: 0x000763CB
    // (set) Token: 0x06001182 RID: 4482 RVA: 0x000781DD File Offset: 0x000763DD
    public float fy
    {
        get
        {
            return 0.001f * (float)this._ints[16];
        }
        set
        {
            this._ints[16] = (int)(value * 1000f);
        }
    }
 
    // Token: 0x170004AE RID: 1198
    // (get) Token: 0x06001183 RID: 4483 RVA: 0x000781F0 File Offset: 0x000763F0
    // (set) Token: 0x06001184 RID: 4484 RVA: 0x00078200 File Offset: 0x00076400
    public BlessedState blessedState
    {
        get
        {
            return this._ints[17].ToEnum<BlessedState>();
        }
        set
        {
            this._ints[17] = (int)value;
        }
    }
 
    // Token: 0x170004AF RID: 1199
    // (get) Token: 0x06001185 RID: 4485 RVA: 0x0007820C File Offset: 0x0007640C
    // (set) Token: 0x06001186 RID: 4486 RVA: 0x0007821C File Offset: 0x0007641C
    public PlaceState _placeState
    {
        get
        {
            return this._ints[18].ToEnum<PlaceState>();
        }
        set
        {
            this._ints[18] = (int)value;
        }
    }
 
    // Token: 0x170004B0 RID: 1200
    // (get) Token: 0x06001187 RID: 4487 RVA: 0x00078228 File Offset: 0x00076428
    // (set) Token: 0x06001188 RID: 4488 RVA: 0x00078233 File Offset: 0x00076433
    public int rarityLv
    {
        get
        {
            return this._ints[19];
        }
        set
        {
            this._ints[19] = value;
        }
    }
 
    // Token: 0x170004B1 RID: 1201
    // (get) Token: 0x06001189 RID: 4489 RVA: 0x0007823F File Offset: 0x0007643F
    // (set) Token: 0x0600118A RID: 4490 RVA: 0x00078252 File Offset: 0x00076452
    public Rarity rarity
    {
        get
        {
            return (this._ints[19] / 100).ToEnum<Rarity>();
        }
        set
        {
            this._ints[19] = (int)(value * (Rarity)100);
        }
    }
 
    // Token: 0x170004B2 RID: 1202
    // (get) Token: 0x0600118B RID: 4491 RVA: 0x00078261 File Offset: 0x00076461
    // (set) Token: 0x0600118C RID: 4492 RVA: 0x0007826C File Offset: 0x0007646C
    public int encLV
    {
        get
        {
            return this._ints[20];
        }
        set
        {
            this._ints[20] = value;
        }
    }
 
    // Token: 0x170004B3 RID: 1203
    // (get) Token: 0x0600118D RID: 4493 RVA: 0x00078278 File Offset: 0x00076478
    // (set) Token: 0x0600118E RID: 4494 RVA: 0x00078283 File Offset: 0x00076483
    public int posInvX
    {
        get
        {
            return this._ints[21];
        }
        set
        {
            this._ints[21] = value;
        }
    }
 
    // Token: 0x170004B4 RID: 1204
    // (get) Token: 0x0600118F RID: 4495 RVA: 0x0007828F File Offset: 0x0007648F
    // (set) Token: 0x06001190 RID: 4496 RVA: 0x0007829A File Offset: 0x0007649A
    public int posInvY
    {
        get
        {
            return this._ints[22];
        }
        set
        {
            this._ints[22] = value;
        }
    }
 
    // Token: 0x170004B5 RID: 1205
    // (get) Token: 0x06001191 RID: 4497 RVA: 0x000782A6 File Offset: 0x000764A6
    // (set) Token: 0x06001192 RID: 4498 RVA: 0x000782B1 File Offset: 0x000764B1
    public int idSkin
    {
        get
        {
            return this._ints[23];
        }
        set
        {
            this._ints[23] = value;
        }
    }
 
    // Token: 0x170004B6 RID: 1206
    // (get) Token: 0x06001193 RID: 4499 RVA: 0x000782BD File Offset: 0x000764BD
    // (set) Token: 0x06001194 RID: 4500 RVA: 0x000782C8 File Offset: 0x000764C8
    public int feat
    {
        get
        {
            return this._ints[24];
        }
        set
        {
            this._ints[24] = value;
        }
    }
 
    // Token: 0x170004B7 RID: 1207
    // (get) Token: 0x06001195 RID: 4501 RVA: 0x000782D4 File Offset: 0x000764D4
    // (set) Token: 0x06001196 RID: 4502 RVA: 0x000782DF File Offset: 0x000764DF
    public int LV
    {
        get
        {
            return this._ints[25];
        }
        set
        {
            this._ints[25] = value;
        }
    }
 
    // Token: 0x170004B8 RID: 1208
    // (get) Token: 0x06001197 RID: 4503 RVA: 0x000782EB File Offset: 0x000764EB
    // (set) Token: 0x06001198 RID: 4504 RVA: 0x000782F6 File Offset: 0x000764F6
    public int exp
    {
        get
        {
            return this._ints[26];
        }
        set
        {
            this._ints[26] = value;
        }
    }
 
    // Token: 0x170004B9 RID: 1209
    // (get) Token: 0x06001199 RID: 4505 RVA: 0x00078302 File Offset: 0x00076502
    // (set) Token: 0x0600119A RID: 4506 RVA: 0x0007830D File Offset: 0x0007650D
    public int qualityTier
    {
        get
        {
            return this._ints[27];
        }
        set
        {
            this._ints[27] = value;
        }
    }
 
    // Token: 0x170004BA RID: 1210
    // (get) Token: 0x0600119B RID: 4507 RVA: 0x00078319 File Offset: 0x00076519
    // (set) Token: 0x0600119C RID: 4508 RVA: 0x00078327 File Offset: 0x00076527
    public bool isCensored
    {
        get
        {
            return this._bits1[1];
        }
        set
        {
            this._bits1[1] = value;
        }
    }
 
    // Token: 0x170004BB RID: 1211
    // (get) Token: 0x0600119D RID: 4509 RVA: 0x00078336 File Offset: 0x00076536
    // (set) Token: 0x0600119E RID: 4510 RVA: 0x00078344 File Offset: 0x00076544
    public bool isDeconstructing
    {
        get
        {
            return this._bits1[2];
        }
        set
        {
            this._bits1[2] = value;
        }
    }
 
    // Token: 0x170004BC RID: 1212
    // (get) Token: 0x0600119F RID: 4511 RVA: 0x00078353 File Offset: 0x00076553
    // (set) Token: 0x060011A0 RID: 4512 RVA: 0x00078361 File Offset: 0x00076561
    public bool isDyed
    {
        get
        {
            return this._bits1[3];
        }
        set
        {
            this._bits1[3] = value;
        }
    }
 
    // Token: 0x170004BD RID: 1213
    // (get) Token: 0x060011A1 RID: 4513 RVA: 0x00078370 File Offset: 0x00076570
    // (set) Token: 0x060011A2 RID: 4514 RVA: 0x0007837E File Offset: 0x0007657E
    public bool isModified
    {
        get
        {
            return this._bits1[4];
        }
        set
        {
            this._bits1[4] = value;
        }
    }
 
    // Token: 0x170004BE RID: 1214
    // (get) Token: 0x060011A3 RID: 4515 RVA: 0x0007838D File Offset: 0x0007658D
    // (set) Token: 0x060011A4 RID: 4516 RVA: 0x0007839B File Offset: 0x0007659B
    public bool isNew
    {
        get
        {
            return this._bits1[5];
        }
        set
        {
            this._bits1[5] = value;
        }
    }
 
    // Token: 0x170004BF RID: 1215
    // (get) Token: 0x060011A5 RID: 4517 RVA: 0x000783AA File Offset: 0x000765AA
    // (set) Token: 0x060011A6 RID: 4518 RVA: 0x000783B8 File Offset: 0x000765B8
    public bool isPlayerCreation
    {
        get
        {
            return this._bits1[6];
        }
        set
        {
            this._bits1[6] = value;
        }
    }
 
    // Token: 0x170004C0 RID: 1216
    // (get) Token: 0x060011A7 RID: 4519 RVA: 0x000783C7 File Offset: 0x000765C7
    // (set) Token: 0x060011A8 RID: 4520 RVA: 0x000783D5 File Offset: 0x000765D5
    public bool ignoreAutoPick
    {
        get
        {
            return this._bits1[7];
        }
        set
        {
            this._bits1[7] = value;
        }
    }
 
    // Token: 0x170004C1 RID: 1217
    // (get) Token: 0x060011A9 RID: 4521 RVA: 0x000783E4 File Offset: 0x000765E4
    // (set) Token: 0x060011AA RID: 4522 RVA: 0x000783F2 File Offset: 0x000765F2
    public bool freePos
    {
        get
        {
            return this._bits1[8];
        }
        set
        {
            this._bits1[8] = value;
        }
    }
 
    // Token: 0x170004C2 RID: 1218
    // (get) Token: 0x060011AB RID: 4523 RVA: 0x00078401 File Offset: 0x00076601
    // (set) Token: 0x060011AC RID: 4524 RVA: 0x00078410 File Offset: 0x00076610
    public bool isHidden
    {
        get
        {
            return this._bits1[9];
        }
        set
        {
            this._bits1[9] = value;
        }
    }
 
    // Token: 0x170004C3 RID: 1219
    // (get) Token: 0x060011AD RID: 4525 RVA: 0x00078420 File Offset: 0x00076620
    // (set) Token: 0x060011AE RID: 4526 RVA: 0x0007842F File Offset: 0x0007662F
    public bool isOn
    {
        get
        {
            return this._bits1[10];
        }
        set
        {
            this._bits1[10] = value;
        }
    }
 
    // Token: 0x170004C4 RID: 1220
    // (get) Token: 0x060011AF RID: 4527 RVA: 0x0007843F File Offset: 0x0007663F
    // (set) Token: 0x060011B0 RID: 4528 RVA: 0x0007844E File Offset: 0x0007664E
    public bool isNPCProperty
    {
        get
        {
            return this._bits1[11];
        }
        set
        {
            this._bits1[11] = value;
        }
    }
 
    // Token: 0x170004C5 RID: 1221
    // (get) Token: 0x060011B1 RID: 4529 RVA: 0x0007845E File Offset: 0x0007665E
    // (set) Token: 0x060011B2 RID: 4530 RVA: 0x0007846D File Offset: 0x0007666D
    public bool isRestrained
    {
        get
        {
            return this._bits1[12];
        }
        set
        {
            this._bits1[12] = value;
        }
    }
 
    // Token: 0x170004C6 RID: 1222
    // (get) Token: 0x060011B3 RID: 4531 RVA: 0x0007847D File Offset: 0x0007667D
    // (set) Token: 0x060011B4 RID: 4532 RVA: 0x0007848C File Offset: 0x0007668C
    public bool isRoofItem
    {
        get
        {
            return this._bits1[13];
        }
        set
        {
            this._bits1[13] = value;
        }
    }
 
    // Token: 0x170004C7 RID: 1223
    // (get) Token: 0x060011B5 RID: 4533 RVA: 0x0007849C File Offset: 0x0007669C
    // (set) Token: 0x060011B6 RID: 4534 RVA: 0x000784AB File Offset: 0x000766AB
    public bool isMasked
    {
        get
        {
            return this._bits1[14];
        }
        set
        {
            this._bits1[14] = value;
        }
    }
 
    // Token: 0x170004C8 RID: 1224
    // (get) Token: 0x060011B7 RID: 4535 RVA: 0x000784BB File Offset: 0x000766BB
    // (set) Token: 0x060011B8 RID: 4536 RVA: 0x000784CA File Offset: 0x000766CA
    public bool disableAutoToggle
    {
        get
        {
            return this._bits1[15];
        }
        set
        {
            this._bits1[15] = value;
        }
    }
 
    // Token: 0x170004C9 RID: 1225
    // (get) Token: 0x060011B9 RID: 4537 RVA: 0x000784DA File Offset: 0x000766DA
    // (set) Token: 0x060011BA RID: 4538 RVA: 0x000784E9 File Offset: 0x000766E9
    public bool isImported
    {
        get
        {
            return this._bits1[16];
        }
        set
        {
            this._bits1[16] = value;
        }
    }
 
    // Token: 0x170004CA RID: 1226
    // (get) Token: 0x060011BB RID: 4539 RVA: 0x000784F9 File Offset: 0x000766F9
    // (set) Token: 0x060011BC RID: 4540 RVA: 0x00078508 File Offset: 0x00076708
    public bool autoRefuel
    {
        get
        {
            return this._bits1[17];
        }
        set
        {
            this._bits1[17] = value;
        }
    }
 
    // Token: 0x170004CB RID: 1227
    // (get) Token: 0x060011BD RID: 4541 RVA: 0x00078518 File Offset: 0x00076718
    // (set) Token: 0x060011BE RID: 4542 RVA: 0x00078527 File Offset: 0x00076727
    public bool ignoreStackHeight
    {
        get
        {
            return this._bits1[18];
        }
        set
        {
            this._bits1[18] = value;
        }
    }
 
    // Token: 0x170004CC RID: 1228
    // (get) Token: 0x060011BF RID: 4543 RVA: 0x00078537 File Offset: 0x00076737
    // (set) Token: 0x060011C0 RID: 4544 RVA: 0x00078546 File Offset: 0x00076746
    public bool isFloating
    {
        get
        {
            return this._bits1[19];
        }
        set
        {
            this._bits1[19] = value;
        }
    }
 
    // Token: 0x170004CD RID: 1229
    // (get) Token: 0x060011C1 RID: 4545 RVA: 0x00078556 File Offset: 0x00076756
    // (set) Token: 0x060011C2 RID: 4546 RVA: 0x00078565 File Offset: 0x00076765
    public bool isWeightChanged
    {
        get
        {
            return this._bits1[20];
        }
        set
        {
            this._bits1[20] = value;
        }
    }
 
    // Token: 0x170004CE RID: 1230
    // (get) Token: 0x060011C3 RID: 4547 RVA: 0x00078575 File Offset: 0x00076775
    // (set) Token: 0x060011C4 RID: 4548 RVA: 0x00078584 File Offset: 0x00076784
    public bool isFireproof
    {
        get
        {
            return this._bits1[21];
        }
        set
        {
            this._bits1[21] = value;
        }
    }
 
    // Token: 0x170004CF RID: 1231
    // (get) Token: 0x060011C5 RID: 4549 RVA: 0x00078594 File Offset: 0x00076794
    // (set) Token: 0x060011C6 RID: 4550 RVA: 0x000785A3 File Offset: 0x000767A3
    public bool isAcidproof
    {
        get
        {
            return this._bits1[22];
        }
        set
        {
            this._bits1[22] = value;
        }
    }
 
    // Token: 0x170004D0 RID: 1232
    // (get) Token: 0x060011C7 RID: 4551 RVA: 0x000785B3 File Offset: 0x000767B3
    // (set) Token: 0x060011C8 RID: 4552 RVA: 0x000785C2 File Offset: 0x000767C2
    public bool isReplica
    {
        get
        {
            return this._bits1[23];
        }
        set
        {
            this._bits1[23] = value;
        }
    }
 
    // Token: 0x170004D1 RID: 1233
    // (get) Token: 0x060011C9 RID: 4553 RVA: 0x000785D2 File Offset: 0x000767D2
    // (set) Token: 0x060011CA RID: 4554 RVA: 0x000785E1 File Offset: 0x000767E1
    public bool isSummon
    {
        get
        {
            return this._bits1[24];
        }
        set
        {
            this._bits1[24] = value;
        }
    }
 
    // Token: 0x170004D2 RID: 1234
    // (get) Token: 0x060011CB RID: 4555 RVA: 0x000785F1 File Offset: 0x000767F1
    // (set) Token: 0x060011CC RID: 4556 RVA: 0x00078600 File Offset: 0x00076800
    public bool isElemental
    {
        get
        {
            return this._bits1[25];
        }
        set
        {
            this._bits1[25] = value;
        }
    }
 
    // Token: 0x170004D3 RID: 1235
    // (get) Token: 0x060011CD RID: 4557 RVA: 0x00078610 File Offset: 0x00076810
    // (set) Token: 0x060011CE RID: 4558 RVA: 0x0007861F File Offset: 0x0007681F
    public bool isBroken
    {
        get
        {
            return this._bits1[26];
        }
        set
        {
            this._bits1[26] = value;
        }
    }
 
    // Token: 0x170004D4 RID: 1236
    // (get) Token: 0x060011CF RID: 4559 RVA: 0x0007862F File Offset: 0x0007682F
    // (set) Token: 0x060011D0 RID: 4560 RVA: 0x0007863E File Offset: 0x0007683E
    public bool isSubsetCard
    {
        get
        {
            return this._bits1[27];
        }
        set
        {
            this._bits1[27] = value;
        }
    }
 
    // Token: 0x170004D5 RID: 1237
    // (get) Token: 0x060011D1 RID: 4561 RVA: 0x0007864E File Offset: 0x0007684E
    // (set) Token: 0x060011D2 RID: 4562 RVA: 0x0007865D File Offset: 0x0007685D
    public bool noSnow
    {
        get
        {
            return this._bits1[28];
        }
        set
        {
            this._bits1[28] = value;
        }
    }
 
    // Token: 0x170004D6 RID: 1238
    // (get) Token: 0x060011D3 RID: 4563 RVA: 0x0007866D File Offset: 0x0007686D
    // (set) Token: 0x060011D4 RID: 4564 RVA: 0x0007867C File Offset: 0x0007687C
    public bool noMove
    {
        get
        {
            return this._bits1[29];
        }
        set
        {
            this._bits1[29] = value;
        }
    }
 
    // Token: 0x170004D7 RID: 1239
    // (get) Token: 0x060011D5 RID: 4565 RVA: 0x0007868C File Offset: 0x0007688C
    // (set) Token: 0x060011D6 RID: 4566 RVA: 0x0007869B File Offset: 0x0007689B
    public bool isGifted
    {
        get
        {
            return this._bits1[30];
        }
        set
        {
            this._bits1[30] = value;
        }
    }
 
    // Token: 0x170004D8 RID: 1240
    // (get) Token: 0x060011D7 RID: 4567 RVA: 0x000786AB File Offset: 0x000768AB
    // (set) Token: 0x060011D8 RID: 4568 RVA: 0x000786BA File Offset: 0x000768BA
    public bool isCrafted
    {
        get
        {
            return this._bits1[31];
        }
        set
        {
            this._bits1[31] = value;
        }
    }
 
    // Token: 0x170004D9 RID: 1241
    // (get) Token: 0x060011D9 RID: 4569 RVA: 0x000786CA File Offset: 0x000768CA
    // (set) Token: 0x060011DA RID: 4570 RVA: 0x000786D8 File Offset: 0x000768D8
    public bool isLostProperty
    {
        get
        {
            return this._bits2[0];
        }
        set
        {
            this._bits2[0] = value;
        }
    }
 
    // Token: 0x170004DA RID: 1242
    // (get) Token: 0x060011DB RID: 4571 RVA: 0x000786E7 File Offset: 0x000768E7
    // (set) Token: 0x060011DC RID: 4572 RVA: 0x000786F5 File Offset: 0x000768F5
    public bool noShadow
    {
        get
        {
            return this._bits2[1];
        }
        set
        {
            this._bits2[1] = value;
        }
    }
 
    // Token: 0x170004DB RID: 1243
    // (get) Token: 0x060011DD RID: 4573 RVA: 0x00078704 File Offset: 0x00076904
    // (set) Token: 0x060011DE RID: 4574 RVA: 0x00078712 File Offset: 0x00076912
    public bool noSell
    {
        get
        {
            return this._bits2[2];
        }
        set
        {
            this._bits2[2] = value;
        }
    }
 
    // Token: 0x170004DC RID: 1244
    // (get) Token: 0x060011DF RID: 4575 RVA: 0x00078721 File Offset: 0x00076921
    // (set) Token: 0x060011E0 RID: 4576 RVA: 0x0007872F File Offset: 0x0007692F
    public bool isLeashed
    {
        get
        {
            return this._bits2[3];
        }
        set
        {
            this._bits2[3] = value;
        }
    }
 
    // Token: 0x170004DD RID: 1245
    // (get) Token: 0x060011E1 RID: 4577 RVA: 0x0007873E File Offset: 0x0007693E
    // (set) Token: 0x060011E2 RID: 4578 RVA: 0x0007874C File Offset: 0x0007694C
    public bool isStolen
    {
        get
        {
            return this._bits2[4];
        }
        set
        {
            this._bits2[4] = value;
        }
    }
 
    // Token: 0x170004DE RID: 1246
    // (get) Token: 0x060011E3 RID: 4579 RVA: 0x0007875B File Offset: 0x0007695B
    // (set) Token: 0x060011E4 RID: 4580 RVA: 0x00078769 File Offset: 0x00076969
    public bool isSale
    {
        get
        {
            return this._bits2[5];
        }
        set
        {
            this._bits2[5] = value;
        }
    }
 
    // Token: 0x170004DF RID: 1247
    // (get) Token: 0x060011E5 RID: 4581 RVA: 0x00078778 File Offset: 0x00076978
    // (set) Token: 0x060011E6 RID: 4582 RVA: 0x00078786 File Offset: 0x00076986
    public bool isCopy
    {
        get
        {
            return this._bits2[6];
        }
        set
        {
            this._bits2[6] = value;
        }
    }
 
    // Token: 0x170004E0 RID: 1248
    // (get) Token: 0x060011E7 RID: 4583 RVA: 0x00078795 File Offset: 0x00076995
    // (set) Token: 0x060011E8 RID: 4584 RVA: 0x000787A3 File Offset: 0x000769A3
    public bool isRestocking
    {
        get
        {
            return this._bits2[7];
        }
        set
        {
            this._bits2[7] = value;
        }
    }
 
    // Token: 0x170004E1 RID: 1249
    // (get) Token: 0x060011E9 RID: 4585 RVA: 0x000787B2 File Offset: 0x000769B2
    public bool isBackerContent
    {
        get
        {
            return this.c_idBacker != 0;
        }
    }
 
    // Token: 0x170004E2 RID: 1250
    // (get) Token: 0x060011EA RID: 4586 RVA: 0x000787BD File Offset: 0x000769BD
    public SourceBacker.Row sourceBacker
    {
        get
        {
            if (!this.isBackerContent)
            {
                return null;
            }
            return EClass.sources.backers.map.TryGetValue(this.c_idBacker, null);
        }
    }
 
    // Token: 0x060011EB RID: 4587 RVA: 0x000787E4 File Offset: 0x000769E4
    public void Mod()
    {
        this.isModified = true;
    }
 
    // Token: 0x170004E3 RID: 1251
    // (get) Token: 0x060011EC RID: 4588 RVA: 0x000787F0 File Offset: 0x000769F0
    // (set) Token: 0x060011ED RID: 4589 RVA: 0x00078813 File Offset: 0x00076A13
    public BedType c_bedType
    {
        get
        {
            return base.GetInt(9, null).ToEnum<BedType>();
        }
        set
        {
            base.SetInt(9, (int)value);
        }
    }
 
    // Token: 0x170004E4 RID: 1252
    // (get) Token: 0x060011EE RID: 4590 RVA: 0x00078820 File Offset: 0x00076A20
    // (set) Token: 0x060011EF RID: 4591 RVA: 0x0007883D File Offset: 0x00076A3D
    public int c_equippedSlot
    {
        get
        {
            return base.GetInt(6, null);
        }
        set
        {
            base.SetInt(6, value);
        }
    }
 
    // Token: 0x170004E5 RID: 1253
    // (get) Token: 0x060011F0 RID: 4592 RVA: 0x00078848 File Offset: 0x00076A48
    // (set) Token: 0x060011F1 RID: 4593 RVA: 0x00078866 File Offset: 0x00076A66
    public int c_lockLv
    {
        get
        {
            return base.GetInt(50, null);
        }
        set
        {
            base.SetInt(50, value);
        }
    }
 
    // Token: 0x170004E6 RID: 1254
    // (get) Token: 0x060011F2 RID: 4594 RVA: 0x00078874 File Offset: 0x00076A74
    // (set) Token: 0x060011F3 RID: 4595 RVA: 0x00078897 File Offset: 0x00076A97
    public Hostility c_originalHostility
    {
        get
        {
            return base.GetInt(12, null).ToEnum<Hostility>();
        }
        set
        {
            base.SetInt(12, (int)value);
        }
    }
 
    // Token: 0x170004E7 RID: 1255
    // (get) Token: 0x060011F4 RID: 4596 RVA: 0x000788A4 File Offset: 0x00076AA4
    // (set) Token: 0x060011F5 RID: 4597 RVA: 0x000788C7 File Offset: 0x00076AC7
    public MinionType c_minionType
    {
        get
        {
            return base.GetInt(61, null).ToEnum<MinionType>();
        }
        set
        {
            base.SetInt(61, (int)value);
        }
    }
 
    // Token: 0x170004E8 RID: 1256
    // (get) Token: 0x060011F6 RID: 4598 RVA: 0x000788D4 File Offset: 0x00076AD4
    // (set) Token: 0x060011F7 RID: 4599 RVA: 0x000788F2 File Offset: 0x00076AF2
    public int c_vomit
    {
        get
        {
            return base.GetInt(13, null);
        }
        set
        {
            base.SetInt(13, value);
        }
    }
 
    // Token: 0x170004E9 RID: 1257
    // (get) Token: 0x060011F8 RID: 4600 RVA: 0x00078900 File Offset: 0x00076B00
    // (set) Token: 0x060011F9 RID: 4601 RVA: 0x00078921 File Offset: 0x00076B21
    public bool c_isImportant
    {
        get
        {
            return base.GetInt(109, null) != 0;
        }
        set
        {
            base.SetInt(109, value ? 1 : 0);
        }
    }
 
    // Token: 0x170004EA RID: 1258
    // (get) Token: 0x060011FA RID: 4602 RVA: 0x00078934 File Offset: 0x00076B34
    // (set) Token: 0x060011FB RID: 4603 RVA: 0x00078955 File Offset: 0x00076B55
    public bool c_lockedHard
    {
        get
        {
            return base.GetInt(63, null) != 0;
        }
        set
        {
            base.SetInt(63, value ? 1 : 0);
        }
    }
 
    // Token: 0x170004EB RID: 1259
    // (get) Token: 0x060011FC RID: 4604 RVA: 0x00078968 File Offset: 0x00076B68
    // (set) Token: 0x060011FD RID: 4605 RVA: 0x00078989 File Offset: 0x00076B89
    public bool c_revealLock
    {
        get
        {
            return base.GetInt(64, null) != 0;
        }
        set
        {
            base.SetInt(64, value ? 1 : 0);
        }
    }
 
    // Token: 0x170004EC RID: 1260
    // (get) Token: 0x060011FE RID: 4606 RVA: 0x0007899C File Offset: 0x00076B9C
    // (set) Token: 0x060011FF RID: 4607 RVA: 0x000789BD File Offset: 0x00076BBD
    public bool c_isTrained
    {
        get
        {
            return base.GetInt(120, null) != 0;
        }
        set
        {
            base.SetInt(120, value ? 1 : 0);
        }
    }
 
    // Token: 0x170004ED RID: 1261
    // (get) Token: 0x06001200 RID: 4608 RVA: 0x000789D0 File Offset: 0x00076BD0
    // (set) Token: 0x06001201 RID: 4609 RVA: 0x000789F1 File Offset: 0x00076BF1
    public bool c_isPrayed
    {
        get
        {
            return base.GetInt(121, null) != 0;
        }
        set
        {
            base.SetInt(121, value ? 1 : 0);
        }
    }
 
    // Token: 0x170004EE RID: 1262
    // (get) Token: 0x06001202 RID: 4610 RVA: 0x00078A04 File Offset: 0x00076C04
    // (set) Token: 0x06001203 RID: 4611 RVA: 0x00078A21 File Offset: 0x00076C21
    public int c_lightColor
    {
        get
        {
            return base.GetInt(5, null);
        }
        set
        {
            this.Mod();
            base.SetInt(5, value);
        }
    }
 
    // Token: 0x170004EF RID: 1263
    // (get) Token: 0x06001204 RID: 4612 RVA: 0x00078A34 File Offset: 0x00076C34
    public Color LightColor
    {
        get
        {
            return new Color((float)(this.c_lightColor / 1024 * 8) / 256f, (float)(this.c_lightColor % 1024 / 32 * 8) / 256f, (float)(this.c_lightColor % 32 * 8) / 256f, 1f);
        }
    }
 
    // Token: 0x170004F0 RID: 1264
    // (get) Token: 0x06001205 RID: 4613 RVA: 0x00078A8C File Offset: 0x00076C8C
    // (set) Token: 0x06001206 RID: 4614 RVA: 0x00078AAA File Offset: 0x00076CAA
    public int c_uidZone
    {
        get
        {
            return base.GetInt(10, null);
        }
        set
        {
            this.Mod();
            base.SetInt(10, value);
        }
    }
 
    // Token: 0x170004F1 RID: 1265
    // (get) Token: 0x06001207 RID: 4615 RVA: 0x00078ABC File Offset: 0x00076CBC
    // (set) Token: 0x06001208 RID: 4616 RVA: 0x00078ADA File Offset: 0x00076CDA
    public int c_uidRefCard
    {
        get
        {
            return base.GetInt(11, null);
        }
        set
        {
            this.Mod();
            base.SetInt(11, value);
        }
    }
 
    // Token: 0x170004F2 RID: 1266
    // (get) Token: 0x06001209 RID: 4617 RVA: 0x00078AEC File Offset: 0x00076CEC
    // (set) Token: 0x0600120A RID: 4618 RVA: 0x00078B0A File Offset: 0x00076D0A
    public int c_priceFix
    {
        get
        {
            return base.GetInt(21, null);
        }
        set
        {
            base.SetInt(21, value);
        }
    }
 
    // Token: 0x170004F3 RID: 1267
    // (get) Token: 0x0600120B RID: 4619 RVA: 0x00078B18 File Offset: 0x00076D18
    // (set) Token: 0x0600120C RID: 4620 RVA: 0x00078B36 File Offset: 0x00076D36
    public int c_priceAdd
    {
        get
        {
            return base.GetInt(29, null);
        }
        set
        {
            base.SetInt(29, value);
        }
    }
 
    // Token: 0x170004F4 RID: 1268
    // (get) Token: 0x0600120D RID: 4621 RVA: 0x00078B44 File Offset: 0x00076D44
    // (set) Token: 0x0600120E RID: 4622 RVA: 0x00078B61 File Offset: 0x00076D61
    public int c_dyeMat
    {
        get
        {
            return base.GetInt(3, null);
        }
        set
        {
            base.SetInt(3, value);
        }
    }
 
    // Token: 0x170004F5 RID: 1269
    // (get) Token: 0x0600120F RID: 4623 RVA: 0x00078B6C File Offset: 0x00076D6C
    // (set) Token: 0x06001210 RID: 4624 RVA: 0x00078B8E File Offset: 0x00076D8E
    public VisitorState visitorState
    {
        get
        {
            return base.GetInt(4, null).ToEnum<VisitorState>();
        }
        set
        {
            base.SetInt(4, (int)value);
        }
    }
 
    // Token: 0x170004F6 RID: 1270
    // (get) Token: 0x06001211 RID: 4625 RVA: 0x00078B98 File Offset: 0x00076D98
    // (set) Token: 0x06001212 RID: 4626 RVA: 0x00078BBB File Offset: 0x00076DBB
    public RescueState c_rescueState
    {
        get
        {
            return base.GetInt(53, null).ToEnum<RescueState>();
        }
        set
        {
            base.SetInt(53, (int)value);
        }
    }
 
    // Token: 0x170004F7 RID: 1271
    // (get) Token: 0x06001213 RID: 4627 RVA: 0x00078BC8 File Offset: 0x00076DC8
    // (set) Token: 0x06001214 RID: 4628 RVA: 0x00078BEB File Offset: 0x00076DEB
    public BossType c_bossType
    {
        get
        {
            return base.GetInt(65, null).ToEnum<BossType>();
        }
        set
        {
            base.SetInt(65, (int)value);
        }
    }
 
    // Token: 0x170004F8 RID: 1272
    // (get) Token: 0x06001215 RID: 4629 RVA: 0x00078BF8 File Offset: 0x00076DF8
    // (set) Token: 0x06001216 RID: 4630 RVA: 0x00078C16 File Offset: 0x00076E16
    public int c_dateStockExpire
    {
        get
        {
            return base.GetInt(22, null);
        }
        set
        {
            base.SetInt(22, value);
        }
    }
 
    // Token: 0x170004F9 RID: 1273
    // (get) Token: 0x06001217 RID: 4631 RVA: 0x00078C24 File Offset: 0x00076E24
    // (set) Token: 0x06001218 RID: 4632 RVA: 0x00078C41 File Offset: 0x00076E41
    public int c_IDTState
    {
        get
        {
            return base.GetInt(2, null);
        }
        set
        {
            base.SetInt(2, value);
        }
    }
 
    // Token: 0x170004FA RID: 1274
    // (get) Token: 0x06001219 RID: 4633 RVA: 0x00078C4C File Offset: 0x00076E4C
    // (set) Token: 0x0600121A RID: 4634 RVA: 0x00078C69 File Offset: 0x00076E69
    public int c_charges
    {
        get
        {
            return base.GetInt(7, null);
        }
        set
        {
            base.SetInt(7, value);
        }
    }
 
    // Token: 0x170004FB RID: 1275
    // (get) Token: 0x0600121B RID: 4635 RVA: 0x00078C74 File Offset: 0x00076E74
    // (set) Token: 0x0600121C RID: 4636 RVA: 0x00078C92 File Offset: 0x00076E92
    public int c_bill
    {
        get
        {
            return base.GetInt(23, null);
        }
        set
        {
            base.SetInt(23, value);
        }
    }
 
    // Token: 0x170004FC RID: 1276
    // (get) Token: 0x0600121D RID: 4637 RVA: 0x00078CA0 File Offset: 0x00076EA0
    // (set) Token: 0x0600121E RID: 4638 RVA: 0x00078CBE File Offset: 0x00076EBE
    public int c_invest
    {
        get
        {
            return base.GetInt(28, null);
        }
        set
        {
            base.SetInt(28, value);
        }
    }
 
    // Token: 0x170004FD RID: 1277
    // (get) Token: 0x0600121F RID: 4639 RVA: 0x00078CCC File Offset: 0x00076ECC
    // (set) Token: 0x06001220 RID: 4640 RVA: 0x00078CEA File Offset: 0x00076EEA
    public int c_seed
    {
        get
        {
            return base.GetInt(33, null);
        }
        set
        {
            base.SetInt(33, value);
        }
    }
 
    // Token: 0x170004FE RID: 1278
    // (get) Token: 0x06001221 RID: 4641 RVA: 0x00078CF8 File Offset: 0x00076EF8
    // (set) Token: 0x06001222 RID: 4642 RVA: 0x00078D16 File Offset: 0x00076F16
    public int c_allowance
    {
        get
        {
            return base.GetInt(114, null);
        }
        set
        {
            base.SetInt(114, value);
        }
    }
 
    // Token: 0x170004FF RID: 1279
    // (get) Token: 0x06001223 RID: 4643 RVA: 0x00078D24 File Offset: 0x00076F24
    // (set) Token: 0x06001224 RID: 4644 RVA: 0x00078D42 File Offset: 0x00076F42
    public int c_fur
    {
        get
        {
            return base.GetInt(62, null);
        }
        set
        {
            base.SetInt(62, value);
        }
    }
 
    // Token: 0x17000500 RID: 1280
    // (get) Token: 0x06001225 RID: 4645 RVA: 0x00078D50 File Offset: 0x00076F50
    // (set) Token: 0x06001226 RID: 4646 RVA: 0x00078D6D File Offset: 0x00076F6D
    public int c_containerSize
    {
        get
        {
            return base.GetInt(8, null);
        }
        set
        {
            base.SetInt(8, value);
        }
    }
 
    // Token: 0x17000501 RID: 1281
    // (get) Token: 0x06001227 RID: 4647 RVA: 0x00078D78 File Offset: 0x00076F78
    // (set) Token: 0x06001228 RID: 4648 RVA: 0x00078D95 File Offset: 0x00076F95
    public int c_weight
    {
        get
        {
            return base.GetInt(1, null);
        }
        set
        {
            base.SetInt(1, value);
        }
    }
 
    // Token: 0x17000502 RID: 1282
    // (get) Token: 0x06001229 RID: 4649 RVA: 0x00078DA0 File Offset: 0x00076FA0
    // (set) Token: 0x0600122A RID: 4650 RVA: 0x00078DBE File Offset: 0x00076FBE
    public int c_diceDim
    {
        get
        {
            return base.GetInt(14, null);
        }
        set
        {
            base.SetInt(14, value);
        }
    }
 
    // Token: 0x17000503 RID: 1283
    // (get) Token: 0x0600122B RID: 4651 RVA: 0x00078DCC File Offset: 0x00076FCC
    // (set) Token: 0x0600122C RID: 4652 RVA: 0x00078DEA File Offset: 0x00076FEA
    public int c_indexContainerIcon
    {
        get
        {
            return base.GetInt(15, null);
        }
        set
        {
            base.SetInt(15, value);
        }
    }
 
    // Token: 0x17000504 RID: 1284
    // (get) Token: 0x0600122D RID: 4653 RVA: 0x00078DF8 File Offset: 0x00076FF8
    // (set) Token: 0x0600122E RID: 4654 RVA: 0x00078E16 File Offset: 0x00077016
    public int c_idMainElement
    {
        get
        {
            return base.GetInt(16, null);
        }
        set
        {
            base.SetInt(16, value);
        }
    }
 
    // Token: 0x17000505 RID: 1285
    // (get) Token: 0x0600122F RID: 4655 RVA: 0x00078E24 File Offset: 0x00077024
    // (set) Token: 0x06001230 RID: 4656 RVA: 0x00078E42 File Offset: 0x00077042
    public int c_summonDuration
    {
        get
        {
            return base.GetInt(17, null);
        }
        set
        {
            base.SetInt(17, value);
        }
    }
 
    // Token: 0x17000506 RID: 1286
    // (get) Token: 0x06001231 RID: 4657 RVA: 0x00078E50 File Offset: 0x00077050
    // (set) Token: 0x06001232 RID: 4658 RVA: 0x00078E6E File Offset: 0x0007706E
    public int c_idBacker
    {
        get
        {
            return base.GetInt(52, null);
        }
        set
        {
            base.SetInt(52, value);
        }
    }
 
    // Token: 0x17000507 RID: 1287
    // (get) Token: 0x06001233 RID: 4659 RVA: 0x00078E7C File Offset: 0x0007707C
    // (set) Token: 0x06001234 RID: 4660 RVA: 0x00078E9A File Offset: 0x0007709A
    public int c_uidMaster
    {
        get
        {
            return base.GetInt(54, null);
        }
        set
        {
            base.SetInt(54, value);
        }
    }
 
    // Token: 0x17000508 RID: 1288
    // (get) Token: 0x06001235 RID: 4661 RVA: 0x00078EA8 File Offset: 0x000770A8
    // (set) Token: 0x06001236 RID: 4662 RVA: 0x00078EC6 File Offset: 0x000770C6
    public int c_ammo
    {
        get
        {
            return base.GetInt(27, null);
        }
        set
        {
            base.SetInt(27, value);
        }
    }
 
    // Token: 0x17000509 RID: 1289
    // (get) Token: 0x06001237 RID: 4663 RVA: 0x00078ED4 File Offset: 0x000770D4
    // (set) Token: 0x06001238 RID: 4664 RVA: 0x00078EF2 File Offset: 0x000770F2
    public int c_daysWithGod
    {
        get
        {
            return base.GetInt(57, null);
        }
        set
        {
            base.SetInt(57, value);
        }
    }
 
    // Token: 0x1700050A RID: 1290
    // (get) Token: 0x06001239 RID: 4665 RVA: 0x00078EFD File Offset: 0x000770FD
    // (set) Token: 0x0600123A RID: 4666 RVA: 0x00078F08 File Offset: 0x00077108
    public string c_idPortrait
    {
        get
        {
            return base.GetStr(9, null);
        }
        set
        {
            base.SetStr(9, value);
        }
    }
 
    // Token: 0x1700050B RID: 1291
    // (get) Token: 0x0600123B RID: 4667 RVA: 0x00078F13 File Offset: 0x00077113
    // (set) Token: 0x0600123C RID: 4668 RVA: 0x00078F1D File Offset: 0x0007711D
    public string c_idRace
    {
        get
        {
            return base.GetStr(3, null);
        }
        set
        {
            base.SetStr(3, value);
        }
    }
 
    // Token: 0x1700050C RID: 1292
    // (get) Token: 0x0600123D RID: 4669 RVA: 0x00078F27 File Offset: 0x00077127
    // (set) Token: 0x0600123E RID: 4670 RVA: 0x00078F31 File Offset: 0x00077131
    public string c_idJob
    {
        get
        {
            return base.GetStr(4, null);
        }
        set
        {
            base.SetStr(4, value);
        }
    }
 
    // Token: 0x1700050D RID: 1293
    // (get) Token: 0x0600123F RID: 4671 RVA: 0x00078F3B File Offset: 0x0007713B
    // (set) Token: 0x06001240 RID: 4672 RVA: 0x00078F46 File Offset: 0x00077146
    public string c_idTone
    {
        get
        {
            return base.GetStr(22, null);
        }
        set
        {
            base.SetStr(22, value);
        }
    }
 
    // Token: 0x1700050E RID: 1294
    // (get) Token: 0x06001241 RID: 4673 RVA: 0x00078F51 File Offset: 0x00077151
    // (set) Token: 0x06001242 RID: 4674 RVA: 0x00078F5B File Offset: 0x0007715B
    public string c_color
    {
        get
        {
            return base.GetStr(8, null);
        }
        set
        {
            base.SetStr(8, value);
        }
    }
 
    // Token: 0x1700050F RID: 1295
    // (get) Token: 0x06001243 RID: 4675 RVA: 0x00078F65 File Offset: 0x00077165
    // (set) Token: 0x06001244 RID: 4676 RVA: 0x00078F70 File Offset: 0x00077170
    public string c_idTalk
    {
        get
        {
            return base.GetStr(21, null);
        }
        set
        {
            base.SetStr(21, value);
        }
    }
 
    // Token: 0x17000510 RID: 1296
    // (get) Token: 0x06001245 RID: 4677 RVA: 0x00078F7B File Offset: 0x0007717B
    // (set) Token: 0x06001246 RID: 4678 RVA: 0x00078F86 File Offset: 0x00077186
    public string c_idDeity
    {
        get
        {
            return base.GetStr(26, null);
        }
        set
        {
            base.SetStr(26, value);
        }
    }
 
    // Token: 0x17000511 RID: 1297
    // (get) Token: 0x06001247 RID: 4679 RVA: 0x00078F91 File Offset: 0x00077191
    // (set) Token: 0x06001248 RID: 4680 RVA: 0x00078F9B File Offset: 0x0007719B
    public string c_altName
    {
        get
        {
            return base.GetStr(1, null);
        }
        set
        {
            base.SetStr(1, value);
        }
    }
 
    // Token: 0x17000512 RID: 1298
    // (get) Token: 0x06001249 RID: 4681 RVA: 0x00078FA5 File Offset: 0x000771A5
    // (set) Token: 0x0600124A RID: 4682 RVA: 0x00078FAF File Offset: 0x000771AF
    public string c_altName2
    {
        get
        {
            return base.GetStr(2, null);
        }
        set
        {
            base.SetStr(2, value);
        }
    }
 
    // Token: 0x17000513 RID: 1299
    // (get) Token: 0x0600124B RID: 4683 RVA: 0x00078FB9 File Offset: 0x000771B9
    // (set) Token: 0x0600124C RID: 4684 RVA: 0x00078FC4 File Offset: 0x000771C4
    public string c_refText
    {
        get
        {
            return base.GetStr(10, null);
        }
        set
        {
            base.SetStr(10, value);
        }
    }
 
    // Token: 0x17000514 RID: 1300
    // (get) Token: 0x0600124D RID: 4685 RVA: 0x00078FCF File Offset: 0x000771CF
    // (set) Token: 0x0600124E RID: 4686 RVA: 0x00078FD9 File Offset: 0x000771D9
    public string c_idRefName
    {
        get
        {
            return base.GetStr(7, null);
        }
        set
        {
            base.SetStr(7, value);
        }
    }
 
    // Token: 0x17000515 RID: 1301
    // (get) Token: 0x0600124F RID: 4687 RVA: 0x00078FE3 File Offset: 0x000771E3
    // (set) Token: 0x06001250 RID: 4688 RVA: 0x00078FEE File Offset: 0x000771EE
    public string c_idRidePCC
    {
        get
        {
            return base.GetStr(55, null);
        }
        set
        {
            base.SetStr(55, value);
        }
    }
 
    // Token: 0x17000516 RID: 1302
    // (get) Token: 0x06001251 RID: 4689 RVA: 0x00078FF9 File Offset: 0x000771F9
    // (set) Token: 0x06001252 RID: 4690 RVA: 0x00079004 File Offset: 0x00077204
    public string c_idAbility
    {
        get
        {
            return base.GetStr(50, null);
        }
        set
        {
            base.SetStr(50, value);
        }
    }
 
    // Token: 0x17000517 RID: 1303
    // (get) Token: 0x06001253 RID: 4691 RVA: 0x0007900F File Offset: 0x0007720F
    // (set) Token: 0x06001254 RID: 4692 RVA: 0x0007901A File Offset: 0x0007721A
    public string c_context
    {
        get
        {
            return base.GetStr(20, null);
        }
        set
        {
            base.SetStr(20, value);
        }
    }
 
    // Token: 0x17000518 RID: 1304
    // (get) Token: 0x06001255 RID: 4693 RVA: 0x00079025 File Offset: 0x00077225
    // (set) Token: 0x06001256 RID: 4694 RVA: 0x00079030 File Offset: 0x00077230
    public string c_idEditor
    {
        get
        {
            return base.GetStr(27, null);
        }
        set
        {
            base.SetStr(27, value);
        }
    }
 
    // Token: 0x17000519 RID: 1305
    // (get) Token: 0x06001257 RID: 4695 RVA: 0x0007903B File Offset: 0x0007723B
    // (set) Token: 0x06001258 RID: 4696 RVA: 0x00079046 File Offset: 0x00077246
    public string c_editorTags
    {
        get
        {
            return base.GetStr(28, null);
        }
        set
        {
            base.SetStr(28, value);
        }
    }
 
    // Token: 0x1700051A RID: 1306
    // (get) Token: 0x06001259 RID: 4697 RVA: 0x00079051 File Offset: 0x00077251
    // (set) Token: 0x0600125A RID: 4698 RVA: 0x0007905C File Offset: 0x0007725C
    public string c_editorTraitVal
    {
        get
        {
            return base.GetStr(25, null);
        }
        set
        {
            base.SetStr(25, value);
        }
    }
 
    // Token: 0x1700051B RID: 1307
    // (get) Token: 0x0600125B RID: 4699 RVA: 0x00079067 File Offset: 0x00077267
    // (set) Token: 0x0600125C RID: 4700 RVA: 0x00079072 File Offset: 0x00077272
    public string c_idTrait
    {
        get
        {
            return base.GetStr(29, null);
        }
        set
        {
            base.SetStr(29, value);
        }
    }
 
    // Token: 0x1700051C RID: 1308
    // (get) Token: 0x0600125D RID: 4701 RVA: 0x0007907D File Offset: 0x0007727D
    // (set) Token: 0x0600125E RID: 4702 RVA: 0x00079087 File Offset: 0x00077287
    public string c_idRefCard
    {
        get
        {
            return base.GetStr(5, null);
        }
        set
        {
            base.SetStr(5, value);
        }
    }
 
    // Token: 0x1700051D RID: 1309
    // (get) Token: 0x0600125F RID: 4703 RVA: 0x00079091 File Offset: 0x00077291
    // (set) Token: 0x06001260 RID: 4704 RVA: 0x0007909B File Offset: 0x0007729B
    public string c_idRefCard2
    {
        get
        {
            return base.GetStr(6, null);
        }
        set
        {
            base.SetStr(6, value);
        }
    }
 
    // Token: 0x1700051E RID: 1310
    // (get) Token: 0x06001261 RID: 4705 RVA: 0x000790A5 File Offset: 0x000772A5
    // (set) Token: 0x06001262 RID: 4706 RVA: 0x000790B0 File Offset: 0x000772B0
    public string c_note
    {
        get
        {
            return base.GetStr(51, null);
        }
        set
        {
            base.SetStr(51, value);
        }
    }
 
    // Token: 0x1700051F RID: 1311
    // (get) Token: 0x06001263 RID: 4707 RVA: 0x000790BB File Offset: 0x000772BB
    // (set) Token: 0x06001264 RID: 4708 RVA: 0x000790C4 File Offset: 0x000772C4
    public UniqueData c_uniqueData
    {
        get
        {
            return base.GetObj<UniqueData>(6);
        }
        set
        {
            base.SetObj(6, value);
        }
    }
 
    // Token: 0x17000520 RID: 1312
    // (get) Token: 0x06001265 RID: 4709 RVA: 0x000790CE File Offset: 0x000772CE
    // (set) Token: 0x06001266 RID: 4710 RVA: 0x000790D8 File Offset: 0x000772D8
    public Thing ammoData
    {
        get
        {
            return base.GetObj<Thing>(9);
        }
        set
        {
            base.SetObj(9, value);
        }
    }
 
    // Token: 0x17000521 RID: 1313
    // (get) Token: 0x06001267 RID: 4711 RVA: 0x000790E3 File Offset: 0x000772E3
    // (set) Token: 0x06001268 RID: 4712 RVA: 0x000790ED File Offset: 0x000772ED
    public Thing c_copyContainer
    {
        get
        {
            return base.GetObj<Thing>(10);
        }
        set
        {
            base.SetObj(10, value);
        }
    }
 
    // Token: 0x17000522 RID: 1314
    // (get) Token: 0x06001269 RID: 4713 RVA: 0x000790F8 File Offset: 0x000772F8
    // (set) Token: 0x0600126A RID: 4714 RVA: 0x00079101 File Offset: 0x00077301
    public Window.SaveData c_windowSaveData
    {
        get
        {
            return base.GetObj<Window.SaveData>(2);
        }
        set
        {
            base.SetObj(2, value);
        }
    }
 
    // Token: 0x17000523 RID: 1315
    // (get) Token: 0x0600126B RID: 4715 RVA: 0x0007910B File Offset: 0x0007730B
    // (set) Token: 0x0600126C RID: 4716 RVA: 0x00079115 File Offset: 0x00077315
    public CharaUpgrade c_upgrades
    {
        get
        {
            return base.GetObj<CharaUpgrade>(11);
        }
        set
        {
            base.SetObj(11, value);
        }
    }
 
    // Token: 0x17000524 RID: 1316
    // (get) Token: 0x0600126D RID: 4717 RVA: 0x00079120 File Offset: 0x00077320
    // (set) Token: 0x0600126E RID: 4718 RVA: 0x0007912A File Offset: 0x0007732A
    public CharaGenes c_genes
    {
        get
        {
            return base.GetObj<CharaGenes>(15);
        }
        set
        {
            base.SetObj(15, value);
        }
    }
 
    // Token: 0x17000525 RID: 1317
    // (get) Token: 0x0600126F RID: 4719 RVA: 0x00079138 File Offset: 0x00077338
    // (set) Token: 0x06001270 RID: 4720 RVA: 0x0007915F File Offset: 0x0007735F
    public ContainerUpgrade c_containerUpgrade
    {
        get
        {
            ContainerUpgrade result;
            if ((result = base.GetObj<ContainerUpgrade>(12)) == null)
            {
                result = (this.c_containerUpgrade = new ContainerUpgrade());
            }
            return result;
        }
        set
        {
            base.SetObj(12, value);
        }
    }
 
    // Token: 0x17000526 RID: 1318
    // (get) Token: 0x06001271 RID: 4721 RVA: 0x0007916A File Offset: 0x0007736A
    // (set) Token: 0x06001272 RID: 4722 RVA: 0x00079174 File Offset: 0x00077374
    public DNA c_DNA
    {
        get
        {
            return base.GetObj<DNA>(14);
        }
        set
        {
            base.SetObj(14, value);
        }
    }
 
    // Token: 0x17000527 RID: 1319
    // (get) Token: 0x06001273 RID: 4723 RVA: 0x0007917F File Offset: 0x0007737F
    // (set) Token: 0x06001274 RID: 4724 RVA: 0x00079189 File Offset: 0x00077389
    public CharaList c_charaList
    {
        get
        {
            return base.GetObj<CharaList>(13);
        }
        set
        {
            base.SetObj(13, value);
        }
    }
 
    // Token: 0x06001275 RID: 4725 RVA: 0x00079194 File Offset: 0x00077394
    public Window.SaveData GetWindowSaveData()
    {
        if (this.IsPC)
        {
            return Window.dictData.TryGetValue("LayerInventoryFloatMain0", null);
        }
        if (this.trait is TraitChestMerchant)
        {
            return Window.dictData.TryGetValue("ChestMerchant", null);
        }
        return this.c_windowSaveData;
    }
 
    // Token: 0x06001276 RID: 4726 RVA: 0x000791D4 File Offset: 0x000773D4
    public bool IsExcludeFromCraft()
    {
        if (this.IsUnique || this.c_isImportant)
        {
            return true;
        }
        Card card = this.parent as Card;
        if (card != null)
        {
            if (card.trait is TraitChestMerchant)
            {
                return true;
            }
            if (card.isSale)
            {
                return true;
            }
            Window.SaveData windowSaveData = card.GetWindowSaveData();
            if (windowSaveData != null)
            {
                return windowSaveData.excludeCraft;
            }
        }
        return false;
    }
 
    // Token: 0x17000528 RID: 1320
    // (get) Token: 0x06001277 RID: 4727 RVA: 0x0007922D File Offset: 0x0007742D
    // (set) Token: 0x06001278 RID: 4728 RVA: 0x00079236 File Offset: 0x00077436
    public byte[] c_textureData
    {
        get
        {
            return base.GetObj<byte[]>(4);
        }
        set
        {
            base.SetObj(4, value);
        }
    }
 
    // Token: 0x17000529 RID: 1321
    // (get) Token: 0x06001279 RID: 4729 RVA: 0x00079240 File Offset: 0x00077440
    public SourceMaterial.Row DyeMat
    {
        get
        {
            return EClass.sources.materials.rows[this.c_dyeMat];
        }
    }
 
    // Token: 0x1700052A RID: 1322
    // (get) Token: 0x0600127A RID: 4730 RVA: 0x0007925C File Offset: 0x0007745C
    // (set) Token: 0x0600127B RID: 4731 RVA: 0x00079269 File Offset: 0x00077469
    public int invX
    {
        get
        {
            return this.pos.x;
        }
        set
        {
            this.pos.x = value;
        }
    }
 
    // Token: 0x1700052B RID: 1323
    // (get) Token: 0x0600127C RID: 4732 RVA: 0x00079277 File Offset: 0x00077477
    // (set) Token: 0x0600127D RID: 4733 RVA: 0x00079284 File Offset: 0x00077484
    public int invY
    {
        get
        {
            return this.pos.z;
        }
        set
        {
            this.pos.z = value;
        }
    }
 
    // Token: 0x1700052C RID: 1324
    // (get) Token: 0x0600127E RID: 4734 RVA: 0x00079292 File Offset: 0x00077492
    public CardRow refCard
    {
        get
        {
            if (!this.c_idRefCard.IsEmpty())
            {
                return EClass.sources.cards.map[this.c_idRefCard];
            }
            return null;
        }
    }
 
    // Token: 0x1700052D RID: 1325
    // (get) Token: 0x0600127F RID: 4735 RVA: 0x000792BD File Offset: 0x000774BD
    public CardRow refCard2
    {
        get
        {
            if (!this.c_idRefCard2.IsEmpty())
            {
                return EClass.sources.cards.map[this.c_idRefCard2];
            }
            return null;
        }
    }
 
    // Token: 0x1700052E RID: 1326
    // (get) Token: 0x06001280 RID: 4736 RVA: 0x000792E8 File Offset: 0x000774E8
    public int ExpToNext
    {
        get
        {
            return (50 + this.LV * 30) * (100 - this.Evalue(403)) / 100;
        }
    }
 
    // Token: 0x1700052F RID: 1327
    // (get) Token: 0x06001281 RID: 4737 RVA: 0x00079308 File Offset: 0x00077508
    public int DefaultLV
    {
        get
        {
            return this.sourceCard.LV;
        }
    }
 
    // Token: 0x17000530 RID: 1328
    // (get) Token: 0x06001282 RID: 4738 RVA: 0x00079318 File Offset: 0x00077518
    public int ChildrenWeight
    {
        get
        {
            if (this.dirtyWeight)
            {
                this._childrenWeight = 0;
                if (!(this.trait is TraitMagicChest))
                {
                    foreach (Thing thing in this.things)
                    {
                        this._childrenWeight += thing.ChildrenAndSelfWeight;
                    }
                    this.dirtyWeight = false;
                    Card card = this.parent as Card;
                    if (card != null)
                    {
                        card.SetDirtyWeight();
                    }
                    if (this.isChara && this.IsPCFaction)
                    {
                        this.Chara.CalcBurden();
                    }
                    if (this._childrenWeight < 0 || this._childrenWeight >= 10000000)
                    {
                        this._childrenWeight = 9999999;
                    }
                }
            }
            return this._childrenWeight * Mathf.Max(100 - this.Evalue(404), 0) / 100;
        }
    }
 
    // Token: 0x06001283 RID: 4739 RVA: 0x00079410 File Offset: 0x00077610
    public void SetDirtyWeight()
    {
        if (EClass.core.IsGameStarted && this.IsPC)
        {
            EClass.player.wasDirtyWeight = true;
        }
        this.dirtyWeight = true;
        Card card = this.parent as Card;
        if (card == null)
        {
            return;
        }
        card.SetDirtyWeight();
    }
 
    // Token: 0x06001284 RID: 4740 RVA: 0x0007944D File Offset: 0x0007764D
    public void ChangeWeight(int a)
    {
        this.c_weight = a;
        this.isWeightChanged = true;
        this.SetDirtyWeight();
    }
 
    // Token: 0x17000531 RID: 1329
    // (get) Token: 0x06001285 RID: 4741 RVA: 0x00079463 File Offset: 0x00077663
    public int ChildrenAndSelfWeight
    {
        get
        {
            return this.ChildrenWeight + this.SelfWeight * this.Num;
        }
    }
 
    // Token: 0x17000532 RID: 1330
    // (get) Token: 0x06001286 RID: 4742 RVA: 0x00079479 File Offset: 0x00077679
    public int ChildrenAndSelfWeightSingle
    {
        get
        {
            return this.ChildrenWeight + this.SelfWeight;
        }
    }
 
    // Token: 0x17000533 RID: 1331
    // (get) Token: 0x06001287 RID: 4743 RVA: 0x00079488 File Offset: 0x00077688
    public virtual int SelfWeight
    {
        get
        {
            return 1000;
        }
    }
 
    // Token: 0x17000534 RID: 1332
    // (get) Token: 0x06001288 RID: 4744 RVA: 0x0007948F File Offset: 0x0007768F
    public virtual int WeightLimit
    {
        get
        {
            return 500000;
        }
    }
 
    // Token: 0x17000535 RID: 1333
    // (get) Token: 0x06001289 RID: 4745 RVA: 0x00079498 File Offset: 0x00077698
    public SourceCategory.Row category
    {
        get
        {
            SourceCategory.Row result;
            if ((result = this._category) == null)
            {
                result = (this._category = EClass.sources.categories.map[this.sourceCard.category]);
            }
            return result;
        }
    }
 
    // Token: 0x17000536 RID: 1334
    // (get) Token: 0x0600128A RID: 4746 RVA: 0x000794D8 File Offset: 0x000776D8
    public SourceMaterial.Row material
    {
        get
        {
            SourceMaterial.Row result;
            if ((result = this._material) == null)
            {
                result = (this._material = EClass.sources.materials.map[this.idMaterial]);
            }
            return result;
        }
    }
 
    // Token: 0x17000537 RID: 1335
    // (get) Token: 0x0600128B RID: 4747 RVA: 0x00079512 File Offset: 0x00077712
    public virtual string AliasMaterialOnCreate
    {
        get
        {
            return this.DefaultMaterial.alias;
        }
    }
 
    // Token: 0x0600128C RID: 4748 RVA: 0x0007951F File Offset: 0x0007771F
    public int Evalue(int ele)
    {
        return this.elements.Value(ele);
    }
 
    // Token: 0x0600128D RID: 4749 RVA: 0x0007952D File Offset: 0x0007772D
    public int Evalue(string alias)
    {
        return this.elements.Value(EClass.sources.elements.alias[alias].id);
    }
 
    // Token: 0x0600128E RID: 4750 RVA: 0x00079554 File Offset: 0x00077754
    public bool HasTag(CTAG tag)
    {
        return this.sourceCard.tag.Contains(tag.ToString());
    }
 
    // Token: 0x0600128F RID: 4751 RVA: 0x00079573 File Offset: 0x00077773
    public bool HasEditorTag(EditorTag tag)
    {
        string c_editorTags = this.c_editorTags;
        return c_editorTags != null && c_editorTags.Contains(tag.ToString());
    }
 
    // Token: 0x06001290 RID: 4752 RVA: 0x00079594 File Offset: 0x00077794
    public void AddEditorTag(EditorTag tag)
    {
        this.c_editorTags = (this.c_editorTags.IsEmpty() ? tag.ToString() : (this.c_editorTags + "," + tag.ToString()));
    }
 
    // Token: 0x06001291 RID: 4753 RVA: 0x000795E0 File Offset: 0x000777E0
    public void RemoveEditorTag(EditorTag tag)
    {
        this.c_editorTags = (this.c_editorTags.IsEmpty() ? null : this.c_editorTags.Replace(tag.ToString(), "").Replace(",,", ","));
    }
 
    // Token: 0x17000538 RID: 1336
    // (get) Token: 0x06001292 RID: 4754 RVA: 0x0007962F File Offset: 0x0007782F
    public Cell Cell
    {
        get
        {
            return this.pos.cell;
        }
    }
 
    // Token: 0x17000539 RID: 1337
    // (get) Token: 0x06001293 RID: 4755 RVA: 0x0007963C File Offset: 0x0007783C
    public virtual Thing Thing
    {
        get
        {
            if (!this.isThing)
            {
                return null;
            }
            return (Thing)this;
        }
    }
 
    // Token: 0x1700053A RID: 1338
    // (get) Token: 0x06001294 RID: 4756 RVA: 0x0007964E File Offset: 0x0007784E
    public virtual Chara Chara
    {
        get
        {
            if (!this.isChara)
            {
                return null;
            }
            return (Chara)this;
        }
    }
 
    // Token: 0x1700053B RID: 1339
    // (get) Token: 0x06001295 RID: 4757 RVA: 0x00079660 File Offset: 0x00077860
    public virtual bool isThing
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x1700053C RID: 1340
    // (get) Token: 0x06001296 RID: 4758 RVA: 0x00079663 File Offset: 0x00077863
    public virtual bool isChara
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x1700053D RID: 1341
    // (get) Token: 0x06001297 RID: 4759 RVA: 0x00079666 File Offset: 0x00077866
    public bool ExistsOnMap
    {
        get
        {
            return this.parent == EClass._zone;
        }
    }
 
    // Token: 0x1700053E RID: 1342
    // (get) Token: 0x06001298 RID: 4760 RVA: 0x00079675 File Offset: 0x00077875
    public virtual bool isSynced
    {
        get
        {
            return this.renderer.isSynced;
        }
    }
 
    // Token: 0x1700053F RID: 1343
    // (get) Token: 0x06001299 RID: 4761 RVA: 0x00079682 File Offset: 0x00077882
    public bool IsContainer
    {
        get
        {
            return this.trait.IsContainer;
        }
    }
 
    // Token: 0x17000540 RID: 1344
    // (get) Token: 0x0600129A RID: 4762 RVA: 0x0007968F File Offset: 0x0007788F
    public bool IsUnique
    {
        get
        {
            return this.rarity == Rarity.Artifact;
        }
    }
 
    // Token: 0x17000541 RID: 1345
    // (get) Token: 0x0600129B RID: 4763 RVA: 0x0007969A File Offset: 0x0007789A
    public bool IsPowerful
    {
        get
        {
            return (this.rarity >= Rarity.Legendary || this.trait is TraitAdventurer) && !this.IsPCFaction;
        }
    }
 
    // Token: 0x17000542 RID: 1346
    // (get) Token: 0x0600129C RID: 4764 RVA: 0x000796BD File Offset: 0x000778BD
    public bool IsImportant
    {
        get
        {
            return this.sourceCard.HasTag(CTAG.important);
        }
    }
 
    // Token: 0x17000543 RID: 1347
    // (get) Token: 0x0600129D RID: 4765 RVA: 0x000796CB File Offset: 0x000778CB
    public virtual SourcePref Pref
    {
        get
        {
            return this.sourceCard.pref;
        }
    }
 
    // Token: 0x17000544 RID: 1348
    // (get) Token: 0x0600129E RID: 4766 RVA: 0x000796D8 File Offset: 0x000778D8
    public virtual bool IsDeadOrSleeping
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000545 RID: 1349
    // (get) Token: 0x0600129F RID: 4767 RVA: 0x000796DB File Offset: 0x000778DB
    public virtual bool IsDisabled
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000546 RID: 1350
    // (get) Token: 0x060012A0 RID: 4768 RVA: 0x000796DE File Offset: 0x000778DE
    public virtual bool IsMoving
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000547 RID: 1351
    // (get) Token: 0x060012A1 RID: 4769 RVA: 0x000796E1 File Offset: 0x000778E1
    public virtual bool flipX
    {
        get
        {
            return this.Tiles.Length == 1 && this.dir % 2 == 1;
        }
    }
 
    // Token: 0x17000548 RID: 1352
    // (get) Token: 0x060012A2 RID: 4770 RVA: 0x000796FB File Offset: 0x000778FB
    public virtual bool IsAliveInCurrentZone
    {
        get
        {
            return this.ExistsOnMap;
        }
    }
 
    // Token: 0x17000549 RID: 1353
    // (get) Token: 0x060012A3 RID: 4771 RVA: 0x00079703 File Offset: 0x00077903
    public virtual string actorPrefab
    {
        get
        {
            return "ThingActor";
        }
    }
 
    // Token: 0x1700054A RID: 1354
    // (get) Token: 0x060012A4 RID: 4772 RVA: 0x0007970A File Offset: 0x0007790A
    public virtual CardRow sourceCard
    {
        get
        {
            return null;
        }
    }
 
    // Token: 0x1700054B RID: 1355
    // (get) Token: 0x060012A5 RID: 4773 RVA: 0x0007970D File Offset: 0x0007790D
    public virtual CardRow sourceRenderCard
    {
        get
        {
            return this.sourceCard;
        }
    }
 
    // Token: 0x1700054C RID: 1356
    // (get) Token: 0x060012A6 RID: 4774 RVA: 0x00079715 File Offset: 0x00077915
    public TileType TileType
    {
        get
        {
            return this.sourceCard.tileType;
        }
    }
 
    // Token: 0x1700054D RID: 1357
    // (get) Token: 0x060012A7 RID: 4775 RVA: 0x00079722 File Offset: 0x00077922
    public string Name
    {
        get
        {
            return this.GetName(NameStyle.Full, -1);
        }
    }
 
    // Token: 0x1700054E RID: 1358
    // (get) Token: 0x060012A8 RID: 4776 RVA: 0x0007972C File Offset: 0x0007792C
    public string NameSimple
    {
        get
        {
            return this.GetName(NameStyle.Simple, -1);
        }
    }
 
    // Token: 0x060012A9 RID: 4777 RVA: 0x00079736 File Offset: 0x00077936
    public virtual string GetName(NameStyle style, int num = -1)
    {
        return "Card";
    }
 
    // Token: 0x060012AA RID: 4778 RVA: 0x0007973D File Offset: 0x0007793D
    public virtual string GetExtraName()
    {
        return "";
    }
 
    // Token: 0x060012AB RID: 4779 RVA: 0x00079744 File Offset: 0x00077944
    public virtual string GetDetail()
    {
        return this.sourceCard.GetText("detail", true);
    }
 
    // Token: 0x1700054F RID: 1359
    // (get) Token: 0x060012AC RID: 4780 RVA: 0x00079757 File Offset: 0x00077957
    public virtual bool IsPC
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000550 RID: 1360
    // (get) Token: 0x060012AD RID: 4781 RVA: 0x0007975C File Offset: 0x0007795C
    public bool _IsPC
    {
        get
        {
            return base.GetInt(56, null) != 0;
        }
    }
 
    // Token: 0x17000551 RID: 1361
    // (get) Token: 0x060012AE RID: 4782 RVA: 0x0007977D File Offset: 0x0007797D
    public virtual bool IsPCC
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000552 RID: 1362
    // (get) Token: 0x060012AF RID: 4783 RVA: 0x00079780 File Offset: 0x00077980
    public virtual bool IsPCParty
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000553 RID: 1363
    // (get) Token: 0x060012B0 RID: 4784 RVA: 0x00079783 File Offset: 0x00077983
    public virtual bool IsMinion
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000554 RID: 1364
    // (get) Token: 0x060012B1 RID: 4785 RVA: 0x00079786 File Offset: 0x00077986
    public virtual bool IsPCPartyMinion
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000555 RID: 1365
    // (get) Token: 0x060012B2 RID: 4786 RVA: 0x00079789 File Offset: 0x00077989
    public virtual bool IsPCFactionMinion
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000556 RID: 1366
    // (get) Token: 0x060012B3 RID: 4787 RVA: 0x0007978C File Offset: 0x0007798C
    public virtual bool IsMultisize
    {
        get
        {
            return this.sourceCard.multisize && this.IsInstalled;
        }
    }
 
    // Token: 0x17000557 RID: 1367
    // (get) Token: 0x060012B4 RID: 4788 RVA: 0x000797A3 File Offset: 0x000779A3
    public bool IsToolbelt
    {
        get
        {
            return this.category.slot == 44;
        }
    }
 
    // Token: 0x17000558 RID: 1368
    // (get) Token: 0x060012B5 RID: 4789 RVA: 0x000797B4 File Offset: 0x000779B4
    public bool IsLightsource
    {
        get
        {
            return this.category.slot == 45;
        }
    }
 
    // Token: 0x17000559 RID: 1369
    // (get) Token: 0x060012B6 RID: 4790 RVA: 0x000797C5 File Offset: 0x000779C5
    public bool IsEquipment
    {
        get
        {
            return this.category.slot != 0;
        }
    }
 
    // Token: 0x1700055A RID: 1370
    // (get) Token: 0x060012B7 RID: 4791 RVA: 0x000797D5 File Offset: 0x000779D5
    public bool IsFood
    {
        get
        {
            return this.category.IsChildOf("food");
        }
    }
 
    // Token: 0x1700055B RID: 1371
    // (get) Token: 0x060012B8 RID: 4792 RVA: 0x000797E7 File Offset: 0x000779E7
    public bool ShowFoodEnc
    {
        get
        {
            return this.IsFood || this.category.IsChildOf("seed") || this.id == "pasture" || this.category.IsChildOf("drug");
        }
    }
 
    // Token: 0x1700055C RID: 1372
    // (get) Token: 0x060012B9 RID: 4793 RVA: 0x00079827 File Offset: 0x00077A27
    public bool IsWeapon
    {
        get
        {
            return this.IsMeleeWeapon || this.IsRangedWeapon;
        }
    }
 
    // Token: 0x1700055D RID: 1373
    // (get) Token: 0x060012BA RID: 4794 RVA: 0x00079839 File Offset: 0x00077A39
    public bool IsEquipmentOrRanged
    {
        get
        {
            return this.category.slot != 0 || this.IsRangedWeapon;
        }
    }
 
    // Token: 0x1700055E RID: 1374
    // (get) Token: 0x060012BB RID: 4795 RVA: 0x00079850 File Offset: 0x00077A50
    public bool IsMeleeWeapon
    {
        get
        {
            return this.category.IsChildOf("melee");
        }
    }
 
    // Token: 0x1700055F RID: 1375
    // (get) Token: 0x060012BC RID: 4796 RVA: 0x00079862 File Offset: 0x00077A62
    public bool IsRangedWeapon
    {
        get
        {
            return this.trait is TraitToolRange;
        }
    }
 
    // Token: 0x17000560 RID: 1376
    // (get) Token: 0x060012BD RID: 4797 RVA: 0x00079872 File Offset: 0x00077A72
    public bool IsThrownWeapon
    {
        get
        {
            return this.sourceCard.HasTag(CTAG.throwWeapon);
        }
    }
 
    // Token: 0x17000561 RID: 1377
    // (get) Token: 0x060012BE RID: 4798 RVA: 0x00079881 File Offset: 0x00077A81
    public bool IsAmmo
    {
        get
        {
            return this.trait is TraitAmmo;
        }
    }
 
    // Token: 0x17000562 RID: 1378
    // (get) Token: 0x060012BF RID: 4799 RVA: 0x00079891 File Offset: 0x00077A91
    public bool IsAgent
    {
        get
        {
            return this == EClass.player.Agent;
        }
    }
 
    // Token: 0x17000563 RID: 1379
    // (get) Token: 0x060012C0 RID: 4800 RVA: 0x000798A0 File Offset: 0x00077AA0
    public bool IsFurniture
    {
        get
        {
            return this.category.IsChildOf("furniture");
        }
    }
 
    // Token: 0x17000564 RID: 1380
    // (get) Token: 0x060012C1 RID: 4801 RVA: 0x000798B2 File Offset: 0x00077AB2
    public bool IsBlessed
    {
        get
        {
            return this.blessedState >= BlessedState.Blessed;
        }
    }
 
    // Token: 0x17000565 RID: 1381
    // (get) Token: 0x060012C2 RID: 4802 RVA: 0x000798C0 File Offset: 0x00077AC0
    public bool IsCursed
    {
        get
        {
            return this.blessedState <= BlessedState.Cursed;
        }
    }
 
    // Token: 0x17000566 RID: 1382
    // (get) Token: 0x060012C3 RID: 4803 RVA: 0x000798CE File Offset: 0x00077ACE
    public bool IsRestrainedResident
    {
        get
        {
            return this.isRestrained && this.IsPCFaction;
        }
    }
 
    // Token: 0x17000567 RID: 1383
    // (get) Token: 0x060012C4 RID: 4804 RVA: 0x000798E0 File Offset: 0x00077AE0
    public virtual bool IsPCFaction
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000568 RID: 1384
    // (get) Token: 0x060012C5 RID: 4805 RVA: 0x000798E3 File Offset: 0x00077AE3
    public bool IsPCFactionOrMinion
    {
        get
        {
            return this.IsPCFaction || this.IsPCFactionMinion;
        }
    }
 
    // Token: 0x17000569 RID: 1385
    // (get) Token: 0x060012C6 RID: 4806 RVA: 0x000798F5 File Offset: 0x00077AF5
    public virtual bool IsGlobal
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x1700056A RID: 1386
    // (get) Token: 0x060012C7 RID: 4807 RVA: 0x000798F8 File Offset: 0x00077AF8
    public virtual int MaxDecay
    {
        get
        {
            return 1000;
        }
    }
 
    // Token: 0x1700056B RID: 1387
    // (get) Token: 0x060012C8 RID: 4808 RVA: 0x000798FF File Offset: 0x00077AFF
    public bool IsDecayed
    {
        get
        {
            return this.decay > this.MaxDecay;
        }
    }
 
    // Token: 0x1700056C RID: 1388
    // (get) Token: 0x060012C9 RID: 4809 RVA: 0x0007990F File Offset: 0x00077B0F
    public bool IsRotting
    {
        get
        {
            return this.decay >= this.MaxDecay / 4 * 3;
        }
    }
 
    // Token: 0x1700056D RID: 1389
    // (get) Token: 0x060012CA RID: 4810 RVA: 0x00079926 File Offset: 0x00077B26
    public bool IsFresn
    {
        get
        {
            return this.decay < this.MaxDecay / 4;
        }
    }
 
    // Token: 0x1700056E RID: 1390
    // (get) Token: 0x060012CB RID: 4811 RVA: 0x00079938 File Offset: 0x00077B38
    public virtual int MaxHP
    {
        get
        {
            return 100;
        }
    }
 
    // Token: 0x1700056F RID: 1391
    // (get) Token: 0x060012CC RID: 4812 RVA: 0x0007993C File Offset: 0x00077B3C
    public virtual int Power
    {
        get
        {
            return Mathf.Max(20, EClass.curve(this.GetTotalQuality(true) * 10, 400, 100, 75));
        }
    }
 
    // Token: 0x17000570 RID: 1392
    // (get) Token: 0x060012CD RID: 4813 RVA: 0x0007995D File Offset: 0x00077B5D
    public int FameLv
    {
        get
        {
            if (!this.IsPC)
            {
                return this.LV;
            }
            return EClass.player.fame / 100 + 1;
        }
    }
 
    // Token: 0x17000571 RID: 1393
    // (get) Token: 0x060012CE RID: 4814 RVA: 0x0007997D File Offset: 0x00077B7D
    public virtual int[] Tiles
    {
        get
        {
            return this.sourceCard._tiles;
        }
    }
 
    // Token: 0x17000572 RID: 1394
    // (get) Token: 0x060012CF RID: 4815 RVA: 0x0007998A File Offset: 0x00077B8A
    public virtual int PrefIndex
    {
        get
        {
            if (this.Tiles.Length < 3)
            {
                return this.dir % 2;
            }
            return this.dir;
        }
    }
 
    // Token: 0x17000573 RID: 1395
    // (get) Token: 0x060012D0 RID: 4816 RVA: 0x000799A6 File Offset: 0x00077BA6
    public bool IsVariation
    {
        get
        {
            return this.sourceCard.origin != null;
        }
    }
 
    // Token: 0x17000574 RID: 1396
    // (get) Token: 0x060012D1 RID: 4817 RVA: 0x000799B6 File Offset: 0x00077BB6
    public virtual int DV
    {
        get
        {
            return this.elements.Value(64);
        }
    }
 
    // Token: 0x17000575 RID: 1397
    // (get) Token: 0x060012D2 RID: 4818 RVA: 0x000799C5 File Offset: 0x00077BC5
    public virtual int PV
    {
        get
        {
            return this.elements.Value(65);
        }
    }
 
    // Token: 0x17000576 RID: 1398
    // (get) Token: 0x060012D3 RID: 4819 RVA: 0x000799D4 File Offset: 0x00077BD4
    public int HIT
    {
        get
        {
            return this.elements.Value(66);
        }
    }
 
    // Token: 0x17000577 RID: 1399
    // (get) Token: 0x060012D4 RID: 4820 RVA: 0x000799E3 File Offset: 0x00077BE3
    public int DMG
    {
        get
        {
            return this.elements.Value(67);
        }
    }
 
    // Token: 0x17000578 RID: 1400
    // (get) Token: 0x060012D5 RID: 4821 RVA: 0x000799F2 File Offset: 0x00077BF2
    public int STR
    {
        get
        {
            return this.elements.Value(70);
        }
    }
 
    // Token: 0x17000579 RID: 1401
    // (get) Token: 0x060012D6 RID: 4822 RVA: 0x00079A01 File Offset: 0x00077C01
    public int DEX
    {
        get
        {
            return this.elements.Value(72);
        }
    }
 
    // Token: 0x1700057A RID: 1402
    // (get) Token: 0x060012D7 RID: 4823 RVA: 0x00079A10 File Offset: 0x00077C10
    public int END
    {
        get
        {
            return this.elements.Value(71);
        }
    }
 
    // Token: 0x1700057B RID: 1403
    // (get) Token: 0x060012D8 RID: 4824 RVA: 0x00079A1F File Offset: 0x00077C1F
    public int PER
    {
        get
        {
            return this.elements.Value(73);
        }
    }
 
    // Token: 0x1700057C RID: 1404
    // (get) Token: 0x060012D9 RID: 4825 RVA: 0x00079A2E File Offset: 0x00077C2E
    public int LER
    {
        get
        {
            return this.elements.Value(74);
        }
    }
 
    // Token: 0x1700057D RID: 1405
    // (get) Token: 0x060012DA RID: 4826 RVA: 0x00079A3D File Offset: 0x00077C3D
    public int WIL
    {
        get
        {
            return this.elements.Value(75);
        }
    }
 
    // Token: 0x1700057E RID: 1406
    // (get) Token: 0x060012DB RID: 4827 RVA: 0x00079A4C File Offset: 0x00077C4C
    public int MAG
    {
        get
        {
            return this.elements.Value(76);
        }
    }
 
    // Token: 0x1700057F RID: 1407
    // (get) Token: 0x060012DC RID: 4828 RVA: 0x00079A5B File Offset: 0x00077C5B
    public int CHA
    {
        get
        {
            return this.elements.Value(77);
        }
    }
 
    // Token: 0x17000580 RID: 1408
    // (get) Token: 0x060012DD RID: 4829 RVA: 0x00079A6A File Offset: 0x00077C6A
    public int INT
    {
        get
        {
            return this.elements.Value(80);
        }
    }
 
    // Token: 0x17000581 RID: 1409
    // (get) Token: 0x060012DE RID: 4830 RVA: 0x00079A79 File Offset: 0x00077C79
    public int LUC
    {
        get
        {
            return this.elements.Value(78);
        }
    }
 
    // Token: 0x060012DF RID: 4831 RVA: 0x00079A88 File Offset: 0x00077C88
    public int GetBestAttribute()
    {
        int num = 1;
        foreach (Element element in from a in this.elements.dict.Values
        where Element.List_MainAttributesMajor.Contains(a.id)
        select a)
        {
            int num2 = element.Value;
            if (this.isChara && this.Chara.tempElements != null)
            {
                num2 -= this.Chara.tempElements.Value(element.id);
            }
            if (num2 > num)
            {
                num = num2;
            }
        }
        return num;
    }
 
    // Token: 0x060012E0 RID: 4832 RVA: 0x00079B3C File Offset: 0x00077D3C
    public void ModExp(string alias, int a)
    {
        this.ModExp(EClass.sources.elements.alias[alias].id, a);
    }
 
    // Token: 0x060012E1 RID: 4833 RVA: 0x00079B5F File Offset: 0x00077D5F
    public void ModExp(int ele, int a)
    {
        if (!this.isChara)
        {
            return;
        }
        this.elements.ModExp(ele, a, false);
    }
 
    // Token: 0x17000582 RID: 1410
    // (get) Token: 0x060012E2 RID: 4834 RVA: 0x00079B78 File Offset: 0x00077D78
    public int W
    {
        get
        {
            if (this.dir % 2 != 0)
            {
                return this.sourceCard.H;
            }
            return this.sourceCard.W;
        }
    }
 
    // Token: 0x17000583 RID: 1411
    // (get) Token: 0x060012E3 RID: 4835 RVA: 0x00079B9B File Offset: 0x00077D9B
    public int H
    {
        get
        {
            if (this.dir % 2 != 0)
            {
                return this.sourceCard.W;
            }
            return this.sourceCard.H;
        }
    }
 
    // Token: 0x17000584 RID: 1412
    // (get) Token: 0x060012E4 RID: 4836 RVA: 0x00079BBE File Offset: 0x00077DBE
    public bool IsIdentified
    {
        get
        {
            return this.c_IDTState == 0;
        }
    }
 
    // Token: 0x17000585 RID: 1413
    // (get) Token: 0x060012E5 RID: 4837 RVA: 0x00079BC9 File Offset: 0x00077DC9
    public string TextRarity
    {
        get
        {
            return Lang.GetList("quality")[Mathf.Clamp((int)(this.rarity + 1), 0, 5)];
        }
    }
 
    // Token: 0x17000586 RID: 1414
    // (get) Token: 0x060012E6 RID: 4838 RVA: 0x00079BE5 File Offset: 0x00077DE5
    public bool IsInstalled
    {
        get
        {
            return this.placeState == PlaceState.installed;
        }
    }
 
    // Token: 0x17000587 RID: 1415
    // (get) Token: 0x060012E7 RID: 4839 RVA: 0x00079BF0 File Offset: 0x00077DF0
    public bool IsMale
    {
        get
        {
            return this.bio != null && this.bio.gender == 2;
        }
    }
 
    // Token: 0x17000588 RID: 1416
    // (get) Token: 0x060012E8 RID: 4840 RVA: 0x00079C0A File Offset: 0x00077E0A
    public bool IsNegativeGift
    {
        get
        {
            return this.HasTag(CTAG.neg) || this.blessedState <= BlessedState.Cursed;
        }
    }
 
    // Token: 0x060012E9 RID: 4841 RVA: 0x00079C24 File Offset: 0x00077E24
    public bool IsChildOf(Card c)
    {
        return this.GetRootCard() == c;
    }
 
    // Token: 0x17000589 RID: 1417
    // (get) Token: 0x060012EA RID: 4842 RVA: 0x00079C2F File Offset: 0x00077E2F
    public bool HasContainerSize
    {
        get
        {
            return this.c_containerSize != 0;
        }
    }
 
    // Token: 0x1700058A RID: 1418
    // (get) Token: 0x060012EB RID: 4843 RVA: 0x00079C3A File Offset: 0x00077E3A
    public Thing Tool
    {
        get
        {
            if (!this.IsPC)
            {
                return null;
            }
            return EClass.player.currentHotItem.Thing;
        }
    }
 
    // Token: 0x1700058B RID: 1419
    // (get) Token: 0x060012EC RID: 4844 RVA: 0x00079C55 File Offset: 0x00077E55
    public virtual SourceMaterial.Row DefaultMaterial
    {
        get
        {
            return this.sourceCard.DefaultMaterial;
        }
    }
 
    // Token: 0x1700058C RID: 1420
    // (get) Token: 0x060012ED RID: 4845 RVA: 0x00079C62 File Offset: 0x00077E62
    public virtual bool HasHost
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x060012EE RID: 4846 RVA: 0x00079C68 File Offset: 0x00077E68
    [OnSerializing]
    private void _OnSerializing(StreamingContext context)
    {
        this._x = this.pos.x;
        this._z = this.pos.z;
        this._ints[0] = this._bits1.ToInt();
        this._ints[2] = this._bits2.ToInt();
        this._placeState = this.placeState;
        this.OnSerializing();
    }
 
    // Token: 0x060012EF RID: 4847 RVA: 0x00079CCF File Offset: 0x00077ECF
    protected virtual void OnSerializing()
    {
    }
 
    // Token: 0x060012F0 RID: 4848 RVA: 0x00079CD4 File Offset: 0x00077ED4
    [OnDeserialized]
    private void _OnDeserialized(StreamingContext context)
    {
        this._bits1.SetInt(this._ints[0]);
        this._bits2.SetInt(this._ints[2]);
        this.placeState = this._placeState;
        this.pos.Set(this._x, this._z);
        this.SetSource();
        this.things.SetOwner(this);
        this.elements.SetOwner(this, false);
        this.ApplyMaterialElements(false);
        this.OnDeserialized();
        this.ApplyTrait();
        this._CreateRenderer();
        foreach (Thing thing in this.things)
        {
            thing.parent = this;
        }
        if (this.isThing && this.Num <= 0)
        {
            this.isDestroyed = true;
        }
    }
 
    // Token: 0x060012F1 RID: 4849 RVA: 0x00079DC0 File Offset: 0x00077FC0
    protected virtual void OnDeserialized()
    {
    }
 
    // Token: 0x060012F2 RID: 4850 RVA: 0x00079DC4 File Offset: 0x00077FC4
    public string ReferenceId()
    {
        return "c" + this.uid.ToString();
    }
 
    // Token: 0x060012F3 RID: 4851 RVA: 0x00079DEC File Offset: 0x00077FEC
    public void Create(string _id, int _idMat = -1, int genLv = -1)
    {
        if (CardBlueprint.current != null)
        {
            this.bp = CardBlueprint.current;
            CardBlueprint.current = null;
        }
        else
        {
            this.bp = CardBlueprint._Default;
        }
        this.id = _id;
        this.Num = 1;
        this.autoRefuel = true;
        EClass.game.cards.AssignUID(this);
        this.isNew = true;
        this.SetSource();
        this.OnBeforeCreate();
        if (this.sourceCard.quality != 0)
        {
            this.rarity = this.sourceCard.quality.ToEnum<Rarity>();
        }
        else if (this.bp.rarity != Rarity.Random)
        {
            this.rarity = this.bp.rarity;
        }
        else if (this.category.slot != 0 && this.category.slot != 45 && this.category.slot != 44)
        {
            if (EClass.rnd(10) == 0)
            {
                this.rarity = Rarity.Crude;
            }
            else if (EClass.rnd(10) == 0)
            {
                this.rarity = Rarity.Superior;
            }
            else if (EClass.rnd(80) == 0)
            {
                this.rarity = Rarity.Legendary;
            }
            else if (EClass.rnd(250) == 0)
            {
                this.rarity = Rarity.Mythical;
            }
        }
        if (this.rarity != Rarity.Normal && this.category.tag.Contains("fixedRarity"))
        {
            this.rarity = Rarity.Normal;
        }
        this.LV = this.DefaultLV;
        if (this.bp.lv != -999)
        {
            this.LV = this.bp.lv;
        }
        if (this.sourceCard.fixedMaterial)
        {
            this._material = EClass.sources.materials.alias[this.AliasMaterialOnCreate];
        }
        else
        {
            bool flag = (this.bp != null && this.bp.fixedMat) || this.sourceCard.quality == 4 || this.sourceCard.tierGroup.IsEmpty();
            if (_idMat != -1)
            {
                this._material = EClass.sources.materials.rows[_idMat];
            }
            else if (!flag)
            {
                if (this.sourceCard.tierGroup == "wood")
                {
                    Debug.Log(this.id);
                }
                this._material = MATERIAL.GetRandomMaterial(genLv, this.sourceCard.tierGroup, this.bp.tryLevelMatTier);
            }
            else
            {
                this._material = EClass.sources.materials.alias[this.AliasMaterialOnCreate];
            }
        }
        this.idMaterial = this._material.id;
        this.things.SetOwner(this);
        this.elements.SetOwner(this, true);
        this.ApplyTrait();
        if (!this.bp.fixedQuality && this.trait.LevelAsQuality && (!EClass._zone.IsPCFaction || EClass.Branch.lv != 1) && EClass.debug.testThingQuality && EClass.rnd(2) == 0)
        {
            this.qualityTier = Mathf.Clamp(EClass.rnd(5) + 1, 1, 3);
            this.LV = this.LV + this.qualityTier * 10 + (this.LV - 1) * (125 + this.qualityTier * 25) / 100;
        }
        this.ApplyMaterial(false);
        this.OnCreate(genLv);
        this._CreateRenderer();
        this.trait.OnCreate(genLv);
        this.hp = this.MaxHP;
        if (this.HasTag(CTAG.hidden))
        {
            this.SetHidden(true);
        }
        this.isFloating = this.Pref.Float;
    }
 
    // Token: 0x060012F4 RID: 4852 RVA: 0x0007A169 File Offset: 0x00078369
    public virtual void OnBeforeCreate()
    {
    }
 
    // Token: 0x060012F5 RID: 4853 RVA: 0x0007A16B File Offset: 0x0007836B
    public virtual void OnCreate(int genLv)
    {
    }
 
    // Token: 0x060012F6 RID: 4854 RVA: 0x0007A16D File Offset: 0x0007836D
    public virtual void SetSource()
    {
    }
 
    // Token: 0x060012F7 RID: 4855 RVA: 0x0007A170 File Offset: 0x00078370
    public virtual void ApplyEditorTags(EditorTag tag)
    {
        if (tag <= EditorTag.IsOn)
        {
            if (tag == EditorTag.Empty)
            {
                this.RemoveThings();
                return;
            }
            if (tag == EditorTag.Hidden)
            {
                this.SetHidden(true);
                return;
            }
            if (tag != EditorTag.IsOn)
            {
                return;
            }
            this.isOn = true;
            return;
        }
        else
        {
            if (tag == EditorTag.IsOff)
            {
                this.isOn = false;
                return;
            }
            if (tag == EditorTag.NoSnow)
            {
                this.noSnow = true;
                return;
            }
            if (tag != EditorTag.Boss)
            {
                return;
            }
            EClass._zone.Boss = this.Chara;
            return;
        }
    }
 
    // Token: 0x060012F8 RID: 4856 RVA: 0x0007A1D8 File Offset: 0x000783D8
    public void ApplyTrait()
    {
        string c_idTrait = this.c_idTrait;
        if (c_idTrait.IsEmpty())
        {
            if (this.sourceCard.trait.IsEmpty())
            {
                this.trait = (this.isChara ? new TraitChara() : new Trait());
            }
            else
            {
                this.trait = ClassCache.Create<Trait>("Trait" + this.sourceCard.trait[0], "Elin");
            }
        }
        else
        {
            this.trait = ClassCache.Create<Trait>(c_idTrait, "Elin");
        }
        this.trait.SetOwner(this);
    }
 
    // Token: 0x060012F9 RID: 4857 RVA: 0x0007A268 File Offset: 0x00078468
    public Card SetLv(int a)
    {
        this.LV = a;
        if (!this.isChara)
        {
            return this;
        }
        Rand.SetSeed(this.uid);
        ElementContainer elementContainer = new ElementContainer();
        elementContainer.ApplyElementMap(this.uid, SourceValueType.Chara, this.Chara.job.elementMap, this.LV, false, false);
        elementContainer.ApplyElementMap(this.uid, SourceValueType.Chara, this.Chara.race.elementMap, this.LV, false, false);
        elementContainer.ApplyElementMap(this.uid, SourceValueType.Chara, this.Chara.source.elementMap, 1, false, true);
        foreach (Element element in this.elements.dict.Values)
        {
            int num = elementContainer.Value(element.id);
            if (num != 0)
            {
                int num2 = num - element.ValueWithoutLink;
                if (num2 != 0)
                {
                    this.elements.ModBase(element.id, num2);
                }
            }
        }
        Rand.SetSeed(-1);
        this.hp = this.MaxHP;
        this.Chara.mana.value = this.Chara.mana.max;
        this.Chara.CalculateMaxStamina();
        this.SetDirtyWeight();
        return this;
    }
 
    // Token: 0x060012FA RID: 4858 RVA: 0x0007A3C0 File Offset: 0x000785C0
    public void AddExp(int a)
    {
        if (!this.IsPC)
        {
            a *= 2;
        }
        this.exp += a;
        while (this.exp >= this.ExpToNext)
        {
            this.exp -= this.ExpToNext;
            this.LevelUp();
        }
    }
 
    // Token: 0x060012FB RID: 4859 RVA: 0x0007A414 File Offset: 0x00078614
    public void LevelUp()
    {
        if (this.IsPC)
        {
            if (EClass.core.version.demo && EClass.player.totalFeat >= 5)
            {
                Msg.Say("demoLimit");
                return;
            }
            EClass.player.totalFeat++;
            Tutorial.Reserve("feat", null);
        }
        int num = this.feat;
        this.feat = num + 1;
        num = this.LV;
        this.LV = num + 1;
        this.Say("dingExp", this, null, null);
        this.PlaySound("jingle_lvup", 1f, true);
        this.PlayEffect("aura_heaven", true, 0f, default(Vector3));
        if (this.HasElement(1415, 1) && this.Evalue(1415) < 9 && this.LV >= this.Evalue(1415) * 5 + 10)
        {
            this.Chara.SetFeat(1415, this.Evalue(1415) + 1, true);
        }
        if (!this.IsPC)
        {
            if (this.Chara.race.id == "mutant")
            {
                int num2 = Mathf.Min(1 + this.LV / 5, 22);
                for (int i = 0; i < num2; i++)
                {
                    if (this.Evalue(1644) < i + 1)
                    {
                        this.Chara.SetFeat(1644, i + 1, false);
                    }
                }
            }
            this.Chara.TryUpgrade(true);
        }
    }
 
    // Token: 0x060012FC RID: 4860 RVA: 0x0007A590 File Offset: 0x00078790
    public virtual void ApplyMaterialElements(bool remove)
    {
    }
 
    // Token: 0x060012FD RID: 4861 RVA: 0x0007A592 File Offset: 0x00078792
    public virtual void ApplyMaterial(bool remove = false)
    {
        this._colorInt = 0;
    }
 
    // Token: 0x060012FE RID: 4862 RVA: 0x0007A59B File Offset: 0x0007879B
    public Card ChangeMaterial(int idNew)
    {
        return this.ChangeMaterial(EClass.sources.materials.map[idNew]);
    }
 
    // Token: 0x060012FF RID: 4863 RVA: 0x0007A5B8 File Offset: 0x000787B8
    public Card ChangeMaterial(string idNew)
    {
        return this.ChangeMaterial(EClass.sources.materials.alias[idNew]);
    }
 
    // Token: 0x06001300 RID: 4864 RVA: 0x0007A5D8 File Offset: 0x000787D8
    public Card ChangeMaterial(SourceMaterial.Row row)
    {
        if (this.sourceCard.fixedMaterial)
        {
            return this;
        }
        this.ApplyMaterial(true);
        this._material = row;
        this.idMaterial = row.id;
        this.decay = 0;
        this.dirtyWeight = true;
        Card rootCard = this.GetRootCard();
        if (rootCard != null && rootCard.IsPC)
        {
            this.GetRootCard().SetDirtyWeight();
        }
        if (this.isThing)
        {
            LayerInventory.SetDirty(this.Thing);
        }
        this.ApplyMaterial(false);
        return this;
    }
 
    // Token: 0x06001301 RID: 4865 RVA: 0x0007A656 File Offset: 0x00078856
    public void SetReplica(bool on)
    {
        this.isReplica = true;
        this.ChangeMaterial("granite");
    }
 
    // Token: 0x06001302 RID: 4866 RVA: 0x0007A66B File Offset: 0x0007886B
    public Thing Add(string id, int num = 1, int lv = 1)
    {
        if (num == 0)
        {
            num = 1;
        }
        return this.AddCard(ThingGen.Create(id, -1, lv).SetNum(num)) as Thing;
    }
 
    // Token: 0x06001303 RID: 4867 RVA: 0x0007A68C File Offset: 0x0007888C
    public Card AddCard(Card c)
    {
        return this.AddThing(c as Thing, true, -1, -1);
    }
 
    // Token: 0x06001304 RID: 4868 RVA: 0x0007A69D File Offset: 0x0007889D
    public void RemoveCard(Card c)
    {
        this.RemoveThing(c as Thing);
    }
 
    // Token: 0x06001305 RID: 4869 RVA: 0x0007A6AB File Offset: 0x000788AB
    public void NotifyAddThing(Thing t, int num)
    {
    }
 
    // Token: 0x06001306 RID: 4870 RVA: 0x0007A6AD File Offset: 0x000788AD
    public Thing AddThing(string id, int lv = -1)
    {
        return this.AddThing(ThingGen.Create(id, -1, (lv == -1) ? this.LV : lv), true, -1, -1);
    }
 
    // Token: 0x06001307 RID: 4871 RVA: 0x0007A6CC File Offset: 0x000788CC
    public Thing AddThing(Thing t, bool tryStack = true, int destInvX = -1, int destInvY = -1)
    {
        if (t.Num == 0 || t.isDestroyed)
        {
            Debug.LogWarning(string.Concat(new string[]
            {
                "tried to add destroyed thing:",
                t.Num.ToString(),
                "/",
                t.isDestroyed.ToString(),
                "/",
                (t != null) ? t.ToString() : null,
                "/",
                (this != null) ? this.ToString() : null
            }));
            return t;
        }
        if (t.parent == this)
        {
            Debug.LogWarning("already child:" + ((t != null) ? t.ToString() : null));
            return t;
        }
        if (this.things.Contains(t))
        {
            Debug.Log("already in the list" + ((t != null) ? t.ToString() : null));
            return t;
        }
        ICardParent cardParent = t.parent;
        Zone zone = EClass._zone;
        bool flag = this.IsPC && t.GetRootCard() == EClass.pc;
        if (t.parent != null)
        {
            t.parent.RemoveCard(t);
        }
        if (t.trait.ToggleType == ToggleType.Fire && destInvY == 0)
        {
            t.trait.Toggle(false, false);
        }
        t.isMasked = false;
        t.ignoreAutoPick = false;
        t.parent = this;
        t.noShadow = false;
        t.isSale = false;
        if (t.IsContainer)
        {
            t.RemoveEditorTag(EditorTag.PreciousContainer);
        }
        t.invX = -1;
        if (destInvY == -1)
        {
            t.invY = 0;
        }
        Thing thing = tryStack ? this.things.TryStack(t, destInvX, destInvY) : t;
        if (t == thing)
        {
            this.things.Add(t);
            this.things.OnAdd(t);
        }
        if (thing == t && this.IsPC && EClass.core.IsGameStarted && EClass._map != null && this.parent == EClass.game.activeZone && this.pos.IsValid && !flag)
        {
            this.NotifyAddThing(t, t.Num);
        }
        if (t == thing && this.isThing && this.parent == EClass._zone && this.placeState != PlaceState.roaming)
        {
            EClass._map.Stocked.Add(t);
        }
        this.SetDirtyWeight();
        if (this.ShouldTrySetDirtyInventory())
        {
            EClass.pc.SetDirtyWeight();
            LayerInventory.SetDirty(thing);
        }
        if (!this.IsPC)
        {
            if (!this.IsContainer)
            {
                return thing;
            }
            Card rootCard = this.GetRootCard();
            if (rootCard == null || !rootCard.IsPC)
            {
                return thing;
            }
        }
        Card.<>c__DisplayClass684_0 CS$<>8__locals1 = new Card.<>c__DisplayClass684_0();
        t.isNPCProperty = false;
        t.isGifted = false;
        CS$<>8__locals1.count = 0;
        CS$<>8__locals1.ings = EClass.player.recipes.knownIngredients;
        CS$<>8__locals1.<AddThing>g__TryAdd|0(t);
        if (t.CanSearchContents)
        {
            t.things.Foreach(delegate(Thing _t)
            {
                base.<AddThing>g__TryAdd|0(_t);
            }, true);
        }
        if (CS$<>8__locals1.count > 0 && EClass.core.IsGameStarted)
        {
            Msg.Say((CS$<>8__locals1.count == 1) ? "newIng" : "newIngs", CS$<>8__locals1.count.ToString() ?? "", null, null, null);
        }
        return thing;
    }
 
    // Token: 0x06001308 RID: 4872 RVA: 0x0007A9E8 File Offset: 0x00078BE8
    public void RemoveThings()
    {
        for (int i = this.things.Count - 1; i >= 0; i--)
        {
            this.RemoveThing(this.things[i]);
        }
    }
 
    // Token: 0x06001309 RID: 4873 RVA: 0x0007AA20 File Offset: 0x00078C20
    public void RemoveThing(Thing thing)
    {
        Chara chara = this.GetRootCard() as Chara;
        if (((chara != null) ? chara.held : null) == thing)
        {
            (this.GetRootCard() as Chara).held = null;
            this.RecalculateFOV();
        }
        this.dirtyWeight = true;
        if (thing.c_equippedSlot != 0 && this.isChara)
        {
            this.Chara.body.Unequip(thing, true);
        }
        this.things.Remove(thing);
        this.things.OnRemove(thing);
        if (this.isSale && this.things.Count == 0 && this.IsContainer)
        {
            this.isSale = false;
            EClass._map.props.sales.Remove(this);
        }
        if (thing.invY == 1)
        {
            WidgetCurrentTool.dirty = true;
        }
        thing.invX = -1;
        thing.invY = 0;
        if (thing.props != null)
        {
            thing.props.Remove(thing);
        }
        this.SetDirtyWeight();
        if (this.ShouldTrySetDirtyInventory())
        {
            LayerInventory.SetDirty(thing);
            WidgetHotbar.dirtyCurrentItem = true;
            thing.parent = null;
            if (thing.trait.IsContainer)
            {
                foreach (LayerInventory layerInventory in LayerInventory.listInv.Copy<LayerInventory>())
                {
                    if (layerInventory.invs[0].owner.Container.GetRootCard() != EClass.pc && layerInventory.floatInv)
                    {
                        EClass.ui.layerFloat.RemoveLayer(layerInventory);
                    }
                }
            }
        }
        thing.parent = null;
    }
 
    // Token: 0x0600130A RID: 4874 RVA: 0x0007ABBC File Offset: 0x00078DBC
    public bool ShouldTrySetDirtyInventory()
    {
        return EClass.player.chara != null && (this.IsPC || this.GetRootCard() == EClass.pc || EClass.ui.layers.Count > 0);
    }
 
    // Token: 0x0600130B RID: 4875 RVA: 0x0007ABF5 File Offset: 0x00078DF5
    public virtual bool CanStackTo(Thing to)
    {
        return false;
    }
 
    // Token: 0x0600130C RID: 4876 RVA: 0x0007ABF8 File Offset: 0x00078DF8
    public bool TryStackTo(Thing to)
    {
        if (!this.CanStackTo(to))
        {
            return false;
        }
        to.ModNum(this.Num, true);
        to.decay = (to.decay * to.Num + this.decay * this.Num) / (to.Num + this.Num);
        if (this.c_isImportant)
        {
            to.c_isImportant = true;
        }
        if (EClass.core.config.game.markStack && to.GetRootCard() == EClass.pc)
        {
            to.isNew = true;
        }
        this.Destroy();
        return true;
    }
 
    // Token: 0x0600130D RID: 4877 RVA: 0x0007AC8C File Offset: 0x00078E8C
    public ICardParent GetRoot()
    {
        if (this.parent == null)
        {
            return this;
        }
        return this.parent.GetRoot();
    }
 
    // Token: 0x0600130E RID: 4878 RVA: 0x0007ACA4 File Offset: 0x00078EA4
    public Card GetRootCard()
    {
        Card card = this.parent as Card;
        if (card == null)
        {
            return this;
        }
        return card.GetRootCard();
    }
 
    // Token: 0x0600130F RID: 4879 RVA: 0x0007ACC8 File Offset: 0x00078EC8
    public bool IsStackable(Thing tg)
    {
        return !(this.id != tg.id) && this.material == tg.material;
    }
 
    // Token: 0x06001310 RID: 4880 RVA: 0x0007ACF0 File Offset: 0x00078EF0
    public Thing Duplicate(int num)
    {
        Thing thing = ThingGen.Create(this.id, -1, -1);
        thing.ChangeMaterial(this.idMaterial);
        thing._bits1 = this._bits1;
        thing._bits2 = this._bits2;
        thing.dir = this.dir;
        thing.refVal = this.refVal;
        thing.altitude = this.altitude;
        thing.idSkin = this.idSkin;
        thing.blessedState = this.blessedState;
        thing.rarityLv = this.rarityLv;
        thing.qualityTier = this.qualityTier;
        thing.LV = this.LV;
        thing.exp = this.exp;
        thing.encLV = this.encLV;
        thing.decay = this.decay;
        thing.mapInt.Clear();
        thing.mapStr.Clear();
        foreach (KeyValuePair<int, int> keyValuePair in this.mapInt)
        {
            thing.mapInt[keyValuePair.Key] = keyValuePair.Value;
        }
        foreach (KeyValuePair<int, string> keyValuePair2 in this.mapStr)
        {
            thing.mapStr[keyValuePair2.Key] = keyValuePair2.Value;
        }
        this.elements.CopyTo(thing.elements);
        thing.SetNum(num);
        if (thing.IsRangedWeapon)
        {
            thing.sockets = IO.DeepCopy<List<int>>(this.sockets);
        }
        return thing;
    }
 
    // Token: 0x06001311 RID: 4881 RVA: 0x0007AEAC File Offset: 0x000790AC
    public Thing Split(int a)
    {
        if (a == this.Num)
        {
            return this.Thing;
        }
        Thing result = this.Duplicate(a);
        this.ModNum(-a, false);
        return result;
    }
 
    // Token: 0x06001312 RID: 4882 RVA: 0x0007AECE File Offset: 0x000790CE
    public Thing SetNum(int a)
    {
        if (!this.isThing)
        {
            return null;
        }
        if (a == this.Num)
        {
            return this as Thing;
        }
        this.ModNum(a - this.Num, true);
        return this as Thing;
    }
 
    // Token: 0x06001313 RID: 4883 RVA: 0x0007AEFF File Offset: 0x000790FF
    public Thing SetNoSell()
    {
        this.noSell = true;
        return this as Thing;
    }
 
    // Token: 0x06001314 RID: 4884 RVA: 0x0007AF10 File Offset: 0x00079110
    public void ModNum(int a, bool notify = true)
    {
        if (this.Num + a < 0)
        {
            a = -this.Num;
        }
        this.Num += a;
        if (this.props != null)
        {
            this.props.OnNumChange(this, a);
        }
        if (this.parent != null)
        {
            this.parent.OnChildNumChange(this);
        }
        if (a > 0 && EClass.core.IsGameStarted && this.GetRootCard() == EClass.pc && notify)
        {
            this.NotifyAddThing(this.Thing, a);
        }
        this.SetDirtyWeight();
        if (this.Num <= 0)
        {
            this.Destroy();
        }
    }
 
    // Token: 0x06001315 RID: 4885 RVA: 0x0007AFAE File Offset: 0x000791AE
    public void AddSocket()
    {
        if (this.sockets == null)
        {
            this.sockets = new List<int>();
        }
        this.sockets.Add(0);
    }
 
    // Token: 0x06001316 RID: 4886 RVA: 0x0007AFD0 File Offset: 0x000791D0
    public void ApplySocket(Thing t)
    {
        TraitMod traitMod = t.trait as TraitMod;
        if (traitMod == null || this.sockets == null)
        {
            return;
        }
        this.ApplySocket(traitMod.source.id, traitMod.owner.encLV, traitMod.owner);
    }
 
    // Token: 0x06001317 RID: 4887 RVA: 0x0007B018 File Offset: 0x00079218
    public void ApplySocket(int id, int lv, Card mod = null)
    {
        int i = 0;
        while (i < this.sockets.Count)
        {
            if (this.sockets[i] == 0)
            {
                if (lv >= 100)
                {
                    lv = 99;
                }
                this.sockets[i] = id * 100 + lv;
                this.elements.ModBase(id, lv);
                if (mod != null)
                {
                    mod.Destroy();
                    return;
                }
                break;
            }
            else
            {
                i++;
            }
        }
    }
 
    // Token: 0x06001318 RID: 4888 RVA: 0x0007B07C File Offset: 0x0007927C
    public void EjectSockets()
    {
        for (int i = 0; i < this.sockets.Count; i++)
        {
            int num = this.sockets[i];
            if (num != 0)
            {
                Thing thing = ThingGen.Create(this.isCopy ? "ash3" : "mod_ranged", -1, -1);
                int refVal = num / 100;
                int encLV = num % 100;
                if (!this.isCopy)
                {
                    thing.refVal = refVal;
                    thing.encLV = encLV;
                }
                EClass._map.TrySmoothPick(this.pos.IsBlocked ? EClass.pc.pos : this.pos, thing, EClass.pc);
                this.elements.ModBase(thing.refVal, -thing.encLV);
                this.sockets[i] = 0;
            }
        }
    }
 
    // Token: 0x06001319 RID: 4889 RVA: 0x0007B14B File Offset: 0x0007934B
    public void OnChildNumChange(Card c)
    {
        if (this.ShouldTrySetDirtyInventory() && c.isThing)
        {
            LayerInventory.SetDirty(c.Thing);
            WidgetCurrentTool.RefreshCurrentHotItem();
        }
    }
 
    // Token: 0x0600131A RID: 4890 RVA: 0x0007B16D File Offset: 0x0007936D
    public Card Install()
    {
        this.SetPlaceState(PlaceState.installed, false);
        return this;
    }
 
    // Token: 0x0600131B RID: 4891 RVA: 0x0007B178 File Offset: 0x00079378
    public void SetPlaceState(PlaceState newState, bool byPlayer = false)
    {
        if (this.placeState == newState)
        {
            return;
        }
        if (this.parent != EClass._zone)
        {
            Debug.Log("tried to change placestate of non-root card:" + ((this != null) ? this.ToString() : null));
            return;
        }
        PlaceState placeState = this.placeState;
        Area area = this.pos.area;
        if (placeState == PlaceState.installed)
        {
            if (area != null)
            {
                area.OnUninstallCard(this);
            }
            if (!this.isRoofItem)
            {
                this.altitude = 0;
                this.freePos = false;
                this.fx = (this.fy = 0f);
            }
            this.trait.Uninstall();
        }
        if (placeState == PlaceState.installed || newState == PlaceState.installed)
        {
            this.ForeachPoint(delegate(Point p, bool main)
            {
                p.cell.RemoveCard(this);
            });
            this.placeState = newState;
            this.ForeachPoint(delegate(Point p, bool main)
            {
                p.cell.AddCard(this);
            });
        }
        else
        {
            this.placeState = newState;
        }
        if (newState == PlaceState.none)
        {
            this.placeState = PlaceState.roaming;
            if (this.props != null)
            {
                this.props.Remove(this);
            }
        }
        else
        {
            EClass._map.props.OnCardAddedToZone(this);
            if (this.placeState == PlaceState.installed)
            {
                if (this.isThing)
                {
                    this.pos.detail.MoveThingToTop(this.Thing);
                }
                if (area != null)
                {
                    area.OnInstallCard(this);
                }
                this.isRoofItem = false;
                this.trait.Install(byPlayer);
            }
        }
        if (this.trait.ShouldRefreshTile)
        {
            this.pos.RefreshNeighborTiles();
        }
        if (this.trait.ShouldTryRefreshRoom && (placeState == PlaceState.installed || this.placeState == PlaceState.installed))
        {
            EClass._map.OnSetBlockOrDoor(this.pos.x, this.pos.z);
        }
        this.trait.OnChangePlaceState(newState);
        if (EClass._zone.IsPCFaction)
        {
            EClass.Branch.resources.SetDirty();
        }
    }
 
    // Token: 0x1700058D RID: 1421
    // (get) Token: 0x0600131C RID: 4892 RVA: 0x0007B339 File Offset: 0x00079539
    public int Quality
    {
        get
        {
            return this.Evalue(2);
        }
    }
 
    // Token: 0x1700058E RID: 1422
    // (get) Token: 0x0600131D RID: 4893 RVA: 0x0007B342 File Offset: 0x00079542
    public int QualityLv
    {
        get
        {
            return this.Quality / 10;
        }
    }
 
    // Token: 0x0600131E RID: 4894 RVA: 0x0007B350 File Offset: 0x00079550
    public int GetTotalQuality(bool applyBonus = true)
    {
        int num = 5 + this.LV + this.material.quality;
        if (applyBonus)
        {
            num = num * (100 + this.Quality) / 100;
        }
        return num;
    }
 
    // Token: 0x0600131F RID: 4895 RVA: 0x0007B388 File Offset: 0x00079588
    public void ModEncLv(int a)
    {
        this.ApplyMaterialElements(true);
        this.encLV += a;
        this.ApplyMaterialElements(false);
        if (this.IsEquipmentOrRanged || this.IsAmmo)
        {
            if (this.IsWeapon || this.IsAmmo)
            {
                this.elements.ModBase(67, a);
                return;
            }
            this.elements.ModBase(65, a * 2);
        }
    }
 
    // Token: 0x06001320 RID: 4896 RVA: 0x0007B3F2 File Offset: 0x000795F2
    public void SetEncLv(int a)
    {
        this.ModEncLv(a - this.encLV);
    }
 
    // Token: 0x06001321 RID: 4897 RVA: 0x0007B404 File Offset: 0x00079604
    public virtual void SetBlessedState(BlessedState s)
    {
        int num = 0;
        if (s == BlessedState.Blessed && this.blessedState < BlessedState.Blessed)
        {
            num = 1;
        }
        if (s < BlessedState.Blessed && this.blessedState == BlessedState.Blessed)
        {
            num = -1;
        }
        if (num != 0 && (this.IsEquipmentOrRanged || this.IsAmmo))
        {
            if (this.IsWeapon || this.IsAmmo)
            {
                this.elements.ModBase(67, num);
            }
            else
            {
                this.elements.ModBase(65, num * 2);
            }
        }
        this.blessedState = s;
    }
 
    // Token: 0x06001322 RID: 4898 RVA: 0x0007B47D File Offset: 0x0007967D
    public virtual void ChangeRarity(Rarity q)
    {
        this.rarity = q;
    }
 
    // Token: 0x06001323 RID: 4899 RVA: 0x0007B488 File Offset: 0x00079688
    public bool TryPay(int a, string id = "money")
    {
        if (this.GetCurrency(id) < a)
        {
            if (this.IsPC)
            {
                SE.Beep();
                Msg.Say((id == "ration") ? "notEnoughFood" : "notEnoughMoney");
            }
            return false;
        }
        if (this.IsPC && !(id == "ration"))
        {
            SE.Pay();
        }
        this.ModCurrency(-a, id);
        return true;
    }
 
    // Token: 0x06001324 RID: 4900 RVA: 0x0007B4F1 File Offset: 0x000796F1
    public void SetCharge(int a)
    {
        this.c_charges = a;
        LayerInventory.SetDirty(this.Thing);
    }
 
    // Token: 0x06001325 RID: 4901 RVA: 0x0007B508 File Offset: 0x00079708
    public void ModCharge(int a, bool destroy = false)
    {
        this.c_charges += a;
        LayerInventory.SetDirty(this.Thing);
        if (this.c_charges <= 0 && destroy)
        {
            this.Say("spellbookCrumble", this, null, null);
            this.ModNum(-1, true);
        }
    }
 
    // Token: 0x06001326 RID: 4902 RVA: 0x0007B554 File Offset: 0x00079754
    public void ModCurrency(int a, string id = "money")
    {
        if (a == 0)
        {
            return;
        }
        if (id == "influence")
        {
            EClass._zone.ModInfluence(a);
            return;
        }
        SourceMaterial.Row mat = null;
        this.things.AddCurrency(this, id, a, mat);
    }
 
    // Token: 0x06001327 RID: 4903 RVA: 0x0007B590 File Offset: 0x00079790
    public int GetCurrency(string id = "money")
    {
        if (id == "influence")
        {
            return EClass._zone.influence;
        }
        int result = 0;
        SourceMaterial.Row mat = null;
        this.things.GetCurrency(id, ref result, mat);
        return result;
    }
 
    // Token: 0x06001328 RID: 4904 RVA: 0x0007B5CC File Offset: 0x000797CC
    public virtual void HealHPHost(int a, HealSource origin = HealSource.None)
    {
        if (this.isChara)
        {
            if (this.Chara.parasite != null)
            {
                this.Chara.parasite.HealHP(a, HealSource.None);
            }
            if (this.Chara.ride != null)
            {
                this.Chara.ride.HealHP(a, HealSource.None);
            }
        }
        this.HealHP(a, origin);
    }
 
    // Token: 0x06001329 RID: 4905 RVA: 0x0007B628 File Offset: 0x00079828
    public virtual void HealHP(int a, HealSource origin = HealSource.None)
    {
        this.hp += a;
        if (this.hp > this.MaxHP)
        {
            this.hp = this.MaxHP;
        }
        if (origin == HealSource.Magic)
        {
            this.PlaySound("heal", 1f, true);
            this.PlayEffect("heal", true, 0f, default(Vector3));
            return;
        }
        if (origin != HealSource.HOT)
        {
            return;
        }
        this.PlaySound("heal_tick", 1f, true);
        this.PlayEffect("heal_tick", true, 0f, default(Vector3));
    }
 
    // Token: 0x0600132A RID: 4906 RVA: 0x0007B6C1 File Offset: 0x000798C1
    public virtual int GetArmorSkill()
    {
        return 0;
    }
 
    // Token: 0x0600132B RID: 4907 RVA: 0x0007B6C4 File Offset: 0x000798C4
    public virtual int ApplyProtection(int dmg, int mod = 100)
    {
        int armorSkill = this.GetArmorSkill();
        Element orCreateElement = this.elements.GetOrCreateElement(armorSkill);
        int num = this.PV + orCreateElement.Value + this.DEX / 10;
        int num2 = 1;
        int sides = 1;
        int bonus = 0;
        if (num > 0)
        {
            int num3 = num / 4;
            num2 = num3 / 10 + 1;
            sides = num3 / num2 + 1;
            bonus = 0;
            dmg = dmg * 100 / (100 + num);
        }
        int num4 = Dice.Roll(num2, sides, bonus, this);
        dmg -= num4 * mod / 100;
        if (dmg < 0)
        {
            dmg = 0;
        }
        return dmg;
    }
 
    // Token: 0x0600132C RID: 4908 RVA: 0x0007B747 File Offset: 0x00079947
    public void DamageHP(int dmg, AttackSource attackSource = AttackSource.None, Card origin = null)
    {
        this.DamageHP(dmg, 0, 0, attackSource, origin, true);
    }
 
    // Token: 0x0600132D RID: 4909 RVA: 0x0007B758 File Offset: 0x00079958
    public void DamageHP(int dmg, int ele, int eleP = 100, AttackSource attackSource = AttackSource.None, Card origin = null, bool showEffect = true)
    {
        Card.<>c__DisplayClass724_0 CS$<>8__locals1 = new Card.<>c__DisplayClass724_0();
        CS$<>8__locals1.<>4__this = this;
        CS$<>8__locals1.dmg = dmg;
        CS$<>8__locals1.origin = origin;
        if (this.hp < 0)
        {
            return;
        }
        if (ele == 0)
        {
            CS$<>8__locals1.e = Element.Void;
        }
        else
        {
            CS$<>8__locals1.e = Element.Create(ele, 0);
            if (attackSource != AttackSource.Condition && showEffect)
            {
                ActEffect.TryDelay(delegate
                {
                    CS$<>8__locals1.<>4__this.PlayEffect(CS$<>8__locals1.e.id, true, 0.25f);
                    EClass.Sound.Play("atk_" + CS$<>8__locals1.e.source.alias);
                });
            }
            if (!CS$<>8__locals1.e.source.aliasRef.IsEmpty())
            {
                CS$<>8__locals1.dmg = Element.GetResistDamage(CS$<>8__locals1.dmg, this.Evalue(CS$<>8__locals1.e.source.aliasRef));
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 100 / (100 + Mathf.Clamp(this.Evalue(961) * 5, -50, 200));
            }
            int dmg2 = CS$<>8__locals1.e.id;
            if (dmg2 != 910)
            {
                if (dmg2 == 912)
                {
                    Chara chara = this.Chara;
                    if (chara != null && chara.isWet)
                    {
                        CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 150 / 100;
                    }
                }
            }
            else
            {
                Chara chara2 = this.Chara;
                if (chara2 != null && chara2.isWet)
                {
                    CS$<>8__locals1.dmg /= 3;
                }
            }
        }
        if (attackSource != AttackSource.Finish)
        {
            if (!this.IsPCFaction && this.LV > 50)
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * (100 - (int)Mathf.Min(80f, Mathf.Sqrt((float)(this.LV - 50)) * 2.5f)) / 100;
            }
            CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * Mathf.Max(0, 100 - this.Evalue((CS$<>8__locals1.e == Element.Void) ? 55 : 56)) / 100;
            if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.IsPC && EClass.player.codex.Has(this.id))
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * (100 + Mathf.Min(10, EClass.player.codex.GetOrCreate(this.id).weakspot)) / 100;
            }
            if (this.isChara && this.Chara.body.GetAttackStyle() == AttackStyle.Shield && this.elements.ValueWithoutLink(123) >= 5 && CS$<>8__locals1.e == Element.Void)
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 90 / 100;
            }
            if (this.Evalue(971) > 0)
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 100 / Mathf.Clamp(100 + this.Evalue(971), 25, 1000);
            }
            if (this.HasElement(1305, 1))
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 90 / 100;
            }
            if (EClass.pc.HasElement(1207, 1) && this.isChara)
            {
                int num = 0;
                int num2 = 0;
                foreach (Condition condition in this.Chara.conditions)
                {
                    if (condition.Type == ConditionType.Buff)
                    {
                        num++;
                    }
                    else if (condition.Type == ConditionType.Debuff)
                    {
                        num2++;
                    }
                }
                if (this.IsPCParty)
                {
                    CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 100 / Mathf.Max(100 + num * 5, 120);
                }
                else
                {
                    CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * Mathf.Max(100 + num2 * 5, 120) / 100;
                }
            }
            if (this.IsPCParty && EClass.pc.ai is GoalAutoCombat)
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg - EClass.pc.Evalue(13) - 1;
            }
            else if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.IsPCParty && EClass.pc.ai is GoalAutoCombat)
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * 100 / Mathf.Max(110 - EClass.pc.Evalue(13), 105);
            }
            if (this.HasElement(1218, 1))
            {
                CS$<>8__locals1.dmg = CS$<>8__locals1.dmg * (1000 - this.Evalue(1218)) / 1000;
                if (CS$<>8__locals1.dmg <= 0 && EClass.rnd(4) == 0)
                {
                    int dmg2 = CS$<>8__locals1.dmg;
                    CS$<>8__locals1.dmg = dmg2 + 1;
                }
            }
            if (CS$<>8__locals1.dmg >= this.MaxHP / 10 && this.Evalue(68) > 0)
            {
                int num3 = this.MaxHP / 10;
                int num4 = CS$<>8__locals1.dmg - num3;
                num4 = num4 * 100 / (200 + this.Evalue(68) * 10);
                CS$<>8__locals1.dmg = num3 + num4;
            }
        }
        if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.IsPC && EClass.pc.Evalue(654) > 0)
        {
            CS$<>8__locals1.dmg = 0;
        }
        if (CS$<>8__locals1.dmg < 0)
        {
            CS$<>8__locals1.dmg = 0;
        }
        int num5 = Mathf.Clamp(CS$<>8__locals1.dmg * 6 / this.MaxHP, 0, 4) + ((CS$<>8__locals1.dmg > 0) ? 1 : 0);
        if (this.Evalue(1421) > 0)
        {
            int num6 = CS$<>8__locals1.dmg;
            if (this.hp > 0)
            {
                num6 = CS$<>8__locals1.dmg - this.hp;
                this.hp -= CS$<>8__locals1.dmg;
                if (this.hp < 0 && this.Chara.mana.value >= 0)
                {
                    this.hp = 0;
                }
            }
            if (this.hp <= 0)
            {
                if (this.Evalue(1421) >= 2)
                {
                    num6 /= 2;
                }
                CS$<>8__locals1.dmg = num6;
                if (this.Chara.mana.value > 0)
                {
                    num6 -= this.Chara.mana.value;
                    this.Chara.mana.value -= CS$<>8__locals1.dmg;
                }
                if (this.Chara.mana.value <= 0)
                {
                    this.hp -= num6;
                }
            }
        }
        else
        {
            this.hp -= CS$<>8__locals1.dmg;
        }
        if (this.isSynced && CS$<>8__locals1.dmg != 0)
        {
            float ratio = (float)CS$<>8__locals1.dmg / (float)this.MaxHP;
            Card c = (this.parent is Chara) ? (this.parent as Chara) : this;
            ActEffect.TryDelay(delegate
            {
                c.PlayEffect("blood", true, 0f, default(Vector3)).SetParticleColor(EClass.Colors.matColors[CS$<>8__locals1.<>4__this.material.alias].main).Emit(20 + (int)(30f * ratio));
                if (EClass.core.config.test.showNumbers || CS$<>8__locals1.<>4__this.isThing)
                {
                    Popper popper = EClass.scene.popper.Pop(CS$<>8__locals1.<>4__this.renderer.PositionCenter(), "DamageNum");
                    Color color = c.IsPC ? EClass.Colors.textColors.damagePC : (c.IsPCFaction ? EClass.Colors.textColors.damagePCParty : EClass.Colors.textColors.damage);
                    if (CS$<>8__locals1.e != Element.Void)
                    {
                        color = EClass.Colors.elementColors.TryGetValue(CS$<>8__locals1.e.source.alias, default(Color));
                        float num13 = (color.r + color.g + color.b) / 3f;
                        num13 = ((num13 > 0.5f) ? 0f : (0.6f - num13));
                        color = new Color(color.r + num13, color.g + num13, color.b + num13, 1f);
                    }
                    popper.SetText(CS$<>8__locals1.dmg.ToString() ?? "", color);
                }
            });
        }
        ZoneInstanceBout zoneInstanceBout = EClass._zone.instance as ZoneInstanceBout;
        if (this.hp < 0)
        {
            if (this.isRestrained && this.IsPCFaction && EClass._zone.IsPCFaction && (!this.IsPC || (this.Chara.ai is AI_Torture && this.Chara.ai.IsRunning)))
            {
                CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                if (this.Chara.stamina.value > 0 && (EClass.rnd(2) == 0 || !this.IsPC))
                {
                    this.Chara.stamina.Mod(-1);
                }
            }
            else if (this.IsInstalled && this.pos.HasBlock && this.trait.IsDoor)
            {
                CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
            }
            else if (!this.trait.CanBeDestroyed)
            {
                CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
            }
            else if (this.HasEditorTag(EditorTag.Invulnerable) || (this.HasEditorTag(EditorTag.InvulnerableToMobs) && (CS$<>8__locals1.origin == null || !CS$<>8__locals1.origin.IsPCParty)))
            {
                CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
            }
            else if (this.isChara)
            {
                if (this.Chara.HasCondition<ConInvulnerable>())
                {
                    CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                }
                else if (this.IsPC && EClass.debug.godMode)
                {
                    CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                }
                else if (this.Chara.host != null)
                {
                    CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                }
                else if (zoneInstanceBout != null && LayerDrama.Instance)
                {
                    CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                }
                else if (LayerDrama.IsActive() && this.IsPC)
                {
                    CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                }
                else
                {
                    if (attackSource != AttackSource.Finish && this.IsPCParty && this.Chara.host == null && EClass.pc.ai is GoalAutoCombat)
                    {
                        if (!EClass.player.invlunerable && (EClass.pc.ai as GoalAutoCombat).listHealthy.Contains(this.Chara))
                        {
                            Msg.Say(this.IsPC ? "abort_damage" : "abort_damgeAlly");
                            EClass.player.invlunerable = true;
                            EClass.player.TryAbortAutoCombat();
                            EClass.pc.stamina.Mod(-EClass.pc.stamina.max / 5);
                        }
                        if (EClass.player.invlunerable)
                        {
                            CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                            goto IL_973;
                        }
                    }
                    if (this.IsPC && this.Evalue(1220) > 0 && this.Chara.stamina.value >= this.Chara.stamina.max / 2)
                    {
                        this.Chara.stamina.Mod(-this.Chara.stamina.max / 2);
                        this.Chara.AddCondition<ConInvulnerable>(100, false);
                        CS$<>8__locals1.<DamageHP>g__EvadeDeath|1();
                    }
                }
            }
        }
        IL_973:
        if (this.trait.CanBeAttacked)
        {
            this.renderer.PlayAnime(AnimeID.HitObj, default(Vector3), false);
            this.hp = this.MaxHP;
        }
        if (this.hp < 0)
        {
            if ((attackSource == AttackSource.Melee || attackSource == AttackSource.Range) && CS$<>8__locals1.origin != null && (CS$<>8__locals1.origin.isSynced || this.IsPC))
            {
                string text = "";
                if (this.IsPC && Lang.setting.combatTextStyle == 0)
                {
                    if (CS$<>8__locals1.e != Element.Void && CS$<>8__locals1.e != null)
                    {
                        text = "dead_" + CS$<>8__locals1.e.source.alias;
                    }
                    if (text == "" || !LangGame.Has(text))
                    {
                        text = "dead_attack";
                    }
                    EClass.pc.Say(text, this, "", null);
                }
                else
                {
                    if (CS$<>8__locals1.e != Element.Void && CS$<>8__locals1.e != null)
                    {
                        text = "kill_" + CS$<>8__locals1.e.source.alias;
                    }
                    if (text == "" || !LangGame.Has(text))
                    {
                        text = "kill_attack";
                    }
                    (this.IsPC ? EClass.pc : CS$<>8__locals1.origin).Say(text, CS$<>8__locals1.origin, this, null, null);
                }
            }
            if (this.isChara)
            {
                if (this.HasElement(1410, 1) && !this.Chara.HasCooldown(1410))
                {
                    this.Chara.AddCooldown(1410, 0);
                    this.Say("reboot", this, null, null);
                    this.PlaySound("reboot", 1f, true);
                    this.Chara.Cure(CureType.Boss, 100, BlessedState.Normal);
                    this.hp = this.MaxHP / 3;
                    this.Chara.AddCondition<ConInvulnerable>(100, false);
                    return;
                }
                foreach (Chara chara3 in EClass._map.charas)
                {
                    if (this.Chara.IsFriendOrAbove(chara3) && chara3.HasElement(1408, 1) && chara3.faith == EClass.game.religions.Healing && EClass.world.date.GetRawDay() != chara3.GetInt(58, null) && (!chara3.IsPCFaction || this.IsPCFaction))
                    {
                        Msg.alwaysVisible = true;
                        Msg.Say("layhand", chara3, this, null, null);
                        Msg.Say("pray_heal", this, null, null, null);
                        this.hp = this.MaxHP;
                        this.Chara.AddCondition<ConInvulnerable>(100, false);
                        this.PlayEffect("revive", true, 0f, default(Vector3));
                        this.PlaySound("revive", 1f, true);
                        chara3.SetInt(58, EClass.world.date.GetRawDay());
                        return;
                    }
                }
            }
            if (zoneInstanceBout != null)
            {
                Chara chara4 = EClass._map.FindChara(zoneInstanceBout.uidTarget);
                if (chara4 != null)
                {
                    if (this.IsPC)
                    {
                        EClass.pc.hp = 0;
                        chara4.ShowDialog("_chara", "bout_lose", "");
                        return;
                    }
                    if (chara4 == this)
                    {
                        this.hp = 0;
                        chara4.ModAffinity(EClass.pc, 10, true);
                        chara4.ShowDialog("_chara", "bout_win", "");
                        return;
                    }
                }
            }
            if (!this.isDestroyed)
            {
                this.Die(CS$<>8__locals1.e, CS$<>8__locals1.origin, attackSource);
            }
            if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.isChara)
            {
                if (CS$<>8__locals1.origin.IsPCFactionOrMinion && this.isChara && !this.isCopy)
                {
                    EClass.player.stats.kills++;
                    EClass.game.quests.list.ForeachReverse(delegate(Quest q)
                    {
                        q.OnKillChara(CS$<>8__locals1.<>4__this.Chara);
                    });
                    EClass.player.codex.AddKill(this.id);
                    if (this.rarity >= Rarity.Legendary && this.Chara.OriginalHostility == Hostility.Enemy)
                    {
                        Guild.Fighter.AddContribution(5 + this.LV / 5);
                        if (Guild.Fighter.relation.rank >= 4 && this.uid % 2 == 0)
                        {
                            int a = EClass.rndHalf(200 + this.LV * 20);
                            Msg.Say("bounty", this.Chara, a.ToString() ?? "", null, null);
                            EClass.pc.ModCurrency(a, "money");
                            SE.Pay();
                        }
                    }
                }
                if (CS$<>8__locals1.origin.IsPCParty && EClass.pc.Evalue(1355) > 0)
                {
                    ConStrife conStrife = (EClass.pc.AddCondition<ConStrife>(100, false) as ConStrife) ?? EClass.pc.GetCondition<ConStrife>();
                    if (conStrife != null)
                    {
                        conStrife.AddKill();
                    }
                }
                if (CS$<>8__locals1.origin.GetInt(106, null) == 0)
                {
                    CS$<>8__locals1.origin.Chara.TalkTopic("kill");
                }
            }
            Msg.SetColor();
        }
        else if ((attackSource == AttackSource.Melee || attackSource == AttackSource.Range) && CS$<>8__locals1.origin != null)
        {
            (this.IsPC ? EClass.pc : CS$<>8__locals1.origin).Say("dmgMelee" + num5.ToString() + (this.IsPC ? "pc" : ""), CS$<>8__locals1.origin, this, null, null);
        }
        else if (this.isChara)
        {
            int num7 = (attackSource == AttackSource.Condition || attackSource == AttackSource.WeaponEnchant) ? 2 : 1;
            if (num5 >= num7)
            {
                if (CS$<>8__locals1.e != Element.Void)
                {
                    this.Say("dmg_" + CS$<>8__locals1.e.source.alias, this, null, null);
                }
                if (CS$<>8__locals1.e == Element.Void || num5 >= 2)
                {
                    this.Say("dmg" + num5.ToString(), this, null, null);
                }
            }
        }
        if (this.isChara && CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.IsAliveInCurrentZone && CS$<>8__locals1.origin.isChara)
        {
            if (CS$<>8__locals1.e.id == 916)
            {
                CS$<>8__locals1.origin.HealHP(Mathf.Clamp(EClass.rnd(CS$<>8__locals1.dmg * (50 + eleP) / 500 + 5), 1, CS$<>8__locals1.origin.MaxHP / 5 + EClass.rnd(10)), HealSource.None);
            }
            if ((attackSource == AttackSource.Melee || attackSource == AttackSource.Range) && CS$<>8__locals1.origin.Dist(this) <= 1)
            {
                if (attackSource == AttackSource.Melee && this.HasElement(1221, 1))
                {
                    int ele2 = (this.Chara.MainElement == Element.Void) ? 924 : this.Chara.MainElement.id;
                    this.Say("reflect_thorne", this, CS$<>8__locals1.origin, null, null);
                    CS$<>8__locals1.origin.DamageHP(Mathf.Clamp(CS$<>8__locals1.dmg / 20, 1, this.MaxHP / 20), ele2, this.Power, AttackSource.Condition, null, true);
                }
                if (this.HasElement(1223, 1))
                {
                    int ele3 = (this.Chara.MainElement == Element.Void) ? 923 : this.Chara.MainElement.id;
                    this.Say("reflect_acid", this, CS$<>8__locals1.origin, null, null);
                    CS$<>8__locals1.origin.DamageHP(Mathf.Clamp(CS$<>8__locals1.dmg / 20, 1, this.MaxHP / 20), ele3, this.Power * 2, AttackSource.Condition, null, true);
                }
            }
            if (CS$<>8__locals1.origin.HasElement(662, 1) && attackSource == AttackSource.Melee && CS$<>8__locals1.origin.isChara && this.Chara.IsHostile(CS$<>8__locals1.origin as Chara))
            {
                int num8 = EClass.rnd(3 + Mathf.Clamp(CS$<>8__locals1.dmg / 100, 0, CS$<>8__locals1.origin.Evalue(662) / 10));
                CS$<>8__locals1.origin.Chara.stamina.Mod(num8);
                if (this.IsAliveInCurrentZone)
                {
                    this.Chara.stamina.Mod(-num8);
                }
            }
            if (CS$<>8__locals1.origin.HasElement(1350, 1) && attackSource == AttackSource.Melee)
            {
                int num9 = EClass.rndHalf(2 + Mathf.Clamp(CS$<>8__locals1.dmg / 10, 0, CS$<>8__locals1.origin.Chara.GetPietyValue() + 10));
                CS$<>8__locals1.origin.Chara.mana.Mod(num9);
                if (this.IsAliveInCurrentZone)
                {
                    this.Chara.mana.Mod(-num9);
                }
            }
            if (CS$<>8__locals1.origin.HasElement(661, 1) && attackSource == AttackSource.Melee)
            {
                int num10 = EClass.rnd(2 + Mathf.Clamp(CS$<>8__locals1.dmg / 10, 0, CS$<>8__locals1.origin.Evalue(661) + 10));
                CS$<>8__locals1.origin.Chara.mana.Mod(num10);
                if (this.IsAliveInCurrentZone)
                {
                    this.Chara.mana.Mod(-num10);
                }
            }
        }
        if (this.hp < 0)
        {
            return;
        }
        if (!this.isChara)
        {
            return;
        }
        if (CS$<>8__locals1.dmg > 0)
        {
            int a2 = 100 * (CS$<>8__locals1.dmg * 100 / this.MaxHP) / 100;
            a2 = Mathf.Min(a2, this.Chara.isRestrained ? 15 : 200);
            this.elements.ModExp(this.GetArmorSkill(), a2, false);
            if (this.Chara.body.GetAttackStyle() == AttackStyle.Shield)
            {
                this.elements.ModExp(123, a2, false);
            }
        }
        int num11 = (EClass.rnd(2) == 0) ? 1 : 0;
        if (attackSource == AttackSource.Condition)
        {
            num11 = 1 + EClass.rnd(2);
        }
        if (num11 > 0)
        {
            bool flag = this.Chara.HasCondition<ConPoison>() || ((CS$<>8__locals1.e.id == 915 || CS$<>8__locals1.e.id == 923) && this.ResistLv(this.Evalue(955)) < 4);
            this.AddBlood(num11, flag ? 6 : -1);
        }
        bool flag2 = true;
        switch (CS$<>8__locals1.e.id)
        {
        case 910:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
            {
                this.Chara.AddCondition<ConBurning>(eleP, false);
            }
            break;
        case 911:
            if (this.Chara.isWet)
            {
                if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 10, 100))
                {
                    this.Chara.AddCondition<ConFreeze>(eleP, false);
                }
            }
            else if (CS$<>8__locals1.<DamageHP>g__Chance|3(50 + eleP / 10, 100))
            {
                this.Chara.AddCondition<ConWet>(eleP, false);
            }
            break;
        case 912:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(75 + eleP / 20, 100) && EClass.rnd(3) == 0)
            {
                this.Chara.AddCondition<ConParalyze>(1, true);
            }
            break;
        case 913:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
            {
                this.Chara.AddCondition<ConBlind>(eleP, false);
            }
            break;
        case 914:
            flag2 = false;
            if (EClass.rnd(3) != 0)
            {
                if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
                {
                    this.Chara.AddCondition<ConConfuse>(eleP, false);
                }
            }
            else if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
            {
                this.Chara.AddCondition<ConSleep>(eleP, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(50, 100))
            {
                this.Chara.SAN.Mod(EClass.rnd(2));
            }
            break;
        case 915:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
            {
                this.Chara.AddCondition<ConPoison>(eleP, false);
            }
            break;
        case 917:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(50 + eleP / 10, 100))
            {
                this.Chara.AddCondition<ConDim>(eleP, false);
            }
            break;
        case 918:
            flag2 = false;
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
            {
                this.Chara.AddCondition<ConParalyze>(eleP, false);
            }
            break;
        case 920:
            flag2 = false;
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConBlind>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConParalyze>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConConfuse>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConPoison>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConSleep>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(5 + eleP / 25, 40))
            {
                this.Chara.AddCondition<ConDim>(eleP / 2, false);
            }
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 10, 100))
            {
                this.Chara.SAN.Mod(EClass.rnd(2));
            }
            break;
        case 922:
            this.Chara.ModCorruption(EClass.rnd(eleP / 50 + 10));
            break;
        case 923:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(50 + eleP / 10, 100) && EClass.rnd(4) == 0)
            {
                ActEffect.Proc(EffectId.Acid, this.Chara, null, 100, default(ActRef));
            }
            break;
        case 924:
            if (CS$<>8__locals1.<DamageHP>g__Chance|3(50 + eleP / 10, 100))
            {
                this.Chara.AddCondition<ConBleed>(eleP, false);
            }
            break;
        case 925:
            if (EClass.rnd(3) == 0)
            {
                if (CS$<>8__locals1.<DamageHP>g__Chance|3(30 + eleP / 5, 100))
                {
                    this.Chara.AddCondition<ConDim>(eleP, false);
                }
            }
            else if (EClass.rnd(2) == 0)
            {
                if (EClass.rnd(3) == 0)
                {
                    this.Chara.AddCondition<ConParalyze>(1, true);
                }
            }
            else if (EClass.rnd(2) == 0)
            {
                this.Chara.AddCondition<ConConfuse>(1 + EClass.rnd(3), true);
            }
            break;
        }
        if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.HasElement(1411, 1) && !this.Chara.HasCondition<ConGravity>())
        {
            Condition.ignoreEffect = true;
            this.Chara.AddCondition<ConGravity>(2000, false);
            Condition.ignoreEffect = false;
        }
        if (this.Chara.conSleep != null && flag2)
        {
            this.Chara.conSleep.Kill(false);
        }
        if (this.Chara.host != null && this.hp == 0 && !this.Chara.HasCondition<ConFaint>())
        {
            this.Chara.AddCondition<ConFaint>(200, true);
        }
        if (this.IsPC)
        {
            float num12 = (float)this.hp / (float)this.MaxHP;
            if (this.Evalue(1421) > 0)
            {
                num12 = (float)this.Chara.mana.value / (float)this.Chara.mana.max;
            }
            if (num12 < 0.3f)
            {
                this.PlaySound("heartbeat", 1f - num12 * 2f, true);
            }
        }
        if (!this.IsPC && this.hp < this.MaxHP / 5 && this.Evalue(423) <= 0 && CS$<>8__locals1.dmg * 100 / this.MaxHP + 10 > EClass.rnd(this.IsPowerful ? 400 : 150) && !this.HasCondition<ConFear>())
        {
            this.Chara.AddCondition<ConFear>(100 + EClass.rnd(100), false);
        }
        if (this.Chara.ai.Current.CancelWhenDamaged && attackSource != AttackSource.Hunger && attackSource != AttackSource.Fatigue)
        {
            this.Chara.ai.Current.TryCancel(CS$<>8__locals1.origin);
        }
        if (this.Chara.HasCondition<ConWeapon>())
        {
            ConWeapon condition2 = this.Chara.GetCondition<ConWeapon>();
            if (CS$<>8__locals1.e.source.aliasRef == condition2.sourceElement.aliasRef)
            {
                condition2.Mod(-1, false);
            }
        }
        if (this.Chara.HasElement(1222, 1) && (CS$<>8__locals1.dmg >= this.MaxHP / 10 || EClass.rnd(20) == 0))
        {
            ActEffect.Proc(EffectId.Duplicate, this, null, 100, default(ActRef));
        }
        if (this.hp < this.MaxHP / 3 && this.HasElement(1409, 1) && !this.Chara.HasCooldown(1409))
        {
            this.Chara.AddCooldown(1409, 0);
            this.Chara.AddCondition<ConBoost>(this.Power, false);
            this.Chara.Cure(CureType.Boss, 100, BlessedState.Normal);
            this.Chara.HealHP(this.MaxHP / 2, HealSource.None);
        }
        if (CS$<>8__locals1.origin != null && CS$<>8__locals1.origin.isChara)
        {
            if (!AI_PlayMusic.ignoreDamage)
            {
                this.Chara.TrySetEnemy(CS$<>8__locals1.origin.Chara);
            }
            if (CS$<>8__locals1.origin.Evalue(428) > 0 && !this.IsPCFactionOrMinion && EClass.rnd(CS$<>8__locals1.dmg) >= EClass.rnd(this.MaxHP / 10) + this.MaxHP / 100 + 1)
            {
                CS$<>8__locals1.origin.Chara.TryNeckHunt(this.Chara, CS$<>8__locals1.origin.Evalue(428) * 20, true);
            }
        }
    }
 
    // Token: 0x0600132E RID: 4910 RVA: 0x0007D2DC File Offset: 0x0007B4DC
    public virtual void Die(Element e = null, Card origin = null, AttackSource attackSource = AttackSource.None)
    {
        Card rootCard = this.GetRootCard();
        Point _pos = ((rootCard != null) ? rootCard.pos : null) ?? this.pos;
        if (_pos != null && !_pos.IsValid)
        {
            _pos = null;
        }
        if (this.trait.EffectDead == EffectDead.Default && _pos != null)
        {
            _pos.PlaySound(this.material.GetSoundDead(this.sourceCard), true, 1f, true);
            _pos.PlayEffect("mine").SetParticleColor(this.material.GetColor()).Emit(10 + EClass.rnd(10));
            this.material.AddBlood(_pos, 6);
            if (_pos.IsSync)
            {
                string text = (rootCard != this) ? "destroyed_inv_" : "destroyed_ground_";
                if (e != null && LangGame.Has(text + e.source.alias))
                {
                    text += e.source.alias;
                }
                if (attackSource != AttackSource.Throw)
                {
                    Msg.Say(text, this, rootCard, null, null);
                }
            }
            else if (attackSource != AttackSource.Throw)
            {
                Msg.Say("destroyed", this, null, null, null);
            }
        }
        if (_pos != null)
        {
            this.things.ForeachReverse(delegate(Thing t)
            {
                if (t.trait is TraitChestMerchant)
                {
                    return;
                }
                EClass._zone.AddCard(t, _pos);
            });
        }
        this.Destroy();
        if (e != null && _pos != null && e.id == 21)
        {
            EClass._zone.AddCard(ThingGen.Create((EClass.rnd(2) == 0) ? "ash" : "ash2", -1, -1), _pos);
        }
        if (this.trait.ThrowType == ThrowType.Explosive)
        {
            this.Explode(this.pos, origin);
        }
    }
 
    // Token: 0x0600132F RID: 4911 RVA: 0x0007D4A4 File Offset: 0x0007B6A4
    public void Explode(Point p, Card origin)
    {
        ActEffect.ProcAt(EffectId.Explosive, 100, this.blessedState, this, null, p, true, new ActRef
        {
            origin = ((origin != null) ? origin.Chara : null),
            refThing = this.Thing,
            aliasEle = "eleImpact"
        });
    }
 
    // Token: 0x06001330 RID: 4912 RVA: 0x0007D4FC File Offset: 0x0007B6FC
    public void Deconstruct()
    {
        this.PlaySound(this.material.GetSoundDead(this.sourceCard), 1f, true);
        this.Destroy();
    }
 
    // Token: 0x06001331 RID: 4913 RVA: 0x0007D524 File Offset: 0x0007B724
    public void Destroy()
    {
        if (this.isDestroyed)
        {
            Debug.Log(this.Name + " is already destroyed.");
            return;
        }
        if (this.isChara)
        {
            if (this.IsPCFaction && !this.Chara.isSummon)
            {
                Debug.Log(this);
                return;
            }
            this.Chara.DropHeld(null);
            this.Chara.isDead = true;
            if (this.IsPCParty)
            {
                EClass.pc.party.RemoveMember(this.Chara);
            }
            if (this.IsGlobal)
            {
                EClass.game.cards.globalCharas.Remove(this.Chara);
            }
        }
        if (this.renderer.hasActor)
        {
            this.renderer.KillActor();
        }
        if (this.parent != null)
        {
            this.parent.RemoveCard(this);
        }
        for (int i = this.things.Count - 1; i >= 0; i--)
        {
            this.things[i].Destroy();
        }
        this.isDestroyed = true;
    }
 
    // Token: 0x06001332 RID: 4914 RVA: 0x0007D628 File Offset: 0x0007B828
    public void SpawnLoot(Card origin)
    {
        if (!this.isChara || this.IsPCFactionMinion || (this.isCopy && EClass.rnd(10) != 0))
        {
            return;
        }
        bool isUserZone = EClass._zone.IsUserZone;
        bool flag = EClass._zone is Zone_Music;
        List<Card> list = new List<Card>();
        SourceRace.Row race = this.Chara.race;
        if (!this.IsPCFaction && !isUserZone && this.sourceCard.idActor.IsEmpty())
        {
            int i = 500;
            if (this.rarity >= Rarity.Legendary)
            {
                i = ((!EClass.player.codex.DroppedCard(this.id)) ? 1 : 10);
                EClass.player.codex.MarkCardDrop(this.id);
            }
            if (this.trait is TraitAdventurerBacker)
            {
                i = 10;
            }
            if (this.<SpawnLoot>g__chance|729_0(i))
            {
                Thing thing = ThingGen.Create("figure", -1, -1);
                thing.MakeFigureFrom(this.id);
                list.Add(thing);
            }
            if (this.<SpawnLoot>g__chance|729_0(i))
            {
                Thing thing2 = ThingGen.Create("figure3", -1, -1);
                thing2.MakeFigureFrom(this.id);
                list.Add(thing2);
            }
        }
        bool flag2 = this.Chara.race.corpse[1].ToInt() > EClass.rnd(1500) || (this.Chara.IsPowerful && !this.IsPCFaction) || EClass.debug.godFood;
        if (this.Chara.race.IsAnimal && EClass.rnd(EClass._zone.IsPCFaction ? 3 : 5) == 0)
        {
            flag2 = true;
        }
        if (origin != null && origin.HasElement(290, 1))
        {
            if (!flag2 && this.Chara.race.corpse[1].ToInt() > EClass.rnd(150000 / (100 + (int)Mathf.Sqrt((float)origin.Evalue(290)) * 5)))
            {
                flag2 = true;
                origin.elements.ModExp(290, 100, false);
            }
            else
            {
                origin.elements.ModExp(290, 5, false);
            }
        }
        if (flag2 && !isUserZone)
        {
            string a = this.Chara.race.corpse[0];
            if (a == "_meat" && EClass.rnd(10) == 0)
            {
                a = "meat_marble";
            }
            Thing thing3 = ThingGen.Create(a, -1, -1);
            if (thing3.source._origin == "meat")
            {
                thing3.MakeFoodFrom(this);
            }
            else
            {
                thing3.ChangeMaterial(this.Chara.race.material);
            }
            list.Add(thing3);
        }
        if (!this.IsPCFaction && this.<SpawnLoot>g__chance|729_0(200))
        {
            list.Add(this.Chara.MakeGene(null));
        }
        if (!this.IsPCFaction && !isUserZone)
        {
            foreach (string text in this.sourceCard.loot.Concat(this.Chara.race.loot).ToList<string>())
            {
                string[] array = text.Split('/', StringSplitOptions.None);
                int num = array[1].ToInt();
                if (num >= 1000 || num > EClass.rnd(1000) || EClass.debug.godMode)
                {
                    list.Add(ThingGen.Create(array[0], -1, -1).SetNum((num >= 1000) ? (num / 1000 + ((EClass.rnd(1000) > num % 1000) ? 1 : 0)) : 1));
                }
            }
            if (race.IsMachine)
            {
                if (this.<SpawnLoot>g__chance|729_0(20))
                {
                    list.Add(ThingGen.Create("microchip", -1, -1));
                }
                if (this.<SpawnLoot>g__chance|729_0(15))
                {
                    list.Add(ThingGen.Create("battery", -1, -1));
                }
            }
            else
            {
                if (race.IsAnimal)
                {
                    if (this.<SpawnLoot>g__chance|729_0(15))
                    {
                        list.Add(ThingGen.Create("fang", -1, -1));
                    }
                    if (this.<SpawnLoot>g__chance|729_0(10))
                    {
                        list.Add(ThingGen.Create("skin", -1, -1));
                    }
                }
                if (this.<SpawnLoot>g__chance|729_0(20))
                {
                    list.Add(ThingGen.Create("offal", -1, -1));
                }
                if (this.<SpawnLoot>g__chance|729_0(20))
                {
                    list.Add(ThingGen.Create("heart", -1, -1));
                }
            }
            if (!this.isBackerContent && !flag)
            {
                int num2 = 1;
                List<Thing> list2 = new List<Thing>();
                foreach (Thing thing4 in this.things)
                {
                    if (!thing4.HasTag(CTAG.gift) && !(thing4.trait is TraitChestMerchant))
                    {
                        if (thing4.isGifted || thing4.rarity >= Rarity.Artifact)
                        {
                            list.Add(thing4);
                        }
                        else if (thing4.IsEquipmentOrRanged)
                        {
                            if (thing4.rarity >= Rarity.Legendary)
                            {
                                list2.Add(thing4);
                            }
                            else if (EClass.rnd(200) == 0)
                            {
                                list.Add(thing4);
                            }
                        }
                        else if (EClass.rnd(5) == 0)
                        {
                            list.Add(thing4);
                        }
                    }
                }
                if (num2 > 0 && list2.Count > 0)
                {
                    list2.Shuffle<Thing>();
                    int num3 = 0;
                    while (num3 < list2.Count && num3 < num2)
                    {
                        list.Add(list2[num3]);
                        num3++;
                    }
                }
            }
            if (!this.isBackerContent && this.id != "big_sister")
            {
                foreach (Thing thing5 in this.things)
                {
                    if (!thing5.HasTag(CTAG.gift) && !(thing5.trait is TraitChestMerchant))
                    {
                        if (thing5.isGifted || thing5.rarity >= Rarity.Legendary || thing5.trait.DropChance > EClass.rndf(1f))
                        {
                            list.Add(thing5);
                        }
                        else if (thing5.IsEquipmentOrRanged)
                        {
                            if (EClass.rnd(200) == 0)
                            {
                                list.Add(thing5);
                            }
                        }
                        else if (EClass.rnd(5) == 0)
                        {
                            list.Add(thing5);
                        }
                    }
                }
            }
        }
        foreach (Thing thing6 in this.things)
        {
            if (thing6.GetInt(116, null) != 0)
            {
                list.Add(thing6);
            }
        }
        Point nearestPoint = this.GetRootCard().pos;
        if (nearestPoint.IsBlocked)
        {
            nearestPoint = nearestPoint.GetNearestPoint(false, true, true, false);
        }
        foreach (Card card in list)
        {
            card.isHidden = false;
            card.SetInt(116, 0);
            EClass._zone.AddCard(card, nearestPoint);
            if (card.IsEquipmentOrRanged && card.rarity >= Rarity.Superior && !card.IsCursed)
            {
                foreach (Chara chara in EClass._map.charas)
                {
                    if (chara.HasElement(1412, 1) && chara.Dist(nearestPoint) < 3)
                    {
                        card.Thing.TryLickEnchant(chara, true, null, null);
                        break;
                    }
                }
            }
        }
    }
 
    // Token: 0x06001333 RID: 4915 RVA: 0x0007DE10 File Offset: 0x0007C010
    public Thing TryMakeRandomItem(int lv = -1)
    {
        if (lv == -1)
        {
            lv = EClass._zone.DangerLv;
        }
        string text = this.id;
        uint num = <PrivateImplementationDetails>.ComputeStringHash(text);
        if (num <= 2291038882U)
        {
            if (num <= 1062293841U)
            {
                if (num != 51003139U)
                {
                    if (num != 1062293841U)
                    {
                        goto IL_2A6;
                    }
                    if (!(text == "log"))
                    {
                        goto IL_2A6;
                    }
                    this.ChangeMaterial((from m in EClass.sources.materials.rows
                    where m.category == "wood"
                    select m).RandomItem<SourceMaterial.Row>());
                    goto IL_2A6;
                }
                else if (!(text == "egg_fertilized"))
                {
                    goto IL_2A6;
                }
            }
            else if (num != 1555468929U)
            {
                if (num != 2291038882U)
                {
                    goto IL_2A6;
                }
                if (!(text == "milk"))
                {
                    goto IL_2A6;
                }
            }
            else if (!(text == "_meat"))
            {
                goto IL_2A6;
            }
        }
        else if (num <= 3595465691U)
        {
            if (num != 2585652531U)
            {
                if (num != 3595465691U)
                {
                    goto IL_2A6;
                }
                if (!(text == "ore_gem"))
                {
                    goto IL_2A6;
                }
                this.ChangeMaterial(MATERIAL.GetRandomMaterialFromCategory(lv, "gem", this.material));
                goto IL_2A6;
            }
            else
            {
                if (!(text == "ore"))
                {
                    goto IL_2A6;
                }
                this.ChangeMaterial(MATERIAL.GetRandomMaterialFromCategory(lv, "ore", this.material));
                goto IL_2A6;
            }
        }
        else if (num != 3786258943U)
        {
            if (num != 3871660930U)
            {
                goto IL_2A6;
            }
            if (!(text == "meat_marble"))
            {
                goto IL_2A6;
            }
        }
        else if (!(text == "_egg"))
        {
            goto IL_2A6;
        }
        string text2 = "c_wilds";
        if (this.id == "_meat" || this.id == "meat_marble")
        {
            text2 = "c_animal";
        }
        int i = 0;
        while (i < 20)
        {
            CardRow cardRow = SpawnList.Get(text2, null, null).Select(lv, -1);
            if (!(cardRow.model.Chara.race.corpse[0] != "_meat") || !(this.id != "milk") || !(this.id != "_egg") || !(this.id != "egg_fertilized"))
            {
                if (!(this.id == "milk"))
                {
                    this.MakeFoodFrom(cardRow.model);
                    break;
                }
                if (this.c_idRefCard.IsEmpty())
                {
                    this.MakeRefFrom(cardRow.model, null);
                    break;
                }
                break;
            }
            else
            {
                i++;
            }
        }
        IL_2A6:
        return this as Thing;
    }
 
    // Token: 0x06001334 RID: 4916 RVA: 0x0007E0C9 File Offset: 0x0007C2C9
    public Card MakeFoodFrom(string _id)
    {
        return this.MakeFoodFrom(EClass.sources.cards.map[_id].model);
    }
 
    // Token: 0x06001335 RID: 4917 RVA: 0x0007E0EC File Offset: 0x0007C2EC
    public Card MakeFoodFrom(Card c)
    {
        this.MakeRefFrom(c, null);
        this.ChangeMaterial(c.material);
        SourceRace.Row race = c.Chara.race;
        int num = race.food[0].ToInt();
        bool flag = this.id == "meat_marble";
        int num2 = 1;
        bool flag2 = this.category.IsChildOf("meat");
        bool flag3 = this.category.IsChildOf("egg");
        if (flag)
        {
            num += 100;
        }
        if (flag2)
        {
            this.elements.SetBase(70, race.STR * race.STR / 5 * num / 100 - 10 + num / 10, 0);
            if (flag)
            {
                this.elements.SetBase(440, race.END * race.END / 5 * num / 100 - 10 + num / 10, 0);
            }
            this.elements.SetBase(71, (int)Mathf.Clamp((float)(num / 10) + Mathf.Sqrt((float)race.height) - 10f, 1f, 60f), 0);
        }
        else if (flag3)
        {
            this.elements.SetBase(444, race.LER * race.LER / 5 * num / 100 - 10 + num / 10, 0);
            num2 = 2;
        }
        else
        {
            num2 = 3;
        }
        foreach (Element element in c.elements.dict.Values)
        {
            if ((!flag3 || element.id != 1229) && (element.source.category == "food" || element.source.tag.Contains("foodEnc") || element.IsTrait))
            {
                this.elements.SetBase(element.id, element.Value, 0);
            }
        }
        List<Tuple<int, int>> list = new List<Tuple<int, int>>();
        foreach (KeyValuePair<int, int> keyValuePair in race.elementMap)
        {
            if (EClass.sources.elements.map[keyValuePair.Key].tag.Contains("primary"))
            {
                list.Add(new Tuple<int, int>(keyValuePair.Key, keyValuePair.Value));
            }
        }
        list.Sort((Tuple<int, int> a, Tuple<int, int> b) => b.Item2 - a.Item2);
        int num3 = 0;
        while (num3 < num2 && num3 < list.Count)
        {
            Tuple<int, int> tuple = list[num3];
            this.elements.SetBase(tuple.Item1, tuple.Item2 * tuple.Item2 / 4, 0);
            num3++;
        }
        if (race.IsUndead)
        {
            this.elements.ModBase(73, -20);
        }
        this.isWeightChanged = true;
        this.c_weight = race.height * 4 + 100;
        this.SetBlessedState(BlessedState.Normal);
        int num4 = c.LV - c.sourceCard.LV;
        if (num4 < 0)
        {
            num4 = 0;
        }
        num4 = EClass.curve(num4, 10, 10, 80);
        if (c.rarity >= Rarity.Legendary || c.IsUnique)
        {
            num4 += 60;
        }
        if (num4 > 0)
        {
            this.elements.ModBase(2, num4);
        }
        return this;
    }
 
    // Token: 0x06001336 RID: 4918 RVA: 0x0007E478 File Offset: 0x0007C678
    public void MakeFoodRef(Card c1, Card c2 = null)
    {
        Card card = c1;
        Card card2 = c2;
        if (Card.<MakeFoodRef>g__IsIgnoreName|733_0(card))
        {
            card = null;
        }
        if (Card.<MakeFoodRef>g__IsIgnoreName|733_0(card2))
        {
            card2 = null;
        }
        if (card == null && card2 != null)
        {
            card = card2;
            card2 = null;
        }
        if (card != null)
        {
            this.MakeRefFrom(card, card2);
            if (card.c_idRefCard != null)
            {
                this.c_idRefCard = card.c_idRefCard;
                this.c_altName = this.TryGetFoodName(card);
            }
            if (card2 != null && card2.c_idRefCard != null)
            {
                this.c_idRefCard2 = card2.c_idRefCard;
                this.c_altName2 = this.TryGetFoodName(card2);
            }
        }
    }
 
    // Token: 0x06001337 RID: 4919 RVA: 0x0007E4F8 File Offset: 0x0007C6F8
    public string TryGetFoodName(Card c)
    {
        if (c.c_idRefCard.IsEmpty())
        {
            return c.c_altName;
        }
        SourceChara.Row row = EClass.sources.cards.map[c.c_idRefCard] as SourceChara.Row;
        if (row == null || !row.isChara)
        {
            return c.c_altName;
        }
        if (!row.aka.IsEmpty())
        {
            if (row.name == "*r" && row.aka == "*r")
            {
                return "corpseGeneral".lang();
            }
            if (row.name == "*r")
            {
                return row.GetText("aka", false);
            }
        }
        return row.GetName();
    }
 
    // Token: 0x06001338 RID: 4920 RVA: 0x0007E5AC File Offset: 0x0007C7AC
    public string GetFoodName(string s)
    {
        return s.Replace("_corpseFrom".lang(), "_corpseTo".lang());
    }
 
    // Token: 0x06001339 RID: 4921 RVA: 0x0007E5C8 File Offset: 0x0007C7C8
    public void MakeFigureFrom(string id)
    {
        this.MakeRefFrom(id);
    }
 
    // Token: 0x0600133A RID: 4922 RVA: 0x0007E5D1 File Offset: 0x0007C7D1
    public void MakeRefFrom(string id)
    {
        this.c_idRefCard = id;
    }
 
    // Token: 0x0600133B RID: 4923 RVA: 0x0007E5DC File Offset: 0x0007C7DC
    public void MakeRefFrom(Card c1, Card c2 = null)
    {
        this.c_idRefCard = c1.id;
        this.c_altName = (c1.IsPC ? c1.c_altName : c1.GetName(NameStyle.Ref, c1.isChara ? 0 : 1));
        if (c2 != null)
        {
            this.c_idRefCard2 = c2.id;
            this.c_altName2 = (c2.IsPC ? c2.c_altName : c2.GetName(NameStyle.Ref, c2.isChara ? 0 : 1));
        }
    }
 
    // Token: 0x0600133C RID: 4924 RVA: 0x0007E656 File Offset: 0x0007C856
    public void SetHidden(bool hide = true)
    {
        this.isHidden = hide;
        this.pos.cell.Refresh();
    }
 
    // Token: 0x0600133D RID: 4925 RVA: 0x0007E66F File Offset: 0x0007C86F
    public virtual Card.MoveResult _Move(Point p, Card.MoveType type = Card.MoveType.Walk)
    {
        EClass._map.MoveCard(p, this);
        if (this.isChara)
        {
            this.Chara.SyncRide();
        }
        return Card.MoveResult.Success;
    }
 
    // Token: 0x0600133E RID: 4926 RVA: 0x0007E694 File Offset: 0x0007C894
    public unsafe void MoveImmediate(Point p, bool focus = true, bool cancelAI = true)
    {
        if (p == null)
        {
            return;
        }
        EClass._map.MoveCard(p, this);
        if (!this.IsPC || focus)
        {
            this.renderer.SetFirst(true, *p.PositionCenter());
        }
        if (this.isChara)
        {
            if (cancelAI)
            {
                this.Chara.ai.Cancel();
            }
            this.Chara.SyncRide();
        }
        if (this.IsPC && focus)
        {
            EClass.screen.FocusPC();
            EClass.screen.RefreshPosition();
        }
    }
 
    // Token: 0x0600133F RID: 4927 RVA: 0x0007E71C File Offset: 0x0007C91C
    public unsafe void Teleport(Point point, bool silent = false, bool force = false)
    {
        if (EClass._zone.IsRegion)
        {
            this.SayNothingHappans();
            return;
        }
        this.PlayEffect("teleport", true, 0f, default(Vector3));
        if (!force && (this.elements.Has(400) || (this.isChara && this.Chara.HasCondition<ConGravity>())))
        {
            this.Say("antiTeleport", this, null, null);
            this.PlaySound("gravity", 1f, true);
            return;
        }
        if (!silent)
        {
            this.PlaySound("teleport", 1f, true);
            this.Say("teleported", this, null, null);
        }
        this._Move(point, Card.MoveType.Walk);
        this.renderer.SetFirst(true, *this.pos.PositionCenter());
        if (this.isChara)
        {
            this.Chara.ai.Cancel();
            foreach (Chara chara in EClass._map.charas)
            {
                if (chara.enemy == this)
                {
                    chara.SetEnemy(null);
                }
            }
            this.Chara.RemoveCondition<ConEntangle>();
        }
        if (this.IsPC)
        {
            EClass.screen.FocusPC();
            EClass.screen.RefreshPosition();
            EClass.player.haltMove = true;
        }
        this.PlayEffect("teleport", false, 0f, default(Vector3));
    }
 
    // Token: 0x06001340 RID: 4928 RVA: 0x0007E8A4 File Offset: 0x0007CAA4
    public virtual void OnLand()
    {
        if (this.Cell.IsTopWaterAndNoSnow)
        {
            this.PlayEffect("ripple", true, 0f, default(Vector3));
            this.PlaySound("Footstep/water", 1f, true);
        }
    }
 
    // Token: 0x06001341 RID: 4929 RVA: 0x0007E8EB File Offset: 0x0007CAEB
    public int ResistLvFrom(int ele)
    {
        return this.ResistLv(EClass.sources.elements.alias[EClass.sources.elements.map[ele].aliasRef].id);
    }
 
    // Token: 0x06001342 RID: 4930 RVA: 0x0007E926 File Offset: 0x0007CB26
    public int ResistLv(int res)
    {
        return Element.GetResistLv(this.Evalue(res));
    }
 
    // Token: 0x06001343 RID: 4931 RVA: 0x0007E934 File Offset: 0x0007CB34
    public bool HasElement(int ele, int req = 1)
    {
        return this.elements.Value(ele) >= req;
    }
 
    // Token: 0x06001344 RID: 4932 RVA: 0x0007E948 File Offset: 0x0007CB48
    public bool HasElement(string id, int req = 1)
    {
        return this.HasElement(EClass.sources.elements.alias[id].id, req);
    }
 
    // Token: 0x06001345 RID: 4933 RVA: 0x0007E96B File Offset: 0x0007CB6B
    public virtual CardRenderer _CreateRenderer()
    {
        this.renderer = new CardRenderer();
        this.renderer.SetOwner(this);
        return this.renderer;
    }
 
    // Token: 0x06001346 RID: 4934 RVA: 0x0007E98C File Offset: 0x0007CB8C
    public void AddBlood(int a = 1, int id = -1)
    {
        if (EClass._zone.IsRegion)
        {
            return;
        }
        for (int i = 0; i < a; i++)
        {
            EClass._map.AddDecal(this.pos.x + ((EClass.rnd(2) == 0) ? 0 : (EClass.rnd(3) - 1)), this.pos.z + ((EClass.rnd(2) == 0) ? 0 : (EClass.rnd(3) - 1)), (id == -1) ? (this.isChara ? this.Chara.race.blood : this.material.decal) : id, 1, true);
        }
        this.PlaySound("blood", 1f, true);
    }
 
    // Token: 0x06001347 RID: 4935 RVA: 0x0007EA3C File Offset: 0x0007CC3C
    public RenderParam GetRenderParam()
    {
        RenderParam shared = RenderParam.shared;
        shared.color = 11010048f;
        shared.liquidLv = 0;
        shared.cell = null;
        this.SetRenderParam(shared);
        return shared;
    }
 
    // Token: 0x06001348 RID: 4936 RVA: 0x0007EA70 File Offset: 0x0007CC70
    public virtual void SetRenderParam(RenderParam p)
    {
    }
 
    // Token: 0x06001349 RID: 4937 RVA: 0x0007EA72 File Offset: 0x0007CC72
    public void DyeRandom()
    {
        this.Dye(EClass.sources.materials.rows.RandomItem<SourceMaterial.Row>().alias);
    }
 
    // Token: 0x0600134A RID: 4938 RVA: 0x0007EA93 File Offset: 0x0007CC93
    public void Dye(string idMat)
    {
        this.Dye(EClass.sources.materials.alias[idMat]);
    }
 
    // Token: 0x0600134B RID: 4939 RVA: 0x0007EAB0 File Offset: 0x0007CCB0
    public void Dye(SourceMaterial.Row mat)
    {
        this.isDyed = true;
        this.c_dyeMat = mat.id;
        this._colorInt = 0;
    }
 
    // Token: 0x0600134C RID: 4940 RVA: 0x0007EACC File Offset: 0x0007CCCC
    public void RefreshColor()
    {
        if (this.isChara)
        {
            if (this.isDyed)
            {
                this._colorInt = BaseTileMap.GetColorInt(ref this.DyeMat.matColor, this.sourceRenderCard.colorMod);
                return;
            }
            if (this.isElemental)
            {
                this._colorInt = BaseTileMap.GetColorInt(ref EClass.setting.elements[this.Chara.MainElement.source.alias].colorSprite, this.sourceRenderCard.colorMod);
                return;
            }
            this._colorInt = 104025;
            return;
        }
        else
        {
            if (this.isDyed)
            {
                this._colorInt = BaseTileMap.GetColorInt(ref this.DyeMat.matColor, this.sourceRenderCard.colorMod);
                return;
            }
            if (this.sourceRenderCard.useRandomColor)
            {
                this._colorInt = BaseTileMap.GetColorInt(this.GetRandomColor(), this.sourceRenderCard.colorMod);
                return;
            }
            if (this.sourceRenderCard.useAltColor)
            {
                this._colorInt = BaseTileMap.GetColorInt(ref this.material.altColor, this.sourceRenderCard.colorMod);
                return;
            }
            this._colorInt = BaseTileMap.GetColorInt(ref this.material.matColor, this.sourceRenderCard.colorMod);
            return;
        }
    }
 
    // Token: 0x0600134D RID: 4941 RVA: 0x0007EC04 File Offset: 0x0007CE04
    public ref Color GetRandomColor()
    {
        Rand.UseSeed(EClass.game.seed + this.sourceCard._index + this.refVal, delegate
        {
            Card._randColor = EClass.sources.materials.rows.RandomItem<SourceMaterial.Row>().matColor;
        });
        return ref Card._randColor;
    }
 
    // Token: 0x0600134E RID: 4942 RVA: 0x0007EC58 File Offset: 0x0007CE58
    public virtual Sprite GetSprite(int dir = 0)
    {
        if (this.trait is TraitAbility)
        {
            Act act = (this.trait as TraitAbility).CreateAct();
            return ((act != null) ? act.GetSprite() : null) ?? EClass.core.refs.icons.defaultAbility;
        }
        return this.sourceCard.GetSprite(dir, this.idSkin, this.IsInstalled && this.pos.cell.IsSnowTile);
    }
 
    // Token: 0x0600134F RID: 4943 RVA: 0x0007ECD7 File Offset: 0x0007CED7
    public virtual Sprite GetImageSprite()
    {
        return null;
    }
 
    // Token: 0x06001350 RID: 4944 RVA: 0x0007ECDA File Offset: 0x0007CEDA
    public void SetImage(Image image, int dir, int idSkin = 0)
    {
        this.sourceRenderCard.SetImage(image, this.GetSprite(dir), this.colorInt, true, dir, idSkin);
    }
 
    // Token: 0x06001351 RID: 4945 RVA: 0x0007ECF8 File Offset: 0x0007CEF8
    public virtual void SetImage(Image image)
    {
        if (this.trait is TraitAbility)
        {
            (this.trait as TraitAbility).act.SetImage(image);
            return;
        }
        this.sourceRenderCard.SetImage(image, this.GetSprite(0), this.colorInt, true, 0, 0);
    }
 
    // Token: 0x06001352 RID: 4946 RVA: 0x0007ED45 File Offset: 0x0007CF45
    public void ShowEmo(Emo _emo = Emo.none, float duration = 0f, bool skipSame = true)
    {
        if (this.isChara && this.Chara.host != null)
        {
            return;
        }
        if (_emo == this.lastEmo && skipSame)
        {
            return;
        }
        if (_emo != Emo.none)
        {
            this.renderer.ShowEmo(_emo, duration);
        }
        this.lastEmo = _emo;
    }
 
    // Token: 0x1700058F RID: 1423
    // (get) Token: 0x06001353 RID: 4947 RVA: 0x0007ED82 File Offset: 0x0007CF82
    public Point ThisOrParentPos
    {
        get
        {
            if (!(this.parent is Card))
            {
                return this.pos;
            }
            return (this.parent as Card).pos;
        }
    }
 
    // Token: 0x06001354 RID: 4948 RVA: 0x0007EDA8 File Offset: 0x0007CFA8
    public void PlaySoundHold(bool spatial = true)
    {
        this.PlaySound(this.material.GetSoundDrop(this.sourceCard), 1f, spatial);
    }
 
    // Token: 0x06001355 RID: 4949 RVA: 0x0007EDC8 File Offset: 0x0007CFC8
    public void PlaySoundDrop(bool spatial = true)
    {
        this.PlaySound(this.material.GetSoundDrop(this.sourceCard), 1f, spatial);
    }
 
    // Token: 0x06001356 RID: 4950 RVA: 0x0007EDE8 File Offset: 0x0007CFE8
    public SoundSource PlaySound(string id, float v = 1f, bool spatial = true)
    {
        if (this.IsPC)
        {
            spatial = false;
        }
        if (this.Dist(EClass.pc) < EClass.player.lightRadius + 1 || !spatial)
        {
            return this.ThisOrParentPos.PlaySound(id, this.isSynced || !spatial, v, spatial);
        }
        return null;
    }
 
    // Token: 0x06001357 RID: 4951 RVA: 0x0007EE3B File Offset: 0x0007D03B
    public void KillAnime()
    {
        this.renderer.KillAnime();
    }
 
    // Token: 0x06001358 RID: 4952 RVA: 0x0007EE48 File Offset: 0x0007D048
    public void PlayAnime(AnimeID id, bool force = false)
    {
        this.renderer.PlayAnime(id, force);
    }
 
    // Token: 0x06001359 RID: 4953 RVA: 0x0007EE57 File Offset: 0x0007D057
    public void PlayAnime(AnimeID id, Point dest, bool force = false)
    {
        this.renderer.PlayAnime(id, dest);
    }
 
    // Token: 0x0600135A RID: 4954 RVA: 0x0007EE68 File Offset: 0x0007D068
    public void PlayAnimeLoot()
    {
        this.renderer.PlayAnime(AnimeID.Loot, default(Vector3), false);
    }
 
    // Token: 0x0600135B RID: 4955 RVA: 0x0007EE8C File Offset: 0x0007D08C
    public unsafe Effect PlayEffect(string id, bool useRenderPos = true, float range = 0f, Vector3 fix = default(Vector3))
    {
        if (id.IsEmpty())
        {
            return null;
        }
        return Effect.Get(id)._Play(this.pos, fix + ((this.isSynced && useRenderPos) ? this.renderer.position : (*this.pos.Position())) + new Vector3(Rand.Range(-range, range), Rand.Range(-range, range), 0f), 0f, null, null);
    }
 
    // Token: 0x0600135C RID: 4956 RVA: 0x0007EF08 File Offset: 0x0007D108
    public unsafe void PlayEffect(int ele, bool useRenderPos = true, float range = 0f)
    {
        Effect effect = Effect.Get("Element/" + EClass.sources.elements.map[ele].alias);
        if (effect == null)
        {
            Debug.Log(ele);
            return;
        }
        effect._Play(this.pos, ((this.isSynced && useRenderPos) ? this.renderer.position : (*this.pos.Position())) + new Vector3(Rand.Range(-range, range), Rand.Range(-range, range), 0f), 0f, null, null);
    }
 
    // Token: 0x0600135D RID: 4957 RVA: 0x0007EFAE File Offset: 0x0007D1AE
    public virtual void SetDir(int d)
    {
        this.dir = d;
        this.renderer.RefreshSprite();
    }
 
    // Token: 0x0600135E RID: 4958 RVA: 0x0007EFC2 File Offset: 0x0007D1C2
    public void SetRandomDir()
    {
        this.SetDir(EClass.rnd(4));
    }
 
    // Token: 0x0600135F RID: 4959 RVA: 0x0007EFD0 File Offset: 0x0007D1D0
    public virtual void LookAt(Card c)
    {
    }
 
    // Token: 0x06001360 RID: 4960 RVA: 0x0007EFD2 File Offset: 0x0007D1D2
    public virtual void LookAt(Point p)
    {
    }
 
    // Token: 0x06001361 RID: 4961 RVA: 0x0007EFD4 File Offset: 0x0007D1D4
    public virtual void Rotate(bool reverse = false)
    {
        int num = 4;
        if (this.sourceCard.tiles.Length > 4)
        {
            num = this.sourceCard.tiles.Length;
        }
        if (this.TileType == TileType.Door)
        {
            num = 2;
        }
        if (reverse)
        {
            int dir = this.dir;
            this.dir = dir - 1;
        }
        else
        {
            int dir = this.dir;
            this.dir = dir + 1;
        }
        if (this.dir < 0)
        {
            this.dir = num - 1;
        }
        if (this.dir == num)
        {
            this.dir = 0;
        }
        this.SetDir(this.dir);
        this.renderer.RefreshSprite();
    }
 
    // Token: 0x06001362 RID: 4962 RVA: 0x0007F070 File Offset: 0x0007D270
    public void ChangeAltitude(int a)
    {
        this.altitude += a;
        if (this.altitude < 0)
        {
            this.altitude = 0;
        }
        if (this.altitude > this.TileType.MaxAltitude)
        {
            this.altitude = this.TileType.MaxAltitude;
        }
    }
 
    // Token: 0x06001363 RID: 4963 RVA: 0x0007F0BF File Offset: 0x0007D2BF
    public virtual SubPassData GetSubPassData()
    {
        return SubPassData.Default;
    }
 
    // Token: 0x06001364 RID: 4964 RVA: 0x0007F0C8 File Offset: 0x0007D2C8
    public unsafe void SetFreePos(Point point)
    {
        this.freePos = (EClass.game.config.FreePos && this.isThing && this.TileType.FreeStyle && !this.sourceCard.multisize && !EClass.scene.actionMode.IsRoofEditMode(this));
        if (this.freePos)
        {
            Vector3 vector = *point.Position();
            Vector3 thingPosition = EClass.screen.tileMap.GetThingPosition(this, point);
            this.fx = EInput.mposWorld.x + EClass.setting.render.freePosFix.x;
            this.fy = EInput.mposWorld.y + EClass.setting.render.freePosFix.y;
            if (EClass.game.config.snapFreePos)
            {
                this.fx -= this.fx % 0.2f;
                this.fy -= this.fy % 0.1f;
            }
            this.fx = this.fx - vector.x + thingPosition.x;
            this.fy = this.fy - vector.y + thingPosition.y;
            return;
        }
        this.fx = (this.fy = 0f);
    }
 
    // Token: 0x06001365 RID: 4965 RVA: 0x0007F224 File Offset: 0x0007D424
    public unsafe void RenderMarker(Point point, bool active, HitResult result, bool main, int dir, bool useCurrentPosition = false)
    {
        if (dir != -1)
        {
            this.dir = dir;
        }
        Vector3 vector = *point.Position();
        bool skipRender = point.cell.skipRender;
        if (result != HitResult.Default && EClass.screen.guide.isActive && !skipRender)
        {
            EClass.screen.guide.passGuideBlock.Add(ref vector, (float)((point.HasObj || point.HasChara) ? 5 : 0), 0f);
        }
        if (!main)
        {
            return;
        }
        RenderParam renderParam = this.GetRenderParam();
        if (EClass.scene.actionMode.IsRoofEditMode(this))
        {
            renderParam.x = vector.x;
            renderParam.y = vector.y;
            renderParam.z = vector.z;
            EClass.screen.tileMap.SetRoofHeight(renderParam, point.cell, point.x, point.z, 0, 0, -1, false);
            vector.x = renderParam.x;
            vector.y = renderParam.y;
            vector.z = renderParam.z;
        }
        if (this.TileType.UseMountHeight && !EClass.scene.actionMode.IsRoofEditMode(this))
        {
            this.TileType.GetMountHeight(ref vector, point, this.dir, this);
        }
        vector.z += EClass.setting.render.thingZ;
        if (!skipRender)
        {
            Vector3 thingPosition = EClass.screen.tileMap.GetThingPosition(this, point);
            if (this.freePos)
            {
                vector.x += this.fx;
                vector.y += this.fy;
                vector.z += thingPosition.z;
            }
            else
            {
                vector += thingPosition;
            }
        }
        if (useCurrentPosition)
        {
            vector = this.renderer.position;
            vector.z += -0.01f;
        }
        if (this.TileType == TileType.Door)
        {
            vector.z -= 0.5f;
        }
        renderParam.matColor = (float)(active ? EClass.Colors.blockColors.Active : EClass.Colors.blockColors.Inactive);
        point.ApplyAnime(ref vector);
        if (this.renderer.hasActor)
        {
            this.renderer.actor.RefreshSprite();
        }
        this.renderer.Draw(renderParam, ref vector, false);
    }
 
    // Token: 0x06001366 RID: 4966 RVA: 0x0007F470 File Offset: 0x0007D670
    public void RecalculateFOV()
    {
        if (this.fov != null)
        {
            this.ClearFOV();
            this.fov = null;
            if (this.IsPC)
            {
                EClass.player.lightRadius = 1;
            }
        }
        this.CalculateFOV();
    }
 
    // Token: 0x06001367 RID: 4967 RVA: 0x0007F4A0 File Offset: 0x0007D6A0
    public bool HasLight()
    {
        return this.GetLightRadius() > 0;
    }
 
    // Token: 0x17000590 RID: 1424
    // (get) Token: 0x06001368 RID: 4968 RVA: 0x0007F4AC File Offset: 0x0007D6AC
    public LightData LightData
    {
        get
        {
            if (this._LightData == null)
            {
                return this._LightData = ((!this.sourceCard.lightData.IsEmpty()) ? EClass.Colors.lightColors[this.sourceCard.lightData] : null);
            }
            return this._LightData;
        }
    }
 
    // Token: 0x06001369 RID: 4969 RVA: 0x0007F500 File Offset: 0x0007D700
    public float GetLightPower()
    {
        float num = this.isChara ? EClass.scene.profile.light.fovCurveChara.Evaluate(EClass.scene.timeRatio) : EClass.scene.profile.global.fovPower;
        if (this.LightData != null)
        {
            return 0.01f * this.LightData.color.a * 256f * 1.12f;
        }
        if (this.IsPCFaction && !this.IsPC)
        {
            num *= 4f;
        }
        return num;
    }
 
    // Token: 0x0600136A RID: 4970 RVA: 0x0007F593 File Offset: 0x0007D793
    public int GetSightRadius()
    {
        if (this.IsPC)
        {
            return this.GetLightRadius();
        }
        return (EClass._map.IsIndoor ? 4 : 5) + (this.IsPCFaction ? 1 : 0);
    }
 
    // Token: 0x0600136B RID: 4971 RVA: 0x0007F5C4 File Offset: 0x0007D7C4
    public int GetLightRadius()
    {
        if (!this.isThing)
        {
            int num = (this.LightData != null) ? this.LightData.radius : 0;
            int num2 = 0;
            if (this.IsPC)
            {
                if (this.Chara.isBlind)
                {
                    return 1;
                }
                num = ((EClass._map.IsIndoor || EClass.world.date.IsNight) ? 2 : ((EClass.world.date.periodOfDay == PeriodOfDay.Day) ? 6 : 5));
                num2 = 2;
            }
            else
            {
                if (!EClass.core.config.graphic.drawAllyLight)
                {
                    return 0;
                }
                if (this.LightData == null && !EClass._map.IsIndoor && !EClass.world.date.IsNight)
                {
                    return 0;
                }
            }
            if (this.IsPCFaction)
            {
                Thing equippedThing = this.Chara.body.GetEquippedThing(45);
                if (equippedThing != null)
                {
                    num2 = (equippedThing.trait as TraitLightSource).LightRadius;
                }
                if (this.Chara.held != null && this.IsPC)
                {
                    int lightRadius = this.Chara.held.GetLightRadius();
                    if (lightRadius > 0)
                    {
                        if (lightRadius > num2)
                        {
                            num2 = this.Chara.held.GetLightRadius() - 1;
                        }
                        if (num2 < 3)
                        {
                            num2 = 3;
                        }
                    }
                }
                if (num < num2)
                {
                    num = num2;
                }
            }
            return num;
        }
        if (!this.IsInstalled && EClass.pc.held != this)
        {
            return 0;
        }
        if (this.trait is TraitLightSource && this.Thing.isEquipped)
        {
            return (this.trait as TraitLightSource).LightRadius;
        }
        if (this.LightData == null || !this.trait.IsLightOn)
        {
            return 0;
        }
        return this.LightData.radius;
    }
 
    // Token: 0x0600136C RID: 4972 RVA: 0x0007F768 File Offset: 0x0007D968
    public void CalculateFOV()
    {
        int lightRadius = this.GetLightRadius();
        if (lightRadius == 0 || !this.IsAliveInCurrentZone || !EClass._zone.isStarted)
        {
            return;
        }
        float num = this.GetLightPower();
        if (this.IsPC)
        {
            if (this.Chara.held != null && this.Chara.held.GetLightRadius() > 0)
            {
                num += this.Chara.held.GetLightPower();
            }
            if (lightRadius <= 2)
            {
                num = 0f;
            }
            foreach (Condition condition in this.Chara.conditions)
            {
                condition.OnCalculateFov(this.fov, ref lightRadius, ref num);
            }
            if (num > EClass.scene.profile.global.playerLightPowerLimit)
            {
                num = EClass.scene.profile.global.playerLightPowerLimit;
            }
            num *= EClass.scene.profile.light.playerLightMod;
            EClass.player.lightRadius = lightRadius;
            EClass.player.lightPower = num;
        }
        if (this.fov == null)
        {
            this.fov = this.CreateFov();
        }
        this.fov.Perform(this.pos.x, this.pos.z, lightRadius, num * 2f);
    }
 
    // Token: 0x0600136D RID: 4973 RVA: 0x0007F8CC File Offset: 0x0007DACC
    public void SetRandomLightColors()
    {
        this.c_lightColor = (int)((byte)(EClass.rnd(8) + 1)) * 1024 + (int)((byte)(EClass.rnd(8) + 1) * 32) + (int)((byte)(EClass.rnd(8) + 1));
    }
 
    // Token: 0x0600136E RID: 4974 RVA: 0x0007F8FC File Offset: 0x0007DAFC
    public Fov CreateFov()
    {
        Fov fov = new Fov();
        int num = this.trait.UseLightColor ? this.c_lightColor : 0;
        if (num != 0)
        {
            fov.r = (byte)(num / 1024);
            fov.g = (byte)(num % 1024 / 32);
            fov.b = (byte)(num % 32);
        }
        else if (this.LightData != null)
        {
            fov.r = (byte)(this.LightData.color.r * 16f);
            fov.g = (byte)(this.LightData.color.g * 16f);
            fov.b = (byte)(this.LightData.color.b * 16f);
        }
        else if (this.isChara)
        {
            fov.r = 0;
            fov.g = 0;
            fov.b = 0;
        }
        else
        {
            fov.r = 3;
            fov.g = 2;
            fov.b = 1;
        }
        if (this.isChara && this.Chara.held != null && this.Chara.held.GetLightRadius() > 0)
        {
            Fov fov2 = this.Chara.held.CreateFov();
            Fov fov3 = fov;
            fov3.r += fov2.r;
            Fov fov4 = fov;
            fov4.g += fov2.g;
            Fov fov5 = fov;
            fov5.b += fov2.b;
        }
        if (this.IsPC)
        {
            fov.isPC = true;
            foreach (Condition condition in this.Chara.conditions)
            {
                condition.OnCreateFov(fov);
            }
        }
        fov.limitGradient = (this.IsPCParty && EClass.scene.profile.global.limitGradient);
        return fov;
    }
 
    // Token: 0x0600136F RID: 4975 RVA: 0x0007FAE0 File Offset: 0x0007DCE0
    public void ClearFOV()
    {
        if (this.fov == null || this.fov.lastPoints.Count == 0)
        {
            return;
        }
        this.fov.Perform(this.pos.x, this.pos.z, 0, 1f);
    }
 
    // Token: 0x06001370 RID: 4976 RVA: 0x0007FB2F File Offset: 0x0007DD2F
    public virtual void OnSimulateHour(VirtualDate date)
    {
        this.trait.OnSimulateHour(date);
        if (date.IsRealTime)
        {
            this.DecayNatural(1);
        }
    }
 
    // Token: 0x06001371 RID: 4977 RVA: 0x0007FB4C File Offset: 0x0007DD4C
    public void DecayNatural(int hour = 1)
    {
        if (this.isNPCProperty)
        {
            return;
        }
        this.things.ForeachReverse(delegate(Thing t)
        {
            t.DecayNatural(hour);
        });
        if (this.parent is Card && (this.parent as Card).trait.CanChildDecay(this))
        {
            this.Decay(10 * hour);
            return;
        }
        if (this.isChara || this.trait.Decay == 0)
        {
            return;
        }
        this.Decay(this.trait.Decay * hour);
    }
 
    // Token: 0x06001372 RID: 4978 RVA: 0x0007FBEC File Offset: 0x0007DDEC
    public void Decay(int a = 10)
    {
        Card card = this.parent as Card;
        int num = 200;
        int num2 = this.MaxDecay / 4 * 3;
        if (a > 0)
        {
            if (card != null)
            {
                num = card.trait.DecaySpeedChild;
            }
            num = num * this.trait.DecaySpeed / 100;
            int num3 = this.Evalue(405);
            if (num3 != 0)
            {
                num = num * (100 - num3 * 2) / 100;
            }
            if (num < 0)
            {
                num = 0;
            }
        }
        else
        {
            num = 100;
        }
        a = a * num / 100;
        if (!this.IsDecayed && this.decay + a > this.MaxDecay)
        {
            if (card != null && !card.trait.OnChildDecay(this))
            {
                return;
            }
            if (EClass.pc.HasElement(1325, 1) && this.GetRootCard() is Chara && this.category.IsChildOf("food"))
            {
                Thing thing = TraitSeed.MakeRandomSeed(true).SetNum(Mathf.Min(this.Num, 3));
                card.AddCard(thing);
                if (!this.<Decay>g__IsParentLocked|800_0())
                {
                    this.GetRootCard().Say("seed_rot", this.GetRootCard(), this, thing.Name, null);
                }
                this.Destroy();
                return;
            }
            if (this.parent == EClass._zone)
            {
                this.Say("rot", this, null, null);
            }
            else if (this.GetRootCard() == EClass.pc)
            {
                if (!this.<Decay>g__IsParentLocked|800_0())
                {
                    EClass.pc.Say("rotInv", this, EClass.pc, null, null);
                }
                LayerInventory.SetDirty(this.Thing);
            }
            if (this.IsFood)
            {
                this.elements.SetBase(73, -10, 0);
            }
        }
        else if (this.decay < num2 && this.decay + a >= num2 && this.GetRootCard() == EClass.pc)
        {
            if (!this.<Decay>g__IsParentLocked|800_0())
            {
                EClass.pc.Say("rottingInv", this, EClass.pc, null, null);
            }
            LayerInventory.SetDirty(this.Thing);
        }
        this.decay += a;
    }
 
    // Token: 0x06001373 RID: 4979 RVA: 0x0007FDE4 File Offset: 0x0007DFE4
    public void Talk(string idTopic, string ref1 = null, string ref2 = null, bool forceSync = false)
    {
        if (this.IsPC && !EClass.player.forceTalk && idTopic != "goodBoy" && idTopic != "insane")
        {
            EClass.player.forceTalk = false;
            Msg.SetColor();
            return;
        }
        EClass.player.forceTalk = false;
        if (!this.isSynced && !forceSync)
        {
            Msg.SetColor();
            return;
        }
        GameLang.refDrama1 = ref1;
        GameLang.refDrama2 = ref2;
        string talkText = this.GetTalkText(idTopic, true, true);
        if (this.id == "adv_gaki")
        {
            BackerContent.GakiConvert(ref talkText);
        }
        this.TalkRaw(talkText, ref1, ref2, forceSync);
    }
 
    // Token: 0x06001374 RID: 4980 RVA: 0x0007FE88 File Offset: 0x0007E088
    public void TalkRaw(string text, string ref1 = null, string ref2 = null, bool forceSync = false)
    {
        if ((!this.isSynced && !forceSync) || text.IsEmpty())
        {
            Msg.SetColor();
            return;
        }
        if (ref1 != null)
        {
            text = text.Replace("#1", ref1);
        }
        if (ref2 != null)
        {
            text = text.Replace("#2", ref2);
        }
        this.HostRenderer.Say(this.ApplyNewLine(text), default(Color), 0f);
        bool flag = text.StartsWith("*");
        Msg.SetColor(text.StartsWith("(") ? Msg.colors.Thinking : (flag ? Msg.colors.Ono : Msg.colors.Talk));
        if (!flag)
        {
            text = text.Bracket(0);
        }
        Msg.Say(text.Replace("&", ""));
    }
 
    // Token: 0x06001375 RID: 4981 RVA: 0x0007FF58 File Offset: 0x0007E158
    public string ApplyNewLine(string text)
    {
        if (text.Contains("&"))
        {
            string str = "_comma".lang();
            text = text.Replace(str + " &", Environment.NewLine ?? "");
            text = text.Replace(str + "&", Environment.NewLine ?? "");
            text = text.Replace("&", Environment.NewLine ?? "");
        }
        return text;
    }
 
    // Token: 0x17000591 RID: 1425
    // (get) Token: 0x06001376 RID: 4982 RVA: 0x0007FFDB File Offset: 0x0007E1DB
    public CardRenderer HostRenderer
    {
        get
        {
            if (!this.isChara || this.Chara.host == null)
            {
                return this.renderer;
            }
            return this.Chara.host.renderer;
        }
    }
 
    // Token: 0x06001377 RID: 4983 RVA: 0x0008000C File Offset: 0x0007E20C
    public void SayRaw(string text, string ref1 = null, string ref2 = null)
    {
        if (!this.isSynced)
        {
            return;
        }
        if (text.IsEmpty())
        {
            return;
        }
        if (ref1 != null)
        {
            text = text.Replace("#1", ref1);
        }
        if (ref2 != null)
        {
            text = text.Replace("#2", ref2);
        }
        this.HostRenderer.Say(text, default(Color), 0f);
    }
 
    // Token: 0x17000592 RID: 1426
    // (get) Token: 0x06001378 RID: 4984 RVA: 0x00080067 File Offset: 0x0007E267
    public bool ShouldShowMsg
    {
        get
        {
            return (this.IsPC || this.parent == EClass.pc || this.isSynced) && (!this.isChara || !this.Chara.isDead);
        }
    }
 
    // Token: 0x06001379 RID: 4985 RVA: 0x000800A0 File Offset: 0x0007E2A0
    public void SayNothingHappans()
    {
        this.Say("nothingHappens", null, null);
    }
 
    // Token: 0x0600137A RID: 4986 RVA: 0x000800AF File Offset: 0x0007E2AF
    public void Say(string lang, string ref1 = null, string ref2 = null)
    {
        if (this.ShouldShowMsg)
        {
            Msg.Say(this.IsPC ? Lang.Game.TryGetId(lang + "_pc", lang) : lang, ref1, ref2, null, null);
        }
        Msg.SetColor();
    }
 
    // Token: 0x0600137B RID: 4987 RVA: 0x000800E9 File Offset: 0x0007E2E9
    public void Say(string lang, Card c1, Card c2, string ref1 = null, string ref2 = null)
    {
        if (this.ShouldShowMsg)
        {
            Msg.Say(this.IsPC ? Lang.Game.TryGetId(lang + "_pc", lang) : lang, c1, c2, ref1, ref2);
        }
        Msg.SetColor();
    }
 
    // Token: 0x0600137C RID: 4988 RVA: 0x00080125 File Offset: 0x0007E325
    public void Say(string lang, Card c1, string ref1 = null, string ref2 = null)
    {
        if (this.ShouldShowMsg)
        {
            Msg.Say(this.IsPC ? Lang.Game.TryGetId(lang + "_pc", lang) : lang, c1, ref1, ref2, null);
        }
        Msg.SetColor();
    }
 
    // Token: 0x0600137D RID: 4989 RVA: 0x00080160 File Offset: 0x0007E360
    public string GetTalkText(string idTopic, bool stripPun = false, bool useDefault = true)
    {
        bool flag = this.isChara && this.Chara.IsHuman;
        string text = MOD.listTalk.GetTalk(this.c_idTalk.IsEmpty(this.id), idTopic, useDefault, flag);
        if (!text.IsEmpty())
        {
            text = text.Split('|', StringSplitOptions.None).RandomItem<string>();
            if (!flag || (this.IsDeadOrSleeping && this.IsAliveInCurrentZone))
            {
                if (!text.StartsWith("(") && !text.StartsWith("*"))
                {
                    text = "(" + text + ")";
                }
                text = text.Replace("。)", ")");
            }
        }
        return this.ApplyTone(text, stripPun);
    }
 
    // Token: 0x0600137E RID: 4990 RVA: 0x00080211 File Offset: 0x0007E411
    public string ApplyTone(string text, bool stripPun = false)
    {
        text = GameLang.ConvertDrama(text, this.Chara);
        Chara chara = this.Chara;
        string c_idTone = this.c_idTone;
        Biography biography = this.bio;
        return Card.ApplyTone(chara, ref text, c_idTone, (biography != null) ? biography.gender : 0, stripPun);
    }
 
    // Token: 0x0600137F RID: 4991 RVA: 0x00080248 File Offset: 0x0007E448
    public static string ApplyTone(Chara c, ref string text, string _tones, int gender, bool stripPun = false)
    {
        if (text.IsEmpty())
        {
            return text;
        }
        string[] array = _tones.IsEmpty("").Split('|', StringSplitOptions.None);
        string key = array[0];
        MOD.tones.Initialize();
        string text2;
        if (!Lang.setting.useTone || MOD.tones.list.Count == 0)
        {
            text2 = text.Replace("{", "").Replace("}", "");
        }
        else
        {
            if (array[0].IsEmpty())
            {
                key = "default";
            }
            if (MOD.tones.all.ContainsKey(key))
            {
                StringBuilder stringBuilder = MOD.tones.ApplyTone(key, ref text, gender);
                if (Lang.isJP && c != null && c.trait.EnableTone)
                {
                    if (array.Length >= 2)
                    {
                        stringBuilder.Replace("_toneI".lang(), array[1]);
                    }
                    if (array.Length >= 3)
                    {
                        stringBuilder.Replace("_toneYou".lang(), array[2]);
                    }
                }
                text2 = stringBuilder.ToString();
            }
            else
            {
                text2 = text.Replace("{", "").Replace("}", "");
            }
        }
        if (!stripPun || !Lang.setting.stripPuns)
        {
            return text2;
        }
        return text2.StripLastPun();
    }
 
    // Token: 0x06001380 RID: 4992 RVA: 0x00080389 File Offset: 0x0007E589
    public void SetRandomTalk()
    {
        MOD.listTalk.Initialize();
        if (!MOD.listTalk.list[0].ContainsKey(this.id))
        {
            this.c_idTalk = MOD.listTalk.GetRandomID("human");
        }
    }
 
    // Token: 0x06001381 RID: 4993 RVA: 0x000803C8 File Offset: 0x0007E5C8
    public void SetRandomTone()
    {
        MOD.tones.Initialize();
        List<Dictionary<string, string>> list = MOD.tones.list;
        if (list.Count == 0)
        {
            return;
        }
        string text = list.RandomItem<Dictionary<string, string>>()["id"];
        for (int i = 0; i < 10; i++)
        {
            Dictionary<string, string> dictionary = list.RandomItem<Dictionary<string, string>>();
            if (EClass.rnd(100) <= dictionary["chance"].ToInt())
            {
                text = dictionary["id"];
                break;
            }
        }
        ToneDataList tones = MOD.tones;
        string text2 = text;
        Biography biography = this.bio;
        this.c_idTone = tones.GetToneID(text2, (biography != null) ? biography.gender : 0);
    }
 
    // Token: 0x06001382 RID: 4994 RVA: 0x00080464 File Offset: 0x0007E664
    public void TryStack(Thing t)
    {
        if (t == this)
        {
            return;
        }
        ThingContainer.DestData dest = this.things.GetDest(t, true);
        if (dest.stack != null)
        {
            if (this.IsPC)
            {
                this.Say("stack_thing", t, dest.stack, null, null);
            }
            t.TryStackTo(dest.stack);
        }
    }
 
    // Token: 0x06001383 RID: 4995 RVA: 0x000804B8 File Offset: 0x0007E6B8
    public void ApplyBacker(int bid)
    {
        this.ChangeRarity(Rarity.Normal);
        SourceBacker.Row row = EClass.sources.backers.map.TryGetValue(bid, null);
        if (row == null)
        {
            return;
        }
        this.c_idBacker = row.id;
        if (row.type == 4)
        {
            this.Chara.bio.SetGender(row.gender);
            this.Chara.hostility = (this.Chara.c_originalHostility = Hostility.Neutral);
        }
        if (row.type == 6)
        {
            this.Chara.bio.SetGender(row.gender);
            this.Chara.bio.SetPortrait(this.Chara);
            this.Chara.idFaith = row.deity.ToLower();
        }
        if (row.type == 4 || row.type == 5 || row.type == 7)
        {
            this.idSkin = ((row.skin == 0) ? EClass.rnd(this.sourceCard._tiles.Length) : row.skin);
            if (this.id == "putty_snow")
            {
                this.idSkin = 0;
            }
        }
        if (bid == 164)
        {
            this.Chara.EQ_ID("amulet_moonnight", -1, Rarity.Random);
        }
    }
 
    // Token: 0x06001384 RID: 4996 RVA: 0x000805F4 File Offset: 0x0007E7F4
    public void RemoveBacker()
    {
        if (this.c_idBacker == 164)
        {
            Thing thing = this.Chara.things.Find("amulet_moonnight", -1, -1);
            if (thing != null)
            {
                thing.Destroy();
            }
        }
        this.c_idBacker = 0;
    }
 
    // Token: 0x06001385 RID: 4997 RVA: 0x00080636 File Offset: 0x0007E836
    public void SetPaintData()
    {
        EClass.ui.Hide(0f);
        EClass.core.WaitForEndOfFrame(delegate
        {
            this.ClearPaintSprite();
            this.c_textureData = this.GetPaintData();
            EClass.core.WaitForEndOfFrame(delegate
            {
                EClass.ui.Show(0f);
            });
        });
    }
 
    // Token: 0x06001386 RID: 4998 RVA: 0x00080660 File Offset: 0x0007E860
    public byte[] GetPaintData()
    {
        Sprite sprite = this.GetSprite(0);
        Texture2D texture2D = ScreenCapture.CaptureScreenshotAsTexture();
        int num = sprite.texture.width * 2;
        int num2 = sprite.texture.height * 2;
        int x = (int)Mathf.Clamp(Input.mousePosition.x - (float)(num / 2), 1f, (float)(texture2D.width - num - 1));
        int y = (int)Mathf.Clamp(Input.mousePosition.y - (float)(num2 / 2), 1f, (float)(texture2D.height - num2 - 1));
        Color[] pixels = texture2D.GetPixels(x, y, num, num2);
        Texture2D texture2D2 = new Texture2D(num, num2, TextureFormat.ARGB32, false);
        texture2D2.SetPixels(pixels);
        texture2D2.Apply();
        byte[] result = texture2D2.EncodeToJPG();
        UnityEngine.Object.Destroy(texture2D);
        UnityEngine.Object.Destroy(texture2D2);
        return result;
    }
 
    // Token: 0x06001387 RID: 4999 RVA: 0x0008071B File Offset: 0x0007E91B
    public void ClearPaintSprite()
    {
        if (this._paintSprite)
        {
            UnityEngine.Object.Destroy(this._paintSprite.texture);
            UnityEngine.Object.Destroy(this._paintSprite);
            this._paintSprite = null;
        }
    }
 
    // Token: 0x06001388 RID: 5000 RVA: 0x0008074C File Offset: 0x0007E94C
    public Sprite GetPaintSprite()
    {
        if (!this._paintSprite)
        {
            byte[] c_textureData = this.c_textureData;
            Texture2D texture2D = new Texture2D(1, 1);
            texture2D.LoadImage(c_textureData);
            this._paintSprite = Sprite.Create(texture2D, new Rect(0f, 0f, (float)texture2D.width, (float)texture2D.height), new Vector2(0.5f, 0.5f), 200f);
            EClass.game.loadedTextures.Add(texture2D);
            TraitCanvas traitCanvas = this.trait as TraitCanvas;
            if (traitCanvas != null)
            {
                texture2D.filterMode = (traitCanvas.PointFilter ? FilterMode.Point : FilterMode.Bilinear);
            }
        }
        return this._paintSprite;
    }
 
    // Token: 0x06001389 RID: 5001 RVA: 0x000807F8 File Offset: 0x0007E9F8
    public void TryUnrestrain(bool force = false, Chara c = null)
    {
        if (this.GetRestrainer() == null || force)
        {
            this.isRestrained = false;
            this.Say("unrestrained", this, null, null);
            if (this != c)
            {
                this.Talk("thanks", null, null, false);
            }
            this.MoveImmediate(this.pos.GetNearestPoint(false, true, true, false), true, true);
            this.renderer.SetFirst(true);
            if (c != null)
            {
                if (this.c_rescueState == RescueState.WaitingForRescue)
                {
                    this.c_rescueState = RescueState.Rescued;
                    if (c.IsPC)
                    {
                        EClass.player.ModKarma(2);
                    }
                }
                foreach (Chara tg in c.pos.ListCharasInRadius(c, 5, (Chara _c) => _c.id == "fanatic" && _c.faith != this.Chara.faith))
                {
                    c.DoHostileAction(tg, true);
                }
            }
        }
    }
 
    // Token: 0x0600138A RID: 5002 RVA: 0x000808E0 File Offset: 0x0007EAE0
    public TraitShackle GetRestrainer()
    {
        foreach (Card card in this.pos.ListCards(false))
        {
            if (card.trait is TraitShackle && card.c_uidRefCard == this.uid)
            {
                return card.trait as TraitShackle;
            }
        }
        return null;
    }
 
    // Token: 0x0600138B RID: 5003 RVA: 0x00080960 File Offset: 0x0007EB60
    public virtual void Tick()
    {
    }
 
    // Token: 0x0600138C RID: 5004 RVA: 0x00080964 File Offset: 0x0007EB64
    public static int GetTilePrice(TileRow row, SourceMaterial.Row mat)
    {
        int num = 0;
        if (row.id == 0)
        {
            return num;
        }
        num = row.value * mat.value / 100;
        if (num < 0)
        {
            num = 1;
        }
        return num;
    }
 
    // Token: 0x0600138D RID: 5005 RVA: 0x00080995 File Offset: 0x0007EB95
    public Thing SetPriceFix(int a)
    {
        this.c_priceFix = a;
        return this.Thing;
    }
 
    // Token: 0x0600138E RID: 5006 RVA: 0x000809A4 File Offset: 0x0007EBA4
    public int GetEquipValue()
    {
        return this.GetValue(false);
    }
 
    // Token: 0x0600138F RID: 5007 RVA: 0x000809B0 File Offset: 0x0007EBB0
    public void SetSale(bool sale)
    {
        if (this.isSale == sale)
        {
            return;
        }
        this.isSale = sale;
        if (this.isSale)
        {
            EClass._map.props.sales.Add(this);
            return;
        }
        EClass._map.props.sales.Remove(this);
    }
 
    // Token: 0x06001390 RID: 5008 RVA: 0x00080A04 File Offset: 0x0007EC04
    public int GetValue(bool sell = false)
    {
        int value = this.trait.GetValue();
        if (value == 0)
        {
            return 0;
        }
        float num = (float)value;
        num = num * (float)Mathf.Max(100 + this.rarityLv + Mathf.Min(this.QualityLv * 10, 200), 80) / 100f;
        if (this.IsFood && !this.material.tag.Contains("food"))
        {
            num *= 0.5f;
        }
        float num2;
        if (this.IsEquipmentOrRanged || this.trait is TraitMod)
        {
            if (sell)
            {
                num *= 0.3f;
            }
            num2 = 2f;
        }
        else
        {
            num2 = 0.5f;
        }
        if (this.isReplica)
        {
            num *= 0.15f;
        }
        if (!this.IsUnique)
        {
            if (this.IsEquipmentOrRanged && this.rarity >= Rarity.Legendary)
            {
                num = Mathf.Max(num, 1800f + num / 5f);
            }
            num = num * (100f + num2 * (float)(this.material.value - 100)) / 100f;
            if (this.IsEquipmentOrRanged)
            {
                int num3 = 0;
                foreach (Element element in this.elements.dict.Values)
                {
                    num3 += element.source.value;
                }
                num = num * (float)(100 + (sell ? ((int)MathF.Sqrt((float)num3) * 10) : num3)) / 100f;
                if (this.rarity >= Rarity.Legendary)
                {
                    num = Mathf.Max(num, 3600f + num / 5f);
                }
            }
        }
        if (this.trait is TraitRecipe && sell)
        {
            num *= 0.1f;
        }
        if (this.encLV != 0)
        {
            if (this.category.tag.Contains("enc"))
            {
                num *= 0.7f + (float)(this.encLV - 1) * 0.2f;
            }
            else if (this.IsFood)
            {
                if (this.id == "honey")
                {
                    num += (float)(this.encLV * 10);
                }
                else
                {
                    num = num * Mathf.Min(1f + 0.1f * (float)this.encLV, 2f) + (float)(this.encLV * 100);
                }
            }
            else
            {
                num *= 1f + (float)this.encLV * 0.01f;
            }
        }
        return (int)num;
    }
 
    // Token: 0x06001391 RID: 5009 RVA: 0x00080C70 File Offset: 0x0007EE70
    public virtual int GetPrice(CurrencyType currency = CurrencyType.Money, bool sell = false, PriceType priceType = PriceType.Default, Chara c = null)
    {
        if (!sell)
        {
            if (this.id == "littleball")
            {
                return 0;
            }
            if (currency != CurrencyType.Medal)
            {
                if (currency == CurrencyType.Plat && this.id == "lucky_coin")
                {
                    return 100;
                }
            }
            else
            {
                string text = this.id;
                uint num = <PrivateImplementationDetails>.ComputeStringHash(text);
                if (num <= 2142614709U)
                {
                    if (num <= 696483963U)
                    {
                        if (num != 319581401U)
                        {
                            if (num != 371758720U)
                            {
                                if (num == 696483963U)
                                {
                                    if (text == "diary_catsister")
                                    {
                                        return 85;
                                    }
                                }
                            }
                            else if (text == "wrench_extend_v")
                            {
                                return 6;
                            }
                        }
                        else if (text == "diary_lady")
                        {
                            return 25;
                        }
                    }
                    else if (num <= 1237752336U)
                    {
                        if (num != 875087290U)
                        {
                            if (num == 1237752336U)
                            {
                                if (text == "water")
                                {
                                    return 3;
                                }
                            }
                        }
                        else if (text == "wrench_extend_h")
                        {
                            return 6;
                        }
                    }
                    else if (num != 1783752896U)
                    {
                        if (num == 2142614709U)
                        {
                            if (text == "diary_sister")
                            {
                                return 12;
                            }
                        }
                    }
                    else if (text == "wrench_bed")
                    {
                        return 3;
                    }
                }
                else if (num <= 2853982554U)
                {
                    if (num != 2149577330U)
                    {
                        if (num != 2315782384U)
                        {
                            if (num == 2853982554U)
                            {
                                if (text == "wrench_storage")
                                {
                                    return 4;
                                }
                            }
                        }
                        else if (text == "monsterball")
                        {
                            return this.LV / 8;
                        }
                    }
                    else if (text == "1165")
                    {
                        return 10;
                    }
                }
                else if (num <= 2987720544U)
                {
                    if (num != 2893910830U)
                    {
                        if (num == 2987720544U)
                        {
                            if (text == "wrench_fridge")
                            {
                                return 15;
                            }
                        }
                    }
                    else if (text == "bill_tax")
                    {
                        return 3;
                    }
                }
                else if (num != 3142504220U)
                {
                    if (num == 3660019884U)
                    {
                        if (text == "container_magic")
                        {
                            return 20;
                        }
                    }
                }
                else if (text == "bill")
                {
                    return 3;
                }
            }
        }
        if (sell && this.noSell)
        {
            return 0;
        }
        if (!sell && this.id == "casino_coin")
        {
            return 20;
        }
        int value = this.GetValue(sell);
        if (value == 0)
        {
            return 0;
        }
        if (c == null)
        {
            c = EClass.pc;
        }
        float p = (float)value;
        Trait trait = this.trait;
        if (!(trait is TraitBed))
        {
            TraitContainer traitContainer = trait as TraitContainer;
            if (traitContainer != null)
            {
                p *= 1f + 1f * (float)(this.things.width - traitContainer.Width) + 1f * (float)(this.things.height - traitContainer.Height);
            }
        }
        else
        {
            p *= 1f + 0.5f * (float)this.c_containerSize;
        }
        p += (float)this.c_priceAdd;
        if (this.c_priceFix != 0)
        {
            p = (float)((int)(p * (float)Mathf.Clamp(100 + this.c_priceFix, 0, 1000000) / 100f));
            if (p == 0f)
            {
                return 0;
            }
        }
        if (this.isStolen)
        {
            if (sell && priceType == PriceType.PlayerShop && EClass.Branch != null && EClass.Branch.policies.IsActive(2824, -1))
            {
                p = p * 100f / Mathf.Max(110f, 170f - Mathf.Sqrt((float)(EClass.Branch.Evalue(2824) * 5)));
            }
            else if (sell && Guild.Thief.IsMember)
            {
                p = (float)Guild.Thief.SellStolenPrice((int)p);
            }
            else
            {
                p *= 0.5f;
            }
        }
        if (!sell && this.category.id == "spellbook")
        {
            p = (float)Guild.Mage.BuySpellbookPrice((int)p);
        }
        int num2 = (priceType == PriceType.CopyShop) ? 5 : 1;
        float num3 = 1f + Mathf.Min(0.01f * (float)this.Evalue(752), 1f) + Mathf.Min(0.01f * (float)this.Evalue(751), 1f) * (float)num2;
        p *= num3;
        p *= 0.2f;
        if (sell)
        {
            p *= 0.2f;
            if (currency == CurrencyType.Money && (this.category.IsChildOf("meal") || this.category.IsChildOf("preserved")))
            {
                p *= 0.5f;
            }
            if (priceType - PriceType.Shipping <= 1 && (this.category.IsChildOf("vegi") || this.category.IsChildOf("fruit")))
            {
                p *= ((EClass.pc.faith == EClass.game.religions.Harvest) ? 3f : 2f);
            }
        }
        if (this.id == "rod_wish")
        {
            p *= (sell ? 0.01f : 50f);
        }
        switch (currency)
        {
        case CurrencyType.Medal:
            p *= 0.0002f;
            goto IL_7FA;
        case CurrencyType.Ecopo:
            if (this.trait is TraitSeed)
            {
                p *= 2f;
                goto IL_7FA;
            }
            if (this.trait is TraitEcoMark)
            {
                p *= 1f;
                goto IL_7FA;
            }
            p *= 0.2f;
            goto IL_7FA;
        case CurrencyType.Money2:
            p *= 0.005f;
            goto IL_7FA;
        case CurrencyType.Influence:
            p *= 0.002f;
            goto IL_7FA;
        case CurrencyType.Casino_coin:
            p *= 0.1f;
            goto IL_7FA;
        }
        if (this.IsIdentified || (this.trait is TraitErohon && !sell))
        {
            if (this.blessedState == BlessedState.Blessed)
            {
                p *= 1.25f;
            }
            else if (this.blessedState == BlessedState.Cursed)
            {
                p *= 0.5f;
            }
            else if (this.blessedState == BlessedState.Doomed)
            {
                p *= 0.2f;
            }
            if (this.trait.HasCharges)
            {
                p = p * 0.05f + p * (0.5f + Mathf.Clamp(0.1f * (float)this.c_charges, 0f, 1.5f));
            }
            if (this.IsDecayed)
            {
                p *= 0.5f;
            }
        }
        else
        {
            Rand.UseSeed(this.uid, delegate
            {
                p = (float)(sell ? (1 + EClass.rnd(15)) : (50 + EClass.rnd(500)));
            });
        }
        if (!sell)
        {
            p *= 1f + 0.2f * (float)c.Evalue(1406);
        }
        IL_7FA:
        float num4 = Math.Clamp(Mathf.Sqrt((float)(c.Evalue(291) + ((!sell && EClass._zone.IsPCFaction) ? (EClass.Branch.Evalue(2800) * 2) : 0))), 0f, 25f);
        if (priceType != PriceType.Shipping)
        {
            if (priceType == PriceType.PlayerShop)
            {
                if (sell)
                {
                    float num5 = 1.25f;
                    if (EClass.Branch != null)
                    {
                        if (EClass.Branch.policies.IsActive(2817, -1))
                        {
                            num5 += 0.1f + 0.01f * Mathf.Sqrt((float)EClass.Branch.Evalue(2817));
                        }
                        if (EClass.Branch.policies.IsActive(2816, -1))
                        {
                            num5 += 0.2f + 0.02f * Mathf.Sqrt((float)EClass.Branch.Evalue(2816));
                        }
                        if (this.isChara)
                        {
                            if (EClass.Branch.policies.IsActive(2828, -1))
                            {
                                num5 += 0.1f + 0.01f * Mathf.Sqrt((float)EClass.Branch.Evalue(2828));
                            }
                        }
                        else if (this.category.IsChildOf("food") || this.category.IsChildOf("drink"))
                        {
                            if (EClass.Branch.policies.IsActive(2818, -1))
                            {
                                num5 += 0.05f + 0.005f * Mathf.Sqrt((float)EClass.Branch.Evalue(2818));
                            }
                        }
                        else if (this.category.IsChildOf("furniture"))
                        {
                            if (EClass.Branch.policies.IsActive(2819, -1))
                            {
                                num5 += 0.05f + 0.005f * Mathf.Sqrt((float)EClass.Branch.Evalue(2819));
                            }
                        }
                        else if (EClass.Branch.policies.IsActive(2820, -1))
                        {
                            num5 += 0.05f + 0.005f * Mathf.Sqrt((float)EClass.Branch.Evalue(2820));
                        }
                    }
                    p *= num5;
                }
            }
        }
        else if (sell)
        {
            p *= 1.1f;
        }
        if (currency > CurrencyType.Money)
        {
            num4 = 0f;
        }
        p *= (sell ? (1f + num4 * 0.02f) : (1f - num4 * 0.02f));
        if (sell)
        {
            p = (float)EClass.curve((int)p, 10000, 10000, 80);
        }
        if (p < 1f)
        {
            p = (float)(sell ? 0 : 1);
        }
        if (!sell)
        {
            if (currency == CurrencyType.Casino_coin)
            {
                if (p > 100000f)
                {
                    p = (float)(Mathf.CeilToInt(p / 100000f) * 100000);
                }
                else if (p > 10000f)
                {
                    p = (float)(Mathf.CeilToInt(p / 10000f) * 10000);
                }
                else if (p > 1000f)
                {
                    p = (float)(Mathf.CeilToInt(p / 1000f) * 1000);
                }
                else if (p > 100f)
                {
                    p = (float)(Mathf.CeilToInt(p / 100f) * 100);
                }
                else if (p > 10f)
                {
                    p = (float)(Mathf.CeilToInt(p / 10f) * 10);
                }
            }
            if (this.trait is TraitDeed)
            {
                p *= Mathf.Pow(2f, (float)EClass.player.flags.landDeedBought);
            }
        }
        return (int)p;
    }
 
    // Token: 0x06001392 RID: 5010 RVA: 0x00081889 File Offset: 0x0007FA89
    public virtual string GetHoverText()
    {
        return this.Name + this.GetExtraName();
    }
 
    // Token: 0x06001393 RID: 5011 RVA: 0x0008189C File Offset: 0x0007FA9C
    public virtual string GetHoverText2()
    {
        return "";
    }
 
    // Token: 0x06001394 RID: 5012 RVA: 0x000818A4 File Offset: 0x0007FAA4
    public int Dist(Card c)
    {
        if (!this.IsMultisize && !c.IsMultisize)
        {
            return this.pos.Distance(c.pos);
        }
        if (this.IsMultisize)
        {
            int dist = 99;
            this.ForeachPoint(delegate(Point p, bool main)
            {
                int num = Card.<Dist>g__DistMulti|837_0(p, c);
                if (num < dist)
                {
                    dist = num;
                }
            });
            return dist;
        }
        return Card.<Dist>g__DistMulti|837_0(this.pos, c);
    }
 
    // Token: 0x06001395 RID: 5013 RVA: 0x00081924 File Offset: 0x0007FB24
    public int Dist(Point p)
    {
        return this.pos.Distance(p);
    }
 
    // Token: 0x06001396 RID: 5014 RVA: 0x00081932 File Offset: 0x0007FB32
    public bool IsInMutterDistance(int d = 10)
    {
        return this.pos.Distance(EClass.pc.pos) < d;
    }
 
    // Token: 0x06001397 RID: 5015 RVA: 0x0008194C File Offset: 0x0007FB4C
    public void SetCensored(bool enable)
    {
        this.isCensored = enable;
        if (EClass.core.config.other.noCensor)
        {
            this.isCensored = false;
        }
        this.renderer.SetCensored(this.isCensored);
    }
 
    // Token: 0x06001398 RID: 5016 RVA: 0x00081984 File Offset: 0x0007FB84
    public void SetDeconstruct(bool deconstruct)
    {
        if (this.isDeconstructing == deconstruct)
        {
            return;
        }
        if (deconstruct)
        {
            EClass._map.props.deconstructing.Add(this);
        }
        else
        {
            EClass._map.props.deconstructing.Remove(this);
        }
        this.isDeconstructing = deconstruct;
    }
 
    // Token: 0x06001399 RID: 5017 RVA: 0x000819D4 File Offset: 0x0007FBD4
    public virtual void SetSortVal(UIList.SortMode m, CurrencyType currency = CurrencyType.Money)
    {
        switch (m)
        {
        case UIList.SortMode.ByNumber:
            this.sortVal = -this.Num * 1000;
            return;
        case UIList.SortMode.ByValue:
            this.sortVal = -this.GetPrice(currency, false, PriceType.Default, null) * 1000;
            return;
        case UIList.SortMode.ByCategory:
            this.sortVal = this.category.sortVal * 1000;
            return;
        case UIList.SortMode.ByEquip:
            this.sortVal = ((this.c_equippedSlot != 0) ? 0 : (this.category.sortVal * 1000));
            return;
        case UIList.SortMode.ByWeight:
            this.sortVal = -this.ChildrenAndSelfWeight * 1000;
            return;
        case UIList.SortMode.ByPrice:
            this.sortVal = -this.GetPrice(currency, false, PriceType.Default, null) * 1000;
            return;
        case UIList.SortMode.ByWeightSingle:
            this.sortVal = -this.ChildrenAndSelfWeightSingle * 1000;
            return;
        }
        this.sortVal = this.sourceCard._index * 1000;
    }
 
    // Token: 0x0600139A RID: 5018 RVA: 0x00081AE0 File Offset: 0x0007FCE0
    public virtual int SecondaryCompare(UIList.SortMode m, Card c)
    {
        int num = 0;
        if (num == 0)
        {
            num = this.id.CompareTo(c.id);
        }
        if (num == 0)
        {
            num = this.trait.CompareTo(c);
        }
        if (num == 0)
        {
            num = this.GetName(NameStyle.Full, 1).CompareTo(c.GetName(NameStyle.Full, 1));
        }
        if (num == 0)
        {
            num = this.refVal - c.refVal;
        }
        if (num == 0)
        {
            num = this.c_charges - c.c_charges;
        }
        if (num == 0)
        {
            num = this.encLV - c.encLV;
        }
        if (num == 0)
        {
            num = this.uid - c.uid;
        }
        return num;
    }
 
    // Token: 0x0600139B RID: 5019 RVA: 0x00081B74 File Offset: 0x0007FD74
    public void ForeachFOV(Func<Point, bool> func)
    {
        if (this.fov == null)
        {
            return;
        }
        foreach (KeyValuePair<int, byte> keyValuePair in this.fov.lastPoints)
        {
            Point arg = new Point().Set(keyValuePair.Key);
            if (func(arg))
            {
                break;
            }
        }
    }
 
    // Token: 0x0600139C RID: 5020 RVA: 0x00081BEC File Offset: 0x0007FDEC
    public void ForeachPoint(Action<Point, bool> action)
    {
        if (this.IsMultisize)
        {
            this.pos.ForeachMultiSize(this.W, this.H, action);
            return;
        }
        action(this.pos, true);
    }
 
    // Token: 0x0600139D RID: 5021 RVA: 0x00081C1C File Offset: 0x0007FE1C
    public void OnInspect()
    {
    }
 
    // Token: 0x17000593 RID: 1427
    // (get) Token: 0x0600139E RID: 5022 RVA: 0x00081C1E File Offset: 0x0007FE1E
    public bool CanInspect
    {
        get
        {
            return !this.isDestroyed && this.ExistsOnMap;
        }
    }
 
    // Token: 0x17000594 RID: 1428
    // (get) Token: 0x0600139F RID: 5023 RVA: 0x00081C30 File Offset: 0x0007FE30
    public string InspectName
    {
        get
        {
            return this.Name;
        }
    }
 
    // Token: 0x17000595 RID: 1429
    // (get) Token: 0x060013A0 RID: 5024 RVA: 0x00081C38 File Offset: 0x0007FE38
    public Point InspectPoint
    {
        get
        {
            return this.pos;
        }
    }
 
    // Token: 0x17000596 RID: 1430
    // (get) Token: 0x060013A1 RID: 5025 RVA: 0x00081C40 File Offset: 0x0007FE40
    public Vector3 InspectPosition
    {
        get
        {
            return this.renderer.position;
        }
    }
 
    // Token: 0x060013A2 RID: 5026 RVA: 0x00081C4D File Offset: 0x0007FE4D
    public virtual void WriteNote(UINote n, Action<UINote> onWriteNote = null, IInspect.NoteMode mode = IInspect.NoteMode.Default, Recipe recipe = null)
    {
    }
 
    // Token: 0x060013A3 RID: 5027 RVA: 0x00081C50 File Offset: 0x0007FE50
    public void Inspect()
    {
        SE.Play("pop_paper");
        if (this.isChara)
        {
            LayerChara layerChara = EClass.ui.AddLayerDontCloseOthers<LayerChara>();
            layerChara.windows[0].SetRect(EClass.core.refs.rects.center, false);
            layerChara.SetChara(this.Chara);
            return;
        }
        EClass.ui.AddLayerDontCloseOthers<LayerInfo>().SetThing(this.Thing, false);
    }
 
    // Token: 0x060013A4 RID: 5028 RVA: 0x00081CC2 File Offset: 0x0007FEC2
    public virtual bool HasCondition<T>() where T : Condition
    {
        return false;
    }
 
    // Token: 0x060013A5 RID: 5029 RVA: 0x00081CC8 File Offset: 0x0007FEC8
    public bool HaveFur()
    {
        if (!this.isChara)
        {
            return false;
        }
        string a = this.id;
        return a == "putty_snow" || a == "putty_snow_gold" || !this.Chara.race.fur.IsEmpty();
    }
 
    // Token: 0x060013A6 RID: 5030 RVA: 0x00081D1A File Offset: 0x0007FF1A
    public bool CanBeSheared()
    {
        return !EClass._zone.IsUserZone && this.HaveFur() && this.c_fur >= 0;
    }
 
    // Token: 0x060013AA RID: 5034 RVA: 0x00081DBA File Offset: 0x0007FFBA
    [CompilerGenerated]
    private bool <SpawnLoot>g__chance|729_0(int i)
    {
        i = i * 100 / (100 + EClass.player.codex.GetOrCreate(this.id).BonusDropLv * 10);
        if (i < 1)
        {
            i = 1;
        }
        return EClass.rnd(i) == 0;
    }
 
    // Token: 0x060013AB RID: 5035 RVA: 0x00081DF8 File Offset: 0x0007FFF8
    [CompilerGenerated]
    internal static bool <MakeFoodRef>g__IsIgnoreName|733_0(Card c)
    {
        if (c == null)
        {
            return true;
        }
        string a = c.id;
        return a == "dough_cake" || a == "dough_bread" || a == "noodle" || a == "flour" || a == "rice";
    }
 
    // Token: 0x060013AC RID: 5036 RVA: 0x00081E55 File Offset: 0x00080055
    [CompilerGenerated]
    private bool <Decay>g__IsParentLocked|800_0()
    {
        return this.parent is Thing && (this.parent as Thing).c_lockLv > 0;
    }
 
    // Token: 0x060013AF RID: 5039 RVA: 0x00081EE4 File Offset: 0x000800E4
    [CompilerGenerated]
    internal static int <Dist>g__DistMulti|837_0(Point p1, Card c)
    {
        if (!c.IsMultisize)
        {
            return p1.Distance(c.pos);
        }
        int dist = 99;
        c.ForeachPoint(delegate(Point p, bool main)
        {
            int num = p1.Distance(p);
            if (num < dist)
            {
                dist = num;
            }
        });
        return dist;
    }
 
    // Token: 0x04000F4B RID: 3915
    [JsonProperty(PropertyName = "A")]
    public int[] _ints = new int[30];
 
    // Token: 0x04000F4C RID: 3916
    [JsonProperty(PropertyName = "B")]
    public string id = "";
 
    // Token: 0x04000F4D RID: 3917
    [JsonProperty(PropertyName = "C")]
    public ThingContainer things = new ThingContainer();
 
    // Token: 0x04000F4E RID: 3918
    [JsonProperty(PropertyName = "D")]
    public ElementContainerCard elements = new ElementContainerCard();
 
    // Token: 0x04000F4F RID: 3919
    [JsonProperty(PropertyName = "E")]
    public Biography bio;
 
    // Token: 0x04000F50 RID: 3920
    [JsonProperty(PropertyName = "SC")]
    public List<int> sockets;
 
    // Token: 0x04000F51 RID: 3921
    public AIAct reservedAct;
 
    // Token: 0x04000F52 RID: 3922
    public Props props;
 
    // Token: 0x04000F53 RID: 3923
    public Trait trait;
 
    // Token: 0x04000F54 RID: 3924
    public ICardParent parent;
 
    // Token: 0x04000F55 RID: 3925
    public Fov fov;
 
    // Token: 0x04000F56 RID: 3926
    public Point pos = new Point();
 
    // Token: 0x04000F57 RID: 3927
    public CardRenderer renderer;
 
    // Token: 0x04000F58 RID: 3928
    public int turn;
 
    // Token: 0x04000F59 RID: 3929
    public int _colorInt;
 
    // Token: 0x04000F5A RID: 3930
    public float roundTimer;
 
    // Token: 0x04000F5B RID: 3931
    public float angle = 180f;
 
    // Token: 0x04000F5C RID: 3932
    public bool isDestroyed;
 
    // Token: 0x04000F5D RID: 3933
    public CardBlueprint bp;
 
    // Token: 0x04000F5E RID: 3934
    public BitArray32 _bits1;
 
    // Token: 0x04000F5F RID: 3935
    public BitArray32 _bits2;
 
    // Token: 0x04000F60 RID: 3936
    public PlaceState placeState;
 
    // Token: 0x04000F61 RID: 3937
    public bool dirtyWeight = true;
 
    // Token: 0x04000F62 RID: 3938
    private int _childrenWeight;
 
    // Token: 0x04000F63 RID: 3939
    private SourceCategory.Row _category;
 
    // Token: 0x04000F64 RID: 3940
    public SourceMaterial.Row _material;
 
    // Token: 0x04000F65 RID: 3941
    private static Color _randColor;
 
    // Token: 0x04000F66 RID: 3942
    public Emo lastEmo;
 
    // Token: 0x04000F67 RID: 3943
    private LightData _LightData;
 
    // Token: 0x04000F68 RID: 3944
    private Sprite _paintSprite;
 
    // Token: 0x04000F69 RID: 3945
    public int sortVal;
 
    // Token: 0x02000948 RID: 2376
    public enum MoveResult
    {
        // Token: 0x0400271F RID: 10015
        Fail,
        // Token: 0x04002720 RID: 10016
        Success,
        // Token: 0x04002721 RID: 10017
        Door
    }
 
    // Token: 0x02000949 RID: 2377
    public enum MoveType
    {
        // Token: 0x04002723 RID: 10019
        Walk,
        // Token: 0x04002724 RID: 10020
        Force
    }
}