diff --git a/asm/ground_event.s b/asm/ground_event.s
index 82f616ba4..83d6ea5b9 100644
--- a/asm/ground_event.s
+++ b/asm/ground_event.s
@@ -5,451 +5,7 @@
 
 	.text
 
-	thumb_func_start GroundEvent_Delete
-GroundEvent_Delete:
-	push {r4,lr}
-	adds r2, r0, 0
-	lsls r2, 16
-	asrs r2, 16
-	ldr r0, _080ADC58
-	lsls r1, r2, 5
-	ldr r4, [r0]
-	adds r4, r1
-	ldr r1, _080ADC5C
-	movs r0, 0
-	bl Log
-	ldr r0, _080ADC60
-	strh r0, [r4, 0x2]
-	pop {r4}
-	pop {r0}
-	bx r0
-	.align 2, 0
-_080ADC58: .4byte gGroundEvents
-_080ADC5C: .4byte gGroundEventDeleteText
-_080ADC60: .4byte 0x0000ffff
-	thumb_func_end GroundEvent_Delete
 
-	thumb_func_start sub_80ADC64
-sub_80ADC64:
-	push {lr}
-	adds r3, r1, 0
-	lsls r0, 16
-	ldr r1, _080ADC84
-	asrs r0, 11
-	ldr r1, [r1]
-	adds r2, r1, r0
-	movs r0, 0x2
-	ldrsh r1, [r2, r0]
-	movs r0, 0x1
-	negs r0, r0
-	cmp r1, r0
-	bne _080ADC88
-	movs r0, 0
-	b _080ADC9A
-	.align 2, 0
-_080ADC84: .4byte gGroundEvents
-_080ADC88:
-	ldr r0, [r2, 0x1C]
-	str r0, [r3]
-	movs r0, 0x2
-	strh r0, [r3, 0x4]
-	ldrh r0, [r2, 0x4]
-	strh r0, [r3, 0x6]
-	ldrb r0, [r2, 0x6]
-	strb r0, [r3, 0x8]
-	movs r0, 0x1
-_080ADC9A:
-	pop {r1}
-	bx r1
-	thumb_func_end sub_80ADC64
-
-	thumb_func_start FindGroundEvent
-FindGroundEvent:
-	push {r4-r7,lr}
-	adds r7, r0, 0
-	adds r4, r1, 0
-	ldr r0, _080ADCEC
-	ldr r3, [r0]
-	movs r5, 0
-	movs r0, 0x1
-	negs r0, r0
-	mov r12, r0
-	movs r6, 0x80
-	lsls r6, 9
-_080ADCB6:
-	movs r1, 0x2
-	ldrsh r0, [r3, r1]
-	cmp r0, r12
-	beq _080ADCF0
-	ldr r0, [r3, 0x8]
-	ands r0, r7
-	cmp r0, 0
-	beq _080ADCF0
-	ldr r1, [r3, 0xC]
-	ldr r0, [r2]
-	cmp r1, r0
-	bge _080ADCF0
-	ldr r1, [r3, 0x14]
-	ldr r0, [r4]
-	cmp r1, r0
-	ble _080ADCF0
-	ldr r1, [r3, 0x10]
-	ldr r0, [r2, 0x4]
-	cmp r1, r0
-	bge _080ADCF0
-	ldr r1, [r3, 0x18]
-	ldr r0, [r4, 0x4]
-	cmp r1, r0
-	ble _080ADCF0
-	adds r0, r5, 0
-	b _080ADD04
-	.align 2, 0
-_080ADCEC: .4byte gGroundEvents
-_080ADCF0:
-	adds r0, r6, 0
-	movs r1, 0x80
-	lsls r1, 9
-	adds r6, r1
-	asrs r5, r0, 16
-	adds r3, 0x20
-	cmp r5, 0x1F
-	ble _080ADCB6
-	movs r0, 0x1
-	negs r0, r0
-_080ADD04:
-	pop {r4-r7}
-	pop {r1}
-	bx r1
-	thumb_func_end FindGroundEvent
-
-	thumb_func_start sub_80ADD0C
-sub_80ADD0C:
-	push {r4-r7,lr}
-	mov r7, r9
-	mov r6, r8
-	push {r6,r7}
-	mov r8, r0
-	adds r6, r1, 0
-	adds r5, r2, 0
-	ldr r0, _080ADD74
-	ldr r4, [r0]
-	movs r7, 0
-	movs r0, 0x1
-	negs r0, r0
-	mov r9, r0
-	movs r1, 0x80
-	lsls r1, 9
-	mov r12, r1
-_080ADD2C:
-	movs r1, 0x2
-	ldrsh r0, [r4, r1]
-	cmp r0, r9
-	beq _080ADD78
-	ldr r0, [r4, 0x8]
-	mov r1, r8
-	ands r0, r1
-	cmp r0, 0
-	beq _080ADD78
-	ldr r0, [r4, 0xC]
-	ldr r1, [r4, 0x14]
-	adds r0, r1
-	lsrs r1, r0, 31
-	adds r0, r1
-	asrs r2, r0, 1
-	ldr r0, [r4, 0x10]
-	ldr r1, [r4, 0x18]
-	adds r0, r1
-	lsrs r1, r0, 31
-	adds r0, r1
-	asrs r3, r0, 1
-	ldr r0, [r5]
-	cmp r2, r0
-	bge _080ADD78
-	ldr r0, [r6]
-	cmp r2, r0
-	ble _080ADD78
-	ldr r0, [r5, 0x4]
-	cmp r3, r0
-	bge _080ADD78
-	ldr r0, [r6, 0x4]
-	cmp r3, r0
-	ble _080ADD78
-	adds r0, r7, 0
-	b _080ADD8C
-	.align 2, 0
-_080ADD74: .4byte gGroundEvents
-_080ADD78:
-	mov r0, r12
-	movs r1, 0x80
-	lsls r1, 9
-	add r12, r1
-	asrs r7, r0, 16
-	adds r4, 0x20
-	cmp r7, 0x1F
-	ble _080ADD2C
-	movs r0, 0x1
-	negs r0, r0
-_080ADD8C:
-	pop {r3,r4}
-	mov r8, r3
-	mov r9, r4
-	pop {r4-r7}
-	pop {r1}
-	bx r1
-	thumb_func_end sub_80ADD0C
-
-	thumb_func_start nullsub_124
-nullsub_124:
-	bx lr
-	thumb_func_end nullsub_124
-
-	thumb_func_start sub_80ADD9C
-sub_80ADD9C:
-	push {r4-r7,lr}
-	mov r7, r10
-	mov r6, r9
-	mov r5, r8
-	push {r5-r7}
-	sub sp, 0x30
-	str r0, [sp, 0x20]
-	str r1, [sp, 0x24]
-	str r2, [sp, 0x28]
-	str r3, [sp, 0x2C]
-	ldr r5, [sp, 0x54]
-	ldr r0, [sp, 0x5C]
-	mov r9, r0
-	movs r0, 0x93
-	lsls r0, 4
-	movs r1, 0x7
-	bl MemoryAlloc
-	mov r10, r0
-	ldr r0, _080ADEB4
-	ldr r7, _080ADEB8
-	adds r1, r7, 0
-	bl OpenFileAndGetFileDataPtr
-	adds r6, r0, 0
-	add r4, sp, 0x1C
-	adds r0, r4, 0
-	adds r1, r5, 0
-	bl sub_80901D8
-	ldrb r5, [r4]
-	ldrb r4, [r4, 0x1]
-	cmp r5, 0x3E
-	bls _080ADDE2
-	movs r5, 0x3E
-_080ADDE2:
-	cmp r4, 0
-	bgt _080ADDE8
-	movs r4, 0x1
-_080ADDE8:
-	adds r0, r5, 0
-	bl GetDungeonFloorCount
-	cmp r4, r0
-	blt _080ADDFA
-	adds r0, r5, 0
-	bl GetDungeonFloorCount
-	subs r4, r0, 0x1
-_080ADDFA:
-	ldr r2, [r6, 0x4]
-	ldr r1, [r2]
-	lsls r0, r5, 2
-	adds r0, r1
-	lsls r1, r4, 4
-	ldr r0, [r0]
-	adds r0, r1
-	movs r3, 0
-	ldrsh r1, [r0, r3]
-	ldr r2, [r2, 0x4]
-	lsls r0, r1, 3
-	subs r0, r1
-	lsls r0, 2
-	adds r0, r2
-	ldrb r0, [r0, 0x2]
-	mov r8, r0
-	adds r0, r6, 0
-	bl CloseFile
-	ldr r1, _080ADEBC
-	ldr r0, _080ADEC0
-	add r0, r8
-	ldrb r5, [r0]
-	add r0, sp, 0x10
-	adds r2, r5, 0
-	bl sprintf
-	add r0, sp, 0x10
-	adds r1, r7, 0
-	bl OpenFileAndGetFileDataPtr
-	adds r4, r0, 0
-	ldr r0, [sp, 0x28]
-	movs r1, 0
-	adds r2, r4, 0
-	bl DecompressATGlobalFile
-	adds r0, r4, 0
-	bl CloseFile
-	ldr r1, _080ADEC4
-	add r0, sp, 0x10
-	mov r2, r8
-	bl sprintf
-	add r0, sp, 0x10
-	adds r1, r7, 0
-	bl OpenFile
-	ldr r1, [sp, 0x20]
-	str r0, [r1]
-	ldr r1, _080ADEC8
-	add r0, sp, 0x10
-	adds r2, r5, 0
-	bl sprintf
-	add r0, sp, 0x10
-	adds r1, r7, 0
-	bl OpenFileAndGetFileDataPtr
-	adds r4, r0, 0
-	ldr r1, _080ADECC
-	ldr r0, [sp, 0x2C]
-	adds r2, r4, 0
-	bl DecompressATFile
-	adds r0, r4, 0
-	bl CloseFile
-	mov r2, r8
-	cmp r2, 0x3F
-	bgt _080ADED4
-	ldr r1, _080ADED0
-	add r0, sp, 0x10
-	adds r2, r5, 0
-	bl sprintf
-	add r0, sp, 0x10
-	adds r1, r7, 0
-	bl OpenFileAndGetFileDataPtr
-	adds r4, r0, 0
-	mov r0, r10
-	movs r1, 0x93
-	lsls r1, 4
-	adds r2, r4, 0
-	bl DecompressATFile
-	adds r0, r4, 0
-	bl CloseFile
-	b _080ADEFC
-	.align 2, 0
-_080ADEB4: .4byte gMapparamText
-_080ADEB8: .4byte gDungeonFileArchive
-_080ADEBC: .4byte gUnknown_811889C
-_080ADEC0: .4byte gUnknown_8108EC0
-_080ADEC4: .4byte gUnknown_81188A8
-_080ADEC8: .4byte gUnknown_81188B4
-_080ADECC: .4byte 0x00001194
-_080ADED0: .4byte gUnknown_81188C0
-_080ADED4:
-	ldr r1, _080ADF80
-	add r0, sp, 0x10
-	mov r2, r8
-	ldr r3, [sp, 0x58]
-	bl sprintf
-	add r0, sp, 0x10
-	adds r1, r7, 0
-	bl OpenFileAndGetFileDataPtr
-	adds r4, r0, 0
-	movs r1, 0x90
-	lsls r1, 2
-	mov r0, r10
-	adds r2, r4, 0
-	bl DecompressATFile
-	adds r0, r4, 0
-	bl CloseFile
-_080ADEFC:
-	movs r5, 0
-	ldr r3, [sp, 0x60]
-	cmp r5, r3
-	bge _080ADF52
-_080ADF04:
-	mov r0, r8
-	bl IsWaterDungeon
-	lsls r0, 24
-	movs r7, 0
-	cmp r0, 0
-	beq _080ADF14
-	movs r7, 0x3
-_080ADF14:
-	movs r4, 0
-	adds r6, r5, 0x1
-	cmp r4, r9
-	bge _080ADF4A
-_080ADF1C:
-	ldr r0, [sp, 0x64]
-	str r0, [sp]
-	str r7, [sp, 0x4]
-	mov r1, r10
-	str r1, [sp, 0x8]
-	mov r2, r8
-	str r2, [sp, 0xC]
-	adds r0, r4, 0
-	adds r1, r5, 0
-	mov r2, r9
-	ldr r3, [sp, 0x60]
-	bl sub_80ADFB8
-	mov r1, r9
-	muls r1, r5
-	adds r1, r4
-	lsls r1, 1
-	ldr r3, [sp, 0x50]
-	adds r1, r3
-	strh r0, [r1]
-	adds r4, 0x1
-	cmp r4, r9
-	blt _080ADF1C
-_080ADF4A:
-	adds r5, r6, 0
-	ldr r0, [sp, 0x60]
-	cmp r5, r0
-	blt _080ADF04
-_080ADF52:
-	ldr r1, _080ADF84
-	add r0, sp, 0x10
-	mov r2, r8
-	bl sprintf
-	ldr r1, _080ADF88
-	add r0, sp, 0x10
-	bl OpenFile
-	ldr r1, [sp, 0x24]
-	str r0, [r1]
-	mov r0, r10
-	bl MemoryFree
-	add sp, 0x30
-	pop {r3-r5}
-	mov r8, r3
-	mov r9, r4
-	mov r10, r5
-	pop {r4-r7}
-	pop {r0}
-	bx r0
-	.align 2, 0
-_080ADF80: .4byte gUnknown_81188CC
-_080ADF84: .4byte gUnknown_81188DC
-_080ADF88: .4byte gDungeonFileArchive
-	thumb_func_end sub_80ADD9C
-
-	thumb_func_start sub_80ADF8C
-sub_80ADF8C:
-	push {r4,lr}
-	adds r4, r0, 0
-	ldr r0, [sp, 0xC]
-	cmp r4, 0
-	blt _080ADFB0
-	cmp r1, 0
-	blt _080ADFB0
-	cmp r4, r2
-	bge _080ADFB0
-	cmp r1, r3
-	bge _080ADFB0
-	adds r0, r1, 0
-	muls r0, r2
-	adds r0, r4, r0
-	lsls r0, 1
-	ldr r1, [sp, 0x8]
-	adds r0, r1
-	ldrh r0, [r0]
-_080ADFB0:
-	pop {r4}
-	pop {r1}
-	bx r1
-	thumb_func_end sub_80ADF8C
 
 	thumb_func_start sub_80ADFB8
 sub_80ADFB8:
diff --git a/src/ground_event.c b/src/ground_event.c
index ffc9aa833..4404b855c 100644
--- a/src/ground_event.c
+++ b/src/ground_event.c
@@ -7,7 +7,7 @@ typedef struct GroundEvent
 {
     s16 unk0;
     s16 unk2;
-    s16 unk4; // scriptID
+    s16 unk4; // scriptID or group?
     s8 unk6; // sector
     s32 unk8;
     s32 unkC;
@@ -29,6 +29,7 @@ extern DebugLocation gUnknown_81187DC;
 extern u8 gGroundEventSelectText[];
 extern u8 gGroundEventCancelText[];
 extern u8 gGroundEventAddText[];
+extern u8 gGroundEventDeleteText[];
 
 void AllocGroundEvents(void) {
     s32 ind;
@@ -133,8 +134,8 @@ static inline void SetUnkInGroundEvent(const CompactPos *posPtr, s32 *dst)
 
 struct TestStruct
 {
-    u32 unk0;
-    u32 unk4;
+    s32 unk0;
+    s32 unk4;
 };
 
 extern struct TestStruct sUnknown; // Todo: figure out or guess what this variable could be.
@@ -204,3 +205,187 @@ s32 GroundEvent_Add(s32 id, const GroundEventData *eventData, s32 group, s32 sec
     return scriptID_s32;
 }
 
+void GroundEvent_Delete(s32 id)
+{
+    s32 scriptID_s32 = (s16) id;
+    GroundEvent *ptr = &gGroundEvents[scriptID_s32];
+    Log(0, gGroundEventDeleteText, scriptID_s32);
+    ptr->unk2 = -1;
+}
+
+bool8 sub_80ADC64(s32 id, ScriptInfoSmall *dst)
+{
+    s32 scriptID_s32 = (s16) id;
+    GroundEvent *ptr = &gGroundEvents[scriptID_s32];
+
+    if (ptr->unk2 != -1) {
+        dst->ptr = ptr->unk1C;
+        dst->state = 2;
+        dst->group = ptr->unk4;
+        dst->sector = ptr->unk6;
+        return TRUE;
+    }
+    else {
+        return FALSE;
+    }
+}
+
+s16 FindGroundEvent(u32 flags, s32 *arg1, s32 *arg2)
+{
+    s32 i;
+    GroundEvent *ptr = &gGroundEvents[0];
+    for (i = 0; i < 0x20; i = (s16)(i + 1), ptr++) {
+        if (ptr->unk2 != -1
+            && (ptr->unk8 & flags)
+            && ptr->unkC < arg2[0]
+            && ptr->unk14 > arg1[0]
+            && ptr->unk10 < arg2[1]
+            && ptr->unk18 > arg1[1])
+        {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+UNUSED static s16 UnusedFindGroundEvent(u32 flags, s32 *arg1, s32 *arg2)
+{
+    s32 i;
+    GroundEvent *ptr = &gGroundEvents[0];
+    for (i = 0; i < 0x20; i = (s16)(i + 1), ptr++) {
+        if (ptr->unk2 != -1 && (ptr->unk8 & flags)) {
+            struct TestStruct r = {0};
+            r.unk0 = (ptr->unkC + ptr->unk14) / 2;
+            r.unk4 = (ptr->unk10 + ptr->unk18) / 2;
+            if (r.unk0 < arg2[0]
+                && r.unk0 > arg1[0]
+                && r.unk4 < arg2[1]
+                && r.unk4 > arg1[1])
+            {
+                return i;
+            }
+        }
+    }
+
+    return -1;
+}
+
+void nullsub_124(void) {}
+
+// TODO: Check if file split here
+
+#include "dungeon.h"
+#include "decompress_at.h"
+#include "def_filearchives.h"
+#include "file_system.h"
+#include "constants/dungeon.h"
+
+extern bool8 IsWaterDungeon(u32 r0);
+
+struct UnkDungeonFileData
+{
+    s16 unk0;
+    s16 unk2;
+    s16 unk4;
+    s16 unk6[5];
+};
+
+struct UnkDataFileStruct
+{
+    struct UnkDungeonFileData **unk0;
+    FloorProperties *unk4;
+    u16 **unk8;
+    UnkDungeonGlobal_unk1CD98 **unkC;
+    u16 **unk10;
+};
+
+s32 sub_80ADFB8(s32 a0, s32 a1, s32 a2, s32 a3, s32 a4, s32 a5, void *a6, s32 a7);
+
+extern const u8 gUnknown_8108EC0[];
+extern const u8 gMapparamText[];
+extern const u8 gUnknown_811889C[];
+extern const u8 gUnknown_81188B4[];
+extern const u8 gUnknown_81188A8[];
+extern const u8 gUnknown_81188C0[];
+extern const u8 gUnknown_81188CC[];
+extern const u8 gUnknown_81188DC[];
+
+void sub_80ADD9C(OpenedFile **a0, OpenedFile **a1, u32 *a2, u32 *a3, u16 *a4, DungeonLocation *a5, s32 a6, s32 a7, s32 a8, s32 a9)
+{
+    OpenedFile *file;
+    s32 r8;
+    s32 i, j;
+    u8 name[12];
+    DungeonLocation dungLoc;
+    u8 dungId;
+    s32 dungFloor;
+    struct UnkDungeonFileData *strPtr;
+    void *r10 = MemoryAlloc(0x930, 7);
+    OpenedFile *mapParamFile = OpenFileAndGetFileDataPtr(gMapparamText, &gDungeonFileArchive);
+
+    sub_80901D8(&dungLoc, a5);
+    dungId = dungLoc.id;
+    dungFloor = dungLoc.floor;
+    if (dungId > 62) {
+        dungId = 62;
+    }
+
+    if (dungFloor <= 0) {
+        dungFloor = 1;
+    }
+    if (dungFloor >= GetDungeonFloorCount(dungId)) {
+        dungFloor = GetDungeonFloorCount(dungId) - 1;
+    }
+
+    strPtr = &((struct UnkDataFileStruct *)(mapParamFile->data))->unk0[dungId][dungFloor];
+    r8 = ((struct UnkDataFileStruct *)(mapParamFile->data))->unk4[strPtr->unk0].unk2;
+
+    CloseFile(mapParamFile);
+
+    sprintf(name, gUnknown_811889C, gUnknown_8108EC0[r8]);
+    file = OpenFileAndGetFileDataPtr(name, &gDungeonFileArchive);
+    DecompressATGlobalFile(a2, 0, file);
+    CloseFile(file);
+
+    sprintf(name, gUnknown_81188A8, r8);
+    *a0 = OpenFile(name, &gDungeonFileArchive);
+
+    sprintf(name, gUnknown_81188B4, gUnknown_8108EC0[r8]);
+    file = OpenFileAndGetFileDataPtr(name, &gDungeonFileArchive);
+    DecompressATFile(a3, 0x1194, file);
+    CloseFile(file);
+
+    if (r8 < 64) {
+        sprintf(name, gUnknown_81188C0, gUnknown_8108EC0[r8]);
+        file = OpenFileAndGetFileDataPtr(name, &gDungeonFileArchive);
+        DecompressATFile(r10, 0x930, file);
+        CloseFile(file);
+    }
+    else {
+        sprintf(name, gUnknown_81188CC, r8, a6);
+        file = OpenFileAndGetFileDataPtr(name, &gDungeonFileArchive);
+        DecompressATFile(r10, 0x240, file);
+        CloseFile(file);
+    }
+
+    for (i = 0; i < a8; i++) {
+        s32 r7 = !IsWaterDungeon(r8) ? 0 : 3;
+        for (j = 0; j < a7; j++) {
+            a4[(i * a7) + j] = sub_80ADFB8(j, i, a7, a8, a9, r7, r10, r8);
+        }
+    }
+
+    sprintf(name, gUnknown_81188DC, r8);
+    *a1 = OpenFile(name, &gDungeonFileArchive);
+    MemoryFree(r10);
+}
+
+s32 sub_80ADF8C(s32 a0, s32 a1, s32 a2, s32 a3, u16 *a4, s32 a5)
+{
+    s32 ret = a5;
+    if (a0 >= 0 && a1 >= 0 && a0 < a2 && a1 < a3) {
+        ret = a4[a0 + (a1 * a2)];
+    }
+    return ret;
+}