In this article, I will be going over how to create a second enemy with different movements.

To begin, I have created a fresh antagonist named “Enemy2” and incorporated all the same components as my initial enemy, excluding the script. The reason behind this is that we intend to develop a new script specifically for “Enemy2,” enabling it to move sideways instead of vertically, unlike the original enemy.

Now, let’s focus on defining the behavior of “Enemy2.” I replicated most of the code from our enemy script, but with a modification in the “calculate movement” method to align with the desired sideways movement.

Next, we need to make adjustments to our Spawn Manager Script to ensure that it can spawn our newly created enemies as well.

As shown earlier, we introduced a new variable called “randomEnemy” in our code. We utilize this variable within a switch statement in the Spawn Manager Script to enable random spawning of different enemy types. This implementation using a switch statement also facilitates the seamless addition of any future enemy types.

Below the switch statement, we instantiate the enemies by referencing the “randomEnemy” variable. You’ll notice that we have assigned the randomEnemy to an index that allows us to conveniently assign our enemies within the editor.

Once this step is complete, we can return to the editor and assign our respective enemy types to the Spawn Manager.

Now, if we proceed to run the game, you will witness the newly created enemy moving horizontally as intended.

And there you have it! We have successfully crafted a new enemy that exhibits sideways movement. In the upcoming lessons, we will delve into creating even more advanced adversaries. Stay tuned for exciting developments in the following sessions!

“Elevate Your Game with Dynamic Camera Shakes: Experience the Thrill!”

Get ready for an exciting upgrade to your game! In this article, we’ll show you how to make the camera shake with every powerful hit your player takes. Brace yourself for a pulse-pounding experience that will leave you on the edge of your seat. Let’s dive in and unleash the thrill of dynamic camera shakes in your game!

To begin, I’ve made the decision to incorporate camera and background image movement in the shake effect. To achieve this, I’ve created an empty GameObject and set both the camera and the background image as its children. Additionally, I’ve developed a new script called ‘CameraShake’ to facilitate this functionality.

After completing the previous steps, please open the script. In this section, our main task is to create a new public Coroutine responsible for the shaking effect. I’ve designed it to be modular, allowing for the addition of shaking from other sources apart from just the player taking damage.

Inside the Coroutine, we will modify the transform.position of the entire gameObject. The position will be set to random values ranging from -1 to 1, multiplied by the specified magnitude, for the given duration. Once the shaking is finished, we will reset the position back to its original value.

Now, let’s make a few additions to the ‘Player’ script. We will define two variables: one for the duration and another for the magnitude of the camera shake effect. Additionally, we need to create a variable that stores the reference to the ‘CameraShake’ GameObject. It’s important to perform a null check to ensure it is not empty.

After that, the only remaining task is to start the ‘Shake’ coroutine whenever the player sustains damage.

And with that, we’re done! Now, whenever the player takes damage, they will experience a mildly unpleasant shake, immediately notifying them of the damage inflicted.

This effect can motivate the player to dodge and avoid further damage, as the intensity of the camera shake will be reduced by doing so.

That wraps it up for today, folks! In our next article, get ready for a game-transforming journey as we explore exciting updates to take your game to the next level. We’ll dive into adding enemy waves, crafting an epic boss level, and much more. Stay tuned for an adventure-packed read that will supercharge your gaming experience!

Currently, in our 2D Space Shooter game, our player can speed up using the thruster, but it lacks limitations which makes the game less challenging.

To address this, in today's article, we will introduce a fuel bar that depletes each time the thruster is used. This will require the player to wait for the fuel to refill before being able to use the thruster again, adding an element of strategy and challenge to the game.

To begin, I searched for a suitable sprite to serve as the fuel bar indicator. After careful consideration, I selected the sprite displayed below, as it effectively depicts both the full and low fuel states.

Now that we have the desired image for the fuel bar, let’s proceed to Unity and add it to an object within our canvas, where we have all our other UI elements. Once this is done, we will be able to see the fuel bar displayed in our game scene.

Now that we have a visually appealing fuel bar, let’s dive into the code and make it functional. To start, within our player script, we need to create a variable for our thruster and set its initial value to 15, which represents the total charge we want to give it. I suggest using a float variable type to allow for gradual fuel depletion as we use the thruster.

Now, if we navigate to our UI script, we need to create two variables that will hold the sprites we created for the fuel bar in the editor. These variables will allow us to dynamically update the appearance of the fuel bar based on the current fuel level.

Having established these variables, we can now proceed to create the method ‘UpdateThruster()’ in our UI script. This method will be responsible for updating the fuel bar in the UI based on the current fuel level. We will call this method in our player script at a later stage.

Let’s return to our player script and create the method that will enable us to use the thruster only if we have remaining fuel. In technical terms, the thruster power should be above 0. We can accomplish this by using an if statement that subtracts 1.0f from our thruster power in real time (using Time.deltaTime). Additionally, we should deactivate the thruster when our _thrusterPower is less than or equal to 0.

Furthermore, you may observe that we have included a line of code to update the UI manager with the appropriate image each time we use the fuel bar. With the ThrusterActive() method now in place, we can integrate it into our CalculateMovement() method within the ‘if’ statement where we previously activated the thruster by holding down the Shift button. This will ensure that the thruster can only be utilized if there is available fuel.

Now, if we return to Unity and run the game, we will notice that our thruster power bar gradually decreases each time we utilize the thruster. This provides us with a visual representation of the fuel consumption.

Next, we need to implement the method responsible for refilling our thruster fuel bar when the thrusters are not active. Let’s name this method AddFuel(). Inside this method, we will incorporate logic to check if the thruster power is less than the maximum value (15 in this case) and if the thruster is not active. If these conditions are met, the fuel bar will gradually recharge at a rate of 0.1f.

In the code below, you will also notice the inclusion of a line that updates our UI manager to reflect the current fuel level. By implementing this method, we ensure that our thruster fuel bar refills itself when the thrusters are not in use, adding an additional layer of gameplay mechanics and strategy.

Now that we have created the AddFuel() method, we can expand the if statement within the CalculateMovement() method, which controls our thruster, to include a call to the AddFuel() method when the thruster is not active. This will allow the fuel bar to replenish itself when the thrusters are not in use.

With this addition, the fuel bar will gradually refill when the thrusters are not actively being used, providing the player with the opportunity to conserve fuel and utilize it strategically.

Having incorporated the necessary logic to ensure the proper functioning of our thruster bar and implemented the code to update our user interface, the next step is to connect all the sprites associated with the thruster bar to their respective handles.

With the successful placement of the required assets in their designated positions, we are now ready to execute our game and observe the full functionality of our thruster bar.

In this tutorial, we accomplished the creation of a functional fuel bar that depletes when the thruster is activated and replenishes when it’s not in use. To achieve this, we established an interaction between the player and the UI manager, following a similar approach to what we previously did when implementing the lives system, ammo system, and player score.

In the upcoming article, we will delve into the process of incorporating a camera shake feature into our game.

Currently, our player possesses a single normal laser shot, and when we collect a power-up, a triple shot becomes available. However, considering the multitude of enemies we encounter, it seems necessary to introduce an additional means of destroying them all. In this article, we will explore the process of creating a secondary firing method that will be unlocked through power-ups.

To begin, we must import certain assets that will serve as visual representations for our fireball projectile and the power-up collectible associated with it.

After importing the assets, we can proceed to attach the required components, scripts, and animations to the newly added sprites. This will allow them to exhibit behavior similar to other power-ups in the game.

With the initial UI setup complete, we can now move on to implementing the desired behavior in our code. To begin, let’s add a reference to our fireball prefab and establish a mechanism to activate it when necessary.

We can now proceed with creating the function responsible for activating our Fireball when the power-up is collected. Additionally, we need to implement a power-down method that will deactivate the Fireball after a specified duration has elapsed.

Now, within the if statement inside our FireLaser method, we can include the ‘_isFireActive’ variable as one of the conditions to check when firing our laser. This can be done similarly to how we have handled the Triple Shot laser. If the triple shot is active, it will fire the triple shot. If the fireball is active, it will fire the fireball. Otherwise, if neither power-up is active, it will fire the normal laser.

After implementing the above changes, we can proceed to the enemy script. Here, we will enable the enemies to detect when they are hit by our fireball, resulting in their destruction.

The final step is to create a script specifically for our Fireball. In this script, we will store the logic to control the activation and duration of the Fireball, specifying how long it should remain active.

Having saved our progress, we can now run the game in Unity and witness the successful collection of our new fireball power-up. We can then proceed to destroy enemies using our fireball weapon, which functions more like a flamethrower.

With the new firing method implemented, our next step will be to introduce limitations to some of the player’s existing powers, starting with the thrusters. We will explore how to restrict their usage frequency in the upcoming article.

Just like we added the ammo collectible in the previous lesson, we will now follow a similar process but with a different sprite representing life. To begin, we need to include the desired sprite in our assets. Next, we will drag it into the scene and attach the required components so that it can function as a collectible.

After incorporating all the necessary components, including the script, we can proceed to develop the logic. In the player script, we will begin by generating a new private GameObject. This will allow us to conveniently position our prefab in that location in the future.

Creating a separate script for the life collectible is unnecessary since it will exhibit the same behavior as other power-ups. However, we do need to implement a function in the player script that handles adding a life when the collectible is obtained.

Having established the function for adding life, we can now integrate it into our switch statement within the power-up script. This will enable us to conveniently reference and utilize it within the editor at a later stage.

Within the “SpawnPowerupRoutine()” function of the Spawn Manager script, we should adjust the scope of the “randomPowerUp” integer to a value of 5. By implementing this change and exercising caution while modifying the code, we can minimize the need for future alterations.

Now that we have implemented the necessary code additions and modifications, we can return to Unity and run our game. In the Inspector, you should observe that when you lose a life and subsequently collect one of the newly generated life power-ups, your life count should increase. This can be visualized in the player’s Inspector tab. However, we still need to make the appropriate changes in our UI Manager so that the updated life count is visible within the game scene.

Having successfully implemented the functionality of our life power-up, we now need to ensure that the corresponding changes are reflected in the UI. To accomplish this, let’s navigate back to our code and specifically the player script. We will begin by reintroducing the image that represents our lives each time a life power-up is collected. To achieve this, we can simply call the “UpdateLives” method that we had previously created in our UI Manager script.

Continuing with the implementation of engine damage, we will proceed to the player script. In this step, we will add the same conditional statement that was used to activate the engine damage visual. However, instead of setting it to true directly, we will nest it within our newly created “AddLife” method and set the damaged engine animation to false. This will ensure that when a life is gained through the life power-up, the damaged engine animation is deactivated.

Once we save the changes and return to Unity to run the game, we will observe that when we collect the life power-up, not only will our lives sprites replenish, but our engines will also be repaired simultaneously.

Congratulations! We have effectively implemented a mechanism to replenish life by collecting life power-ups that function as power-ups.

In the upcoming lesson, we will further enhance our game by introducing an additional firing method that will be accessible exclusively through another power-up.

To begin with, I searched online and discovered an image of a bullet on OpenGameArt.org. I’ve chosen this image as the sprite for our ammo power-up, which we’ll be collecting.

After downloading the image and saving it as a PNG file, we can import it into our game assets and place it in Unity. In the Unity editor, we need to select the image in the inspector and assign it as a Sprite while labeling it as a 2D texture shape.

To enable future assignments, we need to create a prefab for our new ammo sprite. Additionally, we must add essential components such as Rigidbody2D, Collider, and the Powerup Script to allow player interaction. As our ammo power-up will function similarly to our existing power-ups, we can conveniently attach our power-up script to it.

We are now prepared to implement the necessary code logic for interacting with the power-up and refilling our ammo upon collection. First, let’s introduce a variable called “maxAmmo” and set its value to 20, representing the maximum number of bullets we can have at any given time.

Next, let’s create a method that we can call later to refill our ammo and update the ammo count in the UI manager.

With the creation of the ReloadAmmo method, we can now proceed to utilize it in our power-up script to give our ammo sprite the behavior of a power-up. We will add to the existing switch statement, just as we have done with other power-ups before, enabling our player to collect the ammo power-up.

To ensure that our ammo power-up receives the same spawning behavior as other power-ups, we need to make a crucial modification in our Spawn Manager script. By adjusting the spawning range from 3 to 4, we will include our new power-up within the scope of the spawning process.

Now, let’s return to the Unity editor and assign the correct power ID (which is 3 in this case) to our ammo power-up. Afterward, we can navigate to our Spawn Manager and add our ammo prefab as a new element to the appropriate list.

If we proceed to run our game, you will now observe that the ammo power-up spawns just like the other power-ups. Once collected, your Ammo Count will reset to 20, ensuring you have a fresh supply of ammunition.

And there you have it!

We have successfully created a power-up that refills our ammo when collected. In the next lesson, we will explore a similar concept but instead of collecting ammo, we will focus on collecting lives. This will provide us with an opportunity to prolong our survival in the game. Stay tuned for the next lesson!

I aim to initialize the player’s ammunition count to 25 shots. Whenever the player fires, the ammunition count decreases by 1. Once the player’s ammunition is depleted, they should no longer be able to fire their weapon, and the ammunition count should remain at 0 until the player can obtain some ammunition through a randomly generated power-up. As the ammunition count decreases, there should be a visual indication that alerts the player that their ammunition level is getting critical.

Let’s begin by including a private integer variable called _ammoCount in the Player script and setting its initial value to 25.

Next, within the PlayerFiresLaser() method, add the following code snippet at the beginning of the method. This code will verify the value of _ammoCount. The laser weapons can only be fired if _ammoCount is greater than 0 and the "cooldown" condition is true. If both conditions are satisfied, reduce the value of _ammoCount by 1 and invoke the UpdatePlayerAmmoStores() method.

The UpdatePlayerAmmoStores() method is responsible for setting the bounds for the ammunition stores. If the value of _ammoCount becomes negative, it is reset to 0. If it exceeds 25 (which is the maximum quantity chosen for this version of the game), then _ammoCount is capped at 25. After performing these checks, the new value of _ammoCount is passed to the _uiManager through the UpdateAmmoCount(_ammoCount) method.

In the UIManager script, add a new private Text Mesh Pro text field to represent the Player’s ammo count.

In the UIManager script, include a method called UpdateAmmoCount(int ammoCount). This method retrieves the integer value that represents the remaining ammunition held by the player. The ammoCount parameter in the UpdateAmmoCount(int ammoCount) method corresponds to the value represented by _ammoCount in the PlayerFiresLaser() method of the Player script.

By means of script communication, the ammoCount is transferred from the Player script to the UIManager script when the UpdateAmmoCount(int ammoCount) method is invoked.

In the Canvas, duplicate the Score_text, rename it to Ammo_Count_text, change the “Score: 0” text to “Ammo: 25”, reposition it in the game scene, and set its color to bright green.

If you run your game you should now be able to see the score count, and your ammo!

With the initial release of our 2D Space shooter game complete, it’s time to enhance it by incorporating additional features. Our first addition will be thrusters, allowing players to accelerate by pressing a designated button and return to normal speed upon release. Let’s strategize the implementation of this feature:

Tasks:

1. Implement a mechanism to increase the player’s speed when the ‘Left Shift’ key is pressed down.
2. Create a function that resets the player’s speed back to normal when the ‘Left Shift’ key is released.

Let’s begin by introducing a new private variable, specifically for our thrusters, which can be activated in the future.

Next, let’s create a method called `GetSpeed()`, which will contain the logic to activate the velocity boost not only from our thrusters but also from collecting the speed power-up.

Now that we have the new method `GetSpeed()` that handles all of our speed boosts, we can add it to our code and replace any previous variables we had for speed.

Now, let’s proceed to create an if statement that contains the logic to activate our newly implemented speed thruster when the left “Shift” key is pressed and turns it off when the “Shift” key is released.

With this code now in place, if we run our game in Unity, we will be able to observe the effect of our thrusters when we press the shift key. Although we currently lack a visual effect for the thrusters, you can visualize the change in the inspector of our player. When we press the shift key, the “thruster active” option will be checked, resulting in a noticeable speed boost in our player movement. Conversely, when we release the shift key, the option will be unchecked.

There you have it! We have successfully implemented a thruster for our player. In the near future, we can enhance the visual appeal of our game by animating the thruster, making it look even more impressive and adding to the overall coolness factor.

Our Space Shooter Code So Far…

Player Script:

Similar to building our game for Mac and PC, to build for WebGL, we need to access the Build Settings. Instead of selecting the default settings, we will choose the “WebGL” option from the available build options.

Now, you need to switch platforms in Unity to allow for compilation and preparation of the build using WebGL. The option to switch platforms can be found at the bottom of the Build Settings menu.

Once you select the switch option, Unity will initiate the recompilation process.

After the compilation is complete, you will now be able to see the WebGL options. However, before proceeding, it is important to address the warning message regarding necessary changes to the player settings. To resolve this, open the player settings and navigate to the “Other Settings” section under the “Player” options.

In this section, modify the color space setting from “Linear” to “Gamma”.

After making the color space change, Unity will initiate another compilation process, enabling us to proceed with building for WebGL. When you click the build button, you will be prompted to save the build somewhere on your computer. Once the build process is complete, a folder containing the project’s components will automatically open up.

These files are the ones you would upload to a hosting platform or webpage to make your work available online.

If you attempt to open your HTML file directly, you will encounter a specific message. In a future article, I will guide you through the process of officially launching your game once you have a server in place.

To begin, navigate to the “Build Settings” option located in the file menu. Upon opening the Build Settings, you will notice that the default build setting is already configured for PC, Mac & Linux. The target platform should automatically reflect the computer you are currently using, and the architecture should also have a default setting assigned. If the default setting is missing, you can manually select the desired architecture option.

By accessing the Player Settings tab at the bottom, you can customize various aspects of your game’s data.

After entering the desired information for your game, return to the main Build Settings menu. At the bottom, locate and click on the Build button to initiate the build process.

It’s important to note that if you have imported assets, you may encounter errors when attempting to build. In your case, if you have assets installed from Filebase, you will need to disable them temporarily to proceed with the build. If you encounter an error, ensure that you exclude the editor and standalone options temporarily, and then try running your game again.

Once you have successfully built your game, a folder containing your game files will appear. Locate the folder where you saved your game, and inside it, you will find the application for the game you have just created. Open the application and start playing!

Now that we have covered the build settings, let’s proceed to the next step of launching our game online by deploying it through WebGL. This will be the focus of our upcoming article.