// Token: 0x0600007E RID: 126 RVA: 0x00005F3C File Offset: 0x0000413C
private static void BreakdownComponentsInternal(this GameObject obj, int lvl = 0)
{
string text = "";
for (int i = 0; i < lvl; i++)
{
text += "\t";
}
Tools.Log <string>(text + obj.name + "...");
foreach (Component component in obj.GetComponents <Component>())
{
string str = text;
string str2 = " -";
Type type = component.GetType();
Tools.Log <string>(str + str2 + ((type != null) ? type.ToString() : null));
}
foreach (Transform transform in obj.GetComponentsInChildren <Transform>())
{
bool flag = transform != obj.transform;
if (flag)
{
transform.gameObject.BreakdownComponentsInternal(lvl + 1);
}
}
}
public static GenericRoomTable GetSpecialRoomTable()
{
foreach (var entry in GameManager.Instance.GlobalInjectionData.entries)
{
if (entry.injectionData?.InjectionData != null)
{
foreach (var data in entry.injectionData.InjectionData)
{
if (data.exactRoom != null)
{
Tools.Log(data.exactRoom.name);
if (data.prerequisites != null)
{
foreach (var p in data.prerequisites)
{
Tools.Log("\t" + p.prerequisiteType);
}
}
if (data.placementRules != null)
{
foreach (var p in data.placementRules)
{
Tools.Log("\t" + p);
}
}
}
}
}
}
return(null);
}
public static GameObject GetClosestShrineObject()
{
Tools.Log("a");
var player = GameManager.Instance.PrimaryPlayer;
Tools.Log("b");
var talkers = GameObject.FindObjectsOfType <AdvancedShrineController>();
Tools.Log("c");
float dist = float.MaxValue, d;
AdvancedShrineController closest = null;
foreach (var talker in talkers)
{
Tools.Log("d");
try
{
d = Vector2.Distance(talker.sprite.WorldCenter, player.sprite.WorldCenter);
if (talker && d < dist)
{
closest = talker;
dist = d;
}
}
catch { }
}
Tools.Log("e");
Tools.Log(closest);
return(closest.gameObject);
}
public static GameObject GetClosestCustomShrineObject()
{
Tools.Log("a");
var player = GameManager.Instance.PrimaryPlayer;
Tools.Log("b");
var shrines = GameObject.FindObjectsOfType <ShrineFactory.CustomShrineController>();
Tools.Log("c");
float dist = float.MaxValue, d;
ShrineFactory.CustomShrineController closest = null;
foreach (var shrine in shrines)
{
Tools.Log("d");
try
{
d = Vector2.Distance(shrine.sprite.WorldCenter, player.sprite.WorldCenter);
if (shrine && d < dist)
{
closest = shrine;
dist = d;
}
}
catch { }
}
Tools.Log("e");
Tools.Log(closest);
return(closest.gameObject);
}
// Token: 0x06000053 RID: 83 RVA: 0x000055AC File Offset: 0x000037AC
public static DungeonFlow CreateDebugFlow(Dungeon dungeon)
{
DungeonFlow dungeonFlow = SampleFlow.CreateEntranceExitFlow(dungeon);
dungeonFlow.name = "debug_flow";
DungeonFlowNode dungeonFlowNode = new DungeonFlowNode(dungeonFlow)
{
overrideExactRoom = RoomFactory.CreateEmptyRoom(12, 12)
};
DungeonFlowNode parent = dungeonFlowNode;
dungeonFlow.AddNodeToFlow(dungeonFlowNode, dungeonFlow.FirstNode);
foreach (RoomFactory.RoomData roomData in RoomFactory.rooms.Values)
{
string str = "Adding room to flow: ";
PrototypeDungeonRoom room = roomData.room;
Tools.Log <string>(str + ((room != null) ? room.ToString() : null));
DungeonFlowNode dungeonFlowNode2 = new DungeonFlowNode(dungeonFlow)
{
overrideExactRoom = roomData.room
};
dungeonFlow.AddNodeToFlow(dungeonFlowNode2, parent);
dungeonFlowNode = new DungeonFlowNode(dungeonFlow)
{
overrideExactRoom = RoomFactory.CreateEmptyRoom(12, 12)
};
dungeonFlow.AddNodeToFlow(dungeonFlowNode, dungeonFlowNode2);
parent = dungeonFlowNode;
}
dungeon = null;
return(dungeonFlow);
}
public static PrototypeDungeonRoom GetRoomFromDungeon(string roomName, string floor)
{
roomName = roomName.ToLower();
var rooms = GetRoomsFromRoomTables(floor);
foreach (var room in rooms)
{
Tools.Log(room.name, "roomnames.txt");
if (room.name.ToLower().Equals(roomName))
{
return(room);
}
}
var nodes = OfficialFlows.GetAllFlowNodes(floor);
if (nodes == null)
{
return(null);
}
foreach (var node in nodes)
{
var overrideRoom = node.overrideExactRoom;
if (overrideRoom != null)
{
Tools.Log(overrideRoom.name, "roomnames.txt");
}
if (overrideRoom != null && overrideRoom.name.ToLower().Equals(roomName))
{
return(overrideRoom);
}
}
return(null);
}
public static DungeonFlow CreateDebugFlow(Dungeon dungeon)
{
var flow = SampleFlow.CreateEntranceExitFlow(dungeon);
flow.name = "debug_flow";
DungeonFlowNode
customRoom,
hub = new DungeonFlowNode(flow)
{
overrideExactRoom = RoomFactory.CreateEmptyRoom()
},
lastNode = hub;
flow.AddNodeToFlow(hub, flow.FirstNode);
foreach (var room in RoomFactory.rooms.Values)
{
Tools.Log("Adding room to flow: " + room.room);
customRoom = new DungeonFlowNode(flow)
{
overrideExactRoom = room.room
};
flow.AddNodeToFlow(customRoom, lastNode);
hub = new DungeonFlowNode(flow)
{
overrideExactRoom = RoomFactory.CreateEmptyRoom()
};
flow.AddNodeToFlow(hub, customRoom);
lastNode = hub;
}
dungeon = null;
return(flow);
}
// Token: 0x0600000C RID: 12 RVA: 0x00003260 File Offset: 0x00001460
public static void LogProtoRoomData(PrototypeDungeonRoom room)
{
int num = 0;
Tools.LogPropertiesAndFields <PrototypeDungeonRoom>(room, "ROOM");
foreach (PrototypePlacedObjectData prototypePlacedObjectData in room.placedObjects)
{
Tools.Log <string>(string.Format("\n----------------Object #{0}----------------", num++));
Tools.LogPropertiesAndFields <PrototypePlacedObjectData>(prototypePlacedObjectData, "PLACED OBJECT");
Tools.LogPropertiesAndFields <DungeonPlaceable>((prototypePlacedObjectData != null) ? prototypePlacedObjectData.placeableContents : null, "PLACEABLE CONTENT");
bool flag = prototypePlacedObjectData == null;
DungeonPlaceableVariant obj;
if (flag)
{
obj = null;
}
else
{
DungeonPlaceable placeableContents = prototypePlacedObjectData.placeableContents;
obj = ((placeableContents != null) ? placeableContents.variantTiers[0] : null);
}
Tools.LogPropertiesAndFields <DungeonPlaceableVariant>(obj, "VARIANT TIERS");
}
Tools.Print <string>("==LAYERS==", "FFFFFF", false);
foreach (PrototypeRoomObjectLayer prototypeRoomObjectLayer in room.additionalObjectLayers)
{
}
}
// Token: 0x06000077 RID: 119 RVA: 0x00005C34 File Offset: 0x00003E34
public static void Print <T>(T obj, string color = "FFFFFF", bool force = false)
{
bool flag = Tools.verbose || force;
if (flag)
{
string[] array = obj.ToString().Split(new char[]
{
'\n'
});
foreach (string text in array)
{
Tools.LogToConsole(string.Concat(new string[]
{
"<color=#",
color,
">[",
Tools.modID,
"] ",
text,
"</color>"
}));
}
}
Tools.Log <string>(obj.ToString());
}
public static void LoadRoomsFromRoomDirectory()
{
string roomDirectory = RoomDirectory();
Directory.CreateDirectory(roomDirectory);
foreach (string f in Directory.GetFiles(roomDirectory, "*", SearchOption.AllDirectories))
{
if (f.EndsWith(".room", StringComparison.OrdinalIgnoreCase))
{
string name = Path.GetFullPath(f).RemovePrefix(roomDirectory).RemoveSuffix(".room");
Tools.Log($"Found room: \"{name}\"");
var roomData = BuildFromRoomFile(f);
DungeonHandler.Register(roomData);
rooms.Add(name, roomData);
}
else if (f.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
{
Tools.Log($"Found zipped rooms: \"{f}\"");
var roomsData = BuildFromZipFile(f);
foreach (var roomData in roomsData)
{
string name = roomData.room.name;
Tools.Log($"Found room: \"{name}\"");
DungeonHandler.Register(roomData);
rooms.Add(roomData.room.name, roomData);
}
}
}
}
public void DumpEnemyDatabase()
{
Tools.Print("Dumping enemy database.");
for (int i = 0; i < EnemyDatabase.Instance.Entries.Count; i++)
{
var entry = EnemyDatabase.Instance.Entries[i];
Tools.Log($"{entry.myGuid}\t{entry.name}\t{i}\t{entry.isNormalEnemy}\t{entry.isInBossTab}", "EnemyDump.txt");
}
}
public override void Start()
{
try
{
GungeonAPI.Init();
KeyShrine.Add();
//Enable the debug flow
ETGModConsole.Commands.AddUnit("debugflow", (args) =>
{
DungeonHandler.debugFlow = !DungeonHandler.debugFlow;
string status = DungeonHandler.debugFlow ? "enabled" : "disabled";
string color = DungeonHandler.debugFlow ? "00FF00" : "FF0000";
Tools.Print($"Debug flow {status}", color, true);
});
//This is useful for figuring out where you want your shrine to go in the breach
ETGModConsole.Commands.AddUnit("getpos", (args) =>
{
ETGModConsole.Log("Player position: " + GameManager.Instance.PrimaryPlayer.transform.position);
ETGModConsole.Log("Player center: " + GameManager.Instance.PrimaryPlayer.sprite.WorldCenter);
});
ETGModConsole.Commands.AddUnit("dissectshrine", (args) =>
{
var c = GetClosestCustomShrineObject();
Tools.BreakdownComponents(c);
Tools.LogPropertiesAndFields(c.GetComponent <SimpleInteractable>());
});
ETGModConsole.Commands.AddUnit("roomname", (args) =>
{
var room = GameManager.Instance.PrimaryPlayer.CurrentRoom;
Tools.Print(room.GetRoomName());
});
ETGModConsole.Commands.AddUnit("hidehitboxes", (args) => HitboxMonitor.DeleteHitboxDisplays());
ETGModConsole.Commands.AddUnit("showhitboxes", (args) =>
{
foreach (var obj in GameObject.FindObjectsOfType <SpeculativeRigidbody>())
{
if (obj && obj.sprite && Vector2.Distance(obj.sprite.WorldCenter, GameManager.Instance.PrimaryPlayer.sprite.WorldCenter) < 8)
{
Tools.Log(obj?.name);
HitboxMonitor.DisplayHitbox(obj);
}
}
});
Tools.Print($"Custom Rooms {VERSION} loaded.", "FF00FF", true);
}
catch (Exception e)
{
Tools.Print("Failed to load Custom Rooms Mod", "FF0000", true);
Tools.PrintException(e);
}
}
public static void DisplayHitbox(SpeculativeRigidbody speculativeRigidbody)
{
PixelCollider collider = speculativeRigidbody.HitboxPixelCollider;
Tools.Log("Collider Found...");
if (!speculativeRigidbody.gameObject.GetComponent<HitBoxDisplay>())
speculativeRigidbody.gameObject.AddComponent<HitBoxDisplay>();
Tools.Log("Displaying...");
LogHitboxInfo(collider);
}
// Token: 0x06000078 RID: 120 RVA: 0x00005CD8 File Offset: 0x00003ED8
public static void PrintRaw <T>(T obj, bool force = false)
{
bool flag = Tools.verbose || force;
if (flag)
{
Tools.LogToConsole(obj.ToString());
}
Tools.Log <string>(obj.ToString());
}
// Token: 0x06000019 RID: 25 RVA: 0x000036B8 File Offset: 0x000018B8
public static void DisplayHitbox(SpeculativeRigidbody speculativeRigidbody)
{
PixelCollider hitboxPixelCollider = speculativeRigidbody.HitboxPixelCollider;
Tools.Log <string>("Collider Found...");
bool flag = !speculativeRigidbody.gameObject.GetComponent <HitboxMonitor.HitBoxDisplay>();
if (flag)
{
speculativeRigidbody.gameObject.AddComponent <HitboxMonitor.HitBoxDisplay>();
}
Tools.Log <string>("Displaying...");
HitboxMonitor.LogHitboxInfo(hitboxPixelCollider);
}
public static RoomData ExtractRoomData(string data)
{
int end = data.Length - dataHeader.Length - 1;
for (int i = end; i > 0; i--)
{
string sub = data.Substring(i, dataHeader.Length);
if (sub.Equals(dataHeader))
{
return(JsonUtility.FromJson <RoomData>(data.Substring(i + dataHeader.Length)));
}
}
Tools.Log($"No room data found at {data}");
return(new RoomData());
}
public static RoomData ExtractRoomData(string data)
{
int num = (data.Length - dataHeader.Length - 1);
for (int i = num; i > 0; i--)
{
string text = data.Substring(i, dataHeader.Length);
if (text.Equals(dataHeader))
{
return(JsonUtility.FromJson <RoomData>(data.Substring(i + dataHeader.Length)));
}
}
Tools.Log("No room data found at " + data);
return(default(RoomData));
}
public static void AcquirePrototypeRoom(Action <LoopFlowBuilder, BuilderFlowNode> orig, LoopFlowBuilder self, BuilderFlowNode buildData)
{
orig(self, buildData);
if (buildData.assignedPrototypeRoom)
{
if (buildData.assignedPrototypeRoom.category != PrototypeDungeonRoom.RoomCategory.NORMAL)
{
Tools.LogPropertiesAndFields(buildData.assignedPrototypeRoom, "\n" + buildData.assignedPrototypeRoom.name);
}
else
{
Tools.Log("======================= NULL =======================\n");
}
}
}
public static void LoadRoomsFromRoomDirectory()
{
Directory.CreateDirectory(roomDirectory);
foreach (string f in Directory.GetFiles(roomDirectory))
{
if (!f.EndsWith(".room"))
{
continue;
}
string name = Path.GetFileName(f);
Tools.Log($"Found room: \"{name}\"");
var roomData = BuildFromFile(f);
DungeonHandler.Register(roomData);
rooms.Add(name, roomData);
}
}
// Token: 0x0600003A RID: 58 RVA: 0x00003A08 File Offset: 0x00001C08
public static void LoadRoomsFromRoomDirectory()
{
Directory.CreateDirectory(RoomFactory.roomDirectory);
foreach (string text in Directory.GetFiles(RoomFactory.roomDirectory))
{
bool flag = !text.EndsWith(".room");
if (!flag)
{
string fileName = Path.GetFileName(text);
Tools.Log <string>("Found room: \"" + fileName + "\"");
RoomFactory.RoomData roomData = RoomFactory.BuildFromFile(text);
DungeonHandler.Register(roomData);
RoomFactory.rooms.Add(fileName, roomData);
}
}
}
// Token: 0x06000082 RID: 130 RVA: 0x000060B8 File Offset: 0x000042B8
public static void LogPropertiesAndFields <T>(T obj, string header = "")
{
Tools.Log <string>(header);
Tools.Log <string>("=======================");
bool flag = obj == null;
if (flag)
{
Tools.Log <string>("LogPropertiesAndFields: Null object");
}
else
{
Type type = obj.GetType();
Tools.Log <string>(string.Format("Type: {0}", type));
PropertyInfo[] properties = type.GetProperties();
Tools.Log <string>(string.Format("{0} Properties: ", typeof(T)));
foreach (PropertyInfo propertyInfo in properties)
{
try
{
object value = propertyInfo.GetValue(obj, null);
string text = value.ToString();
bool flag2 = ((obj != null) ? obj.GetType().GetGenericTypeDefinition() : null) == typeof(List <>);
bool flag3 = flag2;
if (flag3)
{
List <object> list = value as List <object>;
text = string.Format("List[{0}]", list.Count);
foreach (object obj2 in list)
{
text = text + "\n\t\t" + obj2.ToString();
}
}
Tools.Log <string>("\t" + propertyInfo.Name + ": " + text);
}
catch
{
}
}
Tools.Log <string>(string.Format("{0} Fields: ", typeof(T)));
FieldInfo[] fields = type.GetFields();
foreach (FieldInfo fieldInfo in fields)
{
Tools.Log <string>(string.Format("\t{0}: {1}", fieldInfo.Name, fieldInfo.GetValue(obj)));
}
}
}
public static WeightedRoom SelectByWeight(Func <WeightedRoomCollection, WeightedRoom> orig, WeightedRoomCollection self)
{
try
{
if (!seenTables.Contains(self))
{
//Tools.Log(self.name, "RoomTables/" + self.name + ".txt");
foreach (var wroom in self.elements)
{
Tools.Log(wroom.room.name, "RoomTables/" + seenTables.Count + ".txt");
}
seenTables.Add(self);
}
}catch (Exception e)
{
Tools.PrintException(e);
}
return(orig(self));
}
public static void LogProtoRoomData(PrototypeDungeonRoom room)
{
int i = 0;
Tools.LogPropertiesAndFields(room, "ROOM");
foreach (var placedObject in room.placedObjects)
{
Tools.Log($"\n----------------Object #{i++}----------------");
Tools.LogPropertiesAndFields(placedObject, "PLACED OBJECT");
Tools.LogPropertiesAndFields(placedObject?.placeableContents, "PLACEABLE CONTENT");
Tools.LogPropertiesAndFields(placedObject?.placeableContents?.variantTiers[0], "VARIANT TIERS");
}
Tools.Print("==LAYERS==");
foreach (var layer in room.additionalObjectLayers)
{
//Tools.LogPropertiesAndFields(layer);
}
}
public static void StraightLine()
{
try
{
Vector2[] enemyPositions = new Vector2[100];
string[] enemyGuids = new string[100];
int[] enemyLayers = new int[100];
for (int i = 0; i < enemyGuids.Length; i++)
{
var db = EnemyDatabase.Instance.Entries;
int r = Random.Range(0, db.Count);
enemyGuids[i] = db[r].encounterGuid;
enemyPositions[i] = new Vector2(i * 2, 10);
enemyLayers[i] = 0;
}
Vector2[] exits = new Vector2[]
{
new Vector2(0, 9),
new Vector2(200, 9),
};
string[] dirs = new string[]
{
"WEST", "EAST"
};
RoomData data = new RoomData()
{
enemyPositions = enemyPositions,
enemyGUIDs = enemyGuids,
enemyReinforcementLayers = enemyLayers,
exitPositions = exits,
exitDirections = dirs,
};
Tools.Log("Data to JSON: " + JsonUtility.ToJson(data));
}
catch (Exception e)
{
Tools.PrintException(e);
}
}
// Token: 0x06000028 RID: 40 RVA: 0x00003CA8 File Offset: 0x00001EA8
public static PrototypeDungeonRoom GetRoomFromDungeon(string roomName, string floor)
{
roomName = roomName.ToLower();
List <PrototypeDungeonRoom> roomsFromRoomTables = OfficialFlows.GetRoomsFromRoomTables(floor);
foreach (PrototypeDungeonRoom prototypeDungeonRoom in roomsFromRoomTables)
{
Tools.Log <string>(prototypeDungeonRoom.name, "roomnames.txt");
bool flag = prototypeDungeonRoom.name.ToLower().Equals(roomName);
if (flag)
{
return(prototypeDungeonRoom);
}
}
List <DungeonFlowNode> allFlowNodes = OfficialFlows.GetAllFlowNodes(floor);
bool flag2 = allFlowNodes == null;
PrototypeDungeonRoom result;
if (flag2)
{
result = null;
}
else
{
foreach (DungeonFlowNode dungeonFlowNode in allFlowNodes)
{
PrototypeDungeonRoom overrideExactRoom = dungeonFlowNode.overrideExactRoom;
bool flag3 = overrideExactRoom != null;
if (flag3)
{
Tools.Log <string>(overrideExactRoom.name, "roomnames.txt");
}
bool flag4 = overrideExactRoom != null && overrideExactRoom.name.ToLower().Equals(roomName);
if (flag4)
{
return(overrideExactRoom);
}
}
result = null;
}
return(result);
}
// Token: 0x06000079 RID: 121 RVA: 0x00005D18 File Offset: 0x00003F18
public static void PrintError <T>(T obj, string color = "FF0000")
{
string[] array = obj.ToString().Split(new char[]
{
'\n'
});
foreach (string text in array)
{
Tools.LogToConsole(string.Concat(new string[]
{
"<color=#",
color,
">[",
Tools.modID,
"] ",
text,
"</color>"
}));
}
Tools.Log <string>(obj.ToString());
}
// Token: 0x06000050 RID: 80 RVA: 0x00004840 File Offset: 0x00002A40
public static void StraightLine()
{
try
{
Vector2[] array = new Vector2[100];
string[] array2 = new string[100];
int[] array3 = new int[100];
for (int i = 0; i < array2.Length; i++)
{
List <EnemyDatabaseEntry> entries = EnemyDatabase.Instance.Entries;
int index = UnityEngine.Random.Range(0, entries.Count);
array2[i] = entries[index].encounterGuid;
array[i] = new Vector2((float)(i * 2), 10f);
array3[i] = 0;
}
Vector2[] exitPositions = new Vector2[]
{
new Vector2(0f, 9f),
new Vector2(200f, 9f)
};
string[] exitDirections = new string[]
{
"WEST",
"EAST"
};
RoomFactory.RoomData roomData = new RoomFactory.RoomData
{
enemyPositions = array,
enemyGUIDs = array2,
enemyReinforcementLayers = array3,
exitPositions = exitPositions,
exitDirections = exitDirections
};
Tools.Log <string>("Data to JSON: " + JsonUtility.ToJson(roomData));
}
catch (Exception e)
{
Tools.PrintException(e, "FF0000");
}
}
public static IEnumerable <RoomData> BuildFromZipFile(string zipFilePath)
{
if (!ZipFile.IsZipFile(zipFilePath))
{
Tools.Log($"Not a valid zip file!");
yield break;
}
using (var zipFile = ZipFile.Read(zipFilePath))
{
//Tools.PrintNoID("did it work?");
foreach (var entry in zipFile.Entries)
{
var fileName = Path.GetFileNameWithoutExtension(entry.FileName);
var extension = Path.GetExtension(entry.FileName);
if (!string.Equals(extension, ".room", StringComparison.OrdinalIgnoreCase))
{
continue;
}
byte[] zipData;
int capacity = (int)entry.UncompressedSize;
if (capacity < 0)
{
continue;
}
using (var ms = new MemoryStream(capacity))
{
entry.Extract(ms);
zipData = ms.ToArray();
}
var texture = ResourceExtractor.BytesToTexture(zipData, fileName);
var roomData = ExtractRoomDataFromBytes(zipData);
roomData.room = Build(texture, roomData);
yield return(roomData);
}
}
}
// Token: 0x0600007A RID: 122 RVA: 0x00005DB0 File Offset: 0x00003FB0
public static void PrintException(Exception e, string color = "FF0000")
{
string text = e.Message + "\n" + e.StackTrace;
string[] array = text.Split(new char[]
{
'\n'
});
foreach (string text2 in array)
{
Tools.LogToConsole(string.Concat(new string[]
{
"<color=#",
color,
">[",
Tools.modID,
"] ",
text2,
"</color>"
}));
}
Tools.Log <string>(e.Message);
Tools.Log <string>("\t" + e.StackTrace);
}
