and more refractoring, documentation

src/battle_engine/battle_test.c

 #define TEST_AMOUNT 10000
 
 void test_speed() {
-    print("Initiating Initiative Unit\nTest...\n");
+    debug_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):");
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    debug_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");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_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):");
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    debug_print("testing (await ONE):");
     result = get_first_to_strike(0, 1, 0);
     if (result == ONE)
-        print("\xFE\x1 pass\n\xFE\x0");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_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);
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_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):");
+    debug_print("activating trick room...\n");
+    debug_print("testing (await ONE):");
     result = get_first_to_strike(0, 1, 0);
     if (result == ONE)
-        print("\xFE\x1 pass\n\xFE\x0");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_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):");
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    debug_print("testing (await TWO):");
     result = get_first_to_strike(0, 1, 0);
     if (result == TWO)
-        print("\xFE\x1 pass\n\xFE\x0");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_print("\xFE\x2 fail\n\xFE\x0");
     }
 
     battle_participants[1].ability_id = ABILITY_STALL;
-    print("stall test (+tr): ");
+    debug_print("stall test (+tr): ");
     result = get_first_to_strike(0, 1, 0);
     if (result == ONE)
-        print("\xFE\x1 pass\n\xFE\x0");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_print("\xFE\x2 fail\n\xFE\x0");
     }
     custom_battle_elements.ptr->field_affecting.trick_room = 0;
-    print("stall test (-tr): ");
+    debug_print("stall test (-tr): ");
     
     result = get_first_to_strike(0, 1, 0);
     if (result == ONE)
-        print("\xFE\x1 pass\n\xFE\x0");
+        debug_print("\xFE\x1 pass\n\xFE\x0");
     else {
         pass = false;
-        print("\xFE\x2 fail\n\xFE\x0");
+        debug_print("\xFE\x2 fail\n\xFE\x0");
     }
 
     battle_participants[1].ability_id = 0;
 
-    print("\nPRESS A TO CONTINUE...");
-    wait_for_btn(1);
+    debug_print("\nPRESS A TO CONTINUE...");
+    debug_wait_for_btn(1);
     debug_clean();
 
-    print("speed value tests...\n");
+    debug_print("speed value tests...\n");
     battle_participants[0].spd = 75;
     battle_participants[1].spd = 60;
-    printf("bank_one.spd: %d\n", battle_participants[0].spd);
-    printf("bank_two.spd: %d\n", battle_participants[1].spd);
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_printf("bank_two.spd: %d\n", battle_participants[1].spd);
     u16 speed_one = get_speed(0);
     u16 speed_two = get_speed(1);
-    printf("unaffected speed: %d", speed_one);
-    printf(": %d", speed_two);
+    debug_printf("unaffected speed: %d", speed_one);
+    debug_printf(": %d", speed_two);
     if (speed_one == 75 && speed_two == 60) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
     battle_participants[0].status.flags.paralysis = 1;
     battle_participants[1].status.flags.paralysis = 1;
     speed_one = get_speed(0);
     speed_two = get_speed(1);
-    printf("para speed: %d", speed_one);
-    printf(": %d", speed_two);
+    debug_printf("para speed: %d", speed_one);
+    debug_printf(": %d", speed_two);
 
     if (speed_one == 18 && speed_two == 15) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
     battle_participants[0].spd_buff = 12;
     speed_one = get_speed(0);
     speed_two = get_speed(1);
 
-    printf("para/speed+6: %d", speed_one);
-    printf(": %d", speed_two);
+    debug_printf("para/speed+6: %d", speed_one);
+    debug_printf(": %d", speed_two);
 
     if (speed_one == 75 && speed_two == 60) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
     battle_participants[0].status.flags.paralysis = 0;
     speed_one = get_speed(0);
     speed_two = get_speed(1);
 
-    printf("speed+6: %d", speed_one);
-    printf(": %d", speed_two);
+    debug_printf("speed+6: %d", speed_one);
+    debug_printf(": %d", speed_two);
 
     if (speed_one == 300 && speed_two == 240) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
 
     speed_one = get_speed(0);
     speed_two = get_speed(1);
 
-    printf("speed-3: %d", speed_one);
-    printf(": %d", speed_two);
+    debug_printf("speed-3: %d", speed_one);
+    debug_printf(": %d", speed_two);
 
     if (speed_one == 30 && speed_two == 24) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
 
     battle_participants[0].spd_buff = 6;
     battle_participants[1].spd_buff = 6;
-    print("activating chemtrails...\n");
+    debug_print("activating chemtrails...\n");
     battle_weather.flags.rain = 1;
     battle_weather.flags.sun = 1;
     battle_weather.flags.sandstorm = 1;
     speed_one = get_speed(0);
     if (speed_one != 150)
         weather_pass = false;
-    print("weather test:");
-    print(weather_pass ? "\xFE\x1 pass\xFE\x0\n" : "\xFE\x2 fail\xFE\x0\n");
+    debug_print("weather test:");
+    debug_print(weather_pass ? "\xFE\x1 pass\xFE\x0\n" : "\xFE\x2 fail\xFE\x0\n");
     if (!weather_pass)
         pass = false;
 
-    print("tailwind + weather: ");
+    debug_print("tailwind + weather: ");
     custom_battle_elements.ptr->side_affecting[0].tailwind = 1;
     custom_battle_elements.ptr->side_affecting[0].tailwind_bank = 0;
     custom_battle_elements.ptr->side_affecting[1].tailwind = 1;
     speed_two = get_speed(1);
 
     if (speed_one == 300 && speed_two == 240) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
     custom_battle_elements.ptr->side_affecting[0].tailwind = 0;
     battle_weather.flags.sandstorm = 0;
 
 
-    print("quick feet: ");
+    debug_print("quick feet: ");
     battle_participants[0].ability_id = ABILITY_QUICK_FEET;
     battle_participants[1].ability_id = ABILITY_QUICK_FEET;
     battle_participants[0].status.flags.paralysis = 1;
         quick_feet_pass = false;
 
     if (quick_feet_pass) {
-        print(" \xFE\x1pass\xFE\x0\n");
+        debug_print(" \xFE\x1pass\xFE\x0\n");
     } else {
-        print("\xFE\x02 fail\xFE\x0\n");
+        debug_print("\xFE\x02 fail\xFE\x0\n");
         pass = false;
     }
     battle_participants[0].status.flags.sleep = 0;
     battle_participants[0].ability_id = 0;
     battle_participants[1].ability_id = 0;
-    wait_for_btn(8);
+    debug_wait_for_btn(8);
     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);
+    debug_printf("bank_one.spd: %d\n", battle_participants[0].spd);
+    debug_printf("bank_two.spd: %d\n", battle_participants[1].spd);
     int count_one = 0;
     int count_two = 0;
     for (int i = 0; i < TEST_AMOUNT; ++i) {
             count_two++;
     }
 
-    printf("tie stress test...\ncount \xFE\x1%d\xFE\x0 / ", count_one);
-    printf(" \xFE\x2%d\xFE\x0\n", count_two);
+    debug_printf("tie stress test...\ncount \xFE\x1%d\xFE\x0 / ", count_one);
+    debug_printf(" \xFE\x2%d\xFE\x0\n", count_two);
     int ratio_one = (count_one * 100) / TEST_AMOUNT;
     int ratio_two = (count_two * 100) / TEST_AMOUNT;
-    printf("%d%% / ", ratio_one);
-    printf("%d%%\n", ratio_two);
-    print("\nPRESS A TO CONTINUE...");
+    debug_printf("%d%% / ", ratio_one);
+    debug_printf("%d%%\n", ratio_two);
+    debug_print("\nPRESS A TO CONTINUE...");
 
-    wait_for_btn(1);
+    debug_wait_for_btn(1);
     debug_clean();
 
 
     if (pass)
-        set_debug_background(0x3E0);
+        debug_set_bg(0x3E0);
     else
-        set_debug_background(0x1F);
-    print("test complete\n(entering deadlock)");
+        debug_set_bg(0x1F);
+    debug_print("test complete\n(entering deadlock)");
     while (true) {
     }
     return;

src/battle_engine/scripts/test.S

 .text
 .global bs_test
 bs_test:
-    callasm some_test+1
+    callasm debug_some_test+1
     end
 
 

src/debug/debug.c

-#include <bpre.h>
+/****************************************************************************
+ * Copyright (C) 2015-2016 by the SotS Team                                 *
+ *                                                                          *
+ * This file is part of Sovereign of the Skies.                             *
+ *                                                                          *
+ *   Sovereign of the Skies is free software: you can redistribute it       *
+ *   and/or modify it                                                       *
+ *   under the terms of the GNU Lesser General Public License as published  *
+ *   by the Free Software Foundation, either version 3 of the License, or   *
+ *   (at your option) any later version provided you include a copy of the  *
+ *   licence and this header.                                               *
+ *                                                                          *
+ *   Sovereign of the Skies is distributed in the hope that it will be      *
+ *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+ *   GNU Lesser General Public License for more details.                    *
+ *                                                                          *
+ *   You should have received a copy of the GNU Lesser General Public       *
+ *   License along with Sovereign of the Skies.                             *
+ *   If not, see <http://www.gnu.org/licenses/>.                            *
+ ****************************************************************************/
+
+/**
+ * @file debug.c
+ * @author Sturmvogel
+ * @date 15 dec 2016
+ * @brief Operate with the sots debug engine, very temporary
+ */
+
+/* === INCLUDE === */
+
+#include <types.h>
+#include <callback.h>
+#include <lcd.h>
 #include <debug.h>
+#include <memory.h>
 #include <assets/ascii.h>
 #include <battle_test.h>
+#include <math.h>
+#include <fade.h>
+
+/* === STATICS === */
+
+static struct print_engine* print_memory = (struct print_engine*)(0x0203FFF0);
+
+/* === PROTOTYPES === */
+
+/**
+ * @brief set bg color
+ * @param color color to set bg to
+ */
+void debug_set_bg(u16 color);
+
+/**
+ * @brief clean debug screen from any text and reset cursor
+ */
+void debug_clean();
+
+/**
+ * @brief wait for button press
+ * @param field bitfield to specify buttom combination
+ */
+void debug_wait_for_btn(u16 field);
+
+/**
+ * @brief convert int to char
+ * @param i integer
+ * @param ref buffer to output to
+ */
+void debug_int_to_char(u32 i, char* ref);
+
+/**
+ * @get length of integer
+ * @param i integer
+ * @return length
+ */
+u32 debug_dec_len(u32 i);
+
+/**
+ * @brief update debug environment
+ */
+void debug_update();
+
+/**
+ * @brief reset scrolling (from overworld e.g.)
+ */
+void debug_reset_scrolling();
+
+/**
+ * @brief start a unit test function
+ */
+void debug_init_unit_test();
+
+/**
+ * @brief handle for the debug scene
+ */
+void debug_scene();
+
+/**
+ * @brief convert character to byte
+ * @param character character
+ * @return byte from character
+ */
+u8 char_to_byte(char character);
+
+/**
+ * @brief print a character on the debug environment
+ * @param line line to print to
+ * @param row row to print to
+ * @param character character to print
+ * @param color color to print in
+ */
+void debug_print_char(u16 line, u16 row, char character, u8 color);
+
+/**
+ * @brief print a string to the debug environment
+ * @param line line to print to
+ * @param row row to start
+ * @param color color to print in
+ * @param pBuf string buffer to print (null terminated)
+ */
+void debug_print_string(u16 line, u16 row, u8 color, char* pBuf);
+
+/**
+ * @brief print string onto debug environment at current position with parsing
+ * @param str string to print
+ */
+void debug_print(char* str);
+
+/**
+ * @brief build power
+ * @param n integer to power
+ * @param power exponent
+ * @return n^power
+ */
+u32 debug_power(u32 n, u32 power);
+
+/**
+ * @brief print in format to debug environment
+ * @param str string with format
+ * @param arg argument to print (only one, not an array)
+ */
+void debug_printf(char* str, int arg);
 
-void set_debug_background(u16 color) {
+/**
+ * @brief set bg color of debug environment
+ * @param color color to set to
+ */
+void debug_set_bg(u16 color) {
     u16* bgc = (u16*) 0x020375f8;
     *bgc = color;
     return;
 }
 
+/* === IMPLEMENTATIONS === */
 void debug_scene() {
     if (superstate.multi_purpose_state_tracker == 0) {
         print_memory->row = 0;
         gpu_bg_show(3);
 
         gpu_sync_bg_visibility_and_mode();
-        reset_scrolling_debug();
+        debug_reset_scrolling();
         obj_delete_all();
         memset((void*) 0x06000000, 0, 0x17fe0);
         memset((void*) 0x020375F8, 0, 0x400);
     } else if (superstate.multi_purpose_state_tracker == 1) {
         vram_decompress((void*) asciiTiles, (void*) 0x06000000);
         memcpy((void*) 0x020375F8, (void*) asciiPal, 0x60);
-        set_debug_background(0x0000);
+        debug_set_bg(0x0000);
         superstate.multi_purpose_state_tracker++;
     } else if (superstate.multi_purpose_state_tracker == 2) {
-        init_unit_test();
+        debug_init_unit_test();
         superstate.multi_purpose_state_tracker++;
     }
     return;
 }
 
-u8 some_test() {
+u8 debug_some_test() {
     set_callback2(debug_scene);
     vblank_handler_set(debug_update);
     superstate.multi_purpose_state_tracker = 0;
     return 0;
 }
 
-void reset_scrolling_debug() {
+void debug_reset_scrolling() {
     lcd_io_set_func(0x12, 0x0);
     lcd_io_set_func(0x14, 0x0);
     lcd_io_set_func(0x16, 0x0);
     return;
 }
 
-void init_unit_test() {
+void debug_init_unit_test() {
     test_speed();
 }
 
-void print_string(u16 line, u16 row, u8 color, char* pBuf) {
+void debug_print_string(u16 line, u16 row, u8 color, char* pBuf) {
     while (*pBuf) {
-        print_character(line, row++, *pBuf++, color);
+        debug_print_char(line, row++, *pBuf++, color);
     }
     return;
 }
 
-void print(char* str) {
+void debug_print(char* str) {
     while (*str) {
         if (*str == '\n') {
             print_memory->line++;
                 c = 0;
             print_memory->color = c;
         } else {
-            print_character(print_memory->line, print_memory->row, *str, print_memory->color);
+            debug_print_char(print_memory->line, print_memory->row, *str, print_memory->color);
             print_memory->row++;
         }
         str++;
     return;
 }
 
-void printf(char* str, int arg) {
+void debug_printf(char* str, int arg) {
     while (*str) {
         if (*str == '\n') {
             print_memory->line++;
         } else if (*str == '%') {
             str++;
             if (*str == '%') {
-                print_character(print_memory->line, print_memory->row, *str, print_memory->color);
+                debug_print_char(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)];
+                u32 len = debug_dec_len(arg);
+                char temp[debug_dec_len(len + 1)];
                 temp[len] = 0;
-                int_to_char(arg, temp);
-                print(temp);
+                debug_int_to_char(arg, temp);
+                debug_print(temp);
             } else if (*str == 'c') {
                 char print_char = (char) (arg);
-                print_character(print_memory->line, print_memory->row, print_char, print_memory->color);
+                debug_print_char(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);
+            debug_print_char(print_memory->line, print_memory->row, *str, print_memory->color);
             print_memory->row++;
         }
         str++;
     return;
 }
 
-void wait_for_btn(u16 field) {
+void debug_wait_for_btn(u16 field) {
     volatile u16* control_io = (volatile u16*) (0x04000130);
     while (*control_io & field) {
     }
     return;
 }
 
-void print_character(u16 line, u16 row, char character, u8 color) {
+void debug_print_char(u16 line, u16 row, char character, u8 color) {
     if (color > 2)
         color = 0;
     u16 position = (32 * line) + row;
     obj_gpu_sprites_upload();
 }
 
-void int_to_char(u32 i, char* ref) {
+void debug_int_to_char(u32 i, char* ref) {
     if (i == 0) {
         ref[0] = '0';
         return;
     }
-    u32 len = dec_len(i);
+    u32 len = debug_dec_len(i);
     while (i > 0) {
 
         ref[len - 1] = '0' + (__aeabi_uidivmod(i, 10));
     return;
 }
 
-u32 power(u32 n, u32 power) {
+u32 debug_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 debug_dec_len(u32 i) {
     u32 len = 1;
     while ((i /= 10) > 0) {
         len++;

src/include/debug.h

     u8 color;
 };
 
-static struct print_engine* print_memory = (struct print_engine*)(0x0203FFF0);
-
-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);
+u8 debug_some_test();
 
 #endif /* DEBUG_H */
 

src/specials/custom_specials.c

 	met_play,
 	sp_move_camera,
 	init_script,
-        some_test,
+        debug_some_test,
         dns_switch,
 };