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

  1. Thanks for sharing with us your wisdom.This will absolutely going to help me in my projects .

    Cloud Computing Classes in Chennai

    Cloud Computing Institutes in Chennai

    ReplyDelete
  2. This is an awesome post. Really very informative and creative contents. This concept is a good way to enhance knowledge. I like it and help me to development very well. Thank you for this brief explanation and very nice information. Well, got good knowledge.
    WordPress development company in Chennai

    ReplyDelete
  3. in this content i got a lot information about that javascript thanks for a helpful information and its assist for me to study..once again thanks for useful information
    Javascript Classes in Bangalore
    Advanced Javascript Training in Bangalore
    Best Institute for Javascript in Bangalore
    Javascript Course in Bangalore
    Javascript Training Courses in Bangalore

    ReplyDelete
  4. in this content i got a lot information about that javascript thanks for a helpful information and its assist for me to study..once again thanks for useful information
    Javascript Classes in Bangalore
    Advanced Javascript Training in Bangalore
    Best Institute for Javascript in Bangalore
    Javascript Course in Bangalore
    Javascript Training Courses in Bangalore

    ReplyDelete
  5. This comment has been removed by the author.

    ReplyDelete

Post a Comment

Popular posts from this blog

This Is Exactly How You Should Train Yourself To Be Smarter [Infographic]

Design inspired by the Cognitive Bias Codex
View the high resolution version of the infographic by clicking here. Out of all the interventions we can do to make smarter decisions in our life and career, mastering the most useful and universal mental models is arguably the most important. Over the last few months, I’ve written about how many of the most successful self-made billionaire entrepreneurs like Ray Dalio, Elon Musk, and Charlie Munger swear by mental models… “Developing the habit of mastering the multiple models which underlie reality is the best thing you can do. “ — Charlie Munger “Those who understand more of them and understand them well [principles / mental models] know how to interact with the world more effectively than those who know fewer of them or know them less well. “ — Ray Dalio “It is important to view knowledge as sort of a semantic tree — make sure you understand the fundamental principles, i.e. the trunk and big branches, before you get into the leav…

Warren Buffett: “Really Successful People Say No To Almost Everything”

When I tell people that Warren Buffett follows the 5-Hour Rule and spends 80% of his time reading and thinking, they have an immediate and predictable reaction: “Well, he can do that because he’s Warren Buffett, one of the richest people in the world. I could never do that.” While this response may help people feel better about themselves, it certainly won’t make them smarter. Because the reality is: Buffett has spent most of his time reading and thinking since he was in grade school. Having more money or managing a large company doesn’t magically give you free time. Having free time is never the default. People don’t just fall into huge blocks of free time unless they retire. Rather, free time is the result of strategy. It’s the result of looking at time differently. Curious about Buffett’s unique strategies, I’ve read several books about him, read most of his annual letters to stockholders, and watched nearly all of his interviews. And make no mistake about it… behind Buffett’s jovia…

If you want to be massively successful, do NOT set ambitious goals, according to studies

The conventional model to having great success in your career is setting and ardently pursuing big, hairy, audacious goals (BHAGs), even if you have no idea how you’re going to achieve them when you start. Want to build a billion dollar company? Set the goal and work backward from long-term goals to medium-term goals to short-term goals to today’s to-do list. Then take action, measure your progress along the way, and constantly course correct so you’re always on the most direct path (that you’re aware of) toward your ultimate goal. Want to cure cancer? Set the goal and work backward. Measure your progress. Want to find the love of your life or be happy? Set the goal. Rinse and repeat. This goals model is so obvious in our culture, it goes without saying. It’s central to our collective success recipe. Goals give motivation, meaning, and focus when we feel lazy or distracted — at least so we’re told. However, recent research from the field of artificial intelligence is putting a nail in t…