# Stateful Scriptable Objects

Here's an example of a Scriptable Object with state. Part of TilePlus Toolkit. Note this is free on the asset store but is copyrighted.

```
// ***********************************************************************
// Assembly         : TilePlus
// Created          : 03-25-2023
//
// Last Modified On : 04-03-2023
// ***********************************************************************
// <copyright file="TpZoneManager.cs" >
//     Copyright (c) All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
#nullable enable

using System;
using System.Collections.Generic;
using System.Linq;
// ReSharper disable once RedundantUsingDirective
using UnityEditor;
using UnityEngine;
using UnityEngine.Tilemaps;
using static TilePlus.TpLib;

// ReSharper disable MemberCanBePrivate.Global


namespace TilePlus
{
    /// <summary>
    /// TpZoneManager is used to manage square areas of tilemaps called Zones.
    /// </summary>
    public class TpZoneManager : ScriptableObject
    {
        #region subscriptions
        
        /// <summary>
        /// Notify me when a Zone Reg is added. 
        /// </summary>
        /// <remarks>Be aware that when the ZoneManager instance is deleted this subscription expires</remarks>
        public event Action<ZoneReg, TpZoneManager>? OnZoneRegAdded;
        /// <summary>
        /// Notify me when a Zone Reg is deleted. 
        /// </summary>
        /// <remarks>Be aware that when the ZoneManager instance is deleted this subscription expires</remarks> 
        public event Action<ZoneReg,TpZoneManager>? OnZoneRegDeleted;

        /// <summary>
        /// Notify me that a list of TPT tiles will be deleted.
        /// </summary>
        /// <remarks>Be aware that when the ZoneManager instance is deleted this subscription expires</remarks>
        public event Action<Tilemap,List<TilePlusBase>>? OnTptTilesWillBeDeleted;

        
        #endregion
        
        #region privateFields

        /// <summary>
        /// Mapping between RectInts (locator) and Zone Registrations.
        /// </summary>
        private Dictionary<RectInt, ZoneReg> chunkMap = new ();
       
        /// <summary>
        /// The default ChunkLocator from the size param to Initialize.
        /// This defines the size of each chunk - it's size.x and size.y params
        /// (both should be equal). This is available via a property.
        /// </summary>
        private RectInt defaultLocator;
        
        /// <summary>
        /// The starting position, the position of chunk zero. 
        /// </summary>
        private  Vector2Int worldOrigin;
       
        /// <summary>
        /// indicates that chunking is enabled after a call to Initialize.
        /// </summary>
        private  bool       chunkingConfigured; //backup field for property

        
        //holds the return value for RestoreFromRegistrationJson
        private  readonly List<TilefabLoadResults> currentLoadresults = new(8);

        //temporary list but use the same one repeatedly to reduce garbage
        private    List<ZoneReg> getZoneRegForChunkInternal = new(32);

        //maps for this instance. clients need to use only these maps.
        private Dictionary<string, Tilemap> monitoredTilemaps = new();
        
        //the name of this instance.
        private string instanceName = string.Empty;
        #endregion
        
        #region properties
        /// <summary>
        /// Get the all loading results
        /// </summary>
        public IEnumerable<ZoneReg> GetAllZoneRegistrations => chunkMap.Values.OrderBy(zr => zr.dex);

        
        /// <summary>
        /// Is chunking configured? 
        /// </summary>
        public  bool ChunkingConfigured => chunkingConfigured; 

        /// <summary>
        /// Size of a chunk as set during initialization.
        /// </summary>
        public int ChunkSize => defaultLocator.size.x;
        
        /// <summary>
        /// The number of chunks in the chunkmap.
        /// </summary>
        public int NumChunksInUse => chunkMap.Count;


        /// <summary>
        /// Get a collection of the MonitoredTilemaps dictionary values: Tilemap instances. These are
        /// the only ones that clients of this instance should be using. 
        /// </summary>
        public Dictionary<string, Tilemap>.ValueCollection MonitoredTilemaps => monitoredTilemaps.Values;

        /// <summary>
        /// Access to the Monitored Tilemaps for this instance. DO NOT ALTER THIS DICTIONARY. DON'T SAVE A REFERENCE.
        /// </summary>
        public Dictionary<string, Tilemap> MonitoredTilemapDict => monitoredTilemaps;


        /// <summary>
        /// Get the default locator. This is the value used when
        /// you don't specify a dimensions value when GetZoneReg
        /// or GetLocator with dimensions = null.
        /// </summary>
        // ReSharper disable once ConvertToAutoProperty
        public RectInt DefaultLocator => defaultLocator;
        /// <summary>
        /// Get the ChunkMapAnchorPosition. This is the base or startingPosition from where all Chunks begin.
        /// You can find the center of a chunk by adding multiples of ChunkMapAnchorSize to ChunkMapAnchorPosition. 
        /// </summary>
        public  Vector2Int WorldOrigin => worldOrigin;

        /// <summary>
        /// The name of this instance. Read only
        /// </summary>
        public string InstanceName => instanceName;
        
        /// <summary>
        /// A ref to the ZoneLayout, if used with chunking system. Null otherwise.
        /// </summary>
        public TpZoneLayout? ZoneLayoutComponent { get; set; }

        
        #endregion

        #region access
        
        /// <summary>
        /// Reset all registrations, reset registrationIndex
        /// </summary>
        /// <param name="resetEvents">Reset event descriptions (default=true)</param>
        public void ResetInstance(bool resetEvents = true )
        {
            chunkMap.Clear();
            chunkingConfigured = false;
            currentLoadresults.Clear();
            getZoneRegForChunkInternal.Clear();
            monitoredTilemaps.Clear();
            if (!resetEvents)
                return;
            OnZoneRegDeleted        = null;
            OnZoneRegAdded          = null;
            OnTptTilesWillBeDeleted = null;
        }
        
       

        /// <summary>
        /// Add a TileFab chunk to the database. In general this should ONLY be
        /// called from TileFabLib. CHUNKS ONLY. 
        /// </summary>
        /// <param name="tileFab">The TileFab to load</param>
        /// <param name="createAsImmortal">mark the ZoneReg as immortal</param>
        /// <param name="offset">placement offset</param>
        /// <param name="rotation">rotation</param>
        /// <param name="posToGuidMaps">remapping dictionary</param>
        /// <param name="bundleAssetGuids">Asset GUIDs</param>
        /// <param name="bundleAssetNames">Asset names</param>
        /// <param name = "spawnedPrefabs" >List of prefabs spawned when the TileFab was loaded. Note: not serialized
        /// in the ZoneReg class instance created herein.</param>
        /// <returns>Tuple of ZoneReg and RectInt (locator) or null for error. AssetReg is null if error.</returns>
        internal (ZoneReg? reg, RectInt locator) AddZone(TpTileFab?                        tileFab,
                                                         bool                              createAsImmortal,
                                                         Vector3Int                        offset,
                                                         TpTileBundle.TilemapRotation      rotation,
                                                         Dictionary<Vector3Int, string>[]? posToGuidMaps,
                                                         string[]?                         bundleAssetGuids,
                                                         string[]?                         bundleAssetNames,
                                                         List<GameObject>?                 spawnedPrefabs)
        {
            if (!chunkingConfigured)
            {
                TpLogError("Cannot add Zones to TpZoneManager before it is configured. Use 'Initialize' first!!!");
                return(null,defaultLocator);
            }
            
            if (!tileFab || posToGuidMaps == null || bundleAssetGuids == null || bundleAssetNames == null)
            {
                TpLogError("null TileFab, posToGuidMaps, bundleAssetGuids or bundleAssetName was passed to TpZoneLayout.AddZone.");
                return(null,defaultLocator);
            }
            
            if (!tileFab.m_FromGridSelection)
            {
                TpLogError("Cannot use TpZoneManager.AddZone with a non-chunk TileFab!!! And you can't just click the 'From Grid Selection checkbox on the asset: that won't work correctly. PLease recreate the TileFabs using GridSelections!");
                return(null,defaultLocator);
            }
            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
            if(tileFab.m_TileAssets.Count == 0  || tileFab.m_TileAssets[0] == null || !tileFab.m_TileAssets[0].m_Asset)
            {
                TpLogError($"Invalid TileFab [{tileFab.name}]: does not have any bundles.");
                return(null,defaultLocator);
            }
                
            //need a boundsInt for the chunk in order to create a 'locator' RectInt.
            //we know that the TileFab has to have at least one Chunk. 
            //all chunk boundsInts are identical.
            var chunkBoundsInt = tileFab.IsChunkified ? new BoundsInt(0,0,0,ChunkSize,ChunkSize,1) :
                                     tileFab.LargestBounds; //this method does exactly that when a Fab is a chunk.
            
            //update map from BoundsInt to reg (for camera-region culling)
            //now compute the locator for this chunk: Basically it's a RectInt encompassing the entire Chunk as placed.
            //NOTE THAT the position of a RectInt is NOT the center. It's the lower-left corner. This is fine
            //as long as we're consistent.
            var locator = GetLocatorForGridPosition(offset);
            if (chunkMap.ContainsKey(locator))
            {
                TpLogError($"The locator [{locator}] already exists! Can't place at offset {offset}");
                return(null,defaultLocator);
            }

            var reg = new ZoneReg(TileFabLib.RegistrationIndex,
                                  locator,
                                  tileFab.AssetGuidString,
                                  tileFab.name,
                                  offset,
                                  rotation,
                                  posToGuidMaps,
                                  bundleAssetGuids,
                                  bundleAssetNames,
                                  chunkBoundsInt,
                                  spawnedPrefabs);
            if (createAsImmortal)
                reg.imm = true;

            var hash = new AssetGuidPositionHash(tileFab.TileFabGuid, offset);
            return !AddRegistration(reg, hash)
                       ? (null,defaultLocator)
                       : (reg,locator);
        }

        /// <summary>
        /// Add a registration. Only use if you're not using AddZone and creating your own ZoneRegs
        /// </summary>
        /// <param name="reg">The ZoneReg</param>
        /// <param name="hash">An AssetGuidPositionHash instance</param>
        /// <returns>false for failure: means that there was an entry already existing for this locator.</returns>
        public bool AddRegistration(ZoneReg reg, AssetGuidPositionHash hash)
        {
            var locator = reg.m_MyLocator;
            if (!chunkMap.TryAdd(locator, reg))
            {
                #if UNITY_EDITOR
                TpLogError($"Fatal: duplicate key {locator} in ChunkMap for reg {reg}. ");
                #endif
                return false;
            }
            
            TileFabLib.S_LoadedGuids?.Add(hash);
            TileFabLib.IncrementRegistrationIndex();
            OnZoneRegAdded?.Invoke(reg,this);

            return true;
        }
        

        /// <summary>
        /// Is there a registration for this ZoneReg?
        /// </summary>
        /// <param name="reg">A ZoneReg</param>
        /// <returns></returns>
        public bool HasZone(ZoneReg reg)
        {
            if (chunkingConfigured)
                return chunkMap.ContainsKey(reg.m_MyLocator);
            TpLogError("Cannot use TpZoneManager before it is configured. Use 'Initialize' first!!!");
            return false;
        }

        /// <summary>
        /// Unload a list of Zones
        /// </summary>
        /// <param name="regs">List of ZoneRegs to delete</param>
        /// <param name="destroyTiles">destroy tiles (default)</param>
        /// <param name="destroyPrefabs">destroy prefabs (default)</param>
        /// <returns>false if failed</returns>
        public bool UnloadZones(List<ZoneReg> regs, bool destroyTiles = true, bool destroyPrefabs = true)
        {
            var error = false;
            foreach (var reg in regs)
                error |= UnloadZone(reg, destroyTiles, destroyPrefabs);
            return error;
        }

        /// <summary>
        /// Unload a list of Zones, Async
        /// Does one reg per frame.
        /// </summary>
        /// <param name="regs">List of ZoneRegs to delete</param>
        /// <param name="destroyTiles">destroy tiles (default)</param>
        /// <param name="destroyPrefabs">destroy prefabs (default)</param>
        /// <returns>false if failed</returns>
        public async Awaitable<bool> UnloadZonesAsync(List<ZoneReg> regs, bool destroyTiles = true, bool destroyPrefabs = true)
        {
            var success = true;
            foreach (var reg in regs)
            {
                success &= UnloadZone(reg, destroyTiles, destroyPrefabs);
                if (success)
                    await Awaitable.NextFrameAsync();
            }
            return success;
        }
        
        
        
        /// <summary>
        /// Unload ALL zones, including all parented prefabs.
        /// </summary>
        /// <returns></returns>
        public bool UnloadAllZones()
        {
            return UnloadZones(chunkMap.Values.ToList());
        }
        
        

        /// <summary>
        /// Unload a chunk
        /// </summary>
        /// <param name="reg">corresponding ZoneReg for the chunk you want to delete.</param>
        /// <param name = "destroyTiles" >destroy tiles if true (default)</param>
        /// <param name = "destroyPrefabs" >destroy prefabs if true (default)</param>
        /// <returns>true if successful.</returns>
        /// <remarks> runtime use ONLY </remarks>
        public bool UnloadZone(ZoneReg? reg, bool destroyTiles = true, bool destroyPrefabs = true)
        {
            if (reg == null)
            {
                TpLogError("Null ZoneReg passed to UnloadZone.");
                return false;
            }
            //reserved zones are handled simply since there aren't any tiles/prefabs to delete. 
            if (reg.m_Reserved)
            {
                if (!DeleteZoneRegistration(reg))
                    TpLogWarning($"Could not delete this zonereg: {reg}");

                OnZoneRegDeleted?.Invoke(reg,this);
                return true;
            }

            if (!chunkingConfigured)
            {
                TpLogError("Cannot delete Zones from TpZoneManager before it is configured. Use 'Initialize' first!!!");
                return false;
            }
            
            if (!chunkMap.ContainsKey(reg.m_MyLocator))
            {
                TpLogError($"Unknown ZoneReg [{reg}], can't delete zone!"); 
                return false;
            }

            if (destroyTiles)
            {
                //area is 'largestbounds' from the asset
                var eraseBounds = reg.lb;
                //offset it 
                eraseBounds.position += reg.offs;
                var sz = eraseBounds.size;
                sz.z             = 1;
                eraseBounds.size = sz;

                
                
                var ri = TpTileUtils.RectIntFromBoundsInt(eraseBounds, Vector3Int.zero);
                //Debug.Log($"bounds {eraseBounds} rectint {ri}");

                //todo: could cache depending on chunk size.
                var nulls = new TileBase[sz.x * sz.y]; //these should all be null.

                //get a list of TPBs (which is cleared as required for
                using (TpLib.S_TilePlusBaseList_Pool.Get(out var pTiles))
                {
                    if (pTiles != null)
                    {
                        foreach (var map in monitoredTilemaps.Values)
                        {
                            var pos     = map.transform.position;
                            var gridPos = map.WorldToCell(pos);
                            var ri2     = new RectInt((Vector2Int)gridPos + ri.position, ri.size);
                            TpLib.GetAllTilesInRegionForMap(map, pTiles, ri2);
                            OnTptTilesWillBeDeleted?.Invoke(map, pTiles); //event. 
                            map.SetTilesBlock(eraseBounds, nulls);
                        }
                    }
                }
            }

            if (destroyPrefabs && reg.m_Prefabs != null)
            {
                //destroy any prefabs
                if (reg.m_Prefabs.Count != 0)
                {
                    foreach (var gameObj in reg.m_Prefabs)
                    {
                        if (gameObj.TryGetComponent<TpSpawnLink>(out var link))
                        {
                            link.DespawnMe();
                            continue;
                        }
                        #if UNITY_EDITOR
                        UnityEngine.Object.DestroyImmediate(gameObj, false);
                        #else
                        UnityEngine.Object.Destroy(gameObj);
                        #endif
                    }
                }
            }

            if (!DeleteZoneRegistration(reg))
                TpLogWarning($"Could not delete this zonereg: {reg}");

            OnZoneRegDeleted?.Invoke(reg,this);
            return true;
        }
        

        #endregion
        #region chunking

        /// <summary>
        /// Required if you want to use chunking. No chunking data is accumulated and
        /// chunking will not work if this isn't used. Note that you should use this again for
        /// every new scene. WIPES OUT ANY EXISTING TILEFAB REGISTRATION DATA WHEN USED!!
        /// </summary>
        /// <param name="size">Size of a chunk. Must be even, rounded up if not.
        ///  Min=4. 4x4, 6x6, 8x8 ... 16x16 chunks etc</param>
        /// <param name="origin">The origin position, the base position, such as
        /// Vector3Int.zero, where the chunk numbers should be centered. If null then Vector3Int.zero is used. </param>
        /// <param name="initialMaxNumChunks">sets certain data structures' initial size. Base this on the total
        /// number of chunks of 'size' that would be in your camera's FOV at one time (for example). There's no problem
        /// if the max num chunks is exceeded, this just allocates memory early on given your best estimate of what's
        /// required as set in this method.</param>
        public  void Initialize(int size,  Vector3Int? origin = null, int initialMaxNumChunks = 64)
        {
            origin       ??= Vector3Int.zero; //default for origin position

            if (size < 4) //this would be a 4x4 TileFab which is ridiculously (?) small.
                size = 4;
            //test for an even number. 
            if (size % 2 != 0) //remainder should be zero if this is a multiple of 2.
                size++;
            
            //allocate memory for arrays.
            chunkMap                     = new Dictionary<RectInt,ZoneReg>(initialMaxNumChunks);
            getZoneRegForChunkInternal  = new List<ZoneReg>(initialMaxNumChunks / 4);
            
            defaultLocator   = new RectInt(Vector2Int.zero, new Vector2Int(size, size));
            worldOrigin = new Vector2Int(origin.Value.x, origin.Value.y);

            chunkingConfigured = true;
        }

        /// <summary>
        /// Get the ZoneRegs for a Zone locator RectInt
        /// </summary>
        /// <param name="locator">the RectInt chunk locator</param>
        /// <returns>ZoneReg List, list is Empty for error</returns>
        /// <remarks>return empty list if chunking not enabled or chunklocator is null.
        /// Note that the same list is cleared and re-used every time that this is called. </remarks>
        public  List<ZoneReg> GetZoneRegsForRegion(RectInt? locator)
        {
            getZoneRegForChunkInternal.Clear();
            
            if (!chunkingConfigured || !locator.HasValue || locator.Value.size == Vector2Int.zero)
                return getZoneRegForChunkInternal;

            var loc = locator.Value;
            // ReSharper disable once ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator
            foreach (var item in chunkMap.Keys)
            {
                if (item.Overlaps(loc))
                    getZoneRegForChunkInternal.Add(chunkMap[item]);
            }
            return getZoneRegForChunkInternal;
        }

        /// <summary>
        /// Obtain two datasets: one is a List of ZoneRegs that are outside of an area and another
        /// is a HashSet of ZoneRegs that are inside the area.
        /// </summary>
        /// <param name = "locator" >the RectInt Locator describing the area. </param>
        /// <param name="inside">ref HashSet for inside</param>
        /// <param name="outside">ref List for outside</param>
        /// <returns>false if any error occurs</returns>
        public bool FindRegionalZoneRegs(RectInt? locator, ref HashSet<RectInt> inside, ref List<ZoneReg> outside)
        {
           if (!chunkingConfigured || !locator.HasValue) 
               return false;

           var loc = locator.Value;
           inside.Clear();
           outside.Clear();
            //    return other.xMin < this.xMax && other.xMax > this.xMin && other.yMin < this.yMax && other.yMax > this.yMin;

            // ReSharper disable once ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator
            foreach ((var zone, var reg) in chunkMap)
            {
                if (zone.Overlaps(loc)) //if ANY part of the locator/zone overlaps the 'locator' RectInt
                    inside.Add(zone); //inside the locator's region
                else
                    outside.Add(reg); //outside the locator's region
            }   
            return true;      
        }

        
        /// <summary>
        /// Get the ZoneRegs for a chunk located at a Grid position.
        /// </summary>
        /// <param name="gridPosition">The position to use when searching for Zone registrations</param>
        /// <param name = "dimensions" >[Nullable] if not null, this is the search area. If null, ChunkMapAnchorPosition as set by Initialize</param>
        /// <param name = "align" >Align to grid. Default=true</param>
        /// <returns>a list of ZoneRegs. Empty list is valid and means error or nothing found.</returns>
        public  List<ZoneReg> GetZoneRegsForGridPosition(Vector3Int gridPosition, Vector2Int? dimensions = null, bool align = true)
        {
            return GetZoneRegsForRegion(GetLocatorForGridPosition(gridPosition,dimensions,align));
        }

        /// <summary>
        /// Get the Zone registration for a chunk located at a World position.
        /// </summary>
        /// <param name="worldPosition">The position to use when searching for Zone registrations</param>
        /// <param name = "map" >Tilemap to use for translating world to grid positions. If null, an empty list is returned.</param>
        /// <param name = "dimensions" >[Nullable] if not null, this is the search area. If null, ChunkMapAnchorPosition as set by Initialize</param>
        /// <param name = "align" >Align to grid. Default=true</param>
        /// <returns>a list of ZoneRegs. Empty list is valid and means error or nothing found.</returns>
        public List<ZoneReg> GetZoneRegsForWorldPosition(Vector3 worldPosition, Tilemap? map, Vector2Int? dimensions = null, bool align = true)
        {
            if (map)
                return GetZoneRegsForRegion(GetLocatorForWorldPosition(worldPosition, map, dimensions, align));

            getZoneRegForChunkInternal.Clear();
            return getZoneRegForChunkInternal;
        }
        
       
        /// <summary>
        /// Create an Zone registration locator from a grid position
        /// </summary>
        /// <param name="gridPosition">position on a Tilemap</param>
        /// <param name="dimensions">[Nullable] optional size of locator. If null, ChunkMapAnchorPosition as set by Initialize </param>
        /// <param name = "align" >Align to grid. Default=true</param>
        /// <returns>RectInt Zone registration locator</returns>
        public  RectInt GetLocatorForGridPosition(Vector3Int gridPosition, Vector2Int ?dimensions = null, bool align = true)
        {
            if (align)
                gridPosition = AlignToGrid(gridPosition);
            return new RectInt((Vector2Int) gridPosition + worldOrigin, dimensions ?? defaultLocator.size);
        }

        /// <summary>
        /// Create an Zone registration locator from a world position
        /// </summary>
        /// <param name="position">world position</param>
        /// <param name = "map" >Tilemap to use for translating world to grid positions. If null, new RectInt() is returned.</param>
        /// <param name="dimensions">[Nullable] optional size of locator. If null, ChunkMapAnchorPosition as set by Initialize </param>
        /// <param name = "align" >Align to grid. Default=true</param>
        /// <returns>RectInt Zone registration locator</returns>
        public RectInt GetLocatorForWorldPosition(Vector3 position, Tilemap? map, Vector2Int? dimensions = null, bool align = true)
        {
            return !map ? new RectInt()
                       : GetLocatorForGridPosition(map.WorldToCell(position), dimensions,align);
        }


       
        
        /// <summary>
        /// Is there a Zone registration associated with a RectInt locator? 
        /// </summary>
        /// <param name="locator">the RectInt to check</param>
        /// <returns>true if there's already a locator there.</returns>
        public bool HasZoneRegForLocator(RectInt locator)
        {
            return chunkMap.ContainsKey(locator); 
        }

        /// <summary>
        /// Get a Zone Reg for a locator RectInt
        /// </summary>
        /// <param name="locator">a locator</param>
        /// <param name="reg">a registration</param>
        /// <returns>true if reg was found. Note: if false the reg is default</returns>
        public bool GetZoneRegForLocator(RectInt locator, out ZoneReg? reg)
        {
            return chunkMap.TryGetValue(locator, out reg);
        }
        
        
        /// <summary>
        /// Convert a super-grid position to a locator
        /// </summary>
        /// <param name="sGridPosition">s sGrid postion</param>
        /// <param name="dimensions">dimensions of locator or null for default</param>
        /// <returns>a Locator.</returns>
        public RectInt GetLocatorForSgridPosition(Vector2Int sGridPosition, Vector2Int? dimensions = null)
        {
            var chunkSize = defaultLocator.size.x;
            var gridPos   = new Vector3Int(sGridPosition.x * chunkSize, sGridPosition.y * chunkSize);
            return GetLocatorForGridPosition(gridPos, dimensions);
        }

        /// <summary>
        /// Get a Tilemap grid position from a sGrid position. 
        /// </summary>
        /// <param name="sGridPosition">a sGrid position</param>
        /// <returns>a Tilemap grid position</returns>
        public Vector3Int GetGridPositionForSgridPosition(Vector2Int sGridPosition)
        {
            var chunkSize = defaultLocator.size.x;
            return new Vector3Int(sGridPosition.x * chunkSize, sGridPosition.y * chunkSize);
        }
        
        
        #endregion
        
        
        #region utils

        
        /// <summary>
        /// Get a JSON version of the Zone registrations
        /// </summary>
        /// <param name="prettyPrint"></param>
        /// <returns></returns>
        public  string GetZoneRegJson(bool prettyPrint = true)
        {
            var registrations= chunkMap.Values.OrderBy(zr => zr.dex).ToArray(); 
            var loadWrapper = new LoadWrapper(registrations);
            return JsonUtility.ToJson(loadWrapper, prettyPrint);
        }

        /// <summary>
        /// Restore all Tilefabs or Bundles based on a json-archived dataset.
        /// </summary>
        /// <param name="jsonString">data string to decode</param>
        /// <param name = "targetMap" >optional mapping from tilemap name to Tilemap instance. Speeds tilemap lookups greatly</param>
        /// <param name = "filter" >a Func of [(enum)FilterDataSource, object] returning a bool. See also LoadTileFab. </param>
        /// <param name = "filterOnlyTilePlusTiles"> if true (default) only applies filters to TilePLus tiles, which is usually sufficient and saves much time.  </param>
        /// <returns>A list of the TilefabLoadResults from however many Bundles are in the TileFab. Null is returned for errors</returns>
        /// <remarks>The list of TilefabLoadResults is cleared the next time that this method is used.</remarks>
        public List<TilefabLoadResults>? RestoreFromZoneRegJson(string                                                jsonString,
                                                                Dictionary<string, Tilemap>?                          targetMap = null,
                                                                Func<FabOrBundleFilterType, BoundsInt, object, bool>? filter                  = null,
                                                                bool                         filterOnlyTilePlusTiles = true
            )
        {
            var data = JsonUtility.FromJson<LoadWrapper>(jsonString);
            if(data == null)
                return null;

            var loadResultsArray = data.m_Res.ToList();
            loadResultsArray.Sort(Comparison); //ensure sorted in ascending index order. 
            var numLoadsToMake   = loadResultsArray.Count;
            var numPrevLoads      = currentLoadresults.Count;
            currentLoadresults.Clear(); //absolutely required to avoid exception from next line if count < capacity (no this was thought of in advance)
            if(numLoadsToMake > numPrevLoads) //don't play with Capacity unless enlarging.
                currentLoadresults.Capacity = loadResultsArray.Count;

            var loadFlags = filterOnlyTilePlusTiles
                                   ? FabOrBundleLoadFlags.NormalWithFilter
                                   : FabOrBundleLoadFlags.Normal;
            
            
            foreach (var r in loadResultsArray)
            {
                if(!TileFabLib.GetTileFabFromGuid(r.g, out var fab) || !fab)
                    continue;
                
                var result = TileFabLib.LoadTileFab(null,
                            fab,
                            r.offs,
                            r.rot,
                            loadFlags,
                            filter,
                            targetMap,
                            this);
                if(result == null)
                    continue;

                currentLoadresults.Add(result);

                TileFabLib.UpdateGuidLookup(r, result.ZoneReg!);

            }

            return currentLoadresults;
        }

        private  int Comparison(ZoneReg x, ZoneReg y)
        {
            if (x.dex < y.dex)
                return -1;
            return x.dex == y.dex ? 0 : 1;
        }


        /// <summary>
        /// Sets the name and managed Tilemaps for this instance.
        /// Note you can only do this once.
        /// </summary>
        /// <param name="iName">instance name</param>
        /// <param name="stringToTilemap">Dictionary of tilemap names to tilemap instances.</param>
        /// <returns>false if this has been called already.</returns>
        /// <remarks>This is only called by TileFabLib when creating a ZoneManager instance.</remarks>
        internal bool SetNameAndMap(string iName, Dictionary<string, Tilemap> stringToTilemap)
        {
            if (!string.IsNullOrEmpty(instanceName) || string.IsNullOrEmpty(iName))
                return false;
            instanceName  = iName;
            monitoredTilemaps = stringToTilemap;
            return true;
        }
        
        /// <summary>
        /// Set or change the monitored Tilemaps dict.
        /// </summary>
        /// <param name="stringToTilemap">Dict of stringTilemapName -> TilemapInstance</param>
        internal void SetMaps(Dictionary<string, Tilemap> stringToTilemap)
        {
            monitoredTilemaps = stringToTilemap;
        }
        
        /// <summary>
        /// Remove an Zone registration given an instance of one
        /// </summary>
        /// <param name="reg">ZoneReg instance</param>
        /// <returns>true if found</returns>
        public  bool DeleteZoneRegistration(ZoneReg reg)
        {
            var locator = reg.m_MyLocator;
            if (!chunkMap.Remove(locator)) 
            {
                TpLogError($"Could not delete ZoneReg {reg}");
                return false;
            }

            if (reg.m_Reserved)
                return true;
            
            //need to delete all entries from the s_LoadedGuidLookup that were originally added.
            //this is done by getting the new GUIDs from the registration, then doing a 
            //reverse lookup. That gets us the OLD guid which is the key for the LoadedGuidLookup dictionary.
            //of course also need to remove the corresponding item in the reverse-lookup dictionary
            // ReSharper disable once LoopCanBePartlyConvertedToQuery
            foreach (var bundleGuidMap in reg.ptgm) //these are the GUIDs assigned when loaded via LoadTileFab
                TileFabLib.RemoveGuidLookup(bundleGuidMap);
            TileFabLib.S_LoadedGuids!.Remove(new AssetGuidPositionHash(new Guid(reg.g), reg.offs)); 
            return true;

        }
        
        
        /// <summary>
        /// Get the last N Zone registrations.
        /// </summary>
        /// <param name="numResults"># of results desired. For a tilefab that should be 1</param>
        /// <returns>Enumerable of registrations, which could be empty.</returns>
        public  IEnumerable<ZoneReg> GetLastRegistrations(int numResults = 1)
        {
            return chunkMap.Values.OrderBy(zr => zr.dex).TakeLast(numResults); 
        }

        /// <summary>
        /// Get the very last Zone Reg. Handy when you know there is only one.
        /// </summary>
        /// <returns>the last zone reg used or a new one (index will be 0) if there aren't any regs in the ChunkMap for this ZM.</returns>
        public ZoneReg? GetLastRegistration()
        {
            return chunkMap.Count == 0 ? new ZoneReg() : chunkMap.Values.OrderBy(zr => zr.dex).Last();
        }

        /// <summary>
        /// Get all zone registrations with optional filtering and  ordering
        /// </summary>
        /// <param name="orderByIndex">order by ZoneReg index if true</param>
        /// <param name="filter">Func of ZoneReg returning bool. If ret val true then zm returned else it is skipped.</param>
        /// <returns>IEnumerable of ZoneReg instances. DON'T HOLD REFERENCES TO THESE!!! will make a memory leak.</returns>
        public IEnumerable<ZoneReg> GetAllZoneRegistrationsFiltered(bool orderByIndex=false, Func<ZoneReg, bool>? filter = null)
        {
            if (filter != null)
                return orderByIndex
                           ? chunkMap.Values.OrderBy(zr => zr.dex).Where(filter)
                           : chunkMap.Values.Where(filter);
            
            if(orderByIndex)
                return chunkMap.Values.OrderBy(zr => zr.dex);
            return chunkMap.Values;
        }

        /// <summary>
        /// Is this grid position aligned to the super-grid?
        /// </summary>
        /// <param name="position">position to test</param>
        /// <returns>true if aligned</returns>
        public bool IsAlignedToGrid(Vector3Int position)
        {
            var relativePosition = position - (Vector3Int)worldOrigin;
            var size             = defaultLocator.size.x;
            return relativePosition.x % size == 0 && relativePosition.y % size == 0;
        }


        /// <summary>
        /// Align a position to the super-grid. Note: positions are aligned to the lower-left corner of a rectint.
        /// </summary>
        /// <param name="position">position to adjust</param>
        /// <returns>Adjusted position. Won't change if already aligned.</returns>
        public Vector3Int AlignToGrid(Vector3Int position)
        {
            
            if (IsAlignedToGrid(position))
                return position;
            
            var relPos = position - (Vector3Int)worldOrigin;
            var size   = defaultLocator.size.x;
            var diffX  = relPos.x % size;
            var diffY  = relPos.y % size;

            return new Vector3Int(relPos.x - diffX, relPos.y - diffY, position.z);

        }

        #endregion
        
        
    }
}

```