// Main Function
void _main(void)
{

	ST_helpMsg("F800+rom idx FLINE executed");	//ST_helpMsg is automatically a fline instuction due to USE_FLINE_ROM_CALLS
	ngetchx();
	//asm(".word 0xF800+0x29b");	//idle

asm("
TestBsr:
	.word 0xFFF0
	.long (TestBsrFunc-TestBsr)-2
	bra BsrTestFinished
	
TestBsrFunc:
	rts

BsrTestFinished:
	");
	ST_helpMsg("$FFF0 FLINE executed");ngetchx();
	
	asm("bra TestBra");
	asm("retBra:");
	ST_helpMsg("$FFF1 FLINE executed");ngetchx();
	

	asm(".word 0xFFF2
	   .word 0x19E*4 /* ClrScr */");
	ST_helpMsg("FFF2 index*4 FLINE executed");ngetchx();
}
Exemplo n.º 2
0
void _main(void) {
    LCD_BUFFER backbuffer;
    unsigned char buffer[100*5*4];
    unsigned short i,j;

    LCD_save(backbuffer);

    ST_helpMsg("Sprite8Get() Demo - Press Key");
    ngetchx();

    for (j=0;j<64;j++) {
        for (i=0;i<20;i++) {
            Sprite8Get_R(j+(i<<3),0,100,backbuffer,((unsigned char*)buffer)+100*i);
        }
        ClrScr();
        for (i=0;i<20;i++) {
            Sprite8_OR_R(i<<3,0,100,((unsigned char*)buffer)+100*i,LCD_MEM);
        }
    }

    ST_helpMsg("Sprite16Get() Demo - Press Key");
    ngetchx();

    for (j=0;j<64;j++) {
        for (i=0;i<10;i++) {
            Sprite16Get_R(j+(i<<4),0,100,backbuffer,((unsigned short*)buffer)+100*i);
        }
        ClrScr();
        for (i=0;i<10;i++) {
            Sprite16_OR_R(i<<4,0,100,((unsigned short*)buffer)+100*i,LCD_MEM);
        }
    }

    ST_helpMsg("Sprite32Get() Demo - Press Key");
    ngetchx();

    for (j=0;j<64;j++) {
        for (i=0;i<5;i++) {
            Sprite32Get_R(j+(i<<5),0,100,backbuffer,((unsigned long*)buffer)+100*i);
        }
        ClrScr();
        for (i=0;i<5;i++) {
            Sprite32_OR_R(i<<5,0,100,((unsigned long*)buffer)+100*i,LCD_MEM);
        }
    }

    LCD_restore(backbuffer);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 3
0
/*===========================================================================*/
void _main(void) {
    short         i,j;
    unsigned long measure_val;
    char          tmpstr[50] = "Measuring, please wait ...";
    short         modes[6]   = { A_REPLACE,A_XOR,A_REVERSE,A_XOR,A_REPLACE,A_REVERSE};
    LCD_BUFFER    screen;

    LCD_save(screen);

    FontSetSys(F_4x6);

    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER,INITIAL_TIMER_VALUE);

    ClearScreen();
    DrawStr(0,0,tmpstr,A_REPLACE);

    do {
        //---------------------------------------------------------------------
        // built-in OS line drawing routine ...
        //---------------------------------------------------------------------
        OSTimerRestart(USER_TIMER);
        for (j=0;j<6 && !kbhit();j++) {
            short used_mode = modes[j];
            for (i=0;  i<160;i++) DrawLine(80,50,i,8,   used_mode);
            for (i=8;  i<100;i++) DrawLine(80,50,159,i, used_mode);
            for (i=159;i>=0; i--) DrawLine(80,50,i,99,  used_mode);
            for (i=99; i>=8; i--) DrawLine(80,50,0,i,   used_mode);
        }
        measure_val = OSTimerCurVal(USER_TIMER);
        sprintf(tmpstr,"OS Routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
        memset(LCD_MEM,0,30*8);
        DrawStr(0,0,tmpstr,A_REPLACE);

        if (kbhit()) break;

        //---------------------------------------------------------------------
        // new line drawing routine ...
        //---------------------------------------------------------------------
        OSTimerRestart(USER_TIMER);
        for (j=0;j<6 && !kbhit();j++) {
            short used_mode = modes[j];
            for (i=0;  i<160;i++) FastDrawLine_R(LCD_MEM,80,50,i,8,   used_mode);
            for (i=8;  i<100;i++) FastDrawLine_R(LCD_MEM,80,50,159,i, used_mode);
            for (i=159;i>=0; i--) FastDrawLine_R(LCD_MEM,80,50,i,99,  used_mode);
            for (i=99; i>=8; i--) FastDrawLine_R(LCD_MEM,80,50,0,i,   used_mode);
        }
        measure_val = OSTimerCurVal(USER_TIMER);
        sprintf(tmpstr,"Own Routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
        memset(LCD_MEM,0,30*8);
        DrawStr(0,0,tmpstr,A_REPLACE);
    }
    while (!kbhit());

    ngetchx();
    OSFreeTimer(USER_TIMER);
    LCD_restore(screen);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 4
0
/*===========================================================================*/
void _main(void) {
#define bsize (100*20+4) // Size of a bitmap for a 160x100 screen.
    int i;
    LCD_BUFFER lcd;
    static const SCR_RECT theScreen = {{0,0,159,99}};
    unsigned char sscreen[bsize];
    unsigned char sscreen2[bsize];

    LCD_save(lcd);

    BitmapGet(&theScreen,sscreen);
    memset(sscreen2,0,bsize);
    ((BITMAP*)sscreen2)->NumRows=((BITMAP*)sscreen)->NumRows;
    ((BITMAP*)sscreen2)->NumCols=((BITMAP*)sscreen)->NumCols;
    GKeyFlush();
    for (i = 0; (i <= 360) && (!kbhit()); i++)
    {
        RotateSpriteX8_R(((BITMAP*)sscreen)->Data,((BITMAP*)sscreen2)->Data,160,100,80,50,i);
        ClrScr();
        FastCopyScreen160to240_R(100,((BITMAP*)sscreen2)->Data,LCD_MEM);
    }

    LCD_restore(lcd);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
#undef bsize
}
Exemplo n.º 5
0
void __attribute__ ((noreturn)) Error(FILE *fp) {
	if (fp != NULL)
		fclose(fp);
	
	ST_helpMsg("Error creating 'sumogfx' File");
	exit(1);
}
Exemplo n.º 6
0
/*===========================================================================*/
void _main(void) {
    LCD_BUFFER screen;
    short      retval;

    LCD_save(screen);
    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER,INITIAL_TIMER_VALUE);

    retval = Test8();
    if (retval != KEY_ESC) retval=Test16();
    if (retval != KEY_ESC) retval=Test32();

    OSFreeTimer(USER_TIMER);
    LCD_restore(screen);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 7
0
//  \/
//there is an address error somewhere in this routine.				
static void ScrollFromTop(WINDOW *w, HEX_DAT *d)
{
	WIN_RECT wr={ 0, 0, 0, 0 };
	BACKGROUND_DAT *bg=&gBGDAT;
	USHORT result_top;
	USHORT result_bottom;
	USHORT *ptr;
	char buff[150];
	DASM_DAT dasm;

	wr.x1=WinWidth(w);
	wr.y1=ScrollFromBottom_helper+C(6-1,8-1);
	
	if((ULONG)bg->baseaddr && (ULONG)d->top>(ULONG)bg->baseaddr && bg->hOffsetTable)
	{
		ptr=HeapDeref(bg->hOffsetTable);
		result_top=bsearch(ptr, (ULONG)d->top - (ULONG)bg->baseaddr, bg->entries-1);
		result_bottom=bsearch(ptr, (ULONG)bottom_addr - (ULONG)bg->baseaddr, bg->entries-1);
		
		if(result_top==USHRT_MAX || result_bottom==USHRT_MAX)
		{
			d->top-=2;
			WinPaint(w, d);
			
			#ifdef DEBUG
				ST_helpMsg("Address Not In Buffer.");
			#endif
			
			return;
		}			
		
		if(result_top)
		{
			result_top--;	//the previous instruction
			result_bottom--;
		}
		
		d->top=(char*)&bg->baseaddr[ptr[result_top]>>1];
		bottom_addr=(char*)&bg->baseaddr[ptr[result_bottom]>>1];

		WinScrollV(w, &wr, C(-6,-8));
		
		disassemble_one((unsigned short*)d->top, &dasm);
		sprintf(buff, "%lx%s", d->top, dasm.text);
		WinStrXY(w, 1, 1, buff);
	}
Exemplo n.º 8
0
void _main(void)
{
  short l,c,k;
  void *vecran;
  LCD_BUFFER backbuffer;

  LCD_save(backbuffer);

  if(!(vecran=malloc(LCD_SIZE)))
    return;

  l=c=0;

  do
  {
    DrawTiles16B(MAP_WIDTH,&map[l][c],vecran,sprts);

    FastCopyScreen_R(vecran,LCD_MEM);
/*
    memcpy(LCD_MEM,vecran,LCD_SIZE);
*/

    k=ngetchx();
    if(k==KEY_RIGHT && c<MAP_WIDTH-15)
      c++;
    if(k==KEY_LEFT && c>0)
      c--;
    if(k==KEY_DOWN && l<MAP_HEIGHT-8)
      l++;
    if(k==KEY_UP && l>0)
      l--;

  } while(k!=KEY_ESC);

  free(vecran);
  LCD_restore(backbuffer);
  GKeyFlush();
  ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 9
0
void _main(void)
{
  INT_HANDLER ai1,ai5;
  void *bloc=malloc(BIG_VSCREEN_SIZE*2+LCD_SIZE*2); // 1 big_vscreen et 1 écran virtuel
  void *vecran,*big_vscreen;
  LCD_BUFFER backbuffer;

  LCD_save(backbuffer);

  if(!bloc)
    return;

// Initialisations
  vecran=bloc;

  big_vscreen=bloc+LCD_SIZE*2;

  ai1=GetIntVec(AUTO_INT_1);
  ai5=GetIntVec(AUTO_INT_5);
  SetIntVec(AUTO_INT_1,DUMMY_HANDLER);
  SetIntVec(AUTO_INT_5,DUMMY_HANDLER);

  if(GrayOn())
  {
    RenderMaps(big_vscreen,vecran);
    GrayOff();
  }

  SetIntVec(AUTO_INT_1,ai1);
  SetIntVec(AUTO_INT_5,ai5);

  free(bloc);
  LCD_restore(backbuffer);
  GKeyFlush();
  ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 10
0
/*===========================================================================*/
static inline short Test32(void) {
    unsigned long  measure_val;
    char           tmpstr[100];
    short          x,y;
    long           count;

    //-------------------------------------------------------------------------
    // original sprite functions
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32(x,y,8,spritedata32,LCD_MEM,SPRT_AND);
            Sprite32(x,y,8,spritedata32,LCD_MEM,SPRT_OR);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"TIGCCLIB AND+OR: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

#if __TIGCCLIB_VERSION__ >= 272
    //-------------------------------------------------------------------------
    // original sprite functions with RPLC (GCC4TI 0.96 Beta 10+)
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32(x,y,8,spritedata32,LCD_MEM,SPRT_RPLC);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"TIGCCLIB RPLC: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;
#endif

    //-------------------------------------------------------------------------
    // modified sprite functions using separate and/or
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32_AND_R(x,y,8,spritedata32,LCD_MEM);
            Sprite32_OR_R(x,y,8,spritedata32,LCD_MEM);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"ExtGraph AND+OR: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

    //-------------------------------------------------------------------------
    // modified sprite functions using just one call
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32_MASK_R(x,y,8,spritedata32,spritedata32,LCD_MEM);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"ExtGraph MASK: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32_BLIT_R(x,y,8,spritedata32,0x00000000,LCD_MEM);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"ExtGraph BLIT: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32_RPLC_R(x,y,8,spritedata32,LCD_MEM);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"ExtGraph RPLC: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

    //-------------------------------------------------------------------------
    // original sprite functions
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32(x,y,8,spritedata32,LCD_MEM,SPRT_XOR);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"TIGCCLIB AND+OR: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    if (ngetchx() == KEY_ESC) return KEY_ESC;

    //-------------------------------------------------------------------------
    // modified sprite functions using just one call
    //-------------------------------------------------------------------------
    count = 0;
    ClrScr();

    OSTimerRestart(USER_TIMER);
    for (y=0;y<100-16;y++) {
        for (x=0;x<160-32;x++) {
            count++;
            Sprite32_XOR_R(x,y,8,spritedata32,LCD_MEM);
        }
    }

    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"ExtGraph XOR: %lu ticks for %ld sprites",INITIAL_TIMER_VALUE-measure_val,count);
    ST_helpMsg(tmpstr);
    return ngetchx();
}
Exemplo n.º 11
0
// Main Function
void _main(void)
{
signed char STATUS, a;
int plinkos;
unsigned char *Home = malloc(LCD_SIZE); // Allocate the SAVE_SCREEN buffer
if (Home == NULL) {
	Error_Memory();
	return;
}
LCD_save(Home);  // Save LCD HomeScreen Contents

virtual_dark = malloc ( LCD_SIZE );  // Allocate the dark buffer
if (virtual_dark == NULL) {Error_Memory(); return; }
virtual_light=malloc ( LCD_SIZE );  // Allocate the light buffer
if (virtual_light == NULL)	{
	free(virtual_dark);
	Error_Memory();
	return;
}

randomize();

if (Gray_prep() == QUIT) {
	Error_Memory();
	goto end;
}

if (makefile() == QUIT)  // Tests whether or not we need a default save file and installs one if the 
// user doesn't already have one on their calc
	goto end;

for(a = 10; a--;)
	FADE_LIGHTER();
// Clears both Hidden Gray planes
ClearGrayScreen2B(Hiddenl, Hiddend);

GraySpriteX8_OR(52, 37, 27, titlel, titled, 7, Hiddenl, Hiddend);

FontSetSys (F_4x6);
GrayDBufSetHiddenAMSPlane (DARK_PLANE); 
	DrawStr(122, 94, "-- By Fisch", A_NORMAL);
GrayDBufSetHiddenAMSPlane (LIGHT_PLANE); 
	DrawStr(123, 95, "-- By Fisch", A_NORMAL);
GrayDBufToggleSync(); // switches two sets of planes

for(a = 10; a--;)
	FADE_DARKER();
Waitkey();

NEW_GAME:

if ((STATUS = MENU()) == QUIT)
	goto end;

if ((plinkos = PRODUCTS()) == QUIT)
	goto end;

if ((STATUS = INTRO()) == QUIT)
	goto end;

if ((STATUS = main_game(plinkos)) == QUIT)
	goto end;

goto NEW_GAME;

end:
// Clean up at end of Program
Cleanup();
if (Home) {
	LCD_restore(Home);
	free(Home);
	
	GKeyFlush();
	ST_helpMsg("Plinko  --By Travis Fischer");
}
}
Exemplo n.º 12
0
void Error_Memory(void) {
	ST_helpMsg("Error, Not Enough Memory.  Free up RAM");
}
Exemplo n.º 13
0
/*===========================================================================*/
void _main(void) {
    short         i,j;
    unsigned long measure_val;
    char          tmpstr[50] = "Measuring, please wait ...";
    static const short modes[4] = {COLOR_LIGHTGRAY,COLOR_DARKGRAY,COLOR_BLACK,COLOR_WHITE};
    unsigned short clippedcoord[4];
    LCD_BUFFER    screen;

    LCD_save(screen);

    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER,INITIAL_TIMER_VALUE);

    if (!GrayOn()) goto end;

    //---------------------------------------------------------------------
    // built-in OS line drawing routine ...
    //---------------------------------------------------------------------
    GrayClearScreen_R();
    OSTimerRestart(USER_TIMER);
    for (j=0;j<4;j++) {
        short used_color = modes[j];
        for (i=-40;  i<280;i++) GrayDrawClipLine(120,64,i,-40,used_color);
        for (i=-40;  i<168;i++) GrayDrawClipLine(120,64,280,i,used_color);
        for (i=280;i>=-40; i--) GrayDrawClipLine(120,64,i,168,used_color);
        for (i=168;i>=-40; i--) GrayDrawClipLine(120,64,-40,i,used_color);
    }
    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"OS routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
    GrayDrawRect(0,0,239,7,COLOR_WHITE,RECT_FILLED);
    GrayDrawStrExt(0,0,tmpstr,A_NORMAL | A_CENTERED | A_SHADOWED,F_4x6);

    if (ngetchx() == KEY_ESC) goto end;

    
    //---------------------------------------------------------------------
    // new line drawing routine ...
    //---------------------------------------------------------------------
    GrayClearScreen_R();
    OSTimerRestart(USER_TIMER);
    for (j=0;j<4;j++) {
        short used_color = modes[j];
        for (i=-40;  i<280;i++) GrayClipDrawLine_R(120,64,i,-40,clippedcoord,used_color,GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),GrayFastDrawLine2B_R);
        for (i=-40;  i<280;i++) GrayClipDrawLine_R(120,64,280,i,clippedcoord,used_color,GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),GrayFastDrawLine2B_R);
        for (i=280;i>=-40; i--) GrayClipDrawLine_R(120,64,i,168,clippedcoord,used_color,GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),GrayFastDrawLine2B_R);
        for (i=168;i>=-40; i--) GrayClipDrawLine_R(120,64,-40,i,clippedcoord,used_color,GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),GrayFastDrawLine2B_R);
    }
    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"Own routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
    GrayDrawRect(0,0,239,7,COLOR_WHITE,RECT_FILLED);
    GrayDrawStrExt(0,0,tmpstr,A_NORMAL | A_CENTERED | A_SHADOWED,F_4x6);

    if (ngetchx() == KEY_ESC) goto end;


    GrayOff();
    ClrScr();
    //---------------------------------------------------------------------
    // built-in OS line drawing routine ...
    //---------------------------------------------------------------------
    OSTimerRestart(USER_TIMER);
    for (j=0;j<4;j++) {
        WIN_RECT rect = {120, 64, 0, -40};
        for (i=-40;  i<280;i++) {rect.x1 = i; DrawClipLine(&rect,&(SCR_RECT){{0, 0, 239, 127}},A_XOR); }
        for (i=-40;  i<168;i++) {rect.y1 = i; DrawClipLine(&rect,&(SCR_RECT){{0, 0, 239, 127}},A_XOR); }
        for (i=280;i>=-40; i--) {rect.x1 = i; DrawClipLine(&rect,&(SCR_RECT){{0, 0, 239, 127}},A_XOR); }
        for (i=168;i>=-40; i--) {rect.y1 = i; DrawClipLine(&rect,&(SCR_RECT){{0, 0, 239, 127}},A_XOR); }
    }
    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"OS routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
    GrayDrawRect2B(0,0,239,7,COLOR_WHITE,RECT_FILLED,LCD_MEM,LCD_MEM);
    GrayDrawStrExt2B(0,0,tmpstr,A_NORMAL | A_CENTERED,F_4x6,LCD_MEM,LCD_MEM);

    if (ngetchx() == KEY_ESC) goto end;

    //---------------------------------------------------------------------
    // new line drawing routine ...
    //---------------------------------------------------------------------
    ClrScr();
    OSTimerRestart(USER_TIMER);
    for (j=0;j<4;j++) {
        for (i=-40;  i<280;i++) ClipDrawLine_R(120,64,i,-40,clippedcoord,A_XOR,LCD_MEM,FastDrawLine_R);
        for (i=-40;  i<280;i++) ClipDrawLine_R(120,64,280,i,clippedcoord,A_XOR,LCD_MEM,FastDrawLine_R);
        for (i=280;i>=-40; i--) ClipDrawLine_R(120,64,i,168,clippedcoord,A_XOR,LCD_MEM,FastDrawLine_R);
        for (i=168;i>=-40; i--) ClipDrawLine_R(120,64,-40,i,clippedcoord,A_XOR,LCD_MEM,FastDrawLine_R);
    }
    measure_val = OSTimerCurVal(USER_TIMER);
    sprintf(tmpstr,"Own routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
    GrayDrawRect2B(0,0,239,7,COLOR_WHITE,RECT_FILLED,LCD_MEM,LCD_MEM);
    GrayDrawStrExt2B(0,0,tmpstr,A_NORMAL | A_CENTERED,F_4x6,LCD_MEM,LCD_MEM);

    ngetchx();

    end:
    OSFreeTimer(USER_TIMER);
    GrayOff();
    LCD_restore(screen);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 14
0
/*===========================================================================*/
void _main(void) {
    short         i,j;
    unsigned long measure_val;
    char          tmpstr[50] = "Measuring, please wait ...";
    short         modes[4]   = {COLOR_LIGHTGRAY,COLOR_DARKGRAY,COLOR_BLACK,COLOR_WHITE};
    LCD_BUFFER    screen;

    LCD_save(screen);
    if (!GrayOn()) return;

    OSFreeTimer(USER_TIMER);
    OSRegisterTimer(USER_TIMER,INITIAL_TIMER_VALUE);

    GrayClearScreen_R();

    GrayDrawStrExt(0,0,tmpstr,A_REPLACE|A_CENTERED|A_SHADOWED,F_4x6);

    do {
        //---------------------------------------------------------------------
        // built-in OS line drawing routine ...
        //---------------------------------------------------------------------
        OSTimerRestart(USER_TIMER);
        for (j=0;j<4 && !kbhit();j++) {
            short used_color = modes[j];
            for (i=0;  i<160;i++) GrayDrawLine(80,50,i,8,   used_color);
            for (i=8;  i<100;i++) GrayDrawLine(80,50,159,i, used_color);
            for (i=159;i>=0; i--) GrayDrawLine(80,50,i,99,  used_color);
            for (i=99; i>=8; i--) GrayDrawLine(80,50,0,i,   used_color);
        }
        measure_val = OSTimerCurVal(USER_TIMER);
        sprintf(tmpstr,"OS routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);

        GrayDrawRect(0,0,239,7,COLOR_WHITE,RECT_FILLED);
        GrayDrawStrExt(0,0,tmpstr,A_REPLACE | A_CENTERED | A_SHADOWED,F_4x6);

        if (kbhit()) break;

        //---------------------------------------------------------------------
        // new line drawing routine ...
        //---------------------------------------------------------------------
        OSTimerRestart(USER_TIMER);
        for (j=0;j<4 && !kbhit();j++) {
            short used_color = modes[j];
            for (i=0;  i<160;i++) GrayFastDrawLine2B_R(GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),80,50,i,8,   used_color);
            for (i=8;  i<100;i++) GrayFastDrawLine2B_R(GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),80,50,159,i, used_color);
            for (i=159;i>=0; i--) GrayFastDrawLine2B_R(GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),80,50,i,99,  used_color);
            for (i=99; i>=8; i--) GrayFastDrawLine2B_R(GrayGetPlane(LIGHT_PLANE),GrayGetPlane(DARK_PLANE),80,50,0,i,   used_color);
        }
        measure_val = OSTimerCurVal(USER_TIMER);
        sprintf(tmpstr,"Own routine took %lu ticks",INITIAL_TIMER_VALUE-measure_val);
        GrayDrawRect(0,0,239,8,COLOR_WHITE,RECT_FILLED);
        GrayDrawStrExt(0,0,tmpstr,A_REPLACE | A_CENTERED | A_SHADOWED,F_4x6);
    }
    while (!kbhit());

    ngetchx();
    OSFreeTimer(USER_TIMER);

    GrayOff();
    LCD_restore(screen);
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);
}
Exemplo n.º 15
0
// Main Function
void _main(void)
{
	ST_helpMsg("Saving external data, please wait...");
	UnArchive("sumogfx");
	FILE *fp = fopen("sumogfx", "wb");
	if (!fp)
		Error(NULL);
	
	/* Write all Graphics Data into the 'sumodat' File */
	//#define Write(x)	printf("%lu\n", sizeof(x)); ngetchx();
	
	#define Write(x) ({ Putshort(sizeof((x)), fp); if (fwrite((x), sizeof((x)), 1, fp) != 1) {Error(fp);} })
	Write(stomp1);
	Write(stomp2);
	Write(stomp3);
	
	Write(salt1);
	Write(salt3);
	
	Write(kneel1);
	Write(kneel3);
	Write(kneel5);
	
	Write(tackle1);
	Write(tackle3);
	
	Write(walk1);
	Write(walk3);
	
	Write(charge1);
	Write(charge3);
	
	Write(tumble1);
	Write(tumble2);
	Write(tumble3);
	Write(tumble4);
	
	Write(spinn1);
	Write(spinn3);
	
	Write(tossbackleft);
	
	Write(pummel1);
	Write(pummelpush1);
	
	Write(pummellift1);
	Write(pummellift3);
	Write(pummellift5);
	
	Write(earthquake_throwleft);
	
	Write(shoveleft);
	Write(shovedright);
	Write(shovedleftedge1);
	Write(shovedleftedge2);
	
	Write(pummelthrowleft);
	Write(throwleft);
	Write(thrownright);
	Write(pummelthrowcounter1);
	
	Write(punchleft1);
	Write(punchleft2);
	Write(punchedleft1);
	Write(punchedleft2);
	
	Write(tauntleft1);
	Write(tauntleft2);
	
	Write(laughing1);
	Write(laughing2);
	
	Write(sumoeating1);
	Write(sumoeating2);
	
	Write(sweepingleft);
	Write(smushedleft);
	Write(bellyflopleft1);
	Write(bellyflopleft2);
	Write(backwardsslamleft1);
	Write(backwardsslamleft2);
	Write(slammed);
	Write(Ring_Matrix);
	Write(ring_sprites);
	
	// Put the extension "gfx" onto the Graphics File and close it
	fputc(0, fp);
	fputs("gfx", fp);
	fputc(0, fp);
	fputc(OTH_TAG, fp);
	fclose(fp);
	Archive("sumogfx");  // Archive the Configuration File
	ST_helpMsg("External Data File 'sumogfx' created");
}
Exemplo n.º 16
0
//=============================================================================
// as usual our main function ...
//=============================================================================
void _main(void) {
    LCD_BUFFER  lcd;
    LCD_BUFFER  doublebuffer;
    short       i;
    short       ball_to_update;
    INT_HANDLER oldint1        = GetIntVec(AUTO_INT_1);  // fetch default interrupt handler
    INT_HANDLER oldint5        = GetIntVec(AUTO_INT_5);  // fetch default interrupt handler

    // save screen
    LCD_save(lcd);

    // install dummy interrupt handlers for AUTO_INT1 and AUTO_INT5
    SetIntVec(AUTO_INT_1,DUMMY_HANDLER);
    SetIntVec(AUTO_INT_5,DUMMY_HANDLER);

    do {
        // clear doublebuffer
        memset(doublebuffer,0,LCD_SIZE);
        for (i=0;i<NR_BALLS;i++) {
            // NOTE: DRAWSPRITE is a macro defined at the beginning of this file!
            DRAWSPRITE(balls[i].x,balls[i].y);
        }


        // copy double buffer to visible screen
        FastCopyScreen_R(doublebuffer,LCD_MEM);

        for (ball_to_update=0;ball_to_update<NR_BALLS;ball_to_update++) {
            // calculate new position of ball which should get updated
            CalcNewPosition(&balls[ball_to_update],max_x,max_y);


            // loop over all possible combinations and check for collision ...
            for (i=0;i<NR_BALLS;i++) {
                if (i==ball_to_update) continue; // don't check against myself

                // NOTE: TESTCOLLIDE is a macro defined at the beginning of this file!
                if (TESTCOLLIDE(balls[ball_to_update].newx,balls[ball_to_update].newy,balls[i].newx,balls[i].newy)) {
                    // collision detected -> exchange dirx/diry of involved balls
                    ExchangeDirections(&balls[ball_to_update],&balls[i]);

                    // recalculate new position of ball which should get updated
                    CalcNewPosition(&balls[ball_to_update],max_x,max_y);

                    // if we still stick together than this opponent then this
                    // is not the right target to change my direction ...
                    if (TESTCOLLIDE(balls[ball_to_update].newx,balls[ball_to_update].newy,balls[i].newx,balls[i].newy)) {
                        ExchangeDirections(&balls[ball_to_update],&balls[i]);
                        CalcNewPosition(&balls[ball_to_update],max_x,max_y);
                    }
                }
            }

            // NOTE: this demo is somewhat sloppy. Normally we should not
            //       proceed if a collision is detected AND we shouldn't do the
            //       VERY simple collision detection routine above.
            //       But I don't care about this. It seems to be good enough
            //       to demonstrate the bouncing balls ...
            balls[ball_to_update].x = balls[ball_to_update].newx;
            balls[ball_to_update].y = balls[ball_to_update].newy;
        }
    }
    while (!EscapePressed());

    // restore old interrupt handlers
    SetIntVec(AUTO_INT_1,oldint1);
    SetIntVec(AUTO_INT_5,oldint5);

    // restore screen
    LCD_restore(lcd);

    // empty the keyboard buffer and write "powered by ..." string
    GKeyFlush();
    ST_helpMsg(EXTGRAPH_VERSION_PWDSTR);

}
Exemplo n.º 17
0
Arquivo: t2048.c Projeto: 1cook/t2048
// Main Function
void _main( void ){
	//Create or load savefile
	SAVE gameState;
	if(readSave(&gameState))
		makeSave(&gameState);
	writeSave(&gameState); /*just to test whether writing is possible here
	so the player doesn't spend a long time and lose their progress*/
	//Buffer for the text at the bottom of the
	scoreString = (char*)malloc(60*sizeof(char));
	if(scoreString == NULL)
		exit(ER_MEMORY);
	
	//Pause menu
	pauseMenu = PopupNew(strConv[11], 50);
	if(pauseMenu == H_NULL)
		memkill(4, ER_MEMORY);
		PopupAddText(pauseMenu, -1, "New Game", 1);
		PopupAddText(pauseMenu, 0, "Options", 2);
			PopupAddText(pauseMenu,2,"Toggle Animations",5);
			PopupAddText(pauseMenu,2,"Reset Save Data",6);
			PopupAddText(pauseMenu, -1, "Exit", 3);
			PopupAddText(pauseMenu, -1, "About", 4);
	
	//Hiscore Name Entry
	nameBox = DialogNewSimple(140,35);
	if(nameBox == H_NULL)
		memkill(3, ER_MEMORY);
		DialogAddTitle(nameBox,"NEW HISCORE!",BT_OK,BT_NONE);
		DialogAddRequest(nameBox,3,14,"Name:", 0, 10, 14);
	
	//Game Over Entry
	gameOver = PopupNew("GAME OVER!", 40);
	if(gameOver == H_NULL)
		memkill(2, ER_MEMORY);
		PopupAddText(gameOver,-1,"Try Again",1);
		PopupAddText(gameOver,-1,"Exit",2);
	
	
	//About Dialouge
	aboutBox = DialogNewSimple(140,80);
	if(aboutBox == H_NULL)
		memkill(1, ER_MEMORY);	
		DialogAddTitle(aboutBox,"ABOUT",BT_OK,BT_NONE);

			DialogAddText(aboutBox, 3, 13, "2048: A sliding tile puzzle");
			DialogAddText(aboutBox, 3, 21, "Ti68k port by Harrison Cook");
			DialogAddText(aboutBox, 3, 29, "Original game by Gabriele Cirulli");
			DialogAddText(aboutBox, 3, 37, "\"Based on\" 1024 by Veewo Studio");
			DialogAddText(aboutBox, 3, 45, "\"Conceptually Similar to\":");
			DialogAddText(aboutBox, 3, 52, "Threes by Asher Vollmer");
			DialogAddText(aboutBox, 3, 59, "Built using TIGCC");
	
	ClrScr();
	FontSetSys(F_8x10);
	randomize();
	short int key;
	for(;;){
		ClrScr();
		drawGrid(gameState.grid);
		sprintf(scoreString, "Score: %lu Hiscore: %lu by %s", gameState.score, gameState.bscore, gameState.name);
		if(!isGridAvailable(gameState.grid)){
			
			if(gameState.score > gameState.bscore){
					DialogDo(nameBox,CENTER,CENTER,	gameState.name,NULL);
					gameState.bscore = gameState.score;
					FontSetSys(F_8x10);
			}
			gameState.score = 0;
			initGrid(gameState.grid);
			switch(PopupDo(gameOver,CENTER,CENTER,0)){
			case 1:
				continue;
				break;
			default:
				goto endGame;
				
			}
		}
		ST_helpMsg(scoreString);
		nodraw:
		ST_busy(ST_IDLE);
		key = ngetchx();
		ST_busy(ST_BUSY);
		ST_helpMsg(scoreString);
		char move = 4;
		if(key == KEY_UP)
			move = UP;
		else if(key == KEY_RIGHT)
			move = RIGHT;
		else if(key == KEY_DOWN)
			move = DOWN;
		else if(key == KEY_LEFT)
			move = LEFT;
		else if(key == KEY_OFF || key==KEY_ON)
			//Turn the calculator off during a game. Resume it later
			off();
		else if(key == KEY_ESC){ //Brings up the pause menu
			switch (PopupDo(pauseMenu,CENTER,CENTER,0)){
				case 1: //1. New Game
					gameState.score = 0;
					initGrid(gameState.grid);
					break;
				//case 2: //2. Options
					//this is a submenu
				case 3: //3: Exit
					endGame:
					writeSave(&gameState);
					memkill(0,0);
					break;
				case 4: //4: About
					DialogDo(aboutBox,CENTER,CENTER,NULL,NULL);
					//Dialog sets the font weirdly, set it back
					FontSetSys(F_8x10);
					break;
				case 5: //1. Toggle Animations
					gameState.animations = !gameState.animations;
					break;
				case 6: //2. Reset Saved Data
					makeSave(&gameState);
					break;
			}
		}
		else goto nodraw;
		if(move < 4){
			if(isDirectionAvailable(gameState.grid, move)){
				shiftGrid(gameState.grid,move,&gameState.score, gameState.animations);
				pushNewTile(gameState.grid);
			}
			else goto nodraw;
		}
	}
}