LONG Blank( PrefObject *Prefs )
{
struct Screen *Scr;
struct Window *Wnd;
LONG RetVal;
if( Scr = OpenScreenTags( NULL, SA_Depth, Prefs[0].po_Depth,
SA_Quiet, TRUE, SA_DisplayID, Prefs[0].po_ModeID,
SA_Behind, TRUE, SA_Overscan, OSCAN_STANDARD,
SA_ShowTitle, FALSE, SA_Title, "Garshnescreen",
TAG_DONE ))
{
SetRGB4(&( Scr->ViewPort ), 0, 0, 0, 0 );
ColorTable = RainbowPalette( Scr, 0L, 1L, 0L );
Wnd = BlankMousePointer( Scr );
do
RetVal = Dragon( Scr, Scr->Width, Scr->Height );
while( RetVal == OK );
UnblankMousePointer( Wnd );
RainbowPalette( 0L, ColorTable, 1L, 0L );
CloseScreen( Scr );
}
else
RetVal = FAILED;
return RetVal;
}
VOID InternalBlank( VOID )
{
if( !ServerScr )
{
ServerScr = OpenScreenTags( 0L, SA_DisplayID, getTopScreenMode(),
SA_Depth, 1, SA_Behind, 1, SA_Quiet, TRUE,
TAG_END );
if( ServerScr )
{
Wnd = BlankMousePointer( ServerScr );
SetRGB4(&( ServerScr->ViewPort ), 0, 0, 0, 0 );
SetRGB4(&( ServerScr->ViewPort ), 1, 0, 0, 0 );
ScreenToFront( ServerScr );
Blanking = TRUE;
}
}
}
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;
}
/*>ProcessToolTypes(void)
----------------------
Alters defaults based on icon tool types. Handles the following
tooltypes:
Size=<x> <y> Output dimensions
Offset=<x> <y> Output offset
HPGLMargin=<x> <y> HPGL paper margins
Title=<Font> <Size> Title font and size
XTitle=<Font> <Size> X-axis title font and size
YTitle=<Font> <Size> Y-axis title font and size
XLabel=<Font> <Size> X-axis label font and size
YLabel=<Font> <Size> Y-axis label font and size
Key=<Font> <Size> Key font and size
Extralabel=<Font> <Size> Extra label font and size
Hatching=ON|OFF Use hatching or shading
HatchControl=<thick> <space> Thickness and spacing of hatching
Pen0=<R> <G> <B> Pen colours
Pen1=<R> <G> <B>
Pen2=<R> <G> <B>
Pen3=<R> <G> <B>
DIR=<directory> Default directory
NOSHANGHAI Stops editor SHANGHAI under V2.0
AXISBOUNDS EPSF bounding box set to size given by paper
01.07.92 Original
02.07.92 Added pen colours. Also rebuilds windows if colours have been
set.
06.07.92 Added default directory.
04.08.92 Added NOSHANGHAI
15.09.92 Added AXISBOUNDS
*/
ProcessToolTypes(void)
{
struct DiskObject *DiskObj = NULL;
char *valptr,
string[80];
double value,
value2;
int ival1,
ival2,
ival3,
redowindows = FALSE;
if((DiskObj = (struct DiskObject *)
GetDiskObject(WBenchMsg->sm_ArgList->wa_Name)) != NULL)
{
/* Tooltype: Size=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Size")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xsize = value;
output.ysize = value2;
}
/* Tooltype: Offset=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Offset")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xoffset = value;
output.yoffset = value2;
}
/* Tooltype: HPGLMargin=<x> <y> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"HPGLMargin")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.xmargin = value;
output.ymargin = value2;
}
/* Tooltype: Title=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Title")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(GTitle.PSFont,string);
GTitle.PSSize = value;
}
/* Tooltype: XAxTitle=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"XTitle")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(XTitle.PSFont,string);
XTitle.PSSize = value;
}
/* Tooltype: YAxTitle=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"YTitle")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(YTitle.PSFont,string);
YTitle.PSSize = value;
}
/* Tooltype: XLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"XLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(XLabel.PSFont,string);
XLabel.PSSize = value;
}
/* Tooltype: YLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"YLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(YLabel.PSFont,string);
YLabel.PSSize = value;
}
/* Tooltype: Key=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Key")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(Defaults.KeyPSFont,string);
Defaults.KeyPSSize = value;
}
/* Tooltype: ExtraLabel=<font> <size> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"ExtraLabel")) != NULL)
if(sscanf(valptr,"%s %lf",string,&value) == 2)
{
strcpy(Defaults.LabelPSFont,string);
Defaults.LabelPSSize = value;
}
/* Tooltype: Hatching=ON|OFF */
if(MatchToolValue(FindToolType(DiskObj->do_ToolTypes,"Hatching"),"ON"))
output.hatching = TRUE;
if(MatchToolValue(FindToolType(DiskObj->do_ToolTypes,"Hatching"),"OFF"))
output.hatching = FALSE;
/* Tooltype: HatchControl=<thickness> <spacing> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"HatchControl")) != NULL)
if(sscanf(valptr,"%lf %lf",&value,&value2) == 2)
{
output.hatchthick = value;
output.hatchspace = value2;
}
/* Tooltype: Pen0=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen0")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,0,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen1=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen1")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,1,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen2=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen2")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,2,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: Pen3=<R> <G> <B> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"Pen3")) != NULL)
if(sscanf(valptr,"%d %d %d",&ival1,&ival2,&ival3) == 3)
{
ival1 = RANGECHECK(ival1,0,15);
ival2 = RANGECHECK(ival2,0,15);
ival3 = RANGECHECK(ival3,0,15);
SetRGB4(&MyScreen->ViewPort,3,(UBYTE)ival1,(UBYTE)ival2,(UBYTE)ival3);
redowindows = TRUE;
}
/* Tooltype: DIR=<directory> */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"DIR")) != NULL)
strcpy(Defaults.directory,valptr);
/* Tooltype: NOSHANGHAI */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"NOSHANGHAI")) != NULL)
display.shanghai = FALSE;
/* Tooltype: AXISBOUNDS */
if((valptr = FindToolType(DiskObj->do_ToolTypes,"AXISBOUNDS")) != NULL)
output.fixbounds = FALSE;
FreeDiskObject(DiskObj);
/*
// if(redowindows)
// {
// FreeAllGadgets();
// BuildAllWindows();
// }
*/
}
return(0);
}
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;
}
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;
}
