Bien sûr que l'asm est plus beau et permet de faire de meilleurs optimisations, ça c'est clair, mais là c'est juste un test en C très mal programmé pour voir ce qu'on peut éventuellement faire sur TI avec.

De façons objective je pense que le C reste plus facile à comprendre que l'asm pour des non initiés, mais c'est tout tongue
Y5X0

Bon j'ai un peu optimisé le code et ajouté de quoi calculer les dégâts. Ça finira peut être par faire un vrai jeu tongue

Ah et les ennemis sont moins agressifs maintenant.
test.c

#pragma string name C TEST

#include "..\dev\ti83p.h"
#include "..\dev\tilib.c"
#include "..\dev\gbalib2.c"

// Sprites
#include "..\dev\sprites\title.h"
#include "..\dev\sprites\map.h"
#include "..\dev\sprites\map_player.h"
#include "..\dev\sprites\tiles.h"
#include "..\dev\sprites\battle_player_up.h"
#include "..\dev\sprites\battle_player_up_attack.h"
#include "..\dev\sprites\battle_player_right.h"
#include "..\dev\sprites\battle_player_right_attack.h"
#include "..\dev\sprites\battle_player_down.h"
#include "..\dev\sprites\battle_player_down_attack.h"
#include "..\dev\sprites\battle_player_left.h"
#include "..\dev\sprites\battle_player_left_attack.h"
#include "..\dev\sprites\battle_enemy.h"
#include "..\dev\sprites\battle_enemy_attack.h"

// Map
extern char battle_map[];
#asm
._battle_map
	defb 4,4,4,4,4,4,4,3,3,3,3,3,4,4,4,4,4,4,4,4
	defb 4,0,0,0,0,0,0,1,3,3,3,4,4,0,1,1,1,0,0,4
	defb 4,0,0,0,0,0,0,2,1,3,3,1,1,0,2,2,2,0,0,4
	defb 4,0,0,4,4,4,0,0,2,3,0,2,2,0,0,0,0,0,0,4
	defb 4,0,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,4
	defb 4,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,0,0,0,0,0,0,2,0,0,0,0,0,0,1,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,4
	defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
	defb 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
#endasm

// Constants
#define START	0
#define LOAD	1
#define QUIT	2
#define BATTLE_MAP_WIDTH	20
#define BATTLE_MAP_HEIGHT	20
#define ATTACK_ANIM_DELAY	45

// Global variables
unsigned char i, j, key, player_x = 80, player_y = 59, player_hp = 10, battle_player_x = 10, battle_player_y = 18, *battle_player_direction = 0, camera_x, camera_y, x_temp, y_temp, x_temp2, y_temp2;

typedef struct {
  unsigned char x;
  unsigned char y;
  unsigned char *sprite;
  unsigned char hp;
} enemy_struct;

enemy_struct enemy[4];

extern char text_menu[];
#asm
._text_menu
	defm "Nouveau"&TL_NEWL&"Continuer"&TL_NEWL&"Quitter"&0
#endasm

extern char text_intro[];
#asm
._text_intro
	defm "Vous viviez tranquillement"&TL_NEWL&"en dehors de la soci"&0x96&"t"&0x96&TL_NEWL&"jusqu'au jour o"&0xaf&" vous"&TL_NEWL&"d"&0x96&"couvrez qu'on vous a"&TL_NEWL&"vol"&0x96&"..."&TL_BRK&TL_NEWL&"Vous d"&0x96&"cidez alors de"&TL_NEWL&"partir "&0x8f&" la recherche"&TL_NEWL&"des voleurs."&TL_BRK&0
#endasm

extern char text_castle[];
#asm
._text_castle
	defm "Garde :"&TL_NEWL&"Passez votre chemin sale"&TL_NEWL&"manant !"&TL_BRK&0
#endasm

extern char text_hp[];
#asm
._text_hp
	defm "PV :"&0
#endasm

//Functions prototypes
void main_menu(void);
char draw_cursor(unsigned char x, unsigned char y);
void handle_map(void);
void update_map(void);
char draw_player(unsigned char old_player_x, unsigned char old_player_y, unsigned char player_x, unsigned char player_y);
char check_place(unsigned char player_x, unsigned char player_y);
void battle(void);
void update_battle_screen(void);
char is_location_empty(unsigned char x, unsigned char y);
char hit(unsigned char damage, unsigned char x, unsigned char y);

//Functions
char main(){
	switch(main_menu()){
		case START:
			TL_rectangle_filled(0, 0, 96, 64, TL_RECT_FILL_BLACK);
			TL_rectangle_filled(1, 1, 94, 62, TL_RECT_FILL_WHITE);
			TL_text(2, 1, text_intro, TL_TEXT_TYPE, 5);
			handle_map();
			break;
		case LOAD:
			break;
	}
}

void main_menu(void){
	unsigned char cursor_y = 0;
	TL_large_sprite(5, 0, 11, 26, title);
	TL_rectangle_filled(28, 33, 40, 21, TL_RECT_FILL_BLACK);
	TL_rectangle_filled(29, 34, 38, 19, TL_RECT_FILL_WHITE);
	TL_text(34, 34, text_menu, TL_TEXT_NOTYPE, 0);
	TL_gbuf_to_lcd();
	key = 0;
	while(key != skey_2nd){
		draw_cursor(30, 34+cursor_y*6);
		key = TL_get_key();
		switch(key){
			case skey_up:
				if(cursor_y > START){
					TL_gbuf_to_lcd();
					cursor_y-=1;
				}
				break;
			case skey_down:
				if(cursor_y < QUIT){
					TL_gbuf_to_lcd();
					cursor_y+=1;
				}
				break;
		}
	}
	return cursor_y;
}

char draw_cursor(unsigned char x, unsigned char y){
#asm
	res textwrite,(iy+sgrflags)	; reset some flag to write only to the screen (not the graph buffer)
	ld hl,2
	add hl,sp
	ld b,(hl)	; get y from the parameters (stack)
	inc hl
	inc hl
	ld c,(hl)	; get x
	ld (pencol),bc
	ld a,5
	rst rbr_call
	defw _vputmap	; write the cursor character
	set textwrite,(iy+sgrflags)	; set the flag to write on the gbuf
#endasm
}

void handle_map(void){
	int move;
	update_map();
	key = 0;
	while(key != dkey_clear){
		key = TL_direct_input(dkey_group_1);
		switch(key){
			case dkey_up:
				if((TL_get_pixel(player_x, player_y-1) == TL_PIXEL_ON) || (TL_get_pixel(player_x+1, player_y-1) == TL_PIXEL_ON) || (TL_get_pixel(player_x+2, player_y-1) == TL_PIXEL_ON)){
					check_place(player_x+1, player_y-1);
					update_map();
				}else
					move = 1;
				break;
			case dkey_right:
				if((TL_get_pixel(player_x+3, player_y) == TL_PIXEL_ON) || (TL_get_pixel(player_x+3, player_y+1) == TL_PIXEL_ON) || (TL_get_pixel(player_x+3, player_y+2) == TL_PIXEL_ON)){
					check_place(player_x+3, player_y+1);
					update_map();
				}else
					move = 1;
				break;
			case dkey_left:
				if((TL_get_pixel(player_x-1, player_y) == TL_PIXEL_ON) || (TL_get_pixel(player_x-1, player_y+1) == TL_PIXEL_ON) || (TL_get_pixel(player_x-1, player_y+2) == TL_PIXEL_ON)){
					check_place(player_x-1, player_y+1);
					update_map();
				}else
					move = 1;
				break;
			case dkey_down:
				if((TL_get_pixel(player_x, player_y+3) == TL_PIXEL_ON) || (TL_get_pixel(player_x+1, player_y+3) == TL_PIXEL_ON) || (TL_get_pixel(player_x+2, player_y+3) == TL_PIXEL_ON)){
					check_place(player_x+1, player_y+3);
					update_map();
				}else
					move = 1;
				break;
		}
		if(move){
			draw_player(player_x, player_y, player_x += (key == dkey_right)-(key == dkey_left), player_y += (key == dkey_down)-(key == dkey_up));
			move = 0;
		}
		key = TL_direct_input(dkey_group_2);
	}
}

void update_map(void){
	C_bcall(_cleargbuf);
	TL_large_sprite(0, 0, 12, 64, map);
	TL_small_sprite(player_x, player_y, 3, map_player);
	TL_gbuf_to_lcd();
}

char draw_player(unsigned char old_player_x, unsigned char old_player_y, unsigned char player_x, unsigned char player_y){
	TL_small_sprite(old_player_x, old_player_y, 3, map_player);	// clear the player's sprite
	TL_small_sprite(player_x, player_y, 3, map_player);	// and re-draw it to its new place
	TL_gbuf_to_lcd();
}

char check_place(unsigned char player_x, unsigned char player_y){
	if(player_x > 5 && player_x < 19 && player_y > 4 && player_y < 31){
		// TOWER
	}else if(player_x > 25 && player_x < 58 && player_y > 3 && player_y < 36){
		// CASTLE
		TL_rectangle_filled(0, 37, 96, 27, TL_RECT_FILL_BLACK);
		TL_rectangle_filled(1, 38, 94, 25, TL_RECT_FILL_WHITE);
		TL_text(2, 38, text_castle, TL_TEXT_TYPE, 5);
	}else if(player_x > 57 && player_x < 95 && player_y > 0 && player_y < 25){
		// VOLCANO
	}else if(player_x > 29 && player_x < 49 && player_y > 39 && player_y < 54){
		// TOWN
	}else if(player_x > 59 && player_x < 95 && player_y > 32 && player_y < 63){
		if(player_x > 83 && player_x < 94 && player_y > 52 && player_y < 62){
			// HOUSE
		}else{
			// FOREST
			battle();
		}
	}
}

void battle(void){
	C_bcall(_cleargbuf);
	for(i = 0; i<4; i++){
generate_enemy_coordinates:
		x_temp = TL_random(BATTLE_MAP_WIDTH-2)+1;
		y_temp = TL_random(BATTLE_MAP_HEIGHT/2)+1;
		if(GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) > 0)
			goto generate_enemy_coordinates;
		enemy[i].x = x_temp;
		enemy[i].y = y_temp;
		enemy[i].sprite = battle_enemy;
		enemy[i].hp = 3;
	}
	battle_player_direction = battle_player_up;
	key = 0;
	while(key != skey_clear){
		if(battle_player_x < screen_w/16){
			camera_x = 0;
		}else if(battle_player_x > BATTLE_MAP_WIDTH-screen_w/16){
			camera_x = BATTLE_MAP_WIDTH-screen_w/8;
		}else{
			camera_x = battle_player_x-screen_w/16;
		}
		if(battle_player_y < screen_h/16){
			camera_y = 0;
		}else if(battle_player_y > BATTLE_MAP_HEIGHT-screen_h/18){
			camera_y = BATTLE_MAP_HEIGHT-screen_h/9;
		}else{
			camera_y = battle_player_y-screen_h/16;
		}
		update_battle_screen();
		key = TL_get_key();
		x_temp = battle_player_x-(key == skey_left)+(key == skey_right);
		y_temp = battle_player_y-(key == skey_up)+(key == skey_down);
		if(is_location_empty(x_temp, y_temp) && GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) == 0){
			battle_player_x = x_temp;
			battle_player_y = y_temp;
		}
		switch(key){
			case skey_up:
				battle_player_direction = battle_player_up;
				x_temp2 = battle_player_x;
				y_temp2 = battle_player_y-1;
				break;
			case skey_right:
				battle_player_direction = battle_player_right;
				x_temp2 = battle_player_x+1;
				y_temp2 = battle_player_y;
				break;
			case skey_left:
				battle_player_direction = battle_player_left;
				x_temp2 = battle_player_x-1;
				y_temp2 = battle_player_y;
				break;
			case skey_down:
				battle_player_direction = battle_player_down;
				x_temp2 = battle_player_x;
				y_temp2 = battle_player_y+1;
				break;
		}
		if(key == skey_2nd){
			battle_player_direction += 2*8;	// go to the attack sprite
			if(is_location_empty(x_temp2, y_temp2)){
				update_battle_screen();
				TL_delay(ATTACK_ANIM_DELAY);
			}else
				enemy[j].hp -= hit(TL_random(2), (enemy[j].x-GBA_scroll_x)*8, (enemy[j].y-GBA_scroll_y)*8);
			battle_player_direction -= 2*8;	// go back to the normal sprite
		}
		// IA
		for(i = 0; i<4; i++){
			if(enemy[i].hp > 0){
				if(TL_random(3)){	// 1 in 3 chance that the enemy goes anywhere
					if(TL_random(2))
						x_temp = TL_random(2)+enemy[i].x;
					else
						x_temp = -TL_random(2)+enemy[i].x;
					if(TL_random(2))
						y_temp = TL_random(2)+enemy[i].y;
					else
						y_temp = -TL_random(2)+enemy[i].y;
				}else{	// 2 in 3 chance that the enemy follow the player
					x_temp = enemy[i].x+(enemy[i].x < battle_player_x)-(enemy[i].x > battle_player_x);
					y_temp = enemy[i].y+(enemy[i].y < battle_player_y)-(enemy[i].y > battle_player_y);
				}
				if(TL_random(2))	// to prevent the enemy from moving two tiles at a time
					x_temp = enemy[i].x;
				else
					y_temp = enemy[i].y;
				if(is_location_empty(x_temp, y_temp) && GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) == 0){
					if(x_temp == battle_player_x && y_temp == battle_player_y){
						enemy[i].sprite = battle_enemy_attack;
						player_hp -= hit(TL_random(2), (battle_player_x-GBA_scroll_x)*8, (battle_player_y-GBA_scroll_y)*8);
						enemy[i].sprite = battle_enemy;
					}else{
						enemy[i].x = x_temp;
						enemy[i].y = y_temp;
					}
				}
			}
		}
	}
}

void update_battle_screen(void){
	C_bcall(_cleargbuf);
	GBA_init_map(camera_x, camera_y, 20, 20, tiles, battle_map);
	GBA_restore_map();
	GBA_draw_mask_sprite((battle_player_x-GBA_scroll_x)*8, (battle_player_y-GBA_scroll_y)*8, 1, 8, battle_player_direction, GBA_CLIP_SPRITE);
	for(j = 0; j<4; j++){
		if(enemy[j].hp > 0)
			GBA_draw_mask_sprite((enemy[j].x-GBA_scroll_x)*8, (enemy[j].y-GBA_scroll_y)*8, 1, 8, enemy[j].sprite, GBA_CLIP_SPRITE);
	}
#asm
	ld hl,gbuf+57*(96/8)
	ld de,gbuf+57*(96/8)+1
	ld (hl),@11111111
	ld bc,96/8
	ldir	; draw a horizontal line (x = 0, y = 57, w = 96, h = 1)
#endasm	
	TL_text(0, 58, text_hp, TL_TEXT_NOTYPE, 0);
	TL_put_val(12, 58, player_hp);
	TL_gbuf_to_lcd();
}

char is_location_empty(unsigned char x, unsigned char y){	// return 1 (TRUE) if there's no enemy at the location, otherwise return 0 (FALSE)
	for(j = 0; j<4; j++){
		if(enemy[j].x == x && enemy[j].y == y && enemy[j].hp > 0){
			return 0;
		}
	}
	return 1;
}

char hit(unsigned char damage, unsigned char x, unsigned char y){
	update_battle_screen();
	TL_rectangle_filled(x+2, y-7, 5, 7, TL_RECT_FILL_WHITE);
	TL_put_val(x+3, y-7, damage);
	TL_gbuf_to_lcd();
	TL_delay(ATTACK_ANIM_DELAY);
	return damage;
}
tilib.c

#include "..\dev\tilib.h"	// À MODIFIER EN : #include "tilib.h"

#if defined TL_ALL
#define TL_RANDOM
#define TL_DELAY
#define TL_SMALL_SPRITE
#define TL_LARGE_SPRITE
#define TL_GBUF_TO_LCD
#define TL_DIRECT_INPUT
#define TL_GET_KEY
#define TL_GET_PIXEL
#define TL_RECTANGLE_FILLED
#define TL_TEXT
#define TL_PUT_VAL
#endif

#if defined TL_RANDOM
#asm
TL_random_data:
	defw $0000
#endasm
char __FASTCALL__ TL_random(unsigned char max){
#asm
; Random routine by Joe Wingbermuehle
	ld b,l

TL_random:
	push hl
	push de
	ld hl,(TL_random_data)
	ld a,r
	ld d,a
	ld e,(hl)
	add hl,de
	add a,l
	xor h
	ld (TL_random_data),hl
	sbc hl,hl
	ld e,a
	ld d,h
TL_random_loop:
	add hl,de
	djnz TL_random_loop
	ld a,h
	pop de
	pop hl
	ld h,0
	ld l,a
#endasm
}
#endif

#if defined TL_DELAY
char __FASTCALL__ TL_delay(unsigned char delay){
#asm
	ld b,l
	ei

delay_loop:
	halt
	djnz delay_loop
	di
#endasm
}
#endif

#if defined TL_SMALL_SPRITE
char TL_small_sprite(unsigned char x, unsigned char y, unsigned char height, unsigned char *sprite){
#asm
; Sprite routine by Joe Wingbermuehle
	ld hl,2
	add hl,sp
	ld e,(hl)
	inc hl
	ld d,(hl)
	push de
	pop ix
	inc hl
	ld b,(hl)
	inc hl
	inc hl
	ld c,(hl)
	inc hl
	inc hl
	ld a,(hl)
	ld l,c

TL_small_sprite:
	ld e,l
	ld h,$00
	ld d,h
	add hl,de
	add hl,de
	add hl,hl
	add hl,hl
	ld e,a
	and $07
	ld c,a
	srl e
	srl e
	srl e
	add hl,de
	ld de,gbuf
	add hl,de

TL_small_sprite_loop_1:
	ld d,(ix)
	ld e,$00
	ld a,c
	or a
	jr z,TL_small_sprite_skip_1

TL_small_sprite_loop_2:
	srl d
	rr e
	dec a
	jr nz,TL_small_sprite_loop_2

TL_small_sprite_skip_1:
	ld a,(hl)
	xor d
	ld (hl),a
	inc hl
	ld a,(hl)
	xor e
	ld (hl),a
	ld de,$0b
	add hl,de
	inc ix
	djnz TL_small_sprite_loop_1
#endasm
}
#endif

#if defined TL_LARGE_SPRITE
char TL_large_sprite(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char *sprite){
#asm
; Sprite routine by Joe Wingbermuehle
	ld hl,2
	add hl,sp
	ld e,(hl)
	inc hl
	ld d,(hl)
	push de
	pop ix
	inc hl
	ld b,(hl)
	inc hl
	inc hl
	ld c,(hl)
	inc hl
	inc hl
	push hl
	inc hl
	inc hl
	ld a,(hl)
	pop hl
	ld l,(hl)

TL_large_sprite:
	di
	ex af,af
	ld a,c
	push af
	ex af,af
	ld e,l
	ld h,0
	ld d,h
	add hl,de
	add hl,de
	add hl,hl
	add hl,hl
	ld e,a
	and $07
	ld c,a
	srl e
	srl e
	srl e
	add hl,de
	ld de,gbuf
	add hl,de

TL_large_sprite_loop_1:
	push hl

TL_large_sprite_loop_2:
	ld d,(ix)
	ld e,0
	ld a,c
	or a
	jr z,TL_large_sprite_skip_1

TL_large_sprite_loop_3:
	srl d
	rr e
	dec a
	jr nz,TL_large_sprite_loop_3

TL_large_sprite_skip_1:
	ld a,(hl)
	xor d
	ld (hl),a
	inc hl
	ld a,(hl)
	xor e
	ld (hl),a
	inc ix
	ex af,af
	dec a
	push af
	ex af,af
	pop af
	jr nz,TL_large_sprite_loop_2
	pop hl
	pop af
	push af
	ex af,af
	ld de,$0c
	add hl,de
	djnz TL_large_sprite_loop_1
	pop af
#endasm
}
#endif

#if defined TL_GBUF_TO_LCD || defined TL_TEXT
void TL_gbuf_to_lcd(void){
#asm
; Fast copy routine by Joe Wingbermuehle
TL_gbuf_to_lcd:
	di
	ld a,$80
	out (plcdcmd),a
	ld hl,gbuf-12-(-(12*64)+1)
	ld a,$20
	ld c,a
	inc hl
	dec hl

TL_gbuf_to_lcd_again:
	ld b,64
	inc c
	ld de,-(12*64)+1
	out (plcdcmd),a
	add hl,de
	ld de,10

TL_gbuf_to_lcd_loop:
	add hl,de
	inc hl
	inc hl
	inc de
	ld a,(hl)
	out (plcddata),a
	dec de
	djnz TL_gbuf_to_lcd_loop
	ld a,c
	cp $2b+1
	jr nz,TL_gbuf_to_lcd_again
#endasm
}
#endif

#if defined TL_DIRECT_INPUT
char __FASTCALL__ TL_direct_input(unsigned char keygroup){
#asm
	ld a,l	; a = keygroup
	out (pkey),a
	in a,(pkey)
	ld h,0
	ld l,a		; hl is the return parameter
#endasm
}
#endif

#if defined TL_GET_KEY
void TL_get_key(void){
#asm
TL_get_key_loop:
	rst rbr_call
	defw _getcsc
	or a
	jr z,TL_get_key_loop
	ld h,0
	ld l,a
#endasm
}
#endif

#if defined TL_GET_PIXEL
char TL_get_pixel(unsigned char x, unsigned char y){
#asm
	ld hl,2
	add hl,sp
	ld e,(hl)	; e=y
	inc hl
	inc hl
	ld a,(hl)	; a=x
	ld l,e

TL_get_pixel:
	ld h,0
	ld d,h
	ld e,l
	add hl,hl
	add hl,de
	add hl,hl
	add hl,hl
	ld e,a
	srl e
	srl e
	srl e
	add hl,de
	ld de,plotsscreen
	add hl,de
	and 7
	ld b,a
	ld a,$80
	jr z,TL_test_pixel

TL_get_pixel_loop:
	rrca
	djnz TL_get_pixel_loop

TL_test_pixel:
	and (hl)
	or a
	ld hl,TL_PIXEL_ON
	jr nz,TL_get_pixel_quit
	ld hl,TL_PIXEL_OFF

TL_get_pixel_quit:
#endasm
}
#endif

#if defined TL_RECTANGLE_FILLED
char TL_rectangle_filled(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char color){
#asm
; Rectangle filled routine by chickendude
#define GBUF_LSB	$40
#define GBUF_MSB	$93
	ld hl,2
	add hl,sp
	push hl
	inc hl
	inc hl
	ld b,(hl)
	inc hl
	inc hl
	ld c,(hl)
	inc hl
	inc hl
	ld e,(hl)
	inc hl
	inc hl
	ld d,(hl)
	pop hl
	ld a,(hl)
	cp 2
	jr z,TL_rectangle_filled_xor
	or a
	jr nz,TL_rectangle_filled_solid

;b = height
;c = width
;d = starting x
;e = starting y

TL_rectangle_filled_white:
	call TL_rectangle_filled_solid

TL_rectangle_filled_xor:
	ld a,$ae		;xor (hl)
	jr TL_rectangle_filled_2

TL_rectangle_filled_solid:
	ld a,$b6		;or (hl)

TL_rectangle_filled_2:
	push de
	push bc
	ld (TL_rectangle_filled_or_xor),a	;use smc for xor/solid fill
	ld a,d			;starting x
	and $7			;what bit do we start on?
	ex af,af
	ld a,d			;starting x
	ld l,e			;ld hl,e
	ld h,0			; ..
	ld d,h			;set d = 0
	add hl,de		;starting y * 12
	add hl,de		;x3
	add hl,hl		;x6
	add hl,hl		;x12
	rra				;a = x coord / 8
	rra				;
	rra				;
	and @00011111	;starting x/8 (starting byte in gbuf)
	add a,GBUF_LSB
	ld e,a			;
	ld d,GBUF_MSB	;
	add hl,de		;hl = offset in gbuf
	ex af,af
	ld d,a
	ld a,@10000000
	jr z,TL_rectangle_filled_4

TL_rectangle_filled_3:
	rra
	dec d
	jr nz,TL_rectangle_filled_3

TL_rectangle_filled_4:
	ld e,12

TL_rectangle_filled_loop_x:
	push af
	push bc
	push hl
	ld c,a

TL_rectangle_filled_loop_y:
TL_rectangle_filled_or_xor:
	or (hl)			;smc will modify this to or/xor
	ld (hl),a
	ld a,c
	add hl,de
	djnz TL_rectangle_filled_loop_y
	pop hl
	pop bc
	pop af
	rrca
	jr nc,TL_rectangle_filled_5
	inc hl

TL_rectangle_filled_5:
	dec c
	jr nz,TL_rectangle_filled_loop_x

TL_rectangle_filled_end:
	pop bc
	pop de
#endasm
}
#endif

#if defined TL_TEXT
#asm
TL_text_wait:
	defb 0
TL_text_typing_speed:
	defb 0
TL_text_default_col:
	defb 0
#endasm
char TL_text(unsigned char x, unsigned char y, unsigned char *text, unsigned char is_typed, unsigned char typing_speed){
#asm
; Text routine by chickendude
;0		($00)	= end of a dialogue or end of a menu option
;NEWX	($ff)	= new X coordinate
;NEWY	($fe)	= new Y coordinate
;NEWXY	($fd)	= new XY coordinates
;NEWL	($fc)	= new line
;BRK	($fb)	= pause
	ld hl,2
	add hl,sp
	set textwrite,(iy+sgrflags)
	ld a,(hl)
	ld (TL_text_typing_speed),a
	inc hl
	inc hl
	ld a,(hl)
	ld (TL_text_wait),a
	inc hl
	inc hl
	push hl
	inc hl
	inc hl
	ld d,(hl)
	inc hl
	inc hl
	ld e,(hl)
	pop hl
	ld a,(hl)
	inc hl
	ld h,(hl)
	ld l,a

TL_text_start:
	ld (pencol),de
	ld a,e
	ld (TL_text_default_col),a

TL_text_loop:
	ld de,(pencol)
	ld a,(hl)
	or a
	jp z,TL_gbuf_to_lcd
	cp TL_BRK
	jr c,TL_text_not_special
	ld bc,TL_text_loop
	push bc
	push hl
	ld hl,TL_text_routine_table
	cpl
	add a,a
	ld c,a
	ld b,0
	add hl,bc
	ld c,(hl)
	inc hl
	ld b,(hl)
	pop hl			;hl = adress in the string
	push bc			;bc = routine adress where we want to jump
	ret

TL_text_not_special:
	push de
	push ix
	rst rbr_call
	defw _vputmap
	pop ix
	pop de
	ld a,(TL_text_wait)	;= 0 if no delay, != 0 else
	or a
	call nz,TL_text_delay
	inc hl
	jr TL_text_loop

TL_text_delay:
	di
	exx
	ld a,dkey_group_6	;check ALPHA to skip text typing
	out (pkey),a
	in a,(pkey)
	bit 7,a
	jr nz,TL_text_delay_skip
	xor a
	ld (TL_text_wait),a

TL_text_delay_skip:
	ld a,(TL_text_typing_speed)
	ld b,a

TL_text_delay_loop:
	push bc
	call nc,TL_gbuf_to_lcd
	pop bc
	djnz TL_text_delay_loop
	exx
	ret

TL_text_routine_table:
	defw TL_text_new_x
	defw TL_text_new_y
	defw TL_text_new_x_y
	defw TL_text_new_line
	defw TL_text_pause

TL_text_new_x:
	inc hl
	ld e,(hl)
	ld (pencol),de
	inc hl
	ret

TL_text_new_x_y:
	call TL_text_new_x

TL_text_new_y:
	inc hl
	ld d,(hl)
	ld (pencol),de
	inc hl
	ret

TL_text_new_line:
	ld a,d
	add a,6	;penrow+6
	ld d,a
	ld a,(TL_text_default_col)
	ld e,a
	ld (pencol),de
	inc hl
	ld a,(hl)
	ret

TL_text_pause:
	push hl
	call TL_gbuf_to_lcd

TL_text_pause_loop:
	ei
	halt
	di
	ld a,dkey_group_7	;check 2nd
	out (pkey),a
	in a,(pkey)
	bit 5,a
	jr nz,TL_text_pause_loop

TL_text_load_next:
	ld hl,TL_text_wait
	inc (hl)
	in a,(pkey)
	inc a
	jr nz,TL_text_load_next
	pop hl
	inc hl					;skip BRK
	ret
#endasm
}
#endif

#if defined TL_PUT_VAL
char TL_put_val(unsigned char x, unsigned char y, unsigned char val){
#asm
TL_put_val:
	ld hl,2
	add hl,sp
	ld e,(hl)
	inc hl
	ld d,(hl)
	push de
	inc hl
	ld b,(hl)
	inc hl
	inc hl
	ld c,(hl)
	ld (pencol),bc
	pop hl
	rst rbr_call
	defw _setxxxxop2
	rst rbr_call
	defw _op2toop1
	ld a,3
	rst rbr_call
	defw _dispop1a
#endasm
}
#endif
tilib.h


//****************************************************//
//** Uncomment #define of functions you want to use **//
//****************************************************//

//#define TL_ALL	//Auto define all functions
#define TL_RANDOM
#define TL_DELAY
#define TL_SMALL_SPRITE
#define TL_LARGE_SPRITE
#define TL_GBUF_TO_LCD
#define TL_DIRECT_INPUT
#define TL_GET_KEY
#define TL_GET_PIXEL
#define TL_RECTANGLE_FILLED
#define TL_TEXT
#define TL_PUT_VAL

//*********************//
//** TIlib constants **//
//*********************//

#define TL_PIXEL_ON	1
#define TL_PIXEL_OFF	0
#define TL_RECT_FILL_WHITE	0
#define TL_RECT_FILL_BLACK	1
#define TL_RECT_FILL_XOR	2
#define TL_TEXT_NOTYPE	0
#define TL_TEXT_TYPE	1
#define TL_NEWX	$ff
#define TL_NEWY	$fe
#define TL_NEWXY	$fd
#define TL_NEWL	$fc
#define TL_BRK	$fb

//**************************//
//** Functions prototypes **//
//**************************//

char __FASTCALL__ TL_random(unsigned char max);
char __FASTCALL__ TL_delay(unsigned char delay);
char TL_small_sprite(unsigned char x, unsigned char y, unsigned char height, unsigned char *sprite);
char TL_large_sprite(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char *sprite);
void TL_gbuf_to_lcd(void);
char __FASTCALL__ TL_direct_input(unsigned char keygroup);
void TL_get_key(void);
char TL_get_pixel(unsigned char x, unsigned char y);
char TL_rectangle_filled(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char color);
char TL_text(unsigned char x, unsigned char y, unsigned char *text, unsigned char is_typed, unsigned char typing_speed);
char TL_put_val(unsigned char x, unsigned char y, unsigned char val);