Colorize the winner renderer

[rbdr/sumo] / lib / sumo.js

diff --git a/lib/sumo.js b/lib/sumo.js
index daa7e94cecb9fa9f3a91d4f9bf2d1475dd5d0c9d..835e910ff48c18ea256af2bf9eca8d4e9e42caa8 100644 (file)
--- a/lib/sumo.js
+++ b/lib/sumo.js
@@ -1,10 +1,32 @@
 import 'babel-polyfill';
 import 'babel-polyfill';

+
+import Config from './config';
+
+// Systems
+
+import ApplyForceSystem from './systems/apply_force';
+import CreateCouplingLineSystem from './systems/create_coupling_line';
+import ControlMapperSystem from './systems/control_mapper';
+import DashSystem from './systems/dash';
+import DetectPointsCollisionSystem from './systems/detect_points_collision';
+import DetectWinnerSystem from './systems/detect_winner';
+import DrawDashSystem from './systems/draw_dash';
+import DrawGrabSystem from './systems/draw_grab';
+import ElasticSystem from './systems/elastic';
+import GrabSystem from './systems/grab';

 import PhysicsWorldControlSystem from './systems/physics_world_control';
 import PhysicsToAttributesSystem from './systems/physics_to_attributes';
 import PhysicsWorldControlSystem from './systems/physics_world_control';
 import PhysicsToAttributesSystem from './systems/physics_to_attributes';

-import CreateCouplingLineSystem from './systems/create_coupling_line';
+import RenderPointsSystem from './systems/render_points';

 import RenderSystem from './systems/render';
 import RenderSystem from './systems/render';

+import RenderWinnerSystem from './systems/render_winner';

 import AttributesToRenderableSystem from './systems/attributes_to_renderable';
 import AttributesToRenderableSystem from './systems/attributes_to_renderable';

+
+// Factories
+

 import SumoFactory from './factories/sumo';
 import SumoFactory from './factories/sumo';

+
+// External Dependencies
+

 import Serpentity from '@serpentity/serpentity';
 import { Application } from 'pixi.js';
 import { Engine } from 'matter-js';
 import Serpentity from '@serpentity/serpentity';
 import { Application } from 'pixi.js';
 import { Engine } from 'matter-js';


@@ -19,13 +41,13 @@ const internals = {
 
   onLoad() {
 
 
   onLoad() {
 

-    const sumo = new internals.Sumo({
+    const sumo = new internals.Sumo(Object.assign({

       element: document.getElementById('sumo-app-entry-point')
       element: document.getElementById('sumo-app-entry-point')

-    });
+    }, Config));

 
     sumo.startLoop();
 
 
     sumo.startLoop();
 

-    internals.exports.sumo = sumo;
+    window.sumo = sumo;

   }
 };
 
   }
 };
 


@@ -49,6 +71,7 @@ internals.Sumo = class Sumo {
 
   constructor(config) {
 
 
   constructor(config) {
 

+    // These defaults can get overridden by config

     this.fps = 60;
     this.aspectRatio = [2.76, 1];
     this.verticalResolution = 224;
     this.fps = 60;
     this.aspectRatio = [2.76, 1];
     this.verticalResolution = 224;


@@ -116,7 +139,7 @@ internals.Sumo = class Sumo {
 
       // We're sending the currentTime since it gives better results for
       // this type of renderer, though usually we expect the delta
 
       // We're sending the currentTime since it gives better results for
       // this type of renderer, though usually we expect the delta

-      this._engine.update(currentTime);
+      this._engine.update(currentFrameDuration);

       this._previousTime = currentTime;
     }
   }
       this._previousTime = currentTime;
     }
   }


@@ -176,16 +199,44 @@ internals.Sumo = class Sumo {
 
   _initializeSystems() {
 
 
   _initializeSystems() {
 

+    this._engine.addSystem(new ControlMapperSystem());
+
+    this._engine.addSystem(new DashSystem());
+
+    this._engine.addSystem(new GrabSystem({
+      engine: this._matterJs
+    }));
+
+    this._engine.addSystem(new ApplyForceSystem());
+

     this._engine.addSystem(new PhysicsWorldControlSystem({
       engine: this._matterJs
     }));
 
     this._engine.addSystem(new PhysicsWorldControlSystem({
       engine: this._matterJs
     }));
 

+    this._engine.addSystem(new DetectPointsCollisionSystem());
+
+    this._engine.addSystem(new DetectWinnerSystem());
+
+    this._engine.addSystem(new RenderPointsSystem({
+      application: this._pixi
+    }));
+
+    this._engine.addSystem(new RenderWinnerSystem({
+      application: this._pixi
+    }));
+
+    this._engine.addSystem(new ElasticSystem());
+

     this._engine.addSystem(new PhysicsToAttributesSystem());
 
     this._engine.addSystem(new AttributesToRenderableSystem());
 
     this._engine.addSystem(new CreateCouplingLineSystem());
 
     this._engine.addSystem(new PhysicsToAttributesSystem());
 
     this._engine.addSystem(new AttributesToRenderableSystem());
 
     this._engine.addSystem(new CreateCouplingLineSystem());
 

+    this._engine.addSystem(new DrawDashSystem());
+
+    this._engine.addSystem(new DrawGrabSystem());
+

     this._engine.addSystem(new RenderSystem({
       application: this._pixi
     }));
     this._engine.addSystem(new RenderSystem({
       application: this._pixi
     }));


@@ -195,42 +246,96 @@ internals.Sumo = class Sumo {
 
   _initializeEntities() {
 
 
   _initializeEntities() {
 

-    const entityA = SumoFactory.createSumo(null, {
+    SumoFactory.createArena(this._engine, {

       position: {
       position: {

-        x: 50,
-        y: 50
+        x: this.horizontalResolution / 2,
+        y: this.verticalResolution / 2

       }
     });
 
       }
     });
 

-    const entityB = SumoFactory.createSumo(null, {
+    const sumoA = SumoFactory.createPlayer1Sumo(null, {

       position: {
       position: {

-        x: 309,
-        y: 112
+        x: this.horizontalResolution / 2 - 100,
+        y: this.verticalResolution / 2

       }
     });
 
       }
     });
 

-    const entityC = SumoFactory.createSumo(null, {
+    const sumoB = SumoFactory.createPlayer2Sumo(null, {

       position: {
       position: {

-        x: 500,
-        y: 78
+        x: this.horizontalResolution / 2 + 100,
+        y: this.verticalResolution / 2
+      }
+    });
+
+    const harness = SumoFactory.createHarness(null, {
+      position: {
+        x: this.horizontalResolution / 2,
+        y: this.verticalResolution / 2

       }
     });
 
     SumoFactory.createRubberBand(this._engine, {
       }
     });
 
     SumoFactory.createRubberBand(this._engine, {

-      entityA,
-      entityB
+      entityA: sumoA,
+      entityB: harness

     });
 
     SumoFactory.createRubberBand(this._engine, {
     });
 
     SumoFactory.createRubberBand(this._engine, {

-      entityA: entityC,
-      entityB
+      entityA: sumoB,
+      entityB: harness

     });
 
     });
 

+    // Walls
+
+    SumoFactory.createInvisibleBlock(this._engine, {
+      width: this.horizontalResolution * 2,
+      height: this.verticalResolution * 0.1,
+      position: {
+        x: this.horizontalResolution / 2,
+        y: -this.verticalResolution * 0.1
+      }
+    });
+
+    SumoFactory.createInvisibleBlock(this._engine, {
+      width: this.horizontalResolution * 2,
+      height: this.verticalResolution * 0.1,
+      position: {
+        x: this.horizontalResolution / 2,
+        y: this.verticalResolution + this.verticalResolution * 0.1
+      }
+    });
+
+    // Points Detector
+
+    SumoFactory.createPointsCollider(this._engine, {
+      collisionTarget: sumoA,
+      pointsTarget: 'red',
+      height: this.verticalResolution,
+      width: this.horizontalResolution,
+      position: {
+        x: this.horizontalResolution + this.horizontalResolution / 2,
+        y: this.verticalResolution / 2
+      }
+    });
+
+    SumoFactory.createPointsCollider(this._engine, {
+      collisionTarget: sumoB,
+      pointsTarget: 'blue',
+      height: this.verticalResolution,
+      width: this.horizontalResolution,
+      position: {
+        x: -this.horizontalResolution / 2,
+        y: this.verticalResolution / 2
+      }
+    });
+
+    // The game state
+    SumoFactory.createGameState(this._engine);
+

     // To keep the coupling behind, we'll manually add the sumos later
 
     // To keep the coupling behind, we'll manually add the sumos later
 

-    this._engine.addEntity(entityA);
-    this._engine.addEntity(entityB);
-    this._engine.addEntity(entityC);
+    this._engine.addEntity(sumoA);
+    this._engine.addEntity(sumoB);
+    this._engine.addEntity(harness);

   }
 };
 
   }
 };