#include <vectrex.h>
//#include <stdio.h>
//#include <stdlib.h>
#define extern
typedef int bit8;
typedef long bit16;
typedef long long bit32;
typedef struct {
bit32 pos[3];
bit16 expos[3];
bit16 view[9];
bit16 r;
bit16 d;
bit16 speed;
bit16 *shape;
} bodytype;
typedef struct x {
bit16 pos[3];
struct x *next;
} startype;
typedef struct {
bit16 pos[3];
bit16 r;
bit16 d;
bit16 colour;
bit16 type;
} planettype;
typedef struct {
char type;
bit16 x1,y1,x2,y2;
} atomtype;
#define mul16(x,y) ((bit16)((bit32)(x) * (bit32)(y)))
#define div14(x) (bit16)((bit32)(x) / 16384LL)
#define abs(x) (((x) < 0) ? -(x) : (x))
#define SCRX 320
#define SCRY 256
#define VPX1 64
#define VPY1 88
#define VPX2 256
#define VPY2 216
#define MAX_BODY 8
#define TOP 1
#define BOTTOM 2
#define LEFT 4
#define RIGHT 8
bit16 clipxl = VPX1;
bit16 clipxr = VPX2;
bit16 clipyt = VPY2;
bit16 clipyb = VPY1;
void code(bit16 x, bit16 y, bit16 *c)
{
*c = 0;
if(x < clipxl) {
*c = LEFT;
} else {
if(x > clipxr) {
*c = RIGHT;
}
}
if(y < clipyb) {
*c += BOTTOM;
} else {
if(y > clipyt) {
*c += TOP;
}
}
}
/* Cohen-Sutherland clipping algorithm */
bit16 clip(bit16 x1, bit16 y1, bit16 x2, bit16 y2, atomtype *ip)
{
bit16 c,c1,c2,x,y;
code(x1,y1,&c1);
code(x2,y2,&c2);
while(c1 | c2) {
if((c1 & c2) != 0) return 0;
c = (c1 == 0) ? c2 : c1;
if(LEFT & c) { /* crosses left edge */
y = mul16(y2-y1,clipxl-x1) / (x2 - x1) + y1;
x = clipxl;
} else {
if(RIGHT & c) { /* crosses right edge */
y = mul16(y2-y1,clipxr-x1) / (x2 - x1) + y1;
x = clipxr;
} else {
if(BOTTOM & c) { /* crosses bottom edge */
x = mul16(x2-x1,clipyb-y1) / (y2 - y1) + x1;
y = clipyb;
} else {
if(TOP & c) { /* crosses top edge */
x = mul16(x2-x1,clipyt-y1) / (y2 - y1) + x1;
y = clipyt;
}
}
}
}
if(c == c1) {
x1 = x;
y1 = y;
code(x,y,&c1);
} else {
x2 = x;
y2 = y;
code(x,y,&c2);
}
}
/* here if line is visible */
ip->type = 'v';
ip->x1 = x1;
ip->y1 = y1;
ip->x2 = x2;
ip->y2 = y2;
return 1;
}
extern void vector(bit16 x1, bit16 y1, bit16 x2, bit16 y2, char mode, bit16 col);
extern void plot(bit16 x, bit16 y);
extern void draw_object(bodytype *body);
extern void shit(void);
extern bodytype bodies[];
#ifdef NEVER
extern atomtype imbuf[256];
extern atomtype *ibase1,*ibase2;
extern atomtype *iptr1,*iptr2;
extern atomtype *imax1,*imax2;
void init_atoms(void)
{
iptr1 = ibase1;
}
void plot_atoms(void)
{
char flag;
imax1 = iptr1;
iptr1 = ibase1;
iptr2 = ibase2;
do {
flag = 0;
if(iptr1 != imax1) {
switch(iptr1->type) {
case 'v':
vector(iptr1->x1,iptr1->y1,iptr1->x2,iptr1->y2,'^',5);
break;
case 'p':
plot(iptr1->x1,iptr1->y1);
break;
}
iptr1++;
flag = 1;
}
if(iptr2 != imax2) {
switch(iptr2->type) {
case 'v':
vector(iptr2->x1,iptr2->y1,iptr2->x2,iptr2->y2,'^',5);
break;
case 'p':
plot(iptr2->x1,iptr2->y1);
break;
}
iptr2++;
flag = 1;
}
} while(flag);
iptr1 = ibase1;
ibase1 = ibase2;
ibase2 = iptr1;
imax2 = imax1;
}
#endif
void display(void/*bit16 dmode*/)
{
int i;
register bodytype *p;
//init_atoms();
for(i=0; i<MAX_BODY; i++) {
p = &bodies[i];
if(p->r != 0) {
draw_object(p);
}
}
shit();
// plot_atoms();
}
bit16 clip(bit16 x1, bit16 y1, bit16 x2, bit16 y2, atomtype *ip);
bit32 divx(bit32 x);
//atomtype imbuf[256];
//atomtype *ibase1,*ibase2;
//atomtype *iptr1,*iptr2;
//atomtype *imax1,*imax2;
bit16 *pbase;
struct ptype {
char state;
bit16 trans[3];
bit16 px,py;
} points[20];
extern bit16 view_pos[3];
extern bit16 view_vec[9];
void clear_image(void)
{
// ibase1 = imbuf;
// ibase2 = imbuf + 128;
// imax2 = ibase2;
}
void genxyz(bit16 p, bit16 *v, bit16 *r, bit16 *o)
{
register struct ptype *pp = &points[p];
if(pp->state == '0') {
bit16 *qq;
pp->state = '1';
qq = &pbase[p * 3];
pp->trans[0]=div14(mul16(v[0],qq[0])+mul16(v[3],qq[1])+mul16(v[6],qq[2]))
-view_pos[0]+o[0];
pp->trans[1]=div14(mul16(v[1],qq[0])+mul16(v[4],qq[1])+mul16(v[7],qq[2]))
-view_pos[1]+o[1];
pp->trans[2]=div14(mul16(v[2],qq[0])+mul16(v[5],qq[1])+mul16(v[8],qq[2]))
-view_pos[2]+o[2];
/* printf("qq %d,%d,%d\n",qq[0],qq[1],qq[2]);
printf("ppt %d,%d,%d\n",pp->trans[0],pp->trans[1],pp->trans[2]); */
}
r[0] = pp->trans[0];
r[1] = pp->trans[1];
r[2] = pp->trans[2];
}
void gennorm(bit16 p, bit16 *v, bit16 *r)
{
bit16 *qq = &pbase[p * 3];
r[0]=div14(mul16(v[0],qq[0])+mul16(v[3],qq[1])+mul16(v[6],qq[2]));
r[1]=div14(mul16(v[1],qq[0])+mul16(v[4],qq[1])+mul16(v[7],qq[2]));
r[2]=div14(mul16(v[2],qq[0])+mul16(v[5],qq[1])+mul16(v[8],qq[2]));
}
bit32 scprod(bit16 *v1, bit16 *v2)
{
return mul16(v1[0],v2[0]) + mul16(v1[1],v2[1]) + mul16(v1[2],v2[2]);
}
void genxy(bit16 *v3, bit16 *v2)
{
bit16 d = div14(scprod(v3,view_vec+3));
v2[0] = (bit16)(divx(scprod(v3,view_vec)) / d) + (VPX1+VPX2)/2;
v2[1] = (bit16)(divx(scprod(v3,view_vec+6)) / d) + (VPY1+VPY2)/2;
}
bit32 divx(bit32 x)
{
return (x >> 6);
}
void draw_body(bodytype *body)
{
bit16 *b_data = body->shape;
bit16 *fbase = b_data + 1;
bit16 nface = fbase[0];
bit16 *fptr = fbase + 1;
bit16 *vbase = b_data + 1 + b_data[0];
bit16 maxvec = vbase[-1];
bit16 npoint;
// bit16 flag;
bit16 end_1[3],end_2[3];
bit16 p[2],q[2];
bit16 nvec,i,j;
bit16 n_pos[3],n_vec[3];
// bit16 *fptr2;
char vec_done[20];
pbase = vbase + vbase[-1]*2 + 1;
npoint = pbase[-1];
for(i=0; i<maxvec; i++) vec_done[i] = 0;
for(i=0; i<npoint; i++) points[i].state = '0';
for(i=nface; i != 0; i--) {
nvec = *fptr++;
gennorm(fptr[0],body->view,n_vec);
genxyz(vbase[fptr[1]*2],body->view,n_pos,body->expos);
if(scprod(n_pos,n_vec) < 0) {
fptr++;
for(j=0; j<nvec; j++) {
if(!vec_done[fptr[0]]) {
vec_done[fptr[0]] = 1;
genxyz(vbase[fptr[0]*2],body->view,end_1,body->expos);
genxyz(vbase[fptr[0]*2+1],body->view,end_2,body->expos);
genxy(end_1,p);
genxy(end_2,q);
// if(clip(p[0],p[1],q[0],q[1],iptr1)) iptr1++;
}
fptr++;
} /* for j */
} else {
fptr += nvec + 1;
} /* if(scprod..) */
} /* for i */
}
void draw_object(bodytype *body)
{
bit16 d,x,y,pr;
bit16 delta[3];
delta[0] = body->expos[0] - view_pos[0];
delta[1] = body->expos[1] - view_pos[1];
delta[2] = body->expos[2] - view_pos[2];
d = div14(scprod(&view_vec[3],delta));
if(d > body->r + 10) {
x = (bit16)divx((bit32)scprod(&view_vec[0],delta) / (bit32)d);
y = (bit16)divx((bit32)scprod(&view_vec[6],delta) / (bit32)d);
pr = (bit16)divx(mul16(body->r,16384) / d);
if((abs(x) < (VPX2-VPX1)/2 + pr) && (abs(y) < (VPY2-VPY1)/2 + pr)) {
draw_body(body);
}
}
}
#define umod(x,y) ((unsigned)(x) % (unsigned)(y))
bit16 rnd();
//FILE *fpi;
#define MAX_STARS 4
startype stars[MAX_STARS],*star_ptr;
#define MAX_PLANETS 3
planettype planets[MAX_PLANETS],*planet_ptr;
#define MAX_MOONS 2
planettype moons[MAX_MOONS],*moon_ptr;
bit16 n_stars;
bit16 n_suns;
bit16 n_planets;
bit16 n_moons;
bit16 randseed;
bit16 n_near,n_far;
startype *far_root,*near_root;
const bit16 cube[] = {
38,6,
4,8,0,9,4,8, 4,9,1,9,5,10, 4,10,2,10,6,11,
4,11,3,8,7,11, 4,12,0,1,2,3, 4,13,4,5,6,7,
12, 0,1, 1,2, 2,3, 3,0, 4,5, 5,6, 6,7, 7,4, 0,4, 1,5, 2,6, 3,7,
14,
20,-20,-20, 20,20,-20, -20,20,-20, -20,-20,-20,
20,-20,20, 20,20,20, -20,20,20, -20,-20,20,
1000,0,0, 0,1000,0, -1000,0,0, 0,-1000,0, 0,0,-1000, 0,0,1000
};
const bit16 kcf[] = {
46,8,
3,8,0,7,8, 3,9,1,8,9, 3,10,2,9,10, 3,11,3,10,11,
3,12,4,11,12, 3,13,5,12,13, 3,14,6,13,7, 7,15,0,1,2,3,4,5,6,
14, 1,2, 2,3, 3,4, 4,5, 5,6, 6,7, 7,1,
1,0, 2,0, 3,0, 4,0, 5,0, 6,0, 7,0,
16,
0,35,0, -20,-15,0, -10,-15,-5, 10,-15,-5, 20,-15,0,
10,-15,5, 0,-15,8, -10,-15,5,
-440,176,-880, 0,100,-995, 440,176,-880,
440,176,880, 284,151,947, -284,151,947, -440,176,880,
0,-1000,0
};
const bit16 icos[] = {
16384,16069,15137,13623,11585,9102,6270,3196,
0,-3196,-6270,-9102,-11585,-13623,-15137,-16069,
-16384,-16069,-15137,-13623,-11585,-9102,-6270,-3196,
0,3196,6270,9102,11585,13623,15137,16069
};
const bit16 shit_data[] = {
32,
-96,39,95,59,77,-108,-2,-11,-100,115,52,9,121,-45,117,111,
9,17,44,52,62,43,-11,-42,-87,61,11,-18,-113,69,4,17,
62,42,-68,-9,-94,-3,-113,-34,19,125,-53,41,112,-30,100,76,
114,-45,-22,-19,60,-71,-71,68,47,56,111,-60,5,-7,-92,-4,
28,-82,-43,-65,18,80,-95,-125,-108,-84,55,7,111,29,15,56,
-16,-101,-40,86,106,-12,-78,82,19,90,-98,123,21,30,50,90
};
void make_planet(bit16 x, bit16 y, bit16 z, bit16 r, bit16 col, bit16 type)
{
planettype *p;
p = &planets[n_planets++];
p->pos[0] = x;
p->pos[1] = y;
p->pos[2] = z;
p->r = r;
p->colour = col;
p->type = type;
// // // printf("planet type %d at %d,%d\n",type,x,y);
}
bit16 rand15(void)
{
return (((bit16)Random()<<8L) | (bit16)Random()) & 0x7fff;
}
void enter_galaxy(void)
{
register int i;
//int t1,t2,t3;
int x,y,z;
#ifdef NEVER
fpi = fopen("stars.dat","r");
if(fpi == NULL) exit(0);
fscanf(fpi,"%d",&t1); n_stars = (bit16)t1;
for(i=0; i<n_stars; i++) {
stars[i].next = &stars[i+1];
fscanf(fpi,"%d,%d,%d",&t1,&t2,&t3); stars[i].pos[0]=t1; stars[i].pos[1]=t2;stars[i].pos[2]=t3;
x = stars[i].pos[0] / 64;
y = stars[i].pos[1] / 64;
z = stars[i].pos[2] / 64;
}
#else
n_stars = 4;
for(i=0; i<n_stars; i++) {
stars[i].next = &stars[i+1];
stars[i].pos[0]=rand15(); stars[i].pos[1]=rand15(); stars[i].pos[2]=rand15();
x = (int)(stars[i].pos[0] / 64L);
y = (int)(stars[i].pos[1] / 64L);
z = (int)(stars[i].pos[2] / 64L);
}
#endif
stars[i-1].next = stars;
far_root = stars;
near_root = stars;
n_far = n_stars;
n_near = 0;
}
void enter_solar(void)
{
bit16 n_xp;
bit16 i;
bit16 r_ss,r;
bit16 r_inc;
randseed = (star_ptr - stars);
r = 500 + (rnd() & 255);
n_planets = 0;
switch(rnd() & 3) {
case 3: make_planet(-r*2,-r*2,0,r,7,0);
case 2: make_planet(r*2,-r*2,0,r/2,6,0);
case 0:
case 1: make_planet(0,0,0,r,5,0);
}
n_suns = n_planets;
n_xp = umod(rnd(),5) + 1;
r *= 3;
r_ss = 5000 + umod(rnd(),9000);
r_inc = (r_ss - r) / n_xp;
for(; r<r_ss-100; r += r_inc) {
i = rnd();
make_planet(div14(mul16(icos[i & 31],r)),div14(mul16(icos[(i+8) & 31],r))
,0,10,7,1);
}
}
void enter_planet(void)
{
}
bit16 rnd(void)
{
return (randseed = randseed * 3421 + 1);
}
bit16 mode,disp_mode;
extern void display(void /*bit16 dmode*/);
extern void combat_loop(void);
extern void inigraf(void);
extern void clear_image(void);
extern void panel(void);
extern void enter_galaxy(void);
extern void enter_solar(void);
extern void enter_planet(void);
extern void make_pirates(void);
void a_loop(void)
{
display(/*disp_mode*/);
switch(mode) {
case 0:
combat_loop();
break;
}
}
extern bit16 view_vec[9];
extern void steer_you(void);
extern void move_you(void);
extern void steer_opponents(void);
extern void move_opponents(void);
void solar_loop(void)
{
}
void hyper_loop(void)
{
}
void combat_loop(void)
{
steer_you();
move_you();
steer_opponents();
move_opponents();
}
bodytype bodies[MAX_BODY];
bit32 ini_pos[3] = {0LL,200LL*16384LL,0LL};
bit16 ini_vec[9] = {16384L,0,0, 0,16384L,0, 0,0,16384L};
void copy16(bit16 *s, bit16 *d, bit16 c)
{
do {
*d++ = *s++;
c--;
} while(c != 0);
}
void copy32(bit32 *s, bit32 *d, bit16 c)
{
do {
*d++ = *s++;
c--;
} while(c != 0);
}
void update_pos(bodytype *b)
{
b->expos[0] = div14(b->pos[0]);
b->expos[1] = div14(b->pos[1]);
b->expos[2] = div14(b->pos[2]);
}
void clear_bodies(void)
{
register int i;
for(i=0; i<MAX_BODY; i++) {
bodies[i].r = 0;
}
}
void make_pirates(void)
{
clear_bodies();
copy32(ini_pos,bodies[0].pos,3);
copy16(ini_vec,bodies[0].view,9);
bodies[0].r = 63;
bodies[0].speed = 4;;
bodies[0].shape = (bit16 *)kcf;
update_pos(&bodies[0]);
}
extern bodytype bodies[];
extern bit16 view_vec[],view_pos[];
void distance(void)
{
int i;
register bodytype *p = bodies;
for(i=MAX_BODY; i != 0; i--,p++) {
if(p->r != 0) {
p->d = abs(p->expos[0] - view_pos[0])
+ abs(p->expos[1] - view_pos[1])
+ abs(p->expos[2] - view_pos[2]);
}
}
}
void move_opponents(void)
{
int i;
register bodytype *p = bodies;
for(i=MAX_BODY; i != 0; i--,p++) {
if(p->r != 0) {
p->expos[0] = div14(p->pos[0] += mul16(p->view[3],p->speed));
p->expos[1] = div14(p->pos[1] += mul16(p->view[4],p->speed));
p->expos[2] = div14(p->pos[2] += mul16(p->view[5],p->speed));
}
}
distance();
}
extern void vector(bit16 x1, bit16 y1, bit16 x2, bit16 y2, char mode, bit16 col);
void panel(void)
{
vector(1,1,1,SCRY-2,'|',7);
vector(1,SCRY-2,SCRX-2,SCRY-2,'|',7);
vector(SCRX-2,SCRY-2,SCRX-2,1,'|',7);
vector(SCRX-2,1,1,1,'|',7);
vector(VPX1-1,VPY1-1,VPX2,VPY1-1,'|',6);
vector(VPX2,VPY1-1,VPX2,VPY2,'|',6);
vector(VPX2,VPY2,VPX1-1,VPY2,'|',6);
vector(VPX1-1,VPY2,VPX1-1,VPY1-1,'|',6);
}
bit32 scprod();
extern atomtype *iptr1;
extern bit16 view_pos[3],view_vec[9];
extern bit16 divy(bit32 x);
void shit(void)
{
register bit16 *p = (bit16 *)shit_data;
bit16 i,x,y,d;
bit16 shit_pos[3];
for(i=*p++; i != 0; i--,p+=3) {
shit_pos[0] = (bit8)(p[0]-view_pos[0]);
shit_pos[1] = (bit8)(p[1]-view_pos[1]);
shit_pos[2] = (bit8)(p[2]-view_pos[2]);
d = div14(scprod(shit_pos,view_vec+3));
if(d > 5) {
x = divy(scprod(shit_pos,view_vec) / d) + (VPX1+VPX2)/2;
if((x > VPX1) && (x < VPX2)) {
y = divy(scprod(shit_pos,view_vec+6) / d) + (VPY1+VPY2)/2;
if((y > VPY1) && (y < VPY2)) {
iptr1->type = 'p';
iptr1->x1 = x;
iptr1->y1 = y;
iptr1++;
}
}
}
}
}
bit16 divy(bit32 x)
{
return (bit16)(x >> 8);
}
extern void xrotate(bit16 *v, bit16 x);
extern bodytype bodies[];
void steer_opponents(void)
{
int i;
register bodytype *p = bodies;
for(i=MAX_BODY; i != 0; i--,p++) {
if(p->r != 0) {
xrotate(p->view,1000);
}
}
}
extern void norm(bit16 *a, bit16 *b);
void xrotate(bit16 *v, bit16 x)
{
bit16 t[3];
t[0] = v[6];
t[1] = v[7];
t[2] = v[8];
v[6] -= div14(mul16(v[3],x));
v[7] -= div14(mul16(v[4],x));
v[8] -= div14(mul16(v[5],x));
v[3] += div14(mul16(t[0],x));
v[4] += div14(mul16(t[1],x));
v[5] += div14(mul16(t[2],x));
norm(v+3,v+3);
norm(v+6,v+6);
}
void yrotate(bit16 *v, bit16 x)
{
bit16 t[3];
t[0] = v[6];
t[1] = v[7];
t[2] = v[8];
v[6] -= div14(mul16(v[0],x));
v[7] -= div14(mul16(v[1],x));
v[8] -= div14(mul16(v[2],x));
v[0] += div14(mul16(t[0],x));
v[1] += div14(mul16(t[1],x));
v[2] += div14(mul16(t[2],x));
norm(v,v);
norm(v+3,v+3);
}
void norm(bit16 *a, bit16 *b)
{
register bit32 v = mul16(a[0],a[0])+mul16(a[1],a[1])+mul16(a[2],a[2]);
bit16 g,m;
if((v < 268304400l) || (v > 268566544l)) {
g = 0;
for(m=16384; m != 0; m /= 2) {
g |= m;
if(mul16(g,g) > v) {
g ^= m;
}
}
b[0] = mul16(a[0],16384) / g;
b[1] = mul16(a[1],16384) / g;
b[2] = mul16(a[2],16384) / g;
}
}
char last_mode = '|';
bit16 last_col = 7; // white
// static char hex_chars[] = "0123456789ABCDEF";
// BBC Micro-dependent
void vdu(int code, int arg, int x, int y)
{ // low-level graphics calls on Beeb
#ifdef NEVER
putchar(code); putchar(arg);
x = x*4; y = y*4;
putchar(x & 255); putchar((x >> 8) & 255);
putchar(y & 255); putchar((y >> 8) & 255);
#endif
// // // printf("Vdu %d,%d, %d, %d\n", code, arg, x, y);
(void)code; (void)arg; (void)x; (void)y;
}
void inigraf(void)
{
// vdu(22,0,0,0); // CLS
// // // printf("cls\n");
}
void plot(bit16 x, bit16 y)
{
// // // printf("point %d,%d\n", x,y);
//vdu(25,4,x,y); // moveto
//vdu(25,5,x,y); // lineto same point
Reset0Ref();
Dot_d((int)y,(int)x);
}
void vector(bit16 x1, bit16 y1, bit16 x2, bit16 y2, char mode, bit16 col)
{
if(col != last_col) last_col = col;
(void)mode;
#ifdef NEVER
if(mode != last_mode) {
last_mode = mode;
switch(mode) {
case '|':
//vdu(18,0,1,0); // OR mode
break;
case '^':
//vdu(18,4,1,0); // EXOR mode
break;
}
}
#endif
// // // printf("line %d,%d, %d,%d\n", x1,y1, x2,y2);
Reset0Ref();
Moveto_d_7F((int)y1,(int)x1);
//vdu(25,4,x1,y1); // move to
Draw_Line_d((int)(y2+y1),(int)(x2+x1));
//vdu(25,5,x2,y2); // line to
}
extern void xrotate(bit16 *v, bit16 x);
bit16 view_speed = 3;
bit32 view_big[3] = {0l,0l,0l};
bit16 view_pos[3] = {0,0,0};
bit16 view_vec[9] = {16384,0,0, 0,16384,0, 0,0,16384};
bit16 x_rot_val = 0;
bit16 y_rot_val = 0;
static char c;
//extern void exit(int rc); // no stdlib :-(
void steer_you(void)
{
// get68k(&c);
// get an up/level/down command from the keyboard
c = '5';
if (c == '\0') return;
switch(c) {
case '\033':
/*exit(0)*/;
case '8': x_rot_val = 200;
break;
case '2': x_rot_val = -200;
break;
case '5': x_rot_val = 0;
y_rot_val = 0;
break;
}
}
void move_you(void)
{
if(x_rot_val != 0) xrotate(view_vec,x_rot_val);
view_pos[0] = div14(view_big[0] += mul16(view_vec[3],view_speed));
view_pos[1] = div14(view_big[1] += mul16(view_vec[4],view_speed));
view_pos[2] = div14(view_big[2] += mul16(view_vec[5],view_speed));
}
int main(void)
{
inigraf();
clear_image();
panel();
enter_galaxy();
star_ptr = stars;
enter_solar();
planet_ptr = planets;
enter_planet();
moon_ptr = moons;
mode = 0;
disp_mode = 0;
make_pirates();
Intensity_7F();
VIA_t1_cnt_lo = (unsigned int)(0xFF);
while(1)
{
Wait_Recal();
Print_Str_d(0, -70, "HELLO WORLD\x80");
Moveto_d_7F(-100,-100);
Draw_Line_d(100,100);
a_loop();
};
// if return value is <= 0, then a warm reset will be performed,
// otherwise a cold reset will be performed
return 0;
}
// ***************************************************************************
// end of file
// ***************************************************************************