/********************************************************************

	DROOGS FROM HELL !!!

	by Jason Sodergren
	(so much for organized code)	

*******************03/05/1988***********************************/


 
#include <stdio.h>			/*  standard IO  */
#include <osbind.h>			/*  GEMDOS routines  */
#include <gemdefs.h>			/*  GEM AES  */
#include <obdefs.h>			/*  GEM constraints  */



/*declare global arrays for VDI */
typedef int WORD;			/* WORD is 16 bits  */
WORD contrl[12],			/* VDI control array */
     intout[128], intin[128],		/* VDI input arrays  */
     ptsin[128], ptsout[128];		/* VDI output arrays */
WORD screen_vhandle,			/* virtual screen workstation */
     screen_phandle,			/* physical screen workstation */
     screen_rez,			/* screen resolution 0,1,or 2  */
     color_screen,			/* flag if color monitor */
     x_max,				/* max X screen coordinate */
     y_max;				/* max Y screen coordinate */
typedef struct mfdbstr
{
char *addr;               /*addr of raster area*/
WORD wide;
WORD high;
WORD word_width;
WORD format;
WORD planes;
WORD reserv1, reserv2, reserv3;
} MFDB;
	
#define W_BALL 48
#define H_BALL 48
#define NUM_BALLS 4
typedef struct
{
int x[2];   		/* xcoord for ea screen*/
int y[2];
float dx;
float dy;		/* velocities */
int delay;
} BALL_REC;
char *bitmap0, *bitmap1;
int draw_screen, show_screen;
BALL_REC ball[NUM_BALLS];
float gravity;
int youy;youy=180;
int youx[2]={300,300};
int ky,kb;
int bullx;
int bully[2] = {10,10};
int lvl = 1;
int lives = 5;
int drooghit[NUM_BALLS];
int hit = 0;
int i,tmpdroog;
int sco =0;
char scobuf[16];
char lvlbuf[16];
char livbuf[16];
int button;
int mousex;
int mousey;

MFDB ballMFDB, maskMFDB, scrMFDB[2], youMFDB, bulletMFDB;   /*raster descriptors*/
/* shape defs */
int ball_shape[48][3] =
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x003E, 0x22C0,
  0x3E0C, 0x0021, 0xE040, 0x720E,
  0x2060, 0x3A06, 0xFA42, 0x38EB,
  0x114A, 0xB6C6, 0x0C63, 0x1CD3,
  0x1FC6, 0x0C2B, 0xF5A3, 0x422A,
  0x3FA6, 0x20E3, 0xCB0B, 0x1DA0,
  0x0003, 0x0032, 0x51E0, 0x0000,
  0x0002, 0x0500, 0x0000, 0x0003,
  0x5800, 0x0000, 0x0001, 0x6800,
  0x0000, 0x0001, 0x3000, 0x0000,
  0x0001, 0x6000, 0x0000, 0xF801,
  0x4000, 0x0001, 0x8401, 0x4000,
  0x0003, 0x0401, 0x40FE, 0x0182,
  0x2401, 0x4181, 0x0302, 0x0C01,
  0x4301, 0x0603, 0x0803, 0xC223,
  0x0C01, 0xF802, 0x8302, 0x0800,
  0x0002, 0x8186, 0x1800, 0x0002,
  0x80FC, 0x1000, 0x0002, 0x8000,
  0x1000, 0x0006, 0x8000, 0x1000,
  0x0004, 0x8000, 0x1000, 0x0004,
  0x8000, 0x1000, 0x0004, 0x8000,
  0x1000, 0x000C, 0x8000, 0x1000,
  0x0008, 0x8000, 0x1800, 0x8008,
  0x8000, 0x0800, 0x8008, 0x8000,
  0x0603, 0x0008, 0xC000, 0x03FE,
  0x0018, 0x6000, 0x0000, 0x0010,
  0x3000, 0x0000, 0x0030, 0x1800,
  0x0000, 0x0060, 0x0C00, 0x0000,
  0x00C0, 0x0600, 0x001F, 0x0180,
  0x0300, 0x0031, 0x0300, 0x0180,
  0x0061, 0x0600, 0x00E0, 0x0041,
  0x1800, 0x003E, 0x0063, 0x3000,
  0x0003, 0xE03E, 0x6000, 0x0000,
  0x1F01, 0xC000, 0x0000, 0x01FE,
  0x0000, 0x0000, 0x0000, 0x0000
};
int ball2_shape[48][3]=
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x003E, 0x22C0,
  0x3E0C, 0x0021, 0xE040, 0x720E,
  0x2060, 0x3A06, 0xFA42, 0x38EB,
  0x114A, 0xB6C6, 0x0C63, 0x1CD3,
  0x1FC6, 0x0C2B, 0xF5A3, 0x422A,
  0x3FA6, 0x20E3, 0xCB0B, 0x1DA0,
  0x0003, 0x0032, 0x51E0, 0x0000,
  0x0002, 0x0500, 0x0000, 0x0003,
  0x5800, 0x0000, 0x0001, 0x6800,
  0x0000, 0x0001, 0x2000, 0x0000,
  0x0001, 0x607F, 0x0000, 0x0001,
  0x41C1, 0x8000, 0x0001, 0x4300,
  0x8000, 0x0001, 0x4238, 0x8000,
  0xFC01, 0x4239, 0x8003, 0x0201,
  0x4301, 0x0006, 0x0203, 0xC183,
  0x0084, 0x7302, 0x807E, 0x0386,
  0x3102, 0x8000, 0x0E03, 0x0202,
  0x8000, 0x7001, 0xFC02, 0x8001,
  0xC000, 0x0006, 0x8003, 0x0000,
  0x0004, 0x8006, 0x0000, 0x0004,
  0x8004, 0x0000, 0x0004, 0x8004,
  0x0000, 0x000C, 0x800C, 0x0000,
  0x0008, 0x8008, 0x0000, 0x0008,
  0x800C, 0x0040, 0x0008, 0x8006,
  0x03C0, 0x0008, 0xC003, 0xEC00,
  0x0018, 0x6000, 0x0000, 0x0010,
  0x3000, 0x0000, 0x0030, 0x1800,
  0x03FF, 0xC060, 0x0C00, 0x0686,
  0xC0C0, 0x0600, 0x0CCA, 0x6180,
  0x0300, 0x0A3F, 0xA300, 0x0180,
  0x0DE6, 0x6600, 0x00E0, 0x0626,
  0x5800, 0x003E, 0x06AF, 0xF000,
  0x0003, 0xE3F8, 0x6000, 0x0000,
  0x1F01, 0xC000, 0x0000, 0x01FE,
  0x0000, 0x0000, 0x0000, 0x0000
};

int ball_mask[48][3] = 
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x003E, 0x22C0,
  0x3E0C, 0x0021, 0xE040, 0x720E,
  0x2060, 0x3A06, 0xFA42, 0x38EB,
  0x114A, 0xB6C6, 0x0C63, 0x1CD7,
  0x1FC6, 0x0C2B, 0xF5BF, 0xFF6A,
  0x3FA7, 0xA7FF, 0xFBEB, 0x1DAF,
  0xFFFF, 0xFFF2, 0x51FF, 0xDFFF,
  0xFFFA, 0x05DF, 0xFFFF, 0xFFFB,
  0x59FF, 0xFFFF, 0xFFF9, 0x6BFF,
  0xFFFF, 0xFFF5, 0x3FFF, 0xFFFF,
  0xFFFD, 0x7FFF, 0xFFFF, 0xFFF7,
  0x7FFF, 0xFFFF, 0xFFF7, 0x7FFF,
  0xFFFF, 0xFFFF, 0x7FFF, 0xFFFF,
  0xFFFD, 0x7FFF, 0xFFFF, 0xFFFD,
  0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF,
  0xFFFE, 0xFFFF, 0xFFFF, 0xFFFE,
  0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF,
  0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF,
  0xFFFC, 0xFFFF, 0xFFFF, 0xFFFC,
  0xFFFF, 0xFFFF, 0xFFFC, 0xFFFF,
  0xFFFF, 0xFFFC, 0xFFFF, 0xFFFF,
  0xFFF8, 0xFFFF, 0xFFFF, 0xFFF8,
  0xFFFF, 0xFFFF, 0xFFF8, 0xFFFF,
  0xFFFF, 0xFFF8, 0xFFFF, 0xFFFF,
  0xFFF8, 0x7FFF, 0xFFFF, 0xFFF0,
  0x3FFF, 0xFFFF, 0xFFF0, 0x1FFF,
  0xFFFF, 0xFFE0, 0x0FFF, 0xFFFF,
  0xFFC0, 0x07FF, 0xFFFF, 0xFF80,
  0x03FF, 0xFFFF, 0xFF00, 0x01FF,
  0xFFFF, 0xFE00, 0x00FF, 0xFFFF,
  0xF800, 0x003F, 0xFFFF, 0xF000,
  0x0003, 0xFFFF, 0xE000, 0x0000,
  0x1FFF, 0xC000, 0x0000, 0x01FE,
  0x0000, 0x0000, 0x0000, 0x0000
};



int you[16] = {
0x0180,0x0180,0x0180,0x0180,0x03c0,0x03c0,0x03c0,0x03c0,
0x07e0,0x07e0,0x47e2,0x4ff2,0x4ff2,0xeff7,0xffff,0x1ff8
};

int bullet[16] = {
0x0180,0x03c0,0x07e0,0x0ff0,0x0180,0x0180,0x0180,0x0180,
0x0180,0x0180,0x0180,0x03c0,0x05a0,0x03c0,0x05a0,0x0180	  
};


int sched_shape [48][3] = {
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0008, 0x1020,
  0x0000, 0x023D, 0xBFE1, 0x0000,
  0x01E7, 0xE0FF, 0x4800, 0x1375,
  0xEFFB, 0xE000, 0x1EF7, 0xBFFF,
  0xF840, 0x0EFE, 0x0303, 0xC740,
  0x2DB8, 0x0001, 0xDBC0, 0x09F0,
  0x0000, 0xEBDE, 0x19E0, 0x0000,
  0xA7E0, 0x3780, 0x0000, 0x86B0,
  0x2000, 0x0000, 0x1018, 0x2BFF,
  0xFBFF, 0xFF8C, 0x2100, 0x1C3C,
  0x0084, 0x2180, 0x0404, 0x0086,
  0x2080, 0x0C42, 0x0082, 0x20C0,
  0x1863, 0x8382, 0x207F, 0xF020,
  0xFE02, 0x2000, 0x0030, 0x0002,
  0x2000, 0x0010, 0x0002, 0x2000,
  0x0018, 0x0002, 0x2000, 0x0008,
  0x0002, 0x2000, 0x0008, 0x0002,
  0x2000, 0x0008, 0x0002, 0x2000,
  0x1008, 0x0002, 0x2000, 0x1808,
  0x0002, 0x2000, 0x0FF8, 0x0002,
  0x2000, 0x0000, 0x0002, 0x3000,
  0x010C, 0x0002, 0x1000, 0x67F4,
  0xC002, 0x1801, 0xEFBE, 0xE002,
  0x0801, 0xBB96, 0xE006, 0x0C02,
  0x2032, 0xE004, 0x0402, 0x0FFE,
  0x3004, 0x0602, 0x18C2, 0x100C,
  0x0303, 0x1CC3, 0x1008, 0x0103,
  0x17F9, 0x1018, 0x0103, 0x100F,
  0x0810, 0x0183, 0x1006, 0x0830,
  0x0083, 0x180C, 0x0860, 0x00C7,
  0x0F38, 0x18C0, 0x0064, 0x01E0,
  0x1980, 0x0034, 0x4000, 0x1E00,
  0x001F, 0x4D2A, 0x3C00, 0x0007,
  0xCD2A, 0x7400, 0x0013, 0x7FFF,
  0xC400, 0x001F, 0x3FFF, 0xC400
};
int sched2_shape[48][3]=
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0008, 0x1020,
  0x0000, 0x023D, 0xBFE1, 0x0000,
  0x01E7, 0xE0FF, 0x4800, 0x1375,
  0xEFFB, 0xE000, 0x1EF7, 0xBFFF,
  0xF840, 0x0EFE, 0x0303, 0xC740,
  0x2DB8, 0x0001, 0xDBC0, 0x09F0,
  0x0000, 0xEBDE, 0x19E0, 0x0000,
  0xA7E0, 0x3780, 0x0000, 0x86B0,
  0x2000, 0x0003, 0xBA18, 0x2000,
  0x004F, 0xDA0C, 0x2000, 0x03FC,
  0x0204, 0x203F, 0xFE20, 0x0206,
  0x23F8, 0x8030, 0x0602, 0x2201,
  0x801E, 0x0C02, 0x2203, 0x0043,
  0xF802, 0x2306, 0x00D0, 0x0002,
  0x21FC, 0x0180, 0x0002, 0x2000,
  0x0100, 0x0002, 0x2000, 0x0200,
  0x0002, 0x2000, 0x0200, 0x0002,
  0x2000, 0x0600, 0x0002, 0x2000,
  0x0400, 0x0002, 0x2000, 0x0603,
  0x0002, 0x2000, 0x03FE, 0x0002,
  0x2000, 0x0000, 0x0002, 0x3000,
  0x010C, 0x0002, 0x1000, 0x67F4,
  0xC002, 0x1801, 0xEFBE, 0xE002,
  0x0801, 0xBB96, 0xE006, 0x0C02,
  0x2000, 0xE004, 0x0402, 0x01C0,
  0x3004, 0x0602, 0x0FF8, 0x100C,
  0x0303, 0x1FFE, 0x1008, 0x0103,
  0x3FFF, 0x1018, 0x0103, 0x3FFF,
  0x0810, 0x0183, 0x20C1, 0x0830,
  0x0083, 0x1806, 0x0860, 0x00C7,
  0x0670, 0x18C0, 0x0064, 0x0180,
  0x1980, 0x0034, 0x4000, 0x1E00,
  0x001F, 0x4D2A, 0x3C00, 0x0007,
  0xCD2A, 0x7400, 0x0013, 0x7FFF,
  0xC400, 0x001F, 0x3FFF, 0xC400
};

int sched_mask [48][3] = {
 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0008, 0x1020,
  0x0000, 0x023D, 0xBFE1, 0x0000,
  0x01EF, 0xFFFF, 0x4800, 0x137F,
  0xFFFF, 0xE000, 0x1EFF, 0xFFFF,
  0xFC40, 0x0FFF, 0xFFFF, 0xFF40,
  0x2FFF, 0xFFFF, 0xFFC0, 0x0FFF,
  0xFFFF, 0xFFDE, 0x1FFF, 0xFFFF,
  0xFFE0, 0x3FFF, 0xFFFF, 0xFFF0,
  0x3FFF, 0xFFFF, 0xFFF8, 0x3FFF,
  0xFFFF, 0xFFFC, 0x3FFF, 0xFFFF,
  0xFFFC, 0x3FFF, 0xFFFF, 0xFFFE,
  0x3FFF, 0xFFFF, 0xFFFE, 0x7FFF,
  0xFFFF, 0xFFFE, 0x3FFF, 0xFFFF,
  0xFFFE, 0x3FFF, 0xFFFF, 0xFFFE,
  0x3FFF, 0xFFFF, 0xFFFE, 0x3FFF,
  0xFFFF, 0xFFFE, 0x3FFF, 0xFFFF,
  0xFFFE, 0x3FFF, 0xFFFF, 0xFFFE,
  0x3FFF, 0xFFFF, 0xFFFE, 0x3FFF,
  0xFFFF, 0xFFFE, 0x3FFF, 0xFFFF,
  0xFFFE, 0x3FFF, 0xFFFF, 0xFFFE,
  0x3FFF, 0xFFFF, 0xFFFE, 0x3FFF,
  0xFFFF, 0xFFFE, 0x1FFF, 0xFFFF,
  0xFFFE, 0x1FFF, 0xFFFF, 0xFFFE,
  0x0FFF, 0xFFFF, 0xFFFE, 0x0FFF,
  0xFFFF, 0xFFFC, 0x07FF, 0xFFFF,
  0xFFFC, 0x07FF, 0xFFFF, 0xFFFC,
  0x03FF, 0xFFFF, 0xFFF8, 0x01FF,
  0xFFFF, 0xFFF8, 0x01FF, 0xFFFF,
  0xFFF8, 0x01FF, 0xFFFF, 0xFFF0,
  0x00FF, 0xFFFF, 0xFFE0, 0x00FF,
  0xFFFF, 0xFFC0, 0x007F, 0xFFFF,
  0xFF80, 0x003F, 0xFFFF, 0xFE00,
  0x001F, 0xFFFF, 0xFC00, 0x000F,
  0xFFFF, 0xFC00, 0x001F, 0xFFFF,
  0xFC00, 0x001F, 0xFFFF, 0xFC00
};

int byth_shape [48][3] = {
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0xFFFF, 0xF000,
  0x3783, 0x8000, 0x1800, 0xC064,
  0xC212, 0x2C00, 0xC001, 0xE632,
  0x2600, 0xFFD1, 0x166E, 0x2392,
  0xFC53, 0x12C8, 0x24BD, 0xCCA0,
  0x0202, 0x24D7, 0x6D60, 0x0000,
  0x2505, 0x3C40, 0x0000, 0x0305,
  0x0F80, 0x0000, 0x0325, 0x0100,
  0x0000, 0x0389, 0x0107, 0x0000,
  0x03F1, 0x010C, 0xE000, 0x003B,
  0x0118, 0x3000, 0x0100, 0x0110,
  0x17C0, 0x0100, 0x0131, 0x1067,
  0x0100, 0x0120, 0x1039, 0x8100,
  0x0130, 0x7070, 0x8100, 0x019F,
  0xC0C1, 0x8100, 0x00C0, 0x0081,
  0x0300, 0x00C0, 0x0689, 0x0200,
  0x0040, 0x0C81, 0x0E00, 0x0040,
  0x18FF, 0xFE00, 0x0060, 0x1000,
  0x0400, 0x0020, 0x1000, 0x0C00,
  0x0010, 0x1000, 0x1800, 0x0010,
  0x1000, 0x1000, 0x0010, 0x1FF0,
  0x1000, 0x0010, 0x0000, 0x6000,
  0x0018, 0x3800, 0x4000, 0x000C,
  0x6C01, 0x8000, 0x0004, 0xC5F1,
  0x0000, 0x0004, 0x8713, 0x0000,
  0x0004, 0x0616, 0x0000, 0x0002,
  0xFF94, 0x0000, 0x0001, 0x41BC,
  0x0000, 0x0001, 0x40F0, 0x0000,
  0x0000, 0x71A0, 0x0000, 0x0000,
  0x9F40, 0x0000, 0x0001, 0x0300,
  0x0000, 0x0001, 0x8200, 0x0000,
  0x0000, 0xC600, 0x0000, 0x0000,
  0x4600, 0x0000, 0x0000, 0x7400,
  0x0000, 0x0000, 0x7C00, 0x0000
};
int byth2_shape[48][3]=
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0xFFFF, 0xF000,
  0x3783, 0x8000, 0x5800, 0xC064,
  0xFF50, 0xEC00, 0xCC01, 0xC73B,
  0xA600, 0xF8D1, 0x0CE8, 0x2392,
  0xF053, 0x12CF, 0xA4BD, 0xC0A0,
  0x0202, 0x25DF, 0x6D60, 0x0000,
  0x2D1D, 0x3C40, 0x0000, 0x0F11,
  0x0F80, 0x0000, 0x0333, 0x0100,
  0x0000, 0x0399, 0x0100, 0x0000,
  0x03F1, 0x0100, 0x001F, 0xF83B,
  0x0100, 0x0030, 0x0D00, 0x0100,
  0x07C0, 0x0500, 0x0107, 0xD8C0,
  0x0500, 0x0138, 0x2083, 0x0D00,
  0x0130, 0x1063, 0x1900, 0x01B0,
  0x1030, 0x3100, 0x00E1, 0x111C,
  0x6300, 0x00F0, 0x3303, 0xC200,
  0x0058, 0x2A00, 0x0200, 0x004F,
  0xF600, 0x0600, 0x0060, 0x0400,
  0x0400, 0x0020, 0x0600, 0x0C00,
  0x0010, 0x031C, 0x1800, 0x0010,
  0x01F0, 0x1000, 0x0010, 0xF000,
  0x1000, 0x0011, 0xDFF8, 0x6000,
  0x0019, 0x0608, 0x4000, 0x000D,
  0xC40D, 0x8000, 0x0004, 0xF005,
  0x0000, 0x0004, 0xFE7F, 0x0000,
  0x0004, 0xFFFE, 0x0000, 0x0002,
  0xFFFC, 0x0000, 0x0001, 0x5FFC,
  0x0000, 0x0001, 0x40F0, 0x0000,
  0x0000, 0x71A0, 0x0000, 0x0000,
  0x9F40, 0x0000, 0x0001, 0x0300,
  0x0000, 0x0001, 0x8200, 0x0000,
  0x0000, 0xC600, 0x0000, 0x0000,
  0x4600, 0x0000, 0x0000, 0x7400,
  0x0000, 0x0000, 0x7C00, 0x0000
};

int byth_mask [48][3] = {
 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0xFFFF, 0xF000,
  0x3783, 0xFFFF, 0xF800, 0xFFE7,
  0xFFFF, 0xFC00, 0xFFFF, 0xFFFF,
  0xFE00, 0xFFFF, 0xFFFF, 0xFF92,
  0xFFFF, 0xFFFF, 0xFFFD, 0xFFFF,
  0xFFFF, 0xFFFF, 0x7FFF, 0xFFFF,
  0xFFFF, 0x3FFF, 0xFFFF, 0xFFFF,
  0x0FFF, 0xFFFF, 0xFFFF, 0x017F,
  0xFFFF, 0xFFFF, 0x01FF, 0xFFFF,
  0xFFFF, 0x01FF, 0xFFFF, 0xFFFF,
  0x01FF, 0xFFFF, 0xFF00, 0x01FF,
  0xFFFF, 0xFF00, 0x01FF, 0xFFFF,
  0xFF00, 0x01FF, 0xFFFF, 0xFF00,
  0x01FF, 0xFFFF, 0xFF00, 0x01FF,
  0xFFFF, 0xFF00, 0x00FF, 0xFFFF,
  0xFF00, 0x00FF, 0xFFFF, 0xFE00,
  0x007F, 0xFFFF, 0xFE00, 0x007F,
  0xFFFF, 0xFE00, 0x007F, 0xFFFF,
  0xFC00, 0x003F, 0xFFFF, 0xFC00,
  0x001F, 0xFFFF, 0xF800, 0x001F,
  0xFFFF, 0xF000, 0x001F, 0xFFFF,
  0xF000, 0x001F, 0xFFFF, 0xE000,
  0x001F, 0xFFFF, 0xC000, 0x000F,
  0xFFFF, 0x8000, 0x0007, 0xFFFF,
  0x8000, 0x0007, 0xFFFF, 0x0000,
  0x0005, 0xFFFE, 0x0000, 0x0003,
  0xFFFC, 0x0000, 0x0001, 0xFFFC,
  0x0000, 0x0001, 0xFFF0, 0x0000,
  0x0000, 0x7FE0, 0x0000, 0x0000,
  0xFFC0, 0x0000, 0x0001, 0xFF00,
  0x0000, 0x0001, 0xFE00, 0x0000,
  0x0000, 0xFE00, 0x0000, 0x0000,
  0x7E00, 0x0000, 0x0000, 0x7C00,
  0x0000, 0x0000, 0x7C00, 0x0000
};

int zag_shape [48] [3] ={
  0x0400, 0x1F00, 0x80C2, 0x063F,
  0x0100, 0xF022, 0x02E1, 0x00FE,
  0x1062, 0x0381, 0xE000, 0x11C6,
  0x0000, 0x3C00, 0x0106, 0x0000,
  0x0000, 0x0182, 0x0000, 0x0000,
  0x0086, 0x0000, 0x7FC0, 0x0000,
  0x001F, 0xFF8D, 0x8800, 0x07FF,
  0xFC7B, 0x7602, 0x1FFF, 0xE1D4,
  0xBF03, 0x3FFF, 0x0A04, 0x8381,
  0x7FFC, 0x1000, 0x0383, 0x7FF8,
  0x0000, 0x0182, 0x3FF0, 0x0000,
  0x0182, 0x3FC0, 0x0000, 0x0183,
  0x3FC0, 0x03F0, 0x2EE1, 0x1F40,
  0x00B0, 0x2D81, 0x1F4C, 0x0230,
  0x3201, 0x1FE6, 0x0000, 0x1081,
  0x1FE3, 0x0000, 0x1880, 0x0FE1,
  0xE200, 0x0884, 0x0FE0, 0xF140,
  0x0894, 0x06D8, 0x3A60, 0x39F0,
  0x03E8, 0x3B3F, 0xEFC0, 0x03E8,
  0x1D3A, 0x03C0, 0x0008, 0x07FB,
  0x55D0, 0x000C, 0x03FF, 0xFD58,
  0x0006, 0x01FF, 0xFB0A, 0x0003,
  0x01FF, 0xFE03, 0x0001, 0x80DF,
  0xFE00, 0x0000, 0xC037, 0xFC00,
  0x0000, 0x4000, 0x000B, 0x1FFF,
  0x4000, 0x02C5, 0xF0BF, 0x4000,
  0x01C0, 0x01E0, 0x4000, 0x01C0,
  0x0160, 0x0000, 0x01C0, 0x01E0,
  0x0000, 0x01C0, 0x01E0, 0x0000,
  0x05C0, 0x01EE, 0x0000, 0x0DE0,
  0x01E7, 0x0000, 0x39A0, 0x03E1,
  0xE001, 0xE1A0, 0x03E0, 0x7FFE,
  0x81A0, 0x03E0, 0x0FFE, 0x01A0,
  0x03C0, 0x0000, 0x01A0, 0x03C0,
  0x0000, 0x01E0, 0x03C0, 0x0000,
  0x01C0, 0x01C0, 0x0000, 0x0140
};
int zag2_shape[48][3]=
{  0x0400, 0x1F00, 0x80C2, 0x063F,
  0x0100, 0xF022, 0x02E1, 0x00FE,
  0x1062, 0x0381, 0xE000, 0x11C6,
  0x0000, 0x3C00, 0x0106, 0x0000,
  0x0000, 0x0182, 0x0000, 0x0000,
  0x0086, 0x0000, 0x7FC0, 0x0000,
  0x001F, 0xFF8D, 0x8800, 0x07FF,
  0xFC7B, 0x7602, 0x1FFF, 0xE1D4,
  0xBF03, 0x3FFF, 0x0A04, 0x8381,
  0x7FFC, 0x1000, 0x0383, 0x7FF8,
  0x0000, 0x0182, 0x3FF0, 0x0000,
  0x0182, 0x3FC0, 0x0000, 0x0183,
  0x3FC0, 0x03F0, 0x2EE1, 0x1F40,
  0x00B0, 0x2D81, 0x1F4C, 0x0230,
  0x3201, 0x1FE6, 0x0000, 0x1081,
  0x1FE3, 0x0000, 0x1880, 0x0FE1,
  0xE200, 0x0884, 0x0FE0, 0xF140,
  0x0894, 0x06D8, 0x3A60, 0x39F0,
  0x03E8, 0x3B3F, 0xEFC0, 0x03E8,
  0x1D3A, 0x03C0, 0x0008, 0x07FB,
  0x55D0, 0x000C, 0x03FF, 0xFD58,
  0x0006, 0x01FF, 0xFB0A, 0x0003,
  0x01FF, 0xFE03, 0x0001, 0x80DF,
  0xFE00, 0x0000, 0xC037, 0xFC00,
  0x0000, 0x4000, 0x000B, 0x1FFF,
  0x4000, 0x02C5, 0xF0BF, 0x4000,
  0x01C0, 0x01E0, 0x4000, 0x01C0,
  0x0160, 0x0000, 0x01C0, 0x01E0,
  0x0000, 0x01C0, 0x01E0, 0x0000,
  0x05C0, 0x01EE, 0x0000, 0x0DE0,
  0x01E7, 0x0000, 0x39A0, 0x03E1,
  0xE001, 0xE1A0, 0x03E0, 0x7FFE,
  0x81A0, 0x03E0, 0x0FFE, 0x01A0,
  0x03C0, 0x0000, 0x01A0, 0x03C0,
  0x0000, 0x01E0, 0x03C0, 0x0000,
  0x01C0, 0x01C0, 0x0000, 0x0140
};

int zag_mask [48] [3] = {
  0x0400, 0x1F00, 0x80C2, 0x063F,
  0x0100, 0xF022, 0x02E1, 0x00FE,
  0x1062, 0x0381, 0xE000, 0x11C6,
  0x0000, 0x3C00, 0x0106, 0x0000,
  0x0000, 0x0182, 0x0000, 0x0000,
  0x0086, 0x0000, 0x7FC0, 0x0000,
  0x001F, 0xFFFF, 0xF800, 0x07FF,
  0xFFFF, 0xFE02, 0x1FFF, 0xFFFF,
  0xFF03, 0x3FFF, 0xFFFF, 0xFF81,
  0x7FFF, 0xFFFF, 0xFF83, 0x7FFF,
  0xFFFF, 0xFF82, 0x3FFF, 0xFFFF,
  0xFF82, 0x3FFF, 0xFFFF, 0xFF83,
  0x3FFF, 0xFFFF, 0xFFE1, 0x1FFF,
  0xFFFF, 0xFF81, 0x1FFF, 0xFFFF,
  0xFF81, 0x1FFF, 0xFFFF, 0xFF81,
  0x1FFF, 0xFFFF, 0xFF80, 0x0FFF,
  0xFFFF, 0xFF84, 0x0FFF, 0xFFFF,
  0xFF94, 0x07FF, 0xFFFF, 0xFFF0,
  0x03FF, 0xFFFF, 0xFFC0, 0x03FF,
  0xFFFF, 0xFFC0, 0x000F, 0xFFFF,
  0xFFD0, 0x000F, 0xFFFF, 0xFF58,
  0x0007, 0xFFFF, 0xFF0A, 0x0003,
  0xFFFF, 0xFE03, 0x0001, 0xFFFF,
  0xFE00, 0x0000, 0xFFFF, 0xFC00,
  0x0000, 0x7FFF, 0xF88B, 0x1FFF,
  0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFB
};

int eye_shape [48] [3] ={
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0001,
  0xFFFF, 0x0000, 0x00FE, 0x0001,
  0xE000, 0x0380, 0x0000, 0x3800,
  0x0600, 0x0000, 0x0600, 0x0C00,
  0x0000, 0x0380, 0x1800, 0x0000,
  0x00E0, 0x3400, 0x0000, 0x0030,
  0x6600, 0x0000, 0x001C, 0x4300,
  0x0000, 0x0004, 0x8100, 0x0000,
  0x0006, 0xB180, 0x000C, 0x0002,
  0xD8C0, 0x000C, 0x0002, 0xF840,
  0x000B, 0x0002, 0xF840, 0x0009,
  0xE002, 0xF840, 0x0008, 0x3FFE,
  0xF840, 0x0008, 0x1910, 0xF840,
  0x0008, 0x10A0, 0xF840, 0x000C,
  0x0080, 0xF040, 0x0006, 0x1020,
  0xE0C0, 0x0003, 0xD450, 0x8180,
  0x0000, 0x7FF0, 0x8700, 0x0000,
  0x001C, 0xCC00, 0x0000, 0x0004,
  0x7800, 0x0000, 0x0006, 0x3000,
  0x0000, 0x0002, 0x1C00, 0x0000,
  0x0002, 0x0780, 0x0000, 0x0006,
  0x00E0, 0x0000, 0x000C, 0x003C,
  0x0000, 0xFFF8, 0x0007, 0x8001,
  0x8000, 0x0000, 0xC003, 0x0000,
  0x0000, 0x6002, 0x0000, 0x0000,
  0x2002, 0x0000, 0x0000, 0x2002,
  0x0000, 0x0000, 0x2002, 0x0000,
  0x0000, 0x2002, 0x0000, 0x0000,
  0x6002, 0x0000, 0x0000, 0xD802,
  0x1080, 0x0000, 0xAFFE, 0x4A20,
  0x0000, 0xF91A, 0x4840, 0x0001,
  0xFBDF, 0xBF80, 0x0001, 0x789F,
  0xFEF8, 0x0001, 0xFFFF, 0xFFFE
};
int eye2_shape[48][3]=
{ 0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0001,
  0xFFFF, 0x0000, 0x00FE, 0x0001,
  0xE000, 0x0380, 0x0000, 0x3800,
  0x0640, 0x0000, 0x0600, 0x0CE0,
  0x0000, 0x0380, 0x1BA0, 0x0000,
  0x00E0, 0x3E18, 0x0001, 0x8030,
  0x7E78, 0x0003, 0xE01C, 0x7FCC,
  0x0002, 0x7804, 0xFF06, 0x0006,
  0x4C06, 0xFF82, 0x000C, 0x1602,
  0xFFFF, 0x000C, 0x7302, 0xFFC1,
  0x0008, 0x63C2, 0xFFC1, 0x0008,
  0x0662, 0xFFFF, 0x0008, 0x07FE,
  0xFFC1, 0x0008, 0x0000, 0xFFC1,
  0x0008, 0x0000, 0xFFDF, 0x000C,
  0x0000, 0xFFC1, 0x0004, 0x0000,
  0xFFC3, 0x0004, 0x0000, 0xFFA6,
  0x0003, 0x4800, 0xFF7E, 0x0001,
  0x9C00, 0xFF0C, 0x0000, 0x7470,
  0x7998, 0x0000, 0x1EC8, 0x31F0,
  0x0000, 0x03F0, 0x1CE0, 0x0000,
  0x0004, 0x07C0, 0x0000, 0x0006,
  0x00E0, 0x0000, 0x000C, 0x003C,
  0x0000, 0xFFF8, 0x0007, 0x8001,
  0x8000, 0x0000, 0xC003, 0x0000,
  0x0000, 0x6002, 0x0000, 0x0000,
  0x2002, 0x0000, 0x0000, 0x2002,
  0x0000, 0x0000, 0x2002, 0x0000,
  0x0000, 0x3E02, 0x0000, 0x0000,
  0x7FFE, 0x0000, 0x0000, 0xDFFE,
  0x1080, 0x0000, 0xAFFE, 0x4A20,
  0x0000, 0xF85A, 0x4840, 0x0001,
  0xFBDF, 0xBF80, 0x0001, 0x7A1F,
  0xFEF8, 0x0001, 0xFFFF, 0xFFFE
};
 
int eye_mask[48][3]={
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0000,
  0x0000, 0x0000, 0x0000, 0x0001,
  0xFFFF, 0x0000, 0x00FF, 0xFFFF,
  0xE000, 0x03FF, 0xFFFF, 0xF800,
  0x07FF, 0xFFFF, 0xFE00, 0x0FFF,
  0xFFFF, 0xFF80, 0x1FFF, 0xFFFF,
  0xFFE0, 0x3FFF, 0xFFFF, 0xFFF0,
  0x7FFF, 0xFFFF, 0xFFFC, 0x7FFF,
  0xFFFF, 0xFFFC, 0xFFFF, 0xFFFF,
  0xFFFE, 0xFFFF, 0xFFFF, 0xFFFE,
  0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF,
  0xFFFB, 0xFFFE, 0xFFFF, 0xFFF9,
  0xFFFE, 0xFFFF, 0xFFF8, 0x3FFE,
  0xFFFF, 0xFFF8, 0x1970, 0xFFFF,
  0xFFF8, 0x10E0, 0xFFFF, 0xFFFC,
  0x00C0, 0xFFFF, 0xFFF6, 0x1020,
  0xFFFF, 0xFFFF, 0xD450, 0xFFFF,
  0xFFFF, 0xFFF0, 0xFFFF, 0xFFFF,
  0xFFDC, 0xFFFF, 0xFFFF, 0xFFF4,
  0x7FFF, 0xFFFF, 0xFFF6, 0x3FFF,
  0xFFFF, 0xFFFA, 0x1FFF, 0xFFFF,
  0xFFFA, 0x07FF, 0xFFFF, 0xFFFE,
  0x00FF, 0xFFFF, 0xFFFC, 0x003F,
  0xFFFF, 0xFFF8, 0x0007, 0xFFFF,
  0x8000, 0x0001, 0xFFFF, 0x0000,
  0x0000, 0x7FFE, 0x0000, 0x0000,
  0x3FFF, 0x0000, 0x0000, 0x3FFE,
  0x0000, 0x0000, 0x3FFF, 0x0000,
  0x0000, 0x3FFF, 0x0000, 0x0000,
  0x7FFE, 0x0000, 0x0000, 0xFFFE,
  0x1080, 0x0000, 0xFFFE, 0x4A20,
  0x0000, 0xFFFE, 0x4840, 0x0001,
  0xFFFF, 0xBF80, 0x0001, 0xFFFF,
  0xFEF8, 0x0001, 0xFFFF, 0xFFFE
};
int mac_shape[48][3]={
  0x3FFF, 0xFFFF, 0xFFF0, 0xE000,
  0x0000, 0x000C, 0x81EF, 0xFFFF,
  0xFF07, 0x8700, 0x0300, 0x01C1,
  0x8600, 0x0600, 0x0061, 0x8403,
  0xF7FC, 0x0021, 0x8C06, 0x1E04,
  0x0021, 0x880C, 0x0004, 0x0021,
  0x8C08, 0x00FC, 0x0021, 0x8408,
  0x0100, 0x0031, 0x840C, 0x0180,
  0x0011, 0x8407, 0x00F8, 0x0011,
  0x8401, 0xC078, 0x0011, 0x8600,
  0x7FE0, 0x0031, 0x8300, 0x0000,
  0x00E3, 0x81FF, 0x0000, 0x0783,
  0x8001, 0xFFFF, 0xF803, 0x8000,
  0x0000, 0x0003, 0x8000, 0x0000,
  0x0001, 0x8000, 0x0000, 0x0001,
  0x8000, 0x0000, 0x0001, 0x8000,
  0x0000, 0x0001, 0x8000, 0x0000,
  0x0001, 0x8000, 0x1EFF, 0xE001,
  0x8000, 0x1FFF, 0xFFF1, 0x8000,
  0x1FFF, 0xE001, 0x8000, 0x0000,
  0x0001, 0x8000, 0x0000, 0x0001,
  0x8000, 0x0000, 0x0001, 0x8000,
  0x0000, 0x0002, 0x8000, 0x0000,
  0x0002, 0xC000, 0x0000, 0x0006,
  0x6000, 0x0000, 0x0004, 0x3800,
  0x0000, 0x000C, 0x0FFF, 0xFFFF,
  0xFFF8, 0x1800, 0x701C, 0x007C,
  0x3000, 0x3070, 0x0004, 0x3800,
  0x607F, 0xFFFC, 0x3D7F, 0xE00F,
  0x0018, 0x2000, 0x2018, 0x0008,
  0x3800, 0x601F, 0xFFF8, 0x1BF7,
  0xC00C, 0x0018, 0x1800, 0xF03C,
  0x000C, 0x0FFF, 0x903F, 0xFFFC,
  0x0E01, 0xF010, 0x8058, 0x3FFC,
  0xE07F, 0x7FFC, 0xEFFF, 0xF0DF,
  0xFFFF, 0xFFFF, 0xF1BF, 0xFFFF
};
int mac2_shape[48][3]=
{ 0x3FFF, 0xFFFF, 0xFFF0, 0xE000,
  0x0000, 0x000C, 0x81EF, 0xFFFF,
  0xFF07, 0x8700, 0x0300, 0x01C1,
  0x8600, 0x0600, 0x0061, 0x8403,
  0xD7FC, 0x0021, 0x8C06, 0x7FF4,
  0x0021, 0x880C, 0x4184, 0x0021,
  0x8C08, 0xD7FC, 0x0021, 0x8408,
  0xD100, 0x0031, 0x840C, 0x6D80,
  0x0011, 0x8407, 0x38F8, 0x0011,
  0x8401, 0xCC78, 0x0011, 0x8600,
  0x7FE0, 0x0031, 0x8300, 0x0000,
  0x00E3, 0x81FF, 0x0000, 0x0783,
  0x8001, 0xFFFF, 0xF803, 0x8000,
  0x0000, 0x0003, 0x8000, 0x0000,
  0x0001, 0x8000, 0x0000, 0x0001,
  0x8000, 0x18FC, 0x7001, 0x8000,
  0x38FC, 0x7001, 0x8000, 0x3CFC,
  0xFFC1, 0x8000, 0x3EFD, 0xFFE1,
  0x8000, 0x3FFF, 0xFFE1, 0x8000,
  0x3FFF, 0xFFE1, 0x8000, 0x3EFE,
  0xFFC1, 0x8000, 0x3CFE, 0x7001,
  0x8000, 0x18FE, 0x2001, 0x8000,
  0x0000, 0x0002, 0x8000, 0x0000,
  0x0002, 0xC000, 0x0000, 0x0006,
  0x6000, 0x0000, 0x0004, 0x3800,
  0x0000, 0x000C, 0x0FFF, 0xFFFF,
  0xFFF8, 0x1800, 0x701C, 0x007C,
  0x3380, 0x3070, 0x0004, 0x38FF,
  0x607F, 0xFFFC, 0x3C01, 0xE00F,
  0x4008, 0x27FE, 0x2018, 0x01F8,
  0x3806, 0x601F, 0xBFD8, 0x1B03,
  0xC00C, 0x3018, 0x18FF, 0xF03C,
  0x07FC, 0x0F18, 0x903F, 0xFFFC,
  0x0E01, 0xF010, 0x0058, 0x3FFC,
  0xE07F, 0x00FC, 0xEFFF, 0xF0DF,
  0xFDFF, 0xFFFF, 0xF1BF, 0xFFFF
};

int mac_mask[48][3]={
  0x3FFF, 0xFFFF, 0xFFF0, 0xFFBF,
  0xFFFF, 0xFFFC, 0xBFEF, 0xFFFF,
  0xFFFF, 0xFF00, 0x0300, 0x01FD,
  0xFE00, 0x0600, 0x007D, 0xFC03,
  0xFFFC, 0x003D, 0xFC07, 0xFFFC,
  0x0035, 0xFC0F, 0xFFFC, 0x0035,
  0xFC0F, 0xFFFC, 0x0037, 0xFC0F,
  0xFF00, 0x003F, 0xF40F, 0xFF80,
  0x001F, 0xF407, 0xFFF8, 0x001F,
  0xFC01, 0xFFF8, 0x001F, 0xFE00,
  0x7FE0, 0x003F, 0xFF00, 0x0000,
  0x00FF, 0xFFFF, 0x0000, 0x07FF,
  0xFFFF, 0xFFFF, 0xFBFF, 0xF7FF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFB, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFF5, 0xFFFF, 0xFFFF,
  0xFFFD, 0xFFFF, 0xFFFF, 0xFFFD,
  0xFFFF, 0xFFFF, 0xFFFD, 0xFFFF,
  0xFFFF, 0xFFFD, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFD,
  0xFFFF, 0xFFFF, 0xFFF7, 0xFFFF,
  0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF,
  0xFFFA, 0xDFFF, 0xFFFF, 0xFFFE,
  0x6FFF, 0xFFFF, 0xFFEC, 0x3FFF,
  0xFFFF, 0xFFFC, 0x0FFF, 0xFFFF,
  0xFFF8, 0x1FFF, 0xF01F, 0xFFFC,
  0x37BF, 0x7077, 0xFFF4, 0x3FFF,
  0xE07F, 0xFFFC, 0x3FFF, 0xE00F,
  0xFFF8, 0x2FFF, 0xA01F, 0xFFF8,
  0x3FFF, 0xE01F, 0xFFF8, 0x1FFF,
  0xC00F, 0xF7F8, 0x1FFF, 0xF03F,
  0xFFFC, 0x0FFF, 0xD03F, 0xFFFC,
  0x0FBF, 0xF01F, 0xFDF8, 0x3FFF,
  0xE07F, 0xFFFC, 0xEFFF, 0xF0DF,
  0xFFFF, 0xFFFF, 0xF1BF, 0xFFFF
};

int spid_shape[48][3]=
{ 0x1000, 0x0400, 0x0020, 0x0800,
  0x0E00, 0x0020, 0x0C00, 0x1F00,
  0x0020, 0x0600, 0x3F80, 0x0020,
  0x0200, 0x7FC0, 0x0060, 0x0300,
  0x7FC0, 0x0040, 0x0100, 0xFFE0,
  0x00C0, 0x0180, 0xFFE0, 0x0380,
  0x00C0, 0xFFE0, 0x0E00, 0x0060,
  0xFFE0, 0x1000, 0x8020, 0xFFE0,
  0x301F, 0xC020, 0xFFE0, 0x60F0,
  0x7830, 0xFFE1, 0xC180, 0x0E18,
  0xFFE3, 0x0700, 0x038C, 0x7FEE,
  0x3C00, 0x00C7, 0x7FFA, 0xE000,
  0x0061, 0xBFF3, 0x8000, 0x0030,
  0x7FFF, 0xFF80, 0x001E, 0x7FFF,
  0xFFE0, 0x0003, 0xFFF8, 0x0070,
  0x07FF, 0xFFFE, 0x0038, 0x0C03,
  0xBFF1, 0x801C, 0x1806, 0x3FF0,
  0xC01E, 0x301C, 0x7FF0, 0x7006,
  0x6060, 0xFFF8, 0x1C07, 0xC1C0,
  0xFFF8, 0x0603, 0x8183, 0xFFFC,
  0x0301, 0x8303, 0xFFFC, 0x0381,
  0x8303, 0xFFFC, 0x01C1, 0x8703,
  0xFFFC, 0x01C1, 0x8503, 0xFFFC,
  0x01C1, 0x8503, 0xFFF8, 0x03C1,
  0x8703, 0xFFF0, 0x0280, 0x0706,
  0x7F90, 0x0680, 0x0604, 0xFFC8,
  0x0780, 0x0705, 0x1E28, 0x0700,
  0x0705, 0x002C, 0x0700, 0x0705,
  0x8064, 0x0700, 0x0602, 0x8048,
  0x0F00, 0x0601, 0xE078, 0x0B00,
  0x0600, 0x0000, 0x1600, 0x0600,
  0x0000, 0x3C00, 0x0700, 0x0000,
  0x3800, 0x0380, 0x0000, 0x3000,
  0x0180, 0x0000, 0x3000, 0x01C0,
  0x0000, 0x6000, 0x00C0, 0x0000,
  0x6000, 0x00E0, 0x0000, 0x6000
};
int spid2_shape[48][3]=
{ 0x001C, 0x0400, 0x6000, 0x0030,
  0x0E00, 0x6000, 0x0030, 0x1F00,
  0xC000, 0x0030, 0x3F80, 0xC000,
  0x0030, 0x7FC0, 0xC000, 0x0030,
  0x7FC0, 0xC000, 0x4030, 0xFFE0,
  0x807E, 0x6030, 0xFFE1, 0x80C0,
  0x3030, 0xFFE1, 0x8080, 0x1C30,
  0xFFE3, 0x8300, 0x0E30, 0xFFE3,
  0x8600, 0x0738, 0xFFE6, 0x3C00,
  0x0198, 0xFFE4, 0x6000, 0x00DC,
  0xFFED, 0xC000, 0x006E, 0x7FEF,
  0x0000, 0x0037, 0xFFFA, 0x0000,
  0x001B, 0xFFFC, 0x3FF0, 0x000F,
  0xFFFF, 0xFFFC, 0x1E07, 0xFFFF,
  0x000C, 0x37FF, 0xFFFF, 0x0006,
  0x2D9F, 0xFFFF, 0xC003, 0x787F,
  0xBFF1, 0xF003, 0xF006, 0xBFF0,
  0x7001, 0xA00F, 0xFFF0, 0x3C01,
  0xE01F, 0xFFF8, 0x0601, 0xE03C,
  0xFFF8, 0x0381, 0xC07B, 0xFFFC,
  0x01C0, 0x80E3, 0xFFFC, 0x00E0,
  0x81C3, 0xFFFC, 0x0070, 0x83C3,
  0xFFFC, 0x0038, 0x8383, 0xFFFC,
  0x0038, 0x8383, 0xFFF8, 0x0038,
  0x0783, 0xFFF8, 0x0038, 0x070C,
  0x7F8E, 0x0038, 0x0708, 0xFFC3,
  0x0038, 0x0609, 0x9E21, 0x8038,
  0x0709, 0x0030, 0x8038, 0x0785,
  0x0019, 0x0038, 0x0787, 0x000E,
  0x0030, 0x0383, 0x000C, 0x0030,
  0x01C0, 0x0000, 0x0070, 0x00F0,
  0x0000, 0x0060, 0x00F8, 0x0000,
  0x00E0, 0x0078, 0x0000, 0x01C0,
  0x003C, 0x0000, 0x0380, 0x001C,
  0x0000, 0x0700, 0x000E, 0x0000,
  0x0E00, 0x000F, 0x0000, 0x3C00
};
int spid_mask[48][3]=
{ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
  0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF
};

WORD open_vwork(phys_handle)
WORD phys_handle;
{
WORD work_in[11],
	work_out[57],
	new_handle;		/* handle of workstation  */
int i;

	for (i = 0; i < 10; i++ )  /*set for default values */
		work_in[i] = 1;
	work_in[10]=2;			/* use raster coords */
	new_handle = phys_handle;	/* use currently open workstation */
	v_opnvwk(work_in, &new_handle, work_out);
	return(new_handle);
}

set_screen_attr()
{
WORD work_out[57];

	vq_extnd(screen_vhandle, 0, work_out);
	x_max = work_out[0];
	y_max = work_out[1];
	screen_rez = Getrez();	/* 0 low, 1 med, 2 hi */
	color_screen = (screen_rez < 2); /* mono 2, color 0 or 1 */
}



long Rnd_rng(low, hi)
long low, hi;
/* gen rand num bet lo and hi */

{
	hi++;
	return ( (Random()%(hi-low))+low);
}


char *set_bitmap(new_map)
char **new_map;
 /* allocates mem for new screen bitmap*/

{
long x;

	x=(long)Malloc(32256L);
	if (!(x%256))
		*new_map = (char *) x;
	else
		*new_map = (char *) (x+(256-(x%256)));
return;


}

set_up_rasters()
{
/* ball raster */
ballMFDB.addr = (char *)ball_shape;
ballMFDB.wide = W_BALL;
ballMFDB.high = H_BALL;
ballMFDB.word_width = 3;
ballMFDB.format = 0;
ballMFDB.planes = 1;



maskMFDB.addr = (char *)ball_mask;
maskMFDB.wide = W_BALL;
maskMFDB.high = H_BALL;
maskMFDB.word_width = 3;
maskMFDB.format = 0;
maskMFDB.planes = 1;

/* well looky here! Your Own Memory Form Definition Block!! */
youMFDB.addr = (char *)you;
youMFDB.wide = 16;
youMFDB.high = 16;
youMFDB.word_width = 1;
youMFDB.format = 0;
youMFDB.planes = 1;

bulletMFDB.addr = (char *)bullet;
bulletMFDB.wide=16;
bulletMFDB.high = 16;
bulletMFDB.word_width = 1;
bulletMFDB.format=0;
bulletMFDB.planes = 1;


scrMFDB[0].wide = 640;
scrMFDB[0].high = 400;
scrMFDB[0].word_width = 40;
scrMFDB[0].format = 0;
scrMFDB[0].planes = 1;  

if (screen_rez == 0)
{
scrMFDB[0].wide = 320;
scrMFDB[0].high = 200;
scrMFDB[0].word_width = 20;
scrMFDB[0].planes = 2;
}
else if (screen_rez == 1)
{
scrMFDB[0].wide = 640;
scrMFDB[0].high = 200;
scrMFDB[0].planes = 2;
}

scrMFDB[1].wide = scrMFDB[0].wide;
scrMFDB[1].high = scrMFDB[0].high;
scrMFDB[1].word_width = scrMFDB[0].word_width;
scrMFDB[1].format = scrMFDB[0].format;
scrMFDB[1].planes = scrMFDB[0].planes;
scrMFDB[0].addr = bitmap0; scrMFDB[1].addr = bitmap1;
return;
}
init_ball()
{
int i;
WORD work_out[57];
level_sound(lvl);
vq_extnd(screen_vhandle, 0, work_out);
gravity = 9800000L / (3600L * (float)work_out[4]);
switch(lvl)
{
case 1:
for (i=0; i<NUM_BALLS; i++)
	{
	ball[i].x[0]=ball[i].x[1] = 276;
	ball[i].y[0]=ball[i].y[1] = 40;
	ball[i].dx=5;
	ball[i].dy=1;
	ball[i].delay=(i*4);
	gravity=2;
	drooghit[i]=0;
	}
	break;
case 2:
	for (i=0; i<NUM_BALLS;i++)
	{
	ball[i].x[0]=ball[i].x[1]=270+(i*2);
	ball[i].y[0]=ball[i].y[1]=20;
	ball[i].dx=-10;
	ball[i].dy=2;
	ball[i].delay=(i*4);
	gravity=3;
	drooghit[i]=0;
	}
	break;
case 4:
	for (i=0;i<NUM_BALLS;i++)
	{
	ball[i].x[0]=ball[i].x[1]=230;
	ball[i].y[0]=ball[i].y[1]=30;
	ball[i].dx=-10+((i-1)*5);
	ball[i].dy=3;
	gravity=6;
	drooghit[i]=0;
	}
	break;
case 6:
	for (i=0; i<NUM_BALLS; i++)
	{
	ball[i].x[0]=ball[i].x[1]=120*(i-1);
	ball[i].y[0]=ball[i].y[1]=20;
	ball[i].dx=10-((i-1)*7);
	ball[i].dy=0;
	gravity=7;
	drooghit[i]=0;
	ball[i].delay=6;
	}
	break;



default:
	for (i=0; i<NUM_BALLS; i++)
	{
	ball[i].x[0] = ball[i].x[1] = 276;
	ball[i].y[0] = ball[i].y[1] = 0;
	ball[i].dx = Rnd_rng(-10L, 10L);
	ball[i].dy = 0;
	ball[i].delay = Rnd_rng(1L, 50L);
	drooghit[i] = 0;
	}


}





}

erase_you(yy)         /* you don't matter anyhow.*/
WORD yy;	      /* dont be confused.  This is actually the X value. */
{		      
int youy = 180;
int pxy[8],color_index[2];
color_index[0]=0; color_index[1]=0;
pxy[0]=0; pxy[1]=0; pxy[2]=15; pxy[3]=15; pxy[4]=yy; pxy[5]=youy;
pxy[6]=yy+pxy[2]; pxy[7]=youy+pxy[3];

vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &youMFDB, &scrMFDB[draw_screen],
	color_index);
}



draw_you(yy)
WORD yy;		/* actually X value */
{
int color_index[2],pxy[8];
color_index[0]=1;
pxy[0]=0; pxy[1]=0; pxy[2]=15; pxy[3]=15; pxy[4]=yy; pxy[5]=youy;
	pxy[6]=yy+pxy[2]; pxy[7]=youy+pxy[3];

vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &youMFDB, &scrMFDB[draw_screen],
	color_index);


}

erase_bull(x,y)
WORD x,y;
{

int color_index[2],pxy[8];
if (y>20)
	{
	color_index[0]=0; color_index[1]=0;
	pxy[0]=0;pxy[1]=0;pxy[2]=15;pxy[3]=15;pxy[4]=x;pxy[5]=y;
	pxy[6]=x+pxy[2];pxy[7]=y+pxy[3];
	
vrt_cpyfm(screen_vhandle,MD_TRANS,pxy,&bulletMFDB,&scrMFDB[draw_screen],
			color_index);
	}
}

draw_bull(x,y)
WORD x,y;
{
int color_index[2],pxy[8];
if (y>20)
	{
	color_index[0]=1;color_index[1]=0;
	pxy[0]=0;pxy[1]=0;pxy[2]=15;pxy[3]=15;pxy[4]=x;pxy[5]=y;
	pxy[6]=x+pxy[2];pxy[7]=y+pxy[3];

vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &bulletMFDB, &scrMFDB[draw_screen],
			color_index);
	}
}

	

draw_ball(x,y)
WORD x, y;
{
WORD pxy[8], color_index[2];
color_index[0] = 1;
color_index[1] = 0;

pxy[0] = 0; pxy[1]=0; pxy[2]=W_BALL -1; pxy[3]=H_BALL-1;
pxy[4]=x; pxy[5]=y; pxy[6]=x+pxy[2]; pxy[7]=y+pxy[3];

color_index[0] = 0;
vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &maskMFDB, &scrMFDB[draw_screen],
			color_index);

color_index[0] = 1;
vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &ballMFDB, &scrMFDB[draw_screen],
			color_index);

}


erase_ball(x,y)
WORD x,y;
{
WORD pxy[8],
color_index[2];
color_index[0]=0; color_index[1]=0;

pxy[0]=0; pxy[1]=0; pxy[2]=W_BALL-1; pxy[3]=H_BALL-1; pxy[4]=x; pxy[5]=y;
pxy[6]=x+pxy[2]; pxy[7]=y+pxy[3];

color_index[0]=0;
vrt_cpyfm(screen_vhandle, MD_TRANS, pxy, &maskMFDB, &scrMFDB[draw_screen],
		color_index);
}


calc_ball()
{
int i;
for (i=0; i<NUM_BALLS; i++)
{
if (drooghit[i]==0)
	{
	ball[i].delay--;
	if (ball[i].delay>0)
		continue;

	ball[i].dy += gravity;
	ball[i].y[draw_screen] = ball[i].y[show_screen] + ball[i].dy;
	ball[i].x[draw_screen] = ball[i].x[show_screen] + ball[i].dx;


if (ball[i].x[draw_screen] < 0)
{
ball[i].x[draw_screen] = 0;
ball[i].dx = -ball[i].dx;
}

if (ball[i].x[draw_screen] > (x_max - W_BALL))
{
ball[i].x[draw_screen] = x_max - W_BALL;
ball[i].dx = -ball[i].dx;
}

if (ball[i].y[draw_screen]<0)
{
if (gravity != 0)
{
ball[i].y[draw_screen]=0;
ball[i].dy=0;
}
else 
{ball[i].y[draw_screen]=0;
ball[i].dy=-ball[i].dy;
}

}

if (ball[i].y[draw_screen] > (y_max - H_BALL))
{
ball[i].y[draw_screen] = y_max - H_BALL;
bounce_sound(i);
if (gravity != 0)
ball[i].dy = -ball[i].dy * (1-(lvl*.002));
else
ball[i].dy = -ball[i].dy;
}
}
}   
return;
}
bounce_ball()
{
int i,mousex,mousey,button;
for (i=0; i < NUM_BALLS; i++)
	{
	if (drooghit[i] == 0)
	draw_ball(ball[i].x[draw_screen], ball[i].y[draw_screen]);
	}
vq_mouse(screen_vhandle,&button,&mousex,&mousey);
youx[draw_screen]=mousex;


draw_you(youx[draw_screen]);
draw_bull(bullx,bully[draw_screen]);
v_gtext(screen_vhandle,10,16,scobuf);
v_gtext(screen_vhandle,360,16,lvlbuf);
v_gtext(screen_vhandle,520,16,livbuf);
if (show_screen)
{
draw_screen=1; show_screen=0;

}
else 
{
draw_screen=0; show_screen=1;
}
Setscreen(scrMFDB[draw_screen].addr, scrMFDB[show_screen].addr, -1L);
Vsync();
for (i=0; i<NUM_BALLS; i++)
erase_ball(ball[i].x[draw_screen], ball[i].y[draw_screen]);

erase_you(youx[draw_screen]);
erase_bull(bullx,bully[draw_screen]);
if (bully[draw_screen] > 20)
	bully[draw_screen]=bully[show_screen]-10;
calc_ball();

return;
}


check_youhit()
{
int bx,by,ax,ay,yx,yy,tmp;

bx = ball[i].x[show_screen];
by = ball[i].y[show_screen];
ax = bullx;
ay = bully[show_screen];
yx = youx[show_screen];
yy = youy;




/* check */
if ((bx-8<yx) && (bx+40>yx) && (by+5 > y_max-H_BALL) && (drooghit[i]==0))
		{
		hit=1;
		--lives;
		kill_me();
		}	

if ((ax>bx-4) && (ax<bx+40) && (ay>by) && (ay<by+48) && (ax>0) && (ay>30) 
			&& (bx>0) && (drooghit[i]==0))
			{
			drooghit[i] = 1;
			tmp=draw_screen;
	draw_screen=1;show_screen=0;erase_bull(bullx,bully[draw_screen]);
	draw_screen=0;show_screen=1;erase_bull(bullx,bully[draw_screen]);
			bully[draw_screen]=19;bully[show_screen]=19;
			if (tmp)
				{
				draw_screen=1;show_screen=0;
				}
			sco=sco+(10*lvl);
			sprintf(scobuf,"Score ->%d",sco);
			killdroog();
					}				
return;
}





kill_me()
{
clear_sound();
Giaccess(8,6|0x80);
mixer(037&057&067);
Giaccess(16,8|0x80);
Giaccess(16,9|0x80);
Giaccess(16,10|0x80);
Giaccess(16,12|0x80);
Giaccess(16,13|0x80);
wait(1000);
return;
}


killdroog()
{
clear_sound();
Giaccess(15,6|0x80);
mixer(037,057,067);
Giaccess(16,8|0x80);
Giaccess(16,9|0x80);
Giaccess(16,10|0x80);
Giaccess(16,12|0x80);
Giaccess(16,13|0x80);
return;
}
level_sound()
{
int i,dly;
for (i=0;i<2;i++)
{
register sweep;
clear_sound();
mixer(076);
Giaccess(15,8|0x80);
Giaccess(15,9|0x80);
for (sweep=20; sweep<=90; sweep++)
	{
	Giaccess(sweep,0|0x080);
	Giaccess(sweep+15,2|0x80);
	Giaccess(15-((sweep-15)/5),8|0x80);
	Giaccess(15-((sweep-15)/5),9|0x80);
	dly=1;
	if (sweep>55)
		dly=32;
	vst_effects(screen_vhandle,dly);
	v_gtext(screen_vhandle,280,100,lvlbuf);
	}
}
clear_sound();

vst_effects(screen_vhandle,0);
return;
}

bounce_sound(x)
int x;
{
int dly; register sweep;
mixer(076);
Giaccess(15,8|0x080);
for(sweep=x*20;sweep<(x+1)*20;sweep++)
	{
	Giaccess(sweep,0|0x080);
	dly=7000;
	if (dly>0)
		--dly;
	}
clear_sound();
return;
}



mixer(ch)
int ch;
{
register temp;
temp = Giaccess(0,7);
temp=temp | 077;
ch=ch|0300;
Giaccess(temp&ch,7|0x80);
return;
}

clear_sound()
{
register i;
for(i=0;i<7;i++)
	Giaccess(0,i|0x80);
mixer(077);
Giaccess(0,8|0x80);
Giaccess(0,9|0x80);
Giaccess(0,10|0x80);
return;
}
wait(ms)
int ms;
{
long i;
for (; ms>0; ms--)	
	for(i=125;i>0;i--)
		;
return;
} 


/* The Bigge Intro! */
intro()
{
int char_h,char_w,cell_h,cell_w;
int pxy[8],color_index[2],attrib[10];
color_index[0]=1;color_index[1]=0;

draw_screen=1;show_screen=0;
Setscreen(scrMFDB[draw_screen].addr,scrMFDB[show_screen].addr,-1L);
v_clrwk(screen_vhandle);
draw_screen=0;show_screen=1;
Setscreen(scrMFDB[draw_screen].addr,scrMFDB[show_screen].addr,-1L);
v_clrwk(screen_vhandle);

clear_sound();
mixer(076);
Giaccess(15,8|0x80);
Giaccess(2,1|0x80);
Giaccess(2,3|0x80);
vqt_attributes(screen_vhandle,attrib);
vst_point(screen_vhandle,40,&char_w,&char_h,&cell_w,&cell_h);
Setscreen(scrMFDB[show_screen].addr,-1L,-1L);
v_gtext(screen_vhandle,170,50,"Droogs From Hell!");
Setscreen(scrMFDB[draw_screen].addr,-1L,-1L);
vst_effects(screen_vhandle,4);
v_gtext(screen_vhandle,170,50,"Droogs From Hell!");
vst_point(screen_vhandle,8,&char_w,&char_h,&cell_w,&cell_h);
v_gtext(screen_vhandle,250,180,"whack any key to play");
Setscreen(scrMFDB[show_screen].addr,-1L,-1L);
vst_effects(screen_vhandle,0);
v_gtext(screen_vhandle,250,180,"whack any key to play");
Setscreen(scrMFDB[draw_screen].addr,-1L,-1L);
v_gtext(screen_vhandle,250,100,"by Jason Sodergren");
Setscreen(scrMFDB[show_screen].addr,-1L,-1L);
vst_effects(screen_vhandle,4);
v_gtext(screen_vhandle,250,100,"by Jason Sodergren !");
vst_effects(screen_vhandle,0);


draw_screen=1;draw_ball(100,100);draw_ball(200,103);draw_ball(300,100);
	draw_ball(400,103);draw_ball(500,100);
draw_screen=0;draw_ball(101,103);draw_ball(201,100);draw_ball(301,103);
	draw_ball(401,100);draw_ball(501,103);

while (!Cconis())
	{
	Setscreen(-1L,scrMFDB[0].addr,-1L);
	ping(230);
	Setscreen(-1L,scrMFDB[1].addr,-1L);
	ping(0);
	Setscreen(-1L,scrMFDB[0].addr,-1L);
	ping(230);
	Setscreen(-1L,scrMFDB[1].addr,-1L);
	ping(240);
	}
clear_sound();
}

ping(f)
int f;
{
int v;
v=15;
Giaccess(f,0|0x80);
Giaccess(f+10,2|0x80);
while (v>0)
	{
	Giaccess(v,8|0x80);
	--v;
	wait(20);
	}
wait(50);
}





main()
{
int ap_id;				/* application init verify */
WORD gr_wchar, gr_hchar, 		/* values for VDI handle   */
     gr_wbox, gr_hbox;




	ap_id = appl_init();		/* init AES routines */
	if (ap_id < 0)			/* no calls can be made to AES */
	{				/* use GEMDOS */
		Cconws("***> Ahem.  Init error.  <***\n");
		Cconws(" Whack any key to continue.\n");
		Crawcin();
		exit(-1);		/* set exit value to show err */
	}

	screen_phandle =		/*get handle for screen */ 
		graf_handle(&gr_wchar, &gr_hchar, &gr_wbox, &gr_hbox);
	screen_vhandle = open_vwork(screen_phandle);
	set_screen_attr();		/* get screen attributes */


bitmap0 = (char *)Logbase();
set_bitmap(&bitmap1);
set_up_rasters();
graf_mouse(M_OFF,0x0L);
intro();

do
{

show_screen = 0; draw_screen = 1; Setscreen(bitmap1, -1L, -1L);
v_clrwk(screen_vhandle);
Setscreen(bitmap0, bitmap0, -1L);
sprintf(lvlbuf,"Level -> %d",lvl);
sprintf(livbuf,"Lives -> %d",lives);
sprintf(scobuf,"Score -> %d",sco);
init_ball();
v_clrwk(screen_vhandle);

	do
	{

		do
		{
		bounce_ball();
		vq_mouse(screen_vhandle,&button,&mousex,&mousey);



if  (Rnd_rng(1L,2L)==2)    switch(lvl)
					{
					case 2:
					ballMFDB.addr = *zag_shape;
				        break;
					case 3:
					ballMFDB.addr = *byth_shape;
					break;
				
					case 4:
					ballMFDB.addr = *eye_shape;
					break;
					case 5:
					ballMFDB.addr = *sched_shape;
					break;
					case 6:
					ballMFDB.addr = *mac_shape;
					break;
					case 7:
					ballMFDB.addr = *spid_shape;
					break;
					default:
					ballMFDB.addr = *ball_shape;
					}
else	switch(lvl)
					{
					case 2:
					ballMFDB.addr = *zag2_shape;
				        break;
					case 3:
					ballMFDB.addr = *byth2_shape;
					break;
				
					case 4:
					ballMFDB.addr = *eye2_shape;
					break;
					case 5:
					ballMFDB.addr = *sched2_shape;
					break;
					case 6:
					ballMFDB.addr = *mac2_shape;
					break;
					case 7:
					ballMFDB.addr = *spid2_shape;
					break;
					default:
					ballMFDB.addr = *ball2_shape;
					}



		hit=0;
		tmpdroog=0;
		for (i=0; i<NUM_BALLS; i++)
			{
			check_youhit(); 	 
			if (drooghit[i]==1)
				++tmpdroog;
			if (tmpdroog == NUM_BALLS)
				{
				lvl++;
				hit=1; 
				switch(lvl)
					{
					case 2:
					ballMFDB.addr = *zag_shape;
					maskMFDB.addr = *zag_mask;
				        break;
					case 3:
					ballMFDB.addr = *byth_shape;
					maskMFDB.addr = *byth_mask;
					break;
				
					case 4:
					ballMFDB.addr = *eye_shape;
					maskMFDB.addr = *eye_mask;
					break;
					case 5:
					ballMFDB.addr = *sched_shape;
					maskMFDB.addr = *sched_mask;
					break;
					case 6:
					ballMFDB.addr = *mac_shape;
					maskMFDB.addr = *mac_mask;
					break;
					case 7:
					ballMFDB.addr = *spid_shape;
					maskMFDB.addr = *spid_mask;
					break;
					default:
					ballMFDB.addr = *ball_shape;
					maskMFDB.addr = *ball_mask;
					}



				}

		
			}	
		if (hit == 1)
			break; 
		youx[draw_screen] = youx[show_screen];
	} while (button==0);
	if (hit == 1)
		break;
	if (bully[draw_screen]<30)
			{
			bully[show_screen]=180; bully[draw_screen]=180;
			bullx=youx[show_screen];
			}
	} while (hit==0);
hit=0;
} while (lives > 0);


Setscreen(bitmap0, bitmap0, -1L);
Mfree(bitmap1);
v_clsvwk(screen_vhandle);
	appl_exit();		 /*  exit the program. */
}