bug.txt

File: bug.txt - Tab length: 1 2 4 8 - Lines: on off - No wrap: on off

0001: [img]http://www.mirari.fr/Y5X0[/img]
0002:
0003: 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 :p
0004:
0005: Ah et les ennemis sont moins agressifs maintenant.
0006: [box=test.c]
0007: [code=c]
0008: #pragma string name C TEST
0009:
0010: #include "..\dev\ti83p.h"
0011: #include "..\dev\tilib.c"
0012: #include "..\dev\gbalib2.c"
0013:
0014: // Sprites
0015: #include "..\dev\sprites\title.h"
0016: #include "..\dev\sprites\map.h"
0017: #include "..\dev\sprites\map_player.h"
0018: #include "..\dev\sprites\tiles.h"
0019: #include "..\dev\sprites\battle_player_up.h"
0020: #include "..\dev\sprites\battle_player_up_attack.h"
0021: #include "..\dev\sprites\battle_player_right.h"
0022: #include "..\dev\sprites\battle_player_right_attack.h"
0023: #include "..\dev\sprites\battle_player_down.h"
0024: #include "..\dev\sprites\battle_player_down_attack.h"
0025: #include "..\dev\sprites\battle_player_left.h"
0026: #include "..\dev\sprites\battle_player_left_attack.h"
0027: #include "..\dev\sprites\battle_enemy.h"
0028: #include "..\dev\sprites\battle_enemy_attack.h"
0029:
0030: // Map
0031: extern char battle_map[];
0032: #asm
0033: ._battle_map
0034:   defb 4,4,4,4,4,4,4,3,3,3,3,3,4,4,4,4,4,4,4,4
0035:   defb 4,0,0,0,0,0,0,1,3,3,3,4,4,0,1,1,1,0,0,4
0036:   defb 4,0,0,0,0,0,0,2,1,3,3,1,1,0,2,2,2,0,0,4
0037:   defb 4,0,0,4,4,4,0,0,2,3,0,2,2,0,0,0,0,0,0,4
0038:   defb 4,0,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,4
0039:   defb 4,0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0040:   defb 4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0041:   defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0042:   defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0043:   defb 4,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0044:   defb 4,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0045:   defb 4,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,4
0046:   defb 4,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,4
0047:   defb 4,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0048:   defb 4,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0049:   defb 4,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,4
0050:   defb 4,0,0,0,0,0,0,2,0,0,0,0,0,0,1,0,0,0,0,4
0051:   defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,4
0052:   defb 4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4
0053:   defb 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4
0054: #endasm
0055:
0056: // Constants
0057: #define START 0
0058: #define LOAD 1
0059: #define QUIT 2
0060: #define BATTLE_MAP_WIDTH 20
0061: #define BATTLE_MAP_HEIGHT 20
0062: #define ATTACK_ANIM_DELAY 45
0063:
0064: // Global variables
0065: 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;
0066:
0067: typedef struct {
0068:   unsigned char x;
0069:   unsigned char y;
0070:   unsigned char *sprite;
0071:   unsigned char hp;
0072: } enemy_struct;
0073:
0074: enemy_struct enemy[4];
0075:
0076: extern char text_menu[];
0077: #asm
0078: ._text_menu
0079:   defm "Nouveau"&TL_NEWL&"Continuer"&TL_NEWL&"Quitter"&0
0080: #endasm
0081:
0082: extern char text_intro[];
0083: #asm
0084: ._text_intro
0085:   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
0086: #endasm
0087:
0088: extern char text_castle[];
0089: #asm
0090: ._text_castle
0091:   defm "Garde :"&TL_NEWL&"Passez votre chemin sale"&TL_NEWL&"manant !"&TL_BRK&0
0092: #endasm
0093:
0094: extern char text_hp[];
0095: #asm
0096: ._text_hp
0097:   defm "PV :"&0
0098: #endasm
0099:
0100: //Functions prototypes
0101: void main_menu(void);
0102: char draw_cursor(unsigned char x, unsigned char y);
0103: void handle_map(void);
0104: void update_map(void);
0105: char draw_player(unsigned char old_player_x, unsigned char old_player_y, unsigned char player_x, unsigned char player_y);
0106: char check_place(unsigned char player_x, unsigned char player_y);
0107: void battle(void);
0108: void update_battle_screen(void);
0109: char is_location_empty(unsigned char x, unsigned char y);
0110: char hit(unsigned char damage, unsigned char x, unsigned char y);
0111:
0112: //Functions
0113: char main(){
0114:   switch(main_menu()){
0115:   case START:
0116:   TL_rectangle_filled(0, 0, 96, 64, TL_RECT_FILL_BLACK);
0117:   TL_rectangle_filled(1, 1, 94, 62, TL_RECT_FILL_WHITE);
0118:   TL_text(2, 1, text_intro, TL_TEXT_TYPE, 5);
0119:   handle_map();
0120:   break;
0121:   case LOAD:
0122:   break;
0123:   }
0124: }
0125:
0126: void main_menu(void){
0127:   unsigned char cursor_y = 0;
0128:   TL_large_sprite(5, 0, 11, 26, title);
0129:   TL_rectangle_filled(28, 33, 40, 21, TL_RECT_FILL_BLACK);
0130:   TL_rectangle_filled(29, 34, 38, 19, TL_RECT_FILL_WHITE);
0131:   TL_text(34, 34, text_menu, TL_TEXT_NOTYPE, 0);
0132:   TL_gbuf_to_lcd();
0133:   key = 0;
0134:   while(key != skey_2nd){
0135:   draw_cursor(30, 34+cursor_y*6);
0136:   key = TL_get_key();
0137:   switch(key){
0138:   case skey_up:
0139:   if(cursor_y > START){
0140:   TL_gbuf_to_lcd();
0141:   cursor_y-=1;
0142:   }
0143:   break;
0144:   case skey_down:
0145:   if(cursor_y < QUIT){
0146:   TL_gbuf_to_lcd();
0147:   cursor_y+=1;
0148:   }
0149:   break;
0150:   }
0151:   }
0152:   return cursor_y;
0153: }
0154:
0155: char draw_cursor(unsigned char x, unsigned char y){
0156: #asm
0157:   res textwrite,(iy+sgrflags) ; reset some flag to write only to the screen (not the graph buffer)
0158:   ld hl,2
0159:   add hl,sp
0160:   ld b,(hl) ; get y from the parameters (stack)
0161:   inc hl
0162:   inc hl
0163:   ld c,(hl) ; get x
0164:   ld (pencol),bc
0165:   ld a,5
0166:   rst rbr_call
0167:   defw _vputmap ; write the cursor character
0168:   set textwrite,(iy+sgrflags) ; set the flag to write on the gbuf
0169: #endasm
0170: }
0171:
0172: void handle_map(void){
0173:   int move;
0174:   update_map();
0175:   key = 0;
0176:   while(key != dkey_clear){
0177:   key = TL_direct_input(dkey_group_1);
0178:   switch(key){
0179:   case dkey_up:
0180:   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)){
0181:   check_place(player_x+1, player_y-1);
0182:   update_map();
0183:   }else
0184:   move = 1;
0185:   break;
0186:   case dkey_right:
0187:   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)){
0188:   check_place(player_x+3, player_y+1);
0189:   update_map();
0190:   }else
0191:   move = 1;
0192:   break;
0193:   case dkey_left:
0194:   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)){
0195:   check_place(player_x-1, player_y+1);
0196:   update_map();
0197:   }else
0198:   move = 1;
0199:   break;
0200:   case dkey_down:
0201:   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)){
0202:   check_place(player_x+1, player_y+3);
0203:   update_map();
0204:   }else
0205:   move = 1;
0206:   break;
0207:   }
0208:   if(move){
0209:   draw_player(player_x, player_y, player_x += (key == dkey_right)-(key == dkey_left), player_y += (key == dkey_down)-(key == dkey_up));
0210:   move = 0;
0211:   }
0212:   key = TL_direct_input(dkey_group_2);
0213:   }
0214: }
0215:
0216: void update_map(void){
0217:   C_bcall(_cleargbuf);
0218:   TL_large_sprite(0, 0, 12, 64, map);
0219:   TL_small_sprite(player_x, player_y, 3, map_player);
0220:   TL_gbuf_to_lcd();
0221: }
0222:
0223: char draw_player(unsigned char old_player_x, unsigned char old_player_y, unsigned char player_x, unsigned char player_y){
0224:   TL_small_sprite(old_player_x, old_player_y, 3, map_player); // clear the player's sprite
0225:   TL_small_sprite(player_x, player_y, 3, map_player); // and re-draw it to its new place
0226:   TL_gbuf_to_lcd();
0227: }
0228:
0229: char check_place(unsigned char player_x, unsigned char player_y){
0230:   if(player_x > 5 && player_x < 19 && player_y > 4 && player_y < 31){
0231:   // TOWER
0232:   }else if(player_x > 25 && player_x < 58 && player_y > 3 && player_y < 36){
0233:   // CASTLE
0234:   TL_rectangle_filled(0, 37, 96, 27, TL_RECT_FILL_BLACK);
0235:   TL_rectangle_filled(1, 38, 94, 25, TL_RECT_FILL_WHITE);
0236:   TL_text(2, 38, text_castle, TL_TEXT_TYPE, 5);
0237:   }else if(player_x > 57 && player_x < 95 && player_y > 0 && player_y < 25){
0238:   // VOLCANO
0239:   }else if(player_x > 29 && player_x < 49 && player_y > 39 && player_y < 54){
0240:   // TOWN
0241:   }else if(player_x > 59 && player_x < 95 && player_y > 32 && player_y < 63){
0242:   if(player_x > 83 && player_x < 94 && player_y > 52 && player_y < 62){
0243:   // HOUSE
0244:   }else{
0245:   // FOREST
0246:   battle();
0247:   }
0248:   }
0249: }
0250:
0251: void battle(void){
0252:   C_bcall(_cleargbuf);
0253:   for(i = 0; i<4; i++){
0254: generate_enemy_coordinates:
0255:   x_temp = TL_random(BATTLE_MAP_WIDTH-2)+1;
0256:   y_temp = TL_random(BATTLE_MAP_HEIGHT/2)+1;
0257:   if(GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) > 0)
0258:   goto generate_enemy_coordinates;
0259:   enemy[i].x = x_temp;
0260:   enemy[i].y = y_temp;
0261:   enemy[i].sprite = battle_enemy;
0262:   enemy[i].hp = 3;
0263:   }
0264:   battle_player_direction = battle_player_up;
0265:   key = 0;
0266:   while(key != skey_clear){
0267:   if(battle_player_x < screen_w/16){
0268:   camera_x = 0;
0269:   }else if(battle_player_x > BATTLE_MAP_WIDTH-screen_w/16){
0270:   camera_x = BATTLE_MAP_WIDTH-screen_w/8;
0271:   }else{
0272:   camera_x = battle_player_x-screen_w/16;
0273:   }
0274:   if(battle_player_y < screen_h/16){
0275:   camera_y = 0;
0276:   }else if(battle_player_y > BATTLE_MAP_HEIGHT-screen_h/18){
0277:   camera_y = BATTLE_MAP_HEIGHT-screen_h/9;
0278:   }else{
0279:   camera_y = battle_player_y-screen_h/16;
0280:   }
0281:   update_battle_screen();
0282:   key = TL_get_key();
0283:   x_temp = battle_player_x-(key == skey_left)+(key == skey_right);
0284:   y_temp = battle_player_y-(key == skey_up)+(key == skey_down);
0285:   if(is_location_empty(x_temp, y_temp) && GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) == 0){
0286:   battle_player_x = x_temp;
0287:   battle_player_y = y_temp;
0288:   }
0289:   switch(key){
0290:   case skey_up:
0291:   battle_player_direction = battle_player_up;
0292:   x_temp2 = battle_player_x;
0293:   y_temp2 = battle_player_y-1;
0294:   break;
0295:   case skey_right:
0296:   battle_player_direction = battle_player_right;
0297:   x_temp2 = battle_player_x+1;
0298:   y_temp2 = battle_player_y;
0299:   break;
0300:   case skey_left:
0301:   battle_player_direction = battle_player_left;
0302:   x_temp2 = battle_player_x-1;
0303:   y_temp2 = battle_player_y;
0304:   break;
0305:   case skey_down:
0306:   battle_player_direction = battle_player_down;
0307:   x_temp2 = battle_player_x;
0308:   y_temp2 = battle_player_y+1;
0309:   break;
0310:   }
0311:   if(key == skey_2nd){
0312:   battle_player_direction += 2*8; // go to the attack sprite
0313:   if(is_location_empty(x_temp2, y_temp2)){
0314:   update_battle_screen();
0315:   TL_delay(ATTACK_ANIM_DELAY);
0316:   }else
0317:   enemy[j].hp -= hit(TL_random(2), (enemy[j].x-GBA_scroll_x)*8, (enemy[j].y-GBA_scroll_y)*8);
0318:   battle_player_direction -= 2*8; // go back to the normal sprite
0319:   }
0320:   // IA
0321:   for(i = 0; i<4; i++){
0322:   if(enemy[i].hp > 0){
0323:   if(TL_random(3)){ // 1 in 3 chance that the enemy goes anywhere
0324:   if(TL_random(2))
0325:   x_temp = TL_random(2)+enemy[i].x;
0326:   else
0327:   x_temp = -TL_random(2)+enemy[i].x;
0328:   if(TL_random(2))
0329:   y_temp = TL_random(2)+enemy[i].y;
0330:   else
0331:   y_temp = -TL_random(2)+enemy[i].y;
0332:   }else{ // 2 in 3 chance that the enemy follow the player
0333:   x_temp = enemy[i].x+(enemy[i].x < battle_player_x)-(enemy[i].x > battle_player_x);
0334:   y_temp = enemy[i].y+(enemy[i].y < battle_player_y)-(enemy[i].y > battle_player_y);
0335:   }
0336:   if(TL_random(2)) // to prevent the enemy from moving two tiles at a time
0337:   x_temp = enemy[i].x;
0338:   else
0339:   y_temp = enemy[i].y;
0340:   if(is_location_empty(x_temp, y_temp) && GBA_collision((x_temp-GBA_scroll_x)*8, (y_temp-GBA_scroll_y)*8) == 0){
0341:   if(x_temp == battle_player_x && y_temp == battle_player_y){
0342:   enemy[i].sprite = battle_enemy_attack;
0343:   player_hp -= hit(TL_random(2), (battle_player_x-GBA_scroll_x)*8, (battle_player_y-GBA_scroll_y)*8);
0344:   enemy[i].sprite = battle_enemy;
0345:   }else{
0346:   enemy[i].x = x_temp;
0347:   enemy[i].y = y_temp;
0348:   }
0349:   }
0350:   }
0351:   }
0352:   }
0353: }
0354:
0355: void update_battle_screen(void){
0356:   C_bcall(_cleargbuf);
0357:   GBA_init_map(camera_x, camera_y, 20, 20, tiles, battle_map);
0358:   GBA_restore_map();
0359:   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);
0360:   for(j = 0; j<4; j++){
0361:   if(enemy[j].hp > 0)
0362:   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);
0363:   }
0364: #asm
0365:   ld hl,gbuf+57*(96/8)
0366:   ld de,gbuf+57*(96/8)+1
0367:   ld (hl),@11111111
0368:   ld bc,96/8
0369:   ldir ; draw a horizontal line (x = 0, y = 57, w = 96, h = 1)
0370: #endasm
0371:   TL_text(0, 58, text_hp, TL_TEXT_NOTYPE, 0);
0372:   TL_put_val(12, 58, player_hp);
0373:   TL_gbuf_to_lcd();
0374: }
0375:
0376: 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)
0377:   for(j = 0; j<4; j++){
0378:   if(enemy[j].x == x && enemy[j].y == y && enemy[j].hp > 0){
0379:   return 0;
0380:   }
0381:   }
0382:   return 1;
0383: }
0384:
0385: char hit(unsigned char damage, unsigned char x, unsigned char y){
0386:   update_battle_screen();
0387:   TL_rectangle_filled(x+2, y-7, 5, 7, TL_RECT_FILL_WHITE);
0388:   TL_put_val(x+3, y-7, damage);
0389:   TL_gbuf_to_lcd();
0390:   TL_delay(ATTACK_ANIM_DELAY);
0391:   return damage;
0392: }
0393: [/code]
0394: [/box]
0395: [box=tilib.c]
0396: [code=c]
0397: #include "..\dev\tilib.h" // ï¿½ MODIFIER EN : #include "tilib.h"
0398:
0399: #if defined TL_ALL
0400: #define TL_RANDOM
0401: #define TL_DELAY
0402: #define TL_SMALL_SPRITE
0403: #define TL_LARGE_SPRITE
0404: #define TL_GBUF_TO_LCD
0405: #define TL_DIRECT_INPUT
0406: #define TL_GET_KEY
0407: #define TL_GET_PIXEL
0408: #define TL_RECTANGLE_FILLED
0409: #define TL_TEXT
0410: #define TL_PUT_VAL
0411: #endif
0412:
0413: #if defined TL_RANDOM
0414: #asm
0415: TL_random_data:
0416:   defw $0000
0417: #endasm
0418: char __FASTCALL__ TL_random(unsigned char max){
0419: #asm
0420: ; Random routine by Joe Wingbermuehle
0421:   ld b,l
0422:
0423: TL_random:
0424:   push hl
0425:   push de
0426:   ld hl,(TL_random_data)
0427:   ld a,r
0428:   ld d,a
0429:   ld e,(hl)
0430:   add hl,de
0431:   add a,l
0432:   xor h
0433:   ld (TL_random_data),hl
0434:   sbc hl,hl
0435:   ld e,a
0436:   ld d,h
0437: TL_random_loop:
0438:   add hl,de
0439:   djnz TL_random_loop
0440:   ld a,h
0441:   pop de
0442:   pop hl
0443:   ld h,0
0444:   ld l,a
0445: #endasm
0446: }
0447: #endif
0448:
0449: #if defined TL_DELAY
0450: char __FASTCALL__ TL_delay(unsigned char delay){
0451: #asm
0452:   ld b,l
0453:   ei
0454:
0455: delay_loop:
0456:   halt
0457:   djnz delay_loop
0458:   di
0459: #endasm
0460: }
0461: #endif
0462:
0463: #if defined TL_SMALL_SPRITE
0464: char TL_small_sprite(unsigned char x, unsigned char y, unsigned char height, unsigned char *sprite){
0465: #asm
0466: ; Sprite routine by Joe Wingbermuehle
0467:   ld hl,2
0468:   add hl,sp
0469:   ld e,(hl)
0470:   inc hl
0471:   ld d,(hl)
0472:   push de
0473:   pop ix
0474:   inc hl
0475:   ld b,(hl)
0476:   inc hl
0477:   inc hl
0478:   ld c,(hl)
0479:   inc hl
0480:   inc hl
0481:   ld a,(hl)
0482:   ld l,c
0483:
0484: TL_small_sprite:
0485:   ld e,l
0486:   ld h,$00
0487:   ld d,h
0488:   add hl,de
0489:   add hl,de
0490:   add hl,hl
0491:   add hl,hl
0492:   ld e,a
0493:   and $07
0494:   ld c,a
0495:   srl e
0496:   srl e
0497:   srl e
0498:   add hl,de
0499:   ld de,gbuf
0500:   add hl,de
0501:
0502: TL_small_sprite_loop_1:
0503:   ld d,(ix)
0504:   ld e,$00
0505:   ld a,c
0506:   or a
0507:   jr z,TL_small_sprite_skip_1
0508:
0509: TL_small_sprite_loop_2:
0510:   srl d
0511:   rr e
0512:   dec a
0513:   jr nz,TL_small_sprite_loop_2
0514:
0515: TL_small_sprite_skip_1:
0516:   ld a,(hl)
0517:   xor d
0518:   ld (hl),a
0519:   inc hl
0520:   ld a,(hl)
0521:   xor e
0522:   ld (hl),a
0523:   ld de,$0b
0524:   add hl,de
0525:   inc ix
0526:   djnz TL_small_sprite_loop_1
0527: #endasm
0528: }
0529: #endif
0530:
0531: #if defined TL_LARGE_SPRITE
0532: char TL_large_sprite(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char *sprite){
0533: #asm
0534: ; Sprite routine by Joe Wingbermuehle
0535:   ld hl,2
0536:   add hl,sp
0537:   ld e,(hl)
0538:   inc hl
0539:   ld d,(hl)
0540:   push de
0541:   pop ix
0542:   inc hl
0543:   ld b,(hl)
0544:   inc hl
0545:   inc hl
0546:   ld c,(hl)
0547:   inc hl
0548:   inc hl
0549:   push hl
0550:   inc hl
0551:   inc hl
0552:   ld a,(hl)
0553:   pop hl
0554:   ld l,(hl)
0555:
0556: TL_large_sprite:
0557:   di
0558:   ex af,af
0559:   ld a,c
0560:   push af
0561:   ex af,af
0562:   ld e,l
0563:   ld h,0
0564:   ld d,h
0565:   add hl,de
0566:   add hl,de
0567:   add hl,hl
0568:   add hl,hl
0569:   ld e,a
0570:   and $07
0571:   ld c,a
0572:   srl e
0573:   srl e
0574:   srl e
0575:   add hl,de
0576:   ld de,gbuf
0577:   add hl,de
0578:
0579: TL_large_sprite_loop_1:
0580:   push hl
0581:
0582: TL_large_sprite_loop_2:
0583:   ld d,(ix)
0584:   ld e,0
0585:   ld a,c
0586:   or a
0587:   jr z,TL_large_sprite_skip_1
0588:
0589: TL_large_sprite_loop_3:
0590:   srl d
0591:   rr e
0592:   dec a
0593:   jr nz,TL_large_sprite_loop_3
0594:
0595: TL_large_sprite_skip_1:
0596:   ld a,(hl)
0597:   xor d
0598:   ld (hl),a
0599:   inc hl
0600:   ld a,(hl)
0601:   xor e
0602:   ld (hl),a
0603:   inc ix
0604:   ex af,af
0605:   dec a
0606:   push af
0607:   ex af,af
0608:   pop af
0609:   jr nz,TL_large_sprite_loop_2
0610:   pop hl
0611:   pop af
0612:   push af
0613:   ex af,af
0614:   ld de,$0c
0615:   add hl,de
0616:   djnz TL_large_sprite_loop_1
0617:   pop af
0618: #endasm
0619: }
0620: #endif
0621:
0622: #if defined TL_GBUF_TO_LCD || defined TL_TEXT
0623: void TL_gbuf_to_lcd(void){
0624: #asm
0625: ; Fast copy routine by Joe Wingbermuehle
0626: TL_gbuf_to_lcd:
0627:   di
0628:   ld a,$80
0629:   out (plcdcmd),a
0630:   ld hl,gbuf-12-(-(12*64)+1)
0631:   ld a,$20
0632:   ld c,a
0633:   inc hl
0634:   dec hl
0635:
0636: TL_gbuf_to_lcd_again:
0637:   ld b,64
0638:   inc c
0639:   ld de,-(12*64)+1
0640:   out (plcdcmd),a
0641:   add hl,de
0642:   ld de,10
0643:
0644: TL_gbuf_to_lcd_loop:
0645:   add hl,de
0646:   inc hl
0647:   inc hl
0648:   inc de
0649:   ld a,(hl)
0650:   out (plcddata),a
0651:   dec de
0652:   djnz TL_gbuf_to_lcd_loop
0653:   ld a,c
0654:   cp $2b+1
0655:   jr nz,TL_gbuf_to_lcd_again
0656: #endasm
0657: }
0658: #endif
0659:
0660: #if defined TL_DIRECT_INPUT
0661: char __FASTCALL__ TL_direct_input(unsigned char keygroup){
0662: #asm
0663:   ld a,l ; a = keygroup
0664:   out (pkey),a
0665:   in a,(pkey)
0666:   ld h,0
0667:   ld l,a ; hl is the return parameter
0668: #endasm
0669: }
0670: #endif
0671:
0672: #if defined TL_GET_KEY
0673: void TL_get_key(void){
0674: #asm
0675: TL_get_key_loop:
0676:   rst rbr_call
0677:   defw _getcsc
0678:   or a
0679:   jr z,TL_get_key_loop
0680:   ld h,0
0681:   ld l,a
0682: #endasm
0683: }
0684: #endif
0685:
0686: #if defined TL_GET_PIXEL
0687: char TL_get_pixel(unsigned char x, unsigned char y){
0688: #asm
0689:   ld hl,2
0690:   add hl,sp
0691:   ld e,(hl) ; e=y
0692:   inc hl
0693:   inc hl
0694:   ld a,(hl) ; a=x
0695:   ld l,e
0696:
0697: TL_get_pixel:
0698:   ld h,0
0699:   ld d,h
0700:   ld e,l
0701:   add hl,hl
0702:   add hl,de
0703:   add hl,hl
0704:   add hl,hl
0705:   ld e,a
0706:   srl e
0707:   srl e
0708:   srl e
0709:   add hl,de
0710:   ld de,plotsscreen
0711:   add hl,de
0712:   and 7
0713:   ld b,a
0714:   ld a,$80
0715:   jr z,TL_test_pixel
0716:
0717: TL_get_pixel_loop:
0718:   rrca
0719:   djnz TL_get_pixel_loop
0720:
0721: TL_test_pixel:
0722:   and (hl)
0723:   or a
0724:   ld hl,TL_PIXEL_ON
0725:   jr nz,TL_get_pixel_quit
0726:   ld hl,TL_PIXEL_OFF
0727:
0728: TL_get_pixel_quit:
0729: #endasm
0730: }
0731: #endif
0732:
0733: #if defined TL_RECTANGLE_FILLED
0734: char TL_rectangle_filled(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char color){
0735: #asm
0736: ; Rectangle filled routine by chickendude
0737: #define GBUF_LSB $40
0738: #define GBUF_MSB $93
0739:   ld hl,2
0740:   add hl,sp
0741:   push hl
0742:   inc hl
0743:   inc hl
0744:   ld b,(hl)
0745:   inc hl
0746:   inc hl
0747:   ld c,(hl)
0748:   inc hl
0749:   inc hl
0750:   ld e,(hl)
0751:   inc hl
0752:   inc hl
0753:   ld d,(hl)
0754:   pop hl
0755:   ld a,(hl)
0756:   cp 2
0757:   jr z,TL_rectangle_filled_xor
0758:   or a
0759:   jr nz,TL_rectangle_filled_solid
0760:
0761: ;b = height
0762: ;c = width
0763: ;d = starting x
0764: ;e = starting y
0765:
0766: TL_rectangle_filled_white:
0767:   call TL_rectangle_filled_solid
0768:
0769: TL_rectangle_filled_xor:
0770:   ld a,$ae ;xor (hl)
0771:   jr TL_rectangle_filled_2
0772:
0773: TL_rectangle_filled_solid:
0774:   ld a,$b6 ;or (hl)
0775:
0776: TL_rectangle_filled_2:
0777:   push de
0778:   push bc
0779:   ld (TL_rectangle_filled_or_xor),a ;use smc for xor/solid fill
0780:   ld a,d ;starting x
0781:   and $7 ;what bit do we start on?
0782:   ex af,af
0783:   ld a,d ;starting x
0784:   ld l,e ;ld hl,e
0785:   ld h,0 ; ..
0786:   ld d,h ;set d = 0
0787:   add hl,de ;starting y * 12
0788:   add hl,de ;x3
0789:   add hl,hl ;x6
0790:   add hl,hl ;x12
0791:   rra ;a = x coord / 8
0792:   rra ;
0793:   rra ;
0794:   and @00011111 ;starting x/8 (starting byte in gbuf)
0795:   add a,GBUF_LSB
0796:   ld e,a ;
0797:   ld d,GBUF_MSB ;
0798:   add hl,de ;hl = offset in gbuf
0799:   ex af,af
0800:   ld d,a
0801:   ld a,@10000000
0802:   jr z,TL_rectangle_filled_4
0803:
0804: TL_rectangle_filled_3:
0805:   rra
0806:   dec d
0807:   jr nz,TL_rectangle_filled_3
0808:
0809: TL_rectangle_filled_4:
0810:   ld e,12
0811:
0812: TL_rectangle_filled_loop_x:
0813:   push af
0814:   push bc
0815:   push hl
0816:   ld c,a
0817:
0818: TL_rectangle_filled_loop_y:
0819: TL_rectangle_filled_or_xor:
0820:   or (hl) ;smc will modify this to or/xor
0821:   ld (hl),a
0822:   ld a,c
0823:   add hl,de
0824:   djnz TL_rectangle_filled_loop_y
0825:   pop hl
0826:   pop bc
0827:   pop af
0828:   rrca
0829:   jr nc,TL_rectangle_filled_5
0830:   inc hl
0831:
0832: TL_rectangle_filled_5:
0833:   dec c
0834:   jr nz,TL_rectangle_filled_loop_x
0835:
0836: TL_rectangle_filled_end:
0837:   pop bc
0838:   pop de
0839: #endasm
0840: }
0841: #endif
0842:
0843: #if defined TL_TEXT
0844: #asm
0845: TL_text_wait:
0846:   defb 0
0847: TL_text_typing_speed:
0848:   defb 0
0849: TL_text_default_col:
0850:   defb 0
0851: #endasm
0852: char TL_text(unsigned char x, unsigned char y, unsigned char *text, unsigned char is_typed, unsigned char typing_speed){
0853: #asm
0854: ; Text routine by chickendude
0855: ;0 ($00) = end of a dialogue or end of a menu option
0856: ;NEWX ($ff) = new X coordinate
0857: ;NEWY ($fe) = new Y coordinate
0858: ;NEWXY ($fd) = new XY coordinates
0859: ;NEWL ($fc) = new line
0860: ;BRK ($fb) = pause
0861:   ld hl,2
0862:   add hl,sp
0863:   set textwrite,(iy+sgrflags)
0864:   ld a,(hl)
0865:   ld (TL_text_typing_speed),a
0866:   inc hl
0867:   inc hl
0868:   ld a,(hl)
0869:   ld (TL_text_wait),a
0870:   inc hl
0871:   inc hl
0872:   push hl
0873:   inc hl
0874:   inc hl
0875:   ld d,(hl)
0876:   inc hl
0877:   inc hl
0878:   ld e,(hl)
0879:   pop hl
0880:   ld a,(hl)
0881:   inc hl
0882:   ld h,(hl)
0883:   ld l,a
0884:
0885: TL_text_start:
0886:   ld (pencol),de
0887:   ld a,e
0888:   ld (TL_text_default_col),a
0889:
0890: TL_text_loop:
0891:   ld de,(pencol)
0892:   ld a,(hl)
0893:   or a
0894:   jp z,TL_gbuf_to_lcd
0895:   cp TL_BRK
0896:   jr c,TL_text_not_special
0897:   ld bc,TL_text_loop
0898:   push bc
0899:   push hl
0900:   ld hl,TL_text_routine_table
0901:   cpl
0902:   add a,a
0903:   ld c,a
0904:   ld b,0
0905:   add hl,bc
0906:   ld c,(hl)
0907:   inc hl
0908:   ld b,(hl)
0909:   pop hl ;hl = adress in the string
0910:   push bc ;bc = routine adress where we want to jump
0911:   ret
0912:
0913: TL_text_not_special:
0914:   push de
0915:   push ix
0916:   rst rbr_call
0917:   defw _vputmap
0918:   pop ix
0919:   pop de
0920:   ld a,(TL_text_wait) ;= 0 if no delay, != 0 else
0921:   or a
0922:   call nz,TL_text_delay
0923:   inc hl
0924:   jr TL_text_loop
0925:
0926: TL_text_delay:
0927:   di
0928:   exx
0929:   ld a,dkey_group_6 ;check ALPHA to skip text typing
0930:   out (pkey),a
0931:   in a,(pkey)
0932:   bit 7,a
0933:   jr nz,TL_text_delay_skip
0934:   xor a
0935:   ld (TL_text_wait),a
0936:
0937: TL_text_delay_skip:
0938:   ld a,(TL_text_typing_speed)
0939:   ld b,a
0940:
0941: TL_text_delay_loop:
0942:   push bc
0943:   call nc,TL_gbuf_to_lcd
0944:   pop bc
0945:   djnz TL_text_delay_loop
0946:   exx
0947:   ret
0948:
0949: TL_text_routine_table:
0950:   defw TL_text_new_x
0951:   defw TL_text_new_y
0952:   defw TL_text_new_x_y
0953:   defw TL_text_new_line
0954:   defw TL_text_pause
0955:
0956: TL_text_new_x:
0957:   inc hl
0958:   ld e,(hl)
0959:   ld (pencol),de
0960:   inc hl
0961:   ret
0962:
0963: TL_text_new_x_y:
0964:   call TL_text_new_x
0965:
0966: TL_text_new_y:
0967:   inc hl
0968:   ld d,(hl)
0969:   ld (pencol),de
0970:   inc hl
0971:   ret
0972:
0973: TL_text_new_line:
0974:   ld a,d
0975:   add a,6 ;penrow+6
0976:   ld d,a
0977:   ld a,(TL_text_default_col)
0978:   ld e,a
0979:   ld (pencol),de
0980:   inc hl
0981:   ld a,(hl)
0982:   ret
0983:
0984: TL_text_pause:
0985:   push hl
0986:   call TL_gbuf_to_lcd
0987:
0988: TL_text_pause_loop:
0989:   ei
0990:   halt
0991:   di
0992:   ld a,dkey_group_7 ;check 2nd
0993:   out (pkey),a
0994:   in a,(pkey)
0995:   bit 5,a
0996:   jr nz,TL_text_pause_loop
0997:
0998: TL_text_load_next:
0999:   ld hl,TL_text_wait
1000:   inc (hl)
1001:   in a,(pkey)
1002:   inc a
1003:   jr nz,TL_text_load_next
1004:   pop hl
1005:   inc hl ;skip BRK
1006:   ret
1007: #endasm
1008: }
1009: #endif
1010:
1011: #if defined TL_PUT_VAL
1012: char TL_put_val(unsigned char x, unsigned char y, unsigned char val){
1013: #asm
1014: TL_put_val:
1015:   ld hl,2
1016:   add hl,sp
1017:   ld e,(hl)
1018:   inc hl
1019:   ld d,(hl)
1020:   push de
1021:   inc hl
1022:   ld b,(hl)
1023:   inc hl
1024:   inc hl
1025:   ld c,(hl)
1026:   ld (pencol),bc
1027:   pop hl
1028:   rst rbr_call
1029:   defw _setxxxxop2
1030:   rst rbr_call
1031:   defw _op2toop1
1032:   ld a,3
1033:   rst rbr_call
1034:   defw _dispop1a
1035: #endasm
1036: }
1037: #endif
1038: [/code]
1039: [/box]
1040: [box=tilib.h]
1041: [code=c]
1042: //****************************************************//
1043: //** Uncomment #define of functions you want to use **//
1044: //****************************************************//
1045:
1046: //#define TL_ALL //Auto define all functions
1047: #define TL_RANDOM
1048: #define TL_DELAY
1049: #define TL_SMALL_SPRITE
1050: #define TL_LARGE_SPRITE
1051: #define TL_GBUF_TO_LCD
1052: #define TL_DIRECT_INPUT
1053: #define TL_GET_KEY
1054: #define TL_GET_PIXEL
1055: #define TL_RECTANGLE_FILLED
1056: #define TL_TEXT
1057: #define TL_PUT_VAL
1058:
1059: //*********************//
1060: //** TIlib constants **//
1061: //*********************//
1062:
1063: #define TL_PIXEL_ON 1
1064: #define TL_PIXEL_OFF 0
1065: #define TL_RECT_FILL_WHITE 0
1066: #define TL_RECT_FILL_BLACK 1
1067: #define TL_RECT_FILL_XOR 2
1068: #define TL_TEXT_NOTYPE 0
1069: #define TL_TEXT_TYPE 1
1070: #define TL_NEWX $ff
1071: #define TL_NEWY $fe
1072: #define TL_NEWXY $fd
1073: #define TL_NEWL $fc
1074: #define TL_BRK $fb
1075:
1076: //**************************//
1077: //** Functions prototypes **//
1078: //**************************//
1079:
1080: char __FASTCALL__ TL_random(unsigned char max);
1081: char __FASTCALL__ TL_delay(unsigned char delay);
1082: char TL_small_sprite(unsigned char x, unsigned char y, unsigned char height, unsigned char *sprite);
1083: char TL_large_sprite(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char *sprite);
1084: void TL_gbuf_to_lcd(void);
1085: char __FASTCALL__ TL_direct_input(unsigned char keygroup);
1086: void TL_get_key(void);
1087: char TL_get_pixel(unsigned char x, unsigned char y);
1088: char TL_rectangle_filled(unsigned char x, unsigned char y, unsigned char width, unsigned char height, unsigned char color);
1089: char TL_text(unsigned char x, unsigned char y, unsigned char *text, unsigned char is_typed, unsigned char typing_speed);
1090: char TL_put_val(unsigned char x, unsigned char y, unsigned char val);
1091: [/code]
1092: [/box]