• Overview
• Features
• Usage
• Documentation
• Download
• Contact

• Home
• >Documentation
• >Core
• >Game

Core

Game

The global GAME object is essentially the guts of JackyJS. It is responsible for handling the game loop, checking for events, and rendering output. It's also host to a bunch of constants, variables, events, and useful functions to make developing web games much easier.

TIP: Pay special attention to the Inits table, as that's where all your awesome code goes. :-)

Global Constants

The following are global constants accessed through GAME.cons, which cannot (should not) be changed:

	cons: {
		BLEND: {
			NORMAL: PIXI.blendModes.NORMAL,
			ADD: PIXI.blendModes.ADD,
			MULTIPLY: PIXI.blendModes.MULTIPLY,
			SCREEN: PIXI.blendModes.SCREEN,
			OVERLAY: PIXI.blendModes.OVERLAY,
			DARKEN: PIXI.blendModes.DARKEN,
			LIGHTEN: PIXI.blendModes.LIGHTEN,
			COLOR_DODGE: PIXI.blendModes.COLOR_DODGE,
			COLOR_BURN: PIXI.blendModes.COLOR_BURN,
			HARD_LIGHT: PIXI.blendModes.HARD_LIGHT,
			SOFT_LIGHT: PIXI.blendModes.SOFT_LIGHT,
			DIFFERENCE: PIXI.blendModes.DIFFERENCE,
			EXCLUSION: PIXI.blendModes.EXCLUSION,
			HUE: PIXI.blendModes.HUE,
			SATURATION: PIXI.blendModes.SATURATION,
			COLOR: PIXI.blendModes.COLOR,
			LUMINOSITY: PIXI.blendModes.LUMINOSITY
		},

		DIRECTION: {
			RIGHT: 0,
			UP: 90,
			LEFT: 180,
			DOWN: 270
		}
	}

Global Variables

The following are global variables accessed through GAME.vars, which can be changed at any time:

	vars: {
		SCREEN_X: 0,
		SCREEN_Y: 0,
		GRAVITY: 0.5,
		GRAVITY_DIRECTION: 270,
		SPEED_MAX: 12,
		FRICTION: 0.15,
		PARTICLE_LIMIT: 100
	}

Global Custom

The following is where your custom global constants, variables, and functions should be placed. It is accessed through GAME.custom and initialized in the GAME.initCustom() function. Placing constants, variables, and functions here allows you to access them from anywhere in your game code, without worrying about polluting the global window object scope.

	custom {
		cons: {},
		vars: {},
		funcs: {}
	}

For example:

	GAME.initCustom(function(){
		GAME.custom.cons.ENEMIES_MAX = 10;
		GAME.custom.cons.BULLETS_MAX = 100;
		
		GAME.custom.vars.ENEMY_COUNT = 0;
		GAME.custom.vars.BULLET_COUNT = 0;
		
		GAME.custom.funcs.checkEnemies = function(){
			if (GAME.custom.vars.BULLET_COUNT > GAME.custom.cons.BULLETS_MAX){
				GAME.find({instanceOf:'bullet'}).each(function(obj){
					obj.destroy();
				});
			}
		};
	});

Global Instances

There is a special global variable called GAME.Instances. It stores instantiated entities for quick access; that is, instead of having to use GAME.find all the time. Basically, whatever unique name you provided for an entity during creation, is what gets registered in this global variable. It is for this reason, even though not mandatory, to always provide a name for your entities.

Global instances are available the moment the first room has started. They can be used at any time and in any entity event thereafter. What this means is that any entity can access any other entity's properties, methods, and events! A useful feature for sure. ;-)

NOTE: unless a particular entity is set as persistent, it will no longer be available in GAME.Instances after a Room transition; ie, it doesn't exist anymore.

The naming convention is as follows:

1. uses name if provided, else, asset name.
2. removes underscores and hyphens.
3. captializes all characters.

Consider the following example:

	GAME.initRooms(function(){
		var level1 = GAME.Room.create({name:'level1'});
		
		level1.onCreate(function(obj){
			obj.addSprite('carrot', {x:0, y:0});
			obj.addSprite('carrot', {name:'carrot-2', x:16, y:16});
			obj.addSprite('carrot', {x:32, y:32});
		});
		
		level1.onStart(function(obj){
			// spins all carrots
			GAME.find({instanceOf:'carrot'}).each(function(obj){
				obj.spin();
			});
			
			// blinks only the third carrot
			// global instance name overridden since unique name not provided
			GAME.Instances.CARROT.blink();
			
			// destroys only the second carrot
			GAME.Instances.CARROT2.destroy();
		});
	});

TIP: in cases where you may want multiple instances without unique names, you'll have to use the GAME.find function to precisely target and iterate over these kinds of objects.

Properties (read-only)

Methods

	GAME.find({name:'ball', hasGravity:true, class:'green,fast'});

	var ball = GAME.find({name:'ball'}).items[0];

	GAME.find({class:'ball'}).each(function(obj){
		obj.fadeOut();
	});

	GAME.find({class:'ball'}).eq(3, function(obj){
		// fades out third element
		obj.fadeOut();
	});

	GAME.find({class:'ball'}).last(function(obj){
		obj.fadeOut();
	});

	GAME.log('ERROR', 'missing parameter', obj.name);

	<body>
		<div id="jjs-container">
			<script>
				GAME.execute({
					name: 'MyNewGame',
					width: 320,
					height: 240, 
					scale: true,
					bgColor: '#006699',
					orientationLock: 'landscape'
				});
			</script>
		</div>
	</body>

Events

When a JackyJS event occurs a corresponding global function is executed, that is, if custom code exists for it. Most of the following event functions simply require an anonymous function as its only parameter. Further, these global event functions are typically assigned in the GAME.initGlobal() function.

Inits

This is where all your custom code goes. Basically, you are passing an anonymous function as the only parameter to all of these functions. All of this code should reside in your own Javascript file, which is to be included after the JackyJS min file.

• Overview
• Features
• Usage
• Documentation
• Download
• Contact

• Updates
• |
• Terms of Service
• Privacy Policy