Physics.js

import Matter from 'matter-js';
import Constants from './Constants';
import Pipe from './Pipe';


let pipes = 0;

export const resetPipes = () => {
  pipes = 0;
}

export const randomBetween = (min, max) => {
  return Math.floor(Math.random() * (max - min + 1) + min);
}

export const generatePipes = () => {
  let topPipeHeight = randomBetween(100, (Constants.MAX_HEIGHT / 2) - 100);
  let bottomPipeHeight = Constants.MAX_HEIGHT - topPipeHeight - Constants.GAP_SIZE;

  let sizes = [topPipeHeight, bottomPipeHeight];

  if (Math.random() < 0.5) {
    sizes = sizes.reverse();
  }
  return sizes;
}

export const addPipesAtLocation = (x, world, entities) => {
  let [pipe1Height, pipe2Height] = generatePipes();

  let pipe1 = Matter.Bodies.rectangle(
    x,
    pipe1Height / 2,
    Constants.PIPE_WIDTH,
    pipe1Height,
    { isStatic: true }
  );

  let pipe2 = Matter.Bodies.rectangle(
    x,
    Constants.MAX_HEIGHT - 50 - (pipe2Height / 2),
    Constants.PIPE_WIDTH,
    pipe2Height,
    { isStatic: true }
  );

  Matter.World.add(world, [pipe1, pipe2]);

  entities["pipe" + (pipes + 1)] = {
      body: pipe1, renderer: Pipe, scored: false
  }

  entities["pipe" + (pipes + 2)] = {
    body: pipe2, renderer: Pipe, scored: false
}

pipes += 2;

}


const Physics = (entities, { touches, time, dispatch }) => {
    let engine = entities.physics.engine;
    let world = entities.physics.world;
    let santa = entities.santa.body;

    let hadTouches = false;
    touches.filter(t => t.type === "press").forEach(t => {
        if (!hadTouches) {
            if (world.gravity.y === 0.0){
                world.gravity.y = 1.2;

                addPipesAtLocation((Constants.MAX_WIDTH  * 2)- (Constants.PIPE_WIDTH / 2), world, entities);
                addPipesAtLocation((Constants.MAX_WIDTH  * 3)- (Constants.PIPE_WIDTH / 2), world, entities);

            }

            hadTouches = true;
            Matter.Body.setVelocity( santa, {
            x: santa.velocity.x,
            y: -10    
        });
      }
    });

 
    Matter.Engine.update(engine, time.delta);

    Object.keys(entities).forEach(key => {
        if (key.indexOf("pipe") === 0 && entities.hasOwnProperty(key)){
          Matter.Body.translate(entities[key].body, {x: -2, y: 0});

          if (key.indexOf("pipe") !== -1 && parseInt(key.replace("pipe", "")) % 2 === 0){
            if (entities[key].body.position.x <= santa.position.x && !entities[key].scored){
                entities[key].scored = true;
              dispatch({ type: "score"});
            }
          }

          if (key.indexOf("pipe") !== -1 && parseInt(key.replace("pipe", "")) % 2 === 0) {
            if (entities[key].body.position.x <= -1 * (Constants.PIPE_WIDTH / 2)){
              let pipeIndex = parseInt(key.replace("pipe", ""));
              delete(entities["pipe" + (pipeIndex - 1) + "pipe"]);
              delete(entities["pipe" + (pipeIndex - 1)]);
              delete(entities["pipe" + pipeIndex + "pipe"]);
              delete(entities["pipe" + pipeIndex]);

              addPipesAtLocation((Constants.MAX_WIDTH  * 2)- (Constants.PIPE_WIDTH / 2), world, entities);

            }
          }


        } else if (key.indexOf("floor") === 0) {  
            if (entities[key].body.position.x <= -1 * Constants.MAX_WIDTH / 2) {
                Matter.Body.setPosition(entities[key].body, { x: Constants.MAX_WIDTH + (Constants.MAX_WIDTH / 2), y: entities[key].body.position.y})
            } else {
                Matter.Body.translate(entities[key].body, {x: -2, y: 0});   
        }
      }
    })

    return entities;
}

export default Physics;