369 lines
13 KiB
C#
369 lines
13 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
|
|
using HarmonyLib;
|
|
using IllusionInjector;
|
|
// test
|
|
using Svelto.ECS;
|
|
using RobocraftX.Blocks;
|
|
using RobocraftX.Common;
|
|
using RobocraftX.SimulationModeState;
|
|
using RobocraftX.FrontEnd;
|
|
using Unity.Mathematics;
|
|
|
|
using GamecraftModdingAPI.Commands;
|
|
using GamecraftModdingAPI.Events;
|
|
using GamecraftModdingAPI.Utility;
|
|
using GamecraftModdingAPI.Blocks;
|
|
using GamecraftModdingAPI.Players;
|
|
|
|
namespace GamecraftModdingAPI.Tests
|
|
{
|
|
// unused by design
|
|
/// <summary>
|
|
/// Modding API implemented as a standalone IPA Plugin.
|
|
/// Ideally, GamecraftModdingAPI should be loaded by another mod; not itself
|
|
/// </summary>
|
|
public class GamecraftModdingAPIPluginTest
|
|
#if DEBUG
|
|
: IllusionPlugin.IEnhancedPlugin
|
|
#endif
|
|
{
|
|
|
|
private static Harmony harmony { get; set; }
|
|
|
|
public string[] Filter { get; } = new string[] { "Gamecraft", "GamecraftPreview" };
|
|
|
|
public string Name { get; } = Assembly.GetExecutingAssembly().GetName().Name;
|
|
|
|
public string Version { get; } = Assembly.GetExecutingAssembly().GetName().Version.ToString();
|
|
|
|
public string HarmonyID { get; } = "org.git.exmods.modtainers.gamecraftmoddingapi";
|
|
|
|
public void OnApplicationQuit()
|
|
{
|
|
GamecraftModdingAPI.Main.Shutdown();
|
|
}
|
|
|
|
public void OnApplicationStart()
|
|
{
|
|
FileLog.Reset();
|
|
Harmony.DEBUG = true;
|
|
GamecraftModdingAPI.Main.Init();
|
|
Logging.MetaDebugLog($"Version group id {(uint)ApiExclusiveGroups.versionGroup}");
|
|
// in case Steam is not installed/running
|
|
// this will crash the game slightly later during startup
|
|
//SteamInitPatch.ForcePassSteamCheck = true;
|
|
// in case running in a VM
|
|
//MinimumSpecsCheckPatch.ForcePassMinimumSpecCheck = true;
|
|
// disable some Gamecraft analytics
|
|
//AnalyticsDisablerPatch.DisableAnalytics = true;
|
|
// disable background music
|
|
Logging.MetaDebugLog("Audio Mixers: " + string.Join(",", AudioTools.GetMixers()));
|
|
//AudioTools.SetVolume(0.0f, "Music"); // The game now sets this from settings again after this is called :(
|
|
|
|
//Utility.VersionTracking.Enable();//(very) unstable
|
|
|
|
// debug/test handlers
|
|
HandlerBuilder.Builder()
|
|
.Name("appinit API debug")
|
|
.Handle(EventType.ApplicationInitialized)
|
|
.OnActivation(() => { Logging.Log("App Inited event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("menuact API debug")
|
|
.Handle(EventType.Menu)
|
|
.OnActivation(() => { Logging.Log("Menu Activated event!"); })
|
|
.OnDestruction(() => { Logging.Log("Menu Destroyed event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("menuswitch API debug")
|
|
.Handle(EventType.MenuSwitchedTo)
|
|
.OnActivation(() => { Logging.Log("Menu Switched To event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("gameact API debug")
|
|
.Handle(EventType.Menu)
|
|
.OnActivation(() => { Logging.Log("Game Activated event!"); })
|
|
.OnDestruction(() => { Logging.Log("Game Destroyed event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("gamerel API debug")
|
|
.Handle(EventType.GameReloaded)
|
|
.OnActivation(() => { Logging.Log("Game Reloaded event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("gameswitch API debug")
|
|
.Handle(EventType.GameSwitchedTo)
|
|
.OnActivation(() => { Logging.Log("Game Switched To event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("simulationswitch API debug")
|
|
.Handle(EventType.SimulationSwitchedTo)
|
|
.OnActivation(() => { Logging.Log("Game Mode Simulation Switched To event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("buildswitch API debug")
|
|
.Handle(EventType.BuildSwitchedTo)
|
|
.OnActivation(() => { Logging.Log("Game Mode Build Switched To event!"); })
|
|
.Build();
|
|
|
|
HandlerBuilder.Builder("menu activated API error thrower test")
|
|
.Handle(EventType.Menu)
|
|
.OnActivation(() => { throw new Exception("Event Handler always throws an exception!"); })
|
|
.Build();
|
|
|
|
/*HandlerBuilder.Builder("enter game from menu test")
|
|
.Handle(EventType.Menu)
|
|
.OnActivation(() =>
|
|
{
|
|
Tasks.Scheduler.Schedule(new Tasks.Repeatable(enterGame, shouldRetry, 0.2f));
|
|
})
|
|
.Build();*/
|
|
|
|
// debug/test commands
|
|
if (Dependency.Hell("ExtraCommands"))
|
|
{
|
|
CommandBuilder.Builder()
|
|
.Name("Exit")
|
|
.Description("Close Gamecraft immediately, without any prompts")
|
|
.Action(() => { UnityEngine.Application.Quit(); })
|
|
.Build();
|
|
|
|
CommandBuilder.Builder()
|
|
.Name("SetFOV")
|
|
.Description("Set the player camera's field of view")
|
|
.Action((float d) => { UnityEngine.Camera.main.fieldOfView = d; })
|
|
.Build();
|
|
|
|
CommandBuilder.Builder()
|
|
.Name("MoveLastBlock")
|
|
.Description("Move the most-recently-placed block, and any connected blocks by the given offset")
|
|
.Action((float x, float y, float z) =>
|
|
{
|
|
if (GameState.IsBuildMode())
|
|
foreach (var block in Block.GetLastPlacedBlock().GetConnectedCubes())
|
|
block.Position += new Unity.Mathematics.float3(x, y, z);
|
|
else
|
|
GamecraftModdingAPI.Utility.Logging.CommandLogError("Blocks can only be moved in Build mode!");
|
|
}).Build();
|
|
|
|
CommandBuilder.Builder()
|
|
.Name("PlaceAluminium")
|
|
.Description("Place a block of aluminium at the given coordinates")
|
|
.Action((float x, float y, float z) =>
|
|
{
|
|
var block = Block.PlaceNew(BlockIDs.AluminiumCube, new float3(x, y, z));
|
|
Logging.CommandLog("Block placed with type: " + block.Type);
|
|
})
|
|
.Build();
|
|
|
|
CommandBuilder.Builder()
|
|
.Name("PlaceAluminiumLots")
|
|
.Description("Place a lot of blocks of aluminium at the given coordinates")
|
|
.Action((float x, float y, float z) =>
|
|
{
|
|
Logging.CommandLog("Starting...");
|
|
var sw = Stopwatch.StartNew();
|
|
for (int i = 0; i < 100; i++)
|
|
for (int j = 0; j < 100; j++)
|
|
Block.PlaceNew(BlockIDs.AluminiumCube, new float3(x + i, y, z + j));
|
|
//Block.Sync();
|
|
sw.Stop();
|
|
Logging.CommandLog("Finished in " + sw.ElapsedMilliseconds + "ms");
|
|
})
|
|
.Build();
|
|
//With Sync(): 1135ms
|
|
//Without Sync(): 134ms
|
|
//Async: 348 794ms, doesn't freeze game
|
|
//Without Sync() but wait for submission: 530ms
|
|
//With Sync() at the end: 380ms
|
|
|
|
Block b = null;
|
|
CommandBuilder.Builder("moveBlockInSim", "Run in build mode first while looking at a block, then in sim to move it up")
|
|
.Action(() =>
|
|
{
|
|
if (b == null)
|
|
{
|
|
b = new Player(PlayerType.Local).GetBlockLookedAt();
|
|
Logging.CommandLog("Block saved: " + b);
|
|
}
|
|
else
|
|
Logging.CommandLog("Block moved to: " + (b.GetSimBody().Position += new float3(0, 2, 0)));
|
|
}).Build();
|
|
|
|
CommandBuilder.Builder("Error", "Throw an error to make sure SimpleCustomCommandEngine's wrapper catches it.")
|
|
.Action(() => { throw new Exception("Error Command always throws an error"); })
|
|
.Build();
|
|
|
|
CommandBuilder.Builder("ColorBlock",
|
|
"Change color of the block looked at if there's any.")
|
|
.Action<string>(str =>
|
|
{
|
|
if (!Enum.TryParse(str, out BlockColors color))
|
|
{
|
|
Logging.CommandLog("Color " + str + " not found! Interpreting as 4 color values.");
|
|
var s = str.Split(' ');
|
|
new Player(PlayerType.Local).GetBlockLookedAt().CustomColor = new float4(float.Parse(s[0]),
|
|
float.Parse(s[1]), float.Parse(s[2]), float.Parse(s[3]));
|
|
return;
|
|
}
|
|
new Player(PlayerType.Local).GetBlockLookedAt().Color =
|
|
new BlockColor { Color = color };
|
|
Logging.CommandLog("Colored block to " + color);
|
|
|
|
}).Build();
|
|
|
|
CommandBuilder.Builder("GetBlockByID", "Gets a block based on its object identifier and teleports it up.")
|
|
.Action<char>(ch =>
|
|
{
|
|
foreach (var body in SimBody.GetFromObjectID(ch))
|
|
{
|
|
Logging.CommandLog("SimBody: " + body);
|
|
body.Position += new float3(0, 10, 0);
|
|
foreach (var bodyConnectedBody in body.GetConnectedBodies())
|
|
{
|
|
Logging.CommandLog("Moving " + bodyConnectedBody);
|
|
bodyConnectedBody.Position += new float3(0, 10, 0);
|
|
}
|
|
}
|
|
}).Build();
|
|
|
|
GameClient.SetDebugInfo("InstalledMods", InstalledMods);
|
|
Block.Placed += (sender, args) =>
|
|
Logging.MetaDebugLog("Placed block " + args.Type + " with ID " + args.ID);
|
|
Block.Removed += (sender, args) =>
|
|
Logging.MetaDebugLog("Removed block " + args.Type + " with ID " + args.ID);
|
|
|
|
/*
|
|
CommandManager.AddCommand(new SimpleCustomCommandEngine<float>((float d) => { UnityEngine.Camera.main.fieldOfView = d; },
|
|
"SetFOV", "Set the player camera's field of view"));
|
|
CommandManager.AddCommand(new SimpleCustomCommandEngine<float, float, float>(
|
|
(x, y, z) => {
|
|
bool success = GamecraftModdingAPI.Blocks.Movement.MoveConnectedBlocks(
|
|
GamecraftModdingAPI.Blocks.BlockIdentifiers.LatestBlockID,
|
|
new Unity.Mathematics.float3(x, y, z));
|
|
if (!success)
|
|
{
|
|
GamecraftModdingAPI.Utility.Logging.CommandLogError("Blocks can only be moved in Build mode!");
|
|
}
|
|
}, "MoveLastBlock", "Move the most-recently-placed block, and any connected blocks by the given offset"));
|
|
CommandManager.AddCommand(new SimpleCustomCommandEngine<float, float, float>(
|
|
(x, y, z) => { Blocks.Placement.PlaceBlock(Blocks.BlockIDs.AluminiumCube, new Unity.Mathematics.float3(x, y, z)); },
|
|
"PlaceAluminium", "Place a block of aluminium at the given coordinates"));
|
|
System.Random random = new System.Random(); // for command below
|
|
CommandManager.AddCommand(new SimpleCustomCommandEngine(
|
|
() => {
|
|
if (!GameState.IsSimulationMode())
|
|
{
|
|
Logging.CommandLogError("You must be in simulation mode for this to work!");
|
|
return;
|
|
}
|
|
Tasks.Repeatable task = new Tasks.Repeatable(() => {
|
|
uint count = 0;
|
|
EGID[] eBlocks = Blocks.Signals.GetElectricBlocks();
|
|
for (uint i = 0u; i < eBlocks.Length; i++)
|
|
{
|
|
uint[] ids = Blocks.Signals.GetSignalIDs(eBlocks[i]);
|
|
for (uint j = 0u; j < ids.Length; j++)
|
|
{
|
|
Blocks.Signals.SetSignalByID(ids[j], (float)random.NextDouble());
|
|
count++;
|
|
}
|
|
}
|
|
Logging.MetaDebugLog($"Did the thing on {count} inputs");
|
|
},
|
|
() => { return GameState.IsSimulationMode(); });
|
|
Tasks.Scheduler.Schedule(task);
|
|
}, "RandomizeSignalsInputs", "Do the thing"));
|
|
*/
|
|
}
|
|
|
|
// dependency test
|
|
if (Dependency.Hell("GamecraftScripting", new Version("0.0.1.0")))
|
|
{
|
|
Logging.LogWarning("You're in GamecraftScripting dependency hell");
|
|
}
|
|
else
|
|
{
|
|
Logging.Log("Compatible GamecraftScripting detected");
|
|
}
|
|
|
|
#if TEST
|
|
TestRoot.RunTests();
|
|
#endif
|
|
}
|
|
|
|
private string modsString;
|
|
private string InstalledMods()
|
|
{
|
|
if (modsString != null) return modsString;
|
|
StringBuilder sb = new StringBuilder("Installed mods:");
|
|
foreach (var plugin in PluginManager.Plugins)
|
|
sb.Append("\n" + plugin.Name + " - " + plugin.Version);
|
|
return modsString = sb.ToString();
|
|
}
|
|
|
|
private bool retry = true;
|
|
|
|
private bool shouldRetry()
|
|
{
|
|
return retry;
|
|
}
|
|
|
|
private void enterGame()
|
|
{
|
|
App.Client app = new App.Client();
|
|
App.Game[] myGames = app.MyGames;
|
|
Logging.MetaDebugLog($"MyGames count {myGames.Length}");
|
|
if (myGames.Length != 0)
|
|
{
|
|
Logging.MetaDebugLog($"MyGames[0] EGID {myGames[0].EGID}");
|
|
retry = false;
|
|
try
|
|
{
|
|
//myGames[0].Description = "test msg pls ignore"; // make sure game exists first
|
|
Logging.MetaDebugLog($"Entering game {myGames[0].Name}");
|
|
myGames[0].EnterGame();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.MetaDebugLog($"Failed to enter game; exception: {e}");
|
|
retry = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Logging.MetaDebugLog("MyGames not populated yet :(");
|
|
}
|
|
}
|
|
|
|
public void OnFixedUpdate() { }
|
|
|
|
public void OnLateUpdate() { }
|
|
|
|
public void OnLevelWasInitialized(int level) { }
|
|
|
|
public void OnLevelWasLoaded(int level) { }
|
|
|
|
public void OnUpdate() { }
|
|
|
|
[HarmonyPatch]
|
|
public class MinimumSpecsPatch
|
|
{
|
|
public static bool Prefix()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public static MethodInfo TargetMethod()
|
|
{
|
|
return ((Action) MinimumSpecsCheck.CheckRequirementsMet).Method;
|
|
}
|
|
}
|
|
}
|
|
}
|