int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
{
ULONG temp,i;
D(bug("Opening joystick %ld\n",joystick->index));
if(!(joystick->hwdata=SDL_malloc(sizeof(struct joystick_hwdata))))
return -1;
/* This loop is to check if the controller is a joypad */
for(i=0;i<20;i++)
{
temp=ReadJoyPort(joystick->index^1); // fix to invert amiga joyports
WaitTOF();
}
if((temp&JP_TYPE_MASK)==JP_TYPE_GAMECTLR)
joystick->nbuttons=7;
else
joystick->nbuttons=3;
joystick->nhats=0;
joystick->nballs=0;
joystick->naxes=2;
joystick->hwdata->joystate=0L;
return 0;
}
void AMI_ILBM_cycleTask()
{
while(!viewerDisplay.cycleTaskMustStop)
{
WaitTOF();
if(viewerDisplay.cycleModeEnabled)
AMI_ILBM_cycleColors(&viewerDisplay.image);
else
AMI_ILBM_resetColors(&viewerDisplay.image); /* Restore the palette back to normal */
}
viewerDisplay.cycleTaskTerminated = TRUE;
Wait(0); /* Puts task in a safe state before it terminates */
}
void RError(const char *fmt,...){
va_list argp;
ObtainSemaphore(&ErrorSemaphore);
va_start(argp,fmt);
vsprintf(errorstring,fmt,argp);
if(errorprocessalive==0){ //Should only happen before the player-task has been opened and after it has been closed.
fprintf(stderr,"Error: Errorprocess not alive\n");
fputs(errorstring,stderr);
}else{
Signal(ErrorTask,1L<<ErrorSig);
while(hassent==0){
WaitTOF();
}
hassent=0;
}
va_end(argp);
ReleaseSemaphore(&ErrorSemaphore);
}
LONG Blank( PrefObject *Prefs )
{
LONG ToFrontCount = 0, Wid, Hei, Drops, x, y, r, i, incr, RetVal = OK;
struct RastPort *Rast;
struct Screen *Scr;
struct Window *Wnd;
LONG d, xs, ys, rs;
Drops = Prefs[0].po_Level;
Scr = OpenScreenTags( 0L, SA_Depth, Prefs[2].po_Depth, SA_Quiet, TRUE,
SA_Overscan, OSCAN_STANDARD, SA_Behind, TRUE,
SA_DisplayID, Prefs[2].po_ModeID, SA_ShowTitle, FALSE,
SA_Title, "Garshnescreen", TAG_DONE );
if( Scr )
{
Wid = Scr->Width;
Hei = Scr->Height;
d = min( Wid, Hei );
xs = 3 * Wid;
ys = 4 * Hei;
Rast = &( Scr->RastPort );
SetRast( Rast, 0 );
for( i = 0; i < 4; i++ )
SetRGB4(&( Scr->ViewPort ), i, 4 * i, 4 * i, 4 * i );
Wnd = BlankMousePointer( Scr );
ScreenToFront( Scr );
while( RetVal == OK )
{
if(!( ++ToFrontCount % 60 ))
ScreenToFront( Scr );
if(!( ToFrontCount % Drops ))
SetRast(&( Scr->RastPort ), 0 );
r = RangeRand( d/13 ) + d/25;
if( Wid > Hei )
rs = r * xs / ys;
else
rs = r * ys / xs;
x = RangeRand( Wid - 2*rs ) + rs;
y = RangeRand( Hei - 2*rs ) + rs;
incr = max( Wid/160, 1 );
for( i = 0; i < r; i += incr )
{
WaitTOF();
SetAPen( &Scr->RastPort,
( ULONG )RangeRand(( 1L << Prefs[2].po_Depth ) - 1 )
+ 1 );
if( Wid > Hei )
{
DrawEllipse(&( Scr->RastPort ), x, y, i * xs / ys, i );
if( i )
{
SetAPen(&( Scr->RastPort ), 0 );
DrawEllipse(&( Scr->RastPort ), x, y,
xs * ( i - incr ) / ys, i - incr );
}
}
else
{
DrawEllipse(&( Scr->RastPort ), x, y, i, ys * i / xs );
if( i )
{
SetAPen(&( Scr->RastPort ), 0 );
DrawEllipse(&( Scr->RastPort ), x, y, i - incr,
( i - incr ) * ys / xs );
}
}
}
RetVal = ContinueBlanking();
}
UnblankMousePointer( Wnd );
}
else
RetVal = FAILED;
if( Scr )
CloseScreen( Scr );
return RetVal;
}
LONG Blank( PrefObject *Prefs )
{
struct Screen *LScr;
struct Window *Wnd;
LONG RetVal = OK,i,goatFlag = 0, ToFrontCount = 0;
if (Prefs[SCREEN].po_Active )
LScr = cloneTopScreen( FALSE, TRUE );
else
LScr = OpenScreenTags( 0l, SA_DisplayID, Prefs[MODE].po_ModeID,
SA_Depth, 2, SA_Overscan, OSCAN_STANDARD,
SA_ShowTitle, FALSE, SA_Title, "Garshnescreen",
SA_Quiet, TRUE, SA_Behind, TRUE, TAG_DONE );
if( LScr )
{
if( GarshnelibBase->lib_Version < 39 || !Prefs[SCREEN].po_Active )
{
SetRGB4(&(LScr->ViewPort),0,0x0,0x0,0x0);
SetRGB4(&(LScr->ViewPort),1,0x8,0x8,0x8);
SetRGB4(&(LScr->ViewPort),2,0x7,0x4,0x2);
SetRGB4(&(LScr->ViewPort),3,0x0,0xa,0x0);
backgroundClr = 0;
grassClr = GRASS;
herderClr = HERDER;
goatClr = GOAT;
}
else
{
backgroundClr = FindColor( LScr->ViewPort.ColorMap, 0, 0, 0, -1 );
grassClr = FindColor( LScr->ViewPort.ColorMap, 0, 0x9L<<28, 0,
-1 );
goatClr = FindColor( LScr->ViewPort.ColorMap, 0xAL<<28, 0xAL<<28,
0xAL<<28, -1 );
herderClr = FindColor( LScr->ViewPort.ColorMap, 0xBL<<28, 0x2L<<28,
0x4L<<28, -1 );
}
numGoats = Prefs[GOATS].po_Level;
numHerders = Prefs[HERDERS].po_Level;
reproduction = Prefs[REPRO].po_Level;
Width = LScr->Width;
Height = LScr->Height;
for (i=0;i<numHerders;++i)
herderQ[i] = 0;
herderQ[0] = 1;
herders[0].x = Width/2;
herders[0].y = Height/2;
for (i=0;i<numGoats;++i)
goatQ[i] = 0;
Wnd = BlankMousePointer( LScr );
ScreenToFront( LScr );
i = 0;
while( RetVal == OK )
{
WaitTOF();
if(!( ++ToFrontCount % 60 ))
ScreenToFront( LScr );
if( !Prefs[DELAY].po_Level ||
!( ToFrontCount % Prefs[DELAY].po_Level ))
{
myBlank( LScr, LScr->Width, LScr->Height );
if (!goatFlag && i == 20)
{
goatQ[0] = 1;
goats[0].x = Width/2;
goats[0].y = Height/2;
grassEaten[0] = 0;
goatFlag = 1;
}
else
++i;
}
RetVal = ContinueBlanking();
}
UnblankMousePointer( Wnd );
CloseScreen( LScr );
}
else
RetVal = FAILED;
return RetVal;
}
/*** Handle events coming from main window: ***/
void dispatch_events()
{
extern ULONG sigmainwnd, swinsig;
extern UBYTE record;
BYTE scrolldisp=0, state=0, cnt=0, mark=0, quit = 0;
while( quit == 0 )
{
/* Active collect, when pressing arrow gadgets */
sigrcvd = (state==0 ? Wait(sigbits) : sigmainwnd);
/* if(sigrcvd & SIGBREAKF_CTRL_C) break;
else */ if(sigrcvd & sigport) { handle_port(); continue; }
else if(sigrcvd & swinsig) { handle_search(); continue; }
/* Collect messages posted to the window port */
while( ( msg = (struct IntuiMessage *) GetMsg(Wnd->UserPort) ) )
{
/* Copy the entire message into the buffer */
CopyMemQuick(msg, &msgbuf, sizeof(msgbuf));
ReplyMsg( (struct Message *) msg );
switch( msgbuf.Class )
{
case IDCMP_CLOSEWINDOW: handle_menu(112); break;
case IDCMP_RAWKEY:
handle_kbd(edit);
if(record) {
if(record == 1) reg_act_com(MAC_ACT_SHORTCUT, msgbuf.Code, msgbuf.Qualifier);
else record &= 0x7f;
}
break;
case IDCMP_INTUITICKS:
/* An error message which needs to be removed? */
if(err_time == 0) err_time = msgbuf.Seconds;
if(err_time && msgbuf.Seconds-err_time>4) StopError(Wnd);
break;
case IDCMP_MOUSEBUTTONS:
/* Click somewhere in the text */
switch( msgbuf.Code )
{
case SELECTDOWN:
/* Click over the project bar ? */
if(msgbuf.MouseY < gui.top)
{
edit = select_panel(edit, msgbuf.MouseX);
break;
}
click(edit, msgbuf.MouseX, msgbuf.MouseY, FALSE);
/* Shift-click to use columnar selection */
if( ( move_selection = SwitchSelect(edit, msgbuf.Qualifier & SHIFTKEYS ? 1:0, 1) ) )
mark=TRUE;
break;
case SELECTUP:
if(mark) unclick(edit);
mark=FALSE; scrolldisp=0; break;
}
break;
case IDCMP_NEWSIZE:
new_size(EDIT_ALL);
break;
case IDCMP_GADGETDOWN: /* Left scroll bar */
if(msgbuf.IAddress == (APTR) &Prop->down) state=1;
if(msgbuf.IAddress == (APTR) &Prop->up) state=2;
break;
case IDCMP_GADGETUP: /* Arrows or prop gadget */
state=0;
if(msgbuf.IAddress == (APTR) Prop)
scroll_disp(edit, FALSE), scrolldisp=0;
break;
case IDCMP_MOUSEMOVE:
if(mark) scrolldisp=2;
else
if(Prop->scroller.Flags & GFLG_SELECTED) scrolldisp=1;
break;
case IDCMP_MENUPICK:
{ struct MenuItem * Item;
ULONG MenuId;
/* Multi-selection of menu entries */
while(msgbuf.Code != MENUNULL)
if( (Item = ItemAddress( Menu, msgbuf.Code )) )
{
/* stegerg: get NextSelect here in case menu action causes screen
to be closed/reopened in which case item becomes invalid.
Also assuming here that user in such case will not use
multiselection, ie. that nextselect will be MENUNULL.
If that's not the case it would mean more trouble and to protect
against that one would need to check if during handle_menu() the
screen has been closed/reopened and in that case break out of
the menu multiselection loop here. */
UWORD nextselect = Item->NextSelect;
MenuId = (ULONG)GTMENUITEM_USERDATA( Item );
handle_menu( MenuId );
if(record) reg_act_com(MAC_ACT_COM_MENU, MenuId, msgbuf.Qualifier);
else record &= 0x7f;
msgbuf.Code = nextselect;
}
}
}
}
/* Reduces the number of IDCMP mousemove messages to process */
if(scrolldisp==1) scroll_disp(edit, FALSE), scrolldisp=0;
if(scrolldisp==2) { scrolldisp=0; goto moveit; }
/* User may want to auto-scroll the display using arrow gadgets */
if(state && (mark || (((struct Gadget *)Prop)[state].Flags & GFLG_SELECTED))) {
/* Slow down animation: */
WaitTOF(); cnt++;
if(cnt>1) {
cnt=0;
if(autoscroll(edit,state==1 ? 1:-1)==0) state=0;
else if(mark) {
LONG x , y; moveit:
/* Adjust mouse position */
x = (msgbuf.MouseX-gui.left) / XSIZE;
y = (msgbuf.MouseY-gui.top) / YSIZE;
if(x < 0) x = 0; if(x >= gui.nbcol) x = gui.nbcol-1;
if(y < 0) y = -1; if(y > gui.nbline) y = gui.nbline;
edit->nbrwc = (x += edit->left_pos);
y += (LONG)edit->top_line;
if( x != edit->ccp.xc || y != edit->ccp.yc )
/* Move the selected stream */
if( !(state = move_selection(edit,x,y)) )
set_cursor_line(edit, y, edit->top_line),
inv_curs(edit,TRUE);
}
}
} /* endif: arrow gadget pressed or autoscroll */
}
}
LONG Blank (PrefObject *Prefs)
{
LONG Count, ScrToFrontCnt = 0, RetVal = TRUE, Size;
LONG Number;
struct Screen *PatchScreen;
PatchScreen = OpenScreenTags (NULL,
SA_Depth, 3,
SA_Overscan, OSCAN_STANDARD,
SA_DisplayID, Prefs[MODE].po_ModeID,
SA_Quiet, TRUE,
SA_Behind, TRUE,
TAG_DONE);
Size = sizeof (LINET) * Prefs[NO_LINES].po_Active;
Line = (LINET *) AllocVec (Size, 0L);
if (PatchScreen && Line)
{
HalfWidth = PatchScreen->Width / 2;
HalfHeight = PatchScreen->Height / 2;
if (HalfWidth < HalfHeight)
{
Size = HalfWidth - 1;
}
else
{
Size = HalfHeight - 1;
}
SetRGB4 (&(PatchScreen->ViewPort), 0, 0, 0, 0);
SetRast (&(PatchScreen->RastPort), 0);
Colors = (1L << PatchScreen->RastPort.BitMap->Depth) - 1;
ColorTable = RainbowPalette (PatchScreen, 0L, 1L, 0L);
ScreenToFront (PatchScreen);
Count = Prefs[SPEED].po_Level + 1;
for (Number = 0 ; Number < Prefs[NO_LINES].po_Active ; Number++)
{
DrawLine (&(PatchScreen->RastPort), Prefs, Size, Number);
}
Number = 0;
while (RetVal == TRUE)
{
WaitTOF();
if (!(ScrToFrontCnt++ % 60))
{
ScreenToFront (PatchScreen);
}
if (++Count > MAX_SPEED)
{
Count = Prefs[SPEED].po_Level + 1;
Number++;
if (Number == Prefs[NO_LINES].po_Active)
{
Number = 0;
}
KillLine (&(PatchScreen->RastPort), Prefs, Number);
DrawLine (&(PatchScreen->RastPort), Prefs, Size, Number);
}
RetVal = ContinueBlanking();
}
CloseScreen (PatchScreen);
}
else
{
RetVal = FALSE;
}
return RetVal;
}
LONG Blank( PrefObject *Prefs )
{
LONG delay_rate, i, j, counter = 0, RetVal = OK;
struct RastPort *Rast;
struct Screen *FTScr;
struct Window *FTWin;
struct Window *Wnd;
NumToasters = Prefs[OBJECTS].po_Level;
delay_rate = 11 - Prefs[SPEED].po_Level;
Toasters = AllocVec( sizeof( Toaster ) * NumToasters, MEMF_CLEAR );
FTScr = OpenScreenTags( NULL, SA_DisplayID, Prefs[MODE].po_ModeID,
SA_Depth, 4, SA_Overscan, OSCAN_STANDARD,
SA_Type, CUSTOMSCREEN, SA_Quiet, TRUE,
SA_Behind, TRUE, TAG_DONE );
if( Toasters && FTScr )
{
for( i = 0; i < 48; i += 3 )
if( GfxBase->lib_Version < 39 )
SetRGB4(&( FTScr->ViewPort ), i/3, ( cmap[i] * 16 ) / 256,
( cmap[i+1] * 16 ) / 256, ( cmap[i+2] * 16 ) / 256 );
else
SetRGB32(&( FTScr->ViewPort ), i/3, cmap[i]<<24, cmap[i+1]<<24,
cmap[i+2]<<24 );
FTWin = OpenWindowTags( 0L, WA_Width, FTScr->Width, WA_Height,
FTScr->Height, WA_IDCMP, 0L, WA_Flags,
WFLG_SIMPLE_REFRESH|WFLG_BORDERLESS,
WA_CustomScreen, FTScr, TAG_DONE );
if( FTWin )
{
Rast = FTWin->RPort;
SetAPen( Rast, 0 );
for( i = 0; i < NumToasters; i++ )
if( !FindLaunchPos( i, ( LONG )FTWin->Width,
( LONG )FTWin->Height ))
Toasters[i].delay = 30;
Wnd = BlankMousePointer( FTScr );
ScreenToFront( FTScr );
while( RetVal == OK )
{
WaitTOF();
if(!( ++counter % 60 ))
ScreenToFront( FTScr );
if(!( counter % delay_rate ))
{
for( i = 0; i < NumToasters; i++ )
{
if( !Toasters[i].delay )
{
Toasters[i].old_x = Toasters[i].x;
Toasters[i].old_y = Toasters[i].y;
Toasters[i].x -= Toasters[i].xspeed;
Toasters[i].y += Toasters[i].yspeed;
Toasters[i].xcol = -1;
Toasters[i].ycol = -1;
}
}
for( i = 0; i < NumToasters; i++ )
{
if( !Toasters[i].delay )
{
j = -1;
while(( j = TestExtent( j+1, i, Toasters[i].x,
Toasters[i].y )) >= 0 )
{
if( abs( Toasters[j].old_x -
Toasters[i].old_x ) < IM_WIDBUF )
{
if( Toasters[i].y < Toasters[j].y )
Toasters[i].ycol = j;
if( Toasters[i].xspeed ==
Toasters[j].xspeed )
Toasters[i].xspeed++;
}
else
{
if( Toasters[i].x > Toasters[j].x )
Toasters[i].xcol = j;
if( Toasters[i].yspeed ==
Toasters[j].yspeed )
Toasters[i].yspeed++;
}
if( abs( Toasters[j].old_y -
Toasters[i].old_y ) < IM_HEIBUF )
{
if( Toasters[i].x > Toasters[j].x )
Toasters[i].xcol = j;
if( Toasters[i].yspeed ==
Toasters[j].yspeed )
Toasters[i].yspeed++;
}
}
}
}
for( i = 0; i < NumToasters; i++ )
{
if( !Toasters[i].delay )
{
Toasters[i].x = Toasters[i].old_x - ActXSpeed( i );
Toasters[i].y = Toasters[i].old_y + ActYSpeed( i );
}
}
for( i = 0; i < NumToasters; i++ )
{
if( !Toasters[i].delay )
{
j = -1;
while(( j = TestExtent( j+1, i, Toasters[i].x,
Toasters[i].y )) >= 0 )
{
if( abs( Toasters[j].old_x -
Toasters[i].old_x ) < IM_WIDBUF )
if( Toasters[i].x > Toasters[j].x )
Toasters[i].x = Toasters[i].old_x;
else
if( Toasters[i].y < Toasters[j].y )
Toasters[i].y = Toasters[i].old_y;
if( abs( Toasters[j].old_y -
Toasters[i].old_y ) < IM_HEIBUF )
if( Toasters[i].y < Toasters[j].y )
Toasters[i].y = Toasters[i].old_y;
}
}
}
for( i = 0; i < NumToasters; i++ )
{
if( !Toasters[i].delay )
{
Toasters[i].phase =
( Toasters[i].phase + 1 ) % IMAGEMAX;
EraseRect( Rast, Toasters[i].x + IM_WIDTH,
Toasters[i].old_y, Toasters[i].x +
IM_WIDTH + Toasters[i].xspeed,
Toasters[i].old_y + IM_HEIGHT );
EraseRect( Rast, Toasters[i].old_x,
Toasters[i].old_y,
Toasters[i].old_x + IM_WIDTH,
Toasters[i].old_y + Toasters[i].yspeed );
DrawImage( Rast, img[Toasters[i].phase],
Toasters[i].x, Toasters[i].y );
if(( Toasters[i].x < -IM_WIDTH-1 )||
( Toasters[i].y > FTWin->Height ))
Toasters[i].delay = RangeRand( 50 );
}
else
if(!( --Toasters[i].delay ))
Toasters[i].delay =
FindLaunchPos( i, ( LONG )FTWin->Width,
( LONG )FTWin->Height )
? 0 : 30;
}
}
RetVal = ContinueBlanking();
}
SetSignal( 0L, SIGBREAKF_CTRL_C );
UnblankMousePointer( Wnd );
CloseWindow( FTWin );
}
else
RetVal = FAILED;
CloseScreen( FTScr );
}
else
RetVal = FAILED;
FreeVec( Toasters );
return RetVal;
}
LONG Blank( PrefObject *Prefs )
{
LONG ToFrontCount = 0, Wid, Hei, i, x, y, Stars, Speed, RetVal = OK;
struct RastPort *Rast;
struct Screen *Scr;
struct Window *Wnd;
Coord3D *p;
Coord2D *p2;
Stars = Prefs[0].po_Level;
Speed = Prefs[2].po_Level;
Coords = AllocVec( Stars * sizeof( Coord3D ), MEMF_CLEAR );
OldCoords = AllocVec( Stars * sizeof( Coord2D ), MEMF_CLEAR );
Scr = OpenScreenTags( 0L, SA_Depth, 2, SA_Overscan, OSCAN_STANDARD,
SA_DisplayID, Prefs[4].po_ModeID, SA_Behind, TRUE,
SA_Quiet, TRUE, SA_ShowTitle, FALSE, SA_Title,
"Garshnescreen", TAG_DONE );
if( Coords && OldCoords && Scr )
{
Wid = Scr->Width;
Hei = Scr->Height;
Rast = &( Scr->RastPort );
SetRast( Rast, 0 );
for( i = 0; i < 4; i++ )
SetRGB4(&( Scr->ViewPort ), i, 4 * i, 4 * i, 4 * i );
for( i = 0; i < Stars; i++ )
{
InitStar( &Coords[i], Speed );
OldCoords[i].x = 0;
OldCoords[i].y = 0;
}
Wnd = BlankMousePointer( Scr );
ScreenToFront( Scr );
while( RetVal == OK )
{
WaitTOF();
if(!( ++ToFrontCount % 60 ))
ScreenToFront( Scr );
for( p2 = OldCoords, p = Coords, i = 0;
i < Stars; i++, p++, p2++ )
{
x = p2->x;
y = p2->y;
SetAPen( Rast, 0 );
switch( p->z / 200 )
{
case 0:
WritePixel( Rast, x, y+1 );
WritePixel( Rast, x+1, y+1 );
case 1:
case 2:
case 3:
case 4:
WritePixel( Rast, x+1, y );
default:
WritePixel( Rast, x, y );
}
p->z -= p->speed;
if( p->z <= -1000 )
InitStar( p, Speed );
x = Wid/2 + ( 200 * p->x ) / ( p->z + 1000 );
y = Hei/2 + ( 200 * p->y ) / ( p->z + 1000 );
if(( x < 0 )||( x > Wid-2 )||( y < 0 )||( y > Hei-2 ))
{
InitStar( p, Speed );
p2->x = 0;
p2->y = 0;
}
else
{
p2->x = x;
p2->y = y;
SetAPen( Rast, 3 );
/* Warning: This is a little twisted. */
switch( p->z/200 )
{
case 9:
case 8:
SetAPen( Rast, 2 );
break;
case 0:
WritePixel( Rast, x, y+1 );
WritePixel( Rast, x+1, y+1 );
case 4:
case 3:
case 2:
case 1:
WritePixel( Rast, x+1, y );
case 7:
case 6:
case 5:
break;
default:
SetAPen( Rast, 1 );
break;
}
WritePixel( Rast, x, y );
}
}
if(!( ToFrontCount % 5 ))
RetVal = ContinueBlanking();
}
UnblankMousePointer( Wnd );
}
else
RetVal = FAILED;
if( Scr )
CloseScreen( Scr );
if( Coords )
FreeVec( Coords );
if( OldCoords )
FreeVec( OldCoords );
return RetVal;
}
LONG Blank( PrefObject *Prefs )
{
struct Screen *Scr;
struct Window *Wnd;
LONG ToFrontCount = 0, RetVal = OK;
MaxFires = Prefs[NUMBER].po_Level;
Power = Prefs[POWER].po_Level;
Radius = Prefs[RADIUS].po_Level;
FireTable = AllocVec( sizeof( struct Fire ) * ( MAX_FIRE + 1 ),
MEMF_CLEAR );
if( FireTable )
{
Scr = OpenScreenTags( 0L, SA_Depth, Prefs[MODE].po_Depth,
SA_Overscan, OSCAN_STANDARD, SA_Quiet, TRUE,
SA_DisplayID, Prefs[MODE].po_ModeID,
SA_Behind, TRUE, TAG_DONE );
if( Scr )
{
LastFire = &( FireTable[MAX_FIRE] );
Wid = Scr->Width;
Hei = Scr->Height;
if( Prefs[MODE].po_Depth < 3 )
setCopperList( Hei, 1, &( Scr->ViewPort ), &custom );
SetRGB4(&( Scr->ViewPort ), 0, 0, 0, 0 );
SetRGB4(&( Scr->ViewPort ), 1, 0x0F, 0x0F, 0x0F );
SetRast(&( Scr->RastPort ), 0 );
NumFires = 0;
Wnd = BlankMousePointer( Scr );
ScreenToFront( Scr );
while( RetVal == OK )
{
WaitTOF();
IterateFire(&( Scr->RastPort ));
if(!( ToFrontCount++ % 60 ))
ScreenToFront( Scr );
if(!( ToFrontCount % 5 ))
RetVal = ContinueBlanking();
}
UnblankMousePointer( Wnd );
if( Prefs[MODE].po_Depth < 3 )
clearCopperList( &Scr->ViewPort );
CloseScreen( Scr );
}
else
RetVal = FAILED;
FreeVec( FireTable );
}
else
RetVal = FAILED;
return RetVal;
}
PlayMaze()
{
PrintStatus(); /* Prints the score and everything else */
BlackOut(ALLBLACK); /* Hide the reconstruction of the viewPort */
WaitTOF(),WaitTOF(); /* Wait for the Blackout to finish */
InitializeStarting();
ScrollDisplay(SCROLLDEFINITELY);
killallsound();
button=0;
joyx=0;
joyy=0; /* Initialize Joy Regs */
JoyRead(CTRLR_RESET);
while(!(joyx || joyy))
{
WaitTOF();
JoyRead(CTRLR_READ);
}
playsound(SND_BACKGRND,0),playsound(SND_BACKGRND,0);
SetAPen(rastport,PATHCOLOR); /* We will be erasing dots */
for(i=0; i<numghosts; i++) energized[i]=0;
while(dead>=0 && numdots)
{
tx=xposn[0]+XOFF;
ty=yposn[0]+YOFF;
if(tx>=minx-1 && tx<=maxx+1 && ty>=miny-1 && ty<=maxy+1)
{
lookhere=ReadPixel(rastport,tx+x_dir,ty+y_dir);
if(lookhere==DOTCOLOR)
{
atedot++;
WritePixel(rastport,tx+x_dir,ty+y_dir);
INCSCORE(10);
if(--numdots==advspeed[speedindex])
{
speedindex++;
if(killsound(SND_BACKGRND))
playsound(SND_BACKGRND,0),playsound(SND_BACKGRND,0);
}
playsound(SND_DOT,1);
}
else if(lookhere==ENERGCOLOR)
{
atedot=1;
for(i=-1; i<2; i++) for(c=-1; c<2; c++) /* Erase energizer */
WritePixel(rastport,tx+(x_dir<<1)+c,ty+(y_dir<<1)+i);
INCSCORE(50);
if(--numdots==advspeed[speedindex])
{
speedindex++;
if(killsound(SND_BACKGRND))
playsound(SND_BACKGRND,0),playsound(SND_BACKGRND,0);
}
playsound(SND_DOT,1);
Energize();
}
}
if((!joyx)^(!joyy)) joy_dir =(joyy)?(1+joyy):(2-joyx);
if(x_dir || y_dir) dir_code=(y_dir)?(1+y_dir):(2-x_dir);
dvx=xposn[0]+XOFF-pdest_v->x;
dvy=yposn[0]+YOFF-pdest_v->y;
old_dcode = dir_code;
if((ABS(dvx)+ABS(dvy))<2 && joy_dir!=dir_code
&& pdest_v->next[joy_dir])
{
dir_code = joy_dir;
dvx=0;
dvy=0;
xposn[0]=pdest_v->x-XOFF;
yposn[0]=pdest_v->y-YOFF;
at_vertex = TRUE;
}
else at_vertex=((!dvx && !dvy) || (x_dir==y_dir));
if ((!joyx)^(!joyy)) /* if joy movement */
{
if (at_vertex)
{
if(joyx && pdest_v->next[joy_dir]
&& !(pdest_v->code[joy_dir]&FORBID))
{
pmv=pdest_v;
pdest_v=pdest_v->next[joy_dir]; /* Destination vertex */
x_dir=joyx; /* Direction we are now headed */
y_dir=0;
}
else if(joyy && pdest_v->next[1+joyy]
&& !(pdest_v->code[1+joyy]&FORBID))
{
pmv=pdest_v;
pdest_v=pdest_v->next[1+joyy];
x_dir=0;
y_dir=joyy;
}
else if ((!(pdest_v->next[joy_dir])
|| (pdest_v->code[joy_dir]&FORBID))
&& ((!(pdest_v->next[old_dcode])
|| (pdest_v->code[old_dcode]&FORBID))))
/* If(at_vertex && no (allowable) next vertex) dead end;stop */
{
x_dir=0;
y_dir=0;
}
else if (x_dir||y_dir) /* Joy in invalid dir on vertex */
{
pmv=pdest_v; /* There is a path in current dir - follow it */
pdest_v=pdest_v->next[old_dcode];
dir_code = old_dcode;
}
} /* End of block for if at a vertex */
else if (joyx && !(joyx+x_dir)) /* Reverses direction on edge */
{
x_dir=-x_dir; /* Reverse current direction */
tv=pdest_v; /* Swap pdest_v with last vertex */
pdest_v=pmv;
pmv=tv;
}
else if (joyy && !(joyy+y_dir)) /* Reverses dir along y */
{
y_dir=-y_dir; /* Reverse current direction */
tv=pdest_v; /* Swap pdest_v with last vertex */
pdest_v=pmv;
pmv=tv;
}
} /* End of block for if no button but movement on joystick */
else if (at_vertex && (y_dir || x_dir)) /* move but no joymove */
{
if(x_dir && (!pdest_v->next[old_dcode]
|| (pdest_v->code[old_dcode]&FORBID)))
x_dir=0;/* Stop @ Dead End */
else if(y_dir && (!pdest_v->next[old_dcode]
|| (pdest_v->code[old_dcode]&FORBID)))
y_dir=0;
else
{
pmv=pdest_v; /* Continue moving to next vertex */
pdest_v=pdest_v->next[old_dcode];
}
}
if (atedot<2)
{
xposn[0]+=x_dir;
yposn[0]+=y_dir;
}
else atedot=0;
WrapSprite(0,x_dir,y_dir); /* Wrap around routine */
spoff=((xposn[0]+yposn[0])>>1)&3;
spoff=(spoff>2) ? (1+3*dir_code) : (spoff+3*dir_code);
ChangeSprite(svp,&sprite[0],(short *)(pacmen+spoff));
if ((dead=MoveGhosts())<0) {
dead=-1;
--lives; /* Kill a PACMAN */
Die();
}
else {
ScrollDisplay(SCROLLMAYBE);
PrintScore();
}
if(dead>0) {
killallsound();
playsound(SND_MONSTER,1);
playsound(SND_MONSTER,1);
DeEnergize(dead-1,0); /* Eat a ghost! */
playsound(SND_EYES,0);
}
JoyRead(CTRLR_READ);
} /* End of main control loop */
return 0;
} /* End of loop to decrement lives. */
LONG Blank( PrefObject *Prefs )
{
LONG ToFrontCount = 0, Wid, Hei, Drops, x, y, r, i, incr, RetVal = OK;
struct RastPort *Rast;
struct Screen *Scr;
struct Window *Wnd;
Drops = Prefs[0].po_Level;
Scr = OpenScreenTags( 0L, SA_Depth, Prefs[2].po_Depth, SA_Quiet, TRUE,
SA_Overscan, OSCAN_STANDARD, SA_Behind, TRUE,
SA_DisplayID, Prefs[2].po_ModeID, TAG_DONE );
if( Scr )
{
Wid = Scr->Width;
Hei = Scr->Height;
Rast = &( Scr->RastPort );
SetRast( Rast, 0 );
for( i = 0; i < 4; i++ )
SetRGB4(&( Scr->ViewPort ), i, 4 * i, 4 * i, 4 * i );
Wnd = BlankMousePointer( Scr );
ScreenToFront( Scr );
while( RetVal == OK )
{
if(!( ++ToFrontCount % 60 ))
ScreenToFront( Scr );
if(!( ToFrontCount % Drops ))
SetRast(&( Scr->RastPort ), 0 );
r = RangeRand( Wid/13 ) + Wid/25;
x = RangeRand( Wid - 2*r ) + r;
y = RangeRand( Hei - 2*r ) + r;
incr = max( Wid/160, 1 );
for( i = 0; i < r; i += incr )
{
WaitTOF();
SetAPen( &Scr->RastPort,
( ULONG )RangeRand(( 1L << Prefs[2].po_Depth ) - 1 )
+ 1 );
DrawEllipse(&( Scr->RastPort ), x, y, i, i );
if( i )
{
SetAPen(&( Scr->RastPort ), 0 );
DrawEllipse(&( Scr->RastPort ), x, y, i - incr, i - incr );
}
}
RetVal = ContinueBlanking();
}
UnblankMousePointer( Wnd );
}
else
RetVal = FAILED;
if( Scr )
CloseScreen( Scr );
return RetVal;
}
// Show drag objects
void backdrop_show_drag(
BackdropInfo *info,
BackdropObject *first,
short x,
short y)
{
BackdropObject *object;
BOOL ok=0;
// We also won't move if the mouse position hasn't changed
if (info->last_x==x && info->last_y==y) return;
// Save coords
info->last_x=x;
info->last_y=y;
// Go through backdrop list
for (object=(BackdropObject *)info->objects.list.lh_Head;
object->node.ln_Succ;
object=(BackdropObject *)object->node.ln_Succ)
{
// Is object being dragged?
if (object->drag_info)
{
short ox,oy;
// Get object position relative to first object
ox=object->pos.Left-first->pos.Left;
oy=object->pos.Top-first->pos.Top;
// Offset by mouse coordinates
ox+=x;
oy+=y;
// Offset by drag offset and window offset
ox+=first->drag_x_offset+info->size.MinX-info->offset_x;
oy+=first->drag_y_offset+info->size.MinY-info->offset_y;
// Position image
object->drag_info->sprite.X=ox;
object->drag_info->sprite.Y=oy;
ok=1;
// Not dragging yet?
if (!(GUI->flags&GUIF_DRAGGING))
{
// Add bob to list
AddBob(&object->drag_info->bob,&GUI->drag_screen_rp);
}
}
}
// Update GEL list?
if (ok)
{
// Just started dragging?
if (!(GUI->flags&GUIF_DRAGGING))
{
// Set drag flag
GUI->flags|=GUIF_DRAGGING;
// Lock layer
LockLayers(&info->window->WScreen->LayerInfo);
}
// Sort GELs list
SortGList(&GUI->drag_screen_rp);
DrawDragList(&GUI->drag_screen_rp,&info->window->WScreen->ViewPort,(info->flags&BDIF_CUSTOM_DRAG)?DRAGF_CUSTOM:0);
WaitTOF();
}
}
