TechbloxModdingAPI/TechbloxModdingAPI/App/GameGameEngine.cs

using System.Collections.Generic;

using RobocraftX.Common;
using RobocraftX.Schedulers;
using RobocraftX.SimulationModeState;
using Svelto.ECS;
using Svelto.Tasks;
using Svelto.Tasks.Lean;
using RobocraftX.Blocks;
using RobocraftX.ScreenshotTaker;
using TechbloxModdingAPI.Blocks;
using TechbloxModdingAPI.Engines;
using TechbloxModdingAPI.Tasks;
using TechbloxModdingAPI.Utility;

namespace TechbloxModdingAPI.App
{
	public class GameGameEngine : IApiEngine
    {
		public WrappedHandler<GameEventArgs> EnterGame;

        public WrappedHandler<GameEventArgs> ExitGame;

		public string Name => "TechbloxModdingAPIGameInfoMenuEngine";

		public bool isRemovable => false;

		public EntitiesDB entitiesDB { set; private get; }

		public void Dispose()
		{
			ExitGame.Invoke(this, new GameEventArgs { GameName = GameMode.SaveGameDetails.Name, GamePath = GameMode.SaveGameDetails.Folder });
			IsInGame = false;
		}

		public void Ready()
		{
			EnteringGame().RunOn(Scheduler.leanRunner);
		}

		private IEnumerator<TaskContract> EnteringGame()
		{
			yield return new WaitForSubmissionEnumerator(GameLoadedEnginePatch.Scheduler).Continue();
			EnterGame.Invoke(this, new GameEventArgs { GameName = GameMode.SaveGameDetails.Name, GamePath = GameMode.SaveGameDetails.Folder });
			IsInGame = true;
		}

		// game functionality

		public bool IsInGame
		{
			get;
			private set;
		} = false;

		public void ExitCurrentGame(bool async = false)
		{
			if (async)
			{
				ExitCurrentGameAsync().RunOn(Lean.EveryFrameStepRunner_TimeRunningAndStopped);
			}
			else
			{
				entitiesDB.QueryEntity<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID).WantsToQuit = true;
                entitiesDB.PublishEntityChange<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID);
			}

		}

		public IEnumerator<TaskContract> ExitCurrentGameAsync()
		{
			/*
            while (Lean.EveryFrameStepRunner_RUNS_IN_TIME_STOPPED_AND_RUNNING.isStopping) { yield return Yield.It; }
            AccessTools.Method(typeof(FullGameCompositionRoot), "SwitchToMenu").Invoke(FullGameFields.Instance, new object[0]);*/
			yield return Yield.It;
			entitiesDB.QueryEntity<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID).WantsToQuit = true;
            entitiesDB.PublishEntityChange<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID);
		}

        public void SaveCurrentGame()
		{
			ref GameSceneEntityStruct gses = ref entitiesDB.QueryEntity<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID);
			gses.LoadAfterSaving = false;
			gses.SaveNow = true;
			entitiesDB.PublishEntityChange<GameSceneEntityStruct>(CommonExclusiveGroups.GameSceneEGID);
		}

        public bool IsTimeRunningMode()
		{
			return TimeRunningModeUtil.IsTimeRunningMode(entitiesDB);
		}

        public bool IsTimeStoppedMode()
		{
			return TimeRunningModeUtil.IsTimeStoppedMode(entitiesDB);
		}

        public void ToggleTimeMode()
        {
	        if (!entitiesDB.FoundInGroups<BlockTagEntityStruct>())
		        throw new AppStateException("At least one block must exist in the world to enter simulation");
			TimeRunningModeUtil.ToggleTimeRunningState(entitiesDB);
		}

        public EGID[] GetAllBlocksInGame(BlockIDs filter = BlockIDs.Invalid)
        {
	        var allBlocks = entitiesDB.QueryEntities<BlockTagEntityStruct>();
	        List<EGID> blockEGIDs = new List<EGID>();
	        foreach (var (blocks, _) in allBlocks)
	        {
		        var (buffer, count) = blocks.ToBuffer();
		        for (int i = 0; i < count; i++)
		        {
			        uint dbid;
			        if (filter == BlockIDs.Invalid)
				        dbid = (uint)filter;
			        else
				        dbid = entitiesDB.QueryEntity<DBEntityStruct>(buffer[i].ID).DBID;
			        if (dbid == (ulong)filter)
				        blockEGIDs.Add(buffer[i].ID);
		        }
	        }

	        return blockEGIDs.ToArray();
        }

        public void EnableScreenshotTaker()
		{
			ref var local = ref entitiesDB.QueryEntity<ScreenshotModeEntityStruct>(ScreenshotTakerEgids.ScreenshotTaker);
			if (local.enabled)
				return;
			local.enabled = true;
			entitiesDB.PublishEntityChange<ScreenshotModeEntityStruct>(ScreenshotTakerEgids.ScreenshotTaker);
		}
	}
}