LOTS OF SHIT

16 files changed, 1688 insertions, 0 deletions

diff --git a/tests/automata b/tests/automata
new file mode 100755
index 0000000..7cec568
--- /dev/null
+++ b/tests/automata
diff --git a/tests/automata.c b/tests/automata.c
new file mode 100644
index 0000000..35629e0
--- /dev/null
+++ b/tests/automata.c
@@ -0,0 +1,453 @@
+#include <fcntl.h>
+#include <assert.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#define __USE_GNU //for longer math constants
+#include <math.h>
+
+//#define DEBUG
+
+#define SPLIT_SCREEN 2
+#define CAMERA_SEPARATION 3
+
+#define DEPTH_FACTOR 0.965
+
+#define TRIANGLES 256
+
+#define min(a,b) (((a)<(b))?(a):(b))
+#define max(a,b) (((a)>(b))?(a):(b))
+
+//for one camera, not the whole thing.
+//3 camera
+//#define WIDTH 320
+//#define HEIGHT 240
+//1 camera
+//#define WIDTH 800
+//#define HEIGHT 600
+//2 camera
+#define WIDTH 400
+#define HEIGHT 300
+
+struct object_1 {
+ int type;
+ unsigned char x;
+ unsigned char y;
+ unsigned char z;
+};
+
+struct object_2 {
+ int type;
+ unsigned short x;
+ unsigned short y;
+ unsigned short z;
+};
+
+struct object_4 {
+ int type;
+ unsigned int x;
+ unsigned int y;
+ unsigned int z;
+};
+
+struct camera {
+  int x;
+  int y;
+  int z;
+  int xr;//rotations
+  int yr;
+  int zr;
+} camera;
+
+struct triangle {//use array or linked list?
+  char *id;
+  int x1;
+  int y1;
+  int z1;
+  int x2;
+  int y2;
+  int z2;
+  int x3;
+  int y3;
+  int z3;
+//  int dist;//most recent distance calculated from the camera
+};
+
+struct mainwin {
+  int x;
+  int y;
+  int depth;
+  int mousex;
+  int mousey;
+  int rmousex;
+  int rmousey;
+  int buttonpressed;
+  int width;
+  int height;
+  int border_width;
+  int xoff;
+  int math_error;
+  char *user;
+  XColor green;
+  Colormap color_map;
+  Display *dpy;
+  Window w;
+  GC gc;
+  struct triangle *triangle[TRIANGLES];
+} global;
+
+
+float zmagic(int z) {
+ float tmp=pow(DEPTH_FACTOR,(camera.z-z));
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z))/(camera.z-z);
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z)*(camera.z-z)*(camera.z-z));
+ //measure the distance form the camera and error out if it is too far away.
+// if((camera.z - z) >= 0) return(global.math_error=1);
+ //return (float)1 / (float)(camera.z - z);
+ return tmp;
+}
+
+int to2D(int cw,int w,int z,int d) {
+  return (d/2) - (((w-cw) / zmagic(z)) * 16 );
+}
+
+
+float distance(int x1,int y1,int x2,int y2) {
+ return sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1)));
+}
+
+long double d2r(int d) {
+ while(d<0) d+=360;
+ return (long double)(d%360) / 180.0l * M_PIl;
+}
+
+int rotateXabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return x2;
+ return x2 + radius * cosl(acosl(((long double)x2-(long double)x1)/radius)+radians);
+}
+
+int rotateZabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return z2;
+ return z2 + radius * sinl(asinl(((long double)z2-(long double)z1)/radius)+radians);
+}
+
+
+int to2Dx(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.xr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.x,newx,newz,global.width/SPLIT_SCREEN);
+//  return to2D(camera.x,x,z,global.width/SPLIT_SCREEN);
+}
+
+int to2Dy(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.y,newy,newz,global.height);
+//  return to2D(camera.y,y,z,global.height);
+}
+
+void XDrawTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
+ int x;
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+}
+
+void XDrawFilledTriangle(int x1,int y1,int x2,int y2,int x3,int y3,int density) {
+ int x,y;
+ int b;
+ float m;
+
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+
+ m=(float)(y1-y2)/(float)(x1-x2);
+ b=y1-(m*x1);
+ for(x=min(x1,x2);x<max(x1,x2);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x3,y3,x,y);
+ }
+
+ m=(float)(y2-y3)/(float)(x2-x3);
+ b=y2-(m*x2);
+ for(x=min(x2,x3);x<max(x2,x3);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x1,y1,x,y);
+ }
+
+ m=(float)(y3-y1)/(float)(x3-x1);
+ b=y3-(m*x3);
+ for(x=min(x3,x1);x<max(x3,x1);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x2,y2,x,y);
+ }
+}
+
+void draw3Dtriangle(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3) {
+  char coords[256];
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  //draw string...
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  int tx3=to2Dx(x3,y3,z3);
+  int ty3=to2Dy(x3,y3,z3);
+  if(!global.math_error) {
+#ifdef DEBUG
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x1,y1,z1);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x2,y2,z2);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx2,ty2,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x3,y3,z3);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx3,ty3,coords,strlen(coords));
+#endif
+    XDrawTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+//    XDrawFilledTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+  }
+}
+
+void draw3Dline(int x1,int y1,int z1,int x2,int y2,int z2) {
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  if(!global.math_error) {
+    XDrawLine(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,global.xoff+tx2,ty2);
+  }
+  global.math_error=0;
+}
+
+
+//is basing this all on triangles best, or should I use polygons?
+//void pushTriangle(x1,y1,z1,1) {
+//  for(i=0;global.triangle[i];i++);
+//  global.triangle[i]=malloc(sizeof(struct triangle));
+//  global.triangle[i]->x1=x1;
+//}
+//void pushSquare() {
+//  pushTriangle();
+//  pushTriangle();
+//}
+
+void drawCube(int x,int y,int z,int i) {
+//this is just drawing the cube.
+    draw3Dline(x,y,z,x,y,z+i);
+    draw3Dline(x,y,z,x,y+i,z);
+    draw3Dline(x,y,z,x+i,y,z);
+
+    draw3Dline(x+i,y+i,z+0,x+i,y+0,z+0);
+    draw3Dline(x+i,y+i,z+0,x+0,y+i,z+0);
+
+    draw3Dline(x+0,y+i,z+i,x+0,y+i,z+0);
+    draw3Dline(x+0,y+i,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+0,z+i,x+i,y+0,z+0);
+    draw3Dline(x+i,y+0,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+i,z+i,x+i,y+i,z+0);
+    draw3Dline(x+i,y+i,z+i,x+i,y+0,z+i);
+    draw3Dline(x+i,y+i,z+i,x+0,y+i,z+i);
+}
+
+int applyrule(int a,int b,int c,int rule) {
+ return (rule >> ((!!a<<2) | (!!b<<1) | (!!c)) ) % 2;
+}
+
+char field[HEIGHT+1][WIDTH+1];
+
+void draw_screen(Display *dpy,Window w,GC gc) {
+  int i,j,k;
+  int cn=0;//camera number.
+  char **files;
+  static int offset=0;
+  XFontStruct *font=XLoadQueryFont(dpy,"fixed");
+  XCharStruct overall;
+  int direction,ascent,descent;
+  char coords[256];
+  int x,y,z,x1,y1,x2,y2;
+  XEvent e;
+  XClearWindow(dpy, w);
+
+  j=0;
+  for(i=0;i<HEIGHT;i++) {
+   for(j=0;j<WIDTH;j++) {
+    if(field[i][j]) XDrawPoint(dpy,w,gc,j,i);
+   }
+  }
+  XFlush(dpy);
+}
+
+int load_file(FILE *fp) {
+ struct triangle *to;
+ struct triangle t;
+ char *command;
+ static int i=0;//used to store the last triangle.
+
+ for(;global.triangle[i];i++) ;//hop to the end.
+
+ fcntl(fileno(fp),F_SETFL,O_NONBLOCK);
+
+ for(;;i++) {
+  if(feof(fp))  {
+   //printf("resetting EOF\n");
+   clearerr(fp);
+  }
+  if(fscanf(fp,"%ms %ms %d %d %d %d %d %d %d %d %d",&(t.id),&command,&(t.x1),&(t.y1),&(t.z1),&(t.x2),&(t.y2),&(t.z2),&(t.x3),&(t.y3),&(t.z3)) > 0) {
+   /*if(!strcmp(command,"addsquare")) { } */
+   if(!strcmp(command,"addtriangle")) {
+    global.triangle[i]=malloc(sizeof(struct triangle));
+    to=global.triangle[i];
+    memcpy(to,&t,sizeof(t));
+   }
+   if(!strcmp(command,"move")) {
+    for(i=0;global.triangle[i];i++) {
+     if(!strcmp(global.triangle[i]->id,t.id)) {
+      global.triangle[i]->x1+=t.x1;
+      global.triangle[i]->y1+=t.y1;
+      global.triangle[i]->z1+=t.z1;
+
+      global.triangle[i]->x2+=t.x1;
+      global.triangle[i]->y2+=t.y1;
+      global.triangle[i]->z2+=t.z1;
+
+      global.triangle[i]->x3+=t.x1;
+      global.triangle[i]->y3+=t.y1;
+      global.triangle[i]->z3+=t.z1;
+     }
+    }
+   }
+   global.triangle[i+1]=0;
+   draw_screen(global.dpy,global.w,global.gc);
+  } else {
+   global.triangle[i]=0;
+   break;
+  }
+ }
+}
+
+int export_file(FILE *fp) {
+ struct triangle *to;
+ int i;
+ for(i=0;global.triangle[i];i++) {
+  to=global.triangle[i];
+  printf("%s addtriangle %d %d %d %d %d %d %d %d %d\n",to->id,to->x1,to->y1,to->z1,to->x2,to->y2,to->z2,to->x3,to->y3,to->z3);
+ }
+}
+
+
+int main(int argc,char *argv[]) {
+  char redraw=0;
+  if(argc < 2) {
+   fprintf(stderr,"usage: hackvr yourname < from_others > to_others\n");
+   return 1;
+  } else {
+   global.user=strdup(argv[1]);
+  }
+  setbuf(stdin,0);
+  setbuf(stdout,0);
+  Display *dpy = XOpenDisplay(0);
+  assert(dpy);
+  global.dpy=dpy;
+  unsigned int mask;
+  int i;
+  XEvent e;
+  XSetWindowAttributes attributes;
+  int blackColor = BlackPixel(dpy, DefaultScreen(dpy));
+  int whiteColor = //WhitePixel(dpy, DefaultScreen(dpy));
+  attributes.background_pixel=blackColor;
+  Window w = XCreateWindow(dpy,DefaultRootWindow(dpy),0,0,WIDTH*SPLIT_SCREEN,HEIGHT,1,DefaultDepth(dpy,DefaultScreen(dpy)),InputOutput,DefaultVisual(dpy,DefaultScreen(dpy))\
+                           ,CWBackPixel, &attributes);
+  global.w=w;
+  global.triangle[0]=0;//we'll allocate as we need more.
+
+  int j;
+
+  for(i=0;i<HEIGHT;i++) {
+   for(j=0;j<WIDTH;j++) {
+    if(i==0) field[i][j]=rand()%2;
+    else field[i][j]=(j==0 || j==WIDTH)?0:applyrule(field[i-1][j-1],field[i-1][j],field[i-1][j+1],22);
+   }
+  }
+
+  Window root,child;
+  XSelectInput(dpy, w, PointerMotionMask|StructureNotifyMask|ButtonPressMask|ButtonReleaseMask|ResizeRedirectMask|KeyPressMask);
+  XMapWindow(dpy, w);
+  XStoreName(dpy,w,"hackvr");
+  GC gc = XCreateGC(dpy, w, 0, 0);
+  global.gc=gc;
+  global.color_map=DefaultColormap(dpy, DefaultScreen(dpy));
+  XAllocNamedColor(dpy, global.color_map, "green", &global.green, &global.green);
+  XSetForeground(dpy, gc, global.green.pixel);
+//  XSetForeground(dpy, gc, whiteColor);
+  for(;;) {
+    load_file(stdin);
+    XNextEvent(dpy, &e);
+    redraw=1;
+    switch(e.type) {
+      case MotionNotify:
+        XQueryPointer(dpy,w,&root,&child,&global.rmousex,&global.rmousey,&global.mousex,&global.mousey,&mask);
+        break;
+      case ButtonPress:
+        global.buttonpressed=e.xbutton.button;
+        break;
+      case ButtonRelease:
+        global.buttonpressed=0;
+        break;
+      case ResizeRequest:
+        XGetGeometry(dpy,w,&root,&global.x,&global.y,&global.width,&global.height,&global.border_width,&global.depth);
+      case KeyPress:
+        switch(XLookupKeysym(&e.xkey,0)) {
+          case XK_Up:
+           //fix these to use calculated values down there.
+           //printf("%s move 0 0 1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr));
+           camera.x+=5*sinl(d2r(camera.yr)); break;
+          case XK_Down:
+           //printf("%s move 0 0 -1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+180));
+           camera.x+=5*sinl(d2r(camera.yr+180)); break;
+          case XK_Left:
+           //printf("%s move 1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+90));
+           camera.x+=5*sinl(d2r(camera.yr+90)); break;
+          case XK_Right:
+           //printf("%s move -1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+270));
+           camera.x+=5*sinl(d2r(camera.yr+270)); break;
+          case XK_w:
+           //printf("%s move 0 1 0 0 0 0 0 0 0\n",global.user);
+           camera.y+=5; break;
+          case XK_s:
+           //printf("%s move 0 -1 0 0 0 0 0 0 0\n",global.user);
+           camera.y-=5; break;
+          case XK_q:
+           camera.yr+=5; break;
+          case XK_e:
+           camera.yr-=5; break;
+          case XK_Escape: return 0;
+          default:
+           redraw=0;
+           break;
+        }
+      default:
+        redraw=0;
+        break;
+    }
+    //if(redraw)
+    draw_screen(dpy,w,gc);
+  }
+  return 0;
+}
diff --git a/tests/automata_text b/tests/automata_text
new file mode 100755
index 0000000..28d79cc
--- /dev/null
+++ b/tests/automata_text
diff --git a/tests/automata_text.c b/tests/automata_text.c
new file mode 100644
index 0000000..574c402
--- /dev/null
+++ b/tests/automata_text.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <string.h>
+
+#define HE he
+#define WI wi
+#define RULE rule
+
+
+int main(int argc,char *argv[]) {
+  int i,j;
+  int rule=atoi(argv[1]);
+  char str[256];//lel. close enough.
+  int wi=read(0,str,sizeof(str)-1)*8;
+  int he=atoi(argv[2]);
+  char f[HE+1][WI+1];
+  f[0][WI/2]=1;
+  for(i=0;i<HE;i++) {
+   for(j=0;j<WI;j++) {
+    if(i==0) f[i][j]=(str[j/8]>>(j%8))%2;
+    else f[i][j]=(RULE >> ((!!f[(i+HE-1)%HE][(j+WI-1)%WI]<<2) | (!!f[(i+HE-1)%HE][j]<<1) | (!!f[(i+HE-1)%HE][(j+1)%WI])) & 1);
+   }
+  }
+  for(i=0;i<HE;i++) {
+   for(j=0;j<WI;j++) {
+    if(f[i][j]) {
+     printf("%c",f[i][j]+'0');
+    } else {
+     printf(" ");
+    }
+   }
+   printf("\n");
+  }
+ return 0;
+}
diff --git a/tests/prog-2 b/tests/prog-2
new file mode 100755
index 0000000..007a226
--- /dev/null
+++ b/tests/prog-2
diff --git a/tests/prog-2.c b/tests/prog-2.c
new file mode 100644
index 0000000..8af4548
--- /dev/null
+++ b/tests/prog-2.c
@@ -0,0 +1,175 @@
+#include <X11/Xlib.h>
+#include <assert.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+struct mainwin {
+  int x;
+  int y;
+  int depth;
+  int mousex;
+  int mousey;
+  int rmousex;
+  int rmousey;
+  int buttonpressed;
+  int width;
+  int height;
+  int border_width;
+  XColor green;
+  Colormap color_map;
+} global;
+
+int mycmp(const void *a,const void *b) {
+// printf("comparing '%s' and '%s'\n",*(char **)a,*(char **)b);
+ return strcmp(*(char **)a,*(char **)b);
+}
+
+char **ls(char *dir) {
+  DIR *fd;
+  char **files=malloc(sizeof(char *) * 1000);
+  struct dirent *d;
+  int i;
+  fd = opendir(".");
+  if (fd) {
+    for (i=0;(d = readdir(fd)) != NULL;i++) {
+      files[i]=strdup(d->d_name);
+    }
+    files[i]=0;
+    closedir(fd);
+  }
+  //now to sort files in numerical order.
+//       void qsort(void *base, size_t nmemb, size_t size,
+//                  int (*compar)(const void *, const void *));
+  qsort(files,i,sizeof(char *),mycmp);
+  return files;
+}
+
+void freels(char **files) {
+  int i;
+  for(i=0;files[i];i++) {
+    free(files[i]);
+  }
+  free(files);
+}
+
+void draw_screen(Display *dpy,Window w,GC gc) {
+  int i;
+  char **files;
+  static int offset=0;
+  XFontStruct *font=XLoadQueryFont(dpy,"fixed");
+  XCharStruct overall;
+  int direction,ascent,descent;
+  char coords[256];
+  int x,y;
+  XEvent e;
+  XClearWindow(dpy, w);
+  snprintf(coords,sizeof(coords)-1,"x: %d y: %d",global.mousex,global.mousey);
+  files=ls(".");
+  for(i=0;files[i];i++) {
+    XTextExtents(font,files[i],strlen(files[i]),&direction,&ascent,&descent,&overall);
+    x=30;
+    y=((ascent+descent)*(i+3))+offset;
+    XDrawString(dpy,w,gc,x,y,files[i],strlen(files[i]));
+    if(global.mousex > x && global.mousex < x+overall.width && global.mousey > y-ascent && global.mousey < y+descent) {
+     if(global.buttonpressed) {
+       if(chdir(files[i])) if(!fork()) execlp("xdg-open","xdg-open",files[i],0);
+       else offset=0;
+     }
+     //top line
+     XDrawLine(dpy,w,gc,0,y-ascent,x+overall.width,y-ascent);
+     //bottom line
+     XDrawLine(dpy,w,gc,x,y+descent,global.width,y+descent);
+     //left line
+     XDrawLine(dpy,w,gc,x,y-ascent,x,y+descent);
+     //right line
+     XDrawLine(dpy,w,gc,x+overall.width,y-ascent,x+overall.width,y+descent);
+    }
+  }
+  //  ||
+  // \||/
+  //  \/
+  x=4;
+  y=global.height-16;
+
+  XDrawLine(dpy,w,gc,x+4+1,y+0+1,x+4+1,y+8+1);
+  XDrawLine(dpy,w,gc,x+0+1,y+4+1,x+4+1,y+8+1);
+  XDrawLine(dpy,w,gc,x+8+1,y+4+1,x+4+1,y+8+1);
+
+  if(global.mousex > x && global.mousex < x+10 && global.mousey > y && global.mousey < y+10) {
+   if(global.buttonpressed) {
+    offset-=40;
+   }
+   XDrawLine(dpy,w,gc,x,y,x+10,y);
+   XDrawLine(dpy,w,gc,x,y+10,x+10,y+10);
+   XDrawLine(dpy,w,gc,x,y,x,y+10);
+   XDrawLine(dpy,w,gc,x+10,y,x+10,y+10);
+  }
+  //  /\
+  // /||\
+  //  ||
+  x=4;
+  y=16;
+
+  XDrawLine(dpy,w,gc,x+4+1,y+0+1,x+4+1,y+8+1);
+  XDrawLine(dpy,w,gc,x+0+1,y+4+1,x+4+1,y+0+1);
+  XDrawLine(dpy,w,gc,x+8+1,y+4+1,x+4+1,y+0+1);
+
+  if(global.mousex > x && global.mousex < x+10 && global.mousey > y && global.mousey < y+10) {
+   if(global.buttonpressed) {
+    offset+=40;
+   }
+   XDrawLine(dpy,w,gc,x,y,x+10,y);
+   XDrawLine(dpy,w,gc,x,y+10,x+10,y+10);
+   XDrawLine(dpy,w,gc,x,y,x,y+10);
+   XDrawLine(dpy,w,gc,x+10,y,x+10,y+10);
+  }
+
+  XDrawString(dpy,w,gc,0,0+ascent,coords,strlen(coords));
+  XFlush(dpy);
+}
+
+int main(int argc,char *argv[])
+{
+  Display *dpy = XOpenDisplay(0);
+  assert(dpy);
+  unsigned int mask;
+  XEvent e;
+  XSetWindowAttributes attributes;
+  int blackColor = BlackPixel(dpy, DefaultScreen(dpy));
+  int whiteColor = //WhitePixel(dpy, DefaultScreen(dpy));
+  attributes.background_pixel=blackColor;
+  Window w = XCreateWindow(dpy,DefaultRootWindow(dpy),0,0,500,400,1,DefaultDepth(dpy,DefaultScreen(dpy)),InputOutput,DefaultVisual(dpy,DefaultScreen(dpy))\
+                           ,CWBackPixel, &attributes);
+  Window root,child;
+  XSelectInput(dpy, w, PointerMotionMask|StructureNotifyMask|ButtonPressMask|ButtonReleaseMask|ResizeRedirectMask);
+  XMapWindow(dpy, w);
+  XStoreName(dpy,w,"hackhackhack");
+  GC gc = XCreateGC(dpy, w, 0, 0);
+  global.color_map=DefaultColormap(dpy, DefaultScreen(dpy));
+  XAllocNamedColor(dpy, global.color_map, "green", &global.green, &global.green);
+  XSetForeground(dpy, gc, global.green.pixel);
+//  XSetForeground(dpy, gc, whiteColor);
+  for(;;) {
+    draw_screen(dpy,w,gc);
+    XNextEvent(dpy, &e);
+    switch(e.type) {
+      case MotionNotify:
+        XQueryPointer(dpy,w,&root,&child,&global.rmousex,&global.rmousey,&global.mousex,&global.mousey,&mask);
+        break;
+      case ButtonPress:
+        global.buttonpressed=e.xbutton.button;
+        break;
+      case ButtonRelease:
+        global.buttonpressed=0;
+        break;
+      case ResizeRequest:
+        XGetGeometry(dpy,w,&root,&global.x,&global.y,&global.width,&global.height,&global.border_width,&global.depth);
+      default:
+        break;
+    }
+  }
+  return 0;
+}
diff --git a/tests/readline b/tests/readline
new file mode 100755
index 0000000..f45ea8c
--- /dev/null
+++ b/tests/readline
diff --git a/tests/readline.c b/tests/readline.c
new file mode 100644
index 0000000..76d6a2d
--- /dev/null
+++ b/tests/readline.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+char *read_line_hack(FILE *fp,int len) {
+ short in;
+ char *t;
+ if((in=fgetc(fp)) == '\n') {
+  t=malloc(len+1);
+  t[len]=0;
+  return t;
+ }
+ t=read_line_hack(fp,len+1);
+ t[len]=in;
+ return t;
+}
+
+int main() {
+ char *t=read_line_hack(stdin,0);
+ printf("%s\n",t);
+}
diff --git a/tests/rotate b/tests/rotate
new file mode 100755
index 0000000..9266b2b
--- /dev/null
+++ b/tests/rotate
diff --git a/tests/rotate.c b/tests/rotate.c
new file mode 100644
index 0000000..7f7b9bc
--- /dev/null
+++ b/tests/rotate.c
@@ -0,0 +1,458 @@
+#include <fcntl.h>
+#include <assert.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#define __USE_GNU //for longer math constants
+#include <math.h>
+
+//#define DEBUG
+
+#define SPLIT_SCREEN 2
+#define CAMERA_SEPARATION 3
+
+#define DEPTH_FACTOR 0.965
+
+#define TRIANGLES 256
+
+#define min(a,b) (((a)<(b))?(a):(b))
+#define max(a,b) (((a)>(b))?(a):(b))
+
+//for one camera, not the whole thing.
+//3 camera
+//#define WIDTH 320
+//#define HEIGHT 240
+//1 camera
+//#define WIDTH 800
+//#define HEIGHT 600
+//2 camera
+#define WIDTH 400
+#define HEIGHT 300
+
+struct object_1 {
+ int type;
+ unsigned char x;
+ unsigned char y;
+ unsigned char z;
+};
+
+struct object_2 {
+ int type;
+ unsigned short x;
+ unsigned short y;
+ unsigned short z;
+};
+
+struct object_4 {
+ int type;
+ unsigned int x;
+ unsigned int y;
+ unsigned int z;
+};
+
+struct camera {
+  int x;
+  int y;
+  int z;
+  int xr;//rotations
+  int yr;
+  int zr;
+} camera;
+
+struct triangle {//use array or linked list?
+  char *id;
+  int x1;
+  int y1;
+  int z1;
+  int x2;
+  int y2;
+  int z2;
+  int x3;
+  int y3;
+  int z3;
+//  int dist;//most recent distance calculated from the camera
+};
+
+struct mainwin {
+  int x;
+  int y;
+  int depth;
+  int mousex;
+  int mousey;
+  int rmousex;
+  int rmousey;
+  int buttonpressed;
+  int width;
+  int height;
+  int border_width;
+  int xoff;
+  int math_error;
+  char *user;
+  XColor green;
+  Colormap color_map;
+  Display *dpy;
+  Window w;
+  GC gc;
+  struct triangle *triangle[TRIANGLES];
+} global;
+
+
+float zmagic(int z) {
+ float tmp=pow(DEPTH_FACTOR,(camera.z-z));
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z))/(camera.z-z);
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z)*(camera.z-z)*(camera.z-z));
+ //measure the distance form the camera and error out if it is too far away.
+// if((camera.z - z) >= 0) return(global.math_error=1);
+ //return (float)1 / (float)(camera.z - z);
+ return tmp;
+}
+
+int to2D(int cw,int w,int z,int d) {
+  return (d/2) - (((w-cw) / zmagic(z)) * 16 );
+}
+
+
+float distance(int x1,int y1,int x2,int y2) {
+ return sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1)));
+}
+
+long double d2r(int d) {
+ while(d<0) d+=360;
+ return (long double)(d%360) / 180.0l * M_PIl;
+}
+
+int rotateXabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return x2;
+ return x2 + radius * cosl(acosl(((long double)x2-(long double)x1)/radius)+radians);
+}
+
+int rotateZabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return z2;
+ return z2 + radius * sinl(asinl(((long double)z2-(long double)z1)/radius)+radians);
+}
+
+
+int to2Dx(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.xr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.x,newx,newz,global.width/SPLIT_SCREEN);
+//  return to2D(camera.x,x,z,global.width/SPLIT_SCREEN);
+}
+
+int to2Dy(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.y,newy,newz,global.height);
+//  return to2D(camera.y,y,z,global.height);
+}
+
+void XDrawTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
+ int x;
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+}
+
+void XDrawFilledTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
+ int x,y;
+ int b;
+ float m;
+
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+
+ m=(float)(y1-y2)/(float)(x1-x2);
+ b=y1-(m*x1);
+ for(x=min(x1,x2);x<max(x1,x2);x++) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x3,y3,x,y);
+ }
+
+ m=(float)(y2-y3)/(float)(x2-x3);
+ b=y2-(m*x2);
+ for(x=min(x2,x3);x<max(x2,x3);x++) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x1,y1,x,y);
+ }
+
+ m=(float)(y3-y1)/(float)(x3-x1);
+ b=y3-(m*x3);
+ for(x=min(x3,x1);x<max(x3,x1);x++) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x2,y2,x,y);
+ }
+}
+
+void draw3Dtriangle(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3) {
+  char coords[256];
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  //draw string...
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  int tx3=to2Dx(x3,y3,z3);
+  int ty3=to2Dy(x3,y3,z3);
+  if(!global.math_error) {
+#ifdef DEBUG
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x1,y1,z1);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x2,y2,z2);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx2,ty2,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x3,y3,z3);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx3,ty3,coords,strlen(coords));
+#endif
+    XDrawTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+//    XDrawFilledTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+  }
+}
+
+void draw3Dline(int x1,int y1,int z1,int x2,int y2,int z2) {
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  if(!global.math_error) {
+    XDrawLine(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,global.xoff+tx2,ty2);
+  }
+  global.math_error=0;
+}
+
+
+//is basing this all on triangles best, or should I use polygons?
+//void pushTriangle(x1,y1,z1,1) {
+//  for(i=0;global.triangle[i];i++);
+//  global.triangle[i]=malloc(sizeof(struct triangle));
+//  global.triangle[i]->x1=x1;
+//}
+//void pushSquare() {
+//  pushTriangle();
+//  pushTriangle();
+//}
+
+void drawCube(int x,int y,int z,int i) {
+//this is just drawing the cube.
+    draw3Dline(x,y,z,x,y,z+i);
+    draw3Dline(x,y,z,x,y+i,z);
+    draw3Dline(x,y,z,x+i,y,z);
+
+    draw3Dline(x+i,y+i,z+0,x+i,y+0,z+0);
+    draw3Dline(x+i,y+i,z+0,x+0,y+i,z+0);
+
+    draw3Dline(x+0,y+i,z+i,x+0,y+i,z+0);
+    draw3Dline(x+0,y+i,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+0,z+i,x+i,y+0,z+0);
+    draw3Dline(x+i,y+0,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+i,z+i,x+i,y+i,z+0);
+    draw3Dline(x+i,y+i,z+i,x+i,y+0,z+i);
+    draw3Dline(x+i,y+i,z+i,x+0,y+i,z+i);
+}
+
+void draw_screen(Display *dpy,Window w,GC gc) {
+  int i,j,k;
+  int cn=0;//camera number.
+  char **files;
+  static int offset=0;
+  XFontStruct *font=XLoadQueryFont(dpy,"fixed");
+  XCharStruct overall;
+  int direction,ascent,descent;
+  char coords[256];
+  int x,y,z,x1,y1,x2,y2;
+  XEvent e;
+  XClearWindow(dpy, w);
+
+  //struct triangle **triangle;
+  //for(i=0;global.triangle[i];i++);
+  //triangle=malloc(sizeof(struct triangle *) * i);
+  //for(i=0;global.triangle[i];i++) {
+  // triangle[i]=malloc(sizeof(struct triangle));
+  // memcpy(triangle[i],global.triangle[i],sizeof(triangle));
+  //}
+  //triangle[i]=0;
+
+    XDrawLine(dpy,w,gc,global.xoff,global.height/2,global.xoff+WIDTH,global.height/2);
+    snprintf(coords,sizeof(coords)-1,"x: %d y: %d",global.mousex,global.mousey);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,0+ascent,coords,strlen(coords));
+    snprintf(coords,sizeof(coords)-1,"cx: %d cy: %d cz: %d",camera.x,camera.y,camera.z);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,(descent+0+ascent)*2,coords,strlen(coords));
+
+    snprintf(coords,sizeof(coords)-1,"xr: %d yr: %d zr: %d",camera.xr,camera.yr,camera.zr);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,(descent+0+ascent)*3,coords,strlen(coords));
+
+  j=0;
+  for(i=camera.yr;i<camera.yr+270;i+=10) {
+    XDrawLine(dpy,w,gc,rotateXabout(75-j,0,75-j,100,0,100,i),rotateZabout(75,0,75,100,0,100,i),100,100);
+    j++;
+  }
+
+  XFlush(dpy);
+}
+
+int load_file(FILE *fp) {
+ struct triangle *to;
+ struct triangle t;
+ char *command;
+ static int i=0;//used to store the last triangle.
+
+ for(;global.triangle[i];i++) ;//hop to the end.
+
+ fcntl(fileno(fp),F_SETFL,O_NONBLOCK);
+
+ for(;;i++) {
+  if(feof(fp))  {
+   //printf("resetting EOF\n");
+   clearerr(fp);
+  }
+  if(fscanf(fp,"%ms %ms %d %d %d %d %d %d %d %d %d",&(t.id),&command,&(t.x1),&(t.y1),&(t.z1),&(t.x2),&(t.y2),&(t.z2),&(t.x3),&(t.y3),&(t.z3)) > 0) {
+   /*if(!strcmp(command,"addsquare")) { } */
+   if(!strcmp(command,"addtriangle")) {
+    global.triangle[i]=malloc(sizeof(struct triangle));
+    to=global.triangle[i];
+    memcpy(to,&t,sizeof(t));
+   }
+   if(!strcmp(command,"move")) {
+    for(i=0;global.triangle[i];i++) {
+     if(!strcmp(global.triangle[i]->id,t.id)) {
+      global.triangle[i]->x1+=t.x1;
+      global.triangle[i]->y1+=t.y1;
+      global.triangle[i]->z1+=t.z1;
+
+      global.triangle[i]->x2+=t.x1;
+      global.triangle[i]->y2+=t.y1;
+      global.triangle[i]->z2+=t.z1;
+
+      global.triangle[i]->x3+=t.x1;
+      global.triangle[i]->y3+=t.y1;
+      global.triangle[i]->z3+=t.z1;
+     }
+    }
+   }
+   global.triangle[i+1]=0;
+   draw_screen(global.dpy,global.w,global.gc);
+  } else {
+   global.triangle[i]=0;
+   break;
+  }
+ }
+}
+
+int export_file(FILE *fp) {
+ struct triangle *to;
+ int i;
+ for(i=0;global.triangle[i];i++) {
+  to=global.triangle[i];
+  printf("%s addtriangle %d %d %d %d %d %d %d %d %d\n",to->id,to->x1,to->y1,to->z1,to->x2,to->y2,to->z2,to->x3,to->y3,to->z3);
+ }
+}
+
+
+int main(int argc,char *argv[]) {
+  char redraw=0;
+  if(argc < 2) {
+   fprintf(stderr,"usage: hackvr yourname < from_others > to_others\n");
+   return 1;
+  } else {
+   global.user=strdup(argv[1]);
+  }
+  setbuf(stdin,0);
+  setbuf(stdout,0);
+  Display *dpy = XOpenDisplay(0);
+  assert(dpy);
+  global.dpy=dpy;
+  unsigned int mask;
+  int i;
+  XEvent e;
+  XSetWindowAttributes attributes;
+  int blackColor = BlackPixel(dpy, DefaultScreen(dpy));
+  int whiteColor = //WhitePixel(dpy, DefaultScreen(dpy));
+  attributes.background_pixel=blackColor;
+  Window w = XCreateWindow(dpy,DefaultRootWindow(dpy),0,0,WIDTH*SPLIT_SCREEN,HEIGHT,1,DefaultDepth(dpy,DefaultScreen(dpy)),InputOutput,DefaultVisual(dpy,DefaultScreen(dpy))\
+                           ,CWBackPixel, &attributes);
+  global.w=w;
+  global.triangle[0]=0;//we'll allocate as we need more.
+  Window root,child;
+  XSelectInput(dpy, w, PointerMotionMask|StructureNotifyMask|ButtonPressMask|ButtonReleaseMask|ResizeRedirectMask|KeyPressMask);
+  XMapWindow(dpy, w);
+  XStoreName(dpy,w,"hackvr");
+  GC gc = XCreateGC(dpy, w, 0, 0);
+  global.gc=gc;
+  global.color_map=DefaultColormap(dpy, DefaultScreen(dpy));
+  XAllocNamedColor(dpy, global.color_map, "green", &global.green, &global.green);
+  XSetForeground(dpy, gc, global.green.pixel);
+//  XSetForeground(dpy, gc, whiteColor);
+  for(;;) {
+    load_file(stdin);
+    XNextEvent(dpy, &e);
+    redraw=1;
+    switch(e.type) {
+      case MotionNotify:
+        XQueryPointer(dpy,w,&root,&child,&global.rmousex,&global.rmousey,&global.mousex,&global.mousey,&mask);
+        break;
+      case ButtonPress:
+        global.buttonpressed=e.xbutton.button;
+        break;
+      case ButtonRelease:
+        global.buttonpressed=0;
+        break;
+      case ResizeRequest:
+        XGetGeometry(dpy,w,&root,&global.x,&global.y,&global.width,&global.height,&global.border_width,&global.depth);
+      case KeyPress:
+        switch(XLookupKeysym(&e.xkey,0)) {
+          case XK_Up:
+           //fix these to use calculated values down there.
+           //printf("%s move 0 0 1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr));
+           camera.x+=5*sinl(d2r(camera.yr)); break;
+          case XK_Down:
+           //printf("%s move 0 0 -1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+180));
+           camera.x+=5*sinl(d2r(camera.yr+180)); break;
+          case XK_Left:
+           //printf("%s move 1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+90));
+           camera.x+=5*sinl(d2r(camera.yr+90)); break;
+          case XK_Right:
+           //printf("%s move -1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+270));
+           camera.x+=5*sinl(d2r(camera.yr+270)); break;
+          case XK_w:
+           //printf("%s move 0 1 0 0 0 0 0 0 0\n",global.user);
+           camera.y+=5; break;
+          case XK_s:
+           //printf("%s move 0 -1 0 0 0 0 0 0 0\n",global.user);
+           camera.y-=5; break;
+          case XK_q:
+           camera.yr+=5; break;
+          case XK_e:
+           camera.yr-=5; break;
+          case XK_Escape: return 0;
+          default:
+           redraw=0;
+           break;
+        }
+      default:
+        redraw=0;
+        break;
+    }
+    //if(redraw)
+    draw_screen(dpy,w,gc);
+  }
+  return 0;
+}
diff --git a/tests/splitter.c b/tests/splitter.c
new file mode 100644
index 0000000..25292f6
--- /dev/null
+++ b/tests/splitter.c
@@ -0,0 +1,53 @@
+char **line_splitter(char *line,int *rlen) {
+ char **a;
+ int i=0,j=0;
+ int len;
+ len=1;
+ for(i=0;line[i] && line[i] == ' ';i++);//skip leading space
+ for(;line[i];) {
+  for(;line[i] && line[i] != ' ';i++);//skip rest of data
+  for(;line[i] && line[i] == ' ';i++);//skip rest of space
+  len++;
+ }
+ a=malloc(sizeof(char *) * len+1);
+ a[len]=0;
+ len=0;//reuse!
+ for(i=0;line[i] && line[i] == ' ';i++);//skip leading space
+ a[len]=line+i;
+ for(;;) {
+  for(;line[i] && line[i] != ' ';i++);//skip rest of data
+  if(line[i]) {
+   line[i]=0;
+   i++;
+  } else {
+   //we're at the end! I guess return this shit.
+   len++;
+   a[len]=0;
+   *rlen=len;
+   return a;
+  }
+  for(;line[i] && line[i] == ' ';i++);//skip rest of space
+  if(line[i]) {
+   len++;
+   a[len]=line+i;
+  } else {
+   len++;
+   a[len]=0;
+   *rlen=len;
+   return a;
+  }
+ }
+ *rlen=len;
+ return a;
+}
+
+int main(int argc,char *argv[]) {
+ char **a;
+ int len;
+ int i;
+ a=line_splitter(strdup(argv[1]),&len);
+ for(i=0;i<len;i++) {
+  printf("a[%d]=\"%s\"\n",i,a[i]);
+ }
+ return 0;
+}
diff --git a/tests/test b/tests/test
new file mode 100755
index 0000000..fa10061
--- /dev/null
+++ b/tests/test
diff --git a/tests/test.c b/tests/test.c
new file mode 100644
index 0000000..4817a5b
--- /dev/null
+++ b/tests/test.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+typedef double long c3_t;
+typedef double long c2_t;
+typedef struct {
+  int x;
+  int y;
+} cs_t;
+
+cs_t derp() {
+  return (cs_t){2,3};
+}
+
+int main(int argc,char *argv[]) {
+ cs_t cs=derp();
+ printf("%d,%d\n",cs.x,cs.y);
+ switch(1) {
+   case 1:
+    printf("first\n");
+    break;
+   default:
+    printf("third.\n");
+    break;
+ }
+ return 0;
+}
diff --git a/tests/triangle b/tests/triangle
new file mode 100755
index 0000000..beb83ca
--- /dev/null
+++ b/tests/triangle
diff --git a/tests/triangle.c b/tests/triangle.c
new file mode 100644
index 0000000..e503cce
--- /dev/null
+++ b/tests/triangle.c
@@ -0,0 +1,460 @@
+#include <fcntl.h>
+#include <assert.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#define __USE_GNU //for longer math constants
+#include <math.h>
+
+//#define DEBUG
+
+#define SPLIT_SCREEN 2
+#define CAMERA_SEPARATION 3
+
+#define DEPTH_FACTOR 0.965
+
+#define TRIANGLES 256
+
+#define min(a,b) (((a)<(b))?(a):(b))
+#define max(a,b) (((a)>(b))?(a):(b))
+
+//for one camera, not the whole thing.
+//3 camera
+//#define WIDTH 320
+//#define HEIGHT 240
+//1 camera
+//#define WIDTH 800
+//#define HEIGHT 600
+//2 camera
+#define WIDTH 400
+#define HEIGHT 300
+
+struct object_1 {
+ int type;
+ unsigned char x;
+ unsigned char y;
+ unsigned char z;
+};
+
+struct object_2 {
+ int type;
+ unsigned short x;
+ unsigned short y;
+ unsigned short z;
+};
+
+struct object_4 {
+ int type;
+ unsigned int x;
+ unsigned int y;
+ unsigned int z;
+};
+
+struct camera {
+  int x;
+  int y;
+  int z;
+  int xr;//rotations
+  int yr;
+  int zr;
+} camera;
+
+struct triangle {//use array or linked list?
+  char *id;
+  int x1;
+  int y1;
+  int z1;
+  int x2;
+  int y2;
+  int z2;
+  int x3;
+  int y3;
+  int z3;
+//  int dist;//most recent distance calculated from the camera
+};
+
+struct mainwin {
+  int x;
+  int y;
+  int depth;
+  int mousex;
+  int mousey;
+  int rmousex;
+  int rmousey;
+  int buttonpressed;
+  int width;
+  int height;
+  int border_width;
+  int xoff;
+  int math_error;
+  char *user;
+  XColor green;
+  Colormap color_map;
+  Display *dpy;
+  Window w;
+  GC gc;
+  struct triangle *triangle[TRIANGLES];
+} global;
+
+
+float zmagic(int z) {
+ float tmp=pow(DEPTH_FACTOR,(camera.z-z));
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z))/(camera.z-z);
+// float tmp=pow(DEPTH_FACTOR,(camera.z-z)*(camera.z-z)*(camera.z-z));
+ //measure the distance form the camera and error out if it is too far away.
+// if((camera.z - z) >= 0) return(global.math_error=1);
+ //return (float)1 / (float)(camera.z - z);
+ return tmp;
+}
+
+int to2D(int cw,int w,int z,int d) {
+  return (d/2) - (((w-cw) / zmagic(z)) * 16 );
+}
+
+
+float distance(int x1,int y1,int x2,int y2) {
+ return sqrt(((x2-x1)*(x2-x1))+((y2-y1)*(y2-y1)));
+}
+
+long double d2r(int d) {
+ while(d<0) d+=360;
+ return (long double)(d%360) / 180.0l * M_PIl;
+}
+
+int rotateXabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return x2;
+ return x2 + radius * cosl(acosl(((long double)x2-(long double)x1)/radius)+radians);
+}
+
+int rotateZabout(int x1,int y1,int z1,int x2,int y2,int z2,int degrees) {
+ long double radians=(long double)degrees / (long double)180 * M_PIl;//M_PIl for long double
+ long double radius=distance(x1,z1,x2,z2);
+ if(radius == 0) return z2;
+ return z2 + radius * sinl(asinl(((long double)z2-(long double)z1)/radius)+radians);
+}
+
+
+int to2Dx(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.xr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.x,newx,newz,global.width/SPLIT_SCREEN);
+//  return to2D(camera.x,x,z,global.width/SPLIT_SCREEN);
+}
+
+int to2Dy(int x,int y,int z) {
+  int newx=rotateXabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newy=y;//rotateYabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  int newz=rotateZabout(x,y,z,camera.x,camera.y,camera.z,camera.yr);
+  return to2D(camera.y,newy,newz,global.height);
+//  return to2D(camera.y,y,z,global.height);
+}
+
+void XDrawTriangle(int x1,int y1,int x2,int y2,int x3,int y3) {
+ int x;
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+}
+
+void XDrawFilledTriangle(int x1,int y1,int x2,int y2,int x3,int y3,int density) {
+ int x,y;
+ int b;
+ float m;
+
+ XDrawLine(global.dpy,global.w,global.gc,x1,y1,x2,y2);
+ XDrawLine(global.dpy,global.w,global.gc,x2,y2,x3,y3);
+ XDrawLine(global.dpy,global.w,global.gc,x3,y3,x1,y1);
+
+ m=(float)(y1-y2)/(float)(x1-x2);
+ b=y1-(m*x1);
+ for(x=min(x1,x2);x<max(x1,x2);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x3,y3,x,y);
+ }
+
+ m=(float)(y2-y3)/(float)(x2-x3);
+ b=y2-(m*x2);
+ for(x=min(x2,x3);x<max(x2,x3);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x1,y1,x,y);
+ }
+
+ m=(float)(y3-y1)/(float)(x3-x1);
+ b=y3-(m*x3);
+ for(x=min(x3,x1);x<max(x3,x1);x+=4) {
+  y=m*x+b;
+  XDrawLine(global.dpy,global.w,global.gc,x2,y2,x,y);
+ }
+}
+
+void draw3Dtriangle(int x1,int y1,int z1,int x2,int y2,int z2,int x3,int y3,int z3) {
+  char coords[256];
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  //draw string...
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  int tx3=to2Dx(x3,y3,z3);
+  int ty3=to2Dy(x3,y3,z3);
+  if(!global.math_error) {
+#ifdef DEBUG
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x1,y1,z1);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x2,y2,z2);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx2,ty2,coords,strlen(coords));
+     snprintf(coords,sizeof(coords)-1,"(%d,%d,%d)",x3,y3,z3);
+     XDrawString(global.dpy,global.w,global.gc,global.xoff+tx3,ty3,coords,strlen(coords));
+#endif
+    XDrawTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+//    XDrawFilledTriangle(global.xoff+tx1,ty1,global.xoff+tx2,ty2,global.xoff+tx3,ty3);
+  }
+}
+
+void draw3Dline(int x1,int y1,int z1,int x2,int y2,int z2) {
+  global.math_error=0;
+  int tx1=to2Dx(x1,y1,z1);
+  int ty1=to2Dy(x1,y1,z1);
+  int tx2=to2Dx(x2,y2,z2);
+  int ty2=to2Dy(x2,y2,z2);
+  if(!global.math_error) {
+    XDrawLine(global.dpy,global.w,global.gc,global.xoff+tx1,ty1,global.xoff+tx2,ty2);
+  }
+  global.math_error=0;
+}
+
+
+//is basing this all on triangles best, or should I use polygons?
+//void pushTriangle(x1,y1,z1,1) {
+//  for(i=0;global.triangle[i];i++);
+//  global.triangle[i]=malloc(sizeof(struct triangle));
+//  global.triangle[i]->x1=x1;
+//}
+//void pushSquare() {
+//  pushTriangle();
+//  pushTriangle();
+//}
+
+void drawCube(int x,int y,int z,int i) {
+//this is just drawing the cube.
+    draw3Dline(x,y,z,x,y,z+i);
+    draw3Dline(x,y,z,x,y+i,z);
+    draw3Dline(x,y,z,x+i,y,z);
+
+    draw3Dline(x+i,y+i,z+0,x+i,y+0,z+0);
+    draw3Dline(x+i,y+i,z+0,x+0,y+i,z+0);
+
+    draw3Dline(x+0,y+i,z+i,x+0,y+i,z+0);
+    draw3Dline(x+0,y+i,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+0,z+i,x+i,y+0,z+0);
+    draw3Dline(x+i,y+0,z+i,x+0,y+0,z+i);
+
+    draw3Dline(x+i,y+i,z+i,x+i,y+i,z+0);
+    draw3Dline(x+i,y+i,z+i,x+i,y+0,z+i);
+    draw3Dline(x+i,y+i,z+i,x+0,y+i,z+i);
+}
+
+void draw_screen(Display *dpy,Window w,GC gc) {
+  int i,j,k;
+  int cn=0;//camera number.
+  char **files;
+  static int offset=0;
+  XFontStruct *font=XLoadQueryFont(dpy,"fixed");
+  XCharStruct overall;
+  int direction,ascent,descent;
+  char coords[256];
+  int x,y,z,x1,y1,x2,y2;
+  XEvent e;
+  XClearWindow(dpy, w);
+
+  //struct triangle **triangle;
+  //for(i=0;global.triangle[i];i++);
+  //triangle=malloc(sizeof(struct triangle *) * i);
+  //for(i=0;global.triangle[i];i++) {
+  // triangle[i]=malloc(sizeof(struct triangle));
+  // memcpy(triangle[i],global.triangle[i],sizeof(triangle));
+  //}
+  //triangle[i]=0;
+
+    XDrawLine(dpy,w,gc,global.xoff,global.height/2,global.xoff+WIDTH,global.height/2);
+    snprintf(coords,sizeof(coords)-1,"x: %d y: %d",global.mousex,global.mousey);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,0+ascent,coords,strlen(coords));
+    snprintf(coords,sizeof(coords)-1,"cx: %d cy: %d cz: %d",camera.x,camera.y,camera.z);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,(descent+0+ascent)*2,coords,strlen(coords));
+
+    snprintf(coords,sizeof(coords)-1,"xr: %d yr: %d zr: %d",camera.xr,camera.yr,camera.zr);
+    XTextExtents(font,coords,strlen(coords),&direction,&ascent,&descent,&overall);
+    XDrawString(dpy,w,gc,global.xoff,(descent+0+ascent)*3,coords,strlen(coords));
+
+  j=0;
+/*
+  for(i=camera.yr;i<camera.yr+270;i+=10) {
+    XDrawLine(dpy,w,gc,rotateXabout(75-j,0,75-j,100,0,100,i),rotateZabout(75,0,75,100,0,100,i),100,100);
+    j++;
+  }
+*/
+  XDrawFilledTriangle(10,10,300,60,60,300,1);
+  XFlush(dpy);
+}
+
+int load_file(FILE *fp) {
+ struct triangle *to;
+ struct triangle t;
+ char *command;
+ static int i=0;//used to store the last triangle.
+
+ for(;global.triangle[i];i++) ;//hop to the end.
+
+ fcntl(fileno(fp),F_SETFL,O_NONBLOCK);
+
+ for(;;i++) {
+  if(feof(fp))  {
+   //printf("resetting EOF\n");
+   clearerr(fp);
+  }
+  if(fscanf(fp,"%ms %ms %d %d %d %d %d %d %d %d %d",&(t.id),&command,&(t.x1),&(t.y1),&(t.z1),&(t.x2),&(t.y2),&(t.z2),&(t.x3),&(t.y3),&(t.z3)) > 0) {
+   /*if(!strcmp(command,"addsquare")) { } */
+   if(!strcmp(command,"addtriangle")) {
+    global.triangle[i]=malloc(sizeof(struct triangle));
+    to=global.triangle[i];
+    memcpy(to,&t,sizeof(t));
+   }
+   if(!strcmp(command,"move")) {
+    for(i=0;global.triangle[i];i++) {
+     if(!strcmp(global.triangle[i]->id,t.id)) {
+      global.triangle[i]->x1+=t.x1;
+      global.triangle[i]->y1+=t.y1;
+      global.triangle[i]->z1+=t.z1;
+
+      global.triangle[i]->x2+=t.x1;
+      global.triangle[i]->y2+=t.y1;
+      global.triangle[i]->z2+=t.z1;
+
+      global.triangle[i]->x3+=t.x1;
+      global.triangle[i]->y3+=t.y1;
+      global.triangle[i]->z3+=t.z1;
+     }
+    }
+   }
+   global.triangle[i+1]=0;
+   draw_screen(global.dpy,global.w,global.gc);
+  } else {
+   global.triangle[i]=0;
+   break;
+  }
+ }
+}
+
+int export_file(FILE *fp) {
+ struct triangle *to;
+ int i;
+ for(i=0;global.triangle[i];i++) {
+  to=global.triangle[i];
+  printf("%s addtriangle %d %d %d %d %d %d %d %d %d\n",to->id,to->x1,to->y1,to->z1,to->x2,to->y2,to->z2,to->x3,to->y3,to->z3);
+ }
+}
+
+
+int main(int argc,char *argv[]) {
+  char redraw=0;
+  if(argc < 2) {
+   fprintf(stderr,"usage: hackvr yourname < from_others > to_others\n");
+   return 1;
+  } else {
+   global.user=strdup(argv[1]);
+  }
+  setbuf(stdin,0);
+  setbuf(stdout,0);
+  Display *dpy = XOpenDisplay(0);
+  assert(dpy);
+  global.dpy=dpy;
+  unsigned int mask;
+  int i;
+  XEvent e;
+  XSetWindowAttributes attributes;
+  int blackColor = BlackPixel(dpy, DefaultScreen(dpy));
+  int whiteColor = //WhitePixel(dpy, DefaultScreen(dpy));
+  attributes.background_pixel=blackColor;
+  Window w = XCreateWindow(dpy,DefaultRootWindow(dpy),0,0,WIDTH*SPLIT_SCREEN,HEIGHT,1,DefaultDepth(dpy,DefaultScreen(dpy)),InputOutput,DefaultVisual(dpy,DefaultScreen(dpy))\
+                           ,CWBackPixel, &attributes);
+  global.w=w;
+  global.triangle[0]=0;//we'll allocate as we need more.
+  Window root,child;
+  XSelectInput(dpy, w, PointerMotionMask|StructureNotifyMask|ButtonPressMask|ButtonReleaseMask|ResizeRedirectMask|KeyPressMask);
+  XMapWindow(dpy, w);
+  XStoreName(dpy,w,"hackvr");
+  GC gc = XCreateGC(dpy, w, 0, 0);
+  global.gc=gc;
+  global.color_map=DefaultColormap(dpy, DefaultScreen(dpy));
+  XAllocNamedColor(dpy, global.color_map, "green", &global.green, &global.green);
+  XSetForeground(dpy, gc, global.green.pixel);
+//  XSetForeground(dpy, gc, whiteColor);
+  for(;;) {
+    load_file(stdin);
+    XNextEvent(dpy, &e);
+    redraw=1;
+    switch(e.type) {
+      case MotionNotify:
+        XQueryPointer(dpy,w,&root,&child,&global.rmousex,&global.rmousey,&global.mousex,&global.mousey,&mask);
+        break;
+      case ButtonPress:
+        global.buttonpressed=e.xbutton.button;
+        break;
+      case ButtonRelease:
+        global.buttonpressed=0;
+        break;
+      case ResizeRequest:
+        XGetGeometry(dpy,w,&root,&global.x,&global.y,&global.width,&global.height,&global.border_width,&global.depth);
+      case KeyPress:
+        switch(XLookupKeysym(&e.xkey,0)) {
+          case XK_Up:
+           //fix these to use calculated values down there.
+           //printf("%s move 0 0 1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr));
+           camera.x+=5*sinl(d2r(camera.yr)); break;
+          case XK_Down:
+           //printf("%s move 0 0 -1 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+180));
+           camera.x+=5*sinl(d2r(camera.yr+180)); break;
+          case XK_Left:
+           //printf("%s move 1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+90));
+           camera.x+=5*sinl(d2r(camera.yr+90)); break;
+          case XK_Right:
+           //printf("%s move -1 0 0 0 0 0 0 0 0\n",global.user);
+           camera.z+=5*cosl(d2r(camera.yr+270));
+           camera.x+=5*sinl(d2r(camera.yr+270)); break;
+          case XK_w:
+           //printf("%s move 0 1 0 0 0 0 0 0 0\n",global.user);
+           camera.y+=5; break;
+          case XK_s:
+           //printf("%s move 0 -1 0 0 0 0 0 0 0\n",global.user);
+           camera.y-=5; break;
+          case XK_q:
+           camera.yr+=5; break;
+          case XK_e:
+           camera.yr-=5; break;
+          case XK_Escape: return 0;
+          default:
+           redraw=0;
+           break;
+        }
+      default:
+        redraw=0;
+        break;
+    }
+    //if(redraw)
+    draw_screen(dpy,w,gc);
+  }
+  return 0;
+}
diff --git a/tests/ungets.c b/tests/ungets.c
new file mode 100644
index 0000000..7374100
--- /dev/null
+++ b/tests/ungets.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main() {
+ ungetc('a',stdin);
+ ungetc('b',stdin);
+ printf("%c",fgetc(stdin));
+ printf("%c",fgetc(stdin));
+ printf("\n");
+}