TechbloxModdingAPI/GamecraftModdingAPI/Blocks/PlacementEngine.cs

using System;
using System.Reflection;
using DataLoader;
using GamecraftModdingAPI.Blocks;
using GamecraftModdingAPI.Utility;
using Harmony;
using JetBrains.Annotations;
using RobocraftX.Blocks;
using RobocraftX.Blocks.Ghost;
using RobocraftX.Blocks.Scaling;
using RobocraftX.Character;
using RobocraftX.CommandLine.Custom;
using RobocraftX.Common;
using RobocraftX.Common.Input;
using RobocraftX.Common.Utilities;
using RobocraftX.CR.MachineEditing;
using RobocraftX.StateSync;
using Svelto.ECS;
using Svelto.ECS.EntityStructs;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using uREPL;

namespace GCMC
{
    public class PlacementEngine : IApiEngine
    {
        public bool IsInGame = false;

        public void Dispose()
        {
            IsInGame = false;
        }

        public void Ready()
        {
            IsInGame = true;
        }

        public IEntitiesDB entitiesDB { get; set; }
        internal static BlockEntityFactory _blockEntityFactory; //Injected from PlaceBlockEngine

        /// <summary>
        /// Places a block at the given position
        /// </summary>
        /// <param name="block">The block's type</param>
        /// <param name="color">The block's color</param>
        /// <param name="darkness">The block color's darkness - 0 is default color</param>
        /// <param name="position">The block's position - default block size is 0.2</param>
        /// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
        /// <param name="scale">The block's non-uniform scale - less than 1 means <paramref name="uscale"/> is used</param>
        /// <param name="playerId">The player who placed the block</param>
        /// <exception cref="Exception"></exception>
        public void PlaceBlock(BlockIDs block, BlockColors color, byte darkness, float3 position, int uscale,
            float3 scale, uint playerId, quaternion rotation)
        { //It appears that only the non-uniform scale has any visible effect, but if that's not given here it will be set to the uniform one
            try
            {
                if (darkness > 9)
                    throw new Exception("That is too dark. Make sure to use 0-9 as darkness. (0 is default.)");
                BuildBlock((ushort) block, (byte) (color + darkness * 10), position, uscale, scale, rotation).Init(
                    new BlockPlacementInfoStruct()
                    {
                        loadedFromDisk = false,
                        placedBy = playerId
                    });
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Log.Error(e.Message);
            }
        }

        private EntityStructInitializer BuildBlock(ushort block, byte color, float3 position, int uscale, float3 scale, quaternion rot)
        {
            if (_blockEntityFactory == null)
                throw new Exception("The factory is null.");
            if (uscale < 1)
                throw new Exception("Scale needs to be at least 1");
            if (scale.x < 4e-5) scale.x = uscale;
            if (scale.y < 4e-5) scale.y = uscale;
            if (scale.z < 4e-5) scale.z = uscale;
            //RobocraftX.CR.MachineEditing.PlaceBlockEngine
            ScalingEntityStruct scaling = new ScalingEntityStruct {scale = scale};
            RotationEntityStruct rotation = new RotationEntityStruct {rotation = quaternion.identity};
            GridRotationStruct gridRotation = new GridRotationStruct
                {position = float3.zero, rotation = quaternion.identity};
            CubeCategoryStruct category = new CubeCategoryStruct
                {category = CubeCategory.General, type = CubeType.Block};
            uint dbid = block;
            DBEntityStruct dbEntity = new DBEntityStruct {DBID = dbid};
            uint num = PrefabsID.DBIDMAP[dbid];
            GFXPrefabEntityStructGO gfx = new GFXPrefabEntityStructGO {prefabID = num};
            BlockPlacementScaleEntityStruct placementScale = new BlockPlacementScaleEntityStruct
            {
                blockPlacementHeight = uscale, blockPlacementWidth = uscale, desiredScaleFactor = uscale,
                snapGridScale = uscale,
                unitSnapOffset = 0, isUsingUnitSize = true
            };
            EquippedColourStruct colour = new EquippedColourStruct {indexInPalette = color};
            EGID egid2;
            switch (category.category)
            {
                case CubeCategory.SpawnPoint:
                case CubeCategory.BuildingSpawnPoint:
                    egid2 = MachineEditingGroups.NewSpawnPointBlockID;
                    break;
                default:
                    egid2 = MachineEditingGroups.NewBlockID;
                    break;
            }

            int cubeId = PrefabsID.GenerateDBID((ushort) category.category, block);
            EntityStructInitializer
                structInitializer =
                    _blockEntityFactory.Build(egid2, (uint) cubeId); //The ghost block index is only used for triggers
            if (colour.indexInPalette != byte.MaxValue)
                structInitializer.Init(new ColourParameterEntityStruct
                {
                    indexInPalette = colour.indexInPalette
                });
            structInitializer.Init(new GFXPrefabEntityStructGPUI(gfx.prefabID));
            structInitializer.Init(new PhysicsPrefabEntityStruct(gfx.prefabID));
            structInitializer.Init(dbEntity);
            structInitializer.Init(new PositionEntityStruct {position = position});
            structInitializer.Init(rotation);
            structInitializer.Init(scaling);
            structInitializer.Init(gridRotation);
            structInitializer.Init(new UniformBlockScaleEntityStruct
            {
                scaleFactor = placementScale.desiredScaleFactor
            });
            return structInitializer;
        }

        public string Name { get; } = nameof(PlacementEngine);

        [HarmonyPatch]
        [UsedImplicitly]
        public class FactoryObtainerPatch
        {
            static void Postfix(BlockEntityFactory blockEntityFactory)
            {
                _blockEntityFactory = blockEntityFactory;
                Debug.Log("Block entity factory injected.");
            }

            static MethodBase TargetMethod(HarmonyInstance instance)
            {
                return typeof(PlaceBlockEngine).GetConstructors()[0];
            }
        }
    }
}