jeena/chuck.js
1
0
Fork 0
mirror of https://github.com/logsol/chuck.js.git synced 2026-05-11 10:37:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

new system for synchronizing game objects. fixes #74

Browse source
This commit is contained in:
logsol 2015-06-22 00:14:17 +02:00
parent 3ef3a6abf9
commit 07dad646cf
19 changed files with 194 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

44
app/Game/Channel/GameController.js
View file

@ -83,8 +83,6 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
var spawnTimeout = setTimeout(function() {
player.spawn(spawnPoint.x, spawnPoint.y);
// put it into
self.gameObjects.animated.push(player);
var options = {
id: player.id,
@ -118,6 +116,7 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
var update = {};
/*
var body = this.physicsEngine.world.GetBodyList();
do {
if((getSleeping || body.IsAwake()) && body.GetType() === Box2D.Dynamics.b2Body.b2_dynamicBody) {
@ -125,22 +124,33 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
if (userData instanceof GameObject) {
var gameObject = userData;
update[gameObject.uid] = {
p: body.GetPosition(),
a: body.GetAngle(),
lv: body.GetLinearVelocity(),
av: body.GetAngularVelocity()
};
if(gameObject instanceof Doll) {
update[gameObject.uid].as = gameObject.getActionState();
update[gameObject.uid].laxy = gameObject.lookAtXY;
var updateData = gameObject.getUpdateData();
if (updateData) {
update[gameObject.uid] = updateData;
}
}
}
} while (body = body.GetNext());
*/
for (var uid in this.worldUpdateObjects) {
var gameObject = this.worldUpdateObjects[uid];
if (!(gameObject instanceof GameObject)) {
console.warn('Cant find object ' + uid + ' in worldUpdateObjects pool (channel side), here is the object:');
console.log(gameObject);
continue;
}
var updateData = gameObject.getUpdateData(getSleeping);
if (updateData) {
update[gameObject.uid] = updateData;
}
}
return update;
};
@ -171,9 +181,11 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
GameController.prototype.getRuntimeItems = function() {
var objects = [];
for (var i = 0; i < this.gameObjects.animated.length; i++) {
if(this.gameObjects.animated[i] instanceof RubeDoll) {
var object = this.gameObjects.animated[i];
// This is using the level.createItem mechanism to
// create the RubeDoll from its ItemSettings
for (var uid in this.worldUpdateObjects) {
if(this.worldUpdateObjects[uid] instanceof RubeDoll) {
var object = this.worldUpdateObjects[uid];
var options = object.options;
options.x = object.getPosition().x;
options.y = object.getPosition().y;

12
app/Game/Channel/GameObjects/Doll.js
View file

@ -98,6 +98,18 @@ function (Parent, Item, Box2D, Nc, Assert) {
this.body.SetLinearVelocity(update.lv);
}
};
Doll.prototype.getUpdateData = function(getSleeping) {
var updateData = Parent.prototype.getUpdateData.call(this, getSleeping);
if(updateData) {
updateData.as = this.getActionState();
updateData.laxy = this.lookAtXY;
}
return updateData;
};
return Doll;

36
app/Game/Channel/GameObjects/GameObject.js
View file

@ -1,9 +1,39 @@
define([
"Game/Core/GameObjects/GameObject"
"Game/Core/GameObjects/GameObject",
"Lib/Vendor/Box2D"
],
function(Parent) {
function (Parent, Box2D) {
return Parent;
"use strict";
function GameObject(physicsEngine, uid) {
Parent.call(this, physicsEngine, uid);
}
GameObject.prototype = Object.create(Parent.prototype);
GameObject.prototype.getUpdateData = function(getSleeping) {
if (!this.body) {
return null;
}
if (this.body.GetType() === Box2D.Dynamics.b2Body.b2_staticBody) {
return null;
}
if (!getSleeping && !this.body.IsAwake()) {
return null;
}
return {
p: this.body.GetPosition(),
a: this.body.GetAngle(),
lv: this.body.GetLinearVelocity(),
av: this.body.GetAngularVelocity()
};
}
return GameObject;
});

4
app/Game/Channel/Loader/Level.js
View file

@ -8,8 +8,8 @@ function (Parent, Settings, FileSystem) {
"use strict";
function Level (uid, engine, gameObjects) {
Parent.call(this, uid, engine, gameObjects);
function Level (uid, engine) {
Parent.call(this, uid, engine);
}
Level.prototype = Object.create(Parent.prototype);

53
app/Game/Client/GameController.js
View file

@ -55,9 +55,11 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
this.mePositionStateUpdate();
}
for (var i = 0; i < this.gameObjects.animated.length; i++) {
this.gameObjects.animated[i].render();
}
//for (var uid in this.gameObjects.animated) {
// this.gameObjects.animated[uid].render();
//}
Nc.trigger(Nc.ns.client.game.events.render);
this.view.render();
DomController.fpsStep();
@ -78,17 +80,10 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
if (options.runtimeItems) {
for (i = 0; i < options.runtimeItems.length; i++) {
var itemDef = options.runtimeItems[i];
var alreadyExists = false;
for (var j = 0; j < this.gameObjects.animated.length; j++) {
if(this.gameObjects.animated[j].uid == itemDef.uid) {
alreadyExists = true;
break;
}
}
if(!alreadyExists) {
if(!this.getItemByUid(itemDef.uid)) {
// When creating from synchronization we need to bring it into level format (px)
itemDef.options.x *= Settings.RATIO;
itemDef.options.y *= Settings.RATIO;
@ -112,6 +107,13 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
//this.audioPlayer.play();
};
/*
TODO :
- remove this
- overwrite setUpdateData inside client / Me with an empty function
GameController.prototype.onWorldUpdateGameObject = function(body, gameObject, update) {
if(gameObject === this.me.doll) {
this.me.setLastServerPositionState(update);
@ -122,6 +124,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
Parent.prototype.onWorldUpdateGameObject.call(this, body, gameObject, update);
};
*/
GameController.prototype.createMe = function(user) {
this.me = new Me(user.id, this.physicsEngine, user);
@ -161,15 +164,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
GameController.prototype.onHandActionResponse = function(options) {
var player = this.players[options.playerId];
var item = null;
for (var i = 0; i < this.gameObjects.animated.length; i++) {
var currentItem = this.gameObjects.animated[i];
if(currentItem.uid == options.itemUid) {
item = currentItem;
break;
}
}
var item = this.getItemByUid(options.itemUid);
if(item) {
if(options.action == "throw") {
@ -230,22 +225,6 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
this.me.resetPositionState(options);
};
GameController.prototype.onRemoveGameObject = function(options) {
var object = null;
for (var i = 0; i < this.gameObjects[options.type].length; i++) {
if(this.gameObjects[options.type][i].uid == options.uid) {
object = this.gameObjects[options.type][i];
break;
}
}
if(object) {
//this.onGameObjectRemove(options.type, object);
object.destroy();
} else {
console.warn("GameObject for removal can not be found locally. " + options.uid);
}
};
GameController.prototype.loadLevel = function (path) {
Parent.prototype.loadLevel.call(this, path);
};

2
app/Game/Client/GameObjects/GameObject.js
View file

@ -27,7 +27,7 @@ function (Parent, Exception, Nc) {
GameObject.prototype.createMesh = function() {
throw new Exception('Abstract method GameObject.createMesh not overwritten');
};
return GameObject;
});

2
app/Game/Client/GameObjects/Item.js
View file

@ -12,6 +12,8 @@ function (Parent, Settings, Nc, Layer) {
function Item(physicsEngine, uid, options) {
this.layerId = Layer.ID.ITEM;
Parent.call(this, physicsEngine, uid, options);
Nc.on(Nc.ns.client.game.events.render, this.render, this);
}
Item.prototype = Object.create(Parent.prototype);

2
app/Game/Client/GameObjects/Items/RubeDoll.js
View file

@ -189,8 +189,6 @@ function (Parent, Layer, Settings, Nc) {
RubeDoll.prototype.flip = function(direction) {
Parent.prototype.flip.call(this, direction);
console.log("last", this.lastFlipDirection, "now", direction);
// flipping depth of right body side arm/leg images with left
if (this.lastFlipDirection != direction) { // FIXME : this is a bit broken.

4
app/Game/Client/Loader/TiledLevel.js
View file

@ -8,9 +8,9 @@ function (Parent, Settings, Nc) {
"use strict";
function TiledLevel(uid, engine, gameObjects) {
function TiledLevel(uid, engine) {
this.layerId = "background";
Parent.call(this, uid, engine, gameObjects);
Parent.call(this, uid, engine);
}
TiledLevel.prototype = Object.create(Parent.prototype);

2
app/Game/Client/Player.js
View file

@ -15,6 +15,8 @@ function (Parent, Nc, Settings) {
this.healthBarViewVisibleTimeout = null;
this.healthBarViewVisible = false;
this.initHealthBar();
Nc.on(Nc.ns.client.game.events.render, this.render, this);
}
Player.prototype = Object.create(Parent.prototype);

122
app/Game/Core/GameController.js
View file

@ -17,15 +17,14 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
this.options = options;
this.players = {};
this.level = null;
this.gameObjects = null;
this.resetGameObjects();
this.worldUpdateObjects = {};
this.physicsEngine = new PhysicsEngine();
this.physicsEngine.setCollisionDetector();
this.ncTokens = [
Nc.on(Nc.ns.core.game.gameObject.add, this.onGameObjectAdd, this),
Nc.on(Nc.ns.core.game.gameObject.remove, this.onGameObjectRemove, this)
Nc.on(Nc.ns.core.game.worldUpdateObjects.add, this.onWorldUpdateObjectAdd, this),
Nc.on(Nc.ns.core.game.worldUpdateObjects.remove, this.onWorldUpdateObjectRemove, this)
];
this.loadLevel(options.levelUid);
@ -37,79 +36,58 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
// extend for both sides if necessary
};
GameController.prototype.resetGameObjects = function() {
this.gameObjects = {
fixed: [],
animated: []
};
GameController.prototype.onWorldUpdateObjectAdd = function(object) {
this.worldUpdateObjects[object.uid] = object;
};
GameController.prototype.onGameObjectAdd = function(type, object) {
this.gameObjects[type].push(object);
};
GameController.prototype.onGameObjectRemove = function(type, object) {
var i = this.gameObjects[type].indexOf(object);
if(i>=0) this.gameObjects[type].splice(i, 1);
GameController.prototype.onWorldUpdateObjectRemove = function(object) {
delete this.worldUpdateObjects[object.uid];
};
GameController.prototype.getPhysicsEngine = function () {
return this.physicsEngine;
};
GameController.prototype.getItemByUid = function(uid) {
// FIXME : maybe divide this into a dedicated item pool?
return this.worldUpdateObjects[uid];
};
GameController.prototype.loadLevel = function (levelUid) {
if (this.level) {
this.level.destroy();
this.resetGameObjects();
this.worldUpdateObjects = {};
}
this.level = new TiledLevel(levelUid, this.physicsEngine, this.gameObjects);
this.level = new TiledLevel(levelUid, this.physicsEngine);
};
/*
* This is now in core, because the recorder/player
* uses the world update mechanism on the channel side
*/
GameController.prototype.onWorldUpdate = function (updateData) {
var body = this.physicsEngine.world.GetBodyList();
do {
var userData = body.GetUserData();
if (userData instanceof GameObject) {
var gameObject = userData;
if(updateData[gameObject.uid]) {
var update = updateData[gameObject.uid];
this.onWorldUpdateGameObject(body, gameObject, update);
}
for (var uid in updateData) {
var gameObject = this.worldUpdateObjects[uid];
if (!(gameObject instanceof GameObject)) {
console.warn('Cant find object ' + uid + ' in worldUpdateObjects pool');
continue;
}
} while (body = body.GetNext());
};
GameController.prototype.onWorldUpdateGameObject = function(body, gameObject, update) {
if (gameObject instanceof Doll) {
/*
if(gameObject === this.me.doll) {
this.me.setLastServerPositionState(update);
if(!this.me.acceptPositionStateUpdateFromServer()) {
return; // this is to ignore own doll updates from world update
}
}
*/
gameObject.setActionState(update.as);
gameObject.lookAt(update.laxy.x, update.laxy.y);
gameObject.setUpdateData(updateData[uid]);
}
Assert.number(update.p.x, update.p.y);
Assert.number(update.a);
Assert.number(update.lv.x, update.lv.y);
Assert.number(update.av);
body.SetAwake(true);
body.SetPosition(update.p);
body.SetAngle(update.a);
body.SetLinearVelocity(update.lv);
body.SetAngularVelocity(update.av);
};
/*
GameController.prototype.onWorldUpdateGameObject = function(body, gameObject, update) {
FIXME : call gameObject.setUpdateData(updateData[uid]);
};
*/
GameController.prototype.onResetLevel = function() {
this.loadLevel(this.level.uid);
};
@ -140,39 +118,23 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
GameController.prototype.destroy = function () {
var i = 0;
/*
for(var player in this.players) {
// this.players[player].destroy();
// FIXME:
// commented out for now, because players are in gameObjects array.
// try using a real gameobject for the health bar
}*/
for (i = 0; i < this.ncTokens.length; i++) {
Nc.off(this.ncTokens[i]);
this.players[player].destroy();
}
/*
* Contents of gameObject: Players, Items, Tiles, RagDolls
* No Dolls.
*/
Nc.trigger(Nc.ns.client.game.events.destroy);
for (var key in this.gameObjects) {
for (i = 0; i < this.gameObjects[key].length; i++) {
var gameObject = this.gameObjects[key][i];
gameObject.destroy();
}
// Testing after destroy if worldUpdateObjects is empty
// events.game.destroy -> gameobjects.destroy() -> Nc.trigger(worldUpdateObjects.remove)
if(Object.keys(this.worldUpdateObjects).length > 0) {
console.warn('Not all worldUpdateObjects have been removed... ', Object.keys(this.worldUpdateObjects));
}
this.gameObjects = {
fixed: [],
animated: []
};
this.physicsEngine.destroy();
this.worldUpdateObjects = null;
Nc.off(this.ncTokens);
};
return GameController;

10
app/Game/Core/GameObjects/Doll.js
View file

@ -45,6 +45,7 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
this.createFixtures();
this.body.SetActive(false);
Nc.trigger(Nc.ns.core.game.worldUpdateObjects.add, this);
}
Doll.prototype = Object.create(Parent.prototype);
@ -471,7 +472,16 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
}
};
Doll.prototype.setUpdateData = function(update) {
Parent.prototype.setUpdateData.call(this, update);
this.setActionState(update.as);
this.lookAt(update.laxy.x, update.laxy.y);
};
Doll.prototype.destroy = function() {
Nc.trigger(Nc.ns.core.game.worldUpdateObjects.remove, this);
Parent.prototype.destroy.call(this);
};

27
app/Game/Core/GameObjects/GameObject.js
View file

@ -1,9 +1,11 @@
define([
"Lib/Vendor/Box2D",
"Lib/Utilities/Exception"
"Lib/Utilities/Exception",
"Lib/Utilities/Assert",
"Lib/Utilities/NotificationCenter"
],
function (Box2D, Exception) {
function (Box2D, Exception, Assert, Nc) {
"use strict";
@ -13,6 +15,10 @@ function (Box2D, Exception) {
var def = this.getBodyDef();
def.userData = this;
this.body = physicsEngine.getWorld().CreateBody(def);
this.ncTokens = (this.ncTokens || []).concat([
Nc.on(Nc.ns.client.game.events.destroy, this.destroy, this)
]);
}
GameObject.prototype.getBodyDef = function() {
@ -20,11 +26,14 @@ function (Box2D, Exception) {
};
GameObject.prototype.destroy = function() {
if(this.body instanceof Box2D.Dynamics.b2Body) {
this.body.GetWorld().DestroyBody(this.body);
} else {
throw new Exception("can not destroy body");
}
Nc.off(this.ncTokens);
};
GameObject.prototype.getBody = function() {
@ -34,6 +43,20 @@ function (Box2D, Exception) {
GameObject.prototype.getPosition = function() {
return this.body.GetPosition().Copy();
};
GameObject.prototype.setUpdateData = function(update) {
Assert.number(update.p.x, update.p.y);
Assert.number(update.a);
Assert.number(update.lv.x, update.lv.y);
Assert.number(update.av);
this.body.SetAwake(true);
this.body.SetPosition(update.p);
this.body.SetAngle(update.a);
this.body.SetLinearVelocity(update.lv);
this.body.SetAngularVelocity(update.av);
};
return GameObject;

4
app/Game/Core/GameObjects/Item.js
View file

@ -41,7 +41,7 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
this.body.SetBullet(true);
}
Nc.trigger(Nc.ns.core.game.gameObject.add, "animated", this);
Nc.trigger(Nc.ns.core.game.worldUpdateObjects.add, this);
}
Item.prototype = Object.create(Parent.prototype);
@ -158,7 +158,7 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
};
Item.prototype.destroy = function() {
Nc.trigger(Nc.ns.core.game.gameObject.remove, "animated", this);
Nc.trigger(Nc.ns.core.game.worldUpdateObjects.remove, this);
Parent.prototype.destroy.call(this);
};

1
app/Game/Core/GameObjects/Items/RagDoll.js
View file

@ -378,7 +378,6 @@ function (Parent, Box2D, Settings, Nc, Assert, Options, ItemSettings) {
RagDoll.prototype.destroy = function() {
Nc.trigger(Nc.ns.core.game.gameObject.remove, "animated", this);
var world = this.body.GetWorld();
for (var name in this.limbs) {

1
app/Game/Core/GameObjects/Items/RubeDoll.js
View file

@ -138,7 +138,6 @@ function (Parent, RubeLoader, Box2D, Settings, Assert, Nc, RubeDollJson) {
RubeDoll.prototype.destroy = function() {
Nc.trigger(Nc.ns.core.game.gameObject.remove, "animated", this);
var world = this.body.GetWorld();
for (var name in this.limbs) {

6
app/Game/Core/GameObjects/Tile.js
View file

@ -15,8 +15,6 @@ function (Parent, Box2D, Settings, Exception, Nc, Assert) {
this.options = options;
Parent.call(this, physicsEngine, uid);
this.createPhysicTile(this.options);
Nc.trigger(Nc.ns.core.game.gameObject.add, "fixed", this);
}
Tile.prototype = Object.create(Parent.prototype);
@ -119,10 +117,6 @@ function (Parent, Box2D, Settings, Exception, Nc, Assert) {
Tile.prototype.addVec = function (vs, m1, m2) {
return vs.push(new Box2D.Common.Math.b2Vec2(this.mkArg(m1), this.mkArg(m2)));
};
Tile.prototype.destroy = function() {
Nc.trigger(Nc.ns.core.game.gameObject.remove, "fixed", this);
};
return Tile;

8
app/Game/Core/Player.js
View file

@ -27,8 +27,6 @@ function (Doll, Settings, Nc, Exception, ColorConverter, SpectatorDoll, RubeDoll
this.spawned = false;
this.holdingItem = null;
this.spectatorDoll = new SpectatorDoll(this.physicsEngine, "spectatorDoll-" + this.id, this);
Nc.trigger(Nc.ns.core.game.gameObject.add, 'animated', this);
}
Player.prototype.getNickname = function() {
@ -161,7 +159,7 @@ function (Doll, Settings, Nc, Exception, ColorConverter, SpectatorDoll, RubeDoll
Player.prototype.destroy = function () {
Nc.trigger(Nc.ns.core.game.gameObject.remove, 'animated', this);
// FIXME add destroy nc hook
if(this.holdingItem) {
var options = {
@ -174,8 +172,10 @@ function (Doll, Settings, Nc, Exception, ColorConverter, SpectatorDoll, RubeDoll
this.spectatorDoll.destroy();
// doll destoys itself at the end cause its a gameobject
// but on userLeft, the player has to destroy it.
if(this.doll) {
this.doll.destroy();
this.doll.destroy();
}
if(this.playerController) {

16
app/Lib/Utilities/NotificationCenter.js
View file

@ -85,6 +85,10 @@ function (Exception) {
}
},
game: {
events: {
render: null,
destroy: null
},
gameStats: {
toggle: null
},
@ -102,9 +106,9 @@ function (Exception) {
},
core: {
game: {
gameObject: {
worldUpdateObjects: {
add: null,
remove: null
remove: null,
},
events: {
level: {
@ -241,18 +245,24 @@ function (Exception) {
NotificationCenter.prototype.off = function (token) {
if(token && token.constructor === Array) {
this.offAll(token);
return;
}
for(var m in this.topics) {
if (this.topics[m]) {
for(var i = 0, j = this.topics[m].length; i < j; i++) {
if (this.topics[m][i].token === token) {
this.topics[m].splice(i, 1);
return token;
return;
}
}
}
}
}
// should be treated as a private function - use Nc.off(Array);
NotificationCenter.prototype.offAll = function (tokens) {
for (var i = 0; i < tokens.length; i++) {
this.off(tokens[i]);