826 lines
22 KiB
JavaScript
826 lines
22 KiB
JavaScript
import { defaultDict, includesArray, initializeDistribution } from "./tools.js";
|
|
import { colorDict, DARKGRAY, GOLD } from "./ontology/constants.js";
|
|
import { EOS, Immovable, VGDLSprite } from "./ontology/vgdl-sprite.js";
|
|
import { MovingAvatar } from "./ontology/avatar.js";
|
|
import { Termination } from "./ontology/termination.js";
|
|
import { scoreChange, stochastic_effects } from "./ontology/effect.js";
|
|
import { Resource } from "./ontology/resource";
|
|
import { ContinuousPhysics, distance, quickDistance } from "./ontology/physics.js";
|
|
|
|
const MAX_SPRITES = 10000;
|
|
|
|
export class BasicGame {
|
|
default_mapping = {
|
|
w: ["wall"],
|
|
A: ["avatar"],
|
|
};
|
|
|
|
block_size = 10;
|
|
load_save_enabled = true;
|
|
disableContinuousKeyPress = true;
|
|
image_dir = "../sprites";
|
|
|
|
args = {};
|
|
|
|
score = 0;
|
|
bonus_score = 0;
|
|
real_start_time = 0;
|
|
real_time = 0;
|
|
time = 0;
|
|
ended = false;
|
|
num_sprites = 0;
|
|
kill_list = [];
|
|
all_killed = [];
|
|
|
|
frame_rate = 20;
|
|
|
|
sprite_constr = {
|
|
wall: [Immovable, { color: DARKGRAY }, ["wall"]],
|
|
avatar: [MovingAvatar, {}, ["avatar"]],
|
|
};
|
|
|
|
// z-level of sprite types (in case of overlap)
|
|
sprite_order = ["wall", "avatar"];
|
|
|
|
// contains instance lists
|
|
/**
|
|
* @type {Object.<string, VGDLSprite[]>}
|
|
*/
|
|
sprite_groups = {};
|
|
// which sprite types (abstract or not) are singletons?
|
|
singletons = [];
|
|
// collision effects (ordered by execution order)
|
|
collision_eff = [];
|
|
collision_types = [];
|
|
|
|
playback_actions = [];
|
|
playbacx_index = 0;
|
|
// for reading levels
|
|
char_mapping = {};
|
|
// temination criteria
|
|
terminations = [new Termination()];
|
|
// conditional criteria
|
|
conditions = [];
|
|
// resource properties
|
|
resources_limits = new defaultDict(2);
|
|
resources_colors = new defaultDict(GOLD);
|
|
|
|
is_stochastic = false;
|
|
_lastsaved = null;
|
|
win = null;
|
|
effectList = []; // list of effects this happened this current time step
|
|
spriteDistribution = {};
|
|
movement_options = {};
|
|
all_objects = null;
|
|
|
|
lastcollisions = {};
|
|
steps = 0;
|
|
gameStates = [];
|
|
realGameStates = [];
|
|
keystate = {};
|
|
EOS = new EOS();
|
|
sprite_bonus_granted_on_timestep = -1; // to ensure you only grant bonus once per timestep (since you check _isDone() multiple times)
|
|
timeout_bonus_granted_on_timestep = -1; // to ensure you only grant bonus once per timestep (since you check _isDone() multiple times)
|
|
|
|
shieldedEffects = {};
|
|
paused = true;
|
|
|
|
FPS = false;
|
|
use_frame = false;
|
|
|
|
objectTypes = {};
|
|
|
|
no_players = 1;
|
|
|
|
ignoredattributes = [
|
|
"stypes",
|
|
"name",
|
|
"lastmove",
|
|
// 'color',
|
|
"lastrect",
|
|
"resources",
|
|
"physicstype",
|
|
"physics",
|
|
"rect",
|
|
"alternate_keys",
|
|
"res_type",
|
|
"stype",
|
|
"ammo",
|
|
"draw_arrow",
|
|
"shrink_factor",
|
|
"prob",
|
|
"is_stochastic",
|
|
"cooldown",
|
|
"total",
|
|
"is_static",
|
|
"noiseLevel",
|
|
"angle_diff",
|
|
"only_active",
|
|
"airsteering",
|
|
"strength",
|
|
];
|
|
|
|
constructor(args) {
|
|
this.args = args;
|
|
|
|
for (const argsKey in args) {
|
|
this[argsKey] = args[argsKey];
|
|
}
|
|
|
|
this.reset();
|
|
}
|
|
|
|
reset = () => {
|
|
this.score = 0;
|
|
this.bonus_score = 0;
|
|
this.real_start_time = 0;
|
|
this.real_time = 0;
|
|
this.time = 0;
|
|
this.ended = false;
|
|
this.num_sprites = 0;
|
|
this.kill_list = [];
|
|
this.all_killed = [];
|
|
this.paused = true;
|
|
this.shieldedEffects = {};
|
|
};
|
|
|
|
resetLevel = () => {
|
|
this.reset();
|
|
this.buildLevel(this.level);
|
|
};
|
|
|
|
buildLevel = (lstr) => {
|
|
let lines = lstr
|
|
.split("\n")
|
|
.map((l) => {
|
|
return l.trimEnd();
|
|
})
|
|
.filter((l) => {
|
|
return l.length > 0;
|
|
});
|
|
let lengths = lines.map((line) => line.length);
|
|
|
|
// console.assert(Math.min.apply(null, lengths) === Math.max.apply(null, lengths), "Inconsistent line lengths");
|
|
|
|
this.width = Math.max(...lengths);
|
|
this.height = lines.length;
|
|
|
|
// console.assert(this.width > 1 && this.height > 1, "Level too small");
|
|
|
|
//Set up resources
|
|
for (let res_type in this.sprite_constr) {
|
|
if (!this.sprite_constr.hasOwnProperty(res_type)) continue;
|
|
let [sclass, args, _] = this.sprite_constr[res_type];
|
|
if (new sclass(0, 0, args) instanceof Resource) {
|
|
if (args["res_type"]) {
|
|
res_type = args["res_type"];
|
|
}
|
|
if (args["color"]) {
|
|
this.resources_colors[res_type] = args["color"];
|
|
}
|
|
if (args["limit"]) {
|
|
this.resources_limits[res_type] = args["limit"];
|
|
}
|
|
} else {
|
|
this.sprite_groups[res_type] = [];
|
|
this.sprite_constr[res_type][1]["Z"] =
|
|
this.sprite_order.indexOf(res_type);
|
|
}
|
|
}
|
|
|
|
// create sprites
|
|
lines.forEach((line, row) => {
|
|
for (const col in line) {
|
|
let c = line[col];
|
|
if (c in this.char_mapping) {
|
|
const pos = [parseInt(col), row];
|
|
this._createSprite(this.char_mapping[c], pos);
|
|
} else if (c in this.default_mapping) {
|
|
const pos = [parseInt(col), row];
|
|
this._createSprite(this.default_mapping[c], pos);
|
|
}
|
|
}
|
|
});
|
|
|
|
this.kill_list = [];
|
|
|
|
this.collision_eff.forEach((item) => {
|
|
const effect = item[2];
|
|
if (stochastic_effects.indexOf(effect) !== -1) this.is_stochastic = true;
|
|
});
|
|
|
|
this.level = lstr;
|
|
|
|
// console.log(this.sprite_order)
|
|
};
|
|
|
|
getPath = (start, end) => {};
|
|
|
|
randomizeAvatar = () => {
|
|
if (this.getAvatars().length === 0) this._createSprite(["avatar"], [0, 0]);
|
|
};
|
|
|
|
current_avatar_idx = 0;
|
|
|
|
_createSprite = (keys, pos) => {
|
|
let res = [];
|
|
keys.forEach((key) => {
|
|
if (this.num_sprites > MAX_SPRITES) {
|
|
console.log("Sprite limit reached.");
|
|
return;
|
|
}
|
|
let [sclass, args, stypes] = this.sprite_constr[key];
|
|
let anyother = false;
|
|
|
|
stypes.reverse().forEach((pk) => {
|
|
if (this.singletons.contains(pk)) {
|
|
if (this.numSprites(pk) > 0) {
|
|
anyother = true;
|
|
}
|
|
}
|
|
});
|
|
if (anyother) return;
|
|
args.key = key;
|
|
let s = new sclass(pos, [1, 1], args);
|
|
s.stypes = stypes;
|
|
|
|
if(s instanceof MovingAvatar){
|
|
s.playerID = this.current_avatar_idx;
|
|
this.current_avatar_idx += 1;
|
|
}
|
|
|
|
if (this.sprite_groups[key]) this.sprite_groups[key].push(s);
|
|
else this.sprite_groups[key] = [s];
|
|
this.num_sprites += 1;
|
|
if (s.is_stochastic) this.is_stochastic = true;
|
|
res.push(s);
|
|
});
|
|
|
|
return res;
|
|
};
|
|
|
|
_createSprite_cheap = (key, pos) => {
|
|
const [sclass, args, stypes] = this.sprite_constr[key];
|
|
const s = new sclass(pos, [1, 1], args);
|
|
s.stypes = stypes;
|
|
this.sprite_groups[key].push(s);
|
|
this.num_sprites += 1;
|
|
return s;
|
|
};
|
|
|
|
_iterAll = (ignoreKilled = false, filter_noncollision = false) => {
|
|
if (this.sprite_order[this.sprite_order.length - 1] !== "avatar") {
|
|
this.sprite_order.remove("avatar");
|
|
this.sprite_order.push("avatar");
|
|
}
|
|
/**
|
|
* @type {VGDLSprite[]}
|
|
*/
|
|
const result = this.sprite_order.reduce((base, key) => {
|
|
if (this.sprite_groups[key] === undefined) return base;
|
|
if (ignoreKilled) {
|
|
return base.concat(
|
|
this.sprite_groups[key].filter((s) => !this.kill_list.includes(s)),
|
|
);
|
|
}
|
|
return base.concat(this.sprite_groups[key]);
|
|
}, []);
|
|
|
|
if (filter_noncollision) {
|
|
return result.filter((s) =>
|
|
s.stypes.filter(x => this.collision_types.includes(x)).length > 0
|
|
)
|
|
}
|
|
return result;
|
|
};
|
|
|
|
_iterAllExcept = (keys) => {
|
|
if (this.sprite_order[this.sprite_order.length - 1] !== "avatar") {
|
|
this.sprite_order.remove("avatar");
|
|
this.sprite_order.push("avatar");
|
|
}
|
|
|
|
return this.sprite_order.reduce((base, key) => {
|
|
if (key in keys) return base;
|
|
if (this.sprite_groups[key] === undefined) return base;
|
|
return base.concat(this.sprite_groups[key]);
|
|
}, []);
|
|
};
|
|
|
|
numSprites = (key) => {
|
|
const deleted = this.kill_list.filter((s) => {
|
|
return s.stypes[key];
|
|
}).length;
|
|
// if (key in this.sprite_groups) {
|
|
// //避免找父类情况
|
|
// if(this.sprite_groups[key].length !== 0)
|
|
// return this.sprite_groups[key].length-deleted;
|
|
// }
|
|
|
|
return (
|
|
this._iterAll().filter((s) => {
|
|
return s.stypes.contains(key);
|
|
}).length - deleted
|
|
); // Should be __iter__ - deleted
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param {string} key sprite type
|
|
* @returns {list[Object]}
|
|
*/
|
|
getSprites = (key) => {
|
|
if (this.sprite_groups[key] instanceof Array)
|
|
return this.sprite_groups[key].filter((s) => {
|
|
return this.kill_list.indexOf(s) === -1;
|
|
});
|
|
else
|
|
return this._iterAll().filter((s) => {
|
|
return s.stypes.contains(key) && this.kill_list.indexOf(s) === -1;
|
|
});
|
|
};
|
|
|
|
getAvatars = (key) => {
|
|
const res = [];
|
|
if (this.sprite_groups.hasOwnProperty(key)) {
|
|
const ss = this.sprite_groups[key];
|
|
if (ss && ss[0] instanceof MovingAvatar)
|
|
res.concat(ss.filter((s) => this.kill_list.indexOf(s) === -1));
|
|
}
|
|
return res;
|
|
};
|
|
|
|
getSubTypes = (key) => {
|
|
const getSub = (dict, key) => {
|
|
if (dict.hasOwnProperty(key)) {
|
|
return dict[key];
|
|
} else if (Object.keys(dict).length === 0) {
|
|
return null;
|
|
} else {
|
|
let result = null;
|
|
for (const child in dict) {
|
|
const a = getSub(dict[child], key);
|
|
if (a !== null) result = a;
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
return getSub(this.objectTypes, key);
|
|
};
|
|
|
|
getObjects = () => {
|
|
const obj_list = {};
|
|
const fs = this.getFullState();
|
|
const obs = Object.copy(fs["objects_cur"]);
|
|
|
|
for (let obj_type in obs) {
|
|
this.getSprites(obj_type).forEach((obj) => {
|
|
const features = {
|
|
color: colorDict[obj.color.toString()],
|
|
row: [obj.location.y],
|
|
};
|
|
const type_vector = {
|
|
color: colorDict[obj.color.toString()],
|
|
row: [obj.location.y],
|
|
};
|
|
obj_list[obj.ID] = {
|
|
sprite: obj,
|
|
position: [obj.location.x, obj.location.y],
|
|
features: features,
|
|
type: type_vector,
|
|
};
|
|
});
|
|
}
|
|
|
|
return obj_list;
|
|
};
|
|
|
|
getFullState = () => {
|
|
const ias = this.ignoredattributes;
|
|
const obs = {};
|
|
const killed = {};
|
|
/**
|
|
* @type {VGDLSprite[]}
|
|
*/
|
|
const objects = [];
|
|
const actions = Object.keys(this.keystate).filter((key) => {
|
|
return this.keystate[key];
|
|
});
|
|
this.steps += actions.length;
|
|
|
|
for (const key in this.sprite_groups) {
|
|
if (!this.sprite_groups.hasOwnProperty(key)) continue;
|
|
const ss = {};
|
|
const order = this.sprite_order.indexOf(key);
|
|
this.getSprites(key).forEach((s) => {
|
|
const attrs = {};
|
|
Object.keys(s).forEach((a) => {
|
|
let val = s[a];
|
|
if (ias.indexOf(a) === -1) {
|
|
attrs[a] = val;
|
|
}
|
|
attrs["Z"] = order;
|
|
});
|
|
if (s.resources) {
|
|
attrs["resources"] = s.resources; // Should be object
|
|
}
|
|
|
|
ss[s.ID] = Object.copy(attrs);
|
|
objects.push(s);
|
|
});
|
|
obs[key] = Object.copy(ss);
|
|
}
|
|
|
|
const object_cur = Object.copy(obs);
|
|
|
|
return {
|
|
frame: this.time,
|
|
score: this.bonus_score,
|
|
ended: this.ended,
|
|
win: this.win,
|
|
objects: objects,
|
|
objects_cur: object_cur,
|
|
killed: killed,
|
|
actions: actions,
|
|
events: this.effectList,
|
|
real_time: this.real_time,
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Updates all sprites in the game.
|
|
* @param {number} delta - The time delta since the last update.
|
|
* This method iterates through all sprites and calls their update method, passing the game instance.
|
|
* If a sprite is not crashed, it will be updated; otherwise, it is skipped.
|
|
*/
|
|
_updateAll = (delta) => {
|
|
this._iterAll().forEach((sprite) => {
|
|
// try {
|
|
if (!sprite.crashed) sprite.update(this, delta);
|
|
// } catch (err) {
|
|
// if ((!sprite.crashed)) {
|
|
// console.error('could not update', sprite.name)
|
|
// throw err
|
|
// sprite.crashed = true;
|
|
// }
|
|
|
|
// }
|
|
});
|
|
};
|
|
|
|
_subUpdate = (sub_idx, sum_idx) => {
|
|
this._iterAll().forEach((sprite) => {
|
|
if (!sprite.crashed) sprite.subUpdate(this, sub_idx, sum_idx);
|
|
});
|
|
}
|
|
|
|
_clearAll = (onscreen = true) => {
|
|
this.kill_list.forEach((s) => {
|
|
this.all_killed.push(s);
|
|
this.sprite_groups[s.name].remove(s);
|
|
});
|
|
|
|
this.kill_list = [];
|
|
this.shieldedEffects = {};
|
|
};
|
|
|
|
_updateCollisionDict = (changedsprite) => {
|
|
for (let key in changedsprite.stypes) {
|
|
if (key in this.lastcollisions) delete this.lastcollisions[key];
|
|
}
|
|
};
|
|
|
|
_terminationHandling = () => {
|
|
let break_loop = false;
|
|
this.terminations.forEach((t) => {
|
|
//if (break_loop) return;
|
|
if (break_loop) return;
|
|
const [ended, win] = t.isDone(this);
|
|
|
|
this.ended = ended;
|
|
if (this.ended) {
|
|
if (win) {
|
|
//if (this.score <= 0)
|
|
//this.score += 1;
|
|
this.win = true;
|
|
} else {
|
|
//this.score -= 1;
|
|
this.win = false;
|
|
}
|
|
break_loop = true;
|
|
}
|
|
});
|
|
};
|
|
|
|
_getAllSpriteGroups = () => {
|
|
const lastcollisions = {};
|
|
|
|
this.collision_eff.forEach((eff) => {
|
|
const [class1, class2, effect, kwargs] = eff;
|
|
|
|
[class1, class2].forEach((sprite_class) => {
|
|
if (!(sprite_class in lastcollisions)) {
|
|
let sprite_array = [];
|
|
if (sprite_class in this.sprite_groups) {
|
|
sprite_array = this.sprite_groups[sprite_class].slice();
|
|
} else {
|
|
const sprites_array = [];
|
|
Object.keys(this.sprite_groups).forEach((key) => {
|
|
const sprites = this.sprite_groups[key].slice();
|
|
if (sprites.length && sprites[0].stypes.contains(sprite_class)) {
|
|
sprite_array = sprite_array.concat(sprites);
|
|
}
|
|
});
|
|
}
|
|
lastcollisions[sprite_class] = sprite_array;
|
|
}
|
|
});
|
|
});
|
|
return Object.assign(lastcollisions, this.sprite_groups);
|
|
};
|
|
|
|
_multi_effect = () => {
|
|
function r(sprite, partner, game, kwargs) {
|
|
let value;
|
|
for (let i = 0; i < arguments.length; i++) {
|
|
value = arguments[i](sprite, partner, game, kwargs);
|
|
}
|
|
return value;
|
|
}
|
|
return r;
|
|
};
|
|
|
|
get_effect = (stypes1, stypes2) => {
|
|
const res = [];
|
|
this.collision_eff.forEach((eff) => {
|
|
const class1 = eff[0];
|
|
const class2 = eff[1];
|
|
const eclass = eff[2];
|
|
|
|
if (
|
|
this.shieldedEffects[class1] && includesArray(this.shieldedEffects[class1], [class2, eclass])
|
|
) {
|
|
// console.log(
|
|
// `[GAMES] Check shield ${class1}, ${class2}, return`,
|
|
// );
|
|
return;
|
|
}
|
|
|
|
if (stypes1.includes(class1) && stypes2.includes(class2))
|
|
res.push({ reverse: false, effect: eff[2], kwargs: eff[3] });
|
|
else if (stypes1.includes(class2) && stypes2.includes(class1))
|
|
res.push({ reverse: true, effect: eff[2], kwargs: eff[3] });
|
|
});
|
|
return res;
|
|
};
|
|
|
|
_effectHandling = () => {
|
|
//最多处理碰撞7次
|
|
for (let iter_time = 0; iter_time < 7; iter_time++) {
|
|
// console.log("EffectHandling", iter_time)
|
|
this.updateCollision();
|
|
|
|
if (this.collision_set.length === 0) return;
|
|
|
|
// 确保collision按照顺序执行
|
|
for(let eff of this.collision_eff){
|
|
const class1 = eff[0]
|
|
const class2 = eff[1]
|
|
const eclass = eff[2]
|
|
const used_collision = [];
|
|
for (const collision of this.collision_set) {
|
|
const stypes1 = collision[0].stypes;
|
|
const stypes2 = collision[1].stypes;
|
|
|
|
let effects = [];
|
|
|
|
if (collision[1] === "EOS" || collision[1] === "eos") {
|
|
if (
|
|
stypes1.includes(class1) &&
|
|
(class2 === "EOS" || class2 === "eos")
|
|
)
|
|
effects = [{ reverse: false, effect: eff[2], kwargs: eff[3] }];
|
|
}
|
|
else {
|
|
if (
|
|
this.shieldedEffects[class1] && includesArray(this.shieldedEffects[class1], [class2, eclass])
|
|
) {
|
|
return;
|
|
}
|
|
|
|
if (stypes1.includes(class1) && stypes2.includes(class2))
|
|
effects.push({ reverse: false, effect: eff[2], kwargs: eff[3] });
|
|
else if (stypes1.includes(class2) && stypes2.includes(class1))
|
|
effects.push({ reverse: true, effect: eff[2], kwargs: eff[3] });
|
|
};
|
|
|
|
if (effects.length === 0) continue;
|
|
used_collision.push(collision);
|
|
for (const effect_set of effects) {
|
|
let [sprite, partner] = [collision[0], collision[1]];
|
|
if (effect_set.reverse) {
|
|
[sprite, partner] = [collision[1], collision[0]];
|
|
}
|
|
|
|
effect_set.effect(sprite, partner, this, effect_set.kwargs);
|
|
}
|
|
}
|
|
// this.collision_set = this.collision_set.filter((c) => !used_collision.includes(c));
|
|
}
|
|
this.collision_set = [];
|
|
}
|
|
|
|
};
|
|
|
|
run = (on_game_end) => {
|
|
this.on_game_end = on_game_end;
|
|
return this.startGame;
|
|
};
|
|
|
|
presskey = (keyCode, playerID = 0) => {
|
|
// console.log(`Press Button: ${keyCode}`)
|
|
if (this.key_handler === "Pulse") return;
|
|
const key = `${keyCode}${playerID}`;
|
|
// console.log(`Presskey`, key)
|
|
this.keystate[key] = true;
|
|
// this.key_to_clean?.push(key);
|
|
// if (this.key_handler === "Pulse") {
|
|
// this.update(0, true);
|
|
// }
|
|
};
|
|
|
|
presskeyUp = (keyCode, playerID = 0) => {
|
|
const key = `${keyCode}${playerID}`;
|
|
if (this.key_handler === "Pulse") {
|
|
this.keystate[key] = true;
|
|
this.key_to_clean?.push(key);
|
|
return;
|
|
}
|
|
this.keystate[key] = false;
|
|
this.key_to_clean?.push(key);
|
|
// this.update(0, true)
|
|
};
|
|
|
|
// updateTime = 1000 / 10;
|
|
updateTime = 1/15;
|
|
currentTime = 0;
|
|
|
|
collision_set = [];
|
|
|
|
addCollisions = (a, b) => {
|
|
return;
|
|
};
|
|
|
|
addShield = (a, stype, ftype) => {
|
|
|
|
for(const a_type of a){
|
|
if(!this.shieldedEffects[a_type])
|
|
this.shieldedEffects[a_type] = []
|
|
if(includesArray(this.shieldedEffects[a_type], [stype, ftype])) continue;
|
|
this.shieldedEffects[a_type].push([stype, ftype]);
|
|
}
|
|
// console.log("add shield", a, stype, ftype, this.shieldedEffects)
|
|
};
|
|
|
|
updateCollision = () => {
|
|
//TODO: 使用最简单的方法实现，到非格子的方法可能会有问题
|
|
// console.log("iter all")
|
|
const allSprites = this._iterAll(true, true);
|
|
|
|
// console.log("updateCollision", allSprites.length)
|
|
|
|
|
|
for (let i = 0; i < allSprites.length; i++) {
|
|
const sprite1 = allSprites[i];
|
|
|
|
if (
|
|
sprite1.location.x < 0 ||
|
|
sprite1.location.x > this.width ||
|
|
sprite1.location.y < 0 ||
|
|
sprite1.location.y > this.height
|
|
) {
|
|
this.collision_set.push([sprite1, "EOS"]);
|
|
}
|
|
|
|
for (let j = i + 1; j < allSprites.length; j++) {
|
|
const sprite2 = allSprites[j];
|
|
const dist = quickDistance(sprite1, sprite2);
|
|
|
|
if (dist <= 0.99) {
|
|
this.collision_set.push([sprite1, sprite2]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @param {number} delta, time in seconds
|
|
* @param {boolean} now, if true, update will be called immediately
|
|
* @returns {null | string | undefined} return null if game is paused, return string if game is ended, return undefined if game is running
|
|
*/
|
|
update = (delta, now = false) => {
|
|
// if (this.key_handler === "Pulse") {
|
|
// if (!now) return;
|
|
// }
|
|
|
|
if (this.use_frame === false){
|
|
if (!now) {
|
|
this.currentTime += delta;
|
|
// console.log("BasicGame update", now, this.use_frame, delta, this.use_frame, this.currentTime, this.updateTime, this.currentTime < this.updateTime)
|
|
|
|
if (this.currentTime < this.updateTime) {
|
|
// console.log("return")
|
|
return;
|
|
}
|
|
this.currentTime %= this.updateTime;
|
|
}
|
|
}
|
|
|
|
if (this.paused) return "paused";
|
|
if (this.ended) {
|
|
this.paused = true;
|
|
this.on_game_end(this.getFullState());
|
|
return this.win;
|
|
}
|
|
|
|
|
|
if(this.use_frame === true)
|
|
this.time += delta * 15;
|
|
else this.time ++;
|
|
|
|
this._terminationHandling();
|
|
|
|
this._clearAll();
|
|
this._updateAll();
|
|
|
|
this._effectHandling();
|
|
|
|
for (const keycode of this.key_to_clean) {
|
|
this.keystate[keycode] = false;
|
|
}
|
|
|
|
this.key_to_clean = [];
|
|
this.collision_set = [];
|
|
};
|
|
|
|
/**
|
|
* Start the game.
|
|
*/
|
|
startGame = () => {
|
|
this.reset();
|
|
this.paused = false;
|
|
|
|
this.key_to_clean = [];
|
|
|
|
let sprite_types = [Immovable];
|
|
this.all_objects = this.getObjects(); // Save all objects, some which may be killed in game
|
|
|
|
const objects = this.getObjects();
|
|
this.spriteDistribution = {};
|
|
this.movement_options = {};
|
|
Object.keys(objects).forEach((sprite) => {
|
|
this.spriteDistribution[sprite] = initializeDistribution(sprite_types);
|
|
this.movement_options[sprite] = { OTHER: {} };
|
|
sprite_types.forEach((sprite_type) => {
|
|
this.movement_options[sprite][sprite_type] = {};
|
|
});
|
|
});
|
|
|
|
// This should actually be in a game loop function, or something.
|
|
|
|
// this._clearAll();
|
|
|
|
Object.keys(objects).forEach((sprite_number) => {
|
|
let sprite = objects[sprite_number];
|
|
if (!(this.spriteDistribution in sprite)) {
|
|
this.all_objects[sprite] = objects[sprite];
|
|
this.spriteDistribution[sprite] = initializeDistribution(sprite_types);
|
|
this.movement_options[sprite] = { OTHER: {} };
|
|
sprite_types.forEach((sprite_type) => {
|
|
this.movement_options[sprite][sprite_type] = {};
|
|
});
|
|
}
|
|
});
|
|
|
|
this.keystate = {};
|
|
this.keywait = {};
|
|
|
|
// cache collision types
|
|
this.collision_types = [];
|
|
this.collision_eff.forEach((eff) => {
|
|
const object = eff[0];
|
|
const subject = eff[1];
|
|
if(!this.collision_types.includes(object))
|
|
this.collision_types.push(object)
|
|
if(!this.collision_types.includes(subject))
|
|
this.collision_types.push(subject)
|
|
});
|
|
// console.log(this.collision_types)
|
|
};
|
|
|
|
getPossibleActions = () => {
|
|
return this.getAvatars()[0].declare_possible_actions();
|
|
};
|
|
}
|