Zone.cs File Reference

Go to the source code of this file.

Classes
class	Zone
class	Zone.PortalReturnData

Functions
	[instance initializer]

Variables
$ Can	tloadmap

Function Documentation

[instance initializer]()

RefreshHat.[instance initializer]

Variable Documentation

tloadmap

$ Can tloadmap

Definition at line 1124 of file Zone.cs.

{
        if (idHat != null && EClass.world.date.IsExpired(base.dateHat))
        {
            idHat = null;
            base.dateHat = 0;
        }
        sourceHat = ((idHat != null) ? EClass.sources.cards.map[idHat] : ((IDHat != null) ? EClass.sources.cards.map[IDHat] : null));
    }
 
    public void OnVisit()
    {
        if (EClass.world.date.IsExpired(base.dateRevive))
        {
            ResetHostility();
            Revive();
            List<Chara> list = new List<Chara>();
            foreach (Chara chara in EClass._map.charas)
            {
                chara.TryRestock(onCreate: false);
                if (!chara.IsPCFaction)
                {
                    chara.c_fur = 0;
                }
                if (chara.IsMinion && chara.master != null && !chara.master.IsPCParty)
                {
                    list.Add(chara);
                }
            }
            foreach (Chara item in list)
            {
                item.Destroy();
            }
        }
        if (!EClass.game.isLoading)
        {
            RefreshDeathSentense();
        }
        RefreshCriminal();
        EClass._map.rooms.AssignCharas();
        events.OnVisit();
        OnActivate();
        UpdateQuests();
        OnBeforeSimulate();
        isSimulating = true;
        Simulate();
        isSimulating = false;
        OnAfterSimulate();
        if (EClass.Branch != null)
        {
            EClass.Branch.OnAfterSimulate();
        }
        base.lastActive = EClass.world.date.GetRaw();
        if (!EClass.game.isLoading)
        {
            base.visitCount++;
        }
        base.version = EClass.core.version.GetInt();
        if (HasField(10000))
        {
            Tutorial.Reserve("field");
        }
    }
 
    public void RefreshDeathSentense()
    {
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.HasCondition<ConDeathSentense>())
            {
                chara.GetCondition<ConDeathSentense>().TryRemove();
            }
        }
    }
 
    public void Revive()
    {
        base.dateRevive = EClass.world.date.GetRaw() + 1440 * EClass.setting.balance.dateRevive;
        if (ShouldAutoRevive)
        {
            foreach (Chara deadChara in map.deadCharas)
            {
                if (deadChara.trait.CanAutoRevive && deadChara.CanRevive())
                {
                    deadChara.Revive();
                    if (deadChara.isBackerContent && EClass.player.doneBackers.Contains(deadChara.c_idBacker) && !EClass.core.config.test.ignoreBackerDestoryFlag)
                    {
                        deadChara.RemoveBacker();
                    }
                    EClass._zone.AddCard(deadChara, (deadChara.orgPos != null && deadChara.orgPos.IsInBounds) ? deadChara.orgPos : deadChara.pos);
                }
            }
        }
        foreach (Chara value in EClass.game.cards.globalCharas.Values)
        {
            if (value.isDead && value.CanRevive() && value.homeZone == this)
            {
                value.Revive();
                Point point = GetSpawnPos(value);
                if (value.orgPos != null && value.orgPos.IsInBounds)
                {
                    point = value.orgPos.GetNearestPoint() ?? point;
                }
                EClass._zone.AddCard(value, point);
            }
        }
        map.deadCharas.Clear();
    }
 
    public virtual void OnRegenerate()
    {
    }
 
    public virtual void OnActivate()
    {
        if (!(id == "startVillage2"))
        {
            return;
        }
        if (EClass._map.version.IsBelow(0, 23, 226))
        {
            SetBGM(121, refresh: false);
        }
        int num = 0;
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.id == "cat_silver" && !chara.IsPCFaction)
            {
                num++;
            }
        }
        if (num > 0)
        {
            Msg.Say("num_silvercat", num.ToString() ?? "");
        }
    }
 
    public virtual void OnBeforeDeactivate()
    {
    }
 
    public virtual void OnDeactivate()
    {
    }
 
    public virtual void OnBeforeSimulate()
    {
    }
 
    public virtual void OnVisitNewMapOrRegenerate()
    {
    }
 
    public virtual void OnAfterSimulate()
    {
    }
 
    public virtual void OnAdvanceHour()
    {
    }
 
    public void Simulate()
    {
        if (!EClass.game.isLoading && base.visitCount > 0)
        {
            if (Boss != null && IsNefia)
            {
                Msg.Say("bossLeave", Boss.Name.ToTitleCase(), EClass._zone.Name);
                EClass._zone.RemoveCard(Boss);
                EClass._zone.GetTopZone().isConquered = true;
            }
            int num = Mathf.Clamp(MinsSinceLastActive, 1, 10000);
            foreach (Chara chara2 in EClass._map.charas)
            {
                if (chara2.hp < 0)
                {
                    chara2.hp = 0;
                }
                if (!chara2.IsPCParty)
                {
                    if (chara2.mana.value < 0)
                    {
                        chara2.mana.value = 0;
                    }
                    if (chara2.stamina.value < 0)
                    {
                        chara2.stamina.value = 0;
                    }
                }
                if (num > 60)
                {
                    chara2.resistCon = null;
                }
                if (chara2.rarity >= Rarity.Legendary && !chara2.IsPCFaction && num > 0)
                {
                    Msg.ignoreAll = true;
                    chara2.Cure(CureType.Boss, 20 + num * 10);
                    chara2.HealHP((int)((long)Mathf.Max(1, chara2.MaxHP) * (long)Mathf.Min(num, 20) / 20));
                    chara2.mana.Mod(Mathf.Max(1, chara2.mana.max) * Mathf.Min(num, 20) / 20);
                    chara2.stamina.Mod(Mathf.Max(1, chara2.stamina.max) * Mathf.Min(num, 20) / 20);
                    Msg.ignoreAll = false;
                }
            }
        }
        Debug.Log("Last Active:" + base.lastActive);
        if (base.lastActive == 0 || HourSinceLastActive <= 1 || IsRegion)
        {
            return;
        }
        Debug.Log(Name + " Simulate:" + HourSinceLastActive + " hours");
        VirtualDate virtualDate = new VirtualDate(HourSinceLastActive);
        List<Chara> list = EClass._map.charas.ToList();
        int num2 = HourSinceLastActive / 24;
        int num3 = 0;
        if (num2 > 0)
        {
            foreach (Chara item in list)
            {
                if (!item.IsPCParty)
                {
                    item.OnSleep(200, num2);
                    if (item.conSleep != null)
                    {
                        item.conSleep.Kill();
                    }
                    if (EClass.rnd(EClass.world.date.IsNight ? 20 : 200) == 0 && !item.IsPCFaction)
                    {
                        item.AddCondition<ConSleep>(1000 + EClass.rnd(1000), force: true);
                    }
                    if (item.things.Count > 20)
                    {
                        item.ClearInventory(ClearInventoryType.Purge);
                    }
                }
            }
        }
        VirtualDate.current = virtualDate;
        for (int i = 0; i < HourSinceLastActive; i++)
        {
            virtualDate.SimulateHour();
            if (!virtualDate.IsWinter)
            {
                num3++;
            }
        }
        EClass._map.things.ForeachReverse(delegate(Thing t)
        {
            t.DecayNatural(HourSinceLastActive);
        });
        VirtualDate.current = null;
        if (!IsPCFaction)
        {
            return;
        }
        int num4 = 0;
        foreach (Chara item2 in list)
        {
            if (item2.IsPCParty)
            {
                continue;
            }
            if (!item2.IsHomeMember())
            {
                if (item2.id == "bee")
                {
                    num4++;
                }
                if (num2 > 0 && item2.IsGuest())
                {
                    item2.ChooseNewGoal();
                    item2.ai.SimulateZone(num2);
                }
                continue;
            }
            if (num2 > 0)
            {
                Goal goalWork = item2.GetGoalWork();
                item2.SetAI(goalWork);
                if (goalWork is GoalWork)
                {
                    (goalWork as GoalWork).FindWork(item2);
                }
                item2.ai.SimulateZone(num2);
                goalWork = item2.GetGoalHobby();
                item2.SetAI(goalWork);
                if (goalWork is GoalWork)
                {
                    (goalWork as GoalWork).FindWork(item2);
                }
                item2.ai.SimulateZone(num2);
            }
            item2.ChooseNewGoal();
            if (item2.conSuspend == null)
            {
                item2.ai.OnSimulatePosition();
            }
        }
        List<Thing> list2 = new List<Thing>();
        foreach (Thing thing in map.things)
        {
            if (thing.IsInstalled && thing.trait is TraitBeekeep)
            {
                list2.Add(thing);
            }
        }
        if (num4 >= list2.Count)
        {
            return;
        }
        for (int j = num4; j < list2.Count; j++)
        {
            if (EClass.rnd(200) <= HourSinceLastActive)
            {
                Chara chara = CharaGen.Create("bee");
                AddCard(chara, list2.RandomItem().pos);
                Hostility c_originalHostility = (chara.hostility = Hostility.Neutral);
                chara.c_originalHostility = c_originalHostility;
            }
        }
    }
 
    public Point GetSpawnPos(Chara c, ZoneTransition.EnterState destState = ZoneTransition.EnterState.Auto)
    {
        ZoneTransition zoneTransition = c.global?.transition;
        Zone zone = zoneTransition?.lastZone;
        ZoneTransition.EnterState enterState = zoneTransition?.state ?? destState;
        bool flag = zone == null || zone.lv > base.lv;
        if (IsRegion)
        {
            if (zone != null && !EClass.player.simulatingZone)
            {
                Zone topZone = zone.GetTopZone();
                if (GetZoneAt(topZone.x, topZone.y) != null)
                {
                    return new Point(topZone.mapX, topZone.mapY);
                }
            }
        }
        else if (c.IsPC && EClass.player.lastZonePos != null && zone != null && zone.IsRegion && (enterState == ZoneTransition.EnterState.Left || enterState == ZoneTransition.EnterState.Right || enterState == ZoneTransition.EnterState.Top || enterState == ZoneTransition.EnterState.Bottom))
        {
            return EClass.player.lastZonePos;
        }
        if (enterState == ZoneTransition.EnterState.Region)
        {
            enterState = RegionEnterState;
        }
        if (this is Zone_Kapul && enterState == ZoneTransition.EnterState.Left)
        {
            enterState = ZoneTransition.EnterState.Right;
        }
        float rate = zoneTransition?.ratePos ?? (-1f);
        if (IsPCFaction)
        {
            if ((uint)(enterState - 3) <= 4u || enterState == ZoneTransition.EnterState.Return)
            {
                Thing spot = EClass._map.props.installed.Find<TraitSpotGuidePC>();
                if (spot != null)
                {
                    Point nearestPoint = (spot.trait as TraitSpotGuidePC).GetRandomPoint((Point p) => !p.IsBlocked && !p.Equals(spot.pos)).GetNearestPoint();
                    if (nearestPoint != null && nearestPoint.IsValid)
                    {
                        return nearestPoint;
                    }
                }
            }
        }
        while (true)
        {
            switch (enterState)
            {
            case ZoneTransition.EnterState.UndergroundOrSky:
                return new Point(zoneTransition.x, zoneTransition.z);
            case ZoneTransition.EnterState.Teleport:
            {
                foreach (Thing thing2 in map.things)
                {
                    if (thing2.IsInstalled)
                    {
                        TraitTeleporter traitTeleporter = thing2.trait as TraitTeleporter;
                        if (traitTeleporter != null)
                        {
                            Debug.Log(zoneTransition.idTele + "/" + traitTeleporter.id.IsEmpty(traitTeleporter.GetParam(3)) + "/" + traitTeleporter.GetParam(3));
                        }
                        if (traitTeleporter != null && !zoneTransition.idTele.IsEmpty() && zoneTransition.idTele == traitTeleporter.id.IsEmpty(traitTeleporter.GetParam(3)))
                        {
                            return thing2.pos.GetNearestPoint();
                        }
                    }
                }
                foreach (Thing thing3 in map.things)
                {
                    if (thing3.IsInstalled && thing3.trait is TraitTeleporter traitTeleporter2 && traitTeleporter2.IsFor(zoneTransition.lastZone))
                    {
                        return thing3.pos.GetNearestPoint();
                    }
                }
                Thing randomThing2 = EClass._map.props.installed.traits.GetRandomThing<TraitTeleporter>();
                if (randomThing2 != null)
                {
                    return randomThing2.pos.GetNearestPoint();
                }
                goto case ZoneTransition.EnterState.Return;
            }
            case ZoneTransition.EnterState.Return:
            case ZoneTransition.EnterState.Elevator:
            case ZoneTransition.EnterState.Moongate:
            {
                if (enterState == ZoneTransition.EnterState.Elevator)
                {
                    foreach (Thing thing4 in map.things)
                    {
                        if (thing4.IsInstalled && thing4.trait is TraitElevator traitElevator && traitElevator.IsFor(zoneTransition.lastZone))
                        {
                            return thing4.pos.GetNearestPoint();
                        }
                    }
                    Thing randomThing = EClass._map.props.installed.traits.GetRandomThing<TraitElevator>();
                    if (randomThing != null)
                    {
                        return randomThing.pos.GetNearestPoint();
                    }
                }
                Thing thing = null;
                if (enterState == ZoneTransition.EnterState.Return && EClass.game.IsSurvival)
                {
                    thing = map.props.installed.traits.GetRandomThing<TraitLandingPortal>();
                    if (thing != null)
                    {
                        return thing.pos;
                    }
                }
                thing = map.props.installed.traits.GetRandomThing<TraitWaystone>();
                if (thing != null)
                {
                    return thing.pos.GetNearestPoint();
                }
                thing = map.props.installed.traits.GetRandomThing<TraitCoreZone>();
                if (thing != null)
                {
                    return thing.pos.GetNearestPoint();
                }
                if (base.lv == 0)
                {
                    goto IL_04da;
                }
                flag = base.lv <= 0;
                break;
            }
            case ZoneTransition.EnterState.Center:
            case ZoneTransition.EnterState.Encounter:
                if (map.config.embarkX != 0)
                {
                    return new Point(map.config.embarkX, map.config.embarkY);
                }
                return map.GetCenterPos().GetNearestPoint(allowBlock: false, allowChara: false);
            case ZoneTransition.EnterState.Top:
                return map.bounds.GetTopPos(rate).GetNearestPoint(allowBlock: false, allowChara: false);
            case ZoneTransition.EnterState.Right:
                return map.bounds.GetRightPos(rate).GetNearestPoint(allowBlock: false, allowChara: false);
            case ZoneTransition.EnterState.Bottom:
                return map.bounds.GetBottomPos(rate).GetNearestPoint(allowBlock: false, allowChara: false);
            case ZoneTransition.EnterState.Left:
                return map.bounds.GetLeftPos(rate).GetNearestPoint(allowBlock: false, allowChara: false);
            case ZoneTransition.EnterState.Dead:
            case ZoneTransition.EnterState.Exact:
            case ZoneTransition.EnterState.PortalReturn:
            case ZoneTransition.EnterState.Fall:
                if (zoneTransition.x == 0 && EClass._map.bounds.x != 0)
                {
                    return new Point(map.config.embarkX, map.config.embarkY);
                }
                return new Point(zoneTransition.x, zoneTransition.z);
            case ZoneTransition.EnterState.RandomVisit:
                return GetRandomVisitPos(c);
            case ZoneTransition.EnterState.Down:
                flag = true;
                break;
            case ZoneTransition.EnterState.Up:
                flag = false;
                break;
            }
            break;
            IL_04da:
            enterState = ZoneTransition.EnterState.Center;
        }
        foreach (Thing thing5 in map.things)
        {
            if (thing5.trait is TraitNewZone { zone: not null } traitNewZone && zone != null && traitNewZone.zone.uid == zone.uid)
            {
                if (c != null && enterState != 0)
                {
                    c.SetDir(traitNewZone.owner.dir);
                }
                return traitNewZone.GetExitPos();
            }
        }
        foreach (Thing thing6 in map.things)
        {
            if (thing6.trait is TraitNewZone traitNewZone2 && ((flag && traitNewZone2.IsUpstairs) || (!flag && traitNewZone2.IsDownstairs)))
            {
                if (c != null && enterState != 0)
                {
                    c.SetDir(traitNewZone2.owner.dir);
                }
                return traitNewZone2.GetExitPos();
            }
        }
        return GetRandomVisitPos(c);
    }
 
    public Point GetRandomVisitPos(Chara c)
    {
        Point point = null;
        if (EClass.rnd(3) == 0 && map.rooms.listRoom.Count > 0)
        {
            point = map.rooms.listRoom.RandomItem().points.RandomItem();
        }
        if (point == null && EClass.rnd(4) != 0)
        {
            IEnumerable<Chara> ie = map.charas.Where((Chara t) => t.trait.ShopType != 0 && t.pos != null && t.pos.IsValid);
            if (ie.Count() > 0)
            {
                point = ie.RandomItem().pos.GetRandomPoint(3);
            }
        }
        if (point == null)
        {
            point = map.bounds.GetRandomSurface(centered: false, walkable: true, !IsPCFaction && !(this is Zone_Civilized)) ?? map.bounds.GetRandomPoint();
        }
        return point.GetNearestPoint(allowBlock: false, allowChara: false, allowInstalled: false) ?? EClass._map.GetCenterPos().GetNearestPoint();
    }
 
    public void AddGlobalCharasOnActivate()
    {
        Point spawnPosPC = null;
        if (EClass.pc.currentZone == this)
        {
            spawnPosPC = GetSpawnPos(EClass.pc);
        }
        if (spawnPosPC == null)
        {
            spawnPosPC = map.GetCenterPos();
        }
        if (spawnPosPC.IsValid && EClass.pc.global.transition != null && spawnPosPC.HasBlock)
        {
            spawnPosPC = spawnPosPC.GetNearestPoint();
        }
        spawnPosPC = spawnPosPC.Clamp(useBounds: true).GetNearestPoint();
        foreach (Chara c in EClass.game.cards.globalCharas.Values)
        {
            if (c.currentZone != this)
            {
                continue;
            }
            if (c.parent is Chara)
            {
                Chara chara = c.parent as Chara;
                c.currentZone = chara.currentZone;
            }
            else
            {
                if (c.isDead)
                {
                    continue;
                }
                if (c.isRestrained && c.currentZone == EClass.pc.currentZone && (!c.pos.IsValid || c.pos.FindThing<TraitShackle>() == null))
                {
                    c.isRestrained = false;
                }
                if (c.global.transition != null)
                {
                    Point pos = (c.IsPC ? spawnPosPC : (c.IsPCParty ? spawnPosPC.GetNearestPoint(allowBlock: false, allowChara: false, allowInstalled: true, ignoreCenter: true) : GetSpawnPos(c)));
                    if (c.IsPCParty && !c.IsPC)
                    {
                        if (c.host == EClass.pc)
                        {
                            pos.Set(spawnPosPC);
                        }
                        else if (pos.Equals(spawnPosPC) || !PathManager.Instance.IsPathClear(spawnPosPC, pos, c, 5))
                        {
                            c.pos.Set(spawnPosPC);
                            if (!spawnPosPC.ForeachNearestPoint(delegate(Point p)
                            {
                                if (PathManager.Instance.IsPathClear(spawnPosPC, p, c, 10) && !p.Equals(spawnPosPC))
                                {
                                    pos.Set(p);
                                    return true;
                                }
                                return false;
                            }, allowBlock: false, EClass.pc.party.members.Count >= 12, allowInstalled: true, ignoreCenter: true, EClass._zone.IsRegion ? 2 : 6))
                            {
                                pos.Set(spawnPosPC);
                            }
                        }
                    }
                    c.pos.Set(pos);
                    c.global.transition = null;
                }
                map.charas.Add(c);
                map.AddCardOnActivate(c);
            }
        }
        foreach (Chara item in EClass.player.listCarryoverMap)
        {
            Point nearestPoint = spawnPosPC.GetNearestPoint(allowBlock: false, allowChara: false, allowInstalled: true, ignoreCenter: true);
            item.enemy = null;
            item.pos.Set(nearestPoint);
            map.charas.Add(item);
            map.AddCardOnActivate(item);
        }
        EClass.player.listCarryoverMap.Clear();
    }
 
    public void Deactivate()
    {
        if (!IsUserZone && !IsPCFaction && map != null)
        {
            List<Thing> list = new List<Thing>();
            foreach (Thing thing in map.things)
            {
                if (thing.rarity >= Rarity.Artifact && thing.HasTag(CTAG.godArtifact))
                {
                    list.Add(thing);
                }
            }
            if (this is Zone_Tent)
            {
                foreach (Thing item in map.props.stocked.Things.Concat(map.props.roaming.Things))
                {
                    if (item.IsContainer)
                    {
                        foreach (Thing thing2 in item.things)
                        {
                            if (thing2.trait is TraitTent)
                            {
                                list.Add(thing2);
                            }
                        }
                    }
                    if (item.trait is TraitTent)
                    {
                        list.Add(item);
                    }
                }
            }
            if (list.Count > 0)
            {
                Msg.Say("pick_valuable");
                foreach (Thing item2 in list)
                {
                    Msg.Say("pick_valuable2", item2);
                    EClass.pc.AddCard(item2);
                }
            }
        }
        if (!EClass.player.simulatingZone)
        {
            base.isPeace = false;
        }
        OnBeforeDeactivate();
        if (IsPCFaction)
        {
            foreach (Chara member in branch.members)
            {
                member.ValidateWorks();
            }
        }
        EClass.game.lastActiveZone = EClass.game.activeZone;
        base.lastActive = EClass.world.date.GetRaw();
        map.OnDeactivate();
        EClass.scene.Clear();
        EClass.game.activeZone = null;
        if (IsInstance)
        {
            UnloadMap();
            base.isGenerated = false;
        }
        if (forceRegenerate)
        {
            UnloadMap();
        }
        OnDeactivate();
    }
 
    public void OnKillGame()
    {
        foreach (Thing thing in map.things)
        {
            if (thing.renderer.hasActor)
            {
                thing.renderer.KillActor();
            }
        }
    }
 
    public void UnloadMap()
    {
        map = null;
        if (bp != null)
        {
            bp.map = null;
        }
        if (branch != null)
        {
            branch.OnUnloadMap();
        }
        Debug.Log("Unloaded Map:" + this);
    }
 
    public void ClaimZone(bool debug = false, Point pos = null)
    {
        EClass._map.RevealAll();
        SetMainFaction(EClass.pc.faction);
        branch = new FactionBranch();
        branch.OnCreate(this);
        if (base.icon == 0)
        {
            base.icon = 332;
        }
        instance = null;
        base.dateExpire = 0;
        SetInt(2, EClass.world.date.GetRaw());
        Register();
        foreach (Thing thing in map.things)
        {
            thing.isNPCProperty = false;
        }
        EClass.Branch.OnClaimZone();
        EClass.scene.elomap.SetZone(EClass._zone.x, EClass._zone.y, EClass._zone, updateMesh: true);
        if (debug)
        {
            for (int i = 0; i < 7; i++)
            {
                Chara chara = CharaGen.CreateFromFilter("c_neutral");
                EClass._zone.AddCard(chara, EClass._map.bounds.GetRandomPoint().GetNearestPoint(allowBlock: false, allowChara: false, allowInstalled: false));
                branch.AddMemeber(chara);
            }
        }
        else
        {
            Msg.Say("claimedZone");
            EClass.Branch.Log("claimedZone");
            EClass.Sound.Play("jingle_embark");
            EClass.pc.PlaySound("build");
            if (pos == null)
            {
                pos = EClass.pc.pos.GetNearestPoint(allowBlock: false, allowChara: true, allowInstalled: false);
            }
            Effect.Get("aura_heaven").Play(pos);
            EClass._zone.AddCard(ThingGen.Create("core_zone"), pos).SetPlaceState(PlaceState.installed);
        }
        base.idPrefix = 0;
        if (EClass._zone == EClass.game.StartZone)
        {
            EClass.player.spawnZone = EClass._zone;
        }
        if (EClass._zone != EClass.game.StartZone && !(EClass._zone is Zone_Vernis))
        {
            EClass._zone.SetBGM(new List<int> { 41, 90, 44, 43 });
            EClass._zone.RefreshPlaylist();
        }
    }
 
    public void AbandonZone()
    {
        FactionBranch destBranch = ((EClass.pc.homeBranch == branch) ? EClass.game.StartZone.branch : EClass.pc.homeBranch);
        branch.members.ForeachReverse(delegate(Chara m)
        {
            destBranch.AddMemeber(m);
            if (!m.IsPCParty)
            {
                m.MoveZone(destBranch.owner);
            }
        });
        EClass.Branch.OnUnclaimZone();
        SetMainFaction(null);
        base.dateExpire = EClass.world.date.GetRaw() + 10080;
    }
 
    public bool CanDestroy()
    {
        if (IsActiveZone || IsPCFaction || EClass.player.simulatingZone)
        {
            return false;
        }
        if (IsInstance)
        {
            return true;
        }
        bool flag = false;
        switch (id)
        {
        case "cave_dragon":
            if (!(this is Zone_DungeonDragon))
            {
                flag = true;
            }
            break;
        case "cave_yeek":
            if (!(this is Zone_DungeonYeek))
            {
                flag = true;
            }
            break;
        case "cave_mino":
            if (!(this is Zone_DungeonMino))
            {
                flag = true;
            }
            break;
        case "cave_dead":
            if (!(this is Zone_DungeonDead))
            {
                flag = true;
            }
            break;
        }
        Zone topZone = GetTopZone();
        if (!flag)
        {
            if (base.dateExpire == 0 || !EClass.world.date.IsExpired(base.dateExpire))
            {
                return false;
            }
            if (!base.isRandomSite && !(this is Zone_Field) && (topZone == null || topZone == this || topZone.FindDeepestZone() == this))
            {
                return false;
            }
        }
        if (EClass.pc.currentZone == null || EClass.pc.currentZone is Zone_Tent || topZone == EClass.pc.currentZone.GetTopZone() || (EClass.player.nextZone != null && topZone == EClass.player.nextZone.GetTopZone()))
        {
            return false;
        }
        if (EClass.pc.currentZone.IsInstance)
        {
            Zone zone = EClass.game.spatials.Find(EClass.pc.currentZone.instance.uidZone);
            if (zone != null && zone.GetTopZone() == this)
            {
                return false;
            }
        }
        return true;
    }
 
    public override void _OnBeforeSave()
    {
        if (CanDestroy())
        {
            Debug.Log("Deleting Zone:" + this);
            if (!destryoed)
            {
                Destroy();
            }
        }
        else if (map != null)
        {
            Debug.Log("Saving Zone:" + this);
            map.Save(base.pathSave);
            if (!base.isMapSaved)
            {
                base.isMapSaved = true;
                IO.DeleteDirectory(base.pathSave + "Texture Replace");
                IO.CopyDir(pathTemp + "Texture Replace", base.pathSave + "/Texture Replace");
            }
            if (!IsActiveZone)
            {
                UnloadMap();
            }
        }
    }
 
    public override void OnLoad()
    {
        if (branch != null)
        {
            branch.SetOwner(this);
        }
        events.OnLoad(this);
    }
 
    public override void Destroy()
    {
        children.ForeachReverse(delegate(Spatial z)
        {
            z.Destroy();
        });
        if (map != null)
        {
            UnloadMap();
        }
        if (parent != null && parent.IsRegion && instance == null)
        {
            EClass.scene.elomap.SetZone(base.x, base.y, null, updateMesh: true);
        }
        EClass.game.spatials.Remove(this);
        destryoed = true;
        base.isGenerated = false;
    }
 
    public void ClearZones(Zone current = null)
    {
        if (map != null)
        {
            UnloadMap();
        }
        base.isGenerated = false;
        Zone topZone = GetTopZone();
        if (topZone != this)
        {
            topZone.ClearZones(this);
            return;
        }
        children.ForeachReverse(delegate(Spatial c)
        {
            if (c != current)
            {
                c.Destroy();
            }
        });
    }
 
    public void OnChildNumChange(Card c)
    {
    }
 
    public ICardParent GetRoot()
    {
        return this;
    }
 
    public Zone GetTopZone()
    {
        if (parent == null || parent.IsRegion)
        {
            return this;
        }
        return parent as Zone;
    }
 
    public Card AddCardSplinkle(Card t, Point center, int radius = 4)
    {
        Point point = new Point(center);
        for (int i = 0; i < 1000; i++)
        {
            point.x = center.x + EClass.rnd(radius) - EClass.rnd(radius);
            point.z = center.z + EClass.rnd(radius) - EClass.rnd(radius);
            if (point.IsValid && !point.IsBlocked && !point.HasChara)
            {
                return AddCard(t, point);
            }
        }
        return AddCard(t, center);
    }
 
    public Chara AddChara(string id, int x, int z)
    {
        return AddCard(CharaGen.Create(id), x, z) as Chara;
    }
 
    public Chara AddChara(string id, Point p)
    {
        return AddChara(id, p.x, p.z);
    }
 
    public Card AddThing(string id, int x, int z)
    {
        return AddCard(ThingGen.Create(id), x, z);
    }
 
    public Card AddThing(string id, Point p)
    {
        return AddThing(id, p.x, p.z);
    }
 
    public Card AddCard(Card t, Point point)
    {
        return AddCard(t, point.x, point.z);
    }
 
    public Card AddCard(Card t)
    {
        return AddCard(t, 0, 0);
    }
 
    public Card AddCard(Card t, int x, int z)
    {
        if (t.parent != null)
        {
            t.parent.RemoveCard(t);
        }
        t.parent = this;
        Chara chara = t.Chara;
        if (chara != null)
        {
            chara.currentZone = this;
            chara.SetAI(new NoGoal());
        }
        if (IsActiveZone)
        {
            map.OnCardAddedToZone(t, x, z);
            if (isStarted && t.isThing && t.placeState == PlaceState.roaming && !ignoreSpawnAnime)
            {
                t.PlayAnimeLoot();
            }
            ignoreSpawnAnime = false;
        }
        if (chara != null && EClass.player != null && !chara.hasSpawned)
        {
            EClass.player.codex.AddSpawn(chara.id);
            chara.hasSpawned = true;
        }
        return t;
    }
 
    public void RemoveCard(Card t)
    {
        if (IsActiveZone)
        {
            map.OnCardRemovedFromZone(t);
        }
        t.parent = null;
        if (t.isChara)
        {
            t.Chara.currentZone = null;
        }
        if (t.isThing && !t.trait.IDActorEx.IsEmpty())
        {
            EClass.scene.RemoveActorEx(t);
        }
        if (t.renderer.hasActor)
        {
            t.renderer.OnLeaveScreen();
        }
    }
 
    public T GetRandomSpot<T>() where T : Trait
    {
        return EClass._map.props.installed.traits.GetRandomThing<T>() as T;
    }
 
    public bool TryAddThingInSpot<T>(Thing t, bool useContainer = true) where T : Trait
    {
        Thing randomThing = EClass._map.props.installed.traits.GetRandomThing<T>();
        if (randomThing == null)
        {
            AddCard(t, EClass._map.bounds.GetRandomSurface());
            return false;
        }
        if (useContainer && (!t.IsContainer || t.things.Count == 0))
        {
            List<Thing> list = new List<Thing>();
            foreach (Point item in randomThing.trait.ListPoints(null, onlyPassable: false))
            {
                foreach (Card item2 in item.ListCards())
                {
                    if (item2.IsContainer && !(item2.trait is TraitDeliveryChest))
                    {
                        list.Add(item2.Thing);
                    }
                }
            }
            if (TryAddThingInSharedContainer(t, list, add: true, msg: false, null, sharedOnly: false))
            {
                return true;
            }
        }
        AddCard(t, randomThing.trait.GetRandomPoint());
        return true;
    }
 
    public List<Thing> TryListThingsInSpot<T>(Func<Thing, bool> func = null) where T : TraitSpot
    {
        List<T> list = new List<T>();
        List<Thing> list2 = new List<Thing>();
        foreach (Thing thing in EClass._map.things)
        {
            if (thing.IsInstalled && thing.trait is T)
            {
                list.Add(thing.trait as T);
            }
        }
        foreach (T item in list)
        {
            foreach (Point item2 in item.ListPoints(null, onlyPassable: false))
            {
                foreach (Thing thing2 in item2.Things)
                {
                    if (!thing2.IsInstalled)
                    {
                        continue;
                    }
                    if (thing2.things.Count == 0)
                    {
                        if (IsValid(thing2))
                        {
                            list2.Add(thing2);
                        }
                        continue;
                    }
                    foreach (Thing item3 in thing2.things.List((Thing _t) => IsValid(_t)))
                    {
                        list2.Add(item3);
                    }
                }
            }
        }
        return list2;
        bool IsValid(Thing t)
        {
            if (func != null && !func(t))
            {
                return false;
            }
            return true;
        }
    }
 
    public bool TryAddThingInSharedContainer(Thing t, List<Thing> containers = null, bool add = true, bool msg = false, Chara chara = null, bool sharedOnly = true)
    {
        Thing dest = null;
        int priority = -1;
        ContainerFlag flag = t.category.GetRoot().id.ToEnum<ContainerFlag>();
        if (flag == ContainerFlag.none)
        {
            flag = ContainerFlag.other;
        }
        if (containers == null)
        {
            containers = EClass._map.props.installed.containers;
        }
        if (SearchDest() != null)
        {
            return true;
        }
        if (dest == null)
        {
            return false;
        }
        if (add)
        {
            if (msg)
            {
                chara.Say("putSharedItem", chara, t, dest.GetName(NameStyle.Full));
            }
            dest.AddThing(t);
        }
        return true;
        Thing SearchDest()
        {
            foreach (Thing container in containers)
            {
                Thing thing = container;
                if (thing.trait is TraitShippingChest)
                {
                    thing = EClass.game.cards.container_shipping;
                }
                if ((!sharedOnly || thing.IsSharedContainer) && thing.c_lockLv <= 0 && (thing.things.Count < thing.things.MaxCapacity || thing.things.CanStack(t) != t))
                {
                    Window.SaveData windowSaveData = thing.GetWindowSaveData();
                    if (windowSaveData != null)
                    {
                        if (windowSaveData.priority <= priority || (windowSaveData.noRotten && t.IsDecayed) || (windowSaveData.onlyRottable && t.trait.Decay == 0))
                        {
                            continue;
                        }
                        Window.SaveData.FilterResult filterResult = Window.SaveData.FilterResult.Pass;
                        if (windowSaveData.userFilter)
                        {
                            filterResult = windowSaveData.IsFilterPass(t.GetName(NameStyle.Full, 1));
                            if (filterResult == Window.SaveData.FilterResult.Block)
                            {
                                continue;
                            }
                        }
                        if (filterResult != Window.SaveData.FilterResult.PassWithoutFurtherTest)
                        {
                            if (windowSaveData.advDistribution)
                            {
                                bool flag2 = false;
                                foreach (int cat in windowSaveData.cats)
                                {
                                    if (t.category.uid == cat)
                                    {
                                        flag2 = true;
                                        break;
                                    }
                                }
                                if (!flag2)
                                {
                                    continue;
                                }
                            }
                            else if (windowSaveData.flag.HasFlag(flag))
                            {
                                continue;
                            }
                        }
                        priority = windowSaveData.priority;
                    }
                    else
                    {
                        if (priority != -1)
                        {
                            continue;
                        }
                        priority = 0;
                    }
                    dest = thing;
                }
            }
            return null;
        }
    }
 
    public bool TryAddThing(Thing target, Point p, bool destroyIfFail = false)
    {
        int num = 0;
        if (p.cell.detail != null)
        {
            foreach (Thing thing in p.cell.detail.things)
            {
                if (thing.placeState == PlaceState.roaming)
                {
                    if (target.TryStackTo(thing))
                    {
                        return true;
                    }
                    num++;
                }
            }
        }
        if (num == 0 || !destroyIfFail)
        {
            EClass._zone.AddCard(target, p);
            return true;
        }
        target.Destroy();
        return false;
    }
 
    public Thing TryGetThingFromSharedContainer(Func<Thing, bool> func)
    {
        foreach (Thing container in EClass._map.props.installed.containers)
        {
            if (container.IsSharedContainer)
            {
                Thing thing = container.things.Find(func);
                if (thing != null)
                {
                    return thing;
                }
            }
        }
        return null;
    }
 
    public Thing TryGetRestock<T>(string idCat) where T : TraitSpot
    {
        List<T> list = new List<T>();
        foreach (Thing thing2 in EClass._map.things)
        {
            if (thing2.IsInstalled && thing2.trait is T)
            {
                list.Add(thing2.trait as T);
            }
        }
        foreach (T item in list)
        {
            foreach (Point item2 in item.ListPoints(null, onlyPassable: false))
            {
                foreach (Thing thing3 in item2.Things)
                {
                    if (!thing3.IsInstalled || thing3.isSale)
                    {
                        continue;
                    }
                    if (thing3.things.Count == 0)
                    {
                        if (IsValid(thing3, insideContainer: false))
                        {
                            return thing3;
                        }
                        continue;
                    }
                    Thing thing = thing3.things.Find((Thing _t) => IsValid(_t, insideContainer: true));
                    if (thing != null)
                    {
                        return thing;
                    }
                }
            }
        }
        return null;
        bool IsValid(Thing t, bool insideContainer)
        {
            if (t.category.id != idCat || !TraitSalesTag.CanTagSale(t, insideContainer))
            {
                return false;
            }
            return true;
        }
    }
 
    public ZoneProfile GetProfile()
    {
        string text = IdProfile;
        if (text.IsEmpty())
        {
            Region region = parent as Region;
            if (base.lv != 0)
            {
                text = ((base.lv < 0) ? "Underground" : "Sky");
            }
            else if (region != null)
            {
                EClass.scene.elomapActor.Initialize(region.elomap);
                text = EClass.scene.elomapActor.elomap.GetTileInfo(base.x, base.y).idZoneProfile;
                if (bp != null)
                {
                    name = Lang.GetList("zone_" + text.Split('/')[1]).RandomItem();
                    bp.surrounding = new EloMap.TileInfo[3, 3];
                    for (int i = 0; i < 3; i++)
                    {
                        for (int j = 0; j < 3; j++)
                        {
                            bp.surrounding[j, i] = EClass.scene.elomapActor.elomap.GetTileInfo(base.x - 1 + j, base.y - 1 + i);
                        }
                    }
                    if (text == "Random/R_Shore")
                    {
                        base.isBeach = true;
                    }
                }
            }
            else
            {
                text = "Random";
            }
            idProfile = text;
        }
        return ZoneProfile.Load(text);
    }
 
    public void CreateBP()
    {
        bp = new ZoneBlueprint();
        bp.Create();
        bp.genSetting.seed = base.Seed;
        OnCreateBP();
    }
 
    public virtual void OnCreateBP()
    {
    }
 
    public void Generate()
    {
        base.isGenerated = true;
        if (bp == null)
        {
            CreateBP();
        }
        if (bp.map == null)
        {
            bp.GenerateMap(this);
        }
        map.SetZone(this);
        Zone_Field zone_Field = this as Zone_Field;
        bool flag = IdBiome == "Sand" || IdBiome == "Water" || IsUnderwater;
        if (flag)
        {
            int num = 1 + EClass.rnd((IdBiome == "Water") ? 3 : 2);
            for (int i = 0; i < num; i++)
            {
                Point randomSurface = EClass._map.bounds.GetRandomSurface(centered: false, walkable: true, allowWater: true);
                if (!randomSurface.HasObj && !randomSurface.HasThing)
                {
                    Thing t = ThingGen.Create("pearl_oyster", new string[3] { "wood_birch", "poplar", "coralwood" }.RandomItem(), ContentLv);
                    EClass._zone.AddCard(t, randomSurface).Install();
                }
            }
            num = 4 + EClass.rnd(5);
            for (int j = 0; j < num; j++)
            {
                Point randomSurface2 = EClass._map.bounds.GetRandomSurface(centered: false, walkable: true, allowWater: true);
                if (!randomSurface2.HasObj && !randomSurface2.HasThing && (IsUnderwater || randomSurface2.cell.IsTopWaterAndNoSnow || EClass.rnd(6) == 0))
                {
                    EClass._zone.AddCard(ThingGen.Create("70", -1, ContentLv), randomSurface2);
                }
            }
            for (int k = 0; k < EClass.rnd(EClass.rnd(base.isBeach ? 5 : 3) + 1); k++)
            {
                Point randomSurface3 = EClass._map.bounds.GetRandomSurface(centered: false, walkable: true, allowWater: true);
                if (!randomSurface3.HasObj)
                {
                    EClass._zone.AddCard(ThingGen.Create("bottle_message"), randomSurface3);
                }
            }
        }
        if (IsUnderwater)
        {
            for (int l = 0; l < 30 + EClass.rnd(30); l++)
            {
                SpawnMob(null, SpawnSetting.Fish());
            }
            Crawler crawler = Crawler.Create("pasture");
            int num2 = (EClass.debug.enable ? 3 : EClass.rnd(EClass.rnd(EClass.rnd(EClass.rnd(5) + 1) + 1) + 1));
            bool flag2 = this is Zone_Field;
            Thing seed = null;
            if (IsNefia)
            {
                int num3 = Mathf.Min(EClass._zone.DangerLv, EClass.pc.Evalue(286) * 2 / 3);
                if (num3 > 0)
                {
                    seed = TraitSeed.MakeSeed(EClass.sources.objs.map[137]);
                    Rand.SetSeed(EClass._zone.uid * 10 + num3);
                    TraitSeed.LevelSeed(seed, (seed.trait as TraitSeed).row, num3);
                    Rand.SetSeed();
                    seed.elements.SetBase(2, EClass.curve(seed.encLV, 50, 10, 80));
                }
            }
            crawler.CrawlUntil(EClass._map, () => EClass._map.GetRandomPoint(), num2 + (flag2 ? 4 : 0), delegate(Crawler.Result r)
            {
                int num6 = 137;
                foreach (Point point in r.points)
                {
                    if (!point.cell.isModified && !point.HasThing && !point.HasBlock && !point.HasObj)
                    {
                        map.SetObj(point.x, point.z, num6);
                        int idx = 3 + ((EClass.rnd(3) == 0) ? 1 : 0) + ((EClass.rnd(3) == 0) ? (-1) : 0) + ((EClass.rnd(3) == 0) ? (-1) : 0);
                        point.growth.SetStage(idx);
                        if (seed != null)
                        {
                            EClass._map.AddPlant(point, seed);
                        }
                    }
                }
                return false;
            });
            crawler.CrawlUntil(tries: EClass.rnd(EClass.rnd(5) + 1) + 1 + (flag2 ? 20 : 0), map: EClass._map, onStart: () => EClass._map.GetRandomPoint(), canComplete: delegate(Crawler.Result r)
            {
                int num5 = 136;
                foreach (Point point2 in r.points)
                {
                    if (!point2.cell.isModified && !point2.HasThing && !point2.HasBlock && !point2.HasObj)
                    {
                        map.SetObj(point2.x, point2.z, num5, 1, EClass.rnd(4));
                    }
                }
                return false;
            });
            crawler.CrawlUntil(tries: EClass.rnd(EClass.rnd(10) + 1) + 3 + (flag2 ? 40 : 0), map: EClass._map, onStart: () => EClass._map.GetRandomPoint(), canComplete: delegate(Crawler.Result r)
            {
                int idFloor = 121;
                foreach (Point point3 in r.points)
                {
                    map.SetFloor(point3.x, point3.z, 97, idFloor, Mathf.Clamp(4 - r.startPos.Distance(point3) + EClass.rnd(3) - EClass.rnd(3), 0, 3));
                }
                return false;
            });
        }
        if (zone_Field != null)
        {
            if (EClass.rnd(3) == 0)
            {
                int num4 = EClass.rnd(2);
                for (int m = 0; m < num4; m++)
                {
                    Point randomSurface4 = EClass._map.bounds.GetRandomSurface();
                    if (!randomSurface4.HasObj && !randomSurface4.HasThing)
                    {
                        Card t2 = ThingGen.Create("chest3").ChangeMaterial(biome.style.matDoor);
                        EClass._zone.AddCard(t2, randomSurface4).Install();
                    }
                }
            }
            if (EClass.rnd(8) == 0)
            {
                SpawnAltar();
            }
            TrySpawnFollower();
            if (!flag && EClass.rnd(EClass.debug.enable ? 1 : 10) == 0)
            {
                Point randomSurface5 = EClass._map.bounds.GetRandomSurface();
                if (randomSurface5.IsValid)
                {
                    EClass._zone.AddCard(CharaGen.Create("priest"), randomSurface5);
                }
            }
            if (base.Tile.isRoad)
            {
                for (int n = 0; n < EClass.rnd(4); n++)
                {
                    EClass._zone.SpawnMob(map.GetCenterPos().GetRandomPointInRadius(2, 6, requireLos: false, allowChara: false), SpawnSetting.HomeGuest(EClass._zone.DangerLv));
                }
            }
        }
        map.plDay = CreatePlaylist(ref map._plDay, EClass.Sound.GetPlaylist(IDPlayList) ?? EClass.Sound.GetPlaylist("Day"));
    }
 
    public void TrySpawnFollower()
    {
        bool flag = EClass.pc.HasCondition<ConDrawBacker>();
        if (!EClass.debug.enable && EClass.rnd(flag ? 3 : 20) != 0)
        {
            return;
        }
        Point randomSurface = EClass._map.bounds.GetRandomSurface();
        if (!randomSurface.IsValid)
        {
            return;
        }
        Chara c = CharaGen.Create("follower");
        EClass._zone.AddCard(c, randomSurface);
        (EClass._zone.AddThing("gallows", randomSurface).Install().trait as TraitShackle).Restrain(c);
        c.c_rescueState = RescueState.WaitingForRescue;
        if (EClass.rnd(flag ? 1 : 2) == 0 || EClass.debug.enable)
        {
            SourceBacker.Row row = EClass.sources.backers.listFollower.NextItem(ref BackerContent.indexFollower);
            if (row != null)
            {
                c.ApplyBacker(row.id);
            }
        }
        Religion faith = EClass.game.religions.dictAll.Values.Where((Religion a) => a != c.faith).RandomItem();
        for (int i = 0; i < 3 + EClass.rnd(4); i++)
        {
            Chara chara = CharaGen.Create("fanatic");
            chara.SetFaith(faith);
            Point point = randomSurface.GetRandomPoint(4) ?? randomSurface.GetNearestPoint();
            EClass._zone.AddCard(chara, point);
        }
    }
 
    public void SpawnAltar()
    {
        EClass.core.refs.crawlers.start.CrawlUntil(map, () => map.poiMap.GetCenterCell().GetCenter(), 1, delegate(Crawler.Result r)
        {
            if (r.points.Count <= 4)
            {
                return false;
            }
            map.poiMap.OccyupyPOI(r.points[0]);
            List<Point> points = r.points;
            Religion randomReligion = EClass.game.religions.GetRandomReligion();
            "altarPoint".lang(randomReligion.NameDomain.lang());
            Thing thing = ThingGen.Create("altar");
            (thing.trait as TraitAltar).SetDeity(randomReligion.id);
            Chara t = CharaGen.Create("twintail");
            EClass._zone.AddCard(t, points.RandomItem());
            for (int i = 0; i < 2 + EClass.rnd(2); i++)
            {
                Chara t2 = CharaGen.Create("twintail");
                EClass._zone.AddCard(t2, points.RandomItem());
            }
            if (points[0].Installed == null)
            {
                EClass._zone.AddCard(thing, points[0]).Install();
            }
            foreach (Point item in points)
            {
                if (item.x % 3 == 0 && item.z % 2 == 0 && item != points[0] && !item.Equals(points[0].Front) && item.Installed == null)
                {
                    thing = ThingGen.Create("pillar1");
                    EClass._zone.AddCard(thing, item).Install();
                }
                item.SetObj();
                item.SetFloor(3, 6);
            }
            return true;
        });
    }
 
    public virtual void OnGenerateMap()
    {
        if (MakeEnemiesNeutral)
        {
            foreach (Chara chara in EClass._map.charas)
            {
                if (!chara.IsGlobal && chara.hostility < Hostility.Neutral && chara.OriginalHostility < Hostility.Friend)
                {
                    Hostility hostility2 = (chara.c_originalHostility = Hostility.Neutral);
                    chara.hostility = hostility2;
                }
            }
        }
        if (PrespawnRate != 0f && !IsSkyLevel)
        {
            for (int i = 0; i < (int)((float)MaxSpawn * PrespawnRate); i++)
            {
                SpawnMob();
            }
        }
        TryGenerateOre();
        TryGenerateBigDaddy();
        TryGenerateEvolved();
        TryGenerateShrine();
    }
 
    public void TryGenerateOre()
    {
        if (OreChance <= 0f)
        {
            return;
        }
        Crawler.Create("ore").CrawlUntil(tries: EClass.rnd((int)((float)(map.bounds.Width * map.bounds.Height / 200 + 1) * OreChance + 2f)), map: EClass._map, onStart: () => EClass._map.bounds.GetRandomPoint(), canComplete: delegate(Crawler.Result r)
        {
            byte b = 18;
            string group = "ore";
            if (EClass.rnd(5) == 0)
            {
                b++;
                group = "gem";
            }
            SourceMaterial.Row randomMaterial = MATERIAL.GetRandomMaterial(DangerLv, group);
            foreach (Point point in r.points)
            {
                if (point.sourceBlock.ContainsTag("ore"))
                {
                    map.SetObj(point.x, point.z, randomMaterial.id, b, 1, 0);
                }
            }
            return false;
        });
    }
 
    public Chara TryGenerateEvolved(bool force = false, Point p = null)
    {
        float num = EvolvedChance * (EClass.pc.HasElement(1270) ? 1.1f : 1f);
        if (!force && num <= EClass.rndf(1f))
        {
            return null;
        }
        Chara chara = SpawnMob(p, SpawnSetting.Evolved());
        for (int i = 0; i < 2 + EClass.rnd(2); i++)
        {
            chara.ability.AddRandom();
        }
        chara.AddThing(chara.MakeGene(DNA.Type.Default));
        if (EClass.rnd(2) == 0)
        {
            chara.AddThing(chara.MakeGene(DNA.Type.Superior));
        }
        return chara;
    }
 
    public void TryGenerateBigDaddy()
    {
        if (!(BigDaddyChance * (EClass.pc.HasElement(1270) ? 1.1f : 1f) <= EClass.rndf(1f)))
        {
            Point spawnPos = GetSpawnPos(SpawnPosition.Random, 10000);
            List<string> list = new List<string> { "big_daddy", "big_daddy2" };
            list.Shuffle();
            Spawn(list[0], spawnPos);
            if (EClass.rnd(EClass.debug.enable ? 2 : 20) == 0)
            {
                Spawn(list[1], spawnPos.GetNearestPoint(allowBlock: false, allowChara: false));
            }
            Msg.Say("sign_bigdaddy");
        }
        void Spawn(string id, Point pos)
        {
            int num = (int)((long)DangerLv * 125L / 100);
            if (num >= 30)
            {
                CardBlueprint.Set(new CardBlueprint
                {
                    lv = num
                });
            }
            Chara chara = CharaGen.Create(id);
            if (EClass.pc.HasElement(1270))
            {
                chara.SetHostility(Hostility.Friend);
            }
            else if (EClass.pc.HasElement(1271))
            {
                chara.SetHostility(Hostility.Enemy);
            }
            EClass._zone.AddCard(chara, pos);
        }
    }
 
    public void TryGenerateShrine()
    {
        float num = ShrineChance * (EClass.pc.HasElement(1270) ? 1.1f : 1f);
        for (int i = 0; i < 3; i++)
        {
            Rand.SetSeed(base.uid + i);
            if (num <= EClass.rndf(1f))
            {
                continue;
            }
            Point randomSpace = EClass._map.GetRandomSpace(3, 3);
            if (randomSpace == null)
            {
                continue;
            }
            randomSpace.x++;
            randomSpace.z++;
            if (randomSpace.HasThing || randomSpace.HasChara)
            {
                continue;
            }
            randomSpace.SetObj();
            Rand.SetSeed(EClass.player.seedShrine);
            EClass.player.seedShrine++;
            if (EClass.rnd(EClass.debug.test ? 2 : 15) == 0)
            {
                EClass._zone.AddCard(ThingGen.Create("pedestal_power"), randomSpace).Install();
                EClass._zone.AddCard(ThingGen.Create(EClass.gamedata.godStatues.RandomItemWeighted((GodStatueData a) => a.chance).idThing, -1, DangerLv), randomSpace).Install();
            }
            else
            {
                EClass._zone.AddCard(ThingGen.Create("statue_power", -1, DangerLv), randomSpace).Install().SetRandomDir();
            }
        }
        Rand.SetSeed();
    }
 
    public void ResetHostility()
    {
        foreach (Chara chara in EClass._map.charas)
        {
            if (!chara.source.hostility.IsEmpty() && chara.source.hostility.ToEnum<Hostility>() >= Hostility.Friend && !chara.IsPCFactionOrMinion)
            {
                chara.c_originalHostility = (Hostility)0;
            }
            chara.hostility = chara.OriginalHostility;
            if (chara.enemy != null && (chara.enemy.IsPCFaction || chara.IsPCFaction))
            {
                chara.SetEnemy();
            }
        }
    }
 
    public virtual void OnGenerateRooms(BaseMapGen gen)
    {
    }
 
    public Point GetSpawnPos(SpawnPosition type, int tries = 100)
    {
        Point point = new Point();
        for (int i = 0; i < tries; i++)
        {
            point = EClass._map.bounds.GetRandomSurface(centered: false, walkable: true, allowWater: true);
            if (!point.IsValid || point.cell.hasDoor || point.IsSync)
            {
                continue;
            }
            switch (type)
            {
            case SpawnPosition.Guest:
            {
                List<TraitSpotGuest> list = EClass._map.props.installed.traits.List<TraitSpotGuest>();
                if (list.Count > 0)
                {
                    list.Shuffle();
                    foreach (TraitSpotGuest item in list)
                    {
                        List<Point> list2 = item.ListPoints(null, onlyPassable: true, allowChara: false);
                        if (list2.Count > 0)
                        {
                            return list2.RandomItem();
                        }
                    }
                }
                Room room = point.cell.room;
                if (room != null && room.data.accessType != 0)
                {
                    continue;
                }
                break;
            }
            case SpawnPosition.Outside:
                if (point.cell.HasRoof || point.cell.light > 0)
                {
                    continue;
                }
                break;
            }
            return point;
        }
        return null;
    }
 
    public Chara SpawnMob(string id, Point pos = null)
    {
        return SpawnMob(pos, new SpawnSetting
        {
            id = id
        });
    }
 
    public Chara SpawnMob(Point pos = null, SpawnSetting setting = null)
    {
        if (setting == null)
        {
            setting = SpawnSetting.Default;
        }
        if (pos == null)
        {
            pos = GetSpawnPos(setting.position, setting.tries);
            if (pos == null)
            {
                pos = GetSpawnPos(SpawnPosition.Random, setting.tries);
                if (pos == null)
                {
                    return null;
                }
            }
        }
        BiomeProfile biome = pos.cell.biome;
        if (IsUnderwater && EClass.rnd(15) != 0)
        {
            biome = ((EClass.rnd(4) != 0) ? EClass.core.refs.biomes.Water : EClass.core.refs.biomes.Sand);
        }
        SpawnList spawnList = null;
        if (setting.idSpawnList != null)
        {
            spawnList = SpawnList.Get(setting.idSpawnList);
        }
        else if (EClass._zone is Zone_DungeonYeek && EClass.rnd(5) != 0)
        {
            spawnList = SpawnListChara.Get("dungeon_yeek", (SourceChara.Row r) => r.race == "yeek" && r.quality == 0);
        }
        else if (EClass._zone is Zone_DungeonDragon && EClass.rnd(5) != 0)
        {
            spawnList = SpawnListChara.Get("dungeon_dragon", (SourceChara.Row r) => (r.race == "dragon" || r.race == "drake" || r.race == "wyvern" || r.race == "lizardman" || r.race == "dinosaur") && r.quality == 0);
        }
        else if (EClass._zone is Zone_DungeonMino && EClass.rnd(5) != 0)
        {
            spawnList = SpawnListChara.Get("dungeon_mino", (SourceChara.Row r) => r.race == "minotaur" && r.quality == 0);
        }
        else if (setting.hostility == SpawnHostility.Neutral || (setting.hostility != SpawnHostility.Enemy && Rand.Range(0f, 1f) < ChanceSpawnNeutral))
        {
            spawnList = SpawnList.Get(IsInstance ? "c_neutral_war" : "c_neutral");
        }
        else if (biome.spawn.chara.Count > 0)
        {
            string randomCharaId = biome.spawn.GetRandomCharaId();
            spawnList = ((!IsInstance) ? SpawnList.Get(randomCharaId) : SpawnList.Get("instance_" + randomCharaId, randomCharaId, new CharaFilter
            {
                ShouldPass = (SourceChara.Row s) => (!(s.hostility != "") || (!s.tag.Contains("cat") && !s.race_row.tag.Contains("cat"))) ? true : false
            }));
        }
        else
        {
            spawnList = SpawnList.Get(biome.name, "chara", new CharaFilter
            {
                ShouldPass = delegate(SourceChara.Row s)
                {
                    if (s.hostility != "")
                    {
                        return false;
                    }
                    return s.biome == biome.name || s.biome.IsEmpty();
                }
            });
        }
        int num = ((setting.dangerLv == -1) ? DangerLv : setting.dangerLv);
        CardBlueprint cardBlueprint = new CardBlueprint
        {
            rarity = Rarity.Normal,
            idEle = setting.idEle
        };
        int num2 = ((setting.filterLv == -1) ? num : setting.filterLv);
        if (ScaleType == ZoneScaleType.Void)
        {
            num2 = ((num - 1) % 50 + 5) * 150 / 100;
            if (num2 >= 20 && EClass.rnd(100) < num2)
            {
                num2 = num;
            }
        }
        CardRow cardRow = (setting.id.IsEmpty() ? spawnList.Select(num2, setting.levelRange) : EClass.sources.cards.map[setting.id]);
        if (EClass.world.date.month == 12 && setting.rarity == Rarity.Random && EClass._zone.IsNefia && EClass._zone.isRandomSite && EClass.world.date.day >= 24 && EClass.world.date.day <= 26 && EClass.rnd(50 * (1 + EClass.player.flags.santa) * (1 + EClass.player.flags.santa)) == 0)
        {
            cardRow = EClass.sources.cards.map["santa"];
            EClass.player.flags.santa++;
        }
        long num3 = ((setting.fixedLv == -1) ? cardRow.LV : setting.fixedLv);
        bool flag = setting.fixedLv != -1 || DangerLvBoost > 0;
        num3 += setting.addLv;
        if (ScaleType == ZoneScaleType.Void)
        {
            num3 = (50L + (long)cardRow.LV) * Mathf.Max(1, (num - 1) / 50);
            flag = true;
        }
        num3 += DangerLvBoost;
        if (setting.rarity == Rarity.Random && cardRow.quality == 0)
        {
            if (EClass.rnd(EClass.pc.HasElement(1271) ? 80 : 100) == 0)
            {
                cardBlueprint.rarity = Rarity.Legendary;
                num3 = num3 * 125 / 100;
            }
        }
        else
        {
            cardBlueprint.rarity = setting.rarity;
        }
        if (setting.isBoss)
        {
            num3 = num3 * 150 / 100;
        }
        if (setting.isEvolved)
        {
            num3 = num3 * 2 + 20;
        }
        if (num3 != cardRow.LV)
        {
            cardBlueprint.lv = (int)Mathf.Min(num3, 100000000f);
        }
        CardBlueprint.Set(cardBlueprint);
        Chara chara = CharaGen.Create(cardRow.id, num2);
        if (!flag)
        {
            chara.isScaled = false;
        }
        AddCard(chara, pos);
        if (setting.forcedHostility.HasValue)
        {
            Hostility c_originalHostility = (chara.hostility = setting.forcedHostility.Value);
            chara.c_originalHostility = c_originalHostility;
        }
        else
        {
            switch (chara.id)
            {
            case "unicorn":
                if (EClass.pc.HasElement(1216) && EClass.pc.Evalue(418) < 1)
                {
                    chara.SetHostility(Hostility.Enemy);
                }
                break;
            case "santa":
            case "silverwolf":
            case "twintail":
            case "test17":
                if (EClass.pc.HasElement(1270))
                {
                    chara.SetHostility(Hostility.Friend);
                }
                else if (EClass.pc.HasElement(1271))
                {
                    chara.SetHostility(Hostility.Enemy);
                }
                break;
            }
        }
        if (setting.isBoss)
        {
            chara.c_bossType = BossType.Boss;
        }
        if (setting.isEvolved)
        {
            chara.c_bossType = BossType.Evolved;
        }
        if (DangerLv >= 20 && !IsPCFaction && !IsTown && EClass.rnd(200) == 0)
        {
            chara.AddCondition<ConTransmuteShadow>();
        }
        return chara;
    }
 
    public bool HasField(int idEle)
    {
        return fieldElements.Has(idEle);
    }
 
    public void SetFieldEffect(int idEle, int a, int duration = 0)
    {
        fieldElements.SetBase(idEle, a, duration);
    }
 
    public void RemoveFieldEffect(int idEle)
    {
        fieldElements.Remove(idEle);
    }
 
    public void RefreshElectricity()
    {
        dirtyElectricity = false;
        bool flag = GetSoilCost() > MaxSoil;
        base.electricity = elements.Value(2201) * 10 + BaseElectricity;
        foreach (Thing thing in EClass._map.things)
        {
            if (thing.IsInstalled && thing.trait.Electricity != 0 && (thing.isOn || thing.trait.Electricity > 0))
            {
                base.electricity += thing.trait.Electricity;
            }
        }
        if (!flag)
        {
            EClass._map.bounds.ForeachCell(delegate(Cell c)
            {
                if (c.sourceObj.id == 118 && c.growth.IsMature)
                {
                    base.electricity += 20;
                }
            });
        }
        foreach (Thing thing2 in EClass._map.things)
        {
            if (thing2.IsInstalled)
            {
                thing2.trait.TryToggle();
            }
        }
    }
 
    public int GetElectricity(bool cost = false)
    {
        bool flag = GetSoilCost() > MaxSoil;
        int sum = 0;
        foreach (Thing thing in EClass._map.things)
        {
            if (!thing.IsInstalled || thing.trait.Electricity == 0)
            {
                continue;
            }
            if (cost)
            {
                if (thing.trait.Electricity < 0)
                {
                    sum += -thing.trait.Electricity;
                }
            }
            else if (thing.trait.Electricity > 0)
            {
                sum += thing.trait.Electricity;
            }
        }
        if (!cost)
        {
            sum += elements.Value(2201) * 10 + BaseElectricity;
            if (!flag)
            {
                EClass._map.bounds.ForeachCell(delegate(Cell c)
                {
                    if (c.sourceObj.id == 118 && c.growth.IsMature)
                    {
                        sum += 20;
                    }
                });
            }
        }
        return sum;
    }
 
    public void SetBGM(List<int> ids, bool refresh = true, float fadeDuration = 0f)
    {
        map._plDay.Clear();
        if (ids.Count > 0)
        {
            foreach (int id in ids)
            {
                if (id != -1)
                {
                    map._plDay.Add(id);
                }
            }
        }
        UnityEngine.Object.DestroyImmediate(map.plDay);
        map.plDay = null;
        RefreshPlaylist();
        if (!refresh)
        {
            return;
        }
        if (fadeDuration > 0f)
        {
            EClass.Sound.StopBGM(fadeDuration, playLastBGM: false, delegate
            {
                if (EClass.core.IsGameStarted && EClass.game.activeZone == this)
                {
                    RefreshBGM();
                }
            });
        }
        else
        {
            EClass.Sound.StopBGM();
            RefreshBGM();
        }
    }
 
    public void SetBGM(int id = -1, bool refresh = true, float fadeDuration = 0f)
    {
        SetBGM(new List<int> { id }, refresh, fadeDuration);
    }
 
    public void RefreshPlaylist()
    {
        if (map.plDay == null)
        {
            map.plDay = CreatePlaylist(ref map._plDay, EClass.Sound.GetPlaylist(IDPlayList));
        }
    }
 
    public void ResetPlaylist()
    {
        map._plDay.Clear();
        UnityEngine.Object.DestroyImmediate(map.plDay);
        map.plDay = null;
        RefreshPlaylist();
    }
 
    public void RefreshBGM()
    {
        if (!EClass.pc.IsInActiveZone || EClass.player.simulatingZone)
        {
            return;
        }
        RefreshPlaylist();
        Playlist playlist = map.plDay;
        foreach (ZoneEvent item in events.list)
        {
            if (item.playlist != null)
            {
                playlist = item.playlist;
            }
        }
        if (IDPlaylistOverwrite != null)
        {
            playlist = EClass.Sound.GetPlaylist(IDPlaylistOverwrite);
        }
        if (EClass.pc.IsInActiveZone)
        {
            Room room = EClass.pc.pos.cell.room;
            if (room != null && room.lot != null && room.lot.idBGM != 0)
            {
                playlist = EClass.Sound.plLot;
                if (playlist.list[0].data?.id != room.lot.idBGM)
                {
                    playlist.list[0].data = EClass.core.refs.dictBGM.TryGetValue(room.lot.idBGM);
                    playlist.Reset();
                    if (!LayerDrama.keepBGM)
                    {
                        EClass.Sound.StopBGM(1f);
                    }
                }
            }
        }
        EClass.core.config.SetBGMInterval();
        EClass.Sound.SwitchPlaylist(playlist, !LayerDrama.keepBGM);
    }
 
    public Playlist CreatePlaylist(ref List<int> list, Playlist mold = null)
    {
        return ModUtil.CreatePlaylist(ref list, mold);
    }
 
    public Chara FindChara(string id)
    {
        return map.charas.Find((Chara c) => c.id == id);
    }
 
    public Chara FindChara(int uid)
    {
        return map.charas.Find((Chara c) => c.uid == uid);
    }
 
    public Chara FindDeadChara(string id)
    {
        return map.deadCharas.Find((Chara c) => c.id == id);
    }
 
    public int GetDeepestLv()
    {
        int max = base.lv;
        return GetDeepestLv(ref max);
    }
 
    public int GetDeepestLv(ref int max)
    {
        if (Mathf.Abs(base.lv) > Mathf.Abs(max))
        {
            max = base.lv;
        }
        foreach (Spatial child in children)
        {
            (child as Zone).GetDeepestLv(ref max);
        }
        return max;
    }
 
    public List<Element> ListLandFeats()
    {
        if (landFeats == null)
        {
            landFeats = new List<int>();
            Rand.SetSeed(EClass._zone.uid);
            string[] listBase = IDBaseLandFeat.Split(',');
            string[] array = listBase;
            foreach (string text in array)
            {
                if (!text.IsEmpty())
                {
                    landFeats.Add(EClass.sources.elements.alias[text].id);
                }
            }
            if (listBase.Length == 1)
            {
                List<SourceElement.Row> list = EClass.sources.elements.rows.Where(delegate(SourceElement.Row e)
                {
                    if (e.category != "landfeat" || e.chance == 0)
                    {
                        return false;
                    }
                    bool flag = true;
                    string[] tag = e.tag;
                    foreach (string text2 in tag)
                    {
                        if (text2.StartsWith("bf"))
                        {
                            flag = false;
                            if (listBase[0] == text2)
                            {
                                flag = true;
                                break;
                            }
                        }
                    }
                    return flag ? true : false;
                }).ToList();
                SourceElement.Row row = list.RandomItemWeighted((SourceElement.Row e) => e.chance);
                landFeats.Add(row.id);
                list.Remove(row);
                row = list.RandomItemWeighted((SourceElement.Row e) => e.chance);
                landFeats.Add(row.id);
            }
            Rand.SetSeed();
        }
        List<Element> list2 = new List<Element>();
        foreach (int landFeat in landFeats)
        {
            list2.Add(Element.Create(landFeat, 1));
        }
        return list2;
    }
 
    public ZoneExportData Import(string path)
    {
        ZipFile zipFile = ZipFile.Read(path);
        zipFile.ExtractExistingFile = ExtractExistingFileAction.OverwriteSilently;
        zipFile.ExtractAll(pathTemp);
        zipFile.Dispose();
        return IO.LoadFile<ZoneExportData>(pathTemp + "export") ?? new ZoneExportData();
    }
 
    public void Export(string path, PartialMap partial = null, bool usermap = false)
    {
        if (subset != null)
        {
            SE.Beep();
            return;
        }
        try
        {
            ZoneExportData zoneExportData = new ZoneExportData
            {
                name = name,
                usermap = usermap
            };
            IO.CreateTempDirectory();
            if (!map.config.retainDecal)
            {
                map.ClearRainAndDecal();
            }
            map.Save(IO.TempPath + "/", zoneExportData, partial);
            map.ExportMetaData(IO.TempPath + "/", Path.GetFileNameWithoutExtension(path), partial);
            if (partial == null)
            {
                IO.CopyDir(base.pathSave + "Texture Replace", IO.TempPath + "/Texture Replace");
            }
            IO.SaveFile(IO.TempPath + "/export", zoneExportData, compress: true);
            using (ZipFile zipFile = new ZipFile())
            {
                zipFile.ExtractExistingFile = ExtractExistingFileAction.OverwriteSilently;
                zipFile.AddDirectory(IO.TempPath);
                zipFile.Save(path);
                zipFile.Dispose();
            }
            IO.DeleteTempDirectory();
        }
        catch (Exception ex)
        {
            EClass.ui.Say(ex.Message + ":" + path);
        }
    }
 
    public void ExportDialog(string dir = null)
    {
        EClass.core.WaitForEndOfFrame(delegate
        {
            string text = StandaloneFileBrowser.SaveFilePanel("Export Zone", dir ?? CorePath.ZoneSave, "new zone", "z");
            if (!string.IsNullOrEmpty(text))
            {
                Export(text);
                Msg.SayRaw("Exported Zone");
            }
        });
    }
 
    public void ImportDialog(string dir = null)
    {
        EClass.core.WaitForEndOfFrame(delegate
        {
            string[] array = StandaloneFileBrowser.OpenFilePanel("Import Zone", dir ?? CorePath.ZoneSave, "z", multiselect: false);
            if (array.Length != 0)
            {
                Zone_User zone_User = SpatialGen.Create("user", EClass.world.region, register: true) as Zone_User;
                zone_User.path = array[0];
                Thing thing = ThingGen.Create("teleporter");
                thing.c_uidZone = zone_User.uid;
                EClass._zone.AddCard(thing, EClass.pc.pos);
            }
        });
    }
 
    public static bool IsImportValid(string path)
    {
        try
        {
            return Map.GetMetaData(path)?.IsValidVersion() ?? false;
        }
        catch (Exception ex)
        {
            EClass.ui.Say(ex.Message);
            return false;
        }
    }
 
    public void Export()
    {
        EClass._map.ResetEditorPos();
        string text = pathExport;
        IO.Copy(text, CorePath.ZoneSave + "Backup/");
        Export(text);
        Msg.Say("Exported Map:" + text);
    }
 
    public void WriteNote(UINote n, Action<UINote> onWriteNote = null, IInspect.NoteMode mode = IInspect.NoteMode.Default, Recipe recipe = null)
    {
    }
 
    public void OnInspect()
    {
    }
 
    public int GetSortVal()
    {
        if (IsPCFaction)
        {
            return -10000000 + base.uid;
        }
        if (this is Zone_SubTown)
        {
            return -8000000 + base.uid;
        }
        if (this is Zone_Town)
        {
            return -9000000 + base.uid;
        }
        if (this is Zone_Civilized)
        {
            return -7000000 + base.uid;
        }
        if (this is Zone_RandomDungeon)
        {
            return 1000000 + base.uid;
        }
        return base.uid;
    }
 
    public Chara AddRandomVisitor(bool guest = false)
    {
        Trait random = map.Installed.traits.GetTraitSet<TraitSpotExit>().GetRandom();
        if (random == null)
        {
            return null;
        }
        Point point = random.GetPoint();
        Chara chara = null;
        if (guest)
        {
            Zone z = EClass.world.FindZone("wilds");
            chara = EClass.game.cards.ListGlobalChara(z).RandomItem();
            if (chara != null)
            {
                AddCard(chara, point);
                Msg.Say("guestArrive", chara);
                chara.visitorState = VisitorState.Arrived;
            }
        }
        else
        {
            chara = CharaGen.CreateFromFilter("c_wilds");
            AddCard(chara, point);
            chara.goalListType = GoalListType.Enemy;
        }
        return chara;
    }
 
    public void OnSimulateHour(VirtualDate date)
    {
        if (base.IsPlayerFaction)
        {
            branch.OnSimulateHour(date);
        }
        events.OnSimulateHour();
        if (date.IsRealTime)
        {
            foreach (Thing thing in EClass._map.things)
            {
                if (thing.IsInstalled)
                {
                    thing.trait.TryToggle();
                }
            }
            EClass.pc.DecayNatural();
        }
        EClass._map.things.ForeachReverse(delegate(Thing t)
        {
            t.OnSimulateHour(date);
        });
        foreach (Thing sucker in Suckers)
        {
            sucker.Destroy();
        }
        Suckers.Clear();
        if (RespawnRate != 0f)
        {
            int num = 0;
            foreach (Chara chara in map.charas)
            {
                if (!chara.IsGlobal)
                {
                    num++;
                }
            }
            if (num < MaxRespawn)
            {
                for (int i = 0; i < RespawnPerHour; i++)
                {
                    SpawnMob();
                }
            }
        }
        if (!date.IsRealTime && EClass.rnd(24) == 0)
        {
            RainWater();
        }
        if (date.hour == 6)
        {
            GrowPlants(date);
        }
    }
 
    public void OnSimulateDay(VirtualDate date)
    {
        if (base.IsPlayerFaction)
        {
            branch.OnSimulateDay(date);
        }
    }
 
    public void OnSimulateMonth(VirtualDate date)
    {
        if (base.IsPlayerFaction)
        {
            branch.OnSimulateMonth(date);
        }
        if (date.IsRealTime)
        {
            EClass._map.RefreshAllTiles();
        }
    }
 
    public void RainWater()
    {
        if (EClass._map.IsIndoor || !IsPCFaction)
        {
            return;
        }
        EClass._map.bounds.ForeachCell(delegate(Cell c)
        {
            if (c.IsFarmField && !c.HasRoof)
            {
                c.isWatered = true;
            }
        });
    }
 
    public void GrowPlants(VirtualDate date)
    {
        bool num = (EClass.player.isAutoFarming = IsPCFaction && EClass.Branch.policies.IsActive(2707));
        int weedChance = 1;
        if (IsPCFaction && EClass.Branch.policies.IsActive(2703))
        {
            weedChance += (EClass.debug.enable ? 100000 : 20) + EClass.Branch.Evalue(2703) * 10;
        }
        if (date.sunMap == null)
        {
            date.BuildSunMap();
        }
        if (num)
        {
            HashSet<int> hashSet = new HashSet<int>();
            foreach (Thing thing in EClass._map.things)
            {
                if (!thing.IsInstalled || !(thing.trait is TraitSpotFarm traitSpotFarm))
                {
                    continue;
                }
                foreach (Point item in traitSpotFarm.ListPoints(null, onlyPassable: false))
                {
                    hashSet.Add(item.index);
                }
            }
            Perform(hashSet);
            EClass.player.isAutoFarming = false;
            Perform(hashSet);
        }
        else
        {
            Perform(null);
        }
        void Perform(HashSet<int> farmMap)
        {
            bool isWinter = date.IsWinter;
            EClass._map.bounds.ForeachCell(delegate(Cell c)
            {
                if (farmMap != null)
                {
                    if (EClass.player.isAutoFarming)
                    {
                        if (!farmMap.Contains(c.index))
                        {
                            return;
                        }
                    }
                    else if (farmMap.Contains(c.index))
                    {
                        return;
                    }
                }
                if (c.decal != 0 && EClass.rnd(3) == 0)
                {
                    c.decal = 0;
                }
                if (GrowPlant)
                {
                    if (c.growth != null)
                    {
                        bool flag = false;
                        if (!EClass.player.isAutoFarming && c.growth.HaltGrowth() && (c.IsFarmField || c.IsTopWater) && (!isWinter || !date.IsRealTime))
                        {
                            flag = true;
                        }
                        PlantData plantData = map.TryGetPlant(c);
                        if (!flag && (plantData == null || plantData.fert >= 0))
                        {
                            c.TryGrow(date);
                        }
                        if (isWinter && plantData != null && c.growth != null && c.growth.NeedSunlight && plantData.fert >= 0 && (EClass.rnd(4) == 0 || c.growth.stage.idx == 0))
                        {
                            if (date.sunMap == null)
                            {
                                date.BuildSunMap();
                            }
                            if (!date.sunMap.Contains(c.index) && !c.growth.CanGrow(date))
                            {
                                c.growth.Perish();
                            }
                        }
                    }
                    else if (c.detail != null)
                    {
                        c.Things.ForeachReverse(delegate(Thing t)
                        {
                            if (t.IsInstalled && t.trait is TraitSeed && !t.isSale)
                            {
                                (t.trait as TraitSeed).TrySprout(force: false, sucker: false, date);
                            }
                        });
                    }
                    else if (EClass.rnd(20) == 0 && GrowWeed && c.CanGrowWeed && EClass.rnd(weedChance) == 0)
                    {
                        biome.Populate(c.GetPoint());
                        if (c.growth != null)
                        {
                            c.growth.SetStage(0);
                        }
                    }
                }
                c.isWatered = false;
            });
        }
    }
 
    public Zone GetZoneAt(int _x, int _y)
    {
        if (IsRegion)
        {
            foreach (Spatial child in children)
            {
                if (!(child is Zone_Field) && _x == child.x && _y == child.y)
                {
                    return child as Zone;
                }
            }
        }
        foreach (Spatial child2 in children)
        {
            if (_x == child2.x && _y == child2.y)
            {
                return child2 as Zone;
            }
        }
        return null;
    }
 
    public bool IsCrime(Chara c, Act act)
    {
        if (act.IsHostileAct && HasLaw && !IsPCFaction && c.IsPC)
        {
            return true;
        }
        return false;
    }
 
    public void RefreshCriminal()
    {
        bool flag = EClass.player.IsCriminal && HasLaw && !AllowCriminal && !IsPCFaction;
        Hostility hostility = (flag ? Hostility.Neutral : Hostility.Friend);
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.trait is TraitGuard)
            {
                chara.hostility = hostility;
                if (!flag && chara.enemy != null && chara.enemy.IsPCParty)
                {
                    chara.SetEnemy();
                }
            }
        }
    }
 
    public void RefreshListCitizen()
    {
        if (base.lv != 0)
        {
            return;
        }
        dictCitizen.Clear();
        foreach (Chara item in map.charas.Concat(map.deadCharas))
        {
            if (item.trait.IsCitizen && !item.IsGlobal && !item.isSubsetCard)
            {
                dictCitizen[item.uid] = item.Name;
            }
        }
    }
 
    public virtual void SetAlarm(bool enable)
    {
        base.isAlarmSet = enable;
        if (enable)
        {
            foreach (Chara chara in EClass._map.charas)
            {
                if (!chara.IsPCFactionOrMinion)
                {
                    chara.SetHostility(Hostility.Enemy);
                }
            }
            Msg.Say("alarm");
            Msg.Say("alarm2");
            SE.Play("alarm");
            return;
        }
        foreach (Chara chara2 in EClass._map.charas)
        {
            if (!chara2.IsPCFactionOrMinion)
            {
                chara2.SetHostility(Hostility.Neutral);
            }
        }
    }
 
    public void ModInfluence(int a)
    {
        base.influence += a;
        if (a > 0)
        {
            Msg.Say("gainInfluence", Name, a.ToString() ?? "");
        }
        Tutorial.Reserve("influence");
    }
 
    public void ModDevelopment(int a)
    {
        base.development += a;
        if (a > 0)
        {
            Msg.Say("gainDevelopment", Name, a.ToString() ?? "");
        }
    }
 
    public void UpdateQuests(bool force = false)
    {
        if (!IsPCFaction && (!(this is Zone_Town) || base.lv != 0))
        {
            return;
        }
        Debug.Log("Updating Quest:" + force);
        List<SourceQuest.Row> list = EClass.sources.quests.rows.Where((SourceQuest.Row a) => a.group == "random").ToList();
        int num = 0;
        foreach (Chara item in map.charas.Concat(map.deadCharas))
        {
            if (item.quest != null && !EClass.game.quests.list.Contains(item.quest))
            {
                if (item.quest.IsExpired || completedQuests.Contains(item.quest.uid) || force)
                {
                    item.quest = null;
                }
                else
                {
                    num++;
                }
            }
        }
        if (EClass._zone.dateQuest > EClass.world.date.GetRaw() && !force)
        {
            return;
        }
        EClass._zone.dateQuest = EClass.world.date.GetRaw() + 1440;
        int maxQuest = 3;
        Rand.UseSeed(base.uid + EClass.player.stats.days / 7 % 100, delegate
        {
            maxQuest = 4 + EClass.rnd(4);
        });
        completedQuests.Clear();
        List<Zone> list2 = Quest.ListDeliver();
        List<Tuple<string, int>> listTag = new List<Tuple<string, int>>();
        string[] array = EClass._zone.source.questTag;
        if (EClass._zone.IsPCFaction)
        {
            array = new string[9] { "supply/8", "deliver/7", "food/8", "escort/4", "deliver/4", "monster/0", "war/0", "farm/0", "music/0" };
        }
        string[] array2 = array;
        for (int i = 0; i < array2.Length; i++)
        {
            string[] array3 = array2[i].Split('/');
            listTag.Add(new Tuple<string, int>(array3[0], array3[1].ToInt()));
        }
        for (int j = 0; j < map.charas.Count * 2; j++)
        {
            if (num > maxQuest)
            {
                break;
            }
            if (num > 15)
            {
                break;
            }
            Chara chara = map.charas.RandomItem();
            if (!chara.trait.CanGiveRandomQuest || chara.isSubsetCard || chara.homeZone != EClass._zone || chara.IsGuest() || chara.memberType == FactionMemberType.Livestock || (chara.quest != null && !force))
            {
                continue;
            }
            SourceQuest.Row row = list.RandomItemWeighted(delegate(SourceQuest.Row a)
            {
                int num2 = 1;
                foreach (Tuple<string, int> item2 in listTag)
                {
                    if (a.tags.Contains(item2.Item1))
                    {
                        num2 = item2.Item2;
                        break;
                    }
                }
                if (!EClass._zone.IsPCFaction && a.tags.Contains("bulk"))
                {
                    num2 = 0;
                }
                return a.chance * num2;
            });
            if ((!row.tags.Contains("needDestZone") || list2.Count >= 2) && (row.minFame <= 0 || row.minFame < EClass.player.fame || EClass.debug.enable))
            {
                Quest.Create(row.id, null, chara);
                num++;
            }
        }
    }
 
    public List<Chara> ListMinions(Chara c)
    {
        List<Chara> list = new List<Chara>();
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.c_uidMaster == c.uid && chara.c_minionType == MinionType.Default)
            {
                list.Add(chara);
            }
        }
        return list;
    }
 
    public int CountMinions(Chara c)
    {
        int num = 0;
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.c_uidMaster == c.uid && chara.c_minionType == MinionType.Default)
            {
                num++;
            }
        }
        return num;
    }
 
    public int GetSoilCost()
    {
        int i = 0;
        EClass._map.bounds.ForeachCell(delegate(Cell c)
        {
            i += c.sourceObj.costSoil;
        });
        return i / 10;
    }
 
    public void SpawnLostItems()
    {
        for (int i = 0; i < 2 + EClass.rnd(4); i++)
        {
            Point point = GetPos();
            if (point == null)
            {
                continue;
            }
            if (EClass.rnd(30) == 0)
            {
                Thing thing = ThingGen.Create("purse");
                thing.isLostProperty = true;
                thing.things.DestroyAll();
                int num2 = (thing.c_lockLv = EClass.rndHalf(Mathf.Min(base.development / 10 + 10, 50)));
                thing.Add("money", EClass.rndHalf(num2 * 60 + 1000));
                if (EClass.rnd(2) == 0)
                {
                    thing.Add("plat", EClass.rnd(4));
                }
                else
                {
                    thing.Add("medal", EClass.rnd(2));
                }
                EClass._zone.AddCard(thing, point);
            }
            else
            {
                EClass._zone.AddCard(ThingGen.CreateFromCategory("junk"), point);
            }
        }
        static Point GetPos()
        {
            for (int j = 0; j < 10; j++)
            {
                Point randomPoint = EClass._zone.bounds.GetRandomPoint();
                if (!randomPoint.IsBlocked && !randomPoint.HasThing && !randomPoint.HasObj && !randomPoint.HasBlock)
                {
                    return randomPoint;
                }
            }
            return null;
        }
    }
 
    public void ApplyBackerPet(bool draw)
    {
        bool flag = this is Zone_Yowyn && base.lv == -1;
        IList<SourceBacker.Row> list = EClass.sources.backers.listPet.Copy();
        list.Shuffle();
        if (!EClass.core.config.test.ignoreBackerDestoryFlag)
        {
            list.ForeachReverse(delegate(SourceBacker.Row a)
            {
                if (EClass.player.doneBackers.Contains(a.id))
                {
                    list.Remove(a);
                }
            });
        }
        foreach (Chara chara in EClass._map.charas)
        {
            if (chara.IsGlobal || chara.IsMinion)
            {
                continue;
            }
            if (chara.isBackerContent)
            {
                if (chara.sourceBacker.isStatic != 0)
                {
                    continue;
                }
                if (chara.id != "follower")
                {
                    chara.RemoveBacker();
                }
            }
            if ((flag && chara.race.id != "cat") || (!EClass.debug.enable && EClass.rnd((!flag) ? (draw ? 3 : 10) : (draw ? 1 : 2)) != 0))
            {
                continue;
            }
            foreach (SourceBacker.Row item in list)
            {
                if (item.chara == chara.id)
                {
                    chara.ApplyBacker(item.id);
                    list.Remove(item);
                    break;
                }
            }
        }
    }
 
    public FortuneRollData GetOrCreateFortuneRollData(bool refresh = true)
    {
        if (fortuneRoll == null)
        {
            fortuneRoll = new FortuneRollData();
            fortuneRoll.seed = EClass._zone.uid * 100 + EClass.game.seed;
        }
        if (refresh || fortuneRoll.count == 0)
        {
            fortuneRoll.Refresh();
        }
        return fortuneRoll;
    }
}