Complete Box2D to Planck.js migration

- Replace Box2D.js with Planck.js physics engine
- Update all require paths from 'Lib/Vendor/Box2D' to 'Lib/Vendor/Planck'
- Convert Box2D contact listeners to Planck.js event system
- Fix all method name capitalization (Get* -> get*, Set* -> set*)
- Update collision detection system for Planck.js compatibility
- Server now starts successfully and basic physics working
- Character can land on platforms - core physics functional

Major milestone: Game now running on modern, maintained physics engine

app/Game/Client/View/Pixi/DebugDraw.js

@@ -1,5 +1,5 @@
 define([
-    "Lib/Vendor/Box2D"
+    "Lib/Vendor/Planck"
 ],
  
 function (Box2D) {

app/Game/Client/View/Pixi/PlanckDebugDraw.js

@@ -0,0 +1,154 @@
+define([
+    "Game/Config/Settings"
+],
+
+function (Settings) {
+
+    "use strict";
+
+    function PlanckDebugDraw(canvas) {
+        this.canvas = canvas;
+        this.ctx = canvas.getContext('2d');
+        this.scale = Settings.RATIO;
+        this.flags = {
+            shapes: true,
+            joints: false,
+            aabb: false,
+            pairs: false,
+            centerOfMass: false
+        };
+    }
+
+    PlanckDebugDraw.prototype.clear = function() {
+        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    };
+
+    PlanckDebugDraw.prototype.drawWorld = function(world) {
+        if (!this.flags.shapes) return;
+
+        this.ctx.save();
+        this.ctx.scale(this.scale, this.scale);
+        this.ctx.lineWidth = 1 / this.scale;
+
+        // Iterate through all bodies
+        for (var body = world.getBodyList(); body; body = body.getNext()) {
+            var transform = body.getTransform();
+            
+            // Iterate through all fixtures
+            for (var fixture = body.getFixtureList(); fixture; fixture = fixture.getNext()) {
+                var shape = fixture.getShape();
+                
+                if (body.isDynamic()) {
+                    this.ctx.strokeStyle = '#ff0000'; // Red for dynamic bodies
+                    this.ctx.fillStyle = 'rgba(255, 0, 0, 0.1)';
+                } else if (body.isStatic()) {
+                    this.ctx.strokeStyle = '#00ff00'; // Green for static bodies
+                    this.ctx.fillStyle = 'rgba(0, 255, 0, 0.1)';
+                } else {
+                    this.ctx.strokeStyle = '#0000ff'; // Blue for kinematic bodies
+                    this.ctx.fillStyle = 'rgba(0, 0, 255, 0.1)';
+                }
+
+                this.drawShape(shape, transform);
+            }
+        }
+
+        this.ctx.restore();
+    };
+
+    PlanckDebugDraw.prototype.drawShape = function(shape, transform) {
+        var type = shape.getType();
+        
+        if (type === 'circle') {
+            this.drawCircle(shape, transform);
+        } else if (type === 'polygon') {
+            this.drawPolygon(shape, transform);
+        } else if (type === 'edge') {
+            this.drawEdge(shape, transform);
+        } else if (type === 'chain') {
+            this.drawChain(shape, transform);
+        }
+    };
+
+    PlanckDebugDraw.prototype.drawCircle = function(shape, transform) {
+        var center = transform.p;
+        var radius = shape.getRadius();
+        
+        this.ctx.beginPath();
+        this.ctx.arc(center.x, center.y, radius, 0, 2 * Math.PI);
+        this.ctx.fill();
+        this.ctx.stroke();
+        
+        // Draw radius line to show rotation
+        this.ctx.beginPath();
+        this.ctx.moveTo(center.x, center.y);
+        this.ctx.lineTo(center.x + radius, center.y);
+        this.ctx.stroke();
+    };
+
+    PlanckDebugDraw.prototype.drawPolygon = function(shape, transform) {
+        var vertices = shape.m_vertices;
+        if (!vertices || vertices.length < 3) return;
+
+        this.ctx.beginPath();
+        
+        // Transform first vertex
+        var v = this.transformVertex(vertices[0], transform);
+        this.ctx.moveTo(v.x, v.y);
+        
+        // Transform and draw remaining vertices
+        for (var i = 1; i < vertices.length; i++) {
+            v = this.transformVertex(vertices[i], transform);
+            this.ctx.lineTo(v.x, v.y);
+        }
+        
+        this.ctx.closePath();
+        this.ctx.fill();
+        this.ctx.stroke();
+    };
+
+    PlanckDebugDraw.prototype.drawEdge = function(shape, transform) {
+        var v1 = this.transformVertex(shape.m_vertex1, transform);
+        var v2 = this.transformVertex(shape.m_vertex2, transform);
+        
+        this.ctx.beginPath();
+        this.ctx.moveTo(v1.x, v1.y);
+        this.ctx.lineTo(v2.x, v2.y);
+        this.ctx.stroke();
+    };
+
+    PlanckDebugDraw.prototype.drawChain = function(shape, transform) {
+        var vertices = shape.m_vertices;
+        if (!vertices || vertices.length < 2) return;
+
+        this.ctx.beginPath();
+        
+        var v = this.transformVertex(vertices[0], transform);
+        this.ctx.moveTo(v.x, v.y);
+        
+        for (var i = 1; i < vertices.length; i++) {
+            v = this.transformVertex(vertices[i], transform);
+            this.ctx.lineTo(v.x, v.y);
+        }
+        
+        this.ctx.stroke();
+    };
+
+    PlanckDebugDraw.prototype.transformVertex = function(vertex, transform) {
+        // Apply transform: rotated_vertex = transform.q * vertex + transform.p
+        var cos = Math.cos(transform.q.getAngle());
+        var sin = Math.sin(transform.q.getAngle());
+        
+        return {
+            x: transform.p.x + (cos * vertex.x - sin * vertex.y),
+            y: transform.p.y + (sin * vertex.x + cos * vertex.y)
+        };
+    };
+
+    PlanckDebugDraw.prototype.setFlags = function(flags) {
+        this.flags = flags;
+    };
+
+    return PlanckDebugDraw;
+
+});