flags.c OK

asm/code_0801C85C.s

@@ -1831,8 +1831,8 @@ WriteBit: @ 0x0801D5BC
 	ands r0, r2
 	bx lr
 
-	thumb_func_start sub_0801D5D4
-sub_0801D5D4: @ 0x0801D5D4
+	thumb_func_start ClearBit
+ClearBit: @ 0x0801D5D4
 	lsrs r2, r1, #3
 	adds r3, r0, r2
 	movs r2, #7

asm/code_08056418.s

@@ -9312,7 +9312,7 @@ _0805AC00:
 	bne _0805AC1A
 	adds r0, r7, #0
 	adds r1, r5, #0
-	bl sub_0801D5D4
+	bl ClearBit
 	b _0805ACA6
 _0805AC1A:
 	ldrh r0, [r4, #0xe]

asm/code_0807CAA0.s

@@ -151,55 +151,3 @@ _0807CBCA:
 	adds r0, r1, #0
 	pop {pc}
 	.align 2, 0
-
-	thumb_func_start CheckLocalFlag
-CheckLocalFlag: @ 0x0807CBD0
-	push {lr}
-	adds r1, r0, #0
-	ldr r0, _0807CBE0 @ =gArea
-	ldrh r0, [r0, #4]
-	bl CheckLocalFlagByOffset
-	pop {pc}
-	.align 2, 0
-_0807CBE0: .4byte gArea
-
-	thumb_func_start CheckFlags
-CheckFlags: @ 0x0807CBE4
-	push {lr}
-	ldr r3, _0807CC14 @ =0x000003FF
-	ands r3, r0
-	movs r1, #0xf0
-	lsls r1, r1, #6
-	ands r1, r0
-	lsrs r1, r1, #0xa
-	adds r2, r1, #1
-	movs r1, #0xc0
-	lsls r1, r1, #8
-	ands r1, r0
-	lsrs r1, r1, #0xe
-	cmp r1, #1
-	beq _0807CC22
-	cmp r1, #1
-	blo _0807CC18
-	cmp r1, #2
-	bne _0807CC2C
-	adds r0, r3, #0
-	adds r1, r2, #0
-	bl CheckRoomFlags
-	b _0807CC2E
-	.align 2, 0
-_0807CC14: .4byte 0x000003FF
-_0807CC18:
-	adds r0, r3, #0
-	adds r1, r2, #0
-	bl CheckLocalFlags
-	b _0807CC2E
-_0807CC22:
-	adds r0, r3, #0
-	adds r1, r2, #0
-	bl CheckGlobalFlags
-	b _0807CC2E
-_0807CC2C:
-	movs r0, #0
-_0807CC2E:
-	pop {pc}

asm/code_0807CC3C.s

@@ -5,128 +5,6 @@
 
 	.text
 
-	thumb_func_start SetFlag
-SetFlag: @ 0x0807CCC8
-	push {lr}
-	adds r1, r0, #0
-	cmp r1, #0
-	beq _0807CD02
-	ldr r2, _0807CCF0 @ =0x000003FF
-	ands r2, r1
-	movs r0, #0xc0
-	lsls r0, r0, #8
-	ands r0, r1
-	lsrs r0, r0, #0xe
-	cmp r0, #1
-	beq _0807CCFC
-	cmp r0, #1
-	blo _0807CCF4
-	cmp r0, #2
-	bne _0807CD02
-	adds r0, r2, #0
-	bl SetRoomFlag
-	b _0807CD02
-	.align 2, 0
-_0807CCF0: .4byte 0x000003FF
-_0807CCF4:
-	adds r0, r2, #0
-	bl SetLocalFlag
-	b _0807CD02
-_0807CCFC:
-	adds r0, r2, #0
-	bl SetGlobalFlag
-_0807CD02:
-	pop {pc}
-
-	thumb_func_start SetGlobalFlag
-SetGlobalFlag: @ 0x0807CD04
-	push {lr}
-	adds r1, r0, #0
-	movs r0, #0
-	bl SetLocalFlagByOffset
-	pop {pc}
-
-	thumb_func_start SetRoomFlag
-SetRoomFlag: @ 0x0807CD10
-	push {lr}
-	adds r1, r0, #0
-	ldr r0, _0807CD1C @ =gUnk_02034364
-	bl WriteBit
-	pop {pc}
-	.align 2, 0
-_0807CD1C: .4byte gUnk_02034364
-
-	thumb_func_start ClearLocalFlagByOffset
-ClearLocalFlagByOffset: @ 0x0807CD20
-	push {lr}
-	adds r2, r0, #0
-	ldr r0, _0807CD30 @ =gGlobalFlags
-	adds r2, r2, r1
-	adds r1, r2, #0
-	bl sub_0801D5D4
-	pop {pc}
-	.align 2, 0
-_0807CD30: .4byte gGlobalFlags
-
-	thumb_func_start ClearLocalFlag
-ClearLocalFlag: @ 0x0807CD34
-	push {lr}
-	adds r1, r0, #0
-	ldr r0, _0807CD44 @ =gArea
-	ldrh r0, [r0, #4]
-	bl ClearLocalFlagByOffset
-	pop {pc}
-	.align 2, 0
-_0807CD44: .4byte gArea
-
-	thumb_func_start ClearFlag
-ClearFlag: @ 0x0807CD48
-	push {lr}
-	ldr r2, _0807CD6C @ =0x000003FF
-	ands r2, r0
-	movs r1, #0xc0
-	lsls r1, r1, #8
-	ands r1, r0
-	lsrs r1, r1, #0xe
-	cmp r1, #1
-	beq _0807CD78
-	cmp r1, #1
-	blo _0807CD70
-	cmp r1, #2
-	bne _0807CD7E
-	adds r0, r2, #0
-	bl ClearRoomFlag
-	b _0807CD7E
-	.align 2, 0
-_0807CD6C: .4byte 0x000003FF
-_0807CD70:
-	adds r0, r2, #0
-	bl ClearLocalFlag
-	b _0807CD7E
-_0807CD78:
-	adds r0, r2, #0
-	bl ClearGlobalFlag
-_0807CD7E:
-	pop {pc}
-
-	thumb_func_start ClearGlobalFlag
-ClearGlobalFlag: @ 0x0807CD80
-	push {lr}
-	adds r1, r0, #0
-	movs r0, #0
-	bl ClearLocalFlagByOffset
-	pop {pc}
-
-	thumb_func_start ClearRoomFlag
-ClearRoomFlag: @ 0x0807CD8C
-	push {lr}
-	adds r1, r0, #0
-	ldr r0, _0807CD98 @ =gUnk_02034364
-	bl sub_0801D5D4
-	pop {pc}
-	.align 2, 0
-_0807CD98: .4byte gUnk_02034364
-
 	thumb_func_start sub_0807CD9C
 sub_0807CD9C: @ 0x0807CD9C
 	push {lr}

include/flags.h

@@ -3,7 +3,7 @@
 
 #include "global.h"
 
-extern u32 CheckFlags(u32);
+u32 CheckFlags(u32);
 u32 CheckGlobalFlag(u32);
 u32 CheckGlobalFlags(u32, u32);
 extern u32 CheckLocalFlag(u32);
@@ -13,18 +13,19 @@ u32 CheckLocalFlagsByOffset(u32, u32, u32);
 u32 CheckRoomFlag(u32);
 u32 CheckRoomFlags(u32, u32);
 
-extern void ClearFlag(u32);
-extern void ClearGlobalFlag(u32);
-extern void ClearLocalFlag(u32);
-extern void ClearLocalFlagByOffset(u32, u32);
-extern void ClearRoomFlag(u32);
+void ClearFlag(u32);
+void ClearGlobalFlag(u32);
+void ClearLocalFlag(u32);
+void ClearLocalFlagByOffset(u32, u32);
+void ClearRoomFlag(u32);
 
-extern void SetFlag(u32);
-extern void SetGlobalFlag(u32);
+void SetFlag(u32);
+void SetGlobalFlag(u32);
 void SetLocalFlag(u32);
 void SetLocalFlagByOffset(u32, u32);
-extern void SetRoomFlag(u32);
+void SetRoomFlag(u32);
 
 extern u32 gGlobalFlags;
+extern u32 gRoomFlags;
 
 #endif

linker.ld

@@ -116,7 +116,7 @@ SECTIONS {
         . = 0x000342F8; gUnk_020342F8 = .;
         . = 0x00034330; gUnk_02034330 = .;
         . = 0x00034350; gRoomVars = .;
-        . = 0x00034364; gUnk_02034364 = .;
+        . = 0x00034364; gRoomFlags = .;
         . = 0x00034398; gUnk_02034398 = .;
         . = 0x00034480; gUnk_02034480 = .;
         . = 0x00034490; gUnk_02034490 = .;

src/flags.c

@@ -7,18 +7,43 @@
 extern u32 ReadBit(u32*, u32);
 extern u32 CheckBits(u32*, u32, u32);
 extern void WriteBit(u32*, u32);
+extern void ClearBit(u32*, u32);
 
-u32 CheckGlobalFlag(u32 index) {
-    return CheckLocalFlagByOffset(0, index);
+u32 CheckLocalFlag(u32 flag) {
+    return CheckLocalFlagByOffset(gArea.localFlagOffset, flag);
 }
 
-u32 CheckRoomFlag(u32 index) {
-    return ReadBit(&gRoomVars.roomFlags, index);
+u32 CheckFlags(u32 flags) {
+    s32 uVar1;
+    s32 index;
+    s32 length;
+        index = flags & 0x3ff;
+        length = (((flags & (0xf0) << 0x6) >> 0xa) + 1);
+        uVar1 = (flags & 0xc000) >> 0xe;
+        switch ((u32)uVar1) {
+            case 2:
+                return CheckRoomFlags(index, length);
+            case 0:
+                return CheckLocalFlags(index, length);
+            case 1:
+                return CheckGlobalFlags(index, length);
+            default:
+                return 0;
+        }
+
 }
 
-u32 CheckLocalFlagsByOffset(u32 offset, u32 flag, u32 length) {
+u32 CheckGlobalFlag(u32 flag) {
+    return CheckLocalFlagByOffset(0, flag);
+}
 
-    return CheckBits(&gGlobalFlags, offset + flag, length);
+u32 CheckRoomFlag(u32 flag) {
+    return ReadBit(&gRoomVars.roomFlags, flag);
+}
+
+u32 CheckLocalFlagsByOffset(u32 flag, u32 offset, u32 length) {
+
+    return CheckBits(&gGlobalFlags, flag + offset, length);
 }
 
 u32 CheckLocalFlags(u32 flag, u32 length) {
@@ -29,19 +54,80 @@ u32 CheckGlobalFlags(u32 flag, u32 length) {
     return CheckLocalFlagsByOffset(0, flag, length);
 }
 
-u32 CheckRoomFlags(u32
- flag, u32 length) {
+u32 CheckRoomFlags(u32 flag, u32 length) {
     return CheckBits(&gRoomVars.roomFlags, flag, length);
 }
 
-void SetLocalFlagByOffset(u32 flag, u32 offset)
-{
-  if (offset != 0) {
-    WriteBit(&gGlobalFlags, flag + offset);
-  }
+void SetLocalFlagByOffset(u32 offset, u32 flag) {
+    if (flag != 0) {
+        WriteBit(&gGlobalFlags, offset + flag);
+    }
 }
 
-void SetLocalFlag(u32 index)
-{
-  SetLocalFlagByOffset(gArea.localFlagOffset, index);
+void SetLocalFlag(u32 flag) {
+    SetLocalFlagByOffset(gArea.localFlagOffset, flag);
+}
+
+void SetFlag(u32 flag) {
+    s32 uVar1;
+    s32 index;
+
+    if (flag != 0) {
+        index = flag & 0x3ff;
+        uVar1 = (flag & 0xc000) >> 0xe;
+        switch ((u32)uVar1) {
+            case 2:
+                SetRoomFlag(index);
+                return;
+            case 0:
+                SetLocalFlag(index);
+                return;
+            case 1:
+                SetGlobalFlag(index);
+                return;
+        }
+    }
+}
+
+void SetGlobalFlag(u32 flag) {
+    SetLocalFlagByOffset(0, flag);
+}
+
+void SetRoomFlag(u32 flag) {
+    WriteBit(&gRoomFlags, flag);
+}
+
+void ClearLocalFlagByOffset(u32 offset, u32 flag) {
+    ClearBit(&gGlobalFlags, offset + flag);
+}
+
+void ClearLocalFlag(u32 flag) {
+    ClearLocalFlagByOffset(gArea.localFlagOffset, flag);
+}
+
+void ClearFlag(u32 flag) {
+    s32 uVar1;
+    s32 index;
+
+    index = flag & 0x3ff;
+    uVar1 = (flag & 0xc000) >> 0xe;
+    switch ((u32)uVar1) {
+        case 2:
+            ClearRoomFlag(index);
+            return;
+        case 0:
+            ClearLocalFlag(index);
+            return;
+        case 1:
+            ClearGlobalFlag(index);
+            return;
+    }
+}
+
+void ClearGlobalFlag(u32 flag) {
+    ClearLocalFlagByOffset(0, flag);
+}
+
+void ClearRoomFlag(u32 flag) {
+    ClearBit(&gRoomFlags, flag);
 }