diff --git a/ConsoleGameLib/ConsoleGameLib.csproj b/ConsoleGameLib/ConsoleGameLib.csproj
index e7a1fc2..b133b32 100644
--- a/ConsoleGameLib/ConsoleGameLib.csproj
+++ b/ConsoleGameLib/ConsoleGameLib.csproj
@@ -55,7 +55,13 @@
     <Compile Include="CoreTypes\Point.cs" />
     <Compile Include="CoreTypes\Size.cs" />
     <Compile Include="Helpers\GameState.cs" />
+    <Compile Include="Helpers\MathHelper.cs" />
+    <Compile Include="PhysicsTypes\PhysicsExtensions.cs" />
+    <Compile Include="PhysicsTypes\PhysicsObject.cs" />
+    <Compile Include="PhysicsTypes\PhysicsPoint.cs" />
+    <Compile Include="PhysicsTypes\PhysicsWorld.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="PhysicsTypes\UserControlledPoint.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ConsoleGameLib/Helpers/MathHelper.cs b/ConsoleGameLib/Helpers/MathHelper.cs
new file mode 100644
index 0000000..da35d85
--- /dev/null
+++ b/ConsoleGameLib/Helpers/MathHelper.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ConsoleGameLib.Helpers
+{
+    public static class MathHelper
+    {
+        public static float Clamp(float min, float max, float val)
+        {
+            if(val > max)
+            {
+                return max;
+            }
+            if(val < min)
+            {
+                return min;
+            }
+            return val;
+        }
+        public static float ClampMin(float min, float val)
+        {
+            if(val < min)
+            {
+                return min;
+            }
+            return val;
+        }
+        public static float ClampMax(float max, float val)
+        {
+            if(val > max)
+            {
+                return max;
+            }
+            return val;
+        }
+    }
+}
diff --git a/ConsoleGameLib/PhysicsTypes/PhysicsExtensions.cs b/ConsoleGameLib/PhysicsTypes/PhysicsExtensions.cs
new file mode 100644
index 0000000..0c27ad8
--- /dev/null
+++ b/ConsoleGameLib/PhysicsTypes/PhysicsExtensions.cs
@@ -0,0 +1,59 @@
+using ConsoleGameLib.CoreTypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ConsoleGameLib.PhysicsTypes
+{
+    public static class PhysicsExtensions
+    {
+        public static bool ContainsPoint(this List<PhysicsPoint> points, Point point, bool mustInteractWithEnvironment = true)
+        {
+            foreach(PhysicsPoint entry in points)
+            {
+                if(entry.Position.X == point.X && entry.Position.Y == point.Y && (mustInteractWithEnvironment == true ? entry.InteractsWithEnvironment : true))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static Point BottomLeft(this List<PhysicsPoint> points)
+        {
+            Point lowest = points[0].Position;
+
+            foreach(PhysicsPoint point in points)
+            {
+                if(point.Position.X < lowest.X)
+                {
+                    lowest.X = point.Position.X;
+                }
+                if(point.Position.Y < lowest.Y)
+                {
+                    lowest.Y = point.Position.Y;
+                }
+            }
+            return lowest;
+        }
+
+        public static Point TopRight(this List<PhysicsPoint> points)
+        {
+            Point highest = points[0].Position;
+
+            foreach (PhysicsPoint point in points)
+            {
+                if (point.Position.X > highest.X)
+                {
+                    highest.X = point.Position.X;
+                }
+                if (point.Position.Y > highest.Y)
+                {
+                    highest.Y = point.Position.Y;
+                }
+            }
+            return highest;
+        }
+    }
+}
diff --git a/ConsoleGameLib/PhysicsTypes/PhysicsObject.cs b/ConsoleGameLib/PhysicsTypes/PhysicsObject.cs
new file mode 100644
index 0000000..d20b851
--- /dev/null
+++ b/ConsoleGameLib/PhysicsTypes/PhysicsObject.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ConsoleGameLib;
+using System.Text;
+using ConsoleGameLib.CoreTypes;
+
+namespace ConsoleGameLib.PhysicsTypes
+{
+    /// <summary>
+    /// Work in progress. Will allow for many points treated as one.
+    /// </summary>
+    public class PhysicsObject
+    {
+        public List<PhysicsPoint> Contents = new List<PhysicsPoint>();
+
+        public PhysicsWorld World;
+
+        public Point Velocity;
+
+        public bool ObeysGravity = false;
+
+        /// <summary>
+        /// True if physics should be calculated for the whole object. False if each point in the object should be calculated individually when it comes to physics.
+        /// </summary>
+        public bool Unified = true;
+
+
+        public bool InteractsWithEnvironment = false;
+
+        public PhysicsObject()
+        {
+
+        }
+
+        public void Update()
+        {
+            if (Unified)
+            {
+                bool hitsFloor = false;
+                bool hitsLeft = false;
+                bool hitsRight = false;
+                bool hitsTop = false;
+                Point bottomLeft = Contents.BottomLeft();
+                Point topRight = Contents.TopRight();
+                foreach (PhysicsPoint point in Contents)
+                {
+                    if(InteractsWithEnvironment && point.Position.Y == bottomLeft.Y && World.Contents.ContainsPoint(new Point(point.Position.X,point.Position.Y - 1)))
+                    {
+                        hitsFloor = true;
+                    }
+                    if (InteractsWithEnvironment && point.Position.Y == topRight.Y && World.Contents.ContainsPoint(new Point(point.Position.X, point.Position.Y + 1)))
+                    {
+                        hitsTop = true;
+                    }
+                    if (InteractsWithEnvironment && point.Position.Y == bottomLeft.Y && World.Contents.ContainsPoint(new Point(point.Position.X - 1, point.Position.Y)))
+                    {
+                        hitsLeft = true;
+                    }
+                    if (InteractsWithEnvironment && point.Position.Y == topRight.Y && World.Contents.ContainsPoint(new Point(point.Position.X + 1, point.Position.Y)))
+                    {
+                        hitsRight = true;
+                    }
+                }
+
+
+                foreach (PhysicsPoint point in Contents)
+                {
+                    if (hitsTop || hitsFloor)
+                    {
+                        point.Velocity.Y = 0;
+                    }
+                    if(hitsLeft || hitsRight)
+                    {
+                        point.Velocity.X = 0;
+                    }
+                }
+                
+            }
+            else
+            {
+                foreach (PhysicsPoint point in Contents)
+                {
+                    point.Update();
+                }
+            }
+        }
+
+        public void Draw()
+        {
+            foreach(PhysicsPoint point in Contents)
+            {
+                point.Draw();
+            }
+        }
+
+
+    }
+}
diff --git a/ConsoleGameLib/PhysicsTypes/PhysicsPoint.cs b/ConsoleGameLib/PhysicsTypes/PhysicsPoint.cs
new file mode 100644
index 0000000..2681879
--- /dev/null
+++ b/ConsoleGameLib/PhysicsTypes/PhysicsPoint.cs
@@ -0,0 +1,143 @@
+using ConsoleGameLib.CoreTypes;
+using ConsoleGameLib.Helpers;
+using ConsoleGameLib.PhysicsTypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleGameLib
+{
+    public class PhysicsPoint
+    {
+        public bool ObeysGravity = false;
+
+        public Point Position;
+
+        public Point Velocity = new Point(0,0);
+
+        public bool InteractsWithEnvironment = true;
+
+        public bool ObeysDrag = true;
+
+
+        public ConsoleColor DrawColor = ConsoleColor.Green;
+
+        public PhysicsWorld World;
+
+        
+
+
+        public PhysicsPoint(bool gravity, Point pos, bool interactsWithEnvironment, ConsoleColor drawColor, PhysicsWorld world)
+        {
+            ObeysGravity = gravity;
+            Position = pos;
+            InteractsWithEnvironment = interactsWithEnvironment;
+            DrawColor = drawColor;
+            World = world;
+        }
+
+
+
+        public virtual void Update()
+        {
+            Point tempVel = Velocity;
+            while (tempVel.X != 0 || tempVel.Y != 0)
+            {
+                if (tempVel.Y > 0)
+                {
+                    if (!World.Contents.ContainsPoint(new Point(Position.X, Position.Y + 1)) || !InteractsWithEnvironment)
+                    {
+                        Position.Y++;
+                        tempVel.Y--;
+                    }
+                    else if (InteractsWithEnvironment)
+                    {
+                        Velocity.Y = 0;
+                        tempVel.Y = 0;
+                    }
+                }
+                else if (tempVel.Y < 0)
+                {
+                    if (World.Contents.ContainsPoint(new Point(Position.X, Position.Y - 1)) && InteractsWithEnvironment)
+                    {
+                        Velocity.Y = 0;
+                        tempVel.Y = 0;
+
+                    }
+                    else
+                    {
+                        Position.Y--;
+                        tempVel.Y++;
+                    }
+                }
+
+                if (tempVel.X > 0)
+                {
+                    if (!World.Contents.ContainsPoint(new Point(Position.X + 1, Position.Y)) || !InteractsWithEnvironment)
+                    {
+                        Position.X++;
+                        tempVel.X--;
+                    }
+                    else if (InteractsWithEnvironment)
+                    {
+                        Velocity.X = 0;
+                        tempVel.X = 0;
+                    }
+                }
+                else if (tempVel.X < 0)
+                {
+                    if (World.Contents.ContainsPoint(new Point(Position.X - 1, Position.Y)) && InteractsWithEnvironment)
+                    {
+                        Velocity.X = 0;
+                        tempVel.X = 0;
+
+                    }
+                    else
+                    {
+                        Position.X--;
+                        tempVel.X++;
+                    }
+                }
+            }
+            if(ObeysDrag && World.CurrentDragUpdateInCycle >= World.LinearDragCalculationInterval)
+            {
+                int velX = Velocity.X;
+                if (velX != 0)
+                {
+                    Velocity.X -= Velocity.X > 0 ? World.LinearDrag : -1 * World.LinearDrag;
+                }
+                if(velX > 0 && Velocity.X < 0)
+                {
+                    Velocity.X = (int)MathHelper.ClampMin(0,Velocity.X);
+                }
+                else if(velX < 0 && Velocity.X > 0)
+                {
+                    Velocity.X = (int)MathHelper.ClampMax(0, Velocity.X);
+                }
+
+            }
+            if (ObeysGravity && World.CurrentGravityUpdateInCycle >= World.GravityCalculationInterval)
+            {
+                Velocity.Y -= Velocity.Y > World.TerminalFallVelocity ? World.GravitationalAcceleration : 0;
+                Velocity.Y = (int)MathHelper.ClampMin(World.TerminalFallVelocity,Velocity.Y);
+            }
+            if(World.Contents.ContainsPoint(new Point(Position.X,Position.Y - 1)) && InteractsWithEnvironment)
+            {
+                Velocity.Y = 0;
+            }
+
+        }
+
+        public void Draw()
+        {
+            Console.ForegroundColor = DrawColor;
+            if (Position.Y > 0 && Position.X < World.ScreenSize.Width)
+            {
+                Console.SetCursorPosition(Position.X, World.ScreenSize.Height - Position.Y);
+                Console.Write('█');
+            }
+        }
+    }
+}
diff --git a/ConsoleGameLib/PhysicsTypes/PhysicsWorld.cs b/ConsoleGameLib/PhysicsTypes/PhysicsWorld.cs
new file mode 100644
index 0000000..d96753e
--- /dev/null
+++ b/ConsoleGameLib/PhysicsTypes/PhysicsWorld.cs
@@ -0,0 +1,163 @@
+using ConsoleGameLib.CoreTypes;
+using ConsoleGameLib.PhysicsTypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleGameLib
+{
+    public class PhysicsWorld
+    {
+        private List<PhysicsPoint> points;
+
+
+               
+
+
+        public List<PhysicsPoint> Contents
+        {
+            get { return points; }
+            set { points = value; }
+
+        }
+
+        public UserControlledPoint UserPoint = null;
+
+        //public Camera PhysicsCamera = new Camera();
+
+
+
+        [Obsolete]
+        public int ScreenHeight = 20;
+        [Obsolete]
+        public int ScreenWidth = 40;
+
+        private Size screenSize;
+
+        /// <summary>
+        /// Updates between gravity calculations. 1 or below means calculate every update.
+        /// </summary>
+        public int GravityCalculationInterval = 1;
+
+        /// <summary>
+        /// Linear drag in the X direction.
+        /// </summary>
+        public int LinearDrag = 1;
+
+        /// <summary>
+        /// Updates between drag calculations. 1 or below means calculate every update.
+        /// </summary>
+        public int LinearDragCalculationInterval = 1;
+
+
+        int currentGravUpdate = 0;
+
+        int currentDragUpdate = 0;
+
+        public int CurrentGravityUpdateInCycle
+        {
+            get { return currentGravUpdate; }
+        }
+
+        public int CurrentDragUpdateInCycle
+        {
+            get { return currentDragUpdate; }
+        }
+
+        public bool ClearKeyBufferInUpdate = true;
+
+
+        public Size ScreenSize
+        {
+            get
+            {
+                return screenSize;
+            }
+            set
+            {
+                screenSize = value;
+                Console.SetBufferSize(ScreenSize.Width, ScreenSize.Height);
+            }
+        }
+
+        
+
+
+
+        public int GravitationalAcceleration = 1;
+
+
+        public int TerminalFallVelocity = -3;
+
+        public PhysicsWorld()
+            :this(new Size(Console.BufferWidth, Console.BufferHeight))
+        {
+            
+        }
+
+        public PhysicsWorld(Size screenSize)
+        {
+            ScreenSize = screenSize;
+        }
+
+        public void Update()
+        {
+            currentGravUpdate++;
+            currentDragUpdate++;
+            foreach (PhysicsPoint point in points)
+            {
+                point.World = this;
+                point.Update();
+                if (point.ObeysGravity)
+                {
+                    
+                }
+            }
+            UserPoint.World = this;
+            UserPoint.Update();
+
+            while(Console.KeyAvailable)
+            {
+                Console.ReadKey(true);
+            }
+            if(currentGravUpdate >= GravityCalculationInterval)
+            {
+                currentGravUpdate = 0;
+            }
+            if (currentDragUpdate >= LinearDragCalculationInterval)
+            {
+                currentDragUpdate = 0;
+            }
+
+        }
+
+        public void Draw()
+        {
+            Console.Clear();
+            foreach (PhysicsPoint point in points)
+            {
+                //PhysicsPoint point = pt;
+                //point.Position = new Point(point.Position.X - PhysicsCamera.DrawReferencePosition.X, point.Position.Y - PhysicsCamera.DrawReferencePosition.Y);
+                if (point.Position.X >= 0 && point.Position.X <= ScreenSize.Width && point.Position.Y > 0 && point.Position.Y <= ScreenSize.Height)
+                {
+                    point.Draw();
+                }
+            }
+            //UserControlledPoint userPoint = UserPoint;
+            //userPoint.Position = new Point(userPoint.Position.X - PhysicsCamera.DrawReferencePosition.X, userPoint.Position.Y - PhysicsCamera.DrawReferencePosition.Y);
+            if (UserPoint.Position.X >= 0 && UserPoint.Position.X <= ScreenSize.Width && UserPoint.Position.Y > 0 && UserPoint.Position.Y <= ScreenSize.Height)
+            {
+                UserPoint.Draw();
+            }
+            //if (PhysicsCamera.CursorPlacementPosition.X > 0 && PhysicsCamera.CursorPlacementPosition.X <= Console.BufferWidth && PhysicsCamera.CursorPlacementPosition.Y > 0 && PhysicsCamera.CursorPlacementPosition.Y <= Console.BufferHeight)
+            //{
+            //    Console.SetCursorPosition(PhysicsCamera.CursorPlacementPosition.X, PhysicsCamera.ViewSize.Height - PhysicsCamera.CursorPlacementPosition.Y);
+            //}
+            
+        }
+
+        
+    }
+}
diff --git a/ConsoleGameLib/PhysicsTypes/UserControlledPoint.cs b/ConsoleGameLib/PhysicsTypes/UserControlledPoint.cs
new file mode 100644
index 0000000..25afcbe
--- /dev/null
+++ b/ConsoleGameLib/PhysicsTypes/UserControlledPoint.cs
@@ -0,0 +1,72 @@
+using ConsoleGameLib.CoreTypes;
+using ConsoleGameLib.PhysicsTypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleGameLib
+{
+    public class UserControlledPoint: PhysicsPoint
+    {
+        public event EventHandler OnLegalUp;
+        public event EventHandler OnLegalLeft;
+        public event EventHandler OnLegalRight;
+        public event EventHandler OnLegalDown;
+
+
+        public bool Active = true;
+        public bool CanMoveUp = true;
+        public bool CanMoveLeft = true;
+        public bool CanMoveRight = true;
+        public bool CanMoveDown = true;
+
+        public int UpDistance = 1;
+        public int LeftDistance = 1;
+        public int DownDistance = 1;
+        public int RightDistance = 1;
+
+        public ConsoleKey MoveUpKey = ConsoleKey.W;
+        public ConsoleKey MoveLeftKey = ConsoleKey.A;
+        public ConsoleKey MoveRightKey = ConsoleKey.D;
+        public ConsoleKey MoveDownKey = ConsoleKey.S;
+
+        public UserControlledPoint(bool gravity, Point pos, bool interactsWithEnvironment, ConsoleColor drawColor, PhysicsWorld world)
+            : base(gravity,pos,interactsWithEnvironment,drawColor,world)
+        {
+            
+        }
+
+        public override void Update()
+        {
+            if(Console.KeyAvailable)
+            {
+                ConsoleKey pressedKey = Console.ReadKey(true).Key;
+
+                if(CanMoveUp && pressedKey == MoveUpKey && (!World.Contents.ContainsPoint(new Point(Position.X,Position.Y+1)) || !InteractsWithEnvironment))
+                {
+                    Position.Y+= UpDistance;
+                    OnLegalUp?.Invoke(this,EventArgs.Empty);
+                }
+                else if(CanMoveLeft && pressedKey == MoveLeftKey && (!World.Contents.ContainsPoint(new Point(Position.X - 1, Position.Y)) || !InteractsWithEnvironment))
+                {
+                    Position.X-= LeftDistance;
+                    OnLegalLeft?.Invoke(this, EventArgs.Empty);
+                }
+                else if (CanMoveRight && pressedKey == MoveRightKey && (!World.Contents.ContainsPoint(new Point(Position.X + 1, Position.Y)) || !InteractsWithEnvironment))
+                {
+                    Position.X+=RightDistance;
+                    OnLegalRight?.Invoke(this, EventArgs.Empty);
+                }
+                else if (CanMoveDown && pressedKey == MoveDownKey && (!World.Contents.ContainsPoint(new Point(Position.X, Position.Y - 1)) || !InteractsWithEnvironment))
+                {
+                    Position.Y-=DownDistance;
+                    OnLegalDown?.Invoke(this, EventArgs.Empty);
+                }
+            }
+
+            base.Update();
+        }
+    }
+}
diff --git a/ConsoleGameLibrary.sln b/ConsoleGameLibrary.sln
index 31f14ff..ebd8d5f 100644
--- a/ConsoleGameLibrary.sln
+++ b/ConsoleGameLibrary.sln
@@ -1,30 +1,50 @@
 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual C# Express 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleSnake", "ConsoleSnake\ConsoleSnake.csproj", "{9FD8D851-D491-4BB6-BA97-23F62126E777}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleGameLib", "ConsoleGameLib\ConsoleGameLib.csproj", "{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsolePong", "ConsolePong\ConsolePong.csproj", "{29766C77-DC2A-4C32-9FCC-A5004F590C5E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PhysicsPlatformer", "PhysicsPlatformer\PhysicsPlatformer.csproj", "{344CCEED-00A2-4244-A6A7-222B5139117D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
 		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Debug|x86.ActiveCfg = Debug|x86
 		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Debug|x86.Build.0 = Debug|x86
+		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Release|Any CPU.ActiveCfg = Release|x86
 		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Release|x86.ActiveCfg = Release|x86
 		{9FD8D851-D491-4BB6-BA97-23F62126E777}.Release|x86.Build.0 = Release|x86
+		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Debug|x86.ActiveCfg = Debug|x86
 		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Debug|x86.Build.0 = Debug|x86
+		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Release|Any CPU.ActiveCfg = Release|x86
 		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Release|x86.ActiveCfg = Release|x86
 		{0419B7E3-2988-44E1-B698-8B8E2ADC90A3}.Release|x86.Build.0 = Release|x86
+		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Debug|x86.ActiveCfg = Debug|x86
 		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Debug|x86.Build.0 = Debug|x86
+		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Release|Any CPU.ActiveCfg = Release|x86
 		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Release|x86.ActiveCfg = Release|x86
 		{29766C77-DC2A-4C32-9FCC-A5004F590C5E}.Release|x86.Build.0 = Release|x86
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Debug|x86.Build.0 = Debug|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Release|x86.ActiveCfg = Release|Any CPU
+		{344CCEED-00A2-4244-A6A7-222B5139117D}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/PhysicsPlatformer/App.config b/PhysicsPlatformer/App.config
new file mode 100644
index 0000000..88fa402
--- /dev/null
+++ b/PhysicsPlatformer/App.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+    </startup>
+</configuration>
\ No newline at end of file
diff --git a/PhysicsPlatformer/PhysicsPlatformer.csproj b/PhysicsPlatformer/PhysicsPlatformer.csproj
new file mode 100644
index 0000000..da5b98f
--- /dev/null
+++ b/PhysicsPlatformer/PhysicsPlatformer.csproj
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{344CCEED-00A2-4244-A6A7-222B5139117D}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>PhysicsPlatformer</RootNamespace>
+    <AssemblyName>PhysicsPlatformer</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ConsoleGameLib\ConsoleGameLib.csproj">
+      <Project>{0419b7e3-2988-44e1-b698-8b8e2adc90a3}</Project>
+      <Name>ConsoleGameLib</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/PhysicsPlatformer/Program.cs b/PhysicsPlatformer/Program.cs
new file mode 100644
index 0000000..f3c19e9
--- /dev/null
+++ b/PhysicsPlatformer/Program.cs
@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ConsoleGameLib.CoreTypes;
+using ConsoleGameLib.PhysicsTypes;
+using ConsoleGameLib;
+using System.Threading;
+
+
+namespace PhysicsPlatformer
+{
+    class Program
+    {
+
+        static void Main(string[] args)
+        {
+            PhysicsWorld world = new PhysicsWorld();
+            List<PhysicsPoint> points = new List<PhysicsPoint>();
+
+            Console.CursorVisible = false;
+
+           
+
+            world.GravitationalAcceleration = 1;
+
+            world.LinearDragCalculationInterval = 1;
+
+            UserControlledPoint userPoint = new UserControlledPoint(true,new Point(0,36),true,ConsoleColor.Blue,world);
+
+            userPoint.UpDistance = 0;
+            userPoint.RightDistance = 0;
+            userPoint.LeftDistance = 0;
+
+            userPoint.OnLegalRight += UserPoint_OnLegalRight;
+
+            userPoint.OnLegalLeft += UserPoint_OnLegalLeft;
+
+
+            userPoint.OnLegalUp += UserPoint_OnLegalUp;
+
+            world.GravityCalculationInterval = 1;
+
+
+            userPoint.MoveUpKey = ConsoleKey.Spacebar;
+            userPoint.CanMoveDown = false;
+
+            Random rand = new Random();
+
+
+            for (int i = 0; i < 15; i++)
+            {
+                points.Add(new PhysicsPoint(false,new Point(i,35),true,ConsoleColor.Green,world));
+            }
+            Point tempPos = new Point(15,35);
+
+            for (int j = 0; j < 10; j++)
+            {
+
+                int length = rand.Next(1, 10);
+
+                tempPos.Y += rand.Next(0, 2);
+                tempPos.X += rand.Next(1, 3);
+
+                for (int i = 0; i < length; i++)
+                {
+                    points.Add(new PhysicsPoint(false, new Point(tempPos.X, tempPos.Y), true, ConsoleColor.Green, world));
+                    tempPos.X++;
+                }
+            }
+            /*for (int j = 0; j < 10; j++)
+            {
+
+                int length = rand.Next(1, 10);
+
+                tempPos.Y += rand.Next(-1, 1);
+                tempPos.X += rand.Next(1, 3);
+
+                for (int i = 0; i < length; i++)
+                {
+                    points.Add(new PhysicsPoint(false, new Point(tempPos.X, tempPos.Y), true, ConsoleColor.Green, world));
+                    tempPos.X++;
+                }
+            }*/
+
+            world.UserPoint = userPoint;
+            world.Contents = points;
+
+            while(true)
+            {
+                
+                //world.PhysicsCamera.DrawReferencePosition = new Point(/*world.UserPoint.Position.X - 3, 27*/0,0);
+
+                world.Update();
+
+                world.Draw();
+
+                if (userPoint.Position.Y <= 10)
+                {
+                    userPoint.Position = new Point(0,36);
+                }
+
+
+
+                Thread.Sleep(50);
+
+                
+
+
+            }
+
+        }
+
+        private static void UserPoint_OnLegalLeft(object sender, EventArgs e)
+        {
+            ((UserControlledPoint)sender).Velocity.X-= 1;
+        }
+
+        private static void UserPoint_OnLegalRight(object sender, EventArgs e)
+        {
+            ((UserControlledPoint)sender).Velocity.X+= 1;
+        }
+
+        private static void UserPoint_OnLegalUp(object sender, EventArgs e)
+        {
+            UserControlledPoint sendPoint = (UserControlledPoint)sender;
+            if (sendPoint.World.Contents.ContainsPoint(new Point(sendPoint.Position.X, sendPoint.Position.Y - 1)) && sendPoint.Velocity.Y == 0)
+            {
+                sendPoint.Velocity.Y += 3;
+            }
+        }
+    }
+}
diff --git a/PhysicsPlatformer/Properties/AssemblyInfo.cs b/PhysicsPlatformer/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..b4d82b6
--- /dev/null
+++ b/PhysicsPlatformer/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("PhysicsPlatformer")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("PhysicsPlatformer")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("344cceed-00a2-4244-a6a7-222b5139117d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]