Started work on Player.cs class, converted our OG movement script to C# and implemented as a method in Player class.

Player.cs

@@ -0,0 +1,132 @@
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace LunaLightXMG
+{
+    internal class Player
+    {
+        // Declare variables
+        private float hsp;                  // Horizontal speed
+        private float vsp;                  // Vertical speed
+        private float wallJumpDelay;        // Delay for wall jumping
+        private bool grounded;              // Is the player grounded?
+        private bool walled;                // Is the player wall sliding?
+        private float hsp_acc;              // Horizontal acceleration
+        private float hsp_friction_ground;  // Ground friction
+        private float hsp_friction_air;     // Air friction
+        private float hsp_walk;             // Maximum horizontal speed
+        private float grv;                  // Gravity
+        private float vsp_max;              // Maximum vertical speed
+        private float grv_wall;             // Gravity when wall sliding
+        private float vsp_max_wall;         // Maximum vertical speed when wall sliding
+        private float vsp_jump;             // Jump speed
+
+        // Player position
+        public Vector2 Position;
+
+        // Placeholder for key input states
+        private bool key_left;
+        private bool key_right;
+
+        // Constructor to initialize variables
+        public Player()
+        {
+            // Initialize your variables here
+            hsp = 0;
+            vsp = 0;
+            wallJumpDelay = 0;
+            grounded = false;
+            walled = false;
+            hsp_acc = 0.5f;
+            hsp_friction_ground = 0.2f;
+            hsp_friction_air = 0.1f;
+            hsp_walk = 4f;
+            //grv = 0.5f;
+            grv = 0.0f;     // No grav until we have walls, bounding boxes, etc..
+            vsp_max = 10f;
+            grv_wall = 0.1f;
+            vsp_max_wall = 5f;
+            vsp_jump = -10f;
+
+            Position = new Vector2(163, 63); // Initialize player position
+        }
+
+        // Update method to handle movement logic
+        public void Update(GameTime gameTime)
+        {
+            HandleInput();
+            Movement();
+
+            // Update player position based on speed
+            Position.X += hsp;
+            Position.Y += vsp;
+        }
+
+        private void Movement()
+        {
+            // Horizontal movement with acceleration + wall jump delay
+            wallJumpDelay = Math.Max(wallJumpDelay - 1, 0); // counts down every frame
+
+            if (wallJumpDelay == 0) // no left-right control until delay is 0, prevents rapid wall climb
+            {
+                float move_h = (key_right ? 1 : 0) - (key_left ? 1 : 0);
+                hsp += move_h * hsp_acc;
+
+                if (move_h == 0)
+                {
+                    float hsp_friction_final = grounded ? hsp_friction_ground : hsp_friction_air;
+                    hsp = Approach(hsp, 0, hsp_friction_final);
+                }
+
+                hsp = MathHelper.Clamp(hsp, -hsp_walk, hsp_walk);
+            }
+
+            // Calculate vertical movement
+            float grv_final = grv;
+            float vsp_max_final = vsp_max;
+
+            if (walled && vsp > 0)
+            {
+                grv_final = grv_wall;
+                vsp_max_final = vsp_max_wall;
+            }
+
+            vsp += (vsp == 0 ? grv_final * 2 : grv_final);
+            vsp = MathHelper.Clamp(vsp, vsp_jump, vsp_max_final);
+        }
+
+        // Helper method to smoothly approach a target value
+        private float Approach(float start, float end, float shift)
+        {
+            if (start < end)
+            {
+                start += shift;
+                if (start > end)
+                    return end;
+            }
+            else
+            {
+                start -= shift;
+                if (start < end)
+                    return end;
+            }
+            return start;
+        }
+
+        // Placeholder for key input handling (to be connected to actual input handling logic)
+        private void HandleInput()
+        {
+            KeyboardState keyboardState = Keyboard.GetState();
+            key_left = keyboardState.IsKeyDown(Keys.A); 
+            key_right = keyboardState.IsKeyDown(Keys.D);
+        }
+
+        public void Draw(SpriteBatch spriteBatch, Texture2D texture)
+        {
+            spriteBatch.Draw(texture, Position, Color.White);
+        }
+    }
+
+}