public static SpriteRenderer SearchSprites(GameObject parent, string name, string spriteName)
{
List <Transform> output = new List <Transform>();
SearchChildren(parent.transform, name, output);
foreach (Transform t in output)
{
SpriteRenderer r = t.gameObject.GetComponent <SpriteRenderer>();
if (r == null)
{
continue;
}
if (r.sprite == null)
{
continue;
}
if (r.sprite.name == spriteName)
{
return(r);
}
}
LILogger.LogWarn("Could not find " + spriteName + " (" + name + ")");
return(null);
}
public bool Build(MapAsset asset)
{
GameObject obj = new GameObject("Custom Asset");
// Base64
string base64 = asset.type.Substring(asset.type.IndexOf(",") + 1);
byte[] data;
try
{
data = System.Convert.FromBase64String(base64);
}
catch
{
LILogger.LogError("Could not parse custom asset texture");
return(false);
}
// Texture
Texture2D tex = new Texture2D(1, 1);
ImageConversion.LoadImage(tex, data);
// Sprite Renderer
SpriteRenderer spriteRenderer = obj.AddComponent <SpriteRenderer>();
spriteRenderer.sprite = Sprite.Create(tex, new Rect(0.0f, 0.0f, tex.width, tex.height), new Vector2(0.5f, 0.5f), 100.0f);
// Polus
polus.Add(obj, asset);
return(true);
}
public bool PreBuild(MapAsset asset)
{
if (!asset.type.StartsWith("util-spawn"))
{
return(true);
}
Vector2 pos = new Vector2(asset.x, -asset.y - 25.0f);
if (asset.type == "util-spawn1")
{
polus.shipStatus.InitialSpawnCenter = pos;
}
else if (asset.type == "util-spawn2")
{
polus.shipStatus.MeetingSpawnCenter = pos;
polus.shipStatus.MeetingSpawnCenter2 = pos;
}
else
{
LILogger.LogError("Unknown Spawn Type '" + asset.type + "'");
return(false);
}
return(true);
}
public void Apply(PolusShipStatus shipStatus)
{
if (!MapHandler.Load())
{
return;
}
MapData map = MapHandler.GetMap();
PolusHandler polus = new PolusHandler(shipStatus);
AssetBuilder builder = new AssetBuilder(polus);
polus.ClearTasks();
polus.MoveToTemp();
for (int i = 0; i < map.objs.Length; i++)
{
MapAsset asset = map.objs[i];
bool success = builder.Build(asset);
if (!success)
{
LILogger.LogError("Failed to build " + asset.name);
}
else if (i % 1000 == 0)
{
LILogger.LogMsg(i + " - Objects");
}
}
polus.DeleteTemp();
LILogger.LogInfo("Applied Map Data");
}
private bool RouteBuild(MapAsset asset, bool isPost)
{
try
{
foreach (Builder builder in builders)
{
bool success = false;
if (isPost)
{
success = builder.PostBuild();
}
else
{
success = builder.PreBuild(asset);
}
if (!success)
{
return(false);
}
}
return(true);
}
catch (Exception e)
{
LILogger.LogInfo(e.Message + "\n" + e.StackTrace);
return(false);
}
}
public static bool Prefix(SystemTypes ENHDELNCBNG)
{
// Get Task
PlayerTask playerTask = null;
for (int i = 0; i < ShipStatus.Instance.SpecialTasks.Length; i++)
{
PlayerTask task = ShipStatus.Instance.SpecialTasks[i];
if (task.StartAt == ENHDELNCBNG)
{
playerTask = task;
break;
}
}
// Check
if (playerTask == null)
{
LILogger.LogError("Player has been given invalid System Task: " + ENHDELNCBNG.ToString());
return(false);
}
// Provide
PlayerControl localPlayer = PlayerControl.LocalPlayer;
PlayerTask playerTask2 = GameObject.Instantiate <PlayerTask>(playerTask, localPlayer.transform);
playerTask2.Id = 255U;
playerTask2.Owner = localPlayer;
playerTask2.Initialize();
localPlayer.myTasks.Add(playerTask2);
return(false);
}
public static bool Load()
{
if (mapLoaded)
{
return(true);
}
// Get Directory
string dllDir = System.Reflection.Assembly.GetAssembly(typeof(LevelImposter.MainHarmony)).Location;
mapDir = Path.Combine(Path.GetDirectoryName(dllDir), "map.json");
// Load File
if (!File.Exists(mapDir))
{
LILogger.LogError("Could not find map at " + mapDir);
return(false);
}
string mapJson = File.ReadAllText(mapDir);
// Deserialize
mapData = Newtonsoft.Json.JsonConvert.DeserializeObject <MapData>(mapJson);
// Return
mapLoaded = true;
LILogger.LogInfo("Found and Deserialized Map Data");
return(true);
}
public void PostBuild(PolusShipStatus shipStatus)
{
// Post Build
LILogger.LogInfo("...Wrapping Up");
builder.PostBuild();
polus.SetExile(MapHandler.mapData.exile);
LILogger.LogInfo("Finished!");
}
public static void Postfix(AmongUsClient __instance)
{
LILogger.LogInfo("Loading Ship Prefabs...");
foreach (AssetReference assetRef in __instance.ShipPrefabs)
{
assetRef.LoadAsset <GameObject>();
}
MapHandler.Load();
}
public static void Postfix(AmongUsClient __instance)
{
if (__instance.AmHost)
{
LILogger.LogInfo("Player Joined: Sending map checksum...");
var writer = __instance.StartRpcImmediately(PlayerControl.LocalPlayer.NetId, 42, SendOption.Reliable, -1);
writer.Write(MapHandler.checksum);
__instance.FinishRpcImmediately(writer);
}
}
public bool PreBuild(MapAsset asset)
{
if (asset.type != "util-room")
{
return(true);
}
// Check Collider Count
if (asset.colliders.Length <= 0)
{
LILogger.LogWarn(asset.name + " does not have any colliders!");
return(false);
}
// Object
GameObject obj = new GameObject(asset.name);
// Collider
PolygonCollider2D mainCollider = null;
foreach (MapCollider collider in asset.colliders)
{
PolygonCollider2D polyCollider = obj.AddComponent <PolygonCollider2D>();
polyCollider.isTrigger = true;
polyCollider.SetPath(0, collider.GetPoints());
mainCollider = polyCollider;
}
// Room
PlainShipRoom room = obj.AddComponent <PlainShipRoom>();
room.RoomId = (SystemTypes)roomId;
if (asset.colliders.Length > 0)
{
room.roomArea = mainCollider;
}
// Room DB
if (!db.ContainsKey(asset.id))
{
db.Add(asset.id, (SystemTypes)roomId);
}
// Text DB
TextHandler.Add((SystemTypes)roomId, asset.name);
// Polus
polus.shipStatus.AllRooms = AssetHelper.AddToArr(polus.shipStatus.AllRooms, room);
polus.shipStatus.FastRooms.Add((SystemTypes)roomId, room);
MinimapGenerator.AddRoom(asset);
polus.Add(obj, asset);
roomId++;
return(true);
}
public static T SearchComponent <T>(GameObject parent, string name)
{
GameObject obj = SearchChildren(parent, name);
if (obj != null)
{
return(obj.GetComponent <T>());
}
LILogger.LogWarn("Could not find " + name);
return(default(T));
}
public void PreBuild(PolusShipStatus shipStatus)
{
// Load Map and AssetDB
if (!AssetDB.Import())
{
return;
}
if (!MapHandler.Load())
{
return;
}
// Vars
map = MapHandler.GetMap();
polus = new PolusHandler(shipStatus);
builder = new AssetBuilder(polus);
MinimapGenerator.Reset();
// Rooms
LILogger.LogInfo("...Building Rooms");
for (int i = 0; i < map.objs.Length; i++)
{
if (map.objs[i].type != "util-room")
{
continue;
}
MapAsset asset = map.objs[i];
bool success = builder.PreBuild(asset);
if (!success)
{
LILogger.LogError("Failed to build " + asset.name);
}
}
// Objects
LILogger.LogInfo("...Building Objects");
for (int i = 0; i < map.objs.Length; i++)
{
if (map.objs[i].type == "util-room")
{
continue;
}
MapAsset asset = map.objs[i];
bool success = builder.PreBuild(asset);
if (!success)
{
LILogger.LogError("Failed to build " + asset.name);
}
else if (i % 100 == 0 && i != 0)
{
LILogger.LogInfo("..." + i + " Objects Built");
}
}
}
public static T SearchList <T>(UnhollowerBaseLib.Il2CppReferenceArray <T> list, string name) where T : MonoBehaviour
{
IEnumerable <T> elem = list.Where(t => t.name == name);
if (elem.Count() > 0)
{
return(elem.First());
}
LILogger.LogWarn("Could not find " + name);
return(null);
}
public static bool Load()
{
if (mapLoaded)
{
return(true);
}
LILogger.LogInfo("...Deserializing Map Data");
// Get Directory
string dllDir = System.Reflection.Assembly.GetAssembly(typeof(LevelImposter.MainHarmony)).Location;
mapDir = Path.Combine(Path.GetDirectoryName(dllDir), "map.json");
// Load File
if (!File.Exists(mapDir))
{
LILogger.LogError("Could not find map at " + mapDir);
return(false);
}
string mapJson = File.ReadAllText(mapDir);
// Settings
var settings = new Newtonsoft.Json.JsonSerializerSettings {
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore
};
// Deserialize
try
{
mapData = Newtonsoft.Json.JsonConvert.DeserializeObject <MapData>(mapJson, settings);
}
catch (Exception e)
{
LILogger.LogError("There was an error deserializing map data:\n" + e.Message);
return(false);
}
// Checksum
int checkNum = 0;
foreach (char c in mapJson)
{
checkNum += Convert.ToByte(c);
}
checksum = checkNum.ToString("X4");
// Return
mapLoaded = true;
return(true);
}
public static GameObject SearchChildren(GameObject parent, string name)
{
List <Transform> output = new List <Transform>();
SearchChildren(parent.transform, name, output);
if (output.Count() > 0)
{
return(output[0].gameObject);
}
LILogger.LogWarn("Could not find " + name);
return(null);
}
public static void Postfix([HarmonyArgument(0)] byte callId, [HarmonyArgument(1)] MessageReader reader)
{
if (callId != 42)
{
return;
}
string checksum = reader.ReadString();
if (checksum != MapHandler.checksum)
{
LILogger.LogWarn("Received map checksum does not match! (" + checksum + " => " + MapHandler.checksum + ")");
AmongUsClient client = AmongUsClient.Instance;
client.LastDisconnectReason = DisconnectReasons.Custom;
client.LastCustomDisconnect = "Host is using a different map than client";
client.HandleDisconnect(client.LastDisconnectReason, client.LastCustomDisconnect);
}
}
public static bool Import()
{
LILogger.LogInfo("...Loading Asset Database");
var client = GameObject.Find("NetworkManager").GetComponent <AmongUsClient>();
foreach (AssetReference assetRef in client.ShipPrefabs)
{
if (assetRef.IsDone)
{
AssetDB.Import(assetRef.Asset.Cast <GameObject>());
}
else
{
LILogger.LogError("There was an error loading the Asset Database!");
return(false);
}
}
return(true);
}
public static void Init()
{
try
{
TempDB tempDB = Newtonsoft.Json.JsonConvert.DeserializeObject <TempDB>(
Encoding.UTF8.GetString(Properties.Resources.AssetDB, 0, Properties.Resources.AssetDB.Length)
);
tasks = tempDB.tasks;
utils = tempDB.utils;
sabs = tempDB.sabs;
dec = tempDB.dec;
room = tempDB.room;
}
catch
{
LILogger.LogError("Error during AssetDB JSON Deserialization");
}
}
public bool Build(MapAsset asset)
{
try
{
if (asset.spriteType == "existing")
{
if (asset.type == "util-player")
{
return(spawnBuilder.Build(asset));
}
else if (asset.type == "util-room")
{
return(true);
}
else if (asset.type.StartsWith("util-"))
{
return(utilBuilder.Build(asset));
}
else if (asset.type.StartsWith("dec-"))
{
return(decBuilder.Build(asset));
}
else if (asset.type.StartsWith("room-"))
{
return(roomBuilder.Build(asset));
}
else if (asset.type.StartsWith("task-"))
{
return(taskBuilder.Build(asset));
}
}
else if (asset.spriteType == "custom")
{
return(customBuilder.Build(asset));
}
return(false);
}
catch (Exception e)
{
LILogger.LogInfo(e.Message + "\n" + e.StackTrace);
return(false);
}
}
public static Sprite SpriteFromBase64(string b64)
{
if (string.IsNullOrEmpty(b64))
{
return(null);
}
// Base64
string base64 = b64.Substring(b64.IndexOf(",") + 1);
byte[] data;
try
{
data = System.Convert.FromBase64String(base64);
return(SpriteFromBase64(data));
}
catch
{
LILogger.LogError("Could not parse custom asset texture");
return(null);
}
}
private static void Import(GameObject map)
{
// Ship Status
ShipStatus shipStatus = map.GetComponent <ShipStatus>();
// Determine Map Type
MapType mapType = MapType.Skeld;
if (map.name == "AprilShip")
{
return;
}
if (map.name == "MiraShip")
{
mapType = MapType.Mira;
}
if (map.name == "PolusShip")
{
mapType = MapType.Polus;
}
if (map.name == "Airship")
{
mapType = MapType.Airship;
}
// Import Map to Lists
Import(map, shipStatus, mapType, tasks);
Import(map, shipStatus, mapType, utils);
Import(map, shipStatus, mapType, sabs);
Import(map, shipStatus, mapType, dec);
Import(map, shipStatus, mapType, room);
Import(map, shipStatus, mapType, ss);
LILogger.LogInfo("..." + map.name + " Loaded");
}
public bool PreBuild(MapAsset asset)
{
if (!asset.type.StartsWith("task-"))
{
return(true);
}
TaskData taskData = AssetDB.tasks[asset.type];
// Object
GameObject obj = new GameObject(asset.type);
// Sprite Renderer
SpriteRenderer spriteRenderer = obj.AddComponent <SpriteRenderer>();
spriteRenderer.sprite = taskData.SpriteRenderer.sprite;
spriteRenderer.material = taskData.SpriteRenderer.material;
obj.layer = (int)Layer.ShortObjects;
// Target Room
SystemTypes target = 0;
if (asset.targetIds.Length > 0)
{
if (asset.targetIds[0] > 0)
{
if (ShipRoomBuilder.db.ContainsKey(asset.targetIds[0]))
{
target = ShipRoomBuilder.db[asset.targetIds[0]];
}
}
}
// Divert Power
if (asset.type == "task-divert2")
{
if (divertId >= DIVERT_SYSTEMS.Length)
{
LILogger.LogError("Hit Divert Power's Max System Limit");
return(false);
}
target = DIVERT_SYSTEMS[divertId];
divertId++;
}
// Console
Console console;
Console origConsole = taskData.GameObj.GetComponent <Console>();
if (asset.type == "task-pistols1" || asset.type == "task-rifles1")
{
console = obj.AddComponent <StoreArmsTaskConsole>();
StoreArmsTaskConsole specialConsole = console.Cast <StoreArmsTaskConsole>();
StoreArmsTaskConsole origSpecialConsole = origConsole.Cast <StoreArmsTaskConsole>();
specialConsole.timesUsed = origSpecialConsole.timesUsed;
specialConsole.Images = origSpecialConsole.Images;
specialConsole.useSound = origSpecialConsole.useSound;
specialConsole.usesPerStep = origSpecialConsole.usesPerStep;
}
else if (asset.type.StartsWith("task-towels") && asset.type != "task-towels1")
{
console = obj.AddComponent <TowelTaskConsole>();
TowelTaskConsole specialConsole = console.Cast <TowelTaskConsole>();
TowelTaskConsole origSpecialConsole = origConsole.Cast <TowelTaskConsole>();
specialConsole.useSound = origSpecialConsole.useSound;
}
else
{
console = obj.AddComponent <Console>();
}
console.ConsoleId = origConsole.ConsoleId;
console.AllowImpostor = false;
console.checkWalls = false;
console.GhostsIgnored = false;
console.Image = spriteRenderer;
console.onlyFromBelow = asset.onlyFromBottom;
console.onlySameRoom = false;
console.usableDistance = 1;
console.Room = target;
console.TaskTypes = origConsole.TaskTypes;
console.ValidTasks = origConsole.ValidTasks;
// Box Collider
if (taskData.GameObj.GetComponent <CircleCollider2D>() != null)
{
CircleCollider2D origBox = taskData.GameObj.GetComponent <CircleCollider2D>();
CircleCollider2D box = obj.AddComponent <CircleCollider2D>();
box.radius = origBox.radius;
box.offset = origBox.offset;
box.isTrigger = true;
}
else if (taskData.GameObj.GetComponent <BoxCollider2D>() != null)
{
BoxCollider2D origBox = taskData.GameObj.GetComponent <BoxCollider2D>();
BoxCollider2D box = obj.AddComponent <BoxCollider2D>();
box.size = origBox.size;
box.offset = origBox.offset;
box.isTrigger = true;
}
else if (taskData.GameObj.GetComponent <PolygonCollider2D>() != null)
{
PolygonCollider2D origBox = taskData.GameObj.GetComponent <PolygonCollider2D>();
PolygonCollider2D box = obj.AddComponent <PolygonCollider2D>();
box.points = origBox.points;
box.pathCount = origBox.pathCount;
box.offset = origBox.offset;
box.isTrigger = true;
}
// Button
PassiveButton origBtn = taskData.GameObj.GetComponent <PassiveButton>();
if (origBtn != null)
{
PassiveButton btn = obj.AddComponent <PassiveButton>();
btn.ClickMask = origBtn.ClickMask;
btn.OnMouseOver = new UnityEvent();
btn.OnMouseOut = new UnityEvent();
Action action = console.Use;
btn.OnClick.AddListener(action);
}
// Medscan
if (asset.type == "task-medscan")
{
MedScannerBehaviour medscan = obj.AddComponent <MedScannerBehaviour>();
MedScannerBehaviour origscan = taskData.GameObj.GetComponent <MedScannerBehaviour>();
medscan.Offset = origscan.Offset;
polus.shipStatus.MedScanner = medscan;
}
// Multipart Tasks
if (asset.type.StartsWith("task-waterwheel"))
{
int id = int.Parse(asset.type.Substring(15));
if (1 <= id && id <= 3)
{
console.ConsoleId = id - 1;
}
}
else if (asset.type.StartsWith("task-waterjug"))
{
int id = int.Parse(asset.type.Substring(13));
if (1 <= id && id <= 2)
{
console.ValidTasks = new UnhollowerBaseLib.Il2CppReferenceArray <TaskSet>(1);
console.ValidTasks[0] = new TaskSet();
console.ValidTasks[0].taskType = TaskTypes.ReplaceWaterJug;
console.ValidTasks[0].taskStep = new IntRange(id - 1, id - 1);
}
}
else if (asset.type == "task-node")
{
if (nodeId >= 6)
{
LILogger.LogError("Hit Weather Node's Max System Limit");
return(false);
}
console.ConsoleId = nodeId;
}
else if (asset.type == "task-records2")
{
if (recordsId >= 9)
{
LILogger.LogError("Hit Records's Max System Limit");
return(false);
}
console.ConsoleId = recordsId;
recordsId++;
}
else if (asset.type == "task-toilet")
{
if (toiletId >= 4)
{
LILogger.LogError("Hit Toilet's Max System Limit");
return(false);
}
console.ConsoleId = toiletId;
toiletId++;
}
else if (asset.type == "task-breakers")
{
if (breakersId >= 7)
{
LILogger.LogError("Hit Breakers's Max System Limit");
return(false);
}
console.ConsoleId = breakersId;
breakersId++;
}
else if (asset.type.StartsWith("task-towels") && asset.type != "task-towels1")
{
if (towelsId >= 14)
{
LILogger.LogError("Hit Towels's Max System Limit");
return(false);
}
console.ConsoleId = towelsId;
towelsId++;
}
// Task
if (!string.IsNullOrEmpty(taskData.BehaviorName))
{
GameObject taskHolder = new GameObject(asset.id.ToString());
taskHolder.transform.SetParent(taskMgr.transform);
NormalPlayerTask origTask = taskData.Behavior;
NormalPlayerTask task;
if (asset.type.StartsWith("task-divert"))
{
task = taskHolder.AddComponent <DivertPowerTask>();
DivertPowerTask taskNode = task.Cast <DivertPowerTask>();
DivertPowerTask origNode = origTask.Cast <DivertPowerTask>();
taskNode.TargetSystem = target;
}
else if (asset.type == "task-node")
{
task = taskHolder.AddComponent <WeatherNodeTask>();
WeatherNodeTask taskNode = task.Cast <WeatherNodeTask>();
WeatherNodeTask origNode = origTask.Cast <WeatherNodeTask>();
taskNode.Stage2Prefab = origNode.Stage2Prefab;
taskNode.NodeId = nodeId;
nodeId++;
}
else if (asset.type.StartsWith("task-waterwheel"))
{
task = taskHolder.AddComponent <WaterWayTask>();
}
else if (asset.type == "task-towels1")
{
task = taskHolder.AddComponent <TowelTask>();
}
else
{
task = taskHolder.AddComponent <NormalPlayerTask>();
}
task.StartAt = target;
task.taskStep = origTask.taskStep;
task.MaxStep = origTask.MaxStep;
task.arrowSuspended = origTask.arrowSuspended;
task.ShowTaskTimer = origTask.ShowTaskTimer;
task.ShowTaskStep = origTask.ShowTaskStep;
task.TaskTimer = origTask.TaskTimer;
task.TimerStarted = origTask.TimerStarted;
task.TaskType = origTask.TaskType;
task.MinigamePrefab = origTask.MinigamePrefab;
task.HasLocation = origTask.HasLocation;
task.LocationDirty = origTask.LocationDirty;
if (taskData.TaskType == TaskType.Common)
{
polus.shipStatus.CommonTasks = AssetHelper.AddToArr(polus.shipStatus.CommonTasks, task);
}
if (taskData.TaskType == TaskType.Short)
{
polus.shipStatus.NormalTasks = AssetHelper.AddToArr(polus.shipStatus.NormalTasks, task);
}
if (taskData.TaskType == TaskType.Long)
{
polus.shipStatus.LongTasks = AssetHelper.AddToArr(polus.shipStatus.LongTasks, task);
}
}
// Colliders
AssetHelper.BuildColliders(asset, obj, taskData.Scale);
// Add to Polus
polus.shipStatus.AllConsoles = AssetHelper.AddToArr(polus.shipStatus.AllConsoles, console);
polus.Add(obj, asset, taskData.Scale);
return(true);
}
