home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Significant Series Windows
/
significantserieswindows1993.i
/
0winrun
/
3369
/
hyperoid.c
< prev
next >
Wrap
C/C++ Source or Header
|
1991-11-01
|
45KB
|
1,852 lines
//
// HYPEROID - a neato game
//
// Version: 1.1 Copyright (C) 1990,91 Hutchins Software
// This software is licenced under the GNU General Public Licence
// Please read the associated legal documentation
// Author: Edward Hutchins
// Internet: eah1@cec1.wustl.edu
// USNail: c/o Edward Hutchins, 63 Ridgemoor Dr., Clayton, MO, 63105
// Revisions:
// 10/31/91 made game better/harder - Ed.
//
// Music: R.E.M./The Cure/Ministry/Front 242/The Smiths/New Order/Hendrix...
// Beers: Bass Ale, Augsberger Dark
//
#include "hyperoid.h"
//
// imports
//
IMPORT POINT LetterPart[] FROM( roidsupp.c );
IMPORT NPSTR szNumberDesc[] FROM( roidsupp.c );
IMPORT NPSTR szLetterDesc[] FROM( roidsupp.c );
//
// globals
//
GLOBAL CHAR szAppName[32];
GLOBAL HANDLE hAppInst;
GLOBAL HWND hAppWnd;
GLOBAL HPALETTE hAppPalette;
GLOBAL INT nDrawDelay;
GLOBAL INT nLevel;
GLOBAL INT nSafe;
GLOBAL INT nShield;
GLOBAL INT nBomb;
GLOBAL INT nBadGuys;
GLOBAL LONG lScore;
GLOBAL LONG lLastLife;
GLOBAL LONG lHighScore;
GLOBAL BOOL bRestart;
GLOBAL BOOL bPaused;
GLOBAL BOOL bBW;
GLOBAL INT vkShld;
GLOBAL INT vkClkw;
GLOBAL INT vkCtrClkw;
GLOBAL INT vkThrst;
GLOBAL INT vkRvThrst;
GLOBAL INT vkFire;
GLOBAL INT vkBomb;
GLOBAL NPOBJ npPlayer;
GLOBAL LIST FreeList;
GLOBAL LIST RoidList;
GLOBAL LIST ShotList;
GLOBAL LIST FlameList;
GLOBAL LIST SpinnerList;
GLOBAL LIST HunterList;
GLOBAL LIST HunterShotList;
GLOBAL LIST SwarmerList;
GLOBAL LIST LetterList;
GLOBAL LIST BonusList;
GLOBAL INT nCos[DEGREE_SIZE];
GLOBAL INT nSin[DEGREE_SIZE];
GLOBAL HPEN hPen[PALETTE_SIZE];
GLOBAL OBJ Obj[MAX_OBJS];
GLOBAL HBITMAP hBitmap[IDB_MAX];
//
// locals
//
LOCAL DWORD dwSeed;
LOCAL INT nScoreLen;
LOCAL CHAR szScore[40];
LOCAL RECT rectScoreClip;
LOCAL RECT rectShotClip;
LOCAL POINT Player[] =
{ {0, 0}, {160, 150}, {0, 250}, {96, 150}, {0, 0} };
LOCAL POINT Spinner[] =
{ {160, 150}, {224, 100}, {96, 100}, {32, 150}, {160, 150} };
LOCAL POINT Swarmer[] =
{ {0, 100}, {64, 100}, {128, 100}, {192, 100}, {0, 100} };
LOCAL POINT Hunter[] =
{
{160, 150}, {0, 250}, {192, 30}, {64, 30},
{0, 250}, {96, 150}, {128, 150}, {160, 150}
};
LOCAL POINT Bonus[] =
{ {0, 150}, {102, 150}, {205, 150}, {51, 150}, {154, 150}, {0, 150} };
//
// KillBadGuy - kill off a badguy (made into a macro)
//
#define KillBadGuy() \
((--nBadGuys <= 0)?(SetRestart( RESTART_NEXTLEVEL ),TRUE):FALSE)
//
// arand - pseudorandom number from 0 to x-1 (thanks antman!)
//
INT NEAR PASCAL arand( INT x )
{
dwSeed = dwSeed * 0x343fd + 0x269ec3;
return( (INT)(((dwSeed >> 16) & 0x7fff) * x >> 15) );
}
//
// AddHead - add an object to the head of a list
//
VOID NEAR PASCAL AddHead( NPLIST npList, NPNODE npNode )
{
if (npList->npHead)
{
npNode->npNext = npList->npHead;
npNode->npPrev = NULL;
npList->npHead = (npList->npHead->npPrev = npNode);
}
else // add to an empty list
{
npList->npHead = npList->npTail = npNode;
npNode->npNext = npNode->npPrev = NULL;
}
}
//
// RemHead - remove the first element in a list
//
NPNODE NEAR PASCAL RemHead( NPLIST npList )
{
if (npList->npHead)
{
NPNODE npNode = npList->npHead;
if (npList->npTail != npNode)
{
npList->npHead = npNode->npNext;
npNode->npNext->npPrev = NULL;
}
else npList->npHead = npList->npTail = NULL;
return( npNode );
}
else return( NULL );
}
//
// Remove - remove an arbitrary element from a list
//
VOID NEAR PASCAL Remove( NPLIST npList, NPNODE npNode )
{
if (npNode->npPrev) npNode->npPrev->npNext = npNode->npNext;
else npList->npHead = npNode->npNext;
if (npNode->npNext) npNode->npNext->npPrev = npNode->npPrev;
else npList->npTail = npNode->npPrev;
}
//
// DrawObject - draw a single object
//
VOID NEAR PASCAL DrawObject( HDC hDC, NPOBJ npObj )
{
INT nCnt;
INT nDir = (npObj->nDir += npObj->nSpin);
INT x = (npObj->Pos.x += npObj->Vel.x);
INT y = (npObj->Pos.y += npObj->Vel.y);
POINT Pts[MAX_PTS];
if (x < -CLIP_COORD) npObj->Pos.x = x = CLIP_COORD;
else if (x > CLIP_COORD) npObj->Pos.x = x = -CLIP_COORD;
if (y < -CLIP_COORD) npObj->Pos.y = y = CLIP_COORD;
else if (y > CLIP_COORD) npObj->Pos.y = y = -CLIP_COORD;
for (nCnt = npObj->byPts - 1; nCnt >= 0; --nCnt)
{
WORD wDeg = DEG( npObj->Pts[nCnt].x + nDir );
INT nLen = npObj->Pts[nCnt].y;
Pts[nCnt].x = x + MULDEG( nLen, nCos[wDeg] );
Pts[nCnt].y = y + MULDEG( nLen, nSin[wDeg] );
}
if (npObj->byPts > 1)
{
SelectObject( hDC, hPen[BLACK] );
Polyline( hDC, npObj->Old, npObj->byPts );
if (npObj->nCount > 0)
{
SelectObject( hDC, hPen[npObj->byColor] );
Polyline( hDC, Pts, npObj->byPts );
for (nCnt = npObj->byPts - 1; nCnt >= 0; --nCnt)
npObj->Old[nCnt] = Pts[nCnt];
}
}
else // just a point
{
SetPixel( hDC, npObj->Old[0].x, npObj->Old[0].y, PALETTEINDEX( BLACK ) );
if (npObj->nCount > 0)
{
SetPixel( hDC, Pts[0].x, Pts[0].y, PALETTEINDEX( npObj->byColor ) );
npObj->Old[0] = Pts[0];
}
}
}
//
// SetRestart - set the restart timer
//
VOID NEAR PASCAL SetRestart( RESTART_MODE Restart )
{
POINT Pt;
CHAR szBuff[32];
if (bRestart) return;
SetTimer( hAppWnd, RESTART_TIMER, RESTART_DELAY, NULL );
bRestart = TRUE;
Pt.x = Pt.y = 0;
switch (Restart)
{
case RESTART_GAME:
SpinLetters( "GAME OVER", Pt, Pt, RED, 400 );
break;
case RESTART_LEVEL:
PrintLetters( "GET READY", Pt, Pt, BLUE, 300 );
break;
case RESTART_NEXTLEVEL:
wsprintf( szBuff, "LEVEL %u", nLevel + 1 );
PrintLetters( szBuff, Pt, Pt, BLUE, 300 );
break;
}
}
//
// PrintPlayerMessage - show the player a status message
//
VOID NEAR PASCAL PrintPlayerMessage( NPSTR npszText )
{
POINT Pos, Vel;
Pos = npPlayer->Pos;
Pos.y -= 400;
Vel.x = 0;
Vel.y = -50;
PrintLetters( npszText, Pos, Vel, GREEN, 150 );
}
//
// AddExtraLife - give the player another life
//
VOID NEAR PASCAL AddExtraLife( VOID )
{
PrintPlayerMessage( "EXTRA LIFE" );
++npPlayer->nCount;
npPlayer->byColor = (BYTE)(BLACK + npPlayer->nCount);
if (npPlayer->byColor > WHITE) npPlayer->byColor = WHITE;
}
//
// Hit - something hit an object, do fireworks
//
VOID NEAR PASCAL Hit( HDC hDC, NPOBJ npObj )
{
INT nCnt;
for (nCnt = 0; nCnt < 6; ++nCnt)
{
NPOBJ npFlame = RemHeadObj( &FreeList );
if (!npFlame) return;
npFlame->Pos.x = npObj->Pos.x;
npFlame->Pos.y = npObj->Pos.y;
npFlame->Vel.x = npObj->Vel.x;
npFlame->Vel.y = npObj->Vel.y;
npFlame->nDir = npObj->nDir + (nCnt * DEGREE_SIZE) / 6;
npFlame->nSpin = 0;
npFlame->nCount = 10 + arand( 8 );
npFlame->byColor = YELLOW;
npFlame->byPts = 1;
npFlame->Pts[0].x = npFlame->Pts[0].y = 0;
ACCEL( npFlame, npFlame->nDir, 50 - npFlame->nCount );
AddHeadObj( &FlameList, npFlame );
}
}
//
// Explode - explode an object
//
VOID NEAR PASCAL Explode( HDC hDC, NPOBJ npObj )
{
INT nCnt, nSize = npObj->byPts;
DrawObject( hDC, npObj );
for (nCnt = 0; nCnt < nSize; ++nCnt)
{
NPOBJ npFlame;
if (arand( 2 )) continue;
if (!(npFlame = RemHeadObj( &FreeList ))) return;
npFlame->Pos.x = npObj->Pos.x;
npFlame->Pos.y = npObj->Pos.y;
npFlame->Vel.x = npObj->Vel.x;
npFlame->Vel.y = npObj->Vel.y;
npFlame->nDir = npObj->nDir + nCnt * DEGREE_SIZE / nSize + arand( 32 );
npFlame->nSpin = arand( 31 ) - 15;
npFlame->nCount = 25 + arand( 16 );
npFlame->byColor = npObj->byColor;
npFlame->byPts = 2;
npFlame->Pts[0] = npObj->Pts[nCnt];
if (nCnt == nSize - 1) npFlame->Pts[1] = npObj->Pts[0];
else npFlame->Pts[1] = npObj->Pts[nCnt + 1];
ACCEL( npFlame, npFlame->nDir, 60 - npFlame->nCount );
AddHeadObj( &FlameList, npFlame );
}
Hit( hDC, npObj );
}
//
// HitPlayer - blow up the player
//
BOOL NEAR PASCAL HitPlayer( HDC hDC, NPOBJ npObj )
{
POINT Vel;
INT nMass, nSpin;
if (nSafe || (npPlayer->nCount <= 0)) return( FALSE );
// rumble and shake both objects
nMass = npPlayer->nMass + npObj->nMass;
nSpin = npPlayer->nSpin + npObj->nSpin;
npObj->nSpin -= MulDiv( nSpin, npPlayer->nMass, nMass );
npPlayer->nSpin -= MulDiv( nSpin, npObj->nMass, nMass );
Vel.x = npPlayer->Vel.x - npObj->Vel.x;
Vel.y = npPlayer->Vel.y - npObj->Vel.y;
npObj->Vel.x += MulDiv( Vel.x, npPlayer->nMass, nMass );
npObj->Vel.y += MulDiv( Vel.y, npPlayer->nMass, nMass );
npPlayer->Vel.x -= MulDiv( Vel.x, npObj->nMass, nMass );
npPlayer->Vel.y -= MulDiv( Vel.y, npObj->nMass, nMass );
if (--npPlayer->nCount)
{
npPlayer->byColor = (BYTE)(BLACK + npPlayer->nCount);
if (npPlayer->byColor > WHITE) npPlayer->byColor = WHITE;
Hit( hDC, npPlayer );
return( TRUE );
}
// final death
npPlayer->byColor = WHITE;
Explode( hDC, npPlayer );
SetRestart( RESTART_GAME );
return( FALSE );
}
//
// CreateLetter - make a new letter object
//
NPOBJ FAR PASCAL CreateLetter( CHAR cLetter, INT nSize )
{
NPOBJ npLtr;
INT nCnt;
NPSTR npDesc;
if (cLetter >= '0' && cLetter <= '9') npDesc = szNumberDesc[cLetter - '0'];
else if (cLetter >= 'A' && cLetter <= 'Z') npDesc = szLetterDesc[cLetter - 'A'];
else if (cLetter >= 'a' && cLetter <= 'z') npDesc = szLetterDesc[cLetter - 'a'];
else if (cLetter == '.') npDesc = "l";
else return( NULL );
if (npLtr = RemHeadObj( &FreeList ))
{
npLtr->nMass = 1;
npLtr->nDir = 0;
npLtr->nSpin = 0;
npLtr->nCount = 40;
npLtr->byColor = WHITE;
npLtr->byPts = (BYTE)(nCnt = strlen( npDesc ));
while (nCnt--)
{
npLtr->Pts[nCnt] = LetterPart[npDesc[nCnt] - 'a'];
npLtr->Pts[nCnt].y = MulDiv( npLtr->Pts[nCnt].y, nSize, LETTER_MAX );
}
AddHeadObj( &LetterList, npLtr );
}
return( npLtr );
}
//
// DrawLetters - draw letters and such
//
VOID NEAR PASCAL DrawLetters( HDC hDC )
{
NPOBJ npLtr, npNext;
for (npLtr = HeadObj( &LetterList ); npLtr; npLtr = npNext)
{
npNext = NextObj( npLtr );
switch (--npLtr->nCount)
{
case 3:
--npLtr->byColor;
break;
case 0:
RemoveObj( &LetterList, npLtr );
AddHeadObj( &FreeList, npLtr );
break;
}
DrawObject( hDC, npLtr );
}
}
//
// CreateBonus - make a new bonus object
//
VOID NEAR PASCAL CreateBonus( VOID )
{
NPOBJ npBonus;
INT nCnt;
if (npBonus = RemHeadObj( &FreeList ))
{
npBonus->Pos.x = arand( CLIP_COORD * 2 ) - CLIP_COORD;
npBonus->Pos.y = -CLIP_COORD;
npBonus->Vel.x = npBonus->Vel.y = 0;
npBonus->nDir = arand( DEGREE_SIZE );
npBonus->nSpin = (arand( 2 ) ? 12 : -12);
npBonus->nCount = arand( 4 ) + 1;
npBonus->nDelay = 64 + arand( 128 );
npBonus->nMass = 1;
npBonus->byColor = (BYTE)(WHITE + (npBonus->nCount * 2));
npBonus->byPts = DIM(Bonus);
for (nCnt = 0; nCnt < DIM(Bonus); ++nCnt)
npBonus->Pts[nCnt] = Bonus[nCnt];
ACCEL( npBonus, npBonus->nDir, 30 + nLevel * 2 );
AddHeadObj( &BonusList, npBonus );
}
}
//
// DrawBonuses - process and draw the bonus list
//
VOID NEAR PASCAL DrawBonuses( HDC hDC )
{
NPOBJ npBonus, npNext;
LOCAL INT nNextBonus = 1000;
if (nBadGuys && (--nNextBonus < 0))
{
CreateBonus();
nNextBonus = 1000;
}
for (npBonus = HeadObj( &BonusList ); npBonus; npBonus = npNext)
{
NPOBJ npShot;
INT nDelta;
RECT rect;
npNext = NextObj( npBonus );
MKRECT( &rect, npBonus->Pos, 150 );
if (PTINRECT( &rect, npPlayer->Pos ))
{
if (npPlayer->nCount > 0) switch (npBonus->nCount)
{
case 1:
{
CHAR szBuff[32];
LONG lBonus = 1000L * nLevel;
if (lBonus == 0) lBonus = 500;
lScore += lBonus;
wsprintf( szBuff, "%ld", lBonus );
PrintPlayerMessage( szBuff );
}
break;
case 2:
nSafe = 15;
++nShield;
npPlayer->byColor = GREEN;
PrintPlayerMessage( "EXTRA SHIELD" );
break;
case 3:
++nBomb;
PrintPlayerMessage( "EXTRA BOMB" );
break;
case 4:
AddExtraLife();
break;
}
npBonus->nCount = 0;
Explode( hDC, npBonus );
RemoveObj( &BonusList, npBonus );
AddHeadObj( &FreeList, npBonus );
}
else if (INTRECT(&rect, &rectShotClip))
{
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
{
if (!PTINRECT( &rect, npShot->Pos )) continue;
npShot->nCount = 1;
npBonus->nCount = 0;
Explode( hDC, npBonus );
RemoveObj( &BonusList, npBonus );
AddHeadObj( &FreeList, npBonus );
}
}
if (npBonus->nCount && --npBonus->nDelay <= 0)
{
--npBonus->nCount;
npBonus->nDelay = 64 + arand( 128 );
npBonus->byColor = (BYTE)(WHITE + (npBonus->nCount * 2));
if (npBonus->nCount == 0)
{
Explode( hDC, npBonus );
RemoveObj( &BonusList, npBonus );
AddHeadObj( &FreeList, npBonus );
}
}
nDelta = npPlayer->Pos.x - npBonus->Pos.x;
while (nDelta < -16 || nDelta > 16) nDelta /= 2;
npBonus->Vel.x += nDelta - npBonus->Vel.x / 16;
nDelta = npPlayer->Pos.y - npBonus->Pos.y;
while (nDelta < -16 || nDelta > 16) nDelta /= 2;
npBonus->Vel.y += nDelta - npBonus->Vel.y / 16;
DrawObject( hDC, npBonus );
}
}
//
// DrawHunterShots - process and draw the hunter shot list
//
VOID NEAR PASCAL DrawHunterShots( HDC hDC )
{
NPOBJ npShot, npNext;
for (npShot = HeadObj( &HunterShotList ); npShot; npShot = npNext)
{
RECT rect;
npNext = NextObj( npShot );
MKRECT( &rect, npShot->Pos, 200 );
if (PTINRECT( &rect, npPlayer->Pos ))
{
HitPlayer( hDC, npShot );
npShot->nCount = 1;
}
switch (--npShot->nCount)
{
case 7:
npShot->byColor = DKGREEN;
break;
case 0:
RemoveObj( &HunterShotList, npShot );
AddHeadObj( &FreeList, npShot );
break;
}
DrawObject( hDC, npShot );
}
}
//
// FireHunterShot - fire a hunter bullet
//
VOID NEAR PASCAL FireHunterShot( NPOBJ npHunt )
{
NPOBJ npShot;
if (npShot = RemHeadObj( &FreeList ))
{
npShot->Pos.x = npHunt->Pos.x;
npShot->Pos.y = npHunt->Pos.y;
npShot->Vel.x = npHunt->Vel.x;
npShot->Vel.y = npHunt->Vel.y;
npShot->nMass = 8;
npShot->nDir = npHunt->nDir + arand( 5 ) - 2;
npShot->nSpin = (arand( 2 ) ? 10 : -10);
npShot->nCount = 16 + arand( 8 );
npShot->byColor = GREEN;
npShot->byPts = 2;
npShot->Pts[0].x = 128;
npShot->Pts[0].y = 50;
npShot->Pts[1].x = 0;
npShot->Pts[1].y = 50;
ACCEL( npShot, npShot->nDir, 200 + npShot->nCount );
AddHeadObj( &HunterShotList, npShot );
}
}
//
// CreateHunter - make a new hunter
//
VOID NEAR PASCAL CreateHunter( VOID )
{
NPOBJ npHunt;
INT nCnt;
if (npHunt = RemHeadObj( &FreeList ))
{
npHunt->Pos.x = arand( CLIP_COORD * 2 ) - CLIP_COORD;
npHunt->Pos.y = -CLIP_COORD;
npHunt->Vel.x = npHunt->Vel.y = 0;
npHunt->nMass = 256;
npHunt->nDir = arand( DEGREE_SIZE );
npHunt->nSpin = 0;
npHunt->nCount = 1 + arand( nLevel );
npHunt->nDelay = 2 + arand( 10 );
npHunt->byColor = CYAN;
npHunt->byPts = DIM(Hunter);
for (nCnt = 0; nCnt < DIM(Hunter); ++nCnt)
npHunt->Pts[nCnt] = Hunter[nCnt];
ACCEL( npHunt, npHunt->nDir, 30 + nLevel * 2 );
AddHeadObj( &HunterList, npHunt );
++nBadGuys;
}
}
//
// DrawHunters - process and draw the hunter list
//
VOID NEAR PASCAL DrawHunters( HDC hDC )
{
NPOBJ npHunt, npNext;
LOCAL INT nNextHunter = 200;
if (nBadGuys && (--nNextHunter < 0))
{
CreateHunter();
nNextHunter = 1000 + arand( 1000 ) - nLevel * 8;
}
for (npHunt = HeadObj( &HunterList ); npHunt; npHunt = npNext)
{
NPOBJ npShot;
RECT rect;
npNext = NextObj( npHunt );
MKRECT( &rect, npHunt->Pos, 200 );
if (PTINRECT( &rect, npPlayer->Pos ))
{
HitPlayer( hDC, npHunt );
--npHunt->nCount;
if (npHunt->nCount < 1)
{
KillBadGuy();
npHunt->byColor = CYAN;
Explode( hDC, npHunt );
RemoveObj( &HunterList, npHunt );
AddHeadObj( &FreeList, npHunt );
}
else if (npHunt->nCount == 1) npHunt->byColor = DKCYAN;
}
else if (INTRECT(&rect, &rectShotClip))
{
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
{
if (!PTINRECT( &rect, npShot->Pos )) continue;
npShot->nCount = 1;
lScore += npHunt->nCount * 1000;
if (--npHunt->nCount < 1)
{
KillBadGuy();
npHunt->byColor = CYAN;
Explode( hDC, npHunt );
RemoveObj( &HunterList, npHunt );
AddHeadObj( &FreeList, npHunt );
}
else
{
if (npHunt->nCount == 1) npHunt->byColor = DKCYAN;
Hit( hDC, npHunt );
}
break;
}
}
ACCEL( npHunt, npHunt->nDir, 8 );
npHunt->Vel.x -= npHunt->Vel.x / 16;
npHunt->Vel.y -= npHunt->Vel.y / 16;
if (--npHunt->nDelay <= 0)
{
npHunt->nDelay = arand( 10 );
npHunt->nSpin = arand( 11 ) - 5;
FireHunterShot( npHunt );
}
DrawObject( hDC, npHunt );
}
}
//
// CreateSwarmer - make a new swarmer
//
VOID NEAR PASCAL CreateSwarmer( POINT Pos, INT nDir, INT nCount )
{
NPOBJ npSwarm;
INT nCnt;
if (npSwarm = RemHeadObj( &FreeList ))
{
npSwarm->Pos = Pos;
npSwarm->Vel.x = npSwarm->Vel.y = 0;
npSwarm->nDir = nDir;
npSwarm->nSpin = arand( 31 ) - 15;
npSwarm->nCount = nCount;
npSwarm->nDelay = 64 + arand( 64 );
npSwarm->nMass = 32;
npSwarm->byColor = DKGREEN;
npSwarm->byPts = DIM(Swarmer);
for (nCnt = 0; nCnt < DIM(Swarmer); ++nCnt)
{
npSwarm->Pts[nCnt] = Swarmer[nCnt];
npSwarm->Pts[nCnt].y += nCount * 10;
}
ACCEL( npSwarm, npSwarm->nDir, 30 + nLevel * 2 );
AddHeadObj( &SwarmerList, npSwarm );
++nBadGuys;
}
}
//
// DrawSwarmers - process and draw the swarmer list
//
VOID NEAR PASCAL DrawSwarmers( HDC hDC )
{
NPOBJ npSwarm, npNext;
LOCAL INT nNextSwarmer = 1000;
if (nBadGuys && (--nNextSwarmer < 0))
{
POINT Pos;
Pos.x = arand( CLIP_COORD * 2 ) - CLIP_COORD;
Pos.y = -CLIP_COORD;
CreateSwarmer( Pos, arand( DEGREE_SIZE ), 8 + nLevel * 2 );
nNextSwarmer = 1000 + arand( 500 ) - nLevel * 4;
}
for (npSwarm = HeadObj( &SwarmerList ); npSwarm; npSwarm = npNext)
{
NPOBJ npShot;
RECT rect;
npNext = NextObj( npSwarm );
MKRECT( &rect, npSwarm->Pos, 150 + npSwarm->nCount * 10 );
if (PTINRECT( &rect, npPlayer->Pos ))
{
HitPlayer( hDC, npSwarm );
npSwarm->nCount = 0;
}
else if (INTRECT(&rect, &rectShotClip))
{
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
{
if (!PTINRECT( &rect, npShot->Pos )) continue;
npShot->nCount = 1;
lScore += npSwarm->nCount * 25;
npSwarm->nCount = 0;
break;
}
}
if (npSwarm->nCount <= 0)
{
npSwarm->byColor = GREEN;
KillBadGuy();
Explode( hDC, npSwarm );
RemoveObj( &SwarmerList, npSwarm );
AddHeadObj( &FreeList, npSwarm );
}
else
{
if ((npSwarm->nCount > 1) && (--npSwarm->nDelay <= 0))
{
INT nDir = arand( DEGREE_SIZE );
INT nCount = npSwarm->nCount / 2;
CreateSwarmer( npSwarm->Pos, nDir, nCount );
nCount = npSwarm->nCount - nCount;
CreateSwarmer( npSwarm->Pos, nDir + 128, nCount );
npSwarm->nCount = 0;
}
DrawObject( hDC, npSwarm );
}
}
}
//
// CreateSpinner - make a new spinner
//
VOID NEAR PASCAL CreateSpinner( VOID )
{
NPOBJ npSpin;
INT nCnt;
if (npSpin = RemHeadObj( &FreeList ))
{
npSpin->Pos.x = arand( CLIP_COORD * 2 ) - CLIP_COORD;
npSpin->Pos.y = -CLIP_COORD;
npSpin->Vel.x = npSpin->Vel.y = 0;
npSpin->nDir = arand( DEGREE_SIZE );
npSpin->nSpin = -12;
npSpin->nCount = 1 + arand( nLevel );
npSpin->nMass = 64 + npSpin->nCount * 32;
npSpin->byColor = (BYTE)(MAGENTA - npSpin->nCount);
npSpin->byPts = DIM(Spinner);
for (nCnt = 0; nCnt < DIM(Spinner); ++nCnt)
npSpin->Pts[nCnt] = Spinner[nCnt];
ACCEL( npSpin, npSpin->nDir, 30 + nLevel * 2 );
AddHeadObj( &SpinnerList, npSpin );
++nBadGuys;
}
}
//
// DrawSpinners - process and draw the spinner list
//
VOID NEAR PASCAL DrawSpinners( HDC hDC )
{
NPOBJ npSpin, npNext;
LOCAL INT nNextSpinner = 1000;
if (nBadGuys && (--nNextSpinner < 0))
{
CreateSpinner();
nNextSpinner = 100 + arand( 900 ) - nLevel * 2;
}
for (npSpin = HeadObj( &SpinnerList ); npSpin; npSpin = npNext)
{
NPOBJ npShot;
INT nDelta;
RECT rect;
npNext = NextObj( npSpin );
MKRECT( &rect, npSpin->Pos, 150 );
if (PTINRECT( &rect, npPlayer->Pos ))
{
HitPlayer( hDC, npSpin );
--npSpin->nCount;
npSpin->byColor = (BYTE)(MAGENTA - npSpin->nCount);
if (npSpin->nCount < 1)
{
KillBadGuy();
Explode( hDC, npSpin );
RemoveObj( &SpinnerList, npSpin );
AddHeadObj( &FreeList, npSpin );
}
}
else if (INTRECT(&rect, &rectShotClip))
{
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
{
if (!PTINRECT( &rect, npShot->Pos )) continue;
npShot->nCount = 1;
lScore += npSpin->nCount * 500;
npSpin->byColor = (BYTE)(MAGENTA - (--npSpin->nCount));
if (npSpin->nCount < 1)
{
KillBadGuy();
Explode( hDC, npSpin );
RemoveObj( &SpinnerList, npSpin );
AddHeadObj( &FreeList, npSpin );
}
else Hit( hDC, npSpin );
break;
}
}
nDelta = npPlayer->Pos.x - npSpin->Pos.x;
while (nDelta < -16 || nDelta > 16) nDelta /= 2;
npSpin->Vel.x += nDelta - npSpin->Vel.x / 16;
nDelta = npPlayer->Pos.y - npSpin->Pos.y;
while (nDelta < -16 || nDelta > 16) nDelta /= 2;
npSpin->Vel.y += nDelta - npSpin->Vel.y / 16;
DrawObject( hDC, npSpin );
}
}
//
// CreateRoid - make a new asteroid
//
VOID NEAR PASCAL CreateRoid( POINT Pos, POINT Vel, INT nSides, BYTE byColor,
INT nDir, INT nSpeed, INT nSpin )
{
NPOBJ npRoid;
INT nCnt;
if (npRoid = RemHeadObj( &FreeList ))
{
npRoid->Pos = Pos;
npRoid->Vel = Vel;
npRoid->nMass = nSides * 128;
npRoid->nDir = nDir;
npRoid->nSpin = nSpin + arand( 11 ) - 5;
npRoid->nCount = nSides * 100;
npRoid->byColor = byColor;
npRoid->byPts = (BYTE)(nSides + 1);
for (nCnt = 0; nCnt < nSides; ++nCnt)
{
npRoid->Pts[nCnt].x = nCnt * DEGREE_SIZE / nSides + arand( 30 );
npRoid->Pts[nCnt].y = (nSides - 1) * 100 + 20 + arand( 80 );
}
npRoid->Pts[nSides] = npRoid->Pts[0];
ACCEL( npRoid, nDir, nSpeed );
AddHeadObj( &RoidList, npRoid );
++nBadGuys;
}
}
//
// BreakRoid - break up an asteroid
//
VOID NEAR PASCAL BreakRoid( HDC hDC, NPOBJ npRoid, NPOBJ npShot )
{
INT nCnt, nNew;
lScore += npRoid->nCount;
if (npShot) npShot->nCount = 1;
switch (npRoid->byPts)
{
case 8:
nNew = 2 + arand( 3 );
break;
case 7:
nNew = 1 + arand( 3 );
break;
case 6:
nNew = 1 + arand( 2 );
break;
case 5:
nNew = arand( 2 );
break;
default:
nNew = 0;
break;
}
if (nNew == 1) // don't explode outward
{
POINT Pt = npRoid->Pos;
Pt.x += arand( 301 ) - 150; Pt.y += arand( 301 ) - 150;
CreateRoid( Pt, npRoid->Vel, npRoid->byPts - (nNew + 1),
npRoid->byColor, npShot->nDir, 8, npRoid->nSpin );
}
else if (nNew > 0)
{
INT nSpeed = npRoid->nSpin * npRoid->nSpin * nNew + 16;
for (nCnt = 0; nCnt < nNew; ++nCnt)
{
POINT Pt = npRoid->Pos;
Pt.x += arand( 601 ) - 300; Pt.y += arand( 601 ) - 300;
CreateRoid( Pt, npRoid->Vel, npRoid->byPts - (nNew + 1),
npRoid->byColor,
npRoid->nDir + nCnt * DEGREE_SIZE / nNew + arand( 32 ),
nSpeed + arand( nLevel * 4 ),
npRoid->nSpin / 2 );
}
}
KillBadGuy();
++npRoid->byColor;
npRoid->nCount = 0;
if (nNew)
{
Hit( hDC, npRoid );
DrawObject( hDC, npRoid );
}
else Explode( hDC, npRoid );
RemoveObj( &RoidList, npRoid );
AddHeadObj( &FreeList, npRoid );
}
//
// DrawRoids - process and draw the asteroid list
//
VOID NEAR PASCAL DrawRoids( HDC hDC )
{
NPOBJ npRoid, npNext;
for (npRoid = HeadObj( &RoidList ); npRoid; npRoid = npNext)
{
INT nSize = npRoid->nCount;
NPOBJ npShot;
RECT rect;
npNext = NextObj( npRoid );
DrawObject( hDC, npRoid );
MKRECT( &rect, npRoid->Pos, nSize );
if (PTINRECT( &rect, npPlayer->Pos ) && HitPlayer( hDC, npRoid ))
{
npPlayer->nCount = -npPlayer->nCount;
npPlayer->byColor = WHITE;
Explode( hDC, npPlayer );
BreakRoid( hDC, npRoid, NULL );
if (nBadGuys) SetRestart( RESTART_LEVEL );
else SetRestart( RESTART_NEXTLEVEL );
}
else if (INTRECT(&rect, &rectShotClip))
{
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
{
if (!PTINRECT( &rect, npShot->Pos )) continue;
BreakRoid( hDC, npRoid, npShot );
break;
}
}
}
}
//
// DrawShots - process and draw the player shot list
//
VOID NEAR PASCAL DrawShots( HDC hDC )
{
NPOBJ npShot, npNext;
if (npShot = HeadObj( &ShotList ))
{
rectShotClip.left = rectShotClip.right = npShot->Pos.x;
rectShotClip.top = rectShotClip.bottom = npShot->Pos.y;
while (npShot)
{
npNext = NextObj( npShot );
switch (--npShot->nCount)
{
case 10:
npShot->byColor = DKCYAN;
break;
case 5:
npShot->byColor = DKBLUE;
break;
case 0:
RemoveObj( &ShotList, npShot );
AddHeadObj( &FreeList, npShot );
break;
}
DrawObject( hDC, npShot );
if (npShot->Pos.x < rectShotClip.left) rectShotClip.left = npShot->Pos.x;
else if (npShot->Pos.x > rectShotClip.right) rectShotClip.right = npShot->Pos.x;
if (npShot->Pos.y < rectShotClip.top) rectShotClip.top = npShot->Pos.y;
else if (npShot->Pos.y > rectShotClip.bottom) rectShotClip.bottom = npShot->Pos.y;
npShot = npNext;
}
}
else rectShotClip.left = rectShotClip.right = rectShotClip.top = rectShotClip.bottom = 32767;
}
//
// DrawFlames - process and draw the flame list
//
VOID NEAR PASCAL DrawFlames( HDC hDC )
{
NPOBJ npFlame, npNext;
for (npFlame = HeadObj( &FlameList ); npFlame; npFlame = npNext)
{
npNext = NextObj( npFlame );
switch (--npFlame->nCount)
{
case 7:
npFlame->byColor = RED;
break;
case 3:
npFlame->byColor = DKRED;
break;
case 0:
RemoveObj( &FlameList, npFlame );
AddHeadObj( &FreeList, npFlame );
break;
}
DrawObject( hDC, npFlame );
}
}
//
// FireShot - fire a bullet
//
VOID NEAR PASCAL FireShot( VOID )
{
NPOBJ npShot;
if (npShot = RemHeadObj( &FreeList ))
{
npShot->Pos.x = npPlayer->Pos.x;
npShot->Pos.y = npPlayer->Pos.y;
npShot->Vel.x = npPlayer->Vel.x;
npShot->Vel.y = npPlayer->Vel.y;
npShot->nMass = 8;
npShot->nDir = npPlayer->nDir + arand( 5 ) - 2;
npShot->nSpin = 0;
npShot->nCount = 16 + arand( 8 );
npShot->byColor = CYAN;
npShot->byPts = 2;
npShot->Pts[0].x = 128;
npShot->Pts[0].y = 50;
npShot->Pts[1].x = 0;
npShot->Pts[1].y = 50;
ACCEL( npShot, npShot->nDir, 200 + npShot->nCount );
AddHeadObj( &ShotList, npShot );
}
}
//
// AccelPlayer - move the player forward
//
VOID NEAR PASCAL AccelPlayer( INT nDir, INT nAccel )
{
NPOBJ npFlame;
nDir += npPlayer->nDir;
if (nAccel) ACCEL( npPlayer, nDir, nAccel );
if (npFlame = RemHeadObj( &FreeList ))
{
npFlame->Pos.x = npPlayer->Pos.x;
npFlame->Pos.y = npPlayer->Pos.y;
npFlame->Vel.x = npPlayer->Vel.x;
npFlame->Vel.y = npPlayer->Vel.y;
npFlame->nDir = nDir + 100 + arand( 57 );
npFlame->nSpin = 0;
npFlame->nCount = nAccel + arand( 7 );
npFlame->byColor = YELLOW;
npFlame->byPts = 1;
npFlame->Pts[0].x = npFlame->Pts[0].y = 0;
ACCEL( npFlame, npFlame->nDir, 50 + arand( 10 ) );
AddHeadObj( &FlameList, npFlame );
}
}
//
// DrawPlayer - process and draw the player
//
VOID NEAR PASCAL DrawPlayer( HDC hDC )
{
LOCAL INT nBombing = 0;
LOCAL INT nShotDelay = 0;
if (npPlayer->nCount <= 0) return;
if (nSafe > 0)
{
if (--nSafe == 0)
{
npPlayer->byColor = (BYTE)(BLACK + npPlayer->nCount);
if (npPlayer->byColor > WHITE) npPlayer->byColor = WHITE;
}
}
else if (IsKeyDown( vkShld ) && nShield > 0)
{
nSafe = 15;
if (--nShield > 0) npPlayer->byColor = GREEN;
else npPlayer->byColor = DKGREEN;
}
if (nBombing > 0)
{
if (--nBombing == 0)
{
ExplodeBadguys( hDC, &SpinnerList );
ExplodeBadguys( hDC, &SwarmerList );
ExplodeBadguys( hDC, &HunterList );
}
else
{
HitList( hDC, &SpinnerList );
HitList( hDC, &SwarmerList );
HitList( hDC, &HunterList );
}
}
else if (nBomb && IsKeyDown( vkBomb )) --nBomb, nBombing = 5;
if (IsKeyDown( vkClkw )) npPlayer->nSpin += 8;
if (IsKeyDown( vkCtrClkw )) npPlayer->nSpin -= 8;
if (IsKeyDown( vkThrst )) AccelPlayer( 0, 12 );
if (IsKeyDown( vkRvThrst )) AccelPlayer( 128, 12 );
if (nShotDelay) --nShotDelay;
else if (IsKeyDown( vkFire )) FireShot(), nShotDelay = 2;
DrawObject( hDC, npPlayer );
npPlayer->nSpin /= 2;
}
//
// GetHyperoidDC - get the correct DC for hyperoid rendering
//
HDC NEAR PASCAL GetHyperoidDC( HWND hWnd )
{
HDC hDC;
INT cx, cy;
RECT rect;
GetClientRect( hWnd, &rect );
cx = rect.right - rect.left;
cy = rect.bottom - rect.top;
hDC = GetDC( hWnd );
// set up the mapping mode
SetMapMode( hDC, MM_ISOTROPIC );
SetWindowExt( hDC, MAX_COORD, MAX_COORD );
SetViewportExt( hDC, cx / 2, -cy / 2 );
SetViewportOrg( hDC, cx / 2, cy / 2 );
// realize the palette
SelectPalette( hDC, hAppPalette, 0 );
RealizePalette( hDC );
return( hDC );
}
//
// DrawObjects - transform and redraw everything in the system
//
VOID NEAR PASCAL DrawObjects( HWND hWnd )
{
HDC hDC = GetHyperoidDC( hWnd );
// move and draw things (I don't think the order is important...)
DrawPlayer( hDC );
DrawFlames( hDC );
DrawShots( hDC );
DrawRoids( hDC );
DrawSpinners( hDC );
DrawSwarmers( hDC );
DrawHunters( hDC );
DrawHunterShots( hDC );
DrawLetters( hDC );
DrawBonuses( hDC );
// (...but I'm not changing it!!! :-)
ReleaseDC( hWnd, hDC );
}
//
// SetIndicator - set a quantity indicator
//
INT NEAR PASCAL SetIndicator( NPSTR npBuff, CHAR IDBitmap, INT nQuant )
{
if (nQuant > 5)
{
*npBuff++ = IDBitmap; *npBuff++ = IDBitmap;
*npBuff++ = IDBitmap; *npBuff++ = IDBitmap;
*npBuff++ = IDB_plus;
}
else
{
INT nBlank = 5 - nQuant;
while (nQuant--) *npBuff++ = IDBitmap;
while (nBlank--) *npBuff++ = IDB_blank;
}
return( 5 );
}
//
// CheckScore - show the score and such stuff
//
VOID NEAR PASCAL CheckScore( HWND hWnd )
{
CHAR szBuff[sizeof(szScore)];
NPSTR npBuff = szBuff;
INT nLives, nLen, nCnt, x, y;
HBITMAP hbmOld;
HDC hDC, hDCMem;
if (IsIconic( hWnd )) return;
if (lScore - lLastLife > EXTRA_LIFE)
{
AddExtraLife();
lLastLife = lScore;
}
nLives = ((npPlayer->nCount > 0) ? npPlayer->nCount : -npPlayer->nCount);
*npBuff++ = IDB_level;
wsprintf( npBuff, "%2.2u", nLevel );
while (isdigit( *npBuff ))
*npBuff = (CHAR)(*npBuff + IDB_num0 - '0'), ++npBuff;
*npBuff++ = IDB_blank; *npBuff++ = IDB_score;
wsprintf( npBuff, "%7.7lu", lScore );
while (isdigit( *npBuff ))
*npBuff = (CHAR)(*npBuff + IDB_num0 - '0'), ++npBuff;
*npBuff++ = IDB_blank;
npBuff += SetIndicator( npBuff, IDB_life, nLives );
npBuff += SetIndicator( npBuff, IDB_shield, nShield );
npBuff += SetIndicator( npBuff, IDB_bomb, nBomb );
nLen = npBuff - szBuff;
hDC = GetWindowDC( hWnd );
IntersectClipRect( hDC, rectScoreClip.left, rectScoreClip.top,
rectScoreClip.right, rectScoreClip.bottom );
hDCMem = CreateCompatibleDC( hDC );
hbmOld = SelectObject( hDCMem, hBitmap[0] );
x = rectScoreClip.left;
y = rectScoreClip.top;
for (nCnt = 0; nCnt < nLen; ++nCnt)
{
if (szBuff[nCnt] != szScore[nCnt])
{
SelectObject( hDCMem, hBitmap[szBuff[nCnt] - IDB_blank] );
BitBlt( hDC, x, y, CX_BITMAP, CY_BITMAP, hDCMem, 0, 0, SRCCOPY );
szScore[nCnt] = szBuff[nCnt];
}
x += CX_BITMAP;
}
if (nCnt < nScoreLen)
{
SelectObject( hDCMem, hBitmap[0] );
do {
if (szScore[nCnt] != IDB_blank)
{
BitBlt( hDC, x, y, CX_BITMAP, CY_BITMAP, hDCMem, 0, 0, SRCCOPY );
szScore[nCnt] = IDB_blank;
}
x += CX_BITMAP;
} while (++nCnt < nScoreLen);
}
nScoreLen = nLen;
SelectObject( hDCMem, hbmOld );
DeleteDC( hDCMem );
ReleaseDC( hWnd, hDC );
}
//
// HitList - Hit() a list of things
//
VOID NEAR PASCAL HitList( HDC hDC, NPLIST npList )
{
NPOBJ npObj;
for (npObj = HeadObj( npList ); npObj; npObj = NextObj( npObj ))
if (npObj->nCount) Hit( hDC, npObj );
}
//
// ExplodeBadguys - explode a list of badguys
//
VOID NEAR PASCAL ExplodeBadguys( HDC hDC, NPLIST npList )
{
NPOBJ npObj;
while (npObj = HeadObj( npList ))
{
KillBadGuy();
npObj->nCount = 0;
Explode( hDC, npObj );
RemoveObj( npList, npObj );
AddHeadObj( &FreeList, npObj );
}
}
//
// NewGame - start a new game
//
VOID NEAR PASCAL NewGame( HWND hWnd )
{
HDC hDC = GetHyperoidDC( hWnd );
npPlayer->nCount = 0;
npPlayer->byColor = WHITE;
Explode( hDC, npPlayer );
SetRestart( RESTART_GAME );
ExplodeBadguys( hDC, &RoidList );
ExplodeBadguys( hDC, &SpinnerList );
ExplodeBadguys( hDC, &SwarmerList );
ExplodeBadguys( hDC, &HunterList );
ReleaseDC( hWnd, hDC );
}
//
// RestartHyperoid - set up a game!
//
VOID NEAR PASCAL RestartHyperoid( VOID )
{
if (npPlayer->nCount == 0)
{
POINT Pos, Vel;
Pos.x = 0;
Pos.y = -CLIP_COORD / 2;
Vel.x = 0;
Vel.y = 150;
PrintLetters( szAppName, Pos, Vel, YELLOW, 800 );
npPlayer->nCount = 3;
if (lHighScore < lScore) lHighScore = lScore;
lLastLife = lScore = 0;
nLevel = 0;
nShield = nBomb = 3;
}
else if (npPlayer->nCount < 0)
{
// cheesy way of restarting after a major collision
npPlayer->nCount = -npPlayer->nCount;
nShield = nBomb = 3;
}
npPlayer->Pos.x = npPlayer->Pos.y = 0;
npPlayer->Vel.x = npPlayer->Vel.y = 0;
npPlayer->nDir = 64;
npPlayer->nSpin = 0;
npPlayer->byColor = GREEN;
nSafe = 30;
if (ShotList.npHead)
{
NPOBJ npShot;
for (npShot = HeadObj( &ShotList ); npShot; npShot = NextObj( npShot ))
npShot->nCount = 1;
}
// reseed the asteroid field
if (nBadGuys == 0)
{
INT nCnt;
++nLevel;
for (nCnt = 5 + nLevel; nCnt; --nCnt)
{
POINT Pos, Vel;
Pos.x = arand( MAX_COORD * 2 ) - MAX_COORD;
Pos.y = arand( MAX_COORD * 2 ) - MAX_COORD;
Vel.x = Vel.y = 0;
CreateRoid( Pos, Vel, 6 + arand( 2 ),
(BYTE)(arand( 2 ) ? DKYELLOW : DKGREY),
arand( DEGREE_MAX ), 30 + arand( nLevel * 8 ), 0 );
}
}
}
//
// Panic - boss key (or just pause)
//
VOID NEAR PASCAL Panic( BOOL bPanic )
{
if (bPanic && !bPaused)
{
bPaused = TRUE;
KillTimer( hAppWnd, DRAW_TIMER );
SetWindowText( hAppWnd, "Program Manager Help - PROGMAN.HLP" );
ShowWindow( hAppWnd, SW_SHOWMINNOACTIVE );
InvalidateRect( hAppWnd, NULL, TRUE );
}
else if (bPaused) // double-panic == normal
{
bPaused = FALSE;
SetWindowText( hAppWnd, szAppName );
if (bPanic) ShowWindow( hAppWnd, SW_RESTORE );
SetTimer( hAppWnd, DRAW_TIMER, nDrawDelay, NULL );
}
}
//
// PaintHyperoid - paint the hyperoid window
//
VOID NEAR PASCAL PaintHyperoid( HWND hWnd )
{
PAINTSTRUCT ps;
BeginPaint( hWnd, &ps );
if (bPaused) DrawIcon( ps.hdc, 2, 2, LoadIcon( hAppInst, INTRES(IDI_PANIC) ) );
EndPaint( hWnd, &ps );
}
//
// EraseHyperoidBkgnd - fill in the background
//
BOOL NEAR PASCAL EraseHyperoidBkgnd( HWND hWnd, HDC hDC )
{
HBRUSH hbr;
RECT rect;
GetClientRect( hWnd, &rect );
if (bPaused)
{
SetBrushOrg( hDC, 0, 0 );
hbr = CreateSolidBrush( GetSysColor( COLOR_BACKGROUND ) );
}
else
{
SelectPalette( hDC, hAppPalette, 0 );
RealizePalette( hDC );
hbr = CreateSolidBrush( PALETTEINDEX( BLACK ) );
}
FillRect( hDC, &rect, hbr );
DeleteObject( hbr );
return( TRUE );
}
//
// DrawShadowRect - draw a shaded rectangle around an object
//
VOID NEAR PASCAL DrawShadowRect( HDC hDC, NPRECT npRect, HPEN hHi, HPEN hLo )
{
SelectObject( hDC, hHi );
MoveTo( hDC, npRect->right, npRect->top );
LineTo( hDC, npRect->left, npRect->top );
LineTo( hDC, npRect->left, npRect->bottom );
SelectObject( hDC, hLo );
LineTo( hDC, npRect->right, npRect->bottom );
LineTo( hDC, npRect->right, npRect->top );
}
//
// NCPaintHyperoid - paint a custom frame
//
VOID NEAR PASCAL NCPaintHyperoid( HWND hWnd )
{
HDC hDC, hDCMem;
INT cx, cy, cyCap, h;
HPEN hpenHi, hpenLo;
HBRUSH hbr;
HBITMAP hbm, hbmOld;
BITMAP bm;
RECT rect;
if (IsIconic( hWnd )) return;
hDC = GetWindowDC( hWnd );
GetWindowRect( hWnd, &rect );
rect.right -= rect.left, rect.left = 0;
rect.bottom -= rect.top, rect.top = 0;
cx = GetSystemMetrics( SM_CXFRAME );
cy = GetSystemMetrics( SM_CYFRAME );
cyCap = cy + GetSystemMetrics( SM_CYCAPTION ) - 1;
h = rect.bottom - (cyCap + cy);
SelectPalette( hDC, hAppPalette, 0 );
RealizePalette( hDC );
if (bBW)
{
hbr = SelectObject( hDC, CreateSolidBrush( PALETTEINDEX( WHITE ) ) );
hpenHi = hPen[BLACK];
hpenLo = hPen[BLACK];
}
else
{
hbr = SelectObject( hDC, CreateSolidBrush( PALETTEINDEX( GREY ) ) );
hpenHi = hPen[WHITE];
hpenLo = hPen[DKGREY];
}
PatBlt( hDC, 0, 0, rect.right, cyCap, PATCOPY );
PatBlt( hDC, 0, rect.bottom - cy, rect.right, rect.bottom, PATCOPY );
PatBlt( hDC, 0, cyCap, cx, h, PATCOPY );
PatBlt( hDC, rect.right - cx, cyCap, cx, h, PATCOPY );
--rect.bottom; --rect.right;
DrawShadowRect( hDC, &rect, hpenHi, hpenLo );
--cx; --cy;
rect.left += cx; rect.top += cy;
rect.right -= cx; rect.bottom -= cy;
if (!bBW) DrawShadowRect( hDC, &rect, hpenLo, hpenHi );
// get the title bar rect
++rect.left; ++rect.top; --rect.right;
rect.bottom = rect.top + cyCap - (cy + 2);
DrawShadowRect( hDC, &rect, hpenHi, hpenLo );
++rect.right; // for zoom/restore bitmap
hDCMem = CreateCompatibleDC( hDC );
hbm = LoadBitmap( NULL, INTRES(OBM_CLOSE) );
GetObject( hbm, sizeof(bm), (LPSTR)&bm );
bm.bmWidth /= 2; // they packed two images in here!
hbmOld = SelectObject( hDCMem, hbm );
BitBlt( hDC, rect.left, rect.top, bm.bmWidth, bm.bmHeight, hDCMem, 0, 0, SRCCOPY );
rect.left += bm.bmWidth;
if (IsZoomed( hWnd )) hbm = LoadBitmap( NULL, INTRES(OBM_RESTORE) );
else hbm = LoadBitmap( NULL, INTRES(OBM_ZOOM) );
GetObject( hbm, sizeof(bm), (LPSTR)&bm );
SelectObject( hDCMem, hbm );
rect.right -= bm.bmWidth;
BitBlt( hDC, rect.right, rect.top, bm.bmWidth, bm.bmHeight, hDCMem, 0, 0, SRCCOPY );
hbm = LoadBitmap( NULL, INTRES(OBM_REDUCE) );
GetObject( hbm, sizeof(bm), (LPSTR)&bm );
SelectObject( hDCMem, hbm );
rect.right -= bm.bmWidth;
BitBlt( hDC, rect.right, rect.top, bm.bmWidth, bm.bmHeight, hDCMem, 0, 0, SRCCOPY );
--rect.right;
DrawShadowRect( hDC, &rect, hpenHi, hpenLo );
// clip the score to the free titlebar area
++rect.left; ++rect.top;
rectScoreClip = rect;
DeleteObject( SelectObject( hDCMem, hbmOld ) );
DeleteObject( SelectObject( hDC, hbr ) );
DeleteDC( hDCMem );
ReleaseDC( hWnd, hDC );
// make sure the score gets redrawn
for (cx = 0; cx < nScoreLen; ++cx) szScore[cx] = '\0';
}
//
// HyperoidWndProc - the main window proc for Hyperoid
//
LONG FAR PASCAL EXPORT HyperoidWndProc( HWND hWnd, unsigned message,
WORD wParam, LONG lParam )
{
switch (message)
{
case WM_CREATE:
RestartHyperoid();
SetTimer( hWnd, DRAW_TIMER, nDrawDelay, NULL );
NCPaintHyperoid( hWnd );
break;
case WM_TIMER:
switch (wParam)
{
case DRAW_TIMER:
CheckScore( hWnd );
DrawObjects( hWnd );
return( 0 );
case RESTART_TIMER:
KillTimer( hWnd, RESTART_TIMER );
bRestart = FALSE;
RestartHyperoid();
return( 0 );
}
break;
case WM_SYSCOMMAND:
switch (wParam)
{
case IDM_NEW:
NewGame( hWnd );
break;
case IDM_ABOUT:
AboutHyperoid( hWnd );
break;
default:
return( DefWindowProc( hWnd, message, wParam, lParam ) );
}
break;
case WM_QUERYOPEN:
Panic( FALSE );
return( DefWindowProc( hWnd, message, wParam, lParam ) );
case WM_CHAR:
if (wParam == VK_ESCAPE) Panic( TRUE );
break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_SYSCHAR:
if (lParam & (1L<<29)) // alt key is down
{
return( DefWindowProc( hWnd, message, wParam, lParam ) );
}
switch (wParam)
{
case VK_ESCAPE:
if (message == WM_SYSKEYDOWN) Panic( TRUE );
return( 0 );
case VK_SPACE:
case VK_TAB:
return( 0 );
default:
return( DefWindowProc( hWnd, message, wParam, lParam ) );
}
break;
case WM_ERASEBKGND:
return( EraseHyperoidBkgnd( hWnd, (HDC)wParam ) );
case WM_NCACTIVATE:
case WM_NCPAINT:
NCPaintHyperoid( hWnd );
return( TRUE );
case WM_PAINT:
PaintHyperoid( hWnd );
break;
case WM_QUERYNEWPALETTE:
{
HDC hDC = GetDC( hWnd );
SelectPalette( hDC, hAppPalette, 0 );
RealizePalette( hDC );
ReleaseDC( hWnd, hDC );
}
return( TRUE );
case WM_DESTROY:
KillTimer( hWnd, DRAW_TIMER );
KillTimer( hWnd, RESTART_TIMER );
SaveHyperoidWindowPos( hWnd );
PostQuitMessage( 0 );
break;
default:
return( DefWindowProc( hWnd, message, wParam, lParam ) );
}
return( 0 );
}
//
// InitHyperoid - initialize everything
//
BOOL NEAR PASCAL InitHyperoid( VOID )
{
DOUBLE dRad;
INT nCnt;
// allocate the logical palette
hAppPalette = CreateHyperoidPalette();
if (!hAppPalette) return( FALSE );
for (nCnt = 0; nCnt < PALETTE_SIZE; ++nCnt)
{
hPen[nCnt] = CreatePen( PS_SOLID, 1, PALETTEINDEX( nCnt ) );
if (!hPen[nCnt]) return( FALSE );
}
for (nCnt = 0; nCnt < IDB_MAX; ++nCnt)
{
hBitmap[nCnt] = LoadBitmap( hAppInst, INTRES(IDB_blank + nCnt) );
if (!hPen[nCnt]) return( FALSE );
}
// seed the randomizer
dwSeed = GetCurrentTime();
// create the lookup table (should use resources)
for (nCnt = 0; nCnt < DEGREE_SIZE; ++nCnt)
{
dRad = nCnt * 6.2831855 / DEGREE_SIZE;
nCos[nCnt] = (INT)(DEGREE_MAX * cos( dRad ));
nSin[nCnt] = (INT)(DEGREE_MAX * sin( dRad ));
}
// get the initialization file info
GetHyperoidIni();
// allocate all objects as free
for (nCnt = 0; nCnt < MAX_OBJS; ++nCnt)
AddHeadObj( &FreeList, &(Obj[nCnt]) );
// set up the player
npPlayer = RemHeadObj( &FreeList );
npPlayer->byPts = DIM(Player);
npPlayer->nMass = 256;
for (nCnt = 0; nCnt < DIM(Player); ++nCnt)
npPlayer->Pts[nCnt] = Player[nCnt];
return( TRUE );
}
//
// ExitHyperoid - quit the damn game already!
//
VOID NEAR PASCAL ExitHyperoid( VOID )
{
INT nCnt;
if (hAppPalette) DeleteObject( hAppPalette );
for (nCnt = 0; nCnt < PALETTE_SIZE; ++nCnt)
if (hPen[nCnt]) DeleteObject( hPen[nCnt] );
for (nCnt = 0; nCnt < IDB_MAX; ++nCnt)
if (hBitmap[nCnt]) DeleteObject( hBitmap[nCnt] );
}
//
// WinMain - everybody has to have one
//
INT FAR PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
LPSTR lpszCmdLine, INT nCmdShow )
{
MSG msg;
hAppInst = hInstance;
if (!hPrevInstance)
{
// create the class if we're first
if (!CreateHyperoidClass()) return( FALSE );
}
else
{
// Copy data from previous instance
GetInstanceData( hPrevInstance, (PSTR)szAppName, sizeof(szAppName) );
}
if (!InitHyperoid()) goto Abort; // I LOVE GOTOS! REALLY I DO!
hAppWnd = CreateHyperoidWindow( lpszCmdLine, nCmdShow );
if (!hAppWnd) return( FALSE );
while (GetMessage( &msg, NULL, 0, 0 ))
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
Abort:
ExitHyperoid();
return( msg.wParam );
}