shithub: riscv

ref: 556618eb07d1ac6e2c629a60acd53c45d53261be
dir: /sys/src/games/swar/swar.c/

/*
 * swar -- jerq space war
 * td&rob 84.01.01
 *
 * ported to 9front on 31jul2021
 */
#include <u.h>
#include <libc.h>
#include <draw.h>
#include <event.h>
int xc, yc;
#define	NOBJ	(1+2+6*2)
#define	MSPEED	(V/32)				/* speed of missile relative to ship */
#define	SZ	512				/* maximum scaled coordinate */
#define	V	256				/* velocity scale factor */
#define	G	(V*11585)			/* 11585 is SZ**(3./2.) */
#define	ALIVE	1
#define	DEAD	2
#define	SUN	3
#define	BOOM	4
#define	HYPER	5
#define	SLEEP	40				/* ms per iteration */
#define	TUBA	(2000/SLEEP)			/* iterations until born again */
#define	HYTIME	((600+rand()%600)/SLEEP)	/* iterations in hyperspace */
char *starbits[]={
#include "deathstar.icon"
};
Image *stardwg;
Rectangle starrect={0, 0, 16, 16};
char *p0bits[]={
#include "player0.icon"
};
Image *p0dwg;
Rectangle p0rect={0, 0, 44, 44};
char *p1bits[]={
#include "player1.icon"
};
Image *p1dwg;
Rectangle p1rect={0, 0, 44, 44};
char *misbits[]={
#include "missile.icon"
};
Image *misdwg;
Rectangle misrect={0, 0, 32, 32};
char *boombits[]={
#include "boom.icon"
};
Image *boomdwg;
Rectangle boomrect={0, 0, 64, 64};
struct obj{
	int x, y;
	int vx, vy;		/* scaled by V */
	int orientation;
	int state;
	int diameter;
	Image *bp;
	int curdwg;
#define	wrapped	timer
	int timer;
}obj[NOBJ], iobj[]={
	{0, 0, 0, 0, 0, SUN, 16},
	{ 300, 0, 0,  5*V, 8, ALIVE, 11, 0, 0, TUBA},
	{-300, 0, 0, -5*V, 0, ALIVE, 11, 0, 0, TUBA},
	{0, 0, 0, 0, 0, ALIVE, 8},
};
#define	ATT	(&obj[0])
#define	P0	(&obj[1])
#define	P1	(&obj[2])
int score[3];
#define	NORIENTATION	16
struct dv{
	int x, y;
}dv[NORIENTATION]={
#include "accel.h"
};

int xc, yc, size;
void kbdplayer(int c);
void hyper(struct obj *o);
void right(struct obj *o);
void left(struct obj *o);
void jerk(struct obj *o);
int isqrt(int x);
void fire(struct obj *o);
void initobj(struct obj *o);
void deathto(struct obj *o, int doboom);
void boom(struct obj *o);
void shards(struct obj *o);
void move(struct obj *o);
void blot(struct obj *o, int dwg);
void collide(struct obj *o, struct obj *p);
void newscore(struct obj *o, struct obj *p);
void drawscore(char *str, int sc, int where);
void doscore(void);
Image *initbitmap(char *bits[], Rectangle r);

#define	sq(x)	((x)*(x))
#define	muldiv(a, b, c)	((a)*(b)/(c))

int
min(int a, int b)
{
	return a<b? a: b;
}

int
abs(int a)
{
	return a<0? -a: a;
}

void
redraw(void)
{
	draw(screen, screen->r, display->black, nil, ZP);
	blot(ATT, ATT->orientation);
	doscore();
}

void
eresized(int)
{
	if(getwindow(display, Refnone) < 0)
		sysfatal("resized");
	xc=(screen->r.min.x+screen->r.max.x)/2;
	yc=(screen->r.min.y+screen->r.max.y)/2;
	size=min(screen->r.max.x-screen->r.min.x,
		screen->r.max.y-screen->r.min.y)/2;
	redraw();
}

void
main(void)
{
	struct obj *o, *p;

	initdraw(nil,nil,nil);
	einit(Ekeyboard|Emouse);

	iobj[0].bp = stardwg = initbitmap(starbits, starrect);
	iobj[1].bp = p0dwg = initbitmap(p0bits, p0rect);
	iobj[2].bp = p1dwg = initbitmap(p1bits, p1rect);
	iobj[3].bp = misdwg = initbitmap(misbits, misrect);
	boomdwg = initbitmap(boombits, boomrect);

	xc=(screen->r.min.x+screen->r.max.x)/2;
	yc=(screen->r.min.y+screen->r.max.y)/2;
	size=min(screen->r.max.x-screen->r.min.x,
		screen->r.max.y-screen->r.min.y)/2;

	for(o=obj;o<=P1;o++)
		initobj(o);

	for(;o!=&obj[NOBJ];o++)
		o->state=DEAD;

	for(;;){
		redraw();
		for(o=obj;o!=&obj[NOBJ];o++){
			switch(o->state){
			case ALIVE:
			case SUN:
				for(p=o+1;p!=&obj[NOBJ];p++)
					if(p->state!=DEAD)
						collide(o, p);
				if(o>P1)
					left(o);
				move(o);
				break;
			case HYPER:
				if(--o->timer==0){
					blot(o, o->curdwg);
					o->state=ALIVE;
					if(rand()%4==0){
						deathto(o, 1);
						newscore(ATT, o);
					}
				}else
					move(o);
				break;
			case DEAD:
				if((o==P0 || o==P1) && --o->timer==0)
					initobj(o);
				break;
			case BOOM:
				shards(o);
				move(o);
				break;
			}
		}
		flushimage(display, 1);
		while(ecanmouse()) emouse();
		if(ecankbd()) kbdplayer(ekbd());
		sleep(SLEEP);
	}
}
void kbdplayer(int c){
	switch(c){
	case 'k': left(P0);	break;
	case 'o': jerk(P0);	break;
	case ';': right(P0);	break;
	case 'l': fire(P0);	break;
	case '.':
	case ',': hyper(P0);	break;
	case 'a': left(P1);	break;
	case 'w': jerk(P1);	break;
	case 'd': right(P1);	break;
	case 's': fire(P1);	break;
	case 'z':
	case 'x': hyper(P1);	break;
	case 'Q': exits("");	break;
	}
}
void hyper(struct obj *o){
	if(o->state!=ALIVE)
		return;
	o->state=HYPER;
	o->timer=HYTIME;
	blot(o, o->curdwg);
}
void right(struct obj *o){
	if(++o->orientation==NORIENTATION)
		o->orientation=0;
}
void left(struct obj *o){
	if(--o->orientation<0)
		o->orientation=NORIENTATION-1;
}
void jerk(struct obj *o){
	o->vx+=dv[o->orientation].x/2;
	o->vy+=dv[o->orientation].y/2;
}
int isqrt(int x){
	int s, u;
	if(x<=0)
		return(0);
	if(x>=32768L*(32768L/4))
		return(2*isqrt(x/4));	/* avoid overflow */
	for(s=2, u=4;u<x;s+=s, u*=4);
	while((u=((x+s*s)/s)>>1)<s)
		s=u;
	return(s);
}
void fire(struct obj *o){
	struct obj *m;
	int vx, vy, vl;
	if(o->state!=ALIVE)
		return;
	for(m=o+2;m<&obj[NOBJ];m+=2)
		if(m->state==DEAD){
			initobj(m);
			m->state=ALIVE;
			vl=isqrt(sq(o->vx)+sq(o->vy));
			if(vl==0)
				vl=V;
			vx=muldiv(vl, dv[o->orientation].x, V);
			vy=muldiv(vl, dv[o->orientation].y, V);
			m->x=o->x+muldiv(vx, (o->diameter+m->diameter), vl);
			m->y=o->y+muldiv(vy, (o->diameter+m->diameter), vl);
			m->vx=o->vx+MSPEED*dv[o->orientation].x;
			m->vy=o->vy+MSPEED*dv[o->orientation].y;
			blot(m, m->orientation);
			return;
		}
}
void initobj(struct obj *o){
	*o=(o>P1)?iobj[P1-obj+1]:iobj[o-obj];
	if(o<=P1)
		blot(o, o->orientation);
}
void deathto(struct obj *o, int doboom){
	o->state=DEAD;
	blot(o, o->curdwg);
	if(doboom)
		boom(o);
}
void boom(struct obj *o){
	o->state=BOOM;
	o->bp=boomdwg;
	o->diameter=boomdwg->r.max.x/4;
	blot(o, o->orientation=0);
}
void shards(struct obj *o){
	if(++o->orientation==16){
		blot(o, o->curdwg);
		o->state=DEAD;
		o->timer=TUBA;
	}
}
void move(struct obj *o){
	int r32;
	int x, y;
	if(o->state==DEAD || o->state==SUN)
		return;
	r32=o->x*o->x+o->y*o->y;
	if(r32!=0){
		r32*=isqrt(r32);	/* pow(r, 3./2.) */
		if(r32!=0){
			o->vx-=G*o->x/r32;
			o->vy-=G*o->y/r32;
		}
	}
	x=o->x+o->vx/V;
	y=o->y+o->vy/V;
	if(x<-SZ || SZ<x){
		if(o>P1 && o->wrapped){
    Death:
			deathto(o, 0);
			return;
		}
		if(x<-SZ) x+=2*SZ; else x-=2*SZ;
		o->wrapped++;
	}
	if(y<-SZ || SZ<y){
		if(o>P1 && o->wrapped)
			goto Death;
		if(y<-SZ) y+=2*SZ; else y-=2*SZ;
		o->wrapped++;
	}
	if(o->state!=HYPER)
		blot(o, o->curdwg);
	o->x=x, o->y=y;
	if(o->state!=HYPER)
		blot(o, o->orientation);
}

#define	BLOTSIZE	5
#define	rescale(x)	muldiv(x, size, SZ)

void
blot(struct obj *o, int dwg)
{
	Point p;
	int dx = dwg % 4*o->diameter, dy = dwg / 4*o->diameter;

	p = Pt(rescale(o->x)+xc-o->diameter/2, rescale(o->y)+yc-o->diameter/2);

	draw(screen, rectaddpt(Rect(dx,dy,dx+o->diameter,dy+o->diameter),p), o->bp, nil, Pt(dx, dy));
	o->curdwg = dwg;
}

void
collide(struct obj *o, struct obj *p)
{
	int doneboom;
	/* o<p always */
	if(o->state!=HYPER && p->state!=HYPER
	&& sq(rescale(o->x-p->x))+sq(rescale(o->y-p->y))<
		sq(o->diameter+p->diameter)/4){
		newscore(o, p);
		if(doneboom=o->state==ALIVE)
			deathto(o, 1);
		if(p->state==ALIVE)
			deathto(p, !doneboom || (o==P0 && p==P1));
	}
}

void
newscore(struct obj *o, struct obj *p)
{
	doscore();
	/* o<p always */
	score[2]++;
	if(o==P0 || p==P0)
		score[1]++;
	if(o==P1 || p==P1)
		score[0]++;
	doscore();
}

void
drawscore(char *str, int sc, int where)
{
	static char buf[16];
	char *p = buf+6;
	int s;

	while(*p++=*str++)
		;

	p = buf+6;
	s = abs(sc);
	do{
		*--p = s%10 + '0';
		s /= 10;
	}while(s);

	if(sc < 0)
		*--p = '-';

	if(where == 2)
		s = screen->r.min.x + 20;
	else if(where == 1)
		s = (screen->r.min.x + screen->r.max.x - stringwidth(font, p))/2;
	else
		s = screen->r.max.x - stringwidth(font, p) - 20;

	draw(screen, Rpt(Pt(s, screen->r.min.y+5),Pt(s+stringwidth(font, p), screen->r.min.y+5+font->height)), display->black, nil, ZP);
	string(screen, Pt(s, screen->r.min.y+5), display->white, ZP, font, p);
}

void
doscore(void)
{
	drawscore(" MCI", score[0], 0);
	drawscore(" AT&T", score[2], 1);
	drawscore(" SPRINT", score[1], 2);
}

Image *
initbitmap(char *bits[], Rectangle r)
{
	Point p;
	char *bit;
	Image *b=allocimage(display, r, screen->chan, 0, DTransparent);

	if(b==0)
		sysfatal("allocimage: %r");

	for(p.y = r.min.y; p.y != r.max.y; p.y++){
		bit = bits[p.y-r.min.y];
		for(p.x = r.min.x; p.x != r.max.x; p.x++){
			while(*bit==' ')
				bit++;
			if(*bit++=='x')
				draw(b, Rpt(p,addpt(p,Pt(1,1))), display->white, nil, ZP);
		}
	}
	return b;
}