1199 lines
24 KiB
C
1199 lines
24 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <malloc.h>
|
|
#include <math.h>
|
|
|
|
#include "8086_emulator.h"
|
|
#include "vga_emulator.h"
|
|
|
|
#include "../gr-sim.h"
|
|
#include "../tfv_zp.h"
|
|
|
|
#include "sin1024.h"
|
|
|
|
#define MAXDOTS 1024
|
|
|
|
#define BOTTOM 8000
|
|
|
|
#define SKIP 2
|
|
|
|
#define FRAME_SKIP 7
|
|
|
|
static int write_frame=-1;
|
|
|
|
static short gravitybottom=BOTTOM;
|
|
|
|
static short bpmin=30000;
|
|
static short bpmax=-30000;
|
|
static short gravity=0;
|
|
static short dotnum=0;
|
|
static short gravityd=16;
|
|
|
|
//???,-1280,-960,-640,-320};
|
|
|
|
static short rows[200];
|
|
|
|
//dot dw MAXDOTS dup(0,0,0,0,0,0,0,0) ;x,y,z,oldposshadow,oldpos,-,-,-
|
|
|
|
static struct {
|
|
short x; // 0
|
|
short y; // 2
|
|
short z; // 4
|
|
short old1; // 6 oldpos shadow
|
|
short old2; // 8 oldpos
|
|
short old3; // 10
|
|
short old4; // 12
|
|
short yadd; // 14
|
|
} dot[MAXDOTS];
|
|
|
|
static short rotsin=0;
|
|
static short rotcos=0;
|
|
|
|
static char *bgpic;
|
|
|
|
static int depthtable1[128];
|
|
static int depthtable2[128];
|
|
static int depthtable3[128];
|
|
|
|
static unsigned char depthtable1_bytes[512];
|
|
static unsigned char depthtable2_bytes[512];
|
|
static unsigned char depthtable3_bytes[512];
|
|
|
|
static int shadow[40][48];
|
|
static int ball[40][48];
|
|
FILE *output;
|
|
|
|
static void drawdots(void) {
|
|
int temp32;
|
|
int yy;
|
|
|
|
// CBEG
|
|
ax=0xa000; // mov ax,0a000h
|
|
es=ax; // mov es,ax
|
|
ax=cs; // mov ax,cs
|
|
ds=ax; // mov ds,ax
|
|
|
|
/* why [2]? */
|
|
fs=bgpic[2]; // mov fs,cs:_bgpic[2]
|
|
cx=dotnum; // mov cx,cs:_dotnum
|
|
si=0; // mov si,OFFSET dot
|
|
|
|
label1:
|
|
push(cx); // push cx
|
|
ax=dot[si].x; // mov ax,ds:[si+0] ;X
|
|
imul_16(rotsin); // imul ds:_rotsin
|
|
ax=ax; // mov ax,ax
|
|
cx=dx; // mov cx,dx
|
|
ax=dot[si].z; // mov ax,ds:[si+4] ;Z
|
|
imul_16(rotcos); // imul ds:_rotcos
|
|
ax=ax-bx; // sub ax,bx
|
|
dx=dx-cx; // sub dx,cx
|
|
bp=dx; // mov bp,dx
|
|
bp=bp+9000; // add bp,9000
|
|
|
|
ax=dot[si].x; // mov ax,ds:[si+0] ;X
|
|
imul_16(rotcos); // imul ds:_rotcos
|
|
bx=ax; // mov bx,ax
|
|
cx=dx; // mov cx,dx
|
|
ax=dot[si].z; // mov ax,ds:[si+4] ;Z
|
|
imul_16(rotsin); // imul ds:_rotsin
|
|
|
|
temp32=ax+bx; // add ax,bx
|
|
ax=ax+bx; //
|
|
dx=dx+cx; // adc dx,cx
|
|
if (temp32&(1<<16)) dx=dx+1;
|
|
|
|
|
|
// printf("Before: ax=0x%04X dx=%04X\n",ax,dx);
|
|
ax=(ax>>8)|(dx<<8); // shrd ax,dx,8
|
|
dx=sar(dx,8); // sar dx,8
|
|
// printf("After: ax=0x%04X dx=%04X\n",ax,dx);
|
|
|
|
bx=ax; // mov bx,ax
|
|
cx=dx; // mov cx,dx
|
|
ax=(ax>>3)|(dx<<13); // shrd ax,dx,3
|
|
|
|
dx=sar(dx,3); // sar dx,3
|
|
temp32=ax+bx; // add ax,bx
|
|
ax=ax+bx;
|
|
dx=dx+cx; // adc dx,cx
|
|
if (temp32&(1<<16)) dx=dx+1;
|
|
|
|
temp32=(dx<<16)|(ax&0xfffff);
|
|
idiv_16(bp); // idiv bp
|
|
ax=ax+160; // add ax,160
|
|
push(ax); // push ax
|
|
|
|
/* if off end of screen, no need for shadow */
|
|
|
|
if (ax>319) goto label2; // cmp ax,319
|
|
|
|
// ja @@2
|
|
/**********/
|
|
/* shadow */
|
|
/**********/
|
|
|
|
ax=0; // xor ax,ax
|
|
dx=8; // mov dx,8
|
|
idiv_16(bp); // idiv bp
|
|
ax=ax+100; // add ax,100
|
|
|
|
/* if shadow off screen, don't draw */
|
|
if (ax>199) goto label2; // cmp ax,199
|
|
// ja @@2
|
|
bx=ax; // mov bx,ax
|
|
|
|
// not needed, it's a C array
|
|
//bx=bx<<1; // shl bx,1
|
|
bx=rows[bx]; // mov bx,ds:_rows[bx]
|
|
ax=pop(); // pop ax
|
|
bx=bx+ax; // add bx,ax
|
|
push(ax); // push ax
|
|
|
|
// printf("Drawing shadow at %d,%d\n",bx%320,bx/320);
|
|
|
|
|
|
|
|
/* erase old shadow (?)*/
|
|
di=dot[si].old1; // mov di,ds:[si+6]
|
|
|
|
yy=((di/320)*48)/200;
|
|
if (yy>23) color_equals(5);
|
|
else color_equals(0);
|
|
plot( (di%320)/8,yy);
|
|
|
|
//ax=bgpic[di]; // mov ax,fs:[di]
|
|
//framebuffer[di]=ax; // mov es:[di],ax
|
|
|
|
// framebuffer[di]=bgpic[di];
|
|
// framebuffer[di+1]=bgpic[di+1];
|
|
framebuffer_write(di,bgpic[di]);
|
|
framebuffer_write(di+1,bgpic[di+1]);
|
|
|
|
|
|
|
|
/* draw new shadow (?) */
|
|
// ax=87+87*256; // mov ax,87+87*256
|
|
// framebuffer[bx]=ax; // mov word ptr es:[bx],ax
|
|
|
|
// framebuffer[bx]=87;
|
|
// framebuffer[bx+1]=87;
|
|
framebuffer_write(bx,87);
|
|
framebuffer_write(bx+1,87);
|
|
|
|
// bx/320 -> 200 200->48 *48/200
|
|
|
|
yy=((bx/320)*48)/200;
|
|
color_equals(0);
|
|
plot( (bx%320)/8,yy);
|
|
|
|
shadow[(bx%320)/8][yy]=1;
|
|
|
|
// printf("0,%d,%d\n",(bx%320)/8,yy);
|
|
|
|
// printf("Plotting at %d,%d\n",(bx%320)/8,(bx/320)/5);
|
|
|
|
/* save this to erase next time */
|
|
dot[si].old1=bx; // mov ds:[si+6],bx
|
|
|
|
/********/
|
|
/* ball */
|
|
/********/
|
|
// ax=gravity; // mov ax,ds:_gravity
|
|
// dot[si].yadd+=ax; // add ds:[si+14],ax
|
|
|
|
// if (si==100) printf("Gravity: %hd (%04x) Yadd: %hd (%04x)\n",
|
|
// gravity,gravity,dot[si].yadd,dot[si].yadd);
|
|
|
|
dot[si].yadd+=gravity;
|
|
|
|
// if (si==100) printf("\tyadd after yadd+=gravity: %hd (%04x)\n",
|
|
// dot[si].yadd,dot[si].yadd);
|
|
|
|
// ax=dot[si].y; // mov ax,ds:[si+2] ;Y
|
|
// ax+=dot[si].yadd; // add ax,ds:[si+14]
|
|
ax=dot[si].y+dot[si].yadd;
|
|
|
|
// if (si==100) printf("\tax=y+yadd: %hu (%04x) = "
|
|
// "%hd (%04x) + %hd (%04x)\n",
|
|
// ax,ax,dot[si].y,dot[si].y,dot[si].yadd,dot[si].yadd);
|
|
|
|
// if (si==100) printf("\tcomparing if (ax<gravitybottom): "
|
|
// "%hu < %hd\n",ax,gravitybottom);
|
|
|
|
|
|
temp32=ax;
|
|
if (temp32&0x8000) temp32|=0xffff0000;
|
|
if (temp32<gravitybottom) goto label4; //cmp ax,ds:_gravitybottom
|
|
// jl @@4
|
|
|
|
// if (si==100) printf("\twas greater than (not less)\n");
|
|
|
|
push(ax); // push ax
|
|
|
|
// ax=dot[si].yadd; // mov ax,ds:[si+14]
|
|
// ax=-ax; // neg ax
|
|
ax=-dot[si].yadd;
|
|
|
|
// if (si==100) printf("\tax is -yadd: %hu %x\n",ax,ax);
|
|
|
|
// if (si==100) printf("\tabout to multiply gravityd*ax: "
|
|
// "%hd (%x) * %hu (%x)\n",gravityd,gravityd,
|
|
// ax,ax);
|
|
imul_16(gravityd); // imul cs:_gravityd
|
|
|
|
// if (si==100) printf("\tresult dx:ax is %x:%x (%hu)\n",
|
|
// dx,ax,ax);
|
|
|
|
ax=sar(ax,4); // sar ax,4
|
|
|
|
// if (si==100) printf("\tyadd=(ax>>4 is %x (%hu))\n",
|
|
// ax,ax);
|
|
dot[si].yadd=ax; // mov ds:[si+14],ax
|
|
ax=pop(); // pop ax
|
|
// if (si==100) printf("\trestoring ax=%x, adding yadd %x\n",
|
|
// ax,dot[si].yadd);
|
|
|
|
ax+=dot[si].yadd; // add ax,ds:[si+14]
|
|
|
|
// if (si==100) printf("\tax=%x\n",ax);
|
|
|
|
label4:
|
|
dot[si].y=ax; // mov ds:[si+2],ax
|
|
|
|
// if (si==100) printf("\tdot[si].y=%x\n",dot[si].y);
|
|
|
|
if (ax&0x8000) { // cwd
|
|
dx=0xffff;
|
|
}
|
|
else {
|
|
dx=0;
|
|
}
|
|
|
|
// if (si==100) printf("\tdx:ax = %04hx:%04hx\n",dx,ax);
|
|
|
|
dx=(dx<<6)|(ax>>10); // shld dx,ax,6
|
|
ax=ax<<6; // shl ax,6
|
|
|
|
// if (si==100) printf("\tdx:ax <<6 = %04hx:%04hx, bp=%04hx\n",dx,ax,bp);
|
|
|
|
idiv_16(bp); // idiv bp
|
|
// if (si==100) printf("\tY ax=%d\n",ax);
|
|
ax=ax+100; // add ax,100
|
|
if (ax>199) goto label3; // cmp ax,199
|
|
// ja @@3
|
|
// if (si==100) printf("\tdraw Y ax=%d\n",ax);
|
|
bx=ax; // mov bx,ax
|
|
|
|
// not needed, C array
|
|
//bx=bx<<1; // shl bx,1
|
|
bx=rows[bx]; // mov bx,ds:_rows[bx]
|
|
|
|
ax=pop(); // pop ax
|
|
bx=bx+ax; // add bx,ax
|
|
|
|
di=dot[si].old2; // mov di,ds:[si+8]
|
|
// framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
// framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
// framebuffer[di+2]=bgpic[di+2];
|
|
// framebuffer[di+3]=bgpic[di+3];
|
|
|
|
yy=((di/320)*48)/200;
|
|
if (yy>23) color_equals(5);
|
|
else color_equals(0);
|
|
plot( (di%320)/8,yy);
|
|
|
|
framebuffer_write(di,bgpic[di]);
|
|
framebuffer_write(di+1,bgpic[di+1]);
|
|
framebuffer_write(di+2,bgpic[di+2]);
|
|
framebuffer_write(di+3,bgpic[di+3]);
|
|
|
|
|
|
|
|
|
|
di=di+320; // add di,320
|
|
// framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
// framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
// framebuffer[di+2]=bgpic[di+2];
|
|
// framebuffer[di+3]=bgpic[di+3];
|
|
|
|
framebuffer_write(di,bgpic[di]);
|
|
framebuffer_write(di+1,bgpic[di+1]);
|
|
framebuffer_write(di+2,bgpic[di+2]);
|
|
framebuffer_write(di+3,bgpic[di+3]);
|
|
|
|
|
|
di=di+320; // add di,320
|
|
// framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
// framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
// framebuffer[di+2]=bgpic[di+2];
|
|
// framebuffer[di+3]=bgpic[di+3];
|
|
|
|
framebuffer_write(di,bgpic[di]);
|
|
framebuffer_write(di+1,bgpic[di+1]);
|
|
framebuffer_write(di+2,bgpic[di+2]);
|
|
framebuffer_write(di+3,bgpic[di+3]);
|
|
|
|
//;; add di,320
|
|
//;; mov eax,fs:[di]
|
|
//;; mov es:[di],eax
|
|
|
|
bp=bp>>6; // shr bp,6
|
|
bp=bp&(~3L); // and bp,not 3
|
|
|
|
temp32=bp;
|
|
if (temp32&0x8000) temp32|=0xffff0000;
|
|
if (temp32>=bpmin) goto label_t1; // cmp bp,cs:_bpmin
|
|
// jge @@t1
|
|
bpmin=bp; // mov cs:_bpmin,bp
|
|
label_t1:
|
|
temp32=bp;
|
|
if (temp32&0x8000) temp32|=0xffff0000;
|
|
if (temp32<=bpmax) goto label_t2; // cmp bp,cs:_bpmax
|
|
// jle @@t2
|
|
bpmax=bp; // mov cs:_bpmax,bp
|
|
label_t2:
|
|
// eax=depthtable1[bp]; // mov ax,word ptr ds:_depthtable1[bp]
|
|
// mov word ptr es:[bx+1],ax
|
|
|
|
|
|
yy=((bx/320)*48)/200;
|
|
color_equals(6);
|
|
plot( (bx%320)/8,yy);
|
|
|
|
ball[(bx%320)/8][yy]=1;
|
|
|
|
// printf("6,%d,%d\n",(bx%320)/8,yy);
|
|
|
|
framebuffer[bx+1]=depthtable1_bytes[bp];
|
|
framebuffer[bx+2]=depthtable1_bytes[bp+1];
|
|
|
|
//eax=depthtable2[bp]; // mov eax,ds:_depthtable2[bp]
|
|
// mov dword ptr es:[bx+320],eax
|
|
framebuffer[bx+320]=depthtable2_bytes[bp];
|
|
framebuffer[bx+321]=depthtable2_bytes[bp+1];
|
|
framebuffer[bx+322]=depthtable2_bytes[bp+2];
|
|
framebuffer[bx+323]=depthtable2_bytes[bp+3];
|
|
|
|
// eax=depthtable3[bp]; // mov ax,word ptr ds:_depthtable3[bp]
|
|
// mov word ptr es:[bx+641],ax
|
|
framebuffer[bx+641]=depthtable3_bytes[bp];
|
|
framebuffer[bx+642]=depthtable3_bytes[bp+1];
|
|
dot[si].old2=bx; // mov ds:[si+8],bx
|
|
|
|
|
|
//labelz:
|
|
cx=pop(); // pop cx
|
|
si=si+SKIP; // add si,16 point to next dot
|
|
cx=cx-SKIP;
|
|
if (cx!=0) goto label1; // loop @@1
|
|
label0:
|
|
return;
|
|
// @@0: CEND
|
|
|
|
label2:
|
|
/* This is called when we are off the screen */
|
|
/* erases old but didn't draw new */
|
|
|
|
/* erase old dot */
|
|
di=dot[si].old2; // mov di,ds:[si+8]
|
|
|
|
|
|
yy=((di/320)*48)/200;
|
|
if (yy>23) color_equals(5);
|
|
else color_equals(0);
|
|
plot( (di%320)/8,yy);
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
di=di+320; // add di,320
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
di=di+320; // add di,320
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
ax=(framebuffer[di]|(framebuffer[di+1]<<8));
|
|
|
|
/* doing something to shadow here? */
|
|
|
|
di=dot[si].old1; // mov di,ds:[si+6]
|
|
dot[si].old1=ax; // mov ds:[si+6],ax
|
|
|
|
framebuffer[di]=bgpic[di]; // mov ax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],ax
|
|
|
|
bx=pop(); // pop bx
|
|
cx=pop(); // pop cx
|
|
si=si+SKIP; // add si,16
|
|
cx=cx-SKIP; // loop @@1
|
|
if (cx!=0) goto label1;
|
|
goto label0; // jmp @@0
|
|
|
|
label3:
|
|
/* erase old dot */
|
|
di=dot[si].old2; // mov di,ds:[si+8]
|
|
|
|
yy=((di/320)*48)/200;
|
|
if (yy>23) color_equals(5);
|
|
else color_equals(0);
|
|
plot( (di%320)/8,yy);
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
di=di+320; // add di,320
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
di=di+320; // add di,320
|
|
|
|
framebuffer[di]=bgpic[di]; // mov eax,fs:[di]
|
|
framebuffer[di+1]=bgpic[di+1]; // mov es:[di],eax
|
|
framebuffer[di+2]=bgpic[di+2];
|
|
framebuffer[di+3]=bgpic[di+3];
|
|
|
|
bx=pop(); // pop bx
|
|
cx=pop(); // pop cx
|
|
si=si+SKIP; // add si,16
|
|
cx=cx-SKIP; // loop @@1
|
|
if (cx!=0) goto label1;
|
|
goto label0; // jmp @@0
|
|
|
|
}
|
|
|
|
static void setpalette(char *pal) {
|
|
|
|
int c;
|
|
|
|
// push bp
|
|
// mov bp,sp
|
|
// push si
|
|
// push di
|
|
// push ds
|
|
// mov si,[bp+6]
|
|
// mov ds,[bp+8]
|
|
// mov dx,3c8h
|
|
// mov al,0
|
|
outp(0x3c8,0); //out dx,al
|
|
|
|
for(c=0;c<768;c++) outp(0x3c9,pal[c]);
|
|
grsim_update();
|
|
// inc dx
|
|
//mov cx,768
|
|
//rep outsb
|
|
// pop ds
|
|
// pop di
|
|
// pop si
|
|
// pop bp
|
|
// ret
|
|
|
|
}
|
|
|
|
//short face[]={
|
|
// 2248,-2306,0, // from face.inc
|
|
// 30000,30000,30000
|
|
//};
|
|
|
|
/* wait for VGA border start */
|
|
static short dis_waitb(void) {
|
|
|
|
// descr: Waits for border start
|
|
// waitb_1 PROC NEAR
|
|
// call checkkeys
|
|
|
|
// IFDEF INDEMO
|
|
// sti
|
|
// mov ax,cs:copperframecount
|
|
//@@v: cmp cs:copperframecount,ax
|
|
// je @@v
|
|
//@@q: mov ax,cs:copperframecount
|
|
// mov cs:copperframecount,0
|
|
// ELSE
|
|
|
|
// mov dx,3dah
|
|
//@@1: in al,dx
|
|
// test al,8
|
|
// jnz @@1
|
|
//@@2: in al,dx
|
|
// test al,8
|
|
// jz @@2
|
|
|
|
// mov ax,1 ;number of frames taken ;TEMP!
|
|
|
|
// ENDIF
|
|
// ret
|
|
//waitb_1 ENDP
|
|
|
|
|
|
/* approximate by 70Hz sleep */
|
|
usleep(14286);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static short dis_exit(void) {
|
|
return 0;
|
|
}
|
|
|
|
static short dis_indemo(void) {
|
|
return 0;
|
|
}
|
|
|
|
//char far *vram=(char far *)0xa0000000L;
|
|
static unsigned char *vram=framebuffer;
|
|
|
|
static char pal[768];
|
|
static char pal2[768];
|
|
|
|
static short isin(short deg) {
|
|
return(sin1024[deg&1023]);
|
|
}
|
|
|
|
static short icos(short deg) {
|
|
return(sin1024[(deg+256)&1023]);
|
|
}
|
|
|
|
static void setborder(short color) {
|
|
|
|
//printf("Setting border to %d\n",color);
|
|
|
|
// to write attribute register:
|
|
// read/write address to $3c0
|
|
// data written to $3c0, read from $3c1
|
|
// flip flop tracks if it's index/data, you reset that
|
|
// by reading $3da
|
|
|
|
//mov dx,3dah // input status reg #1
|
|
//in al,dx // resets index/addr flip-flop
|
|
|
|
//mov dx,3c0h // attribute access
|
|
//mov al,11h+32 // $11=overscan (border color)
|
|
// 32 is PAS bit
|
|
//out dx,al
|
|
|
|
//mov al,color
|
|
//out dx,al
|
|
}
|
|
|
|
static short cols[]={
|
|
0,0,0,
|
|
4,25,30,
|
|
8,40,45,
|
|
16,55,60};
|
|
|
|
static short dottaul[1024];
|
|
|
|
int main(int argc,char **argv) {
|
|
|
|
// short timer=30000;
|
|
short dropper,repeat;
|
|
short frame=0;
|
|
short rota=-1*64;
|
|
// short fb=0;
|
|
short rot=0,rots=0;
|
|
short a,b,c,d,i,j=0;//,mode;
|
|
short grav,gravd;
|
|
short f=0;
|
|
int ch;
|
|
int xx,yy;
|
|
unsigned char buffer[10];
|
|
|
|
output=fopen("out","w");
|
|
if (output==NULL) {
|
|
fprintf(stderr,"error opening\n");
|
|
exit(1);
|
|
}
|
|
|
|
//dis_partstart();
|
|
|
|
dotnum=512;
|
|
for(a=0;a<dotnum;a++) {
|
|
dottaul[a]=a;
|
|
}
|
|
|
|
for(a=0;a<500;a++) {
|
|
b=rand()%dotnum;
|
|
c=rand()%dotnum;
|
|
d=dottaul[b];
|
|
dottaul[b]=dottaul[c];
|
|
dottaul[c]=d;
|
|
}
|
|
|
|
dropper=22000;
|
|
|
|
for(a=0;a<dotnum;a++) {
|
|
dot[a].x=0;
|
|
dot[a].y=2560-dropper;
|
|
dot[a].z=0;
|
|
dot[a].yadd=0;
|
|
}
|
|
//mode=7;
|
|
grav=3;
|
|
gravd=13;
|
|
gravitybottom=8105;
|
|
i=-1;
|
|
|
|
for(a=0;a<500;a++) { // scramble
|
|
b=rand()%dotnum;
|
|
c=rand()%dotnum;
|
|
d=dot[b].x; dot[b].x=dot[c].x; dot[c].x=d;
|
|
d=dot[b].y; dot[b].y=dot[c].y; dot[c].y=d;
|
|
d=dot[b].z; dot[b].z=dot[c].z; dot[c].z=d;
|
|
}
|
|
|
|
/* setup rows lookup table */
|
|
for(a=0;a<200;a++) {
|
|
rows[a]=a*320;
|
|
}
|
|
|
|
// set_default_pal();
|
|
|
|
// mode13h_graphics_init("dots",2);
|
|
|
|
grsim_init();
|
|
|
|
gr();
|
|
|
|
clear_screens();
|
|
soft_switch(MIXCLR);
|
|
|
|
ram[DRAW_PAGE]=0;
|
|
|
|
color_equals(5);
|
|
for(a=24;a<48;a++) hlin(0,0,40,a);
|
|
|
|
|
|
// set mode 13h
|
|
// _asm mov ax,13h
|
|
// _asm int 10h
|
|
|
|
/* set palette address to 0 */
|
|
outp(0x3c8,0);
|
|
|
|
/* set up colors for first 64 colors */
|
|
for(a=0;a<16;a++) {
|
|
for(b=0;b<4;b++) {
|
|
c=100+a*9;
|
|
outp(0x3c9,cols[b*3+0]);
|
|
outp(0x3c9,cols[b*3+1]*c/256);
|
|
outp(0x3c9,cols[b*3+2]*c/256);
|
|
}
|
|
}
|
|
|
|
/* set palette for color 255 */
|
|
outp(0x3c8,255);
|
|
|
|
/* some sort of purplish color? */
|
|
outp(0x3c9,31);
|
|
outp(0x3c9,0);
|
|
outp(0x3c9,15);
|
|
|
|
|
|
/* set colors starting from 64 ... 164 */
|
|
/* looks like a grey gradient of some sort */
|
|
outp(0x3c8,64);
|
|
|
|
for(a=0;a<100;a++) {
|
|
c=64-256/(a+4);
|
|
c=c*c/64;
|
|
outp(0x3c9,c/4);
|
|
outp(0x3c9,c/4);
|
|
outp(0x3c9,c/4);
|
|
}
|
|
|
|
/* read out the VGA card's idea of palette (?) */
|
|
outp(0x3c7,0);
|
|
for(a=0;a<768;a++) pal[a]=inp(0x3c9);
|
|
|
|
/* clear palette to all 0 */
|
|
/* this lets up setup background while not visible */
|
|
outp(0x3c8,0);
|
|
for(a=0;a<768;a++) outp(0x3c9,0);
|
|
|
|
/* put grey gradient on bottom half of screen? */
|
|
for(a=0;a<100;a++) {
|
|
memset(vram+(100+a)*320,a+64,320);
|
|
}
|
|
|
|
/* set up depth table? */
|
|
/* this has further away balls a darker color */
|
|
for(a=0;a<128;a++) {
|
|
c=a-(43+20)/2;
|
|
c=c*3/4;
|
|
c+=8;
|
|
if(c<0) c=0; else if(c>15) c=15;
|
|
c=15-c;
|
|
depthtable1[a]=0x202+0x04040404*c;
|
|
depthtable2[a]=0x02030302+0x04040404*c;
|
|
depthtable3[a]=0x202+0x04040404*c;
|
|
//depthtable4[a]=0x02020302+0x04040404*c;
|
|
}
|
|
|
|
/* make a byte-wise copy of this */
|
|
/* the original code just indexes byte-wise into integer data */
|
|
/* which is a pain */
|
|
for(a=0;a<128;a++) {
|
|
depthtable1_bytes[(a*4)+0]=(depthtable1[a]>>0)&0xff;
|
|
depthtable1_bytes[(a*4)+1]=(depthtable1[a]>>8)&0xff;
|
|
depthtable1_bytes[(a*4)+2]=(depthtable1[a]>>16)&0xff;
|
|
depthtable1_bytes[(a*4)+3]=(depthtable1[a]>>24)&0xff;
|
|
|
|
depthtable2_bytes[(a*4)+0]=(depthtable2[a]>>0)&0xff;
|
|
depthtable2_bytes[(a*4)+1]=(depthtable2[a]>>8)&0xff;
|
|
depthtable2_bytes[(a*4)+2]=(depthtable2[a]>>16)&0xff;
|
|
depthtable2_bytes[(a*4)+3]=(depthtable2[a]>>24)&0xff;
|
|
|
|
depthtable3_bytes[(a*4)+0]=(depthtable3[a]>>0)&0xff;
|
|
depthtable3_bytes[(a*4)+1]=(depthtable3[a]>>8)&0xff;
|
|
depthtable3_bytes[(a*4)+2]=(depthtable3[a]>>16)&0xff;
|
|
depthtable3_bytes[(a*4)+3]=(depthtable3[a]>>24)&0xff;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
/* allocate space for background */
|
|
//bgpic=halloc(64000L,1L);
|
|
bgpic=calloc(65536L,1L);
|
|
|
|
/* backup background */
|
|
memcpy(bgpic,vram,64000);
|
|
|
|
grsim_update();
|
|
|
|
/* Fade back in from black to palette */
|
|
a=0;
|
|
for(b=64;b>=0;b--) {
|
|
for(c=0;c<768;c++) {
|
|
a=pal[c]-b;
|
|
if(a<0) a=0;
|
|
pal2[c]=a;
|
|
}
|
|
/* wait for retrace (delay) */
|
|
dis_waitb();
|
|
dis_waitb();
|
|
outp(0x3c8,0);
|
|
for(c=0;c<768;c++) outp(0x3c9,pal2[c]);
|
|
grsim_update();
|
|
}
|
|
|
|
while(!dis_exit() && frame<2450) {
|
|
|
|
for(xx=0;xx<40;xx++) {
|
|
for(yy=0;yy<48;yy++) {
|
|
shadow[xx][yy]=0;
|
|
ball[xx][yy]=0;
|
|
}
|
|
}
|
|
|
|
/* code sets border color */
|
|
/* then waits for it to end, as a timing thing? */
|
|
setborder(0);
|
|
|
|
/* when not in demo this defaults to 1? */
|
|
repeat=dis_waitb();
|
|
|
|
if(frame>2300) setpalette(pal2);
|
|
|
|
setborder(1);
|
|
|
|
if(dis_indemo()) {
|
|
/* ?? music synchronization? */
|
|
// a=dis_musplus();
|
|
// if(a>-4 && a<0) break;
|
|
}
|
|
|
|
repeat=1;
|
|
|
|
while(repeat--) {
|
|
|
|
frame++;
|
|
if(frame==500) f=0;
|
|
i=dottaul[j];
|
|
j++; j%=dotnum;
|
|
|
|
/* initial spin */
|
|
if(frame<500) {
|
|
dot[i].x=isin(f*11)*40;
|
|
dot[i].y=icos(f*13)*10-dropper;
|
|
dot[i].z=isin(f*17)*40;
|
|
dot[i].yadd=0;
|
|
// printf("%d: %d,%d,%d,%d\n",i,
|
|
// dot[i].x,dot[i].y,dot[i].z,dot[i].yadd);
|
|
}
|
|
/* bouncing ring */
|
|
else if(frame<900) {
|
|
dot[i].x=icos(f*15)*55;
|
|
dot[i].y=dropper;
|
|
dot[i].z=isin(f*15)*55;
|
|
dot[i].yadd=-260;
|
|
}
|
|
/* fountain */
|
|
else if(frame<1700) {
|
|
a=sin1024[frame&1023]/8;
|
|
dot[i].x=icos(f*66)*a;
|
|
dot[i].y=8000;
|
|
dot[i].z=isin(f*66)*a;
|
|
dot[i].yadd=-300;
|
|
}
|
|
/* swirling */
|
|
else if(frame<2360) {
|
|
/*
|
|
a=rand()/128+32;
|
|
dot[i].y=8000-a*80;
|
|
b=rand()&1023;
|
|
a+=rand()&31;
|
|
dot[i].x=sin1024[b]*a/3+(a-50)*7;
|
|
dot[i].z=sin1024[(b+256)&1023]*a/3+(a-40)*7;
|
|
dot[i].yadd=300;
|
|
if(frame>1640 && !(frame&31) && grav>-2) grav--;
|
|
*/
|
|
dot[i].x=rand()-16384;
|
|
dot[i].y=8000-rand()/2;
|
|
dot[i].z=rand()-16384;
|
|
dot[i].yadd=0;
|
|
if(frame>1900 && !(frame&31) && grav>0) grav--;
|
|
}
|
|
/* palette to white */
|
|
else if(frame<2400) {
|
|
a=frame-2360;
|
|
for(b=0;b<768;b+=3) {
|
|
c=pal[b+0]+a*3;
|
|
if(c>63) c=63;
|
|
pal2[b+0]=c;
|
|
c=pal[b+1]+a*3;
|
|
if(c>63) c=63;
|
|
pal2[b+1]=c;
|
|
c=pal[b+2]+a*4;
|
|
if(c>63) c=63;
|
|
pal2[b+2]=c;
|
|
}
|
|
}
|
|
/* palette to black */
|
|
else if(frame<2440) {
|
|
a=frame-2400;
|
|
for(b=0;b<768;b+=3) {
|
|
c=63-a*2;
|
|
if(c<0) c=0;
|
|
pal2[b+0]=c;
|
|
pal2[b+1]=c;
|
|
pal2[b+2]=c;
|
|
}
|
|
}
|
|
if(dropper>4000) dropper-=100;
|
|
|
|
rotcos=icos(rot)*64; rotsin=isin(rot)*64;
|
|
rots+=2;
|
|
|
|
if(frame>1900) {
|
|
rot+=rota/64;
|
|
rota--;
|
|
}
|
|
else rot=isin(rots);
|
|
|
|
f++;
|
|
gravity=grav;
|
|
gravityd=gravd;
|
|
|
|
}
|
|
|
|
|
|
drawdots();
|
|
|
|
grsim_update();
|
|
|
|
|
|
// fprintf(output,"Frame %d\n",frame);
|
|
// fprintf(output,"\tShadow\n");
|
|
|
|
write_frame++;
|
|
if (write_frame==FRAME_SKIP ) {
|
|
write_frame=0;
|
|
}
|
|
|
|
if (write_frame==0) {
|
|
|
|
#if 0
|
|
int new_row=1;
|
|
|
|
/* Shadow */
|
|
buffer[0]=0xfe;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
for(yy=0;yy<48;yy++) {
|
|
new_row=1;
|
|
for(xx=0;xx<40;xx++) {
|
|
if ((!ball[xx][yy]) && (shadow[xx][yy])) {
|
|
if (new_row) {
|
|
buffer[0]=(yy|0x40);
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
new_row=0;
|
|
}
|
|
buffer[0]=(xx);
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
}
|
|
}
|
|
}
|
|
/* Balls */
|
|
buffer[0]=0xfd;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
for(yy=0;yy<48;yy++) {
|
|
new_row=1;
|
|
for(xx=0;xx<40;xx++) {
|
|
if (ball[xx][yy]) {
|
|
if (new_row) {
|
|
buffer[0]=(yy|0x40);
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
new_row=0;
|
|
}
|
|
buffer[0]=xx;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
int new_row=1;
|
|
|
|
/* Shadow */
|
|
buffer[0]=0xfe;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
for(yy=0;yy<24;yy++) {
|
|
new_row=1;
|
|
for(xx=0;xx<40;xx++) {
|
|
/* cases: */
|
|
/* shadow ball action */
|
|
/* top bottom top bottom */
|
|
/* 0 0 0 0 none */
|
|
/* 0 0 0 1 none */
|
|
/* 0 0 1 0 none */
|
|
/* 0 0 1 1 none */
|
|
/* 0 1 0 0 bot 1 */
|
|
/* 0 1 0 1 none */
|
|
/* 0 1 1 0 both 4 */
|
|
/* 0 1 1 1 none */
|
|
/* 1 0 0 0 top 2 */
|
|
/* 1 0 0 1 both 5 */
|
|
/* 1 0 1 0 none */
|
|
/* 1 0 1 1 none */
|
|
/* 1 1 0 0 both 3 */
|
|
/* 1 1 0 1 both 3 */
|
|
/* 1 1 1 0 both 3 */
|
|
/* 1 1 1 1 none */
|
|
|
|
/* case 1/4 */
|
|
if ( (shadow[xx][yy*2]==0) &&
|
|
(shadow[xx][(yy*2)+1]==1) ) {
|
|
|
|
/* case 1 -- bottom */
|
|
if ( (ball[xx][(yy*2)]==0) &&
|
|
(ball[xx][(yy*2)+1]==0)) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,
|
|
sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0x40);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
/* case 4 -- both */
|
|
if ( (ball[xx][(yy*2)]==1) &&
|
|
(ball[xx][(yy*2)+1]==0) ) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,
|
|
sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0xC0);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
}
|
|
/* case 2/5 */
|
|
else if ( (shadow[xx][yy*2]==1) &&
|
|
(shadow[xx][(yy*2)+1]==0) ) {
|
|
|
|
/* case 2 -- top */
|
|
if ( (ball[xx][(yy*2)]==0) &&
|
|
(ball[xx][(yy*2)+1]==0) ) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,
|
|
sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0x80);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
/* case 5 -- both */
|
|
if ( (ball[xx][(yy*2)]==0) &&
|
|
(ball[xx][(yy*2)+1]==1) ) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,
|
|
sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0xC0);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
}
|
|
/* case 3 */
|
|
else if ( (shadow[xx][yy*2]==1) &&
|
|
(shadow[xx][(yy*2)+1]==1) ) {
|
|
|
|
/* case 2 -- top */
|
|
if ( (ball[xx][(yy*2)]==1) &&
|
|
(ball[xx][(yy*2)+1]==1) ) {
|
|
}
|
|
else {
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,
|
|
sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0xc0);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
/* Balls */
|
|
buffer[0]=0xfd;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
for(yy=0;yy<24;yy++) {
|
|
new_row=1;
|
|
for(xx=0;xx<40;xx++) {
|
|
/* cases: */
|
|
/* shadow ball action */
|
|
/* top bottom top bottom */
|
|
/* X X 0 0 none */
|
|
/* X X 0 1 bot 1 */
|
|
/* X X 1 0 top 2 */
|
|
/* X X 1 1 both 3 */
|
|
|
|
/* case 1 -- bottom */
|
|
if ( (ball[xx][(yy*2)]==0) &&
|
|
(ball[xx][(yy*2)+1]==1)) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0x40);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
/* case 2 -- top */
|
|
else if ( (ball[xx][(yy*2)]==1) &&
|
|
(ball[xx][(yy*2)+1]==0) ) {
|
|
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0x80);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
/* case 3 */
|
|
else if ( (ball[xx][(yy*2)]==1) &&
|
|
(ball[xx][(yy*2)+1]==1) ) {
|
|
if (new_row) {
|
|
buffer[0]=yy;
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
new_row=0;
|
|
}
|
|
|
|
buffer[0]=(xx|0xc0);
|
|
fwrite(buffer,1,sizeof(char),
|
|
output);
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//again:
|
|
ch=grsim_input();
|
|
if (ch==27) {
|
|
return 0;
|
|
}
|
|
// else if (ch==0) goto again;
|
|
|
|
}
|
|
|
|
buffer[0]=0xff;
|
|
fwrite(buffer,1,sizeof(char),output);
|
|
|
|
fclose(output);
|
|
|
|
return 0;
|
|
}
|