@{
   ViewBag.Title = "Planck";
}

@section Styles {

}

<h4>Car with Planck 2D physics</h4>
<p>
    Keyboard:: Left-right keys: accelerate, up-down: spring frequency.
    Mobile:: touch: accelerate
</p>
<div style="padding: 5px 0 15px;">
    <div id="editor" style="height: 100px; width: 100%"></div>
</div>
<button id="run">Run Code</button>
<div style="padding: 0 0 10px;"></div>
<canvas id="stage" style="width: 100%; height: 100%;"></canvas>

@section Scripts {

    <!--<script src="https://cdn.jsdelivr.net/planck/0.1/planck-with-testbed.js"></script>-->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.2.3/ace.js" type="text/javascript" charset="utf-8"></script>
    <!--<script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.2.3/mode-csharp.js" type="text/javascript" charset="utf-8"></script>-->
    <script src="/static/portfolio/Scripts/planckjs/planck-with-testbed.js"></script>

    <script>
        /*
         * Copyright (c) 2016-2017 Ali Shakiba http://shakiba.me/planck.js
         * Copyright (c) 2006-2011 Erin Catto  http://www.box2d.org
         *
         * This software is provided 'as-is', without any express or implied
         * warranty.  In no event will the authors be held liable for any damages
         * arising from the use of this software.
         * Permission is granted to anyone to use this software for any purpose,
         * including commercial applications, and to alter it and redistribute it
         * freely, subject to the following restrictions:
         * 1. The origin of this software must not be misrepresented; you must not
         * claim that you wrote the original software. If you use this software
         * in a product, an acknowledgment in the product documentation would be
         * appreciated but is not required.
         * 2. Altered source versions must be plainly marked as such, and must not be
         * misrepresented as being the original software.
         * 3. This notice may not be removed or altered from any source distribution.
         */

        // This is a fun demo that shows off the wheel joint
        $(document).ready(function () {

            //var ed = editor.getValue();
            //eval(ed);
            var editor = ace.edit("editor");
            editor.setTheme("ace/theme/monokai");
            editor.getSession().setMode("ace/mode/javascript");
            //editor.getSession().setMode("ace/mode/csharp");
            //editor.setKeyboardHandler("ace/keyboard/vim");
            editor.$blockScrolling = Infinity;

            $('#run').on('click', function () {
                eval(editor.getValue());
            });
        });

        planck.testbed('Car', function (testbed) {

            testbed.speed = 1.3;
            testbed.hz = 1 / 50;

            testbed.height = 40;
            testbed.width = 100;

            var pl = planck, Vec2 = pl.Vec2;
            var world = new pl.World({
                gravity: Vec2(0, -10)
            });

            // wheel spring settings
            var HZ = 4.0;
            var ZETA = 0.7;
            var SPEED = 50.0;

            var ground = world.createBody();

            var groundFD = {
                density: 0.0,
                friction: 0.6
            };

            var terrain = {
                "none": 0,
                "flat": 1,
                "hills": 2,
                "mountains": 3,
                "bridge": 4,
                "boxes": 5,
                "jump": 6,
                "teeter": 999,
                "max": 5
            };
            testbed.landOrigin = -20.0; // where the land "starts" (so we can delete old land)
            testbed.landX = -20.0; // current location where we add new "land"
            testbed.landY = 0.0;
            hillScale = 2.0;
            hillHalf = hillScale / 2.0;
            mountainScale = 5.0;
            mountainHalf = mountainScale / 2.0;
            testbed.makeLand = function (ti) {
                if (testbed.lastTerrain == terrain.bridge) {
                    ti = terrain.flat;
                } else {
                    ti = ti || Math.round(Math.random() * terrain.max);
                }
                //ti = terrain.flat;
                var x = testbed.landX, y1 = testbed.landY, y2 = y1, dx = 5.0;
                //debugger;
                switch (ti) {
                    case terrain.flat:
                        ground.createFixture(pl.Edge(Vec2(x, y1), Vec2(x + 20.0, y1)), groundFD);
                        x += 20.0;
                        break;
                    case terrain.hills:
                        for (var i = 0; i < 10; ++i) {
                            var y2 = y1 + Math.round(Math.random() * hillScale) - hillHalf;
                            ground.createFixture(pl.Edge(Vec2(x, y1), Vec2(x + dx, y2)), groundFD);
                            y1 = y2;
                            x += dx;
                        }
                        break;
                    case terrain.mountains:
                        for (var i = 0; i < 10; ++i) {
                            var y2 = y1 + Math.round(Math.random() * mountainScale) - mountainHalf;
                            ground.createFixture(pl.Edge(Vec2(x, y1), Vec2(x + dx, y2)), groundFD);
                            y1 = y2;
                            x += dx;
                        }
                        break;
                    case terrain.bridge:
                        // Bridge
                        var bridgeFD = {};
                        bridgeFD.density = 1.0;
                        bridgeFD.friction = 0.6;

                        var prevBody = ground;
                        for (var i = 0; i < 20; ++i) {
                            //    var bridgeBlock = world.createDynamicBody(Vec2(161.0 + 2.0 * i, -0.125));
                            var bridgeBlock = world.createDynamicBody(Vec2(x + 2.0 * i, y1 - 0.125));
                            bridgeBlock.createFixture(pl.Box(1.0, 0.125), bridgeFD);

                            world.createJoint(pl.RevoluteJoint({}, prevBody, bridgeBlock, Vec2(x + 2.0 * i, y1 - 0.125)));

                            prevBody = bridgeBlock;
                        }

                        world.createJoint(pl.RevoluteJoint({}, prevBody, ground, Vec2(x + 2.0 * i, y1 - 0.125)));
                        x += 40.0;
                        break;
                    case terrain.teeter:
                        // Teeter
                        var teeter = world.createDynamicBody(Vec2(x, y1 + 1.0));
                        teeter.createFixture(pl.Box(10.0, 0.25), y1 + 1.0);
                        world.createJoint(pl.RevoluteJoint({
                            lowerAngle: -8.0 * Math.PI / 180.0,
                            upperAngle: 8.0 * Math.PI / 180.0,
                            enableLimit: true
                        }, ground, teeter, teeter.getPosition()));

                        teeter.applyAngularImpulse(100.0, true);
                        break;
                    case terrain.boxes:
                        // Boxes
                        var box = pl.Box(0.5, 0.5);

                        world.createDynamicBody(Vec2(x, y1 + 0.5))
                          .createFixture(box, 0.5);

                        world.createDynamicBody(Vec2(x, y1 + 1.5))
                          .createFixture(box, 0.5);

                        world.createDynamicBody(Vec2(x, y1 + 2.5))
                          .createFixture(box, 0.5);

                        world.createDynamicBody(Vec2(x, y1 + 3.5))
                          .createFixture(box, 0.5);

                        world.createDynamicBody(Vec2(x, y1 + 4.5))
                          .createFixture(box, 0.5);
                        break;
                    default:

                }
                //debugger;
                testbed.landX = x;
                testbed.landY = y2;
                testbed.lastTerrain = ti;
            }
            testbed.makeLand(terrain.flat);
            //testbed.makeLand(terrain.bridge);
            //testbed.makeLand(terrain.flat);
            //testbed.makeLand(terrain.hills);
            //testbed.makeLand(terrain.bridge);
            //testbed.makeLand(terrain.flat);
            //testbed.makeLand(terrain.mountains);
            //testbed.makeLand(terrain.bridge);
            //testbed.makeLand(terrain.mountains);
            for (var i = 0; i < 5; i++) {
                testbed.makeLand();
            }
            //ground.createFixture(pl.Edge(Vec2(-20.0, 0.0), Vec2(20.0, 0.0)), groundFD);

            //var hs = [0.25, 1.0, 4.0, 0.0, 0.0, -1.0, -2.0, -2.0, -1.25, 0.0];

            //var x = 20.0, y1 = 0.0, dx = 5.0;

            //for (var i = 0; i < 10; ++i) {
            //    var y2 = hs[i];
            //    ground.createFixture(pl.Edge(Vec2(x, y1), Vec2(x + dx, y2)), groundFD);
            //    y1 = y2;
            //    x += dx;
            //}

            //for (var i = 0; i < 10; ++i) {
            //    var y2 = hs[i];
            //    ground.createFixture(pl.Edge(Vec2(x, y1), Vec2(x + dx, y2)), groundFD);
            //    y1 = y2;
            //    x += dx;
            //}

            //ground.createFixture(pl.Edge(Vec2(x, 0.0), Vec2(x + 40.0, 0.0)), groundFD);

            //x += 80.0;
            //ground.createFixture(pl.Edge(Vec2(x, 0.0), Vec2(x + 40.0, 0.0)), groundFD);

            //x += 40.0;
            //ground.createFixture(pl.Edge(Vec2(x, 0.0), Vec2(x + 10.0, 5.0)), groundFD);

            //x += 20.0;
            //ground.createFixture(pl.Edge(Vec2(x, 0.0), Vec2(x + 40.0, 0.0)), groundFD);

            //x += 40.0;
            //ground.createFixture(pl.Edge(Vec2(x, 0.0), Vec2(x, 20.0)), groundFD);

            //// Teeter
            //var teeter = world.createDynamicBody(Vec2(140.0, 1.0));
            //teeter.createFixture(pl.Box(10.0, 0.25), 1.0);
            //world.createJoint(pl.RevoluteJoint({
            //    lowerAngle: -8.0 * Math.PI / 180.0,
            //    upperAngle: 8.0 * Math.PI / 180.0,
            //    enableLimit: true
            //}, ground, teeter, teeter.getPosition()));

            //teeter.applyAngularImpulse(100.0, true);

            //// Bridge
            //var bridgeFD = {};
            //bridgeFD.density = 1.0;
            //bridgeFD.friction = 0.6;

            //var prevBody = ground;
            //for (var i = 0; i < 20; ++i) {
            //    var bridgeBlock = world.createDynamicBody(Vec2(161.0 + 2.0 * i, -0.125));
            //    bridgeBlock.createFixture(pl.Box(1.0, 0.125), bridgeFD);

            //    world.createJoint(pl.RevoluteJoint({}, prevBody, bridgeBlock, Vec2(160.0 + 2.0 * i, -0.125)));

            //    prevBody = bridgeBlock;
            //}

            //world.createJoint(pl.RevoluteJoint({}, prevBody, ground, Vec2(160.0 + 2.0 * i, -0.125)));

            //// Boxes
            //var box = pl.Box(0.5, 0.5);

            //world.createDynamicBody(Vec2(230.0, 0.5))
            //  .createFixture(box, 0.5);

            //world.createDynamicBody(Vec2(230.0, 1.5))
            //  .createFixture(box, 0.5);

            //world.createDynamicBody(Vec2(230.0, 2.5))
            //  .createFixture(box, 0.5);

            //world.createDynamicBody(Vec2(230.0, 3.5))
            //  .createFixture(box, 0.5);

            //world.createDynamicBody(Vec2(230.0, 4.5))
            //  .createFixture(box, 0.5);

            // Car
            var car = world.createDynamicBody(Vec2(0.0, 1.0));
            car.createFixture(pl.Polygon([
              Vec2(-1.5, -0.5),
              Vec2(1.5, -0.5),
              Vec2(1.5, 0.0),
              Vec2(0.0, 0.9),
              Vec2(-1.15, 0.9),
              Vec2(-1.5, 0.2)
            ]), 1.0);

            var wheelFD = {};
            wheelFD.density = 1.0;
            wheelFD.friction = 0.9;

            var wheelBack = world.createDynamicBody(Vec2(-1.0, 0.35));
            wheelBack.createFixture(pl.Circle(0.7), wheelFD); // 0.4

            var wheelFront = world.createDynamicBody(Vec2(1.0, 0.4));
            wheelFront.createFixture(pl.Circle(0.7), wheelFD);

            var springBack = world.createJoint(pl.WheelJoint({
                motorSpeed: 0.0,
                maxMotorTorque: 20.0,
                enableMotor: true,
                frequencyHz: HZ,
                dampingRatio: ZETA
            }, car, wheelBack, wheelBack.getPosition(), Vec2(0.0, 1.0)));

            var springFront = world.createJoint(pl.WheelJoint({
                motorSpeed: 0.0,
                maxMotorTorque: 10.0,
                enableMotor: false,
                frequencyHz: HZ,
                dampingRatio: ZETA
            }, car, wheelFront, wheelFront.getPosition(), Vec2(0.0, 1.0)));

            testbed.keydown = function () {
                if (testbed.activeKeys.down) {
                    HZ = Math.max(0.0, HZ - 1.0);
                    springBack.setSpringFrequencyHz(HZ);
                    springFront.setSpringFrequencyHz(HZ);

                } else if (testbed.activeKeys.up) {
                    HZ += 1.0;
                    springBack.setSpringFrequencyHz(HZ);
                    springFront.setSpringFrequencyHz(HZ);
                }
            };

            var touching = false;
            testbed.touchstart = function (ev) {
                touching = true;
            }

            testbed.touchend = function (ev) {
                touching = false;
            }

            testbed.step = function () {
                // testbed.drawPolygon(points, 'red');
                if (testbed.activeKeys.right && testbed.activeKeys.left) {
                    springBack.setMotorSpeed(0);
                    springBack.enableMotor(true);

                } else if (testbed.activeKeys.right || touching) {
                    springBack.setMotorSpeed(-SPEED);
                    springBack.enableMotor(true);

                } else if (testbed.activeKeys.left) {
                    springBack.setMotorSpeed(+SPEED);
                    springBack.enableMotor(true);

                } else {
                    springBack.setMotorSpeed(0);
                    springBack.enableMotor(false);
                }

                var cp = car.getPosition();
                if (cp.x > testbed.x + 10) {
                    testbed.x = cp.x - 10;

                } else if (cp.x < testbed.x - 10) {
                    testbed.x = cp.x + 10;
                }
                if (cp.y > testbed.y + 3) {
                    testbed.y = cp.y - 3;
                } else if (cp.y < testbed.y - 3) {
                    testbed.y = cp.y + 3;
                }
                if (cp.x > testbed.landX - 50.0) {
                    testbed.makeLand();
                }
            };

            testbed.info('←/→: Accelerate car, ↑/↓: Change spring frequency');

            return world;
        });

    </script>
}