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]