/**

  * Back 2 Browser Bytecode Translator

  * Copyright (C) 2012-2015 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, version 2 of the License.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://opensource.org/licenses/GPL-2.0.

  */

 package org.apidesign.benchmark.jbox2d;

 /*

  *  Copyright 2014 Alexey Andreev.

  *

  *  Licensed under the Apache License, Version 2.0 (the "License");

  *  you may not use this file except in compliance with the License.

  *  You may obtain a copy of the License at

  *

  *       http://www.apache.org/licenses/LICENSE-2.0

  *

  *  Unless required by applicable law or agreed to in writing, software

  *  distributed under the License is distributed on an "AS IS" BASIS,

  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  *  See the License for the specific language governing permissions and

  *  limitations under the License.

  */

 import org.jbox2d.collision.shapes.CircleShape;

 import org.jbox2d.collision.shapes.PolygonShape;

 import org.jbox2d.common.Vec2;

 import org.jbox2d.dynamics.*;

 import org.jbox2d.dynamics.joints.RevoluteJointDef;

 /** Taken from TeaVM.

  * <a href="https://github.com/konsoletyper/teavm/blob/3341df3668bbe3f0c3ed78b621e311361c88acfc/samples/benchmark/src/main/java/org/teavm/samples/benchmark/Scene.java">Sample</a>

  * is licensed under Apache license.

  *

  * @author Alexey Andreev

  */

 public class Scene {

     private World world;

     private Body axis;

     private Body reel;

     private long lastCalculated;

     private long startTime;

     public Scene() {

         world = new World(new Vec2(0, -9.8f));

         initAxis();

         initReel();

         joinReelToAxis();

         initBalls();

         lastCalculated = System.currentTimeMillis();

         startTime = lastCalculated;

     }

     private void initAxis() {

         BodyDef axisDef = new BodyDef();

         axisDef.type = BodyType.STATIC;

         axisDef.position = new Vec2(3, 3);

         axis = world.createBody(axisDef);

         CircleShape axisShape = new CircleShape();

         axisShape.setRadius(0.02f);

         axisShape.m_p.set(0, 0);

         FixtureDef axisFixture = new FixtureDef();

         axisFixture.shape = axisShape;

         axis.createFixture(axisFixture);

     }

     private void initReel() {

         BodyDef reelDef = new BodyDef();

         reelDef.type = BodyType.DYNAMIC;

         reelDef.position = new Vec2(3, 3);

         reel = world.createBody(reelDef);

         FixtureDef fixture = new FixtureDef();

         fixture.friction = 0.5f;

         fixture.restitution = 0.4f;

         fixture.density = 1;

         int parts = 30;

         for (int i = 0; i < parts; ++i) {

             PolygonShape shape = new PolygonShape();

             double angle1 = i / (double) parts * 2 * Math.PI;

             double x1 = 2.7 * Math.cos(angle1);

             double y1 = 2.7 * Math.sin(angle1);

             double angle2 = (i + 1) / (double) parts * 2 * Math.PI;

             double x2 = 2.7 * Math.cos(angle2);

             double y2 = 2.7 * Math.sin(angle2);

             double angle = (angle1 + angle2) / 2;

             double x = 0.01 * Math.cos(angle);

             double y = 0.01 * Math.sin(angle);

             shape.set(new Vec2[] { new Vec2((float) x1, (float) y1), new Vec2((float) x2, (float) y2),

                     new Vec2((float) (x2 - x), (float) (y2 - y)), new Vec2((float) (x1 - x), (float) (y1 - y)) }, 4);

             fixture.shape = shape;

             reel.createFixture(fixture);

         }

     }

     private void initBalls() {

         float ballRadius = 0.15f;

         BodyDef ballDef = new BodyDef();

         ballDef.type = BodyType.DYNAMIC;

         FixtureDef fixtureDef = new FixtureDef();

         fixtureDef.friction = 0.3f;

         fixtureDef.restitution = 0.3f;

         fixtureDef.density = 0.2f;

         CircleShape shape = new CircleShape();

         shape.m_radius = ballRadius;

         fixtureDef.shape = shape;

         for (int i = 0; i < 5; ++i) {

             for (int j = 0; j < 5; ++j) {

                 float x = (j + 0.5f) * (ballRadius * 2 + 0.01f);

                 float y = (i + 0.5f) * (ballRadius * 2 + 0.01f);

                 ballDef.position.x = 3 + x;

                 ballDef.position.y = 3 + y;

                 Body body = world.createBody(ballDef);

                 body.createFixture(fixtureDef);

                 ballDef.position.x = 3 - x;

                 ballDef.position.y = 3 + y;

                 body = world.createBody(ballDef);

                 body.createFixture(fixtureDef);

                 ballDef.position.x = 3 + x;

                 ballDef.position.y = 3 - y;

                 body = world.createBody(ballDef);

                 body.createFixture(fixtureDef);

                 ballDef.position.x = 3 - x;

                 ballDef.position.y = 3 - y;

                 body = world.createBody(ballDef);

                 body.createFixture(fixtureDef);

             }

         }

     }

     private void joinReelToAxis() {

         RevoluteJointDef jointDef = new RevoluteJointDef();

         jointDef.bodyA = axis;

         jointDef.bodyB = reel;

         world.createJoint(jointDef);

     }

     public void calculate() {

         long currentTime = System.currentTimeMillis();

         int timeToCalculate = (int) (currentTime - lastCalculated);

         long relativeTime = currentTime - startTime;

         while (timeToCalculate > 10) {

             int period = (int) ((relativeTime + 5000) / 10000);

             reel.applyTorque(period % 2 == 0 ? 8f : -8f);

             world.step(0.01f, 20, 40);

             lastCalculated += 10;

             timeToCalculate -= 10;

         }

     }

     public int timeUntilNextStep() {

         return (int) Math.max(0, lastCalculated + 10 - System.currentTimeMillis());

     }

     public World getWorld() {

         return world;

     }

 }