games@tekred.TEK.COM (06/01/88)
Submitted by: udenva!koala!dir (Dan Rosenblatt)
Comp.sources.games: Volume 4, Issue 23
Archive-name: spacewar/Part03
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 3 (of 6)."
# Contents: mutils.c plinit.c proctrap.c prvcmd.c scrn.c see.c
# updaln.c updmov.c
# Wrapped by billr@saab on Tue May 31 09:54:52 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f mutils.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mutils.c\"
else
echo shar: Extracting \"mutils.c\" \(2974 characters\)
sed "s/^X//" >mutils.c <<'END_OF_mutils.c'
X/*
X * Spacewar - matrix, vector, and trig routines
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X
XVOID unity(mtrx)
Xdouble mtrx[3][3];
X{
X minit(mtrx);
X mtrx[0][0] = 1.0;
X mtrx[1][1] = 1.0;
X mtrx[2][2] = 1.0;
X}
X
XVOID matmul(amtrx,bmtrx,cmtrx)
Xdouble amtrx[3][3],bmtrx[3][3],cmtrx[3][3];
X{
X double tmp,tmpmtrx[3][3];
X int i,j,k;
X
X for (i=0;i<3;++i)
X for (j=0;j<3;++j) {
X tmp = 0.0;
X for (k=0;k<3;++k)
X tmp = ADD(tmp,MUL(amtrx[k][j],bmtrx[i][k]));
X tmpmtrx[i][j] = tmp;
X }
X mcopy(cmtrx,tmpmtrx);
X}
X
XVOID vecmul(avec,bmtrx,cvec)
Xdouble avec[3],bmtrx[3][3],cvec[3];
X{
X double tmp,tmpvec[3];
X int i,j;
X
X for (i=0;i<3;++i) {
X tmp = 0.0;
X for (j=0;j<3;++j)
X tmp = ADD(tmp,MUL(avec[j],bmtrx[i][j]));
X tmpvec[i] = tmp;
X }
X vcopy(cvec,tmpvec);
X}
X
XVOID xrot(rotmtrx,rotangl)
Xdouble rotmtrx[3][3],rotangl;
X{
X double tmpmtrx[3][3];
X
X minit(tmpmtrx);
X tmpmtrx[1][1] = tmpmtrx[2][2] = COS(rotangl);
X tmpmtrx[1][2] = NEG(tmpmtrx[2][1] = SIN(rotangl));
X tmpmtrx[0][0] = 1.0;
X matmul(rotmtrx,tmpmtrx,rotmtrx);
X}
X
XVOID yrot(rotmtrx,rotangl)
Xdouble rotmtrx[3][3],rotangl;
X{
X double tmpmtrx[3][3];
X
X minit(tmpmtrx);
X tmpmtrx[0][0] = tmpmtrx[2][2] = COS(rotangl);
X tmpmtrx[2][0] = NEG(tmpmtrx[0][2] = SIN(rotangl));
X tmpmtrx[1][1] = 1.0;
X matmul(rotmtrx,tmpmtrx,rotmtrx);
X}
X
XVOID zrot(rotmtrx,rotangl)
Xdouble rotmtrx[3][3],rotangl;
X{
X double tmpmtrx[3][3];
X
X minit(tmpmtrx);
X tmpmtrx[0][0] = tmpmtrx[1][1] = COS(rotangl);
X tmpmtrx[0][1] = NEG(tmpmtrx[1][0] = SIN(rotangl));
X tmpmtrx[2][2] = 1.0;
X matmul(rotmtrx,tmpmtrx,rotmtrx);
X}
X
XVOID sptort(spvec,rtvec)
Xdouble spvec[3],rtvec[3];
X{
X double sin2,tmpvec[3];
X
X sin2 = SIN(spvec[2]);
X tmpvec[0] = MUL(spvec[0],MUL(COS(spvec[1]),sin2));
X tmpvec[1] = MUL(spvec[0],MUL(SIN(spvec[1]),sin2));
X tmpvec[2] = MUL(spvec[0],COS(spvec[2]));
X vcopy(rtvec,tmpvec);
X}
X
Xdouble xatan2(x,y)
Xdouble x,y;
X{
X if (x == 0. && y == 0.)
X return(0.);
X else
X return(ATAN2(x,y));
X}
X
XVOID rttosp(rtvec,spvec)
Xdouble rtvec[3],spvec[3];
X{
X double tmp,tmpvec[3];
X
X tmp = ADD(SQUARE(rtvec[0]),SQUARE(rtvec[1]));
X tmpvec[0] = SQRT(ADD(tmp,SQUARE(rtvec[2])));
X tmpvec[1] = FMOD(ADD(xatan2(rtvec[1],rtvec[0]),TWOPI),TWOPI);
X tmpvec[2] = FMOD(ADD(xatan2(SQRT(tmp),rtvec[2]),TWOPI),TWOPI);
X vcopy(spvec,tmpvec);
X}
X
XVOID vdiff(avec,bvec,cvec)
Xregister double *avec,*bvec,*cvec;
X{
X register int i;
X
X for (i=0;i++<3;)
X *cvec++ = *avec++ - *bvec++;
X}
X
Xdouble vdist(avec,bvec)
Xdouble avec[3],bvec[3];
X{
X double tmp,sumsqr=0.;
X int i;
X
X for (i=0;i<3;++i) {
X tmp = SUB(avec[i],bvec[i]);
X sumsqr = ADD(sumsqr,SQUARE(tmp));
X }
X return(SQRT(sumsqr));
X}
X
Xdouble vlen(avec)
Xdouble avec[3];
X{
X double sumsqr;
X
X sumsqr = SQUARE(avec[0]);
X sumsqr = ADD(sumsqr,SQUARE(avec[1]));
X sumsqr = ADD(sumsqr,SQUARE(avec[2]));
X return(SQRT(sumsqr));
X}
X
X#if defined(NEEDFMOD)
Xdouble fmod(arg1,arg2)
Xdouble arg1,arg2;
X{
X double tmp;
X
X while ((tmp = SUB(arg1,arg2)) >= 0.)
X arg1 = tmp;
X return(arg1);
X}
X#endif
END_OF_mutils.c
if test 2974 -ne `wc -c <mutils.c`; then
echo shar: \"mutils.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f plinit.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"plinit.c\"
else
echo shar: Extracting \"plinit.c\" \(7450 characters\)
sed "s/^X//" >plinit.c <<'END_OF_plinit.c'
X/*
X * Spacewar - routine to initialize a player into the universe
X * - terminal type
X * - craft name
X * - craft structure and universe entry
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#ifndef VMS
X#include <sys/types.h>
X#include <dbm.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#include "dbm.h"
X#endif /* VMS */
X#include "spacewar.h"
X#include "universe.h"
X#include "login.h"
X#include "sys.h"
X#include "crft.h"
X#include "obj.h"
X#include "aln.h"
X#include "torp.h"
X#include "build.h"
X
Xextern char *malloc(),*tgetstr(),*lckmsg();
Xextern int numpling;
X
Xint plinit(plogin)
Xregister struct login *plogin;
X{
X char trmbuf[2048],trmcap[128],*ptrmcap,*pcm,*pcl,*pce,*pso,*pse;
X char buf[80+1],*s,*so,*se;
X register struct universe *puniv;
X register struct crft *pcrft;
X struct crftkey getcrkey;
X struct crft getcrdat;
X struct syskey getskey;
X datum dbmkey,dbmdata;
X int i;
X
X#ifdef DEBUG
X DBG("plinit(#%d/%s)\n",plogin-loginlst,plogin->ln_name);
X#endif
X
X if (!strcmp(plogin->ln_input,".")) goto noplay;
X
X /********************/
X /* no terminal type */
X /********************/
X if (!plogin->ln_term) {
X
X /* get terminal type from user input */
X if (!plogin->ln_input[0]) {
Xgetterm: output(plogin,'C',0,"\nWhat (termcap) terminal type>");
X output(plogin,0,0,0);
X#ifdef DEBUG
X VDBG("plinit return\n");
X#endif
X return(0);
X }
X plogin->ln_rvslh = 0;
X switch(plogin->ln_input[0]) {
X case '.':
X so = "so"; se = "se";
X plogin->ln_rvslh = 1;
X strcpy(plogin->ln_input,plogin->ln_input+1);
X break;
X case ',':
X so = "us"; se = "ue";
X strcpy(plogin->ln_input,plogin->ln_input+1);
X break;
X case ';':
X so = "us"; se = "ue";
X plogin->ln_rvslh = 1;
X strcpy(plogin->ln_input,plogin->ln_input+1);
X break;
X default:
X so = "so"; se = "se";
X break;
X }
X if (tgetent(trmbuf,plogin->ln_input) != 1) goto getterm;
X
X /* get necessary capabilities */
X ptrmcap = trmcap;
X if (!(pcm=tgetstr("cm",&ptrmcap)) ||
X !(pcl=tgetstr("cl",&ptrmcap)) ||
X !(pce=tgetstr("ce",&ptrmcap)) ||
X !(pso=tgetstr(so,&ptrmcap)) ||
X !(pse=tgetstr(se,&ptrmcap))) {
X output(plogin,'C',0,
X "\nMissing minimum necessary terminal capabilities\n");
X goto noplay;
X }
X
X /* save terminal type and capabilities */
X if (!(plogin->ln_term = malloc((unsigned)strlen(plogin->ln_input)+1)) ||
X !(plogin->ln_tcm = malloc((unsigned)strlen(pcm)+1)) ||
X !(plogin->ln_tcl = malloc((unsigned)strlen(pcl)+1)) ||
X !(plogin->ln_tce = malloc((unsigned)strlen(pce)+1)) ||
X !(plogin->ln_tso = malloc((unsigned)strlen(pso)+1)) ||
X !(plogin->ln_tse = malloc((unsigned)strlen(pse)+1))) {
X perror("plinit: out of memory for termcaps");
X plogin->ln_term = NULL;
X plogin->ln_tcm = NULL;
X plogin->ln_tcl = NULL;
X plogin->ln_tce = NULL;
X plogin->ln_tso = NULL;
X plogin->ln_tse = NULL;
X goto noplay;
X }
X strcpy(plogin->ln_term,plogin->ln_input);
X plogin->ln_input[0] = NULL;
X strcpy(plogin->ln_tcm,pcm);
X strcpy(plogin->ln_tcl,pcl);
X strcpy(plogin->ln_tce,pce);
X strcpy(plogin->ln_tso,pso);
X strcpy(plogin->ln_tse,pse);
X }
X
X /*********/
X /* craft */
X /*********/
X
X /* prompt for ship name */
X if (!plogin->ln_input[0]) {
X output(plogin,'C',0,"\nWhat ship>");
X output(plogin,0,0,0);
X#ifdef DEBUG
X VDBG("plinit return\n");
X#endif
X return(0);
X }
X
X /* get craft */
X plogin->ln_input[sizeof(plogin->ln_crft)-1] = NULL;
X binit((char *)&getcrkey,sizeof(getcrkey));
X getcrkey.cr_crftkey = CRAFT;
X strcpy(getcrkey.cr_plyr,plogin->ln_name);
X strcpy(getcrkey.cr_name,plogin->ln_input);
X dbmkey.dptr = (char *)&getcrkey;
X dbmkey.dsize = sizeof(getcrkey);
X dbmdata = fetch(dbmkey);
X if (!dbmdata.dptr) {
X sprintf(buf,"\n'%s' - no such ship\n",plogin->ln_input);
X output(plogin,'C',0,buf);
X goto noplay;
X }
X binit((char *)&getcrdat,sizeof(getcrdat));
X bcopy((char *)&getcrdat,dbmdata.dptr,dbmdata.dsize);
X
X /* must have a hull */
X if (!getcrdat.cr_htyp) {
X sprintf(buf,"\n'%s' - has no hull\n",plogin->ln_input);
X output(plogin,'C',0,buf);
X goto noplay;
X }
X
X /* must be room in the universe */
X for (puniv=univlst+MAXOBJ+MAXALN;puniv < univlst+MAXUNIVERSE;++puniv)
X if (!puniv->uv_type)
X break;
X if (puniv >= univlst+MAXUNIVERSE) {
X output(plogin,'C',0,"\nSorry, the universe is temporarily full\n");
X goto noplay;
X }
X
X /* must not be locked */
X if (s=lckmsg()) {
X output(plogin,'C',0,"\n");
X output(plogin,'C',0,s);
X output(plogin,'C',0,"\n");
X goto noplay;
X }
X
X
X /**********************************/
X /* put player/craft into universe */
X /**********************************/
X
X /* fill in craft data */
X pcrft = crftlst + (plogin - loginlst); /* 1to1 correspondence */
X *pcrft = getcrdat;
X
X /* if first time playing, pick a pstn near the object */
X if (pcrft->cr_dock.ip_ofst == -1) {
X pcrft->cr_dock.ip_ptr = NULL;
X i = RANDOM(MAXOBJ-1) + 1; /* 1:MAXOBJ-1 */
X vcopy(pcrft->cr_pstn,univlst[i].uv_pstn);
X pcrft->cr_pstn[0] =
X ADD(pcrft->cr_pstn[0],FLOAT(RANDOM(2000)+500));
X pcrft->cr_pstn[1] =
X ADD(pcrft->cr_pstn[1],FLOAT(RANDOM(2000)+500));
X pcrft->cr_vang = DIV(PI,4.);
X pcrft->cr_vdst =
X INT(DIV(VANGVDST,SQUARE(pcrft->cr_vang)));
X
X /* point so that facing the object */
X vdiff(univlst[i].uv_pstn,pcrft->cr_pstn,pcrft->cr_dir);
X rttosp(pcrft->cr_dir,pcrft->cr_dir);
X
X /* previously docked with a non-object; pstn remains the same */
X } else if (pcrft->cr_dock.ip_ofst >= MAXOBJ ||
X pcrft->cr_dock.ip_ofst <= 0) {
X pcrft->cr_dock.ip_ptr = NULL;
X
X /* prevsiously docked with an object; pstn shifts to object */
X } else if (pcrft->cr_dock.ip_ofst) {
X pcrft->cr_dock.ip_ptr = univlst + pcrft->cr_dock.ip_ofst;
X vcopy(pcrft->cr_pstn,pcrft->cr_dock.ip_ptr->uv_pstn);
X }
X
X /* turn off inappropriate homing/autopilot */
X if (pcrft->cr_auto.ip_ofst >= MAXOBJ || pcrft->cr_auto.ip_ofst <= 0)
X pcrft->cr_auto.ip_ptr = NULL;
X else
X pcrft->cr_auto.ip_ptr = univlst + pcrft->cr_auto.ip_ofst;
X for (i=0;i < MHOM;++i) {
X if (pcrft->cr_hom[i].ip_ofst >= MAXOBJ || pcrft->cr_hom[i].ip_ofst <= 0)
X pcrft->cr_hom[i].ip_ptr = NULL;
X else
X pcrft->cr_hom[i].ip_ptr = univlst + pcrft->cr_hom[i].ip_ofst;
X }
X
X /* normalize direction and do rotation matrix */
X fixdir(pcrft);
X
X /* get all subsystems */
X binit((char *)&getskey,sizeof(getskey));
X getskey.s_syskey = SUBSYS;
X strcpy(getskey.s_plyr,plogin->ln_name);
X strcpy(getskey.s_crft,getcrkey.cr_name);
X dbmkey.dptr = (char *)&getskey;
X dbmkey.dsize = sizeof(getskey);
X for (i=0;i < MSYS;++i) {
X getskey.s_type = i;
X dbmdata = fetch(dbmkey);
X if (dbmdata.dptr)
X bcopy((char *)(pcrft->cr_sys+i),dbmdata.dptr,dbmdata.dsize);
X }
X
X /* et al */
X pcrft->cr_lgn = plogin;
X pcrft->cr_lhit.ip_ptr = NULL;
X plogin->ln_iomode = 's';
X strcpy(plogin->ln_crft,getcrkey.cr_name);
X plogin->ln_play.ip_ptr = puniv;
X puniv->uv_type = 'P';
X puniv->uv_pctr = pcrft->cr_htyp + '0';
X puniv->uv_pstn = pcrft->cr_pstn;
X puniv->uv_mass = pcrft->cr_sys[HULL].s_dmg;
X puniv->uv_rad = 1;
X puniv->uv_ptr.uv_crft = pcrft;
X pcrft->cr_univ.ip_ptr = puniv;
X
X /* first player must start universe update */
X if (!numpling++) firstplyr();
X
X#ifdef DEBUG
X VDBG("plinit return\n");
X#endif
X return(1);
X
Xnoplay: plogin->ln_stat = NULL;
X output(plogin,'C',0,PROMPT);
X output(plogin,0,0,0);
X#ifdef DEBUG
X VDBG("plinit return\n");
X#endif
X return(0);
X}
END_OF_plinit.c
if test 7450 -ne `wc -c <plinit.c`; then
echo shar: \"plinit.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f proctrap.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"proctrap.c\"
else
echo shar: Extracting \"proctrap.c\" \(6181 characters\)
sed "s/^X//" >proctrap.c <<'END_OF_proctrap.c'
X/*
X * Spacewar - process an asynchronous trap, usually a player wanting
X * to logon to the game or possibly a signal from a user
X * noticed and passed on by playsw
X *
X * trapmsg structure: pid {signal#|ttyname}
X *
X * Copyright 1984 obo Systems, Inc.
X * Copyright 1984 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X#ifdef BSD
X# include <sys/ioctl.h>
X#else /* VMS SYSIII SYSV */
X#ifdef VMS
X# include <descrip.h>
X# include <ssdef.h>
X# include <psldef.h>
X# include "uio.h"
X#else /* SYSIII SYSV */
X# include <fcntl.h>
X#endif /* VMS SYSIII SYSV */
X#endif /* BSD VMS SYSIII SYSV */
X#include <signal.h>
X#include "universe.h"
X#include "login.h"
X#ifndef VMS
X# include "uio2.h"
X#endif /* VMS */
X
Xstatic int setupread();
X
X#ifdef BSD
XVOID proctrap(trapmsgfd,ntrapmsg)
Xint trapmsgfd,*ntrapmsg;
X{
X struct uio2 uio;
X#else /* VMS SYSIII SYSV */
XVOID proctrap(uio)
X#ifdef VMS
Xstruct uio uio;
X#else /* SYSIII SYSV */
Xstruct uio2 uio;
X#endif /* VMS SYSIII SYSV */
X{
X#endif /* VMS BSD SYSIII SYSV */
X register struct login *plogin;
X int i;
X#ifdef VMS
X int pid;
X#endif /* VMS */
X extern VOID logon(),logoff();
X
X#ifdef BSD
X#ifdef DEBUG
X DBG("proctrap(%d,%d)\n",trapmsgfd,*ntrapmsg);
X#endif
X
X /* for as many traps as received */
X do {
X
X /* get the pid */
X if (read(trapmsgfd,&uio,sizeof(uio)) != sizeof(uio)) {
X perror("trapmsg file uio");
X *ntrapmsg = 0;
X#ifdef DEBUG
X VDBG("proctrap return\n");
X#endif
X return;
X }
X#ifdef DEBUG
X VDBG("proctrap: uio %d %d %s\n",uio.uio2sig,uio.uio2pid,
X uio.uio2tty);
X#endif
X#else /* VMS SYSIII SYSV */
X#ifdef VMS
X#ifdef DEBUG
X DBG("proctrap(%d,%s)\n",(int)uio.uio_lgn,uio.uio_chrs);
X#endif
X sscanf(uio.uio_chrs+2,"%x",&pid);
X#else /* SYSIII SYSV */
X#ifdef DEBUG
X DBG("proctrap(%d,%d,%s)\n",uio.uio2sig,uio.uio2pid,uio.uio2tty);
X#endif
X#endif /* VMS SYSIII SYSV */
X#endif /* VMS BSD SYSIII SYSV */
X
X /* try to find player */
X for (plogin=loginlst,i=MAXLOGIN+1;--i > 0;++plogin)
X#ifdef VMS
X if (plogin->ln_pid == pid)
X#else /* BSD SYSIII SYSV */
X if (plogin->ln_playpid == uio.uio2pid)
X#endif /* VMS BSD SYSIII SYSV */
X break;
X#ifdef DEBUG
X VDBG("proctrap: login entry #%d\n",plogin-loginlst);
X#endif
X
X /* player is already logged on, therefore its a signal */
X if (i) {
X
X /* process according to signal# */
X#ifdef VMS
X switch((int)uio.uio_lgn) {
X#else /* BSD SYSIII SYSV */
X switch(uio.uio2sig) {
X#endif /* VMS BSD SYSIII SYSV */
X
X case SIGQUIT: /* wants to go away */
X output(plogin,'E',0,0);
X case SIGHUP: /* or just went away */
X logoff(plogin);
X break;
X
X case SIGINT: /* restart if not playing */
X if (plogin->ln_play.ip_ptr == NULL) {
X output(plogin,'C',0,
X "\n\n\nInterrupt - restarting\n");
X logon(plogin);
X }
X break;
X
X default:
X perror("proctrap: unknown signal");
X break;
X }
X
X /* not logged in, therefore its the ttyname */
X } else {
X
X /* find an available login */
X for (plogin=loginlst,i=MAXLOGIN+1;--i > 0;++plogin)
X if (plogin->ln_tty == NULL)
X break;
X#ifdef DEBUG
X VDBG("proctrap: available login entry #%d\n",
X plogin-loginlst);
X#endif
X#ifdef VMS
X /* psw will timeout if no message from setupread */
X if (i && setupread(plogin,pid))
X logon(plogin);
X#else /* BSD SYSIII SYSV */
X if (i && setupread(plogin,uio.uio2pid,uio.uio2tty))
X logon(plogin);
X else
X kill(uio.uio2pid,SIGTERM);
X#endif /* VMS BSD SYSIII SYSV */
X }
X#ifdef BSD
X } while (--(*ntrapmsg) > 0);
X#endif /* BSD */
X#ifdef DEBUG
X VDBG("proctrap return\n");
X#endif
X}
X
X#ifdef VMS
Xstatic int setupread(plogin,pid)
Xstruct login *plogin;
Xint pid;
X{
X struct dsc$descriptor_d mlbx;
X char buf[32];
X int i;
X extern int errno;
X
X#ifdef DEBUG
X DBG("setupread(#%d,%x)\n",plogin-loginlst,pid);
X#endif
X
X sprintf(buf,"sw%x",pid);
X mlbx.dsc$w_length = strlen(buf);
X mlbx.dsc$b_dtype = DSC$K_DTYPE_T;
X mlbx.dsc$b_class = DSC$K_CLASS_S;
X mlbx.dsc$a_pointer = buf;
X if ((i=sys$crembx(1,&plogin->ln_tty,0,0,0,PSL$C_USER,&mlbx)) !=
X SS$_NORMAL) {
X perror("crembx");
X#ifdef DEBUG
X VDBG("setupread crembx()=%d, errno=%d\n",i,errno);
X#endif
X plogin->ln_tty = NULL;
X#ifdef DEBUG
X VDBG("setupread return\n");
X#endif
X return(0);
X }
X plogin->ln_pid = pid;
X
X sprintf(buf,"%d",plogin);
X output(plogin,'C',0,buf);
X output(plogin,0,0,0);
X
X#ifdef DEBUG
X VDBG("setupread return\n");
X#endif
X return(1);
X}
X#else /* BSD SYSIII SYSV */
X/*
X * setting up a readsw process with:
X * fd0 attached to the terminal
X * fd1 as it exists in spacewar
X * all other fd's closed
X * partially fill in the login structure
X * returns non-zero if successful, 0 otherwise
X */
Xstatic int setupread(plogin,playpid,ttynm)
Xregister struct login *plogin;
Xint playpid;
Xchar *ttynm;
X{
X int ttyfd,readpid,i;
X char buf[32];
X extern int doproctrap;
X
X /* temporarily disable interrupts */
X if (doproctrap == 1) doproctrap = 0;
X
X#ifdef DEBUG
X DBG("setupread(#%d,%d,%s)\n",plogin-loginlst,playpid,ttynm);
X#endif
X
X /* open the player's tty */
X if ((ttyfd = open(ttynm,2)) < 0) {
X perror(ttynm);
X if (doproctrap == 0) doproctrap = 1;
X#ifdef DEBUG
X VDBG("setupread return\n");
X#endif
X return(0);
X }
X
X /* fork */
X switch(readpid=fork()) {
X case -1: /* failed */
X perror("fork");
X if (close(ttyfd)) perror(ttynm);
X if (doproctrap == 0) doproctrap = 1;
X#ifdef DEBUG
X VDBG("setupread return\n");
X#endif
X return(0);
X
X case 0: /* child */
X#ifdef BSD
X if (dup2(ttyfd,0) < 0) {
X perror("dup2");
X exit(1);
X }
X if (close(ttyfd)) perror(ttynm);
X for (i=3;i < 20;ioctl(i++,FIOCLEX,NULL));
X#ifdef TIOCGPGRP
X ioctl(0,TIOCGPGRP,&i);
X setpgrp(0,i);
X#endif
X#else /* SYSIII SYSV */
X if (close(0)) {
X perror("close(0)");
X exit(1);
X }
X if (fcntl(ttyfd,F_DUPFD,0) != 0) {
X perror("fcntl(ttyfd,F_DUPFD,0)");
X exit(1);
X }
X if (close(ttyfd)) perror(ttynm);
X for (i=3;i < 20;fcntl(i++,F_SETFD,1));
X#endif /* BSD SYSIII SYSV */
X sprintf(buf,"%d",(int)plogin);
X execlp(SWREAD,"rsw",buf,0);
X perror(SWREAD);
X exit(1);
X }
X
X /* parent; fill in login structure */
X plogin->ln_tty = ttyfd;
X plogin->ln_playpid = playpid;
X plogin->ln_readpid = readpid;
X
X if (doproctrap == 0) doproctrap = 1;
X#ifdef DEBUG
X VDBG("setupread return\n");
X#endif
X return(1);
X}
X#endif /* VMS BSD SYSIII SYSV */
END_OF_proctrap.c
if test 6181 -ne `wc -c <proctrap.c`; then
echo shar: \"proctrap.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f prvcmd.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"prvcmd.c\"
else
echo shar: Extracting \"prvcmd.c\" \(7159 characters\)
sed "s/^X//" >prvcmd.c <<'END_OF_prvcmd.c'
X/*
X * Spacewar - priviledged commands for SWMASTER
X *
X * Copyright 1984 obo Systems, Inc.
X * Copyright 1984 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X#ifndef VMS
X#include <sys/types.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#endif /* VMS */
X#include "universe.h"
X#include "login.h"
X#include "sys.h"
X#include "aln.h"
X#include "build.h"
X#include "obj.h"
X#include "crft.h"
X#include "torp.h"
X
Xstatic char *fmtip();
X
XVOID prvcmd(plogin)
Xstruct login *plogin;
X{
X char *s=plogin->ln_input,buf[256];
X struct login *plgn;
X struct aln *paln;
X struct sys *psys;
X struct obj *pobj;
X struct universe *puniv;
X struct crft *pcrft;
X struct torp *ptorp;
X int i;
X
X#ifdef DEBUG
X DBG("prvcmd(#%d/%s)\n",plogin-loginlst,plogin->ln_name);
X#endif
X
X /* only allowed if priviledged */
X if (strcmp(SWMASTER,plogin->ln_name)) {
X#ifdef DEBUG
X VDBG("prvcmd return\n");
X#endif
X return;
X }
X
X if (!strcmp(".shutdown",s)) {
X shutdown(0);
X
X } else if (!strncmp(".logoff ",s,8)) {
X for (s+=8,plgn=loginlst;plgn < loginlst+MAXLOGIN;++plgn) {
X if (!plgn->ln_tty) continue;
X if (!strcmp(plgn->ln_name,s)) logoff(plgn);
X }
X
X } else if (!strncmp(".aln",s,4)) {
X s += 4;
X for (paln=alnlst;paln < alnlst+MAXALN;++paln) {
X sprintf(buf,
X "#%-3d (%8.1e %8.1e %8.1e) (%3.0f %3.0f %3.0f) (%2.0f %2.0f %2.0f)",
X paln-alnlst,paln->al_pstn[0],paln->al_pstn[1],paln->al_pstn[2],
X paln->al_vel[0],paln->al_vel[1],paln->al_vel[2],
X paln->al_thr[0],paln->al_thr[1],paln->al_thr[2]);
X output(plogin,'C',0,buf);
X sprintf(buf," %d %d %s",paln->al_dly,paln->al_htyp,
X fmtip(paln->al_lhit));
X output(plogin,'C',0,buf);
X sprintf(buf," %s %d\n",fmtip(paln->al_atck),paln->al_aeval);
X output(plogin,'C',0,buf);
X if (*s)
X for (psys=paln->al_sys;psys < paln->al_sys+MSYS;++psys) {
X if (!psys->s_cap) continue; /* not in this craft */
X sprintf(buf,"\t%-8.8s %3d %3d %3d %5d %5d\n",
X subsysnam[psys-paln->al_sys],psys->s_pct,psys->s_edmg,
X psys->s_dmg,psys->s_lvl,psys->s_cap);
X output(plogin,'C',0,buf);
X }
X }
X
X } else if (!strncmp(".crft",s,5)) {
X s += 5;
X for (pcrft=crftlst;pcrft < crftlst+MAXCRFT;++pcrft) {
X if (!pcrft->cr_htyp) continue;
X sprintf(buf,"#%-3d %d %5ld %3ld %5ld %5ld %2d %s\n",
X pcrft-crftlst,pcrft->cr_htyp,pcrft->cr_flsp,pcrft->cr_crew,
X pcrft->cr_pnts,pcrft->cr_time,pcrft->cr_kill,
X fmtip(pcrft->cr_dock));
X output(plogin,'C',0,buf);
X sprintf(buf," (%8.1e %8.1e %8.1e) (%8.1e %8.1e %8.1e)\
X(%3.0f %3.0f %3.0f) (%2.0f %2.0f %2.0f)\n ",
X pcrft->cr_pstn[0],pcrft->cr_pstn[1],pcrft->cr_pstn[2],
X pcrft->cr_dir[0],pcrft->cr_dir[1],pcrft->cr_dir[2],
X pcrft->cr_vel[0],pcrft->cr_vel[1],pcrft->cr_vel[2],
X pcrft->cr_thr[0],pcrft->cr_thr[1],pcrft->cr_thr[2]);
X output(plogin,'C',0,buf);
X for (i=0;i < MHOM;++i) {
X sprintf(buf,"%d:%s ",i,fmtip(pcrft->cr_hom[i]));
X output(plogin,'C',0,buf);
X }
X sprintf(buf," %s %d %5.1f %ld %d\n",fmtip(pcrft->cr_auto),
X pcrft->cr_ffwd,DIV(pcrft->cr_vang,DEGTORAD),pcrft->cr_vdst,
X pcrft->cr_plvl);
X output(plogin,'C',0,buf);
X if (*s)
X for (psys=pcrft->cr_sys;psys < pcrft->cr_sys+MSYS;++psys) {
X if (!psys->s_cap) continue; /* not in this craft */
X sprintf(buf,"\t%-8.8s %3d %3d %3d %5d %5d\n",
X subsysnam[psys-pcrft->cr_sys],psys->s_pct,psys->s_edmg,
X psys->s_dmg,psys->s_lvl,psys->s_cap);
X output(plogin,'C',0,buf);
X }
X }
X } else if (!strncmp(".login",s,6)) {
X s += 6;
X for (plgn=loginlst;plgn < loginlst+MAXLOGIN;++plgn) {
X if (!plgn->ln_tty) continue;
X if (*s) {
X#ifdef VMS
X sprintf(buf,
X "#%-3d %2d %x '%-8.8s' '%-8.8s' '%c' '%-12.12s' %s",
X plgn-loginlst,plgn->ln_tty,plgn->ln_pid,plgn->ln_name,
X plgn->ln_term ? plgn->ln_term : "",
X plgn->ln_iomode ? plgn->ln_iomode : ' ',
X plgn->ln_crft,fmtip(plgn->ln_play));
X#else /* BSD SYSIII SYSV */
X sprintf(buf,
X "#%-3d %2d %5d %5d '%-8.8s' '%-8.8s' '%c' '%-12.12s' %s",
X plgn-loginlst,plgn->ln_tty,plgn->ln_playpid,
X plgn->ln_readpid,plgn->ln_name,
X plgn->ln_term ? plgn->ln_term : "",
X plgn->ln_iomode ? plgn->ln_iomode : ' ',plgn->ln_crft,
X fmtip(plgn->ln_play));
X#endif /* VMS BSD SYSIII SYSV */
X output(plogin,'C',0,buf);
X sprintf(buf," '%c'\n '%s'\n",
X plgn->ln_stat ? plgn->ln_stat : ' ',plgn->ln_input);
X output(plogin,'C',0,buf);
X } else {
X sprintf(buf,"#%-3d '%-8.8s' '%-8.8s' '%c' '%-12.12s' %s",
X plgn-loginlst,plgn->ln_name,
X plgn->ln_term ? plgn->ln_term : "",
X plgn->ln_iomode ? plgn->ln_iomode : ' ',plgn->ln_crft,
X fmtip(plgn->ln_play));
X output(plogin,'C',0,buf);
X sprintf(buf," '%c'\n",plgn->ln_stat ? plgn->ln_stat : ' ');
X output(plogin,'C',0,buf);
X }
X }
X
X } else if (!strncmp(".obj",s,4)) {
X s += 4;
X for (pobj=objlst;pobj < objlst+MAXOBJ;++pobj) {
X sprintf(buf,"#%-3d %7ld %3d '%c' %s %5d %7ld %3.0f",
X pobj-objlst,pobj->oj_mass,pobj->oj_rad,pobj->oj_rep,
X fmtip(pobj->oj_octr),pobj->oj_oprd,pobj->oj_orad,
X DIV(pobj->oj_ocrpt,DEGTORAD));
X output(plogin,'C',0,buf);
X if (*s) {
X sprintf(buf," %5.1f %5.1f %5.1f %3.0f %3.0f %3.0f",
X pobj->oj_optx,pobj->oj_opty,pobj->oj_optz,
X pobj->oj_vel[0],pobj->oj_vel[1],pobj->oj_vel[2]);
X output(plogin,'C',0,buf);
X }
X output(plogin,'C',0,"\n");
X }
X
X } else if (!strcmp(".torp",s)) {
X for (ptorp=torplst;ptorp < torplst+MAXTORP;++ptorp) {
X if (!ptorp->tp_aim.ip_ptr) continue;
X sprintf(buf,"#%-3d (%8.1e %8.1e %8.1e) (%3.0f %3.0f %3.0f) \
X(%2.0f %2.0f %2.0f) %s",
X ptorp-torplst,ptorp->tp_pstn[0],ptorp->tp_pstn[1],
X ptorp->tp_pstn[2],ptorp->tp_vel[0],ptorp->tp_vel[1],
X ptorp->tp_vel[2],ptorp->tp_thr[0],ptorp->tp_thr[1],
X ptorp->tp_thr[2],fmtip(ptorp->tp_aim));
X output(plogin,'C',0,buf);
X sprintf(buf," %s %ld %d",fmtip(ptorp->tp_fby),ptorp->tp_dist,
X ptorp->tp_dmg);
X output(plogin,'C',0,buf);
X sprintf(buf," %s\n",fmtip(ptorp->tp_lhit));
X output(plogin,'C',0,buf);
X }
X
X } else if (!strcmp(".universe",s)) {
X for (puniv=univlst;puniv < univlst+MAXUNIVERSE;++puniv) {
X if (!puniv->uv_type) continue;
X sprintf(buf,"#%-3d '%c/%c' %8.1e %8.1e %8.1e %7ld %5d",
X puniv-univlst,puniv->uv_type,puniv->uv_pctr,
X puniv->uv_pstn[0],puniv->uv_pstn[1],puniv->uv_pstn[2],
X puniv->uv_mass,puniv->uv_rad);
X output(plogin,'C',0,buf);
X switch(puniv->uv_type) {
X case 'A':
X sprintf(buf," #%-3d\n",puniv->uv_ptr.uv_aln-alnlst);
X break;
X case 'P':
X sprintf(buf," #%-3d\n",puniv->uv_ptr.uv_crft-crftlst);
X break;
X case 'O':
X sprintf(buf," #%-3d\n",puniv->uv_ptr.uv_obj-objlst);
X break;
X case 'T':
X sprintf(buf," #%-3d\n",puniv->uv_ptr.uv_torp-torplst);
X break;
X default:
X strcpy(buf,"\n");
X break;
X }
X output(plogin,'C',0,buf);
X }
X
X } else if (!strncmp(".lock",s,5)) {
X static msg[80+1];
X s += 5;
X while (*s == ' ') ++s;
X strcpy(msg,s);
X prvlck((*s) ? msg : NULL);
X
X } else if (!strcmp(".unlock",s)) {
X prvlck("");
X }
X
X output(plogin,0,0,0);
X#ifdef DEBUG
X VDBG("prvcmd return\n");
X#endif
X}
X
Xstatic char *fmtip(ip)
Xidxptr ip;
X{
X static char buf[16];
X if (ip.ip_ptr)
X sprintf(buf,"#%-3d",ip.ip_ptr-univlst);
X else
X strcpy(buf,"NULL");
X return(buf);
X}
END_OF_prvcmd.c
if test 7159 -ne `wc -c <prvcmd.c`; then
echo shar: \"prvcmd.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f scrn.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"scrn.c\"
else
echo shar: Extracting \"scrn.c\" \(6276 characters\)
sed "s/^X//" >scrn.c <<'END_OF_scrn.c'
X/*
X * Spacewar - (play) screen output stuff
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X#ifndef VMS
X#include <sys/types.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#endif /* VMS */
X#include "universe.h"
X#include "login.h"
X#include "flds.h"
X#include "sys.h"
X#include "crft.h"
X#include "build.h"
X#include "aln.h"
X#include "obj.h"
X#include "torp.h"
X
Xstatic VOID dofld();
Xextern long gametime;
X
XVOID background(pcrft)
Xstruct crft *pcrft;
X{
X static struct {
X char bg_row,bg_col,*bg_str;
X } bg[]={
X {0, 0, "-------DIRECTION-------"},
X {2, 0, "--------POSITION-------"},
X {4, 0, "--------VELOCITY-------"},
X {7, 0, "ANGLE"},
X {7, 6, "---DST---"},
X {7, 16, "SEE"},
X {7, 20, "BAD"},
X {10, 0, "---------HOMING--------"},
X {11, 0, "#1:"},
X {12, 0, "#2:"},
X {13, 0, "#3:"},
X {11, 12, "#4:"},
X {12, 12, "#5:"},
X {13, 12, "#6:"},
X {15, 0, "RADIO:"},
X {0, 59, "SYSTEM"},
X {0, 69, "LEVEL"},
X {0, 75, "%DMG"}
X };
X int i;
X register struct flddesc *pfld;
X
X for (pfld=flds+FLD_BACKGROUND,i=0;i < sizeof(bg)/sizeof(bg[0]);++i) {
X pfld->f_row = bg[i].bg_row;
X pfld->f_col = bg[i].bg_col;
X output(pcrft->cr_lgn,'L',FLD_BACKGROUND,bg[i].bg_str);
X }
X}
X
XVOID nums(pcrft)
Xregister struct crft *pcrft;
X{
X int i,j;
X struct sys *psys;
X
X /* direction */
X dofld(pcrft,FLD_DIR1,0,BIT_DIR1,DIV(pcrft->cr_dir[1],DEGTORAD));
X dofld(pcrft,FLD_DIR2,0,BIT_DIR2,DIV(pcrft->cr_dir[2],DEGTORAD));
X if (pcrft->cr_ffwd)
X dofld(pcrft,FLD_AUTOFFWD,0,BIT_AUTOFFWD,"FFWD");
X else if (pcrft->cr_auto.ip_ptr)
X dofld(pcrft,FLD_AUTOFFWD,0,BIT_AUTOFFWD,"AUTO");
X else
X dofld(pcrft,FLD_AUTOFFWD,0,BIT_AUTOFFWD,"");
X
X /* position */
X dofld(pcrft,FLD_PN1,0,BIT_PN1,pcrft->cr_pstn[0]);
X dofld(pcrft,FLD_PN2,0,BIT_PN2,pcrft->cr_pstn[1]);
X dofld(pcrft,FLD_PN3,0,BIT_PN3,pcrft->cr_pstn[2]);
X
X /* velocity */
X dofld(pcrft,FLD_VEL1,0,BIT_VEL1,pcrft->cr_vel[0]);
X dofld(pcrft,FLD_VEL2,0,BIT_VEL2,pcrft->cr_vel[1]);
X dofld(pcrft,FLD_VEL3,0,BIT_VEL3,pcrft->cr_vel[2]);
X
X /* viewscreen attributes */
X dofld(pcrft,FLD_VANGL,0,BIT_VANGL,DIV(pcrft->cr_vang,DEGTORAD));
X dofld(pcrft,FLD_VDIST,0,BIT_VDIST,pcrft->cr_vdst);
X
X /* sensors */
X dofld(pcrft,FLD_SSEE,0,BIT_SSEE,pcrft->cr_sens[0]);
X dofld(pcrft,FLD_SBAD,0,BIT_SBAD,pcrft->cr_sens[1]);
X
X /* homing */
X for (i=0;i < MHOM;++i)
X if (pcrft->cr_hom[i].ip_ptr)
X dofld(pcrft,FLD_HOMCHAN+i,0,BIT_HOMCHAN+i,pcrft->cr_hdst[i]);
X else {
X char *savfmt;
X struct flddesc *pfld=flds+(FLD_HOMCHAN+i);
X savfmt = pfld->f_fmt;
X pfld->f_fmt = "%-7.7s";
X dofld(pcrft,FLD_HOMCHAN+i,0,BIT_HOMCHAN+i,"");
X pfld->f_fmt = savfmt;
X }
X
X /* subsystems */
X for (j=0,psys=pcrft->cr_sys,i=0;i < MSYS;++psys,++i) {
X if (!psys->s_cap) continue; /* not in this craft */
X dofld(pcrft,FLD_SNAME,i,BIT_SNAME,++j,subsysnam[i]);
X dofld(pcrft,FLD_SLEVEL,i,BIT_SLEVEL,psys->s_lvl);
X dofld(pcrft,FLD_SDMG,i,BIT_SDMG,psys->s_dmg);
X }
X
X /* time */
X output(pcrft->cr_lgn,'H',FLD_TIME,gametime);
X}
X
X/*VARARGS4*/
Xstatic VOID dofld(pcrft,fld,grp,bit,val1,val2,val3,val4)
Xstruct crft *pcrft;
Xint fld,grp,bit;
Xint val1,val2,val3,val4;
X{
X extern int nabit();
X
X bit += grp * flds[fld].f_grpw;
X if (nabit(pcrft->cr_chng,bit)) {
X output(pcrft->cr_lgn,'H',(grp<<8)|fld,val1,val2,val3,val4);
X bitoff(pcrft->cr_chng,bit);
X }
X}
X
XVOID view(pcrft)
Xregister struct crft *pcrft;
X{
X char vnew[15][31],buf[31+1];
X double vdst[15][31],tmpdst,tmpvec[3],hlfvang;
X dsplcmnt tmpdspl;
X long ldst;
X int row,col,savrow,savcol;
X register struct universe *puniv;
X static char vinit[]="\
X@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\
X@@@@@@@@ | @@@@@@@@\
X@@@@@ | @@@@@\
X@@@ | @@@\
X@@ | @@\
X@ | @\
X@ | @\
X@-------------- --------------@\
X@ | @\
X@ | @\
X@@ | @@\
X@@@ | @@@\
X@@@@@ | @@@@@\
X@@@@@@@@ | @@@@@@@@\
X@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\
X";
X
X /* init to 'nothing there' */
X bcopy((char *)vnew,vinit,sizeof(vnew));
X binit((char *)vdst,sizeof(vdst));
X savrow = flds[FLD_VIEWSCREEN].f_row;
X savcol = flds[FLD_VIEWSCREEN].f_col;
X
X /* special case: draw entire viewscreen */
X if (pcrft->cr_scrn[0][0] == NULL) {
X buf[31] = NULL;
X bcopy((char *)pcrft->cr_scrn,vinit,sizeof(pcrft->cr_scrn));
X for (row=0;row < 15;++row) {
X bcopy(buf,pcrft->cr_scrn[row],31);
X flds[FLD_VIEWSCREEN].f_row = savrow + row;
X output(pcrft->cr_lgn,'L',FLD_VIEWSCREEN,buf);
X }
X }
X
X /* every object except own ship */
X for (puniv=univlst;puniv < univlst+MAXUNIVERSE;++puniv) {
X if (!puniv->uv_type) continue;
X if (puniv->uv_ptr.uv_crft == pcrft) continue;
X
X /* translate and rotate to center viewscreen on */
X /* z-axis then see if its within cone of vision */
X /*vdiff(puniv->uv_pstn,pcrft->cr_pstn,tmpvec);*/
X tmpdspl = vdisp(puniv,pcrft->cr_lgn->ln_play.ip_ptr,'v');
X vecmul(/*tmpvec*/tmpdspl.vec,pcrft->cr_rmat,tmpvec);
X rttosp(tmpvec,tmpvec);
X hlfvang = DIV(pcrft->cr_vang,2.);
X if (SUB(hlfvang,tmpvec[2]) >= 0.) {
X
X /* determine where it shows on viewscreen */
X /* closer object wins if they coincide */
X tmpdst = tmpvec[0];
X if (tmpdst == 0.) tmpdst = -1.;
X tmpvec[0] = DIV(tmpvec[2],hlfvang);
X tmpvec[2] = DIV(PI,2.);
X sptort(tmpvec,tmpvec);
X row = INT(MUL(tmpvec[1],7.)) + 7;
X col = INT(MUL(tmpvec[0],15.)) + 15;
X if (vdst[row][col] == 0. || SUB(vdst[row][col],tmpdst) > 0.) {
X vdst[row][col] = tmpdst;
X ldst = INT(tmpdst);
X if (ldst <= pcrft->cr_vdst)
X vnew[row][col] = puniv->uv_pctr;
X else if (ldst <= 5000)
X vnew[row][col] = '.';
X else
X vdst[row][col] = 0.;
X }
X }
X }
X
X /* correct actual viewscreen (only put out differences) */
X buf[1] = NULL;
X for (row=0;row < 15;++row) {
X for (col=0;col < 31;++col) {
X if (pcrft->cr_scrn[row][col] != vnew[row][col]) {
X flds[FLD_VIEWSCREEN].f_row = savrow + row;
X flds[FLD_VIEWSCREEN].f_col = savcol + col;
X buf[0] = pcrft->cr_scrn[row][col] = vnew[row][col];
X output(pcrft->cr_lgn,(vdst[row][col] <= 0.) ? 'L' : 'H',
X FLD_VIEWSCREEN,buf);
X }
X }
X }
X
X flds[FLD_VIEWSCREEN].f_row = savrow;
X flds[FLD_VIEWSCREEN].f_col = savcol;
X}
END_OF_scrn.c
if test 6276 -ne `wc -c <scrn.c`; then
echo shar: \"scrn.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f see.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"see.c\"
else
echo shar: Extracting \"see.c\" \(7080 characters\)
sed "s/^X//" >see.c <<'END_OF_see.c'
X/*
X * Spacewar - let users see the standings
X * shows crafts in dbm(3) order, then
X * shows players and their standings in dbm(3) order
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#ifndef VMS
X#include <sys/types.h>
X#include <dbm.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#include "dbm.h"
X#endif /* VMS */
X#include "spacewar.h"
X#include "universe.h"
X#include "login.h"
X#include "sys.h"
X#include "crft.h"
X#include "plyr.h"
X
Xstruct sstat {
X char ss_stat; /* C(raft) or P(layer) */
X char ss_savkey[32]; /* for nextkey(dbm); kludge */
X int ss_savsiz; /* for nextkey(dbm); kludge */
X struct pst *ss_lst; /* list of player statistics */
X};
Xstruct pst {
X struct pst *ps_nxt; /* next player */
X char ps_name[8+1]; /* player's name */
X long ps_tpnts,ps_mpnts; /* total,max points */
X time_t ps_ttm,ps_mtm; /* total,max time */
X short ps_tkls,ps_mkls; /* total,max kills */
X short ps_opnts,ps_otm,ps_okls;/* ordering for points, time, kills */
X short ps_ncrfts; /* number of crafts (for avg) */
X};
Xstatic struct pst zpst;
X
Xchar *malloc();
X
X
XVOID see(plogin)
Xregister struct login *plogin;
X{
X struct sstat *psstat;
X register struct pst *ppst;
X struct pst *nxtpst;
X int nlines=6,nc;
X char buf[80+1];
X datum dbmkey,dbmdata;
X struct crftkey getcrkey;
X struct crft getcrdat;
X struct plyrkey getplkey;
X struct plyr getpldat;
X
X
X#ifdef DEBUG
X DBG("see(#%d/%s)\n",plogin-loginlst,plogin->ln_name);
X#endif
X
X /**************/
X /* first time */
X /**************/
X if (!(psstat = (struct sstat *)plogin->ln_substat)) {
X
X /* allocate and init subtask status structure */
X if (!(psstat = (struct sstat *)malloc(sizeof(struct sstat)))) {
X perror("see: out of memory for sstat");
X goto done;
X }
X binit((char *)psstat,sizeof(*psstat));
X psstat->ss_stat = CRAFT;
X plogin->ln_substat = (char *)psstat;
X
X sprintf(buf,"Output is in groups of %d lines. ",nlines);
X output(plogin,'C',0,buf);
X output(plogin,'C',0,"Hit return when ready for more.\n");
X output(plogin,'C',0,
X "A single dot (.) on a line by itself terminates See.\n\n");
X plogin->ln_iomode = 'm';
X dbmkey = firstkey();
X
X /****************/
X /* continuation */
X /****************/
X } else {
X dbmkey.dptr = ((dbmkey.dsize = psstat->ss_savsiz) > 0) ?
X psstat->ss_savkey : NULL;
X }
X
X#ifdef DEBUG
X VDBG("see: stat '%c'\n",psstat->ss_stat);
X#endif
X
X /* terminate */
X if (!strcmp(plogin->ln_input,".")) goto done; /* horrendous */
X
X /*********************************************************/
X /* keep getting and displaying the current_state records */
X /*********************************************************/
Xagain: while (dbmkey.dptr) {
X if (dbmkey.dptr[0] == CRAFT && psstat->ss_stat == CRAFT) {
X
X bcopy((char *)&getcrkey,dbmkey.dptr,sizeof(getcrkey));
X dbmdata = fetch(dbmkey);
X if (!dbmdata.dptr) {
X perror("see: can't fetch craft");
X goto done;
X }
X bcopy((char *)&getcrdat,dbmdata.dptr,dbmdata.dsize);
X
X /* find/create player statistics structure */
X for (ppst=psstat->ss_lst;ppst;ppst=ppst->ps_nxt)
X if (!strcmp(ppst->ps_name,getcrkey.cr_plyr))
X break;
X if (!ppst) {
X if (!(ppst = (struct pst *)malloc(sizeof(struct pst)))) {
X perror("see: out of memory for pst");
X goto done;
X }
X binit((char *)ppst,sizeof(*ppst));
X ppst->ps_nxt = psstat->ss_lst;
X psstat->ss_lst = ppst;
X strcpy(ppst->ps_name,getcrkey.cr_plyr);
X }
X
X /* accumulate statistics */
X ppst->ps_tpnts += getcrdat.cr_pnts;
X ppst->ps_ttm += getcrdat.cr_time;
X ppst->ps_tkls += getcrdat.cr_kill;
X if (getcrdat.cr_pnts > ppst->ps_mpnts)
X ppst->ps_mpnts = getcrdat.cr_pnts;
X if (getcrdat.cr_time > ppst->ps_mtm)
X ppst->ps_mtm = getcrdat.cr_time;
X if (getcrdat.cr_kill > ppst->ps_mkls)
X ppst->ps_mkls = getcrdat.cr_kill;
X ppst->ps_ncrfts += 1;
X
X /* show */
X sprintf(buf,"%-8s %-12s %14ld %14ld %8d\n",
X getcrkey.cr_plyr,getcrkey.cr_name,getcrdat.cr_pnts,
X getcrdat.cr_time,getcrdat.cr_kill);
X output(plogin,'C',0,buf);
X nlines -= 1;
X
X } else if (dbmkey.dptr[0] == PLYR && psstat->ss_stat == PLYR) {
X
X bcopy((char *)&getplkey,dbmkey.dptr,sizeof(getplkey));
X dbmdata = fetch(dbmkey);
X if (!dbmdata.dptr) {
X perror("see: can't fetch plyr");
X goto done;
X }
X bcopy((char *)&getpldat,dbmdata.dptr,sizeof(getpldat));
X
X /* find player statistics structure */
X for (ppst=psstat->ss_lst;ppst;ppst=ppst->ps_nxt)
X if (!strcmp(ppst->ps_name,getplkey.pl_name))
X break;
X if (!ppst)
X ppst = &zpst;
X
X /* show */
X if (!(nc = ppst->ps_ncrfts)) nc = 1;
X sprintf(buf,
X "\n%-8s %12d %5ld/%5ld/%2d %5ld/%5ld/%2d %2d/%2d/%2d\n",
X getplkey.pl_name,ppst->ps_ncrfts,
X ppst->ps_tpnts/nc,ppst->ps_mpnts,ppst->ps_opnts,
X ppst->ps_ttm/nc,ppst->ps_mtm,ppst->ps_otm,
X ppst->ps_tkls/nc,ppst->ps_mkls,ppst->ps_okls);
X output(plogin,'C',0,buf);
X sprintf(buf,"%8s (%10d) (%12ld) (%12ld) (%6d)\n","",
X getpldat.pl_slst,getpldat.pl_plst,getpldat.pl_tlst,
X getpldat.pl_klst);
X output(plogin,'C',0,buf);
X nlines -= 3;
X }
X dbmkey = nextkey(dbmkey);
X
X /* if output linecount reached, save state */
X if (nlines <= 0) {
X output(plogin,0,0,0);
X psstat->ss_savsiz = (dbmkey.dptr) ? dbmkey.dsize : 0;
X bcopy(psstat->ss_savkey,dbmkey.dptr,psstat->ss_savsiz);
X#ifdef DEBUG
X VDBG("see return\n");
X#endif
X return;
X }
X }
X
X /*************************************************/
X /* no more dbm records, (possibly) switch states */
X /*************************************************/
X if (psstat->ss_stat == CRAFT) {
X
X /* reset state */
X psstat->ss_stat = PLYR;
X dbmkey = firstkey();
X
X /*************************************************************/
X /* compute player's ordering for each of points, time, kills */
X /*************************************************************/
X nc = 0;
X do {
X for (nxtpst=NULL,ppst=psstat->ss_lst;ppst;ppst=ppst->ps_nxt) {
X if (!ppst->ps_opnts)
X if (!nxtpst || ppst->ps_mpnts > nxtpst->ps_mpnts)
X nxtpst = ppst;
X }
X if (nxtpst)
X nxtpst->ps_opnts = ++nc;
X } while (nxtpst);
X nc = 0;
X do {
X for (nxtpst=NULL,ppst=psstat->ss_lst;ppst;ppst=ppst->ps_nxt) {
X if (!ppst->ps_otm)
X if (!nxtpst || ppst->ps_mtm > nxtpst->ps_mtm)
X nxtpst = ppst;
X }
X if (nxtpst)
X nxtpst->ps_otm = ++nc;
X } while (nxtpst);
X nc = 0;
X do {
X for (nxtpst=NULL,ppst=psstat->ss_lst;ppst;ppst=ppst->ps_nxt) {
X if (!ppst->ps_okls)
X if (!nxtpst || ppst->ps_mkls > nxtpst->ps_mkls)
X nxtpst = ppst;
X }
X if (nxtpst)
X nxtpst->ps_okls = ++nc;
X } while (nxtpst);
X
X goto again; /* horrendous */
X }
X
X /*************************************/
X /* cleanup - free up allocated space */
X /*************************************/
Xdone: for (nxtpst=ppst=psstat->ss_lst;ppst;ppst=nxtpst) {
X nxtpst = nxtpst->ps_nxt;
X free((char *)ppst);
X }
X free((char *)psstat);
X plogin->ln_iomode = NULL;
X plogin->ln_stat = NULL;
X plogin->ln_substat = NULL;
X output(plogin,'C',0,PROMPT);
X output(plogin,0,0,0);
X
X#ifdef DEBUG
X VDBG("see return\n");
X#endif
X}
END_OF_see.c
if test 7080 -ne `wc -c <see.c`; then
echo shar: \"see.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f updaln.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"updaln.c\"
else
echo shar: Extracting \"updaln.c\" \(5782 characters\)
sed "s/^X//" >updaln.c <<'END_OF_updaln.c'
X/*
X * Spacewar - alien intelligence
X * thrust toward and attack
X * find a player to attack/randomly de-assign
X * if not attacking, randomly thrust toward objects
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X#ifndef VMS
X#include <sys/types.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#endif /* VMS */
X#include "universe.h"
X#include "sys.h"
X#include "aln.h"
X#include "build.h"
X#include "flds.h"
X#include "login.h"
X#include "crft.h"
X#include "torp.h"
X#include "obj.h"
X
Xstatic VOID thr(paln,tmpvec)
Xstruct aln *paln;
Xdouble *tmpvec;
X{
X rttosp(tmpvec,tmpvec);
X tmpvec[0] = FLOAT(RANDOM(50)+20);
X sptort(tmpvec,tmpvec);
X vdiff(tmpvec,paln->al_vel,paln->al_thr);
X}
X
XVOID updaln()
X{
X register struct aln *paln;
X struct sys *psys;
X register struct universe *puniv;
X double vdist(),ftmp,tmpvec[3];
X long l;
X int i;
X dsplcmnt tmpdspl;
X
X#ifdef DEBUG
X DBG("updaln()\n");
X#endif
X
X for (paln=alnlst+MAXALN;paln-- > alnlst;paln->al_dly -= 1) {
X psys = paln->al_sys;
X if (paln->al_atck.ip_ptr) {
X /*ftmp = vdist(paln->al_atck.ip_ptr->uv_pstn,paln->al_pstn);*/
X tmpdspl = vdisp(paln->al_atck.ip_ptr,paln->al_univ.ip_ptr,'d');
X ftmp = tmpdspl.dst;
X }
X
X /* not attacking or delaying or no energy+phasers to attack with */
X if (!paln->al_atck.ip_ptr || paln->al_dly > 0 ||
X !psys[DILITH].s_cap || !psys[PHASERS].s_cap)
X goto noatck;
X
X /* too far away to attack; less chance if closer */
X if (SUB(ftmp,2500.) > 0.)
X goto noatck;
X if (RANDOM(100) > 15 + INT(ftmp)/25)
X goto noatck;
X
X /* attack and set delay */
X if ((l = INT(ftmp)/(RANDOM(50)+1)) > 100L)
X l = 100L;
X if (paln->al_aeval > 500)
X l += paln->al_aeval/20;
X if (l > psys[DILITH].s_lvl && psys[DILITH].s_lvl < 50)
X goto noatck;
X if (l > psys[DILITH].s_lvl)
X l = psys[DILITH].s_lvl;
X psys[DILITH].s_lvl -= l;
X l *= psys[PHASERS].s_pct;
X l /= 100L;
X l *= 100L - psys[PHASERS].s_dmg;
X l /= 100L;
X l *= psys[PHASERS].s_cap;
X l /= 100L;
X /*for (puniv=univlst+MAXUNIVERSE;puniv-- > univlst;)
X if (puniv->uv_type == 'A' && puniv->uv_ptr.uv_aln == paln)
X damage(puniv,paln->al_atck.ip_ptr,1.,FLOAT(l),
X "Phaser attack");
X */
X damage(paln->al_univ.ip_ptr,paln->al_atck.ip_ptr,1.,FLOAT(l),
X "Phaser attack");
X paln->al_dly = 3;
Xnoatck:
X
X /* find an attackee */
X if (paln->al_atck.ip_ptr)
X ;
X else if (RANDOM(100) < 10) { /* find a close one */
X for (puniv=univlst+MAXUNIVERSE;puniv-- > univlst;)
X if (puniv->uv_type == 'P' &&
X !puniv->uv_ptr.uv_crft->cr_dock.ip_ptr) {
X tmpdspl = vdisp(paln->al_univ.ip_ptr,puniv,'d');
X if (SUB(tmpdspl.dst,500.) < 0.) {
X paln->al_atck.ip_ptr = puniv;
X paln->al_dly = 50;
X ftmp = tmpdspl.dst;
X break;
X }
X }
X } else if (RANDOM(100) > 90) { /* choose a random one */
X puniv = univlst + RANDOM(MAXUNIVERSE-MAXOBJ) + MAXOBJ;
X if (puniv->uv_type == 'P' &&
X !puniv->uv_ptr.uv_crft->cr_dock.ip_ptr) {
X paln->al_atck.ip_ptr = puniv;
X paln->al_dly = 50;
X /*ftmp = vdist(puniv->uv_pstn,paln->al_pstn);*/
X tmpdspl = vdisp(puniv,paln->al_univ.ip_ptr,'d');
X ftmp = tmpdspl.dst;
X }
X }
X
X /* randomly de-assign; decreasing probability based on aeval */
X if (paln->al_atck.ip_ptr &&
X RANDOM(5000) < 500 - paln->al_aeval)
X paln->al_atck.ip_ptr = NULL;
X if (paln->al_aeval > 0)
X paln->al_aeval -= 1; /* decay of evaluation (lose interest) */
X
X /* get closer to attackee by warping */
X if (paln->al_atck.ip_ptr && psys[WARP].s_cap &&
X (l=500L+15L*INT(SQRT(ftmp))) > 1170L && psys[WARP].s_lvl >= l) {
X psys[WARP].s_lvl -= l;
X paln->al_dly = 5;
X for (i=0;i<3;++i)
X paln->al_pstn[i] = ADD(paln->al_atck.ip_ptr->uv_pstn[i],
X FLOAT(RANDOM(600) - 300));
X vchngd(paln->al_univ.ip_ptr);
X for (puniv=univlst+MAXUNIVERSE;puniv-- > univlst;) {
X register struct crft *pcrft;
X if (puniv->uv_type != 'P') continue;
X pcrft = puniv->uv_ptr.uv_crft;
X if (pcrft->cr_auto.ip_ptr &&
X pcrft->cr_auto.ip_ptr->uv_type == 'A' &&
X pcrft->cr_auto.ip_ptr->uv_ptr.uv_aln == paln) {
X pcrft->cr_auto.ip_ptr = NULL;
X biton(pcrft->cr_chng,BIT_AUTOFFWD);
X }
X if (pcrft->cr_dock.ip_ptr &&
X pcrft->cr_dock.ip_ptr->uv_type == 'A' &&
X pcrft->cr_auto.ip_ptr->uv_ptr.uv_aln == paln) {
X pcrft->cr_dock.ip_ptr = NULL;
X pcrft->cr_scrn[7][15] = '?';
X }
X }
X }
X
X /* compute thrust */
X /* not attacking, go toward an object */
X if (!paln->al_atck.ip_ptr && paln->al_dly <= 0) {
X puniv = univlst + RANDOM(MAXOBJ);
X /*vdiff(puniv->uv_pstn,paln->al_pstn,tmpvec);*/
X tmpdspl = vdisp(puniv,paln->al_univ.ip_ptr,'v');
X thr(paln,/*tmpvec*/tmpdspl.vec);
X paln->al_dly = 200;
X
X /* attacking, go toward attackee */
X } else if (paln->al_atck.ip_ptr) {
X
X if (paln->al_dly < -60) { /* long wait ==> break off */
X /*vdiff(paln->al_pstn,paln->al_atck.ip_ptr->uv_pstn,tmpvec);*/
X tmpdspl = vdisp(paln->al_univ.ip_ptr,paln->al_atck.ip_ptr,'v');
X thr(paln,/*tmpvec*/tmpdspl.vec);
X paln->al_dly = 20;
X paln->al_atck.ip_ptr = NULL;
X } else {
X /*ftmp = vdist(paln->al_pstn,paln->al_atck.ip_ptr->uv_pstn);*/
X tmpdspl = vdisp(paln->al_univ.ip_ptr,paln->al_atck.ip_ptr,'d');
X ftmp = tmpdspl.dst;
X for (i=0;i<3;++i)
X tmpvec[i] = ADD(paln->al_pstn[i],paln->al_vel[i]);
X ftmp = SUB(ftmp,vdist(tmpvec,paln->al_atck.ip_ptr->uv_pstn));
X if (ftmp <= 0.) { /* getting further away */
X /*vdiff(paln->al_atck.ip_ptr->uv_pstn,paln->al_pstn,tmpvec);*/
X tmpdspl = vdisp(paln->al_atck.ip_ptr,paln->al_univ.ip_ptr,'v');
X thr(paln,/*tmpvec*/tmpdspl.vec);
X }
X }
X }
X }
X
X#ifdef DEBUG
X VDBG("updaln return\n");
X#endif
X}
END_OF_updaln.c
if test 5782 -ne `wc -c <updaln.c`; then
echo shar: \"updaln.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f updmov.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"updmov.c\"
else
echo shar: Extracting \"updmov.c\" \(7076 characters\)
sed "s/^X//" >updmov.c <<'END_OF_updmov.c'
X/*
X * Spacewar - updates movement of non-objects
X * from rocket thrust
X * from gravity
X * checks and carries out crashing into objects
X * docked crfts are updated
X *
X * Copyright 1985 obo Systems, Inc.
X * Copyright 1985 Dan Rosenblatt
X */
X
X#include "spacewar.h"
X#ifndef VMS
X#include <sys/types.h>
X#else /* BSD SYSIII SYSV */
X#include <types.h>
X#endif /* VMS */
X#include "universe.h"
X#include "sys.h"
X#include "login.h"
X#include "obj.h"
X#include "crft.h"
X#include "aln.h"
X#include "torp.h"
X#include "build.h"
X#include "flds.h"
X
Xextern double vlen();
X
XVOID updmov()
X{
X register struct universe *puniv,*pobj;
X register struct sys *psys;
X double *ppstn,*pvel,*pthr;
X double accel[3],ftmp,tmpvec[3];
X char *pchng;
X long l,m,sub;
X register int i;
X dsplcmnt tmpdspl;
X
X#ifdef DEBUG
X DBG("updmov()\n");
X#endif
X
X for (puniv=univlst+MAXUNIVERSE;puniv-- > univlst;) {
X
X /**********/
X /* set up */
X /**********/
X ppstn = puniv->uv_pstn;
X sub = 0L;
X switch(puniv->uv_type) {
X case 'A':
X pvel = puniv->uv_ptr.uv_aln->al_vel;
X pthr = puniv->uv_ptr.uv_aln->al_thr;
X psys = puniv->uv_ptr.uv_aln->al_sys;
X pchng = NULL;
X break;
X case 'P':
X if (puniv->uv_ptr.uv_crft->cr_dock.ip_ptr) continue;
X pvel = puniv->uv_ptr.uv_crft->cr_vel;
X pthr = puniv->uv_ptr.uv_crft->cr_thr;
X psys = puniv->uv_ptr.uv_crft->cr_sys;
X pchng = puniv->uv_ptr.uv_crft->cr_chng;
X break;
X case 'T':
X pvel = puniv->uv_ptr.uv_torp->tp_vel;
X pthr = puniv->uv_ptr.uv_torp->tp_thr;
X psys = NULL;
X pchng = NULL;
X break;
X default:
X continue;
X }
X
X /***********************************/
X /* acceleration from rocket thrust */
X /***********************************/
X rttosp(pthr,accel);
X if (accel[0] != 0.) {
X l = INT(accel[0]);
X
X /* limited by how much fuel is available and maximum */
X /* acceleration (reduced by damage to rockets) */
X if (psys && psys[ROCKETS].s_cap) {
X if (l > psys[ROCKETS].s_lvl) {
X sub += l - psys[ROCKETS].s_lvl;
X l = psys[ROCKETS].s_lvl;
X }
X m = psys[ROCKETS].s_cap;
X m *= 100L - psys[ROCKETS].s_dmg;
X m /= 100L;
X if (l > m) {
X sub += l - m;
X l = m;
X }
X }
X
X /* limited by maximum hull acceleration */
X if (psys && l > psys[HULL].s_cap) {
X sub += l - psys[HULL].s_cap;
X l = psys[HULL].s_cap;
X } else if (puniv->uv_type == 'T' && l > MAXTTHR) {
X sub += l - MAXTTHR;
X l = MAXTTHR;
X }
X
X /* reduce fuel (only for Players) */
X if (l && psys && psys[ROCKETS].s_cap) {
X if (pchng) {
X psys[ROCKETS].s_lvl -= l;
X biton(pchng,BIT_SLEVEL+ROCKETS*flds[FLD_SLEVEL].f_grpw);
X }
X }
X
X /* reduce thrust */
X accel[0] = SUB(accel[0],FLOAT(sub));
X sptort(accel,accel);
X for (i=0;i<3;++i) {
X pthr[i] = SUB(pthr[i],accel[i]);
X
X /* close enough to zero to be zero */
X if ((ftmp=pthr[i]) < 0.) ftmp = NEG(ftmp);
X if (SUB(ftmp,1.) < 0.) pthr[i] = 0.;
X }
X }
X
X /*****************************/
X /* acceleration from gravity */
X /*****************************/
X if (!pchng || !puniv->uv_ptr.uv_crft->cr_plvl)
X for (pobj=univlst+MAXOBJ;pobj-- > univlst;) {
X
X /* vector and distance to object */
X /*vdiff(pobj->uv_pstn,ppstn,tmpvec);*/
X /*ftmp = vlen(tmpvec);*/
X tmpdspl = vdisp(pobj,puniv,'b');
X ftmp = tmpdspl.dst;
X
X /* crash */
X if ((l = INT(ftmp)) < 2*(pobj->uv_rad+1)) {
X struct crft *pcrft;
X if (puniv->uv_type == 'T') {
X if (puniv->uv_ptr.uv_torp->tp_fby.ip_ptr &&
X puniv->uv_ptr.uv_torp->
X tp_fby.ip_ptr->uv_type == 'P') {
X setrpt(pcrft=puniv->uv_ptr.uv_torp->
X tp_fby.ip_ptr->uv_ptr.uv_crft);
X output(pcrft->cr_lgn,'B',0,0);
X rpt(pcrft,"Your torpedo crashed");
X fnshrpt(pcrft,1);
X }
X if (puniv->uv_ptr.uv_torp->tp_lhit.ip_ptr &&
X puniv->uv_ptr.uv_torp->
X tp_lhit.ip_ptr->uv_type == 'P') {
X setrpt(pcrft=puniv->uv_ptr.uv_torp->
X tp_lhit.ip_ptr->uv_ptr.uv_crft);
X output(pcrft->cr_lgn,'B',0,0);
X rpt(pcrft,"Torpedo destroyed by you (crashed)");
X fnshrpt(pcrft,1);
X }
X } else if (puniv->uv_type == 'A') {
X if (puniv->uv_ptr.uv_aln->al_lhit.ip_ptr &&
X puniv->uv_ptr.uv_aln->
X al_lhit.ip_ptr->uv_type == 'P') {
X setrpt(pcrft=puniv->uv_ptr.uv_aln->
X al_lhit.ip_ptr->uv_ptr.uv_crft);
X output(pcrft->cr_lgn,'B',0,0);
X rpt(pcrft,"Alien destroyed by you (crashed)");
X fnshrpt(pcrft,1);
X }
X }
X if (pchng) {
X struct login *plgn;
X pcrft = puniv->uv_ptr.uv_crft;
X pcrft->cr_dock.ip_ptr = NULL; /* assure destruc. */
X pcrft->cr_sens[1] = 1; /* assure destruction */
X unplay(plgn=pcrft->cr_lgn);
X output(plgn,'B',0,0);
X output(plgn,'E',0,0);
X output(plgn,'C',0,"You have crashed");
X output(plgn,'C',0,PROMPT);
X output(plgn,0,0,0);
X } else {
X idxptr prmv;
X prmv.ip_ptr = puniv;
X remove(prmv);
X }
X goto nxtuobj;
X }
X
X /* acceleration from gravity */
X if (l < 250L) { /* cube root of 10*greatest_mass_object */
X ftmp = CUBE(ftmp);
X for (i=0;i<3;++i)
X accel[i] = ADD(accel[i],
X DIV(MUL(pobj->uv_mass,tmpdspl.vec[i]),ftmp));
X }
X }
X
X /* show acceleration if Player */
X if (pchng)
X if ((l=INT(vlen(accel))) != psys[HULL].s_lvl) {
X psys[HULL].s_lvl = l;
X biton(pchng,BIT_SLEVEL+HULL*flds[FLD_SLEVEL].f_grpw);
X }
X
X /*******************************************/
X /* position and velocity from acceleration */
X /*******************************************/
X for (i=0;i<3;++i) {
X
X /* close enough to zero to be zero */
X if ((ftmp=accel[i]) < 0.) ftmp = NEG(ftmp);
X if (SUB(ftmp,.1) < 0.) accel[i] = 0.;
X
X ftmp = ADD(ADD(ppstn[i],pvel[i]),DIV(accel[i],2.));
X if (pchng && INT(ftmp) != INT(ppstn[i]))
X biton(pchng,BIT_PN1+i);
X ppstn[i] = ftmp;
X
X ftmp = ADD(pvel[i],accel[i]);
X if (pchng && INT(MUL(ftmp,50.)) != INT(MUL(pvel[i],50.)))
X biton(pchng,BIT_VEL1+i);
X pvel[i] = ftmp;
X
X /* close enough to zero to be zero */
X if (ftmp < 0.) ftmp = NEG(ftmp);
X if (SUB(ftmp,.1) < 0.) pvel[i] = 0.;
X }
X vchngd(puniv);
Xnxtuobj:;
X }
X
X /**********/
X /* docked */
X /**********/
X for (puniv=univlst+MAXUNIVERSE;puniv-- > univlst;) {
X if (puniv->uv_type != 'P') continue;
X pvel = puniv->uv_ptr.uv_crft->cr_vel;
X if (pobj = puniv->uv_ptr.uv_crft->cr_dock.ip_ptr) {
X /*vdiff(pobj->uv_pstn,puniv->uv_pstn,tmpvec);*/
X tmpdspl = vdisp(pobj,puniv,'v');
X vcopy(tmpvec,tmpdspl.vec);
X for (i=0;i<3;++i) {
X
X /* close enough to zero to be zero */
X if ((ftmp=tmpvec[i]) < 0.) ftmp = NEG(ftmp);
X if (SUB(ftmp,.1) < 0.) tmpvec[i] = 0.;
X
X if (INT(MUL(tmpvec[i],50.)) != INT(MUL(pvel[i],50.)))
X biton(puniv->uv_ptr.uv_crft->cr_chng,BIT_VEL1+i);
X pvel[i] = tmpvec[i];
X
X if (INT(pobj->uv_pstn[i]) != INT(puniv->uv_pstn[i]))
X biton(puniv->uv_ptr.uv_crft->cr_chng,BIT_PN1+i);
X puniv->uv_pstn[i] = pobj->uv_pstn[i];
X }
X vchngd(puniv);
X }
X }
X
X#ifdef DEBUG
X VDBG("updmov return\n");
X#endif
X}
END_OF_updmov.c
if test 7076 -ne `wc -c <updmov.c`; then
echo shar: \"updmov.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 3 \(of 6\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 4 5 6 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 6 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0