added unit test for initiatibve (normal + trickroom)

tied to bs_test

bpre.sym

 m4aSongNumStart = 0x081DD0F5;
 MPlayStart_rev01 = 0x081DD859;
 MPlayContinue = 0x081DCFF9;
-__aeabi_idiv = 0x081E460C|1;
+__aeabi_idiv = 0x081E4018|1;
+__aeabi_idivmod = 0x081E40F4|1;
+__aeabi_uidiv = 0x081E460C|1;
+__aeabi_uidivmod = 0x081E4684|1;

data/moves/effect_table.S

 
 .global m_effect_table
 m_effect_table:
-	@.word bs_power_trick    @for testing
+	@.word bs_test           @for unit tests
+        @.word bs_power_trick    @for testing
         .word 0x081D6900 @0
 	.word 0x081D696D @1
 	.word 0x081D69DC @2

linker.ld

                 *(.text)
                 *(.ctors)
                 *(.dtors)
-                *(.rodata)
                 *(.fini)
                 *(COMMON)
                 __text_end  = . ;
+                *(.rodata*)
+                *(.rdata)
                 *(.data)
                 __bss_start__ = . ;
                 *(.bss)

makefile

 
 DEFINES   := -DBPRE -DSOFTWARE_VERSION=0
 ASFLAGS   := -mthumb
-CFLAGS    := -g -mthumb -mno-thumb-interwork -mcpu=arm7tdmi -fno-inline -mlong-calls -march=armv4t -O3 -std=gnu99 -Isrc/include $(DEFINES)
+CFLAGS    := -g -mthumb -mno-thumb-interwork -mcpu=arm7tdmi -fno-inline -mlong-calls -march=armv4t -O3 -std=c99 -Wall -Isrc/include $(DEFINES)
 GRITFLAGS := -ftc -fa
 LDFLAGS   := -z muldefs
 BLDPATH   := object
 .PHONY: rom
 rom: main.asm $(MAIN_OBJ)
 	$(ARS) $<
-	$(NM) $(BLDPATH)/linked.o -n -g --defined-only | \
+	$(NM) $(BLDPATH)/linked.o -l -n -g --defined-only | \
 		sed -e '{s/^/0x/g};{/.*\sA\s.*/d};{s/\sT\s/ /g}' > $(OUTPATH)/__symbols.sym
 	@echo "*** SUCCESSFULLY BUILT PROJECT ***"
 	

nbproject/configurations.xml

         <df name="battle_engine">
           <df name="scripts">
             <in>hazards.S</in>
+            <in>test.S</in>
           </df>
           <in>battle_abilities.c</in>
           <in>battle_help.c</in>
           <in>battle_initiative.c</in>
-          <in>battle_initiative.h</in>
           <in>battle_switch_in_hook.S</in>
+          <in>battle_test.c</in>
           <in>custom_structs_malloc.c</in>
           <in>custom_structs_malloc_hook.S</in>
           <in>entry_hazards.c</in>
         </df>
         <df name="include">
           <in>battle_abilities.h</in>
+          <in>battle_initiative.h</in>
+          <in>battle_test.h</in>
           <in>debug.h</in>
           <in>item_effects.h</in>
           <in>items.h</in>
             tool="0"
             flavor2="0">
       </item>
-      <item path="src/battle_engine/battle_initiative.h"
-            ex="false"
-            tool="3"
-            flavor2="0">
-      </item>
       <item path="src/battle_engine/battle_switch_in_hook.S"
             ex="false"
             tool="4"
             flavor2="0">
       </item>
+      <item path="src/battle_engine/battle_test.c" ex="false" tool="0" flavor2="0">
+      </item>
       <item path="src/battle_engine/custom_structs_malloc.c"
             ex="false"
             tool="0"
             tool="4"
             flavor2="0">
       </item>
+      <item path="src/battle_engine/scripts/test.S" ex="false" tool="4" flavor2="0">
+      </item>
       <item path="src/debug/debug.c" ex="false" tool="0" flavor2="0">
       </item>
       <item path="src/encode/crc32.c" ex="false" tool="0" flavor2="0">
       </item>
       <item path="src/include/battle_abilities.h" ex="false" tool="3" flavor2="0">
       </item>
+      <item path="src/include/battle_initiative.h" ex="false" tool="3" flavor2="0">
+      </item>
+      <item path="src/include/battle_test.h" ex="false" tool="3" flavor2="0">
+      </item>
       <item path="src/include/debug.h" ex="false" tool="3" flavor2="0">
       </item>
       <item path="src/include/item_effects.h" ex="false" tool="3" flavor2="0">

nbproject/private/configurations.xml

         <df name="battle_engine">
           <df name="scripts">
             <in>hazards.S</in>
+            <in>test.S</in>
           </df>
           <in>battle_abilities.c</in>
           <in>battle_help.c</in>
-          <in>battle_help.h</in>
           <in>battle_initiative.c</in>
-          <in>battle_initiative.h</in>
           <in>battle_switch_in_hook.S</in>
+          <in>battle_test.c</in>
           <in>custom_structs_malloc.c</in>
           <in>custom_structs_malloc.h</in>
           <in>custom_structs_malloc_hook.S</in>
           <in>attack_names.h</in>
           <in>battle.h</in>
           <in>battle_abilities.h</in>
+          <in>battle_help.h</in>
+          <in>battle_initiative.h</in>
           <in>battle_locations.h</in>
           <in>battle_script.h</in>
           <in>battle_structs.h</in>
+          <in>battle_test.h</in>
           <in>bpre.h</in>
           <in>callback.h</in>
           <in>config.h</in>
         <gdb_interceptlist>
           <gdbinterceptoptions gdb_all="false" gdb_unhandled="true" gdb_unexpected="true"/>
         </gdb_interceptlist>
-        <gdb_signals>
-        </gdb_signals>
         <gdb_options>
           <DebugOptions>
             <option name="gdb_init_file"

src/battle_engine/battle_help.c

-#include "battle_help.h"
+#include <battle_help.h>
 
 //from kds emerald battle engine upgrade
 

src/battle_engine/battle_initiative.c

-#include "battle_initiative.h"
+#include <battle_initiative.h>
+#include <battle.h>
+#include <battle_help.h>
+#include <bpre.h>
 struct move_info move_table[1024];
 
 u16 get_speed(u8 bank) {
                 speed <<= 1;
             break;
     }
-    if(has_ability_effect(bank, 0, 1))
-    {
+    if (has_ability_effect(bank, 0, 1)) {
         u8 weather_effects = weather_abilities_effect();
-        switch (battle_participants[bank].ability_id)
-        {
+        switch (battle_participants[bank].ability_id) {
             case ABILITY_CHLOROPHYLL:
-                if(weather_effects && (battle_weather.flags.harsh_sun || battle_weather.flags.permament_sun || battle_weather.flags.sun))
-                    speed *=2;
+                if (weather_effects && (battle_weather.flags.harsh_sun || battle_weather.flags.permament_sun || battle_weather.flags.sun))
+                    speed *= 2;
                 break;
             case ABILITY_SWIFT_SWIM:
-                if(weather_effects && (battle_weather.flags.rain || battle_weather.flags.downpour || battle_weather.flags.permament_rain || battle_weather.flags.heavy_rain))
-                    speed *=2;
+                if (weather_effects && (battle_weather.flags.rain || battle_weather.flags.downpour || battle_weather.flags.permament_rain || battle_weather.flags.heavy_rain))
+                    speed *= 2;
                 break;
             case ABILITY_SAND_RUSH:
-                if(weather_effects && (battle_weather.flags.sandstorm || battle_weather.flags.permament_sandstorm))
+                if (weather_effects && (battle_weather.flags.sandstorm || battle_weather.flags.permament_sandstorm))
                     speed *= 2;
                 break;
             case ABILITY_QUICK_FEET:
-                if(battle_participants[bank].status.flags.burn || battle_participants[bank].status.flags.poison || battle_participants[bank].status.flags.toxic_poison)
+                if (battle_participants[bank].status.flags.burn || battle_participants[bank].status.flags.poison || battle_participants[bank].status.flags.toxic_poison)
                     speed *= 2;
-                else if(battle_participants[bank].status.flags.paralysis)
+                else if (battle_participants[bank].status.flags.paralysis)
                     speed *= 4;
                 break;
         }
     }
-    if(battle_participants[bank].status.flags.paralysis)
+    if (battle_participants[bank].status.flags.paralysis)
         speed >= 2;
-    if(custom_battle_elements.ptr->side_affecting[get_side_from_bank(bank)].tailwind)
+    if (custom_battle_elements.ptr->side_affecting[get_side_from_bank(bank)].tailwind)
         speed *= 2;
     //TODO: unburden
     speed = (speed * stat_buffs[battle_participants[bank].spd_buff].dividend) / (stat_buffs[battle_participants[bank].spd_buff].divisor);
         //TODO: calculate speed
         u8 stall_one = has_ability(bank_one, ABILITY_STALL);
         u8 stall_two = has_ability(bank_two, ABILITY_STALL);
-        if(stall_one && !stall_two)
+        if (stall_one && !stall_two)
             result = TWO;
-        else if(stall_two && !stall_one)
+        else if (stall_two && !stall_one)
             result = ONE;
-        else
-        {
+        else {
             u16 speed_one = get_speed(bank_one);
             u16 speed_two = get_speed(bank_two);
-            if(custom_battle_elements.ptr->field_affecting.trick_room || (stall_one && stall_two))
-            {
+            if (custom_battle_elements.ptr->field_affecting.trick_room || (stall_one && stall_two)) {
                 u16 swap_speed = speed_one;
                 speed_one = speed_two;
                 speed_two = swap_speed;
             }
-            if(speed_one > speed_two)
+            if (speed_one > speed_two)
                 result = ONE;
-            else if(speed_two > speed_one)
+            else if (speed_two > speed_one)
                 result = TWO;
             else if (random() & 1)
                 result = ONE;

src/battle_engine/battle_test.c

+#include <battle_test.h>
+#include <battle.h>
+#include <bpre.h>
+#include <debug.h>
+#include <battle_initiative.h>
+
+void test_battle() {
+    print("Initiating Initiative Unit\nTest...\n");
+    u8 pass = true;
+    battle_participants[0].spd = 10;
+    battle_participants[1].spd = 11;
+    printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    print("testing (await TWO):");
+    enum init_enum result = get_first_to_strike(0, 1, 0);
+    if (result == TWO)
+        print("\xFE\x1 pass\n\xFE\x0");
+    else {
+        pass = false;
+        print("\xFE\x2 fail\n\xFE\x0");
+    }
+    battle_participants[0].spd = 12;
+    printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    print("testing (await ONE):");
+    result = get_first_to_strike(0, 1, 0);
+    if (result == ONE)
+        print("\xFE\x1 pass\n\xFE\x0");
+    else {
+        pass = false;
+        print("\xFE\x2 fail\n\xFE\x0");
+    }
+    battle_participants[0].spd = 10;
+    battle_participants[1].spd = 11;
+    printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+
+    //trick room
+    custom_battle_elements.ptr->field_affecting.trick_room = 1;
+    print("activating trick room...\n");
+    print("testing (await ONE):");
+    result = get_first_to_strike(0, 1, 0);
+    if (result == ONE)
+        print("\xFE\x1 pass\n\xFE\x0");
+    else {
+        pass = false;
+        print("\xFE\x2 fail\n\xFE\x0");
+    }
+
+    battle_participants[0].spd = 12;
+    printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    print("testing (await TWO):");
+    result = get_first_to_strike(0, 1, 0);
+    if (result == TWO)
+        print("\xFE\x1 pass\n\xFE\x0");
+    else {
+        pass = false;
+        print("\xFE\x2 fail\n\xFE\x0");
+    }
+    
+    wait_for_btn(1);
+    debug_clean();
+    
+    //stress
+    battle_participants[0].spd = 20;
+    battle_participants[1].spd = 20;
+    printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    int count_one = 0;
+    int count_two = 0;
+    for (int i = 0; i < 5000; ++i) {
+        result = get_first_to_strike(0, 1, 0);
+        if (result == ONE)
+            count_one++;
+        else
+            count_two++;
+    }
+    printf("tie stress test...\ncount \xFE\x1%d\xFE\x0 / ", count_one);
+    printf(" \xFE\x2%d\xFE\x0\n", count_two);
+    wait_for_btn(1);
+    debug_clean();
+    if(pass)
+        set_debug_background(0x3E0);
+    else
+        set_debug_background(0x31);
+    print("test complete\n(entering deadlock)");
+    while(true)
+    {}
+    return;
+}

src/battle_engine/custom_structs_malloc.c

 #include <battle.h>
 #include "custom_structs.h"
 #include "custom_structs_malloc.h"
+#include <debug.h>
 
 void malloc_battle_structs()
 {
 	custom_battle_elements.ptr=(struct custom_battle_struct*)malloc(sizeof(struct custom_battle_struct));
+        some_test();
 }
 
 void free_battle_structs()

src/battle_engine/entry_hazards.c

-#include "battle_help.h"
+#include <battle_help.h>
 #include <bpre.h>
 
 extern void* bs_stealth_rock;

src/battle_engine/scripts/test.S

+#include <battle_script.h>
+
+.align 2
+.thumb
+.text
+.global bs_test
+bs_test:
+    callasm some_test+1
+    end
+
+

src/debug/debug.c

 #include <bpre.h>
 #include <debug.h>
 #include <assets/ascii.h>
+#include <battle_test.h>
 
-void set_background(u16 color) {
+void set_debug_background(u16 color) {
     u16* bgc = (u16*) 0x020375f8;
     *bgc = color;
     return;
     } else if (superstate.multi_purpose_state_tracker == 1) {
         vram_decompress((void*) asciiTiles, (void*) 0x06000000);
         memcpy((void*) 0x020375F8, (void*) asciiPal, 0x60);
-        set_background(0x0000);
+        set_debug_background(0x0000);
         superstate.multi_purpose_state_tracker++;
     } else if (superstate.multi_purpose_state_tracker == 2) {
         init_unit_test();
     return;
 }
 
-void some_test() {
+u8 some_test() {
     set_callback2(debug_scene);
+    vblank_handler_set(debug_update);
     superstate.multi_purpose_state_tracker = 0;
 
-    return;
+    return 0;
 }
 
 void reset_scrolling_debug() {
+    lcd_io_set_func(0x12, 0x0);
     lcd_io_set_func(0x14, 0x0);
     lcd_io_set_func(0x16, 0x0);
     lcd_io_set_func(0x18, 0x0);
 }
 
 void init_unit_test() {
-    print("Hello\nWorld!\xFE\x2\nHello\nWorld!");
+    test_battle();
 }
 
 void print_string(u16 line, u16 row, u8 color, char* pBuf) {
 }
 
 void print(char* str) {
-    while(*str)
-    {
-        if(*str== '\n')
-        {
+    while (*str) {
+        if (*str == '\n') {
             print_memory->line++;
             print_memory->row = 0;
-        }
-        else if(*str == '\xFE')
-        {
+        } else if (*str == '\xFE') {
             str++;
             u8 c = *str;
-            if(c > 2)
+            if (c > 2)
                 c = 0;
-            print_memory->color=c;
+            print_memory->color = c;
+        } else {
+            print_character(print_memory->line, print_memory->row, *str, print_memory->color);
+            print_memory->row++;
         }
-        else
-        {
+        str++;
+    }
+    return;
+}
+
+void printf(char* str, int arg) {
+    while (*str) {
+        if (*str == '\n') {
+            print_memory->line++;
+            print_memory->row = 0;
+        } else if (*str == '\xFE') {
+            str++;
+            u8 c = *str;
+            if (c > 2)
+                c = 0;
+            print_memory->color = c;
+        } else if (*str == '%') {
+            str++;
+            if (*str == '%') {
+                print_character(print_memory->line, print_memory->row, *str, print_memory->color);
+                print_memory->row++;
+            } else if (*str == 'd') {
+                u32 len = dec_len(arg);
+                char temp[dec_len(len + 1)];
+                temp[len] = 0;
+                int_to_char(arg, temp);
+                print(temp);
+            } else if (*str == 'c') {
+                char print_char = (char) (arg);
+                print_character(print_memory->line, print_memory->row, print_char, print_memory->color);
+                print_memory->row++;
+            }
+        } else {
             print_character(print_memory->line, print_memory->row, *str, print_memory->color);
             print_memory->row++;
         }
         str++;
     }
+}
+
+void debug_clean() {
+    memset((void*) 0x0600C800, 0, 0x800);
+    print_memory->row = 0;
+    print_memory->line = 0;
+    print_memory->color = 0;
+    return;
+}
+
+void wait_for_btn(u16 field) {
+    volatile u16* control_io = (volatile u16*) (0x04000130);
+    while (*control_io & field) {
+    }
     return;
 }
 
     union t_map_entry map_entry;
     map_entry.entry.tile = char_to_byte(character);
     map_entry.entry.pal = color;
-    u16* ptr = (u16*) (0x0600C800 + (position * 2));
+    u16* ptr = (u16*) (0x0600c800 + (position * 2));
     *ptr = map_entry.short_map;
     return;
 }
         return character - 0x20;
     else
         return 3;
+}
+
+void debug_update() {
+    fade_update();
+    task_exec();
+    objc_exec();
+    obj_sync();
+    gpu_pal_upload();
+    gpu_sprites_upload();
+}
+
+void int_to_char(u32 i, char* ref) {
+    if (i == 0) {
+        ref[0] = '0';
+        return;
+    }
+    u32 len = dec_len(i);
+    while (i > 0) {
+
+        ref[len - 1] = '0' + (__aeabi_uidivmod(i, 10));
+        i /= 10;
+        len--;
+    }
+
+    return;
+}
+
+u32 power(u32 n, u32 power) {
+    u32 out = 1;
+    for (int i = 0; i < power; ++i) {
+        out = out * n;
+    }
+    return out;
+}
+
+u32 dec_len(u32 i) {
+    u32 len = 1;
+    while ((i /= 10) > 0) {
+        len++;
+    }
+    return len;
 }

src/battle_engine/battle_initiative.h → src/include/battle_initiative.h

 #ifndef BATTLE_INITIATIVE_H
 #define BATTLE_INITIATIVE_H
 
-#include <battle.h>
-#include "battle_help.h"
-#include <bpre.h>
+#include <types.h>
 
 enum init_enum {ONE, TWO, TIE};
 

src/include/battle_test.h

+#ifndef BATTLE_TEST_H
+#define BATTLE_TEST_H
+
+void test_battle();
+
+#endif /* BATTLE_TEST_H */
+

src/include/bpre.h

 #include <callback.h>
 #include <config.h>
 
+u32 __aeabi_uidivmod(u32 a, u32 b);
 u16 *var_access(int index);
 u8 flag_check(int flag);
 void clear_flag(u16 flag);
 u16 random();
 void* malloc(int size);
 void free(void* address);
-void* memcpy (void * destination, const void* source, u32 num);
+void* memcpy (void * destination, const void* source, size_t num);
+void* memset (void* dst, int value, size_t size);
 
 //debug
 void agbprintf(const char* pBuf, ...);

src/include/debug.h

 
 static struct print_engine* print_memory = (struct print_engine*)(0x0203FFF0);
 
-void some_test();
+void set_debug_background(u16 color);
+void debug_clean();
+void wait_for_btn(u16 field);
+void int_to_char(u32 i, char* ref);
+u32 dec_len(u32 i);
+void debug_update();
+u8 some_test();
 void reset_scrolling_debug();
 void init_unit_test();
 void debug_scene();
 u8 char_to_byte(char character);
 void print_character(u16 line, u16 row, char character, u8 color);
 void print_string(u16 line, u16 row, u8 color, char* pBuf);
+void print(char* str);
+u32 power(u32 n, u32 power);
+void printf(char* str, int arg);
 
 #endif /* DEBUG_H */
 

src/include/types.h

 typedef     float                   f32;
 typedef     double                  f64;
 
+typedef     unsigned int            size_t;
+
 #define true 1
 #define false 0