diff --git a/src/Line.java b/src/Line.java
index 0968350..24acda2 100644
--- a/src/Line.java
+++ b/src/Line.java
@@ -35,8 +35,8 @@
                 try {
                     img.setRGB(returnVal[0], returnVal[1], Color.HSBtoRGB(1, 1, 1));
                 }
-                catch (ArrayIndexOutOfBoundsException ref){
-                    System.out.println(returnVal[0] + " " + returnVal[1]);
+                catch (ArrayIndexOutOfBoundsException ignored){
+                    // System.out.println(returnVal[0] + " " + returnVal[1]);
                 }
             }
         } else {
@@ -45,8 +45,8 @@
                 try {
                     img.setRGB(returnVal[0], returnVal[1], Color.HSBtoRGB(.5f, 1, 1));
                 }
-                catch (ArrayIndexOutOfBoundsException ref){
-                    System.out.println(returnVal[0] + " " + returnVal[1]);
+                catch (ArrayIndexOutOfBoundsException ignored){
+                    // System.out.println(returnVal[0] + " " + returnVal[1]);
                 }
             }
         }
@@ -125,7 +125,7 @@
         }
         else {
             is_initialised = false;
-            return null;
+            throw new RuntimeException("Accessed too many line pixels");
         }
         iteratorVal += 1;
         return returnVal;
diff --git a/src/Matrix.java b/src/Matrix.java
new file mode 100644
index 0000000..3a75712
--- /dev/null
+++ b/src/Matrix.java
@@ -0,0 +1,63 @@
+public class Matrix {
+    protected int x;
+    protected int y;
+    private double[][] items;
+
+    public Matrix(int _x, int _y){
+        x = _x; y= _y;
+        items = new double[y][x];
+    }
+    public double item(int _x, int _y){
+        return items[_y][_x];
+    }
+    public void setItem(int _x, int _y, double val){
+        items[_y][_x] = val;
+    }
+    public double[][] getItems() {
+        return items;
+    }
+    public void setItems(double[][] newItems){
+        items = newItems;
+    }
+    public Matrix multiply(Matrix mult) {
+        Matrix result = new Matrix(mult.x, this.y);
+        double newItem;
+        if(x==mult.y){
+            for(int rx = 0; rx< result.x; rx+=1){
+                for(int ry = 0; ry< result.y; ry+=1){
+                    newItem = 0;
+                    for(int i = 0; i<x; i+=1){
+                        newItem += this.item(i, ry)*mult.item(rx, i);
+                    }
+                    result.setItem(rx, ry, newItem);
+            }}
+        } else {
+            throw new RuntimeException("wrong dimensions");
+        }
+        return result;
+    }
+    public Point3D multiplyPoint3(Point3D point) {
+        double px;double py; double pz;
+        if(x==3){
+            px = point.x * item(0,0) + point.y*item(1,0) + point.z*item(2,0);
+            py = point.x * item(0,1) + point.y*item(1,1) + point.z*item(2,1);
+            pz = point.x * item(0,2) + point.y*item(1,2) + point.z*item(2,2);
+        } else if(x == 4){
+            px = point.x * item(0,0) + point.y*item(1,0) + point.z*item(2,0) + item(3,0);
+            py = point.x * item(0,1) + point.y*item(1,1) + point.z*item(2,1) + item(3,1);
+            pz = point.x * item(0,2) + point.y*item(1,2) + point.z*item(2,2) + item(3,2);
+        } else {throw new RuntimeException("wrong-dimensions");}
+        return new Point3D(px, py, pz);
+    }
+    public Point2D multiplyPoint2(Point3D point) throws Exception {
+        double px;double py;
+        if(x==2){
+            px = point.x * item(0,0) + point.y*item(0,1);
+            py = point.x * item(1,0) + point.y*item(1,1);
+        } else if(x == 3){
+            px = point.x * item(0,0) + point.y*item(0,1) + item(0,2);
+            py = point.x * item(1,0) + point.y*item(1,1) + item(1,2);
+        } else {throw new Exception("wrong-dimensions");}
+        return new Point2D(px, py);
+    }
+}
diff --git a/src/Player.java b/src/Player.java
index d3c4d71..254d203 100644
--- a/src/Player.java
+++ b/src/Player.java
@@ -1,3 +1,5 @@
+import sun.awt.motif.X11CNS11643;
+
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
@@ -9,9 +11,12 @@
     // image that represents the player's position on the board
     private BufferedImage image;
     // current position of the player on the board grid
-    private Point3D position;
-    private Point3D rotation;
-
+    public Matrix camMatrix;
+    public double Fpdis = 0.4;
+    private Point3D position = new Point3D(-30,0,0);
+    private Point3D rotation = new Point3D(0,Math.PI / 2, 0);
+    private Point3D direction = new Point3D(0,0,0);
+    public double mouseSensitivity = 0.005; // radians per pixel
     // called when the player is initialised
     public Player() {
     }
@@ -34,21 +39,90 @@
     }
 
     public void keyPressed(int key) {
-        if (key == KeyEvent.VK_UP) {
-        }
-        if (key == KeyEvent.VK_RIGHT) {
-        }
-        if (key == KeyEvent.VK_DOWN) {
-        }
-        if (key == KeyEvent.VK_LEFT) {
+        if (key == KeyEvent.VK_W) {
+            direction.x = 1;
+        } else if (key == KeyEvent.VK_S) {
+            direction.x = -1;
+        } else if (key == KeyEvent.VK_A) {
+            direction.y = -1;
+        } else if (key == KeyEvent.VK_D) {
+            direction.y = 1;
+        } else if (key == KeyEvent.VK_SPACE) {
+            direction.z = 1;
+        } else if (key == KeyEvent.VK_SHIFT) {
+            direction.z = -1;
         }
     }
     public void keyReleased(int key){
-
+        if (key == KeyEvent.VK_W) {
+            direction.x = 0;
+        } else if (key == KeyEvent.VK_S) {
+            direction.x = 0;
+        } else if (key == KeyEvent.VK_A) {
+            direction.y = 0;
+        } else if (key == KeyEvent.VK_D) {
+            direction.y = 0;
+        } else if (key == KeyEvent.VK_SPACE) {
+            direction.z = 0;
+        } else if (key == KeyEvent.VK_SHIFT) {
+            direction.z = 0;
+        }
     }
     public void tick(Point2D mouseRel) {
-        // System.out.println(mouseRel.x + " " + mouseRel.y);
         // gets called once every tick, before the repainting process happens.
+        // change rotation depending on mouse movement
+        rotation.z += mouseRel.x * mouseSensitivity;
+        rotation.y += mouseRel.y * mouseSensitivity;
+        // calculate direction vector to translate position by
+        Matrix zMat = new Matrix(3, 3);
+        zMat.setItems(new double[][]{
+                {Math.cos(rotation.z),  Math.sin(rotation.z), 0},
+                {-Math.sin(rotation.z), Math.cos(rotation.z), 0},
+                {0,                      0,                     1}}
+        );
+        Matrix yMat = new Matrix(3, 3);
+        yMat.setItems(new double[][]{
+                {Math.cos(rotation.y), 0, -Math.sin(rotation.y)},
+                {0,                    1, 0                    },
+                {Math.sin(rotation.y), 0, Math.cos(rotation.y) }}
+        );
+        Matrix xMat = new Matrix(3, 3);
+        xMat.setItems(new double[][]{
+                {1, 0,                    0                   },
+                {0, Math.cos(rotation.x), Math.sin(rotation.x)},
+                {0, -Math.sin(rotation.x), Math.cos(rotation.x)}}
+        );
+        Matrix izMat = new Matrix(3, 3);
+        izMat.setItems(new double[][]{
+                {Math.cos(-rotation.z),  Math.sin(-rotation.z), 0},
+                {-Math.sin(-rotation.z), Math.cos(-rotation.z), 0},
+                {0,                      0,                     1}}
+        );
+        // apply zmat to direction vector
+        try {
+            Point3D dirvec = izMat.multiplyPoint3(direction);
+            position.translate(dirvec);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+        Matrix traMat = new Matrix(4, 3);
+        traMat.setItems(new double[][]
+                {{1, 0, 0, -position.x},
+                 {0, 1, 0, -position.y},
+                 {0, 0, 1, -position.z}}
+        );
+        // multiply out camera matrix
+        try {
+            //camMatrix = ((zMat.multiply(yMat)).multiply(xMat)).multiply(traMat);
+//            camMatrix = zMat.multiply(yMat);
+//            camMatrix = camMatrix.multiply(xMat);
+//            camMatrix = camMatrix.multiply(traMat);
+            camMatrix = xMat.multiply(yMat);
+            camMatrix = camMatrix.multiply(zMat);
+            camMatrix = camMatrix.multiply(traMat);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
     }
 
     // returnValue Functions
diff --git a/src/Point3D.java b/src/Point3D.java
index 7aa557d..e45488b 100644
--- a/src/Point3D.java
+++ b/src/Point3D.java
@@ -1,7 +1,7 @@
 public class Point3D {
-    private double x;
-    private double y;
-    private double z;
+    public double x;
+    public double y;
+    public double z;
 
     public Point3D(double _x, double _y, double _z){
         x = _x;
@@ -13,6 +13,17 @@
         y = _new[1];
         z = _new[2];
     }
+    public void translate(Point3D trVec){
+        x += trVec.x;
+        y += trVec.y;
+        z += trVec.z;
+    }
+    public Point2D project(double fpdis, int scrX, int scrY){
+        return new Point2D(
+                (((fpdis*y)/z + .5)*scrX),
+                (((fpdis*x)/z + .5)*scrY)
+        );
+    }
     public double[] get(){
         return new double[]{x, y, z};
     }
diff --git a/src/Screen.java b/src/Screen.java
index fb2b209..0fdf4de 100644
--- a/src/Screen.java
+++ b/src/Screen.java
@@ -1,6 +1,7 @@
 import java.awt.*;
 import java.awt.event.*;
 import java.awt.image.BufferedImage;
+import java.util.ArrayList;
 import javax.swing.*;
 
 public class Screen extends JPanel implements ActionListener, KeyListener, MouseListener, MouseMotionListener {
@@ -9,12 +10,16 @@
         // mouse
     private boolean captured = true;
     private final Point2D mouseRel = new Point2D(0d,0d);
-    //private final Cursor invisibleCursor;
+    private Cursor invisibleCursor;
 
         // testing
-    private Line line = new Line(new Point2D(200, 200),
-                                 new Point2D(1, 1));
-    private Triangle Triangle = new Triangle(new Point2D(200, 200), new Point2D(1, 1), new Point2D(400,200));
+    //private Line line = new Line(new Point2D(200, 200),new Point2D(1, 1));
+    //private Triangle Triangle = new Triangle(new Point2D(200, 200), new Point2D(1, 1), new Point2D(400,200));
+    private Point3D[] points = new Point3D[]{
+            new Point3D(1,1,-1),
+        new Point3D(-1, 1, -1),
+        new Point3D(-1, -1, -1),
+        new Point3D(1, -1, -1)};
     double ang = 0;
     // __config variables__
     // controls the delay between each tick in ms
@@ -41,8 +46,8 @@
         Toolkit toolkit = Toolkit.getDefaultToolkit();
         Point hotSpot = new Point(0,0);
         BufferedImage cursorImage = new BufferedImage(1, 1, BufferedImage.TRANSLUCENT);
-        //invisibleCursor = toolkit.createCustomCursor(cursorImage, hotSpot, "InvisibleCursor");
-        //setCursor(invisibleCursor);
+        invisibleCursor = toolkit.createCustomCursor(cursorImage, hotSpot, "InvisibleCursor");
+        setCursor(invisibleCursor);
 
         // initialize the game state
         player = new Player();
@@ -80,12 +85,37 @@
     }
     private void drawScreen(Graphics g) {
         BufferedImage img = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB );
-        line.point2.x = 100*Math.sin(ang) + 200;
-        line.point2.y = 100*Math.cos(ang) + 200;
-        Triangle.point2.x = 100*Math.sin(ang+3) + 200;
-        Triangle.point2.y = 100*Math.cos(ang+3) + 200;
-        line.draw(img);
-        Triangle.draw(img);
+//        line.point2.x = 100*Math.sin(ang) + 200;
+//        line.point2.y = 100*Math.cos(ang) + 200;
+//        Triangle.point2.x = 100*Math.sin(ang+3) + 200;
+//        Triangle.point2.y = 100*Math.cos(ang+3) + 200;
+//        line.draw(img);
+        ArrayList<Point3D> newPoints = new ArrayList<Point3D>();
+        for (Point3D point: points) {
+            Point3D _new = player.camMatrix.multiplyPoint3((point));
+            if(_new.z > .1) {
+                newPoints.add(_new);
+            } else{
+                newPoints.add(null);
+            }
+        }
+        Triangle t1 = null;
+        Triangle t2 = null;
+        try {
+            t1 = new Triangle(
+                    newPoints.get(0).project(player.Fpdis, getWidth(), getHeight()),
+                    newPoints.get(1).project(player.Fpdis, getWidth(), getHeight()),
+                    newPoints.get(2).project(player.Fpdis, getWidth(), getHeight()));
+        } catch(NullPointerException ignored){}
+        try{
+            t2 = new Triangle(
+                newPoints.get(0).project(player.Fpdis, getWidth(), getHeight()),
+                newPoints.get(2).project(player.Fpdis, getWidth(), getHeight()),
+                newPoints.get(3).project(player.Fpdis, getWidth(), getHeight()));
+        } catch(NullPointerException ignored){}
+
+        try{t1.draw(img);}catch (NullPointerException ignored){}
+        try{t2.draw(img);}catch (NullPointerException ignored){}
         ang += 0.02;
         g.drawImage(img, 0, 0, this);
 
@@ -107,7 +137,11 @@
     }
 
     @Override
-    public void keyReleased(KeyEvent e) {}
+    public void keyReleased(KeyEvent e) {
+        int key = e.getKeyCode();
+
+        player.keyReleased(key);
+    }
 
     // gets the relative position of the mouse since the last time this function was called
     public Point2D get_mouse_rel(){
@@ -136,7 +170,7 @@
     public void mouseClicked(MouseEvent mouseEvent) {
         if (mouseEvent.getButton() == MouseEvent.BUTTON1){
             captured = true;
-            //setCursor(invisibleCursor);
+            setCursor(invisibleCursor);
         }
     }
 
diff --git a/src/Triangle.java b/src/Triangle.java
index 5356e41..7c85ed3 100644
--- a/src/Triangle.java
+++ b/src/Triangle.java
@@ -23,7 +23,8 @@
     }
     public void draw(BufferedImage img){
         if (!is_initialised){initialise();}
-        int[] point1 = new int[]{0,0}; int[] point2 = new int[]{0, 0};
+        int[] point1 = new int[]{0, 0};
+        int[] point2 = new int[]{0, 0};
         int lastX = 0;
         int lastXLong = 0;
         char currentLine = 'A';
@@ -39,8 +40,8 @@
             }
             while(lastX == point2[0]) {
                 if (currentLine == 'A') {
-                    point2 = LineA.nextPix();
-                    if (point2 == null) {
+                    try{point2 = LineA.nextPix();}
+                    catch (RuntimeException e){
                         currentLine = 'B';
                         point2 = LineB.nextPix();
                     }
@@ -52,14 +53,22 @@
             lastXLong = point1[0];
             lastX = point2[0];
             if(point1[1] < point2[1]) {
-                for (int y = point1[1]; y <= point2[1]; y += 1) {img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));
+                for (int y = point1[1]; y <= point2[1]; y += 1) {
+                    try{img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));}
+                    catch(ArrayIndexOutOfBoundsException ignored){}
             }} else {
-                for (int y = point2[1]; y <= point1[1]; y += 1) {img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));
-            }}
+                for (int y = point2[1]; y <= point1[1]; y += 1) {
+                    try{img.setRGB(x, y, Color.HSBtoRGB(.5f, 1, 1));}
+                    catch(ArrayIndexOutOfBoundsException ignored){}
+
+                }}
         }
         is_initialised = false;
     }
     public void initialise(){
+        if (point1 == null || point2 == null || point3 == null){
+            throw new NullPointerException();
+        }
         min = new Point2D(Math.min(point1.x, Math.min(point2.x, point3.x)), Math.min(point1.y, Math.min(point2.y, point3.y)));
         max = new Point2D(Math.max(point1.x, Math.max(point2.x, point3.x)), Math.max(point1.y, Math.max(point2.y, point3.y)));
         // woo horrible IFs mess.