Squaby Demo
// this reduces the delay between 2 squaby creations by this value per wave
//var squabyDelayDecrementPerWave = 500;
//var pauseBetweenWavesDecrementPerWave = 500;
// this guarantees that at high wave count the delay never gets lower than this number
//var minimumSquabyDelay = 2000; // this setting has high impact on performance - if set too low, a heap of squabies gets created which might cause the application to run slowly on slow devices!
//var minimumPauseBetweenWaves = 3000;
var currentSquabyDelay = 8000; // this is the initial delay between 2 squaby creations
var currentPauseBetweenWaves = 5000; // this is the initial waiting time between waves, which can be used to adjust the towers (repair, sell or upgrade them if in game its too hectic)
// this is used for getting the last wave from the level - when no more waves are defined, they simply get repeated, and currentWave is increased so an increasing number can be shown in the hud!
// so internalWaveIndex is equal to currentWave as long as waves.length, then it stays at wave.length
var internalWaveIndex = 1;
// this gets set to true after all squabies were created for this wave
var __isWaitingForNextWave = false;
//var squabiesBuiltInCurrentWave = 0;
// this is true while timerTriggered is call - it is a guard for the initial (first time loading) of SquabyScene, where it might be that multiple entities are created
var isCurrentlyCreating = false;
function initialize() {
currentWave = 1
internalWaveIndex = currentWave
percentageCreatedInWave = 1
squabiesBuiltInCurrentWave = 0
if(!waves) {
console.debug("SquabyCreatorLogic: no waves known yet!")
return
}
__isWaitingForNextWave = false;
squabyCreator.state = ""
// warning no waves set
if(!getCurrentWave())
return
currentSquabyDelay = getCurrentWave().squabyDelay;
currentPauseBetweenWaves = getCurrentWave().pauseBetweenWaves;
amountSquabiesInCurrentWave = getCurrentWave().amount;
//console.debug("amountSquabiesInCurrentWave initialized to", amountSquabiesInCurrentWave)
setIntervalOfCreationTimer(currentSquabyDelay);
}
function setIntervalOfCreationTimer(interval) {
console.debug("SquabyCreatorLogic: set creationTimer interval to", interval);
// ATTENTION: a change of interval automatically restarts the timer!
creationTimer.interval = interval;
}
/*
// look at the level file for description of each squaby type!
// this is defined in Level now!
// abbreviations for faster writing - earlier by types, now squabyTypes are the ids to real components!
var sy = "squabyYellow";
// change this to squabyOrange once it is available, but now for testing with only 1 squaby type leave it with that
var so = "squabyOrange";
var sr = "squabyRed";
var sgreen = "squabyGreen";
var sblue = "squabyBlue";
var sgrey = "squabyGrey";
// this is defined in level now, as this is a level-specific setting!
var waves = [
// for testing a single squaby type, use the line below with the intended types:
//{amount: 50, types:[ {type: sgrey, p: 1}, {type: so, p: 0} ]},
// optionally, the intended time between 2 squaby creations can be set, or also the desired delay from the last wave; if one of them is not set, the default decrement-values are used..
{amount: 1, types:[ {type: sy, p: 1}, {type: so, p: 0} ]},
// these 2 parameters are optional per level: {amount: 2, squabyDelay: 2, pauseBetweenWaves: 1.8, types:[ {type: sy, p: 1}, {type: so, p: 0.1} ]},
{amount: 2, types:[ {type: sy, p: 1}, {type: so, p: 0.1} ]},
{amount: 3, types:[ {type: sy, p: 1}, {type: so, p: 0.5} ]},
{amount: 4, types:[ {type: sy, p: 1}, {type: so, p: 0.8} ]},
{amount: 5, types:[ {type: sy, p: 1}, {type: so, p: 1.0} ]},
{amount: 8, types:[ {type: sy, p: 1}, {type: so, p: 1.0}, {type: sr, p: 1.0} ]},
{amount: 12, types:[ {type: sy, p: 1}, {type: so, p: 1.0}, {type: sr, p: 1.0}, {type: sgreen, p: 1.0}]},
{amount: 20, types:[ {type: sy, p: 1}, {type: so, p: 1.0}, {type: sr, p: 1.0}, {type: sgreen, p: 1.0}, {type: sblue, p: 1.0}]},
{amount: 30, types:[ {type: sy, p: 1}, {type: so, p: 1.0}, {type: sr, p: 1.0}, {type: sgreen, p: 1.0}, {type: sblue, p: 1.0}, {type: sgrey, p: 1.0}]},
// the hardest squabies have higher probability here
{amount: 30, types:[ {type: sy, p: 0.1}, {type: so, p: 0.2}, {type: sr, p: 1.0}, {type: sgreen, p: 1.0}, {type: sblue, p: 0.5}, {type: sgrey, p: 1.0}]},
]
*/
function updatePauseBetweenWaves() {
if(!getCurrentWave()) {
return
}
// if the pauseBetweenWaves property is set, set it directly
if(getCurrentWave().pauseBetweenWaves)
currentPauseBetweenWaves = getCurrentWave().pauseBetweenWaves;
// otherwise, decrease it by specified amount
else
currentPauseBetweenWaves -= pauseBetweenWavesDecrementPerWave;
// guarantee the calculated value never gets below the minimum threshold
if(currentPauseBetweenWaves<minimumPauseBetweenWaves)
currentPauseBetweenWaves = minimumPauseBetweenWaves;
}
function timerTriggered() {
if(isCurrentlyCreating) {
console.debug("OVERLOAD because too much is loading in the beginning - skip entity creation once!")
return;
}
isCurrentlyCreating = true;
console.debug("SquabyCreatorLogic: creationTimer triggered");
// the squaby type per wave could be calculated randomly, based on the probability for each squaby type
// check if randomnumber is deterministic (results in the same number generated every program start) - it IS when qsrand() is called at initialization, which is done in application.cpp!
//var randomNumber = Math.floor(Math.random()*5 );
//print("randomNumber: " + randomNumber);
//print("__lastCreationTimer: " + __lastCreationTimer);
//print("Core.time: " + Core.time);
// use last wave for endless run
if(endlessGameRunning) {
currentWave = waves.length-1
internalWaveIndex = currentWave
__isWaitingForNextWave = true
}
// also use the lastCreationTimer for measuring the time elapsed since the last squaby in this wave was created (and since then it is in the paused state)
if(__isWaitingForNextWave) {
currentWave++;
// also increase the internalWaveIndex
internalWaveIndex = currentWave
// e.g. when waves.length = 12, the maximum number of internalWaveIndex is also 12, because below the index is accessed with i-1
// out-of-bounds check, is not necessary because also checked above
if(currentWave>waves.length && !endlessGameRunning) {
// stop next level logic will take over the role of a restart if endless game.
squabyCreator.stop()
isCurrentlyCreating = false;
return
}
// warning no waves set
if(!getCurrentWave()) {
isCurrentlyCreating = false
return
}
// if the squabyDelay property is set, set it directly
if(getCurrentWave().squabyDelay)
currentSquabyDelay = getCurrentWave().squabyDelay;
// otherwise, decrease it by specified amount
else
currentSquabyDelay -= squabyDelayDecrementPerWave;
// guarantee the calculated value never gets below the minimum threshold
if(currentSquabyDelay<minimumSquabyDelay)
currentSquabyDelay = minimumSquabyDelay;
updatePauseBetweenWaves()
if(getCurrentWave().amount)
amountSquabiesInCurrentWave = getCurrentWave().amount
squabiesBuiltInCurrentWave = 0;
__isWaitingForNextWave = false;
}
// don't put this code into an else-block, because also if the wave was changed
//var entity = EntityFactory.createEntityAndEngage(getSquabyType());
// the default pose (-20, 40) is fine
//entityManager.createEntityFromComponent(getSquabyType());
entityManager.createEntityFromEntityTypeAndVariationType( {entityType: "squaby", variationType: getSquabyType()} );
squabyCreator.currentActiveSquabies++
squabiesBuiltInCurrentWave++;
// this will never get 0, because after waiting for next wave a new squaby immediately gets created!
percentageCreatedInWave = squabiesBuiltInCurrentWave/amountSquabiesInCurrentWave;
if(squabiesBuiltInCurrentWave >= amountSquabiesInCurrentWave) {
// end of this wave is reached, wait until next wave can be started
__isWaitingForNextWave = true;
squabyCreator.state = "waitingForNextWave";
// update time which could differ after the first wave when settings have not been set
updatePauseBetweenWaves()
setIntervalOfCreationTimer(currentPauseBetweenWaves);
} else {
// while not waiting for the next wave, the state is waitingForNextSquaby
squabyCreator.state = "waitingForNextSquaby";
// for the next time the timer should have the normal delay between squabies in a wave
setIntervalOfCreationTimer(currentSquabyDelay);
}
// does the timer start already while onTriggered() is called? the timer resolution is very unprecise!
//creationTimer.start();
isCurrentlyCreating = false;
}
function getCurrentWave() {
if(waves.length < internalWaveIndex-1 || waves.length === 0) {
console.debug("SquabyCreatorLogic: Out of bound when accessing waves!")
return 0
}
// currentWave starts with 1, not with 0!
// this is important to use the internalWaveIndex here, not currentWave
return waves[internalWaveIndex-1];
}
function getSquabyType() {
var types = [] //getCurrentWave().types;
if(!getCurrentWave())
return "squabyYellow"
var type = {}
type.type = "squabyYellow"
type.p = getCurrentWave().yellow
types.push(type)
type = {}
type.type = "squabyOrange"
type.p = getCurrentWave().orange
types.push(type)
type = {}
type.type = "squabyRed"
type.p = getCurrentWave().red
types.push(type)
type = {}
type.type = "squabyGreen"
type.p = getCurrentWave().green
types.push(type)
type = {}
type.type = "squabyBlue"
type.p = getCurrentWave().blue
types.push(type)
type = {}
type.type = "squabyGrey"
type.p = getCurrentWave().grey
types.push(type)
var nextCreationType = types[0].type;
// Math.random returns a number 0 <= x < 1
var highestProbabilityForChosenType = types[0].p*Math.random();
for(var i=1;i<types.length;i++) {
var possiblyHighestProbability = types[i].p*Math.random();
if(possiblyHighestProbability > highestProbabilityForChosenType) {
highestProbabilityForChosenType = possiblyHighestProbability;
nextCreationType = types[i].type;
}
}
