day and night core

bpre.sym

 vblank_handler_set = 0x080006F5;
 malloc = 0x08002BB0|1;
 free = 0x08002BC4|1;
+memmove = 0x081E8E60|1;
 memset = 0x081E5ED8|1;
 memcpy = 0x081E5E78|1;
 template_instanciate_forward_search = 0x08006F8D;
 calc_circle = 0x0807EE2C|1;
 random = 0x08044EC8|1;
 
+palette_unfaded_buffer = 0x020371F8;
+palette_faded_buffer = 0x020375F8;
+current_mapheader = 0x02036DFC;
+
+blockset_load_palette_to_gpu = 0x080599C8|1;
+npc_pal_idx_for_given_tag = 0x0805F5A0|1;
+gpu_pal_apply = 0x080703EC|1;
+tint_palette = 0x08083598|1;
+tint_filter = 0x02036E28;
+gpu_pal_tags_index_of = 0x080089E8|1;
+
 vram_decompress = 0x081E3B6C|1;
 pal_decompress_slice_to_faded_and_unfaded = 0x080703A8|1;
 gpu_tile_obj_decompress_alloc_tag_and_upload = 0x0800F035;

data/overworld/overworld_pal_table.S

 .word ow_00000Pal
 .byte 254, 19, 0, 0
 .word ow_00000Pal
-.byte 255, 19, 0, 0
+.byte 255, 19, 0, 0
+
+.global npc_palettes
+npc_palettes:
+    .word ow_pal_table

main.asm

 .include "patches/pokemon_data/pokemon_icons.asm"
 .include "patches/pokemon_data/pokemon_habitats.asm"
 
+.include "patches/dns/core.asm"
+
 .include "patches/overworlds/overworld.asm"
 
 .include "patches/battle_engine/malloc.asm"

nbproject/configurations.xml

           <in>battle_engine.asm</in>
           <in>malloc.asm</in>
         </df>
+        <df name="dns">
+          <in>core.asm</in>
+        </df>
         <df name="items">
           <in>item_limits.asm</in>
           <in>item_routines.asm</in>
         <df name="debug">
           <in>debug.c</in>
         </df>
+        <df name="dns">
+          <in>dns_core.c</in>
+        </df>
         <df name="encode">
           <in>crc32.c</in>
         </df>
       </item>
       <item path="patches/disable_cry_table_blocks.s" ex="false" tool="4" flavor2="0">
       </item>
+      <item path="patches/dns/core.asm" ex="false" tool="4" flavor2="0">
+      </item>
       <item path="patches/dynamic_overworld_hooks.asm"
             ex="false"
             tool="4"
       </item>
       <item path="src/debug/debug.c" ex="false" tool="0" flavor2="0">
       </item>
+      <item path="src/dns/dns_core.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">

nbproject/private/configurations.xml

           </df>
           <df name="debug">
           </df>
+          <df name="dns">
+          </df>
           <df name="encode">
           </df>
           <df name="include">
           <in>battle_engine.asm</in>
           <in>malloc.asm</in>
         </df>
+        <df name="dns">
+          <in>core.asm</in>
+        </df>
         <df name="items">
           <in>item_limits.asm</in>
           <in>item_routines.asm</in>
         <df name="debug">
           <in>debug.c</in>
         </df>
+        <df name="dns">
+          <in>dns_core.c</in>
+        </df>
         <df name="encode">
           <in>crc32.c</in>
         </df>

patches/dns/core.asm

+.org 0x08059A90
+    ldr r3, =mapdata_load_palette_one+1
+    bx r3
+    .pool
+
+.org 0x08059AA0
+    ldr r3, =mapdata_load_palette_two+1
+    bx r3
+    .pool
+
+.org 0x0805F538
+    ldr r2, =pal_patch_for_npc+1
+    bx r2
+    .pool

src/dns/dns_core.c

+#include <bpre.h>
+
+enum time_type {
+    DAY,
+    NIGHT
+};
+
+enum map_type {
+    UNK_00,
+    VILLAGE,
+    CITY,
+    ROUTE,
+    CELLAR,
+    UNDERWATER,
+    UNK_07,
+    UNK_08,
+    INSIDE,
+    SECRET_BASE
+};
+
+struct mapdata_header {
+    u32 width;
+    u32 height;
+    void* border;
+    void* data;
+    void* blockset_one;
+    void* blockset_two;
+    u8 border_width;
+    u8 border_height;
+    u16 unknown;
+};
+
+struct mapheader {
+    struct mapdata_header* data_header;
+    void* events;
+    void* scripts;
+    void* connections;
+    u16 music;
+    u16 mapindex;
+    u8 name;
+    u8 cave;
+    u8 weather;
+    enum map_type maptype;
+    u8 field18;
+    u8 escape_rope;
+    u8 showname;
+    u8 battletype;
+};
+
+extern struct mapheader current_mapheader;
+
+struct color_shade {
+    struct color color;
+    u8 alpha;
+};
+
+struct npc_palette {
+    struct color* palette;
+    u16 tag;
+    u16 fill;
+};
+
+struct pal_replace {
+    void* blockset;
+    u8 pal;
+    u8 index;
+    struct color color;
+};
+
+extern struct npc_palette* npc_palettes;
+extern volatile u8 tint_filter;
+void apply_shaders(u8 pal, u8 fade_copy);
+struct color alpha_blend(struct color a, struct color b, u8 alpha);
+extern void blockset_load_palette_to_gpu(void* blockset, u16 start, u16 len);
+extern void gpu_pal_apply(struct color* src, u16 dst, u16 len);
+extern void tint_palette(u8 pal_slot);
+extern u8 gpu_pal_tags_index_of(u16 pal_tag);
+void copy_unfaded(u8 slot);
+u8 is_current_map_dn_valid(enum map_type current_type);
+//care, this has to be manually patched to be u16
+extern u16 npc_pal_idx_for_given_tag(u16 tag);
+struct color_shade get_color_from_time(enum time_type current_time);
+enum time_type get_time_of_day();
+void apply_lighting(void* blockset, u8 copy);
+
+enum time_type get_time_of_day() {
+    return NIGHT;
+}
+
+static struct pal_replace lightmap[] = {
+    {(void*) 0x082D4AAC, 9, 10, {31, 31, 0}},
+    {(void*) 0x082D4AAC, 9, 9, {31, 31, 0}},
+    {(void*) 0x082D4AAC, 9, 8, {31, 31, 0}}
+};
+
+static struct color_shade color_shade_day = {
+    {0, 0, 0}, 255
+};
+static struct color_shade color_shade_night = {
+    {0, 6, 16}, 120
+};
+
+void mapdata_load_palette_two(struct mapdata_header* data_header) {
+    blockset_load_palette_to_gpu(data_header->blockset_two, 0x70, 0xC0);
+    for (u8 i = 7; i < 7 + 6; ++i)
+        apply_shaders(i, 0);
+    apply_lighting(data_header->blockset_two, 0);
+    return;
+}
+
+void mapdata_load_palette_one(struct mapdata_header* data_header) {
+    blockset_load_palette_to_gpu(data_header->blockset_one, 0x0, 0xE0);
+    for (u8 i = 0; i < 7; ++i)
+        apply_shaders(i, 0);
+    apply_lighting(data_header->blockset_one, 0);
+    return;
+}
+
+void apply_lighting(void* blockset, u8 copy) 
+{
+    for (int i = 0; i < (sizeof (lightmap) / sizeof (lightmap[0])); ++i) {
+        if (blockset == lightmap[i].blockset) {
+            palette_unfaded_buffer[lightmap[i].pal * 16 + lightmap[i].index] = lightmap[i].color;
+        }
+    }
+    return;
+}
+
+void apply_shaders(u8 pal, u8 fade_copy) {
+    if (tint_filter != 0)
+        return;
+    if (!is_current_map_dn_valid(current_mapheader.maptype))
+        return;
+    for (int i = pal * 16; i < (pal * 16) + 16; ++i) {
+        struct color_shade current_shade = get_color_from_time(get_time_of_day());
+        palette_unfaded_buffer[i] = alpha_blend(palette_unfaded_buffer[i], current_shade.color, current_shade.alpha);
+    }
+    if (fade_copy)
+        copy_unfaded(pal);
+}
+
+void copy_unfaded(u8 slot) {
+    for (int i = slot * 16; i < (slot * 16) + 16; ++i) {
+        palette_faded_buffer[i] = palette_unfaded_buffer[i];
+    }
+}
+
+u8 is_current_map_dn_valid(enum map_type current_type) {
+    switch (current_type) {
+        case VILLAGE:
+        case CITY:
+        case ROUTE:
+            return 1;
+        default:
+            return 0;
+    }
+    return 0;
+}
+
+struct color_shade get_color_from_time(enum time_type current_time) {
+    switch (current_time) {
+        case NIGHT:
+            return color_shade_night;
+        case DAY:
+        default:
+            return color_shade_day;
+    }
+}
+
+struct color alpha_blend(struct color a, struct color b, u8 alpha) {
+    if (alpha == 255)
+        return a;
+    if (alpha == 0)
+        return b;
+    struct color output;
+    u8 inverted_alpha = 255 - alpha;
+
+    output.r = ((a.r * alpha + b.r * inverted_alpha) / 255);
+    output.b = ((a.b * alpha + b.b * inverted_alpha) / 255);
+    output.g = ((a.g * alpha + b.g * inverted_alpha) / 255);
+    return output;
+}
+
+void pal_patch_for_npc(u16 tag, u8 pal_slot) {
+    u16 npc_map_entry = npc_pal_idx_for_given_tag(tag);
+    gpu_pal_apply(npc_palettes[npc_map_entry].palette, (pal_slot + 16) * 16, 32);
+    tint_palette(pal_slot);
+    apply_shaders(pal_slot + 16, 1);
+}
+/*use fade in animation, load palettes according to current fade state*/

src/include/bpre.h

 #include <callback.h>
 #include <config.h>
 #include <pkmn_attributes.h>
+#include <battle_structs.h>
 
 u32 __aeabi_uidivmod(u32 a, u32 b);
 u16 *var_access(int index);

src/include/lcd.h

     u16 pal : 4;
 };
 
-union t_map_entry{
+union t_map_entry {
     u16 short_map;
     struct map_entry entry;
 };
 
+struct color {
+    u16 r : 5;
+    u16 g : 5;
+    u16 b : 5;
+};
+
 static struct bg_config standard_bg[4] = {
     {0, 0, 0x19, 0, 0, 0},
     {1, 1, 0x1A, 0, 0, 1},
 void gpu_pal_upload();
 void gpu_sprites_upload();
 
-void gpu_pal_obj_alloc_tag_and_apply(resource *pal);
+u8 gpu_pal_obj_alloc_tag_and_apply(resource *pal);
 void gpu_pal_free_by_tag(u16 tag);
 void gpu_tile_obj_free_by_tag(u16 tag);
 void obj_delete_and_free_tiles(object *obj);
 
 u16 lcd_io_get(u8 id);
 
-#define palette_unfaded_buffer ((void*)0x020371F8)
-#define palette_faded_buffer ((void*)0x020375F8)
+#define palette_faded_buffer ((struct color*) 0x020375F8)
+#define palette_unfaded_buffer ((struct color*) 0x020371F8)
 
 #endif