public OverriddenElementViewModel(ElementLookup lookup, EnvironmentMergeSection environmentSection, ElementViewModel subject)
 {
     this.lookup = lookup;
     this.environmentSection = environmentSection;
     this.elementReference = new ReferenceContainer(this);
     this.subject = subject;
 }
 public OverriddenElementViewModel(ElementLookup lookup, EnvironmentMergeSection environmentSection, EnvironmentNodeMergeElement mergeElement)
 {
     this.lookup = lookup;
     this.environmentSection = environmentSection;
     this.mergeElement = mergeElement;
     this.elementReference = new ReferenceContainer(this);
     this.elementReference.InitializeReference(mergeElement.ConfigurationNodePath, mergeElement);
 }
Exemplo n.º 3
0
    void sendNewBytes()
    {
        const int  acreSizeItems = 32 * 32;
        const uint acreSizeBytes = acreSizeItems * Item.SIZE;

        // convert all to lists
        var listLayer1     = new List <Item>(fieldManager.Layer1.Tiles);
        var listLayer2     = new List <Item>(fieldManager.Layer2.Tiles);
        var templateLayer1 = new List <Item>(layerTemplate1);
        var templateLayer2 = new List <Item>(layerTemplate2);

        // split everything into acres
        var splitl1  = listLayer1.ChunkBy(acreSizeItems);
        var splitl2  = listLayer2.ChunkBy(acreSizeItems);
        var splitlt1 = templateLayer1.ChunkBy(acreSizeItems);
        var splitlt2 = templateLayer2.ChunkBy(acreSizeItems);

        var offset       = (uint)OffsetHelper.FieldItemStart;
        var offsetl2     = offset + (MapGrid.MapTileCount32x32 * Item.SIZE);
        var dataSendList = new List <OffsetData>();

        // layer 1
        for (uint i = 0; i < splitl1.Count; ++i)
        {
            int ix = (int)i;
            if (splitl1[ix].IsDifferent(splitlt1[ix]))
            {
                dataSendList.Add(new OffsetData(offset + (i * acreSizeBytes), splitl1[ix].SetArray(Item.SIZE)));
            }
        }

        // layer 2
        for (uint i = 0; i < splitl2.Count; ++i)
        {
            int ix = (int)i;
            if (splitl2[ix].IsDifferent(splitlt2[ix]))
            {
                dataSendList.Add(new OffsetData(offsetl2 + (i * acreSizeBytes), splitl2[ix].SetArray(Item.SIZE)));
            }
        }

        var layerBytes = new List <byte>(listLayer1.SetArray(Item.SIZE));

        layerBytes.AddRange(listLayer2.SetArray(Item.SIZE));

        ReferenceContainer <float> progressValue = new ReferenceContainer <float>(0f);
        Texture2D itemTex = SpriteBehaviour.ItemToTexture2D(5984, 0, out var _); // large star fragment

        UI_Popup.CurrentInstance.CreateProgressBar("Placing new acres... Go in then out of a building to view changes.", progressValue, itemTex, Vector3.up * 180, null, "Cancel", () => { StopAllCoroutines(); });
        StartCoroutine(writeData(dataSendList.ToArray(), progressValue, () => { field = layerBytes.ToArray(); generateAll(); }));
    }
Exemplo n.º 4
0
    public void DumpTwoLayers()
    {
        layer1Dump = new Item[MapGrid.MapTileCount32x32]; layer2Dump = new Item[MapGrid.MapTileCount32x32];
        Func <Item, bool>          dumpL1            = new Func <Item, bool>(x => DumpItemToLayer(x, 0));
        Func <Item, bool>          dumpL2            = new Func <Item, bool>(x => DumpItemToLayer(x, 1));
        ReferenceContainer <float> itemFunctionValue = new ReferenceContainer <float>(0f);
        Texture2D itemTex = SpriteBehaviour.ItemToTexture2D(8574, 0, out var _);

        UI_Popup.CurrentInstance.CreateProgressBar("Getting item layout template, please run around but don't place anything on your island...", itemFunctionValue, itemTex, Vector3.up * 180, null, "Cancel", () => { CancelCurrentFunction(); KeepAliveButton.interactable = ResendButton.interactable = false; });

        StartCoroutine(functionTiles(dumpL1, itemFunctionValue, dumpL2));
        KeepAliveButton.interactable = true;
        ResendButton.interactable    = true;
    }
Exemplo n.º 5
0
    IEnumerator progressBar(ReferenceContainer <float> progress)
    {
        while (progress.Value < 1)
        {
            ProgressBar.fillAmount = progress.Value;

            Vector3 newLoaderPos = Vector3.Lerp(LoaderPosStart.transform.position, LoaderPosEnd.transform.position, progress.Value);
            LoaderImage.transform.position = newLoaderPos;

            yield return(null);
        }

        cleanUp();
    }
Exemplo n.º 6
0
    public void PlaceNMT()
    {
        Item nmt = new Item(5851);

        nmt.Count            = 9;
        CurrentlyPlacingItem = nmt;

        Func <Item, bool>          itemPlacer        = new Func <Item, bool>(PlaceItemIfEmpty);
        ReferenceContainer <float> itemFunctionValue = new ReferenceContainer <float>(0f);
        Texture2D itemTex = SpriteBehaviour.ItemToTexture2D(5851, 0, out var _);

        UI_Popup.CurrentInstance.CreateProgressBar("Placing items, please run around but don't place anything on your island...", itemFunctionValue, itemTex, Vector3.up * 180, null, "Cancel", () => { CancelCurrentFunction(); });

        StartCoroutine(functionTiles(itemPlacer, itemFunctionValue));
    }
Exemplo n.º 7
0
        public TypeSpec GetStackType(EmitContext ec)
        {
            var instance_type = instance.Type;

            if (addressRequired)
            {
                return(ReferenceContainer.MakeType(ec.Module, instance_type));
            }

            if (instance_type.IsStructOrEnum)
            {
                return(ec.Module.Compiler.BuiltinTypes.Object);
            }

            return(instance_type);
        }
Exemplo n.º 8
0
    IEnumerator KeepAliveLoop(Func <Item, bool> processItem, ReferenceContainer <float> progress, Func <Item, bool> processItemLayer2 = null)
    {
        bool exitToken   = false;
        int  refreshRate = UI_Settings.GetThreadSleepTime();

        UI_Popup.CurrentInstance.CreatePopupChoice($"Your map is being continuously refreshed at minimum {refreshRate}ms per acre. You may decrease this value in settings, but the tradeoff may be stability.\r\nTo see replenished items, go in & out of a building.", "Stop refreshing", () => { exitToken = true; });
        while (!exitToken)
        {
            LastRefresherTime.text = $"Last refresher run:\r\n{DateTime.Now:dddd, dd MMMM yyyy HH:mm:ss}";
            StartCoroutine(functionTiles(processItem, progress, processItemLayer2, true));
            mapFunctionRunning = true;
            while (mapFunctionRunning && !exitToken)
            {
                yield return(new WaitForSeconds(1f));
            }
        }

        CancelCurrentFunction();
    }
Exemplo n.º 9
0
        static TypeSpec EmitCallInstance(EmitContext ec, Expression instance, TypeSpec declaringType, OpCode callOpcode)
        {
            var instance_type = instance.Type;

            //
            // Push the instance expression
            //
            if ((instance_type.IsStruct && (callOpcode == OpCodes.Callvirt || (callOpcode == OpCodes.Call && declaringType.IsStruct))) ||
                instance_type.IsGenericParameter || declaringType.IsNullableType)
            {
                //
                // If the expression implements IMemoryLocation, then
                // we can optimize and use AddressOf on the
                // return.
                //
                // If not we have to use some temporary storage for
                // it.
                var iml = instance as IMemoryLocation;
                if (iml != null)
                {
                    iml.AddressOf(ec, AddressOp.Load);
                }
                else
                {
                    LocalTemporary temp = new LocalTemporary(instance_type);
                    instance.Emit(ec);
                    temp.Store(ec);
                    temp.AddressOf(ec, AddressOp.Load);
                }

                return(ReferenceContainer.MakeType(ec.Module, instance_type));
            }

            if (instance_type.IsEnum || instance_type.IsStruct)
            {
                instance.Emit(ec);
                ec.Emit(OpCodes.Box, instance_type);
                return(ec.BuiltinTypes.Object);
            }

            instance.Emit(ec);
            return(instance_type);
        }
Exemplo n.º 10
0
    IEnumerator writeData(OffsetData[] toSend, ReferenceContainer <float> progress, Action onEnd)
    {
        for (int i = 0; i < toSend.Length; ++i)
        {
            var chunk = toSend[i];
            MapParent.CurrentConnection.WriteBytes(chunk.ToSend, chunk.Offset);
            MapParent.CurrentConnection.WriteBytes(chunk.ToSend, chunk.Offset + (uint)OffsetHelper.BackupSaveDiff);
            float currentProgress = (i + 1) / (float)toSend.Length;
            progress.UpdateValue(currentProgress);
            yield return(null);
        }


        onEnd?.Invoke();
        yield return(null);

        progress.UpdateValue(1.01f);
        UI_ACItemGrid.LastInstanceOfItemGrid.PlayHappyParticles();
    }
Exemplo n.º 11
0
        public void EmitToVariable(EmitContext ec)
        {
            var type = Expr.Type;

            if (IsByRef)
            {
                var ml = (IMemoryLocation)Expr;
                ml.AddressOf(ec, AddressOp.LoadStore);
                type = ReferenceContainer.MakeType(ec.Module, type);
            }
            else
            {
                Expr.Emit(ec);
            }

            variable = new LocalTemporary(type);
            variable.Store(ec);

            Expr = variable;
        }
        public void MainTest()
        {
            using (var session = Domain.OpenSession()) {
                using (var transactionScope = session.OpenTransaction()) {
                    var item = new Item();
                    var referenceContainer1 = new ReferenceContainer();
                    var referenceContainer2 = new ReferenceContainer {
                        Items = { new Reference {
                                      Item = item
                                  } }
                    };

                    session.SaveChanges();
                    var l = session.Query.All <IHasItems>()
                            .Where(container => container.Items.Any())
                            .ToList();

                    Assert.AreEqual(1, l.Count);
                }
            }
        }
Exemplo n.º 13
0
    public void CreateProgressBar(string message, ReferenceContainer <float> progress, Texture2D progressMovingTexture = null, Vector3?pmtRot = null, Texture2D imgTexture = null, string buttonLabel1 = null, Action onButton1 = null, Color?c = null)
    {
        CreatePopupChoice(message, buttonLabel1, onButton1, c);

        ProgressBar.gameObject.SetActive(true);
        ProgressBar.transform.parent.gameObject.SetActive(true);

        PopImage.gameObject.SetActive(true);
        if (imgTexture != null)
        {
            PopImage.texture = imgTexture;
        }
        else
        {
            PopImage.gameObject.SetActive(false);
        }

        LoaderImage.gameObject.SetActive(true);
        if (progressMovingTexture != null)
        {
            LoaderImage.texture = progressMovingTexture;
        }
        else
        {
            LoaderImage.gameObject.SetActive(false);
        }
        LoaderImage.transform.position = LoaderPosStart.transform.position;

        if (pmtRot.HasValue)
        {
            LoaderImage.transform.rotation = Quaternion.Euler(pmtRot.Value);
        }
        else
        {
            LoaderImage.transform.rotation = Quaternion.identity;
        }

        StopAllCoroutines();
        StartCoroutine(progressBar(progress));
    }
Exemplo n.º 14
0
    public void ClearItems()
    {
        Func <Item, bool>          deleter           = new Func <Item, bool>(x => DeleteType(x, currentRemovalItem));
        ReferenceContainer <float> itemFunctionValue = new ReferenceContainer <float>(0f);
        Texture2D imgToShow;
        string    progressString;
        Vector3   rot;

        switch (currentRemovalItem)
        {
        case RemovalItem.Bush:
        case RemovalItem.Flower:
        case RemovalItem.Weed:
            imgToShow      = SpriteBehaviour.ItemToTexture2D(338, 0, out var _); // red lawnmover
            progressString = "Mowing lawn, please run around but don't place anything on your island...";
            rot            = Vector3.up * 180;
            break;

        case RemovalItem.Fence:
        case RemovalItem.Tree:
        case RemovalItem.Stone:
        case RemovalItem.TreeBranch:
            imgToShow      = SpriteBehaviour.ItemToTexture2D(9617, 0, out var _); // golden axe
            progressString = $"Chopping up every {currentRemovalItem.ToString().ToLower()}, please run around but don't place anything on your island...";
            rot            = Vector3.up * 180;
            break;

        default:
            imgToShow      = ResourceLoader.GetAngryIsabelle(); // \_/
            progressString = "Isabelle is cleaning up your mess, please run around but don't place anything on your island...";
            rot            = Vector3.up * 180;
            break;
        }

        UI_Popup.CurrentInstance.CreateProgressBar(progressString, itemFunctionValue, imgToShow, rot, null, "Cancel", () => { CancelCurrentFunction(); });

        StartCoroutine(functionTiles(deleter, itemFunctionValue));
    }
Exemplo n.º 15
0
	// Update Physics Skinning
	public void UpdatePhysicsSkinning()
	{
		if(m_oMeshColliders != null)
		{
			if(m_oBones != null)
			{
				int iColliderCount = MeshColliders.Count;
				if(iColliderCount > 0)
				{
					// Create Collider meshes arrays if needed
					if(m_oPoseColliderMeshes == null || m_oPoseColliderMeshes.Length != iColliderCount)
					{
						m_oPoseColliderMeshes = new Mesh[iColliderCount];
					}
					if(m_oRefManipulatedColliderMeshes == null || m_oRefManipulatedColliderMeshes.Length != iColliderCount)
					{
						// Destroy old references
						DestroyManipulatedColliderMeshReferences();
						
						// Recreate
						m_oRefManipulatedColliderMeshes = new ReferenceContainer[iColliderCount];
						for(int i = 0; i<iColliderCount; ++i)
						{
							ReferenceContainer rReferenceContainer = new ReferenceContainer();
							rReferenceContainer.Initialize(this, true);
							m_oRefManipulatedColliderMeshes[i] = rReferenceContainer;
						}
					}
					
					// Apply the skin blend on each collider
					int iColliderIndex = 0;
					List<Mesh> rColliderMeshes = m_rSprite.SpriteData.meshCollidersList;
					foreach(MeshCollider rMeshCollider in m_oMeshColliders)
					{
						if(rMeshCollider != null)
						{
							// Get The pose and manipulated mesh
							Mesh rPoseMesh = m_oPoseColliderMeshes[iColliderIndex];
							ReferenceContainer rRefManipulatedMesh = m_oRefManipulatedColliderMeshes[iColliderIndex];
							
							if(ApplySkinBlend(rColliderMeshes[iColliderIndex], rMeshCollider.sharedMesh, ref rPoseMesh, ref rRefManipulatedMesh))
							{
								// Update collider mesh
								rMeshCollider.sharedMesh = null;
								rMeshCollider.sharedMesh = rRefManipulatedMesh.Reference as Mesh;
								
								m_oPoseColliderMeshes[iColliderIndex] = rPoseMesh;
							}
						}
						
						++iColliderIndex;
					}
				}
			}
		}
		
		#if AFTER_UNITY_4_3
		if(PolygonCollider2D != null)
		{
			PolygonCollider2D.points = Uni2DSkinningUtils.ApplySkinBlend(m_rSprite.SpriteData.mesh2D, m_oBones, transform, quality);
		}
		#endif
	}
Exemplo n.º 16
0
    IEnumerator functionTiles(Func <Item, bool> processItem, ReferenceContainer <float> progress)
    {
        int maxtransferSizeRemainder = CurrentConnection.MaximumTransferSize % Item.SIZE;
        int maxtransferSize          = CurrentConnection.MaximumTransferSize - maxtransferSizeRemainder;

        uint fieldItemsStart1 = CurrentMapAddress;
        uint fieldItemsStart2 = CurrentMapAddress + FieldItemLayerSize;
        uint itemsPerFrame    = (uint)maxtransferSize / Item.SIZE;
        uint lastTileIndex    = 0;

        int byteCheckCount  = 0;
        int yieldCheckCount = 0;

        while (lastTileIndex < MapGrid.MapTileCount32x32)
        {
            int    thisFrameL1Proc = 0;
            int    thisFrameL2Proc = 0;
            int    bytesToCheck    = (int)Math.Min((int)itemsPerFrame * Item.SIZE, FieldItemLayerSize - (lastTileIndex * Item.SIZE));
            byte[] bytesLayer1     = CurrentConnection.ReadBytes(fieldItemsStart1 + (lastTileIndex * Item.SIZE), bytesToCheck);
            byte[] bytesLayer2     = CurrentConnection.ReadBytes(fieldItemsStart2 + (lastTileIndex * Item.SIZE), bytesToCheck);
            Item[] itemLayer1      = Item.GetArray(bytesLayer1);
            Item[] itemLayer2      = Item.GetArray(bytesLayer2);
            foreach (Item i in itemLayer1)
            {
                if (processItem(i))
                {
                    thisFrameL1Proc++;
                }
            }
            foreach (Item i in itemLayer2)
            {
                if (processItem(i))
                {
                    thisFrameL2Proc++;
                }
            }
            if (thisFrameL1Proc > 0)
            {
                byte[] nl1 = itemLayer1.SetArray(Item.SIZE);
                CurrentConnection.WriteBytes(nl1, fieldItemsStart1 + (lastTileIndex * Item.SIZE));
            }
            if (thisFrameL2Proc > 0)
            {
                byte[] nl2 = itemLayer2.SetArray(Item.SIZE);
                CurrentConnection.WriteBytes(nl2, fieldItemsStart2 + (lastTileIndex * Item.SIZE));
            }
            byteCheckCount += bytesToCheck;
            //Debug.Log(string.Format("Currently read byte {0}/{1}.", byteCheckCount, FieldItemLayerSize));
            lastTileIndex += itemsPerFrame;
            yieldCheckCount++;

            if (yieldCheckCount % YieldCount == 0)
            {
                float progressNow = (float)byteCheckCount / FieldItemLayerSize;
                progress.UpdateValue(progressNow);
                yield return(null);
            }
        }

        progress.UpdateValue(0.99f);
        yield return(null);

        progress.UpdateValue(1.01f);
    }
Exemplo n.º 17
0
 // Ensure Mesh Validity
 private bool EnsureMeshValidity(Mesh a_rSourceMesh, Mesh a_rUsedMesh, ref Mesh a_rPoseMesh, ref ReferenceContainer a_rRefManipulatedMesh)
 {
     if (a_rSourceMesh != null)
     {
         Object rManipulatedMesh = a_rRefManipulatedMesh.Reference;
         if (a_rPoseMesh == null || a_rPoseMesh != a_rSourceMesh || rManipulatedMesh == null || rManipulatedMesh != a_rUsedMesh)
         {
             a_rPoseMesh = a_rSourceMesh;
             if (rManipulatedMesh != null)
             {
                 DestroyImmediate(rManipulatedMesh);
             }
             a_rRefManipulatedMesh.Reference = Uni2DEditorResourceCopyUtils.DuplicateMesh(a_rPoseMesh);
         }
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemplo n.º 18
0
    // ApplySkinBlend
    private bool ApplySkinBlend(Mesh a_rSourceMesh, Mesh a_rUsedMesh, ref Mesh a_rPoseMesh, ref ReferenceContainer a_rRefManipulatedMesh)
    {
        if (EnsureMeshValidity(a_rSourceMesh, a_rUsedMesh, ref a_rPoseMesh, ref a_rRefManipulatedMesh))
        {
            // Renderer
            Vector3[] oVertices = a_rPoseMesh.vertices;
            Uni2DSkinningUtils.ApplySkinBlend(ref oVertices, a_rPoseMesh, m_oBones, transform, quality);
            Mesh rManipulatedMesh = a_rRefManipulatedMesh.Reference as Mesh;
            (rManipulatedMesh).vertices = oVertices;
            rManipulatedMesh.RecalculateBounds();

            return(true);
        }
        else
        {
            return(false);
        }
    }
Exemplo n.º 19
0
    // Update Physics Skinning
    public void UpdatePhysicsSkinning()
    {
        if (m_oMeshColliders != null)
        {
            if (m_oBones != null)
            {
                int iColliderCount = MeshColliders.Count;
                if (iColliderCount > 0)
                {
                    // Create Collider meshes arrays if needed
                    if (m_oPoseColliderMeshes == null || m_oPoseColliderMeshes.Length != iColliderCount)
                    {
                        m_oPoseColliderMeshes = new Mesh[iColliderCount];
                    }
                    if (m_oRefManipulatedColliderMeshes == null || m_oRefManipulatedColliderMeshes.Length != iColliderCount)
                    {
                        // Destroy old references
                        DestroyManipulatedColliderMeshReferences();

                        // Recreate
                        m_oRefManipulatedColliderMeshes = new ReferenceContainer[iColliderCount];
                        for (int i = 0; i < iColliderCount; ++i)
                        {
                            ReferenceContainer rReferenceContainer = new ReferenceContainer();
                            rReferenceContainer.Initialize(this, true);
                            m_oRefManipulatedColliderMeshes[i] = rReferenceContainer;
                        }
                    }

                    // Apply the skin blend on each collider
                    int         iColliderIndex  = 0;
                    List <Mesh> rColliderMeshes = m_rSprite.SpriteData.meshCollidersList;
                    foreach (MeshCollider rMeshCollider in m_oMeshColliders)
                    {
                        if (rMeshCollider != null)
                        {
                            // Get The pose and manipulated mesh
                            Mesh rPoseMesh = m_oPoseColliderMeshes[iColliderIndex];
                            ReferenceContainer rRefManipulatedMesh = m_oRefManipulatedColliderMeshes[iColliderIndex];

                            if (ApplySkinBlend(rColliderMeshes[iColliderIndex], rMeshCollider.sharedMesh, ref rPoseMesh, ref rRefManipulatedMesh))
                            {
                                // Update collider mesh
                                rMeshCollider.sharedMesh = null;
                                rMeshCollider.sharedMesh = rRefManipulatedMesh.Reference as Mesh;

                                m_oPoseColliderMeshes[iColliderIndex] = rPoseMesh;
                            }
                        }

                        ++iColliderIndex;
                    }
                }
            }
        }

                #if AFTER_UNITY_4_3
        if (PolygonCollider2D != null)
        {
            PolygonCollider2D.points = Uni2DSkinningUtils.ApplySkinBlend(m_rSprite.SpriteData.mesh2D, m_oBones, transform, quality);
        }
                #endif
    }
Exemplo n.º 20
0
	// ApplySkinBlend
	private bool ApplySkinBlend(Mesh a_rSourceMesh, Mesh a_rUsedMesh, ref Mesh a_rPoseMesh, ref ReferenceContainer a_rRefManipulatedMesh)
	{
		if(EnsureMeshValidity(a_rSourceMesh, a_rUsedMesh, ref a_rPoseMesh, ref a_rRefManipulatedMesh))
		{
			// Renderer
			Vector3[] oVertices = a_rPoseMesh.vertices;
			Uni2DSkinningUtils.ApplySkinBlend(ref oVertices, a_rPoseMesh, m_oBones, transform, quality);
			Mesh rManipulatedMesh = a_rRefManipulatedMesh.Reference as Mesh;
			(rManipulatedMesh).vertices = oVertices;
			rManipulatedMesh.RecalculateBounds();
			
			return true;
		}
		else
		{
			return false;
		}
	}
Exemplo n.º 21
0
	// Ensure Mesh Validity
	private bool EnsureMeshValidity(Mesh a_rSourceMesh, Mesh a_rUsedMesh, ref Mesh a_rPoseMesh, ref ReferenceContainer a_rRefManipulatedMesh)
	{
		if(a_rSourceMesh != null)
		{
			Object rManipulatedMesh = a_rRefManipulatedMesh.Reference;
			if(a_rPoseMesh == null || a_rPoseMesh != a_rSourceMesh || rManipulatedMesh == null || rManipulatedMesh != a_rUsedMesh)
			{
				a_rPoseMesh = a_rSourceMesh;
				if(rManipulatedMesh != null)
				{
					DestroyImmediate(rManipulatedMesh);
				}
				a_rRefManipulatedMesh.Reference = Uni2DEditorResourceCopyUtils.DuplicateMesh(a_rPoseMesh);
			}
			return true;
		}
		else
		{
			return false;
		}
	}
Exemplo n.º 22
0
 /// <summary>
 /// Checkbox item with a toggleable checkbox, Updates With Reference Change.
 /// </summary>
 /// <param name="text">Item label.</param>
 /// <param name="check">Boolean value whether the checkbox is checked.</param>
 public UIMenuCheckboxItem(string text, ref ReferenceContainer <bool> check) : this(text, ref check, "")
 {
 }
Exemplo n.º 23
0
 private void Awake()
 {
     _instance = this;
 }
Exemplo n.º 24
0
    IEnumerator functionTiles(Func <Item, bool> processItem, ReferenceContainer <float> progress, Func <Item, bool> processItemLayer2 = null, bool checkArrivals = false)
    {
        mapFunctionRunning = true;
        int maxtransferSizeRemainder = CurrentConnection.MaximumTransferSize % Item.SIZE;
        int maxtransferSize          = CurrentConnection.MaximumTransferSize - maxtransferSizeRemainder;

        uint fieldItemsStart1 = CurrentMapAddress;
        uint fieldItemsStart2 = CurrentMapAddress + FieldItemLayerSize;
        uint itemsPerFrame    = (uint)maxtransferSize / Item.SIZE;
        uint lastTileIndex    = 0;

        int byteCheckCount  = 0;
        int yieldCheckCount = 0;

        while (lastTileIndex < MapGrid.MapTileCount32x32)
        {
            int    thisFrameL1Proc = 0;
            int    thisFrameL2Proc = 0;
            int    bytesToCheck    = (int)Math.Min((int)itemsPerFrame * Item.SIZE, FieldItemLayerSize - (lastTileIndex * Item.SIZE));
            byte[] bytesLayer1     = CurrentConnection.ReadBytes(fieldItemsStart1 + (lastTileIndex * Item.SIZE), bytesToCheck);
            byte[] bytesLayer2     = Layer2Affect.isOn ? CurrentConnection.ReadBytes(fieldItemsStart2 + (lastTileIndex * Item.SIZE), bytesToCheck) : null;
            Item[] itemLayer1      = Item.GetArray(bytesLayer1);
            Item[] itemLayer2      = Layer2Affect.isOn ? Item.GetArray(bytesLayer2) : null;
            for (uint j = 0; j < itemLayer1.Length; ++j)
            {
                Item i = itemLayer1[j];
                indexOfItemBeingProcessed = lastTileIndex + j;
                if (processItem(i))
                {
                    thisFrameL1Proc++;
                }
            }
            if (Layer2Affect.isOn)
            {
                for (uint j = 0; j < itemLayer2.Length; ++j)
                {
                    Item i = itemLayer2[j];
                    indexOfItemBeingProcessed = lastTileIndex + j;
                    if (processItemLayer2 == null)
                    {
                        if (processItem(i))
                        {
                            thisFrameL2Proc++;
                        }
                    }
                    else
                    {
                        if (processItemLayer2(i))
                        {
                            thisFrameL2Proc++;
                        }
                    }
                }
            }
            // Check if someone is arriving
            if (checkArrivals)
            {
                if (IsSomeoneArriving(out string coming))
                {
                    CurrentLog.IncrementJoin(coming);
                    UI_Popup.CurrentInstance.UpdateText($"{coming} is arriving!\r\nThe auto-refresher is temporarily paused while their airplane animation occurs.");
                    yield return(new WaitForSeconds(74.5f));

                    SetLastComingVisitorName(string.Empty);
                    UI_Popup.CurrentInstance.ResetText();
                }
            }
            if (thisFrameL1Proc > 0)
            {
                byte[] nl1 = itemLayer1.SetArray(Item.SIZE);
                CurrentConnection.WriteBytes(nl1, fieldItemsStart1 + (lastTileIndex * Item.SIZE));
                CurrentConnection.WriteBytes(nl1, fieldItemsStart1 + (lastTileIndex * Item.SIZE) + (uint)OffsetHelper.BackupSaveDiff);
            }
            if (thisFrameL2Proc > 0 && Layer2Affect.isOn)
            {
                byte[] nl2 = itemLayer2.SetArray(Item.SIZE);
                CurrentConnection.WriteBytes(nl2, fieldItemsStart2 + (lastTileIndex * Item.SIZE));
                CurrentConnection.WriteBytes(nl2, fieldItemsStart2 + (lastTileIndex * Item.SIZE) + (uint)OffsetHelper.BackupSaveDiff);
            }
            byteCheckCount += bytesToCheck;
            //Debug.Log(string.Format("Currently read byte {0}/{1}.", byteCheckCount, FieldItemLayerSize));
            lastTileIndex += itemsPerFrame;
            yieldCheckCount++;

            if (yieldCheckCount % YieldCount == 0)
            {
                float progressNow = (float)byteCheckCount / FieldItemLayerSize;
                progress.UpdateValue(progressNow);
                yield return(null);
            }
        }

        progress.UpdateValue(0.99f);
        yield return(null);

        progress.UpdateValue(1.01f);
        mapFunctionRunning = false;
    }