Beispiel #1
0
        public IEnumerator DetectOverTime()
        {
            //get all the scripts that this affects
            List <WorldItem> detectedItems = new List <WorldItem>();
            //start in the chunk group
            var getAllChildrenByType = WIGroups.GetAllChildrenByType(
                GameWorld.Get.PrimaryChunk.ChunkGroup.Props.PathName,
                Usage.TargetWIScriptNames,
                detectedItems,
                Player.Local.Position,
                EffectRadius,
                gMaxDetectedItems);

            while (getAllChildrenByType.MoveNext())
            {
                yield return(getAllChildrenByType.Current);
            }

            //did we detect anything?
            if (detectedItems.Count > 0)
            {
                //tell these items to light up temporarily
                foreach (WorldItem detectedItem in detectedItems)
                {
                    if (!string.IsNullOrEmpty(Usage.SendMessageArgument))
                    {
                        detectedItem.SendMessage(Usage.SendMessageToTargetObject, Usage.SendMessageArgument, SendMessageOptions.DontRequireReceiver);
                    }
                    else
                    {
                        detectedItem.SendMessage(Usage.SendMessageToTargetObject, SendMessageOptions.DontRequireReceiver);
                    }
                    //spawn any vfx on detection
                    if (!string.IsNullOrEmpty(Effects.FXOnSuccess))
                    {
                        FXManager.Get.SpawnFX(detectedItem.transform.position, Effects.FXOnSuccess);
                        if (!string.IsNullOrEmpty(Effects.FXOnSuccessMasteredBooster))
                        {
                            //if we have a 'mastered' booster effect
                            //spawn that if we've mastered
                            FXManager.Get.SpawnFX(detectedItem.transform.position, Effects.FXOnSuccessMasteredBooster);
                        }
                    }
                    double waitUntil = Frontiers.WorldClock.AdjustedRealTime + 1f;
                    while (Frontiers.WorldClock.AdjustedRealTime < waitUntil)
                    {
                        yield return(null);
                    }
                }
                OnSuccess();
            }
            yield break;
        }
Beispiel #2
0
        //this function is meant to be used with the HouseOfHealing skill
        //i've only been able to get this process to work a few times
        //the idea is to super-load the last visited HOH
        //then load its interior and put the player in one of its beds
        //great in theory but in practice something always f***s up
        protected IEnumerator SpawnInClosestStructureOverTime(Vector3 despawnPosition, List <MobileReference> structureReferences, Action <Bed> OnFinishAction)
        {
            if (mSpawningPlayer)
            {
                //whoops
                yield break;
            }
            mSpawningPlayer = true;

            CurrentStartupPosition = null;

            float           closestDistanceSoFar           = Mathf.Infinity;
            StackItem       closestStructureStateSoFar     = null;
            StackItem       currentStructureState          = null;
            MobileReference currentStructureReference      = null;
            MobileReference closestStructureReferenceSoFar = null;
            Vector3         closestStructurePositionSoFar  = despawnPosition;
            WorldChunk      currentChunk = null;

            //find out which structure is the closest
            for (int i = 0; i < structureReferences.Count; i++)
            {
                currentStructureReference = structureReferences [i];
                //Debug.Log ("SPAWNMANAGER: Checking structure reference " + currentStructureReference.FullPath.ToString ());
                if (WIGroups.LoadStackItem(currentStructureReference, out currentStructureState))
                {
                    if (currentStructureState.Is <Structure> ())
                    {
                        //get the chunk for this item
                        if (GameWorld.Get.ChunkByID(currentStructureReference.ChunkID, out currentChunk))
                        {
                            Vector3 structureWorldPosition = WorldChunk.ChunkPositionToWorldPosition(currentChunk.ChunkBounds, currentStructureState.ChunkPosition);
                            structureWorldPosition += currentChunk.ChunkOffset;
                            float currentDistance = Vector3.Distance(despawnPosition, structureWorldPosition);
                            if (currentDistance < closestDistanceSoFar)
                            {
                                closestDistanceSoFar           = currentDistance;
                                closestStructureStateSoFar     = currentStructureState;
                                closestStructureReferenceSoFar = currentStructureReference;
                                closestStructurePositionSoFar  = structureWorldPosition;
                            }
                        }
                    }
                }
            }

            if (closestStructureStateSoFar == null)
            {
                yield break;
            }

            //move the player to the position of the new item
            //this will help us to super-load the structure
            Player.Local.Position = closestStructurePositionSoFar;

            //reset the current loading structure
            mSpawnStructureWorldItem = null;
            Structure spawnStructure = null;
            Bed       loadedBed      = null;

            //super-load the item
            //yield return null;
            //WorldItems.Get.SuspendActiveStateChecking = true;
            StartCoroutine(WIGroups.SuperLoadChildItem(closestStructureReferenceSoFar.GroupPath, closestStructureReferenceSoFar.FileName, SpawnStructureLoaded, 0f));
            WIGroup lastGroupLoaded = null;

            while (mSpawnStructureWorldItem == null)
            {
                yield return(null);
            }

            //WorldItems.Get.SuspendActiveStateChecking = false;
            //okay next we have to load the structure interior
            mSpawnStructureWorldItem.ActiveStateLocked = false;
            mSpawnStructureWorldItem.ActiveState       = WIActiveState.Active;
            mSpawnStructureWorldItem.ActiveStateLocked = true;
            yield return(null);

            //now that the player is where they're supposed to be we can resume active state checking
            //but keep the structure itself locked
            //Player.Local.Position = mSpawnStructureWorldItem.Position;
            //ColoredDebug.Log ("Sending player to spawn structure position " + mSpawnStructureWorldItem.Position.ToString (), "Yellow");

            spawnStructure = mSpawnStructureWorldItem.Get <Structure> ();
            spawnStructure.LoadPriority = StructureLoadPriority.SpawnPoint;
            if (spawnStructure.Is(StructureLoadState.ExteriorUnloaded))
            {
                yield return(StartCoroutine(spawnStructure.CreateStructureGroups(StructureLoadState.ExteriorLoaded)));

                Structures.AddExteriorToLoad(spawnStructure);
                while (spawnStructure.Is(StructureLoadState.ExteriorLoading | StructureLoadState.ExteriorWaitingToLoad))
                {
                    yield return(null);
                }
            }
            if (spawnStructure.Is(StructureLoadState.ExteriorLoaded))
            {
                Structures.AddInteriorToLoad(spawnStructure);
                while (spawnStructure.Is(StructureLoadState.InteriorWaitingToLoad | StructureLoadState.InteriorLoading))
                {
                    yield return(null);
                }
                spawnStructure.RefreshColliders(true);
                spawnStructure.RefreshRenderers(true);
                //finally we search for a bed
            }
            spawnStructure.StructureGroup.Load();
            while (!spawnStructure.StructureGroup.Is(WIGroupLoadState.Loaded))
            {
                yield return(null);
            }

            yield return(null);

            //wait a tick to let the group catch up
            //wait a tick to let the group catch up
            yield return(null);

            List <WorldItem> bedWorldItems = new List <WorldItem> ();

            while (bedWorldItems.Count == 0)
            {
                yield return(StartCoroutine(WIGroups.GetAllChildrenByType(spawnStructure.StructureGroup.Props.PathName, new List <string> ()
                {
                    "Bed"
                }, bedWorldItems, spawnStructure.worlditem.Position, Mathf.Infinity, 1)));

                //can't use WaitForSeconds because timescale will be zero
                double waitUntil = WorldClock.RealTime + 0.1f;
                while (WorldClock.RealTime < waitUntil)
                {
                    yield return(null);
                }
            }

            WorldItem bedWorldItem = bedWorldItems [0];

            while (!bedWorldItem.Is(WILoadState.Initialized))
            {
                yield return(null);
            }
            loadedBed = bedWorldItem.Get <Bed> ();
            //Player.Local.Position = loadedBed.BedsidePosition;
            mSpawningPlayer = false;
            mSpawnStructureWorldItem.ActiveStateLocked = false;
            OnFinishAction(loadedBed);
            Player.Local.Surroundings.StructureEnter(spawnStructure);
            yield break;
        }