Skip to main content

Building a Game using JavaScript : Part-1

Introduction

I really wanted to write a tutorial about a game technology I like to use, so here it is. In this story, we will start making a little shoot’em up game with PixiJS, a really simple and cool Javascript library.
What we are going to do exactly is to make a spaceship able to move and shoot, enemy waves coming through and a beautiful animated background with moving clouds. The first part (this story) will focus on the background.
Ready guys? Let’s nail it!

Getting started

Let’s start by setting up our project: I uploaded a code structure already set so we are all working with the same base. However if you want to make it yourself, I put a picture of my folder just below:
Project folder structure
We will need a local server to run the game: I invite you to download WAMP if you’re working with Windows, or MAMP for macOS, they are free and easy to use. Let’s put your game folder in the server one (htdocs for MAMP / www for WAMP) and type the localhost link in your favorite browser (for me: http://localhost:8888/Spaceship/bin/)
In index.html, we are importing the javascript files in the header:

<script src="../src/lib/pixi.min.js"></script>
<script src="“../src/main.js”"></script>

… and we need to do the same for every file we make. Then comes the initialization of Pixi (which is based on the WebGL render engine):

var renderer = PIXI.autoDetectRenderer(window.innerWidth, window.innerHeight);
For this tutorial, we tell the game to cover the whole browser window, so if you try it now you will get an all-black background.
The main.js file is the place where all the game starts. It’s like a manager, with the first-executed function of the game, and the loop where we can tell the game what it needs to do on each frame. What we want is a blue background for the sky when the game starts, so let’s update the init function:

function init()
{
    renderer.backgroundColor = 0x22A7F0;
    renderer.render(stage);
    loop();
}


Pixi is using the hex color format, so you need to write your color code preceded by 0x. Let’s save and see the result in your browser!

Clouds everywhere

This background is very boring, let’s add some floating clouds.

First, let’s add a new CloudManager class file in the src folder (which is going to create and move the clouds):

class CloudManager
{
    constructor()
    {
    }
    update()
    {
    }
}

Don’t forget to add it in the index.html file as we did for main.js:

<script src="../src/lib/pixi.min.js"></script>
<script src="../src/CloudManager.js"></script>
<script src="../src/main.js"></script>

The constructor is the entry point of this class where we can add the spawn function for our clouds. What we want is basically a method able to create a cloud every X seconds, and it’s fine because there is a javascript thing for this:

window.setInterval(function()
{
}
, 1000);

This piece of code, placed in the constructor, will call what’s inside the moustache brackets every 1000 milliseconds (= 1 second).
Let’s add cloud sprites in the assets folder, and because it’s better we have 2 different images: (the clouds are white with transparent background so they were invisible on this page, but here are the links on GitHub ;)
https://github.com/Karzam/Spaceship_Tutorial_Part_1/blob/master/bin/assets/cloud_1.png
https://github.com/Karzam/Spaceship_Tutorial_Part_1/blob/master/bin/assets/cloud_2.png
We need to load the sprites before the game starts, so add them in the Pixi.loader.add function:

PIXI.loader.add([
    "assets/cloud_1.png",
    "assets/cloud_2.png"
]).load(init);

Ok, now we can display the clouds in the setInterval method of the CloudManager:

window.setInterval(function()
{
    const sprite = (Math.random() > 0.5 ? "cloud_1" : "cloud_2");
    this.cloud = new PIXI.Sprite(PIXI.loader.resources["assets/" + sprite + ".png"].texture);
    this.cloud.anchor.set(0.5, 0.5);
    this.cloud.position.set(renderer.width * 1.2, renderer.height * Math.random());
    stage.addChild(this.cloud);
}
, 1000);

To resume this code:
  • First, we are computing a random number between 0 and 1, and either it’s less than 0.5 so we store the first sprite in a constant or otherwise it’s the second one.
  • Then, we create a new sprite object with the image we got in the previous line.
  • The origin point of this sprite is going to be its top left corner, so we set its anchor point in the middle.
  • We have to display the cloud beyond the right border of the screen, so it can move to the left through the screen: renderer.width * 1.2 is the left border position + the width of the screen + 20% of its width. We can be sure that we won’t see it spawning. For the y position, renderer.height * Math.random() is a number between 0 and the window height. So the cloud vertical position will be located between the top and the bottom of the screen.
  • Finally, we addChild this cloud to the stage.
If you run this code, nothing should appear, and it’s on purpose because they have to pop out of sight. So now we have to make them move.
The update function is the place to do it. But we need to store the clouds in an array so we can iterate through and set their positions. Let’s initialize a new array in CloudManager constructor:

this.cloudsList = [];

… and push the clouds inside after the stage.addChild function:

this.cloudsList.push(this.cloud);

Now we can iterate the array in update and set the position of each cloud:

this.cloudsList.forEach(function(element) {
    element.position.x -= 4;
});

Now it’s working!
 
 
 
 
Moving clouds!

Oh wait, something should actually annoy us: where are all those clouds going?

Yeah, if we don’t remove them after they left the screen, they will continue to exist and it may cause some performance troubles. Let’s add a statement in forEach that delete them when their horizontal position is a little bit inferior to the left border of the screen (so we can’t see them popping out):
We’re done with the clouds!
What about making a random variation on the clouds size? Add this to the cloud creation block:

let minScale = 0.2;
let maxScale = 1.2;
let scale = Math.random() * (maxScale - minScale) + minScale;
this.cloud.scale.set(scale, scale);

Random clouds size
If you something’s missing / not working in your code, you can check the result here.


Thank you for reading!


If you want to build a website just like Trivago and Tripadvisor then try our Hotel price comparison API, which compares more than 200 websites to generate JSON results .

Comments

Post a Comment

Popular posts from this blog

Cheat Sheets for AI, Neural Networks, Machine Learning, Deep Learning & Big Data

Over the past few months, I have been collecting AI cheat sheets. From time to time I share them with friends and colleagues and recently I have been getting asked a lot, so I decided to organize and share the entire collection. To make things more interesting and give context, I added descriptions and/or excerpts for each major topic. This is the most complete list and the Big-O is at the very end, enjoy… If you like this list, you can let me know here Neural Networks

Neural Networks Cheat Sheet Neural Networks Graphs

Neural Networks Graphs Cheat Sheet



Neural Network Cheat Sheet Ultimate Guide to Leveraging NLP & Machine Learning for your Chatbot
Code Snippets and Github Includedchatbotslife.com
Machine Learning Overview

Machine Learning Cheat Sheet
Machine Learning: Scikit-learn algorithm This machine learning cheat sheet will help you find the right estimator for the job which is the most difficult part. The flowchart will help you check the documentation and rough guide of …

A Tour of The Top 10 Algorithms for Machine Learning Newbies

In machine learning, there’s something called the “No Free Lunch” theorem. In a nutshell, it states that no one algorithm works best for every problem, and it’s especially relevant for supervised learning (i.e. predictive modeling). For example, you can’t say that neural networks are always better than decision trees or vice-versa. There are many factors at play, such as the size and structure of your dataset. As a result, you should try many different algorithms for your problem, while using a hold-out “test set” of data to evaluate performance and select the winner. Of course, the algorithms you try must be appropriate for your problem, which is where picking the right machine learning task comes in. As an analogy, if you need to clean your house, you might use a vacuum, a broom, or a mop, but you wouldn’t bust out a shovel and start digging.
 "Try our Hotel price comparison API to compare more than 200 hotel websites." And if you love this post don't forge…

The Difference Between Artificial Intelligence, Machine Learning, and Deep Learning

Simple explanations of Artificial Intelligence, Machine Learning, and Deep Learning and how they’re all different. Plus, how AI and IoT are inextricably connected. We’re all familiar with the term “Artificial Intelligence.” After all, it’s been a popular focus in movies such as The Terminator, The Matrix, and Ex Machina (a personal favorite of mine). But you may have recently been hearing about other terms like “Machine Learning” and “Deep Learning,” sometimes used interchangeably with artificial intelligence. As a result, the difference between artificial intelligence, machine learning, and deep learning can be very unclear. I’ll begin by giving a quick explanation of what Artificial Intelligence (AI), Machine Learning (ML), and Deep Learning (DL) actually mean and how they’re different. Then, I’ll share how AI and the Internet of Things are inextricably intertwined, with several technological advances all converging at once to set the foundation for an AI and IoT exp…