NGnius
/
Pixi
generated from modtainers/HelloModdingWorld
Watch 2
Star 1
Fork 1
Code Issues 4 Pull Requests 0 Releases 8 Wiki Activity
Magically import images and more into Gamecraft as blocks
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.
20 Commits
4 Branches
2.0MB
Tree: cdd474e1ec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cdd474e1ec'
${ noResults }
Pixi/Pixi/Robots/CubeUtility.cs

485 lines
17KB
Raw Blame History 

  1. using System;

  2. using System.Collections.Generic;

  3. using System.IO;

  4. using System.Reflection;

  5. using System.Runtime.CompilerServices;

  6. 

  7. using RobocraftX.Common;

  8. using Newtonsoft.Json;

  9. using Unity.Mathematics;

  10. using UnityEngine;

  11. 

  12. using GamecraftModdingAPI.Blocks;

  13. using GamecraftModdingAPI.Utility;

  14. using GamecraftModdingAPI;

  15. 

  16. using Pixi.Common;

  17. 

  18. namespace Pixi.Robots

  19. {

  20.     public static class CubeUtility

  21.     {

  22. 		private static Dictionary<uint, string> map = null;

  23. 

  24. 		private static Dictionary<uint, BlockJsonInfo[]> blueprintMap = null;

  25. 

  26. 		public static RobotStruct? ParseRobotInfo(string robotInfo)

  27. 		{

  28. 			try

  29. 			{

  30. 				return JsonConvert.DeserializeObject<RobotStruct>(robotInfo);

  31. 			}

  32. 			catch (Exception e)

  33. 			{

  34. 				Logging.MetaLog(e);

  35. 				return null;

  36. 			}

  37. 		}

  38. 

  39. 		public static CubeInfo[] ParseCubes(RobotStruct robot)

  40. 		{

  41. 			return ParseCubes(robot.cubeData, robot.colourData);

  42. 		}

  43. 

  44. 		public static CubeInfo[] ParseCubes(string cubeData, string colourData)

  45. 		{

  46. 			BinaryBufferReader cubes = new BinaryBufferReader(Convert.FromBase64String(cubeData), 0);

  47. 			BinaryBufferReader colours = new BinaryBufferReader(Convert.FromBase64String(colourData), 0);

  48. 			uint cubeCount = cubes.ReadUint();

  49. 			uint colourCount = colours.ReadUint();

  50. 			if (cubeCount != colourCount)

  51. 			{

  52. 				Logging.MetaLog("Something is fucking broken");

  53. 				return null;

  54. 			}

  55. 			Logging.MetaLog($"Detected {cubeCount} cubes");

  56. 			CubeInfo[] result = new CubeInfo[cubeCount];

  57. 			for (int cube = 0; cube < cubeCount; cube++)

  58. 			{

  59. 				result[cube] = TranslateSpacialEnumerations(

  60. 					cubes.ReadUint(),

  61. 					cubes.ReadByte(),

  62. 					cubes.ReadByte(),

  63. 					cubes.ReadByte(),

  64. 					cubes.ReadByte(),

  65. 					colours.ReadByte(),

  66. 					colours.ReadByte(),

  67. 					colours.ReadByte(),

  68. 					colours.ReadByte()

  69. 				);

  70. 			}

  71. 			return result;

  72. 		}

  73. 

  74. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  75. 		public static CubeInfo TranslateSpacialEnumerations(uint cubeId, byte x, byte y, byte z, byte rotation, byte colour, byte colour_x, byte colour_y, byte colour_z)

  76. 		{

  77. 			if (x != colour_x || z != colour_z || y != colour_y) return default;

  78. 			CubeInfo result = new CubeInfo { visible = true, cubeId = cubeId };

  79. 			TranslateBlockColour(colour, ref result);

  80. 			TranslateBlockPosition(x, y, z, ref result);

  81. 			TranslateBlockRotation(rotation, ref result);

  82. 			TranslateBlockId(cubeId, ref result);

  83. #if DEBUG

  84. 			Logging.MetaLog($"Cube {cubeId} ({x}, {y}, {z}) rot:{rotation} decoded as {result.block} {result.position} rot: {result.rotation} color: {result.color} {result.darkness}");

  85. #endif

  86. 			return result;

  87. 		}

  88. 

  89. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  90. 		private static void TranslateBlockRotation(byte rotation, ref CubeInfo result)

  91. 		{

  92.             // face refers to the face of the block connected to the bottom of the current one

  93.             // nvm, they're all incorrect

  94. 			switch (rotation)

  95. 			{

  96. 				case 0:

  97. 					result.rotation = new float3(0, 0, 0); // top face, forwards

  98. 					break;

  99. 				case 1:

  100. 					result.rotation = new float3(0, 0, 90); // left face, forwards

  101. 					break;

  102. 				case 2:

  103.                     result.rotation = new float3(0, 0, 180); // bottom face, forwards

  104.                     break;

  105. 				case 3:

  106.                     result.rotation = new float3(0, 0, -90); // front face, down

  107.                     break;

  108. 				case 4:

  109.                     result.rotation = new float3(0, 90, 0); // top face, right

  110.                     break;

  111. 				case 5:

  112.                     result.rotation = new float3(0, 90, 90); // front face, right

  113.                     break;

  114. 				case 6:

  115.                     result.rotation = new float3(-90, -90, 0); // right face, backwards

  116.                     break;

  117. 				case 7:

  118.                     result.rotation = new float3(0, 90, -90); // back face, right

  119.                     break;

  120. 				case 8:

  121.                     result.rotation = new float3(0, -90, 90); // back face, left

  122.                     break;

  123. 				case 9:

  124.                     result.rotation = new float3(0, -90, -90); // front face, left

  125.                     break;

  126. 				case 10:

  127.                     result.rotation = new float3(90, -90, 0); // left face, down

  128.                     break;

  129. 				case 11:

  130.                     result.rotation = new float3(90, 90, 0); // right face, forwards

  131.                     break;

  132. 				case 12:

  133.                     result.rotation = new float3(-90, 90, 0); // left face, up

  134.                     break;

  135. 				case 13:

  136.                     result.rotation = new float3(0, 90, 180); // bottom face, right

  137.                     break;

  138. 				case 14:

  139.                     result.rotation = new float3(0, 180, 0); // top face, backwards

  140.                     break;

  141. 				case 15:

  142.                     result.rotation = new float3(0, 180, 90); // right face, up

  143.                     break;

  144. 				case 16:

  145.                     result.rotation = new float3(0, 180, 180); // bottom face, backwards

  146.                     break;

  147. 				case 17:

  148.                     result.rotation = new float3(0, 180, -90); // left face, backwards

  149.                     break;

  150. 				case 18:

  151.                     result.rotation = new float3(0, -90, 0); // top face, left

  152.                     break;

  153. 				case 19:

  154.                     result.rotation = new float3(0, -90, 180); // bottom face, left

  155.                     break;

  156. 				case 20:

  157.                     result.rotation = new float3(90, 0, 0); // front face, down

  158.                     break;

  159. 				case 21:

  160.                     result.rotation = new float3(90, 180, 0); // back face, down

  161.                     break;

  162. 				case 22:

  163.                     result.rotation = new float3(-90, 0, 0); // back face, up

  164.                     break;

  165. 				case 23:

  166.                     result.rotation = new float3(-90, 180, 0); // front face, up

  167.                     break;

  168. 				default:

  169. #if DEBUG

  170. 					Logging.MetaLog($"Unknown rotation {rotation.ToString("X2")}");

  171. #endif

  172. 					result.rotation = float3.zero;

  173. 					break;

  174. 			}

  175.             // my brain hurts after figuring out all of those rotations

  176.             // I wouldn't recommend trying to redo this

  177. 		}

  178. 

  179. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  180. 		private static void TranslateBlockPosition(byte x, byte y, byte z, ref CubeInfo result)

  181. 		{

  182. 			// for some reason, z is forwards in garage bays

  183. 			result.position = new float3(x, y, z);

  184. 		}

  185. 

  186. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  187. 		private static void TranslateBlockColour(byte colour, ref CubeInfo result)

  188. 		{

  189.             // I hope these colours are accurate, I just guessed

  190.             // TODO colour accuracy (lol that won't ever happen)

  191. 			switch (colour)

  192. 			{

  193. 				case 0:

  194. 					result.color = BlockColors.White;

  195. 					result.darkness = 0;

  196. 					break;

  197. 				case 1:

  198. 					result.color = BlockColors.White;

  199. 					result.darkness = 5;

  200. 					break;

  201. 				case 2:

  202. 					result.color = BlockColors.Orange;

  203.                     result.darkness = 0;

  204. 					break;

  205.                 case 3:

  206. 					result.color = BlockColors.Blue;

  207.                     result.darkness = 2;

  208. 					break;

  209. 				case 4:

  210.                     result.color = BlockColors.White;

  211.                     result.darkness = 8;

  212. 					break;

  213.                 case 5:

  214. 					result.color = BlockColors.Red;

  215.                     result.darkness = 0;

  216. 					break;

  217.                 case 6:

  218. 					result.color = BlockColors.Yellow;

  219.                     result.darkness = 0;

  220. 					break;

  221.                 case 7:

  222. 					result.color = BlockColors.Green;

  223.                     result.darkness = 0;

  224. 					break;

  225. 				case 8:

  226. 					result.color = BlockColors.Purple;

  227.                     result.darkness = 0;

  228. 					break;

  229.                 case 9:

  230.                     result.color = BlockColors.Blue;

  231.                     result.darkness = 7;

  232. 					break;

  233.                 case 10:

  234.                     result.color = BlockColors.Purple;

  235.                     result.darkness = 5;

  236. 					break;

  237.                 case 11:

  238.                     result.color = BlockColors.Orange;

  239.                     result.darkness = 7;

  240. 					break;

  241. 				case 12:

  242. 					result.color = BlockColors.Green;

  243.                     result.darkness = 3;

  244. 					break;

  245.                 case 13:

  246. 					result.color = BlockColors.Green;

  247.                     result.darkness = 2;

  248. 					break;

  249.                 case 14:

  250. 					result.color = BlockColors.Pink;

  251.                     result.darkness = 3;

  252. 					break;

  253.                 case 15:

  254.                     result.color = BlockColors.Pink;

  255.                     result.darkness = 2;

  256. 					break;

  257. 				case 16:

  258.                     result.color = BlockColors.Red;

  259.                     result.darkness = 2;

  260. 					break;

  261.                 case 17:

  262.                     result.color = BlockColors.Orange;

  263.                     result.darkness = 8;

  264. 					break;

  265.                 case 18:

  266.                     result.color = BlockColors.Red;

  267.                     result.darkness = 7;

  268. 					break;

  269.                 case 19:

  270.                     result.color = BlockColors.Pink;

  271.                     result.darkness = 0;

  272. 					break;

  273. 				case 20:

  274. 					result.color = BlockColors.Yellow;

  275.                     result.darkness = 2;

  276. 					break;

  277.                 case 21:

  278. 					result.color = BlockColors.Green;

  279.                     result.darkness = 7;

  280. 					break;

  281.                 case 22:

  282. 					result.color = BlockColors.Green;

  283.                     result.darkness = 8;

  284. 					break;

  285.                 case 23:

  286.                     result.color = BlockColors.Blue;

  287.                     result.darkness = 8;

  288. 					break;

  289. 				case 24:

  290. 					result.color = BlockColors.Aqua;

  291.                     result.darkness = 7;

  292. 					break;

  293.                 case 25:

  294. 					result.color = BlockColors.Blue;

  295.                     result.darkness = 6;

  296. 					break;

  297.                 case 26:

  298. 					result.color = BlockColors.Aqua;

  299.                     result.darkness = 5;

  300. 					break;

  301.                 case 27:

  302.                     result.color = BlockColors.Blue;

  303.                     result.darkness = 4;

  304. 					break;

  305. 				case 28:

  306. 					result.color = BlockColors.Aqua;

  307.                     result.darkness = 3;

  308. 					break;

  309.                 case 29:

  310. 					result.color = BlockColors.Blue;

  311.                     result.darkness = 5;

  312. 					break;

  313.                 case 30:

  314. 					result.color = BlockColors.Purple;

  315.                     result.darkness = 3;

  316. 					break;

  317.                 case 31:

  318. 					result.color = BlockColors.Purple;

  319.                     result.darkness = 1;

  320. 					break;

  321. 				default:

  322. 					result.color = BlockColors.Aqua;

  323. 					result.darkness = 0;

  324. 					break;

  325. 			}

  326. 		}

  327. 

  328. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  329. 		private static void TranslateBlockId(uint cubeId, ref CubeInfo result)

  330. 		{

  331.             if (map == null)

  332. 			{

  333. 				StreamReader cubemap = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("Pixi.cubes-id.json"));

  334.                 map = JsonConvert.DeserializeObject<Dictionary<uint, string>>(cubemap.ReadToEnd());

  335. 			}

  336. 

  337. 			if (!map.ContainsKey(cubeId))

  338. 			{

  339. 				result.block = BlockIDs.TextBlock;

  340. 				result.name = "Unknown cube #" + cubeId.ToString();

  341. 				//result.rotation = float3.zero;

  342. #if DEBUG

  343. 				Logging.MetaLog($"Unknown cubeId {cubeId}");

  344. #endif

  345. 			}

  346. 			string cubeName = map[cubeId];

  347. 			if (cubeName.Contains("cube"))

  348. 			{

  349. 				result.block = BlockIDs.AluminiumCube;

  350.                 result.rotation = float3.zero;

  351. 			}

  352. 			else if (cubeName.Contains("prism") || cubeName.Contains("edge"))

  353. 			{

  354. 				if (cubeName.Contains("round"))

  355. 				{

  356. 					if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  357.                     {

  358.                         result.block = BlockIDs.GlassRoundedSlope;

  359.                     } else

  360. 					    result.block = BlockIDs.AluminiumRoundedSlope;

  361. 				}

  362. 				else

  363. 				{

  364.                     if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  365.                     {

  366. 						result.block = BlockIDs.GlassSlope;

  367.                     } else

  368. 					    result.block = BlockIDs.AluminiumSlope;

  369. 				}

  370. 			}

  371. 			else if (cubeName.Contains("inner"))

  372.             {

  373.                 if (cubeName.Contains("round"))

  374.                 {

  375. 					if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  376. 					{

  377. 						result.block = BlockIDs.GlassRoundedSlicedCube;

  378. 					} else

  379. 					    result.block = BlockIDs.AluminiumRoundedSlicedCube;

  380.                 }

  381. 				else

  382. 				{

  383.                     if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  384.                     {

  385.                         result.block = BlockIDs.GlassSlicedCube;

  386.                     } else

  387. 					    result.block = BlockIDs.AluminiumSlicedCube;

  388. 				}

  389. 			}

  390. 			else if (cubeName.Contains("tetra") || cubeName.Contains("corner"))

  391.             {

  392.                 if (cubeName.Contains("round"))

  393.                 {

  394.                     if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  395.                     {

  396. 						result.block = BlockIDs.GlassRoundedCorner;

  397.                     } else

  398.                         result.block = BlockIDs.AluminiumRoundedCorner;

  399.                 }

  400. 				else

  401. 				{

  402.                     if (cubeName.Contains("glass") || cubeName.Contains("windshield"))

  403.                     {

  404.                         result.block = BlockIDs.GlassCorner;

  405.                     } else

  406. 					    result.block = BlockIDs.AluminiumCorner;

  407. 				}

  408. 			}

  409. 			else if (cubeName.Contains("pyramid"))

  410. 			{

  411. 				result.block = BlockIDs.AluminiumPyramidSegment;

  412. 			}

  413. 			else if (cubeName.Contains("cone"))

  414. 			{

  415. 				result.block = BlockIDs.AluminiumConeSegment;

  416. 			}

  417. 			else

  418. 			{

  419. 				result.block = BlockIDs.TextBlock;

  420. 				result.name = cubeName;

  421. 			}

  422. 		}

  423. 

  424. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  425. 		public static Block[] BuildBlueprintOrTextBlock(CubeInfo cube, float3 actualPosition, int scale = 3)

  426. 		{

  427.             // actualPosition is the middle of the cube

  428. 			if (blueprintMap == null) LoadBlueprintMap();

  429. 			if (!blueprintMap.ContainsKey(cube.cubeId) || scale != 3)

  430. 			{

  431. #if DEBUG

  432. 				Logging.LogWarning($"Missing blueprint for {cube.name} (id:{cube.cubeId}), substituting {cube.block}");

  433. #endif

  434. 				return new Block[] { Block.PlaceNew(cube.block, actualPosition, cube.rotation, cube.color, cube.darkness, scale: cube.scale) };

  435. 			}

  436. #if DEBUG

  437. 			Logging.MetaLog($"Found blueprint for {cube.name} (id:{cube.cubeId})");

  438. #endif

  439. 			Quaternion cubeQuaternion = Quaternion.Euler(cube.rotation);

  440. 			BlockJsonInfo[] blueprint = blueprintMap[cube.cubeId];

  441. 			float3 correctionVec = new float3((float)(0), (float)(RobotCommands.blockSize), (float)(0));

  442. 			Block[] placedBlocks = new Block[blueprint.Length];

  443. 			for (int i = 0; i < blueprint.Length; i++)

  444. 			{

  445. 				BlockColor blueprintBlockColor = ColorSpaceUtility.QuantizeToBlockColor(blueprint[i].color);

  446. 				BlockColors blockColor = blueprintBlockColor.Color == BlockColors.White && blueprintBlockColor.Darkness == 0 ? cube.color : blueprintBlockColor.Color;

  447. 				byte blockDarkness = blueprintBlockColor.Color == BlockColors.White && blueprintBlockColor.Darkness == 0 ? cube.darkness : blueprintBlockColor.Darkness;

  448. 				float3 bluePos = new float3(blueprint[i].position[0], blueprint[i].position[1], blueprint[i].position[2]);

  449. 				float3 blueScale = new float3(blueprint[i].scale[0], blueprint[i].scale[1], blueprint[i].scale[2]);

  450. 				float3 blueRot = new float3(blueprint[i].rotation[0], blueprint[i].rotation[1], blueprint[i].rotation[2]);

  451. 				float3 physicalLocation = (float3)(cubeQuaternion * bluePos) + actualPosition;// + (blueprintSizeRotated / 2);

  452. 				//physicalLocation.x += blueprintSize.x / 2;

  453. 				physicalLocation -= (float3)(cubeQuaternion * correctionVec);

  454. 				//physicalLocation.y -= (float)(RobotCommands.blockSize * scale / 2);

  455. 				//float3 physicalScale = (float3)(cubeQuaternion * blueScale); // this actually over-rotates when combined with rotation

  456. 				float3 physicalScale = blueScale;

  457. 				float3 physicalRotation = (cubeQuaternion * Quaternion.Euler(blueRot)).eulerAngles;

  458. #if DEBUG

  459. 				Logging.MetaLog($"Placing blueprint block at {physicalLocation} rot{physicalRotation} scale{physicalScale}");

  460. 				Logging.MetaLog($"Location math check original:{bluePos} rotated: {(float3)(cubeQuaternion * bluePos)} actualPos: {actualPosition} result: {physicalLocation}");

  461. 				Logging.MetaLog($"Scale math check original:{blueScale} rotation: {(float3)cubeQuaternion.eulerAngles} result: {physicalScale}");

  462. 				Logging.MetaLog($"Rotation math check original:{blueRot} rotated: {(cubeQuaternion * Quaternion.Euler(blueRot))} result: {physicalRotation}");

  463. #endif

  464. 				placedBlocks[i] = Block.PlaceNew(VoxelObjectNotationUtility.NameToEnum(blueprint[i].name),

  465. 				                                 physicalLocation,

  466. 				                                 physicalRotation,

  467. 				                                 blockColor,

  468. 				                                 blockDarkness,

  469. 				                                 scale: physicalScale);

  470. 			}

  471. #if DEBUG

  472. 			Logging.MetaLog($"Placed {placedBlocks.Length} blocks for blueprint {cube.name} (id:{cube.cubeId})");

  473. #endif

  474. 			return placedBlocks;

  475. 		}

  476. 

  477. 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

  478.         private static void LoadBlueprintMap()

  479. 		{

  480. 			StreamReader bluemap = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("Pixi.blueprints.json"));

  481. 			blueprintMap = JsonConvert.DeserializeObject<Dictionary<uint, BlockJsonInfo[]>>(bluemap.ReadToEnd());

  482. 		}

  483. 	}

  484. }