package com.mygdx.game;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.Box2DDebugRenderer;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.PolygonShape;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.physics.box2d.joints.RevoluteJointDef;
import com.badlogic.gdx.physics.box2d.joints.WeldJointDef;

import utils.Constants;

public class MyGdxGame extends ApplicationAdapter {
	private OrthographicCamera camera;
	private boolean DEBUG = false;
	private World world;
	private Box2DDebugRenderer b2dr;
	private Body basis;

	// 4 зубца
	private Body box;
	private Body toptooth;
	private Body righttooth;
	private Body bottooth;
	private Body lefttooth;

	// 6 зубцов
	private Body hexagonum;
	private Body lefthextooth;
	private Body righthextooth;
	private Body toprighthextooth;
	private Body toplefthextooth;
	private Body botrighthextooth;
	private Body botlefthextooth;

	// 12 зубцов
	private Body Dodecangulum;
	private Body Dodecangulum2;
	private Body DodecangulumBotLeftTooth1;
	private Body DodecangulumBotLeftTooth2;
	private Body DodecangulumBotLeftTooth3;
	private Body DodecangulumBotRightTooth1;
	private Body DodecangulumBotRightTooth2;
	private Body DodecangulumBotRightTooth3;
	private Body DodecangulumTopLeftTooth1;
	private Body DodecangulumTopLeftTooth2;
	private Body DodecangulumTopLeftTooth3;
	private Body DodecangulumTopRightTooth1;
	private Body DodecangulumTopRightTooth2;
	private Body DodecangulumTopRightTooth3;

	// 24 зубца
	private Body twentyfourteethcog1;
	private Body twentyfourteethcog2;
	private Body twentyfourteethcog3;
	private Body twentyfourteethcog4;
	private Body twentyfourteethcogBotLeftTooth1;
	private Body twentyfourteethcogBotLeftTooth2;
	private Body twentyfourteethcogBotLeftTooth3;
	private Body twentyfourteethcogBotLeftTooth4;
	private Body twentyfourteethcogBotLeftTooth5;
	private Body twentyfourteethcogBotLeftTooth6;
	private Body twentyfourteethcogBotRightTooth1;
	private Body twentyfourteethcogBotRightTooth2;
	private Body twentyfourteethcogBotRightTooth3;
	private Body twentyfourteethcogBotRightTooth4;
	private Body twentyfourteethcogBotRightTooth5;
	private Body twentyfourteethcogBotRightTooth6;
	private Body twentyfourteethcogTopLeftTooth1;
	private Body twentyfourteethcogTopLeftTooth2;
	private Body twentyfourteethcogTopLeftTooth3;
	private Body twentyfourteethcogTopLeftTooth4;
	private Body twentyfourteethcogTopLeftTooth5;
	private Body twentyfourteethcogTopLeftTooth6;
	private Body twentyfourteethcogTopRightTooth1;
	private Body twentyfourteethcogTopRightTooth2;
	private Body twentyfourteethcogTopRightTooth3;
	private Body twentyfourteethcogTopRightTooth4;
	private Body twentyfourteethcogTopRightTooth5;
	private Body twentyfourteethcogTopRightTooth6;

	public void create() {
		float w = Gdx.graphics.getWidth();
		float h = Gdx.graphics.getHeight();
		camera = new OrthographicCamera();
		camera.setToOrtho(false, w / 2, h / 2);
		world = new World(new Vector2(0, -9.8f), false);
		b2dr = new Box2DDebugRenderer();
		twentyfourCog(0f, 0f, 0f, true, 0.7f, 30, 30);
		// первый параметр - угол поворота, второй - координата центра вращения по x,
		// третий - координата центра вращения по y, четвертый - есть ли мотор, пятый -
		// масштаб шестерни, шестой - скорость мотора, седьмой - мощность мотора
	}

	// создание шестерни с 24 зубцами
	public void twentyfourCog(float rotation, float xo, float yo, boolean n, float resize, int speed, int hf) {
		// основание, центр вращения
		basis = createBasis(xo, yo, resize);
		// шестерня строится из 4 полигонов, потому что в Box2D ограничение по
		// количеству вершин полигона от 3 до 8
		twentyfourteethcog1 = createtwentyfourteethcog1(xo, yo, resize);
		twentyfourteethcog2 = createtwentyfourteethcog2(xo, yo, resize);
		twentyfourteethcog3 = createtwentyfourteethcog3(xo, yo, resize);
		twentyfourteethcog4 = createtwentyfourteethcog4(xo, yo, resize);
		// здесь задается вращение
		twentyfourteethcog1.setTransform(xo, yo, rotation);
		twentyfourteethcog2.setTransform(xo, yo, rotation);
		twentyfourteethcog3.setTransform(xo, yo, rotation);
		twentyfourteethcog4.setTransform(xo, yo, rotation);
		// создаются зубья, по одному
		twentyfourteethcogTopRightTooth1 = createtwentyfourteethcogTopRightTooth1(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth1.setTransform(xo, yo, rotation);
		twentyfourteethcogTopRightTooth2 = createtwentyfourteethcogTopRightTooth2(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth2.setTransform(xo, yo, rotation);
		twentyfourteethcogTopRightTooth3 = createtwentyfourteethcogTopRightTooth3(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth3.setTransform(xo, yo, rotation);
		twentyfourteethcogTopRightTooth4 = createtwentyfourteethcogTopRightTooth4(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth4.setTransform(xo, yo, rotation);
		twentyfourteethcogTopRightTooth5 = createtwentyfourteethcogTopRightTooth5(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth5.setTransform(xo, yo, rotation);
		twentyfourteethcogTopRightTooth6 = createtwentyfourteethcogTopRightTooth6(xo, yo, xo, yo, resize);
		twentyfourteethcogTopRightTooth6.setTransform(xo, yo, rotation);

		twentyfourteethcogTopLeftTooth1 = createtwentyfourteethcogTopLeftTooth1(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth1.setTransform(xo, yo, rotation);
		twentyfourteethcogTopLeftTooth2 = createtwentyfourteethcogTopLeftTooth2(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth2.setTransform(xo, yo, rotation);
		twentyfourteethcogTopLeftTooth3 = createtwentyfourteethcogTopLeftTooth3(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth3.setTransform(xo, yo, rotation);
		twentyfourteethcogTopLeftTooth4 = createtwentyfourteethcogTopLeftTooth4(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth4.setTransform(xo, yo, rotation);
		twentyfourteethcogTopLeftTooth5 = createtwentyfourteethcogTopLeftTooth5(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth5.setTransform(xo, yo, rotation);
		twentyfourteethcogTopLeftTooth6 = createtwentyfourteethcogTopLeftTooth6(xo, yo, xo, yo, resize);
		twentyfourteethcogTopLeftTooth6.setTransform(xo, yo, rotation);

		twentyfourteethcogBotRightTooth1 = createtwentyfourteethcogBotRightTooth1(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth1.setTransform(xo, yo, rotation);
		twentyfourteethcogBotRightTooth2 = createtwentyfourteethcogBotRightTooth2(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth2.setTransform(xo, yo, rotation);
		twentyfourteethcogBotRightTooth3 = createtwentyfourteethcogBotRightTooth3(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth3.setTransform(xo, yo, rotation);
		twentyfourteethcogBotRightTooth4 = createtwentyfourteethcogBotRightTooth4(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth4.setTransform(xo, yo, rotation);
		twentyfourteethcogBotRightTooth5 = createtwentyfourteethcogBotRightTooth5(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth5.setTransform(xo, yo, rotation);
		twentyfourteethcogBotRightTooth6 = createtwentyfourteethcogBotRightTooth6(xo, yo, xo, yo, resize);
		twentyfourteethcogBotRightTooth6.setTransform(xo, yo, rotation);

		twentyfourteethcogBotLeftTooth1 = createtwentyfourteethcogBotLeftTooth1(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth1.setTransform(xo, yo, rotation);
		twentyfourteethcogBotLeftTooth2 = createtwentyfourteethcogBotLeftTooth2(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth2.setTransform(xo, yo, rotation);
		twentyfourteethcogBotLeftTooth3 = createtwentyfourteethcogBotLeftTooth3(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth3.setTransform(xo, yo, rotation);
		twentyfourteethcogBotLeftTooth4 = createtwentyfourteethcogBotLeftTooth4(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth4.setTransform(xo, yo, rotation);
		twentyfourteethcogBotLeftTooth5 = createtwentyfourteethcogBotLeftTooth5(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth5.setTransform(xo, yo, rotation);
		twentyfourteethcogBotLeftTooth6 = createtwentyfourteethcogBotLeftTooth6(xo, yo, xo, yo, resize);
		twentyfourteethcogBotLeftTooth6.setTransform(xo, yo, rotation);

		// связки между полигонами, составляющими шестерню
		weldMotJoint(twentyfourteethcog1, twentyfourteethcog2);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcog3);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcog4);

		weldMotJoint(twentyfourteethcog2, twentyfourteethcog1);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcog3);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcog4);

		weldMotJoint(twentyfourteethcog3, twentyfourteethcog1);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcog2);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcog4);

		weldMotJoint(twentyfourteethcog4, twentyfourteethcog1);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcog2);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcog3);

		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth1);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth2);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth3);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth4);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth5);
		weldMotJoint(twentyfourteethcog1, twentyfourteethcogTopRightTooth6);

		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth1);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth2);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth3);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth4);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth5);
		weldMotJoint(twentyfourteethcog4, twentyfourteethcogTopLeftTooth6);

		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth1);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth2);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth3);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth4);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth5);
		weldMotJoint(twentyfourteethcog2, twentyfourteethcogBotRightTooth6);

		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth1);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth2);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth3);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth4);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth5);
		weldMotJoint(twentyfourteethcog3, twentyfourteethcogBotLeftTooth6);

		// связь между шестерней и базисом для обеспечения вращения
		revJoint(basis, twentyfourteethcog1, n, speed, hf);
		revJoint(basis, twentyfourteethcog2, n, speed, hf);
		revJoint(basis, twentyfourteethcog3, n, speed, hf);
		revJoint(basis, twentyfourteethcog4, n, speed, hf);
	}

	// все по аналогии, шестерня с 12 зубьями
	public void twelveCog(float rotation, float xo, float yo, boolean n, float resize, int speed, int hf) {
		basis = createBasis(xo, yo, resize);

		Dodecangulum = createDodecangulum(xo, yo, resize);
		Dodecangulum.setTransform(xo, yo, rotation);

		DodecangulumTopLeftTooth1 = createTopLeftDodecangulumTooth1(xo, yo, xo, yo, resize);
		DodecangulumTopLeftTooth1.setTransform(xo, yo, rotation);
		DodecangulumTopLeftTooth2 = createTopLeftDodecangulumTooth2(xo, yo, xo, yo, resize);
		DodecangulumTopLeftTooth2.setTransform(xo, yo, rotation);
		DodecangulumTopLeftTooth3 = createTopLeftDodecangulumTooth3(xo, yo, xo, yo, resize);
		DodecangulumTopLeftTooth3.setTransform(xo, yo, rotation);
		DodecangulumTopRightTooth1 = createTopRightDodecangulumTooth1(xo, yo, xo, yo, resize);
		DodecangulumTopRightTooth1.setTransform(xo, yo, rotation);
		DodecangulumTopRightTooth2 = createTopRightDodecangulumTooth2(xo, yo, xo, yo, resize);
		DodecangulumTopRightTooth2.setTransform(xo, yo, rotation);
		DodecangulumTopRightTooth3 = createTopRightDodecangulumTooth3(xo, yo, xo, yo, resize);
		DodecangulumTopRightTooth3.setTransform(xo, yo, rotation);

		weldMotJoint(DodecangulumTopLeftTooth1, Dodecangulum);
		weldMotJoint(DodecangulumTopLeftTooth2, Dodecangulum);
		weldMotJoint(DodecangulumTopLeftTooth3, Dodecangulum);
		weldMotJoint(DodecangulumTopRightTooth1, Dodecangulum);
		weldMotJoint(DodecangulumTopRightTooth2, Dodecangulum);
		weldMotJoint(DodecangulumTopRightTooth3, Dodecangulum);

		Dodecangulum2 = createDodecangulum2(xo, yo, resize);
		Dodecangulum2.setTransform(xo, yo, rotation);

		DodecangulumBotLeftTooth1 = createBotLeftDodecangulumTooth1(xo, yo, xo, yo, resize);
		DodecangulumBotLeftTooth1.setTransform(xo, yo, rotation);
		DodecangulumBotLeftTooth2 = createBotLeftDodecangulumTooth2(xo, yo, xo, yo, resize);
		DodecangulumBotLeftTooth2.setTransform(xo, yo, rotation);
		DodecangulumBotLeftTooth3 = createBotLeftDodecangulumTooth3(xo, yo, xo, yo, resize);
		DodecangulumBotLeftTooth3.setTransform(xo, yo, rotation);
		DodecangulumBotRightTooth1 = createBotRightDodecangulumTooth1(xo, yo, xo, yo, resize);
		DodecangulumBotRightTooth1.setTransform(xo, yo, rotation);
		DodecangulumBotRightTooth2 = createBotRightDodecangulumTooth2(xo, yo, xo, yo, resize);
		DodecangulumBotRightTooth2.setTransform(xo, yo, rotation);
		DodecangulumBotRightTooth3 = createBotRightDodecangulumTooth3(xo, yo, xo, yo, resize);
		DodecangulumBotRightTooth3.setTransform(xo, yo, rotation);

		weldMotJoint(DodecangulumBotLeftTooth1, Dodecangulum2);
		weldMotJoint(DodecangulumBotLeftTooth2, Dodecangulum2);
		weldMotJoint(DodecangulumBotLeftTooth3, Dodecangulum2);

		weldMotJoint(DodecangulumBotRightTooth1, Dodecangulum2);
		weldMotJoint(DodecangulumBotRightTooth2, Dodecangulum2);
		weldMotJoint(DodecangulumBotRightTooth3, Dodecangulum2);

		weldMotJoint(Dodecangulum2, Dodecangulum);
		weldMotJoint(Dodecangulum, Dodecangulum2);
		revJoint(basis, Dodecangulum, n, speed, hf);
		revJoint(basis, Dodecangulum2, n, speed, hf);
	}

	// все по аналогии, шестерня с 6 зубьями
	public void sixCog(float rotation, float xo, float yo, boolean n, float resize, int speed, int hf) {
		basis = createBasis(xo, yo, resize);
		hexagonum = createHexagonum(xo, yo, resize);
		revJoint(basis, hexagonum, n, speed, hf);
		hexagonum.setTransform(hexagonum.getPosition().x, hexagonum.getPosition().y, rotation);
		lefthextooth = createLeftHexTooth(xo, yo, xo, yo, resize);
		lefthextooth.setTransform(xo, yo, rotation);
		righthextooth = createRightHexTooth(xo, yo, xo, yo, resize);
		righthextooth.setTransform(xo, yo, rotation);
		toprighthextooth = createTopRightHexTooth(xo, yo, xo, yo, resize);
		toprighthextooth.setTransform(xo, yo, rotation);
		toplefthextooth = createTopLeftHexTooth(xo, yo, xo, yo, resize);
		toplefthextooth.setTransform(xo, yo, rotation);
		botlefthextooth = createBotLeftHexTooth(xo, yo, xo, yo, resize);
		botlefthextooth.setTransform(xo, yo, rotation);
		botrighthextooth = createBotRightHexTooth(xo, yo, xo, yo, resize);
		botrighthextooth.setTransform(xo, yo, rotation);
		weldMotJoint(hexagonum, lefthextooth);
		weldMotJoint(hexagonum, righthextooth);
		weldMotJoint(hexagonum, toprighthextooth);
		weldMotJoint(hexagonum, toplefthextooth);
		weldMotJoint(hexagonum, botlefthextooth);
		weldMotJoint(hexagonum, botrighthextooth);
	}

	// все по аналогии, шестерня с 4 зубьями
	public void fourCog(float rotation, float xo, float yo, boolean n, float resize, int speed, int hf) {
		basis = createBasis(xo, yo, resize);
		box = createBox(xo, yo, resize);
		box.setTransform(box.getPosition().x, box.getPosition().y, rotation);
		toptooth = createTopTooth(xo, yo, xo, yo, resize);
		toptooth.setTransform(xo, yo, rotation);
		righttooth = createRightTooth(xo, yo, xo, yo, resize);
		righttooth.setTransform(xo, yo, rotation);
		bottooth = createBotTooth(xo, yo, xo, yo, resize);
		bottooth.setTransform(xo, yo, rotation);
		lefttooth = createLeftTooth(xo, yo, xo, yo, resize);
		lefttooth.setTransform(xo, yo, rotation);
		weldMotJoint(box, toptooth);
		weldMotJoint(box, righttooth);
		weldMotJoint(box, bottooth);
		weldMotJoint(box, lefttooth);
		revJoint(basis, box, n, speed, hf);
	}

	// описание связки для обеспечения вращения
	public void revJoint(Body body1, Body body2, boolean n, int speed, int hf) {
		RevoluteJointDef rjd = new RevoluteJointDef();
		if (n == true) {
			rjd.enableMotor = true;
			rjd.motorSpeed = speed;
			rjd.maxMotorTorque = hf;
		}
		rjd.collideConnected = false;
		rjd.bodyA = body1;
		rjd.bodyB = body2;
		rjd.localAnchorA.set(body1.getPosition().x, body1.getPosition().y);
		rjd.localAnchorB.set(body2.getPosition().x, body2.getPosition().y);
		world.createJoint(rjd);
	}

	// неподвижная связка
	public void weldMotJoint(Body body1, Body body2) {
		WeldJointDef rjd = new WeldJointDef();
		rjd.collideConnected = false;
		rjd.bodyA = body1;
		rjd.bodyB = body2;
		rjd.localAnchorA.set(body1.getPosition().x, body1.getPosition().y);
		rjd.localAnchorB.set(body2.getPosition().x, body2.getPosition().y);
		world.createJoint(rjd);
	}

	public void render() {
		update(Gdx.graphics.getDeltaTime());
		Gdx.gl.glClearColor(0, 0, 0, 1);
		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
		b2dr.render(world, camera.combined.scl(Constants.PPM));
	}

	public void resize(int width, int height) {
		camera.setToOrtho(false, width / 2, height / 2);
	}

	public void dispose() {
		world.dispose();
		b2dr.dispose();
	}

	public void update(float delta) {
		world.step(1 / 60f, 6, 2);
		cameraUpdate(delta);
	}

	// камера следит за центром вращения
	public void cameraUpdate(float delta) {
		Vector3 position = camera.position;
		position.x = basis.getPosition().x * Constants.PPM;
		position.y = basis.getPosition().y * Constants.PPM;
		camera.position.set(position);
		camera.update();
	}

	// создание центра вращения для шестерни с 4 зубьями
	public Body createBox(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	// каждый зубец создается, как полигон с четырьмя вершинами
	public Body createTopTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-0.5f * 10 / utils.Constants.PPM * resize + dx,
				8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(0.5f * 10 / utils.Constants.PPM * resize + dx,
				8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createRightTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				-0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createBotTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-0.5f * 10 / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(0.5f * 10 / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createLeftTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				-0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-2f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBasis(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(2f * 10 / utils.Constants.PPM / 2 * resize + dx,
				2f * 10 / utils.Constants.PPM / 2 * resize + dy);
		verticles[1] = new Vector2(2f * 10 / utils.Constants.PPM / 2 * resize + dx,
				-2f * 10 / utils.Constants.PPM / 2 * resize + dy);
		verticles[2] = new Vector2(-2f * 10 / utils.Constants.PPM / 2 * resize + dx,
				2f * 10 / utils.Constants.PPM / 2 * resize + dy);
		verticles[3] = new Vector2(-2f * 10 / utils.Constants.PPM / 2 * resize + dx,
				-2f * 10 / utils.Constants.PPM / 2 * resize + dy);

		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.StaticBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);

		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	// Шестерня с 6 зубьями
	public Body createHexagonum(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[6];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);

		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createLeftHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-9.5f * 10 / utils.Constants.PPM * resize + dx,
				-0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-9.5f * 10 / utils.Constants.PPM * resize + dx,
				0.5f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createRightHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(9.5f * 10 / utils.Constants.PPM * resize + dx,
				-0.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(9.5f * 10 / utils.Constants.PPM * resize + dx,
				0.5f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopRightHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(5.9f * 10 / utils.Constants.PPM * resize + dx,
				8.7f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(5.1f * 10 / utils.Constants.PPM * resize + dx,
				9.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopLeftHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-5.9f * 10 / utils.Constants.PPM * resize + dx,
				8.7f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-5.1f * 10 / utils.Constants.PPM * resize + dx,
				9.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotRightHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(5.9f * 10 / utils.Constants.PPM * resize + dx,
				-8.7f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(5.1f * 10 / utils.Constants.PPM * resize + dx,
				-9.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotLeftHexTooth(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-3f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				-1.5f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-5.9f * 10 / utils.Constants.PPM * resize + dx,
				-8.7f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-5.1f * 10 / utils.Constants.PPM * resize + dx,
				-9.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	// Шестерня с 12 зубьями, состоит из 2 частей из-за ограничения по вершинам
	public Body createDodecangulum(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(4 * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0 * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createDodecangulum2(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(4 * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createTopLeftDodecangulumTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				11.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-3.6f * 10 / utils.Constants.PPM * resize + dx,
				11.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopLeftDodecangulumTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-8.1f * 10 / utils.Constants.PPM * resize + dx,
				8.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-8.7f * 10 / utils.Constants.PPM * resize + dx,
				8.1f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopLeftDodecangulumTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4.0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-11.25f * 10 / utils.Constants.PPM * resize + dx,
				3.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-11.5f * 10 / utils.Constants.PPM * resize + dx,
				2.7f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopRightDodecangulumTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				11.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(3.6f * 10 / utils.Constants.PPM * resize + dx,
				11.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopRightDodecangulumTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(8.1f * 10 / utils.Constants.PPM * resize + dx,
				8.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(8.7f * 10 / utils.Constants.PPM * resize + dx,
				8.1f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createTopRightDodecangulumTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4.0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(11.25f * 10 / utils.Constants.PPM * resize + dx,
				3.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(11.5f * 10 / utils.Constants.PPM * resize + dx,
				2.7f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotLeftDodecangulumTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2.5f * 10 / utils.Constants.PPM * resize + dx,
				-11.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-3.6f * 10 / utils.Constants.PPM * resize + dx,
				-11.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotLeftDodecangulumTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-8.1f * 10 / utils.Constants.PPM * resize + dx,
				-8.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-8.7f * 10 / utils.Constants.PPM * resize + dx,
				-8.1f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotLeftDodecangulumTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4.0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-11.25f * 10 / utils.Constants.PPM * resize + dx,
				-3.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-11.5f * 10 / utils.Constants.PPM * resize + dx,
				-2.7f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotRightDodecangulumTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.5f * 10 / utils.Constants.PPM * resize + dx,
				-11.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(3.6f * 10 / utils.Constants.PPM * resize + dx,
				-11.3f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotRightDodecangulumTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.2f * 10 / utils.Constants.PPM * resize + dx,
				-3.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(8.1f * 10 / utils.Constants.PPM * resize + dx,
				-8.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(8.7f * 10 / utils.Constants.PPM * resize + dx,
				-8.1f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createBotRightDodecangulumTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4.0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(3.4f * 10 / utils.Constants.PPM * resize + dx,
				-2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(11.25f * 10 / utils.Constants.PPM * resize + dx,
				-3.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(11.5f * 10 / utils.Constants.PPM * resize + dx,
				-2.7f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	// шестерня с 24 зубьями задается, как 4 связанных полигона
	public Body createtwentyfourteethcog1(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(0 * 10 / utils.Constants.PPM * resize + dx,
				8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcog2(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(0 * 10 / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcog3(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(0 * 10f / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcog4(float dx, float dy, float resize) {
		Vector2[] verticles = new Vector2[8];
		verticles[0] = new Vector2(-0 * 10 / utils.Constants.PPM * resize + dx,
				8 * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[4] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				4f * 10 / utils.Constants.PPM * resize + dy);
		verticles[5] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);
		verticles[6] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		verticles[7] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				0 * 10 / utils.Constants.PPM * resize + dy);
		PolygonShape shape = new PolygonShape();
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(dx, dy);
		def.fixedRotation = false;
		fBody = world.createBody(def);
		shape.set(verticles);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.5f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.0f * 10 / utils.Constants.PPM * resize + dx,
				15.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(3.0f * 10 / utils.Constants.PPM * resize + dx,
				15.6f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				14.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(6.6f * 10 / utils.Constants.PPM * resize + dx,
				14.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(10.2f * 10 / utils.Constants.PPM * resize + dx,
				12.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(9.5f * 10 / utils.Constants.PPM * resize + dx,
				12.8f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth4(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(12.2f * 10 / utils.Constants.PPM * resize + dx,
				10.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(12.8f * 10 / utils.Constants.PPM * resize + dx,
				9.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth5(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(14.5f * 10 / utils.Constants.PPM * resize + dx,
				6.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(14.9f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopRightTooth6(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				0.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(15.8f * 10 / utils.Constants.PPM * resize + dx,
				2.0f * 10 / utils.Constants.PPM * resize + dy);

		verticles[3] = new Vector2(15.6f * 10 / utils.Constants.PPM * resize + dx,
				3.0f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2.0f * 10 / utils.Constants.PPM * resize + dx,
				15.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-3.0f * 10 / utils.Constants.PPM * resize + dx,
				15.6f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				7.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				14.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-6.6f * 10 / utils.Constants.PPM * resize + dx,
				14.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-10.2f * 10 / utils.Constants.PPM * resize + dx,
				12.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-9.5f * 10 / utils.Constants.PPM * resize + dx,
				12.8f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth4(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-12.2f * 10 / utils.Constants.PPM * resize + dx,
				10.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-12.8f * 10 / utils.Constants.PPM * resize + dx,
				9.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth5(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-14.5f * 10 / utils.Constants.PPM * resize + dx,
				6.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-14.9f * 10 / utils.Constants.PPM * resize + dx,
				5.6f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogTopLeftTooth6(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				0.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-15.8f * 10 / utils.Constants.PPM * resize + dx,
				2.0f * 10 / utils.Constants.PPM * resize + dy);

		verticles[3] = new Vector2(-15.6f * 10 / utils.Constants.PPM * resize + dx,
				3.0f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(2.0f * 10 / utils.Constants.PPM * resize + dx,
				-15.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(3.0f * 10 / utils.Constants.PPM * resize + dx,
				-15.6f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				-14.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(6.6f * 10 / utils.Constants.PPM * resize + dx,
				-14.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(10.2f * 10 / utils.Constants.PPM * resize + dx,
				-12.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(9.5f * 10 / utils.Constants.PPM * resize + dx,
				-12.8f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth4(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(12.2f * 10 / utils.Constants.PPM * resize + dx,
				-10.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(12.8f * 10 / utils.Constants.PPM * resize + dx,
				-9.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth5(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(14.5f * 10 / utils.Constants.PPM * resize + dx,
				-6.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(14.9f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotRightTooth6(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(8f * 10 / utils.Constants.PPM * resize + dx,
				0.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(15.8f * 10 / utils.Constants.PPM * resize + dx,
				-2.0f * 10 / utils.Constants.PPM * resize + dy);

		verticles[3] = new Vector2(15.6f * 10 / utils.Constants.PPM * resize + dx,
				-3.0f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth1(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(0f * 10 / utils.Constants.PPM * resize + dx,
				-8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-2.0f * 10 / utils.Constants.PPM * resize + dx,
				-15.8f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-3.0f * 10 / utils.Constants.PPM * resize + dx,
				-15.6f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);

		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth2(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-2.1f * 10 / utils.Constants.PPM * resize + dx,
				-7.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				-14.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-6.6f * 10 / utils.Constants.PPM * resize + dx,
				-14.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth3(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-4f * 10 / utils.Constants.PPM * resize + dx,
				-6.9f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-10.2f * 10 / utils.Constants.PPM * resize + dx,
				-12.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-9.5f * 10 / utils.Constants.PPM * resize + dx,
				-12.8f * 10 / utils.Constants.PPM * resize + dy);

		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth4(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-5.6f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[2] = new Vector2(-12.2f * 10 / utils.Constants.PPM * resize + dx,
				-10.2f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-12.8f * 10 / utils.Constants.PPM * resize + dx,
				-9.5f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth5(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-6.9f * 10 / utils.Constants.PPM * resize + dx,
				-4.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-14.5f * 10 / utils.Constants.PPM * resize + dx,
				-6.6f * 10 / utils.Constants.PPM * resize + dy);
		verticles[3] = new Vector2(-14.9f * 10 / utils.Constants.PPM * resize + dx,
				-5.6f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}

	public Body createtwentyfourteethcogBotLeftTooth6(float xo, float yo, float dx, float dy, float resize) {
		PolygonShape shape = new PolygonShape();

		Vector2[] verticles = new Vector2[4];
		verticles[0] = new Vector2(-8f * 10 / utils.Constants.PPM * resize + dx,
				0.0f * 10 / utils.Constants.PPM * resize + dy);
		verticles[1] = new Vector2(-7.6f * 10 / utils.Constants.PPM * resize + dx,
				-2.1f * 10 / utils.Constants.PPM * resize + dy);

		verticles[2] = new Vector2(-15.8f * 10 / utils.Constants.PPM * resize + dx,
				-2.0f * 10 / utils.Constants.PPM * resize + dy);

		verticles[3] = new Vector2(-15.6f * 10 / utils.Constants.PPM * resize + dx,
				-3.0f * 10 / utils.Constants.PPM * resize + dy);
		Body fBody;
		BodyDef def = new BodyDef();
		def.type = BodyDef.BodyType.DynamicBody;
		def.position.set(xo * 10 / utils.Constants.PPM + dx, yo * 10 / utils.Constants.PPM + dy);
		def.fixedRotation = false;
		shape.set(verticles);
		fBody = world.createBody(def);
		FixtureDef fd = new FixtureDef();
		fd.shape = shape;
		fd.friction = 0.7f;
		fd.density = 3f;
		fd.restitution = 0.5f;
		fBody.createFixture(fd);
		shape.dispose();
		return fBody;
	}
}