DEV Community: Emilien Leroy

From Escape the Wave to Pong Why I'm Taking on a New Challenge

Emilien Leroy — Thu, 23 Mar 2023 14:00:00 +0000

This week marks the start of a new project for me. While my current project, Escape The Wave, is on hold as I'm awaiting visual assets from a friend, I've decided to take on a new challenge. One of the main reasons for starting a new project is that I want to train myself in implementing online multiplayer functionality, something which is currently too complex for me to implement in Escape The Wave.

For my new game, I've decided to create a simple multiplayer Pong game. The concept of Pong is straightforward, so there isn't much to say about the game itself. This week, I focused on developing the basics of the game, including two-player functionality and a score system.

Moving forward, I plan to work on the game's style and design to create a simple yet beautiful game. This will be my focus for next week.

Overall, I'm excited about this new project and look forward to continuing to develop it. While Escape The Wave is still a priority, I believe that taking on a new challenge will help me grow as a developer and better prepare me for future projects. You can find the repository of this project here.

Optimizing Mob Pathfinding. Improving Game Performance for Smooth Gameplay

Emilien Leroy — Thu, 16 Mar 2023 14:00:00 +0000

During this week of development, I focused on improving the performance of my game Escape The Wave when a lot of mobs are searching for the player. This was a challenging task, but I found some effective solutions.

First, I updated the mob pathfinding by using a NavigationAgent instead of the get_simple_path function of a Navigation node. This new approach allowed my game to have many more mobs on a small map. Previously, in the demo map, I was limited to around 70 mobs, or else the game would become laggy. But with this new technique, I can have more than 500 mobs without any lag on a small map.

However, this technique alone did not reduce lagging on a large map. To reduce lag on maps larger than a certain size, I had to make some compromises. Not all mobs can constantly search for the player on the map, as this significantly affects the game's performance. To address this, I used a VisibilityNotifier to detect if a mob is displayed on the screen or not. If a mob is displayed on the screen, it will try to reach the player's position. Once the mob is out of the screen, it will keep its current direction without searching for the player. When a mob spawns, it initially does not have any direction to go, which can cause mobs to stack on a single point, creating performance issues when the player is nearby. To prevent this issue, I simply define a random direction for the mob to go in until it crosses the player's path.

Using these techniques, my game no longer lags when many mobs are searching for the player. Only the displayed enemies try to attack the player, while the others go in a random direction. However, in the game, it appears as if all the mobs are trying to find and attack the player. Sometimes the game may experience slight FPS drops, but they are minimal and do not disrupt gameplay.

In conclusion, improving game performance can be a challenging task, especially when dealing with multiple mobs searching for the player. However, by using a NavigationAgent and a VisibilityNotifier, it is possible to significantly increase the number of mobs on a small map without causing lag. Additionally, by defining a random direction for mobs to go in when they spawn, it is possible to prevent stacking and performance issues when the player is nearby. These techniques have helped to make the game smoother and more enjoyable for players.

Island Escapades Updates on the Development of Escape The Wave

Emilien Leroy — Thu, 09 Mar 2023 14:00:00 +0000

Game development can be both challenging and exciting. It requires a lot of effort and creativity to come up with a game that is both engaging and enjoyable. In this devlog, I will be sharing my progress on my new game Escape The Wave.

Adding Escape Element

This week, I worked on adding the escape element to the game, which emits a signal when the player enters into the zone. The idea is to allow players to escape from the island they are stranded on. To achieve this, I created a new node and added it to the procedural map using a function that gave me the border of the island. Once I got a random position based on the island's border, I added it to the map.

Solving Map Issues

However, sometimes the island would have small archipelagos that could result in the escape being out of the main island's reach, making it impossible for the player to access it. To fix this, I created a function with the help of Chat GPT that removes all the unconnected islands. This allowed the escape to be always on the island.

But another issue arose when the wall could block the access to the escape. At the moment, I am waiting for assets for the game, so I haven't fixed this problem yet. I plan to work on it once I have implemented the assets. In addition to this, I also improved the loading time of the map when its size is too large.

Mob Spawns and Level System

Lastly, I added mob spawns on the island using a random position on the island. I also added a level system, where once the player enters the escape, they go to the next level. The next level will have a bigger map and more mobs, increasing the game's difficulty.

Conclusion

In conclusion, game development is a never-ending process of tweaking and improving. With every step forward, new challenges arise, but with perseverance and determination, they can be overcome. Escape The Wave is still a work in progress, and I can't wait to see how it evolves in the coming weeks.

Introducing Procedural Generation For My Game

Emilien Leroy — Thu, 02 Mar 2023 14:00:00 +0000

In this week's devlog for my new game Escape The Wave, I focused on the procedural generation of the map. It was a challenging but instructive process, and with the help of ChatGPT and a lot of research, I was able to successfully generate a map for my game!

Exploring Procedural Generation Methods

The objective of my game is to generate an island with randomly placed walls that have spaces for the player to pass through. To achieve this, I first researched various procedural generation methods. The first method I tried was perlin noise, which uses noise values to determine the position of each tile. While this method was easy to implement, it didn't allow me to control the form of the generated map to match my specific needs for the walls.

Next, I experimented with the walker algorithm, which is often used to create dungeon-like environments by creating rooms and links between them. I attempted to use this method to generate walls, but the result was inconclusive.

Developing a Custom Algorithm

Ultimately, I decided to create my own algorithm inspired by the two previous methods. I began by creating a 2D array with a predefined size, filling it with zeros to represent water. Then, I added an island by placing a circle in the center of the array with a radius equal to one-quarter of the array size. I filled this circle with ones to represent grass. To improve the form of the island, which initially resembled a simple circle, I used perlin noise and added water depending on the noise value. To ensure that the island did not become an archipelago, I applied the noise only on the border of the circle.

Finally, I added walls with a simple pattern, removing the middle of any wall larger than six tiles to ensure that the player could pass through all walls.

You can find the full algo here

Conclusion

Overall, the procedural generation of the map was a challenging but rewarding process. I am excited to continue developing my new game and to see how the generated map will enhance the player's experience.

Enemies, Health Regeneration, and Scene Updates

Emilien Leroy — Thu, 23 Feb 2023 14:00:00 +0000

Hi everybody! It's the third week of the development of my new game, Escape The Wave. I'm excited to share some of the new features I've added to the game.

Enemies can attack the player

One of the most significant updates to the game is that enemies can now attack the player. This feature adds a new level of difficulty to the game, making it even more challenging. When an enemy is near the player, the player will lose some of their life. If the player loses all of their life, the game is over.

Life item added

To balance out the increased difficulty, I've added a life item to the game. This item allows the player to regain some of their life when they touch it. Currently, I've added the life item statically to the game, but in the future, it will spawn randomly on the map.

Home and Score Scenes Added

In addition to these new gameplay elements, I've also worked on the home and score scenes. To make it easier to switch between scenes and pass data between them, I've added a router singleton. The home and score views are currently quite basic, as I haven't defined the theme of the game yet.

Invulnerable Frames Added

Finally, I've added some invulnerable frames to the player when they take damage. This means that the player will blink when they're invulnerable, indicating to the user that they cannot take any more damage during this time.

What's next

Overall, I'm happy with the progress I've made in the third week of development. These new features add more depth to the game and make it even more engaging for players. I can't wait to see how the game continues to evolve as I add more elements to it in the coming weeks. Stay tuned for more updates!

Escape the Wave, Week Two Development Update

Emilien Leroy — Mon, 13 Feb 2023 14:00:00 +0000

It's the second week of development for the game "Escape the Wave" and this week was focused on creating the base mob for the game. The goal of the game is to escape the waves of enemies that come at you, and this week was dedicated to creating the foundation for these enemies.

Creating the Base Mob

The first step in creating the base mob was to create a simple red square with some health. This square will serve as the foundation for all future mobs in the game. When a bullet from the player hits the mob, it will lose some health, and when its health reaches zero, it will be removed from the game. This basic mechanic sets the foundation for creating more complex and challenging enemies in the future.

Adding the Pathfinding System

The next step was to work on the pathfinding system for the mobs. This system allows the mobs to follow the player, making the game more challenging and engaging. Currently, an old method is used to find the path to the player, which works with a tileset. However, in a future version, this pathfinding system will be improved using the new navigation system in Godot. This will make the pathfinding more sophisticated and accurate, providing a better gaming experience for the player.

Adding the Player Score System

Finally, the player score system was added to the game. Now, when an enemy is killed, the player will earn points towards their score. This score system is simple for now, but it will be improved in the coming weeks to make the game even more engaging and rewarding.

In conclusion, this week was a productive one for the development of Escape the Wave. The base mob was created, the pathfinding system was improved, and the player score system was added, providing a solid foundation for creating more challenging enemies and a more engaging gaming experience.

Introducing Escape the Wave. My Exciting New Game!

Emilien Leroy — Thu, 09 Feb 2023 14:00:00 +0000

Last week, I officially released my first game, Falling Square, which marked a great milestone for me. However, the serious work now begins. This week, I'm starting development on my second game, Escape the Wave. It will be a simple shooting game with some surprises (which I'll keep secret for now). The game will be available on Android and iOS, like my first game, and may also be available on Windows, Linux, and macOS.

Virtual Joysticks for Player Movement

I've made my first addition to the game by incorporating the player and their movements. To cater to mobile devices, I've added a virtual joystick that enables users to move the player. I've also added another virtual joystick for rotation. Both virtual joysticks were developed by MarcoFazioRandom and can be found under the name "Virtual-Joystick-Godot" on GitHub at this link: https://github.com/MarcoFazioRandom/Virtual-Joystick-Godot."

Implementation of Player Shooting Mechanism

Next, I added the bullet and player shooting functionality. Currently, it's just a simple white ball without any textures, but there will likely be various types of bullets with unique effects in the future. To shoot, use the rotation joystick. Rotating the joystick will automatically trigger a shot.

Addition of First Wall and Camera Implementation

Finally, I've added the first wall using a simple tileset, as well as a camera that follows the player. When a bullet hits a wall, it is automatically destroyed. The camera and wall serve as the first elements in creating a visually appealing and functional environment for the game.

What's next

In the first week of development, I successfully laid the foundation for my new game. Building upon this solid foundation, I plan to add the first enemy in the upcoming week. This will bring the game one step closer to completion and provide players with a new challenge to overcome. I am eager to continue working on this project and can't wait to see how it evolves in the coming weeks.

The tool that revolutionized my workflow. My experience with Vite

Emilien Leroy — Thu, 02 Feb 2023 14:00:00 +0000

In my previous post, I shared my experience with TSED. Today, I want to talk about a tool that has greatly increased my workflow: ViteJS. For those unfamiliar, ViteJS is a web application development build tool created by Evan You and his team.

Before discussing ViteJS, I want to mention the previous build tool I used, Webpack. Webpack has a prominent place in web development and I used it on several projects over the years (and still use it on some legacy projects). However, it is slower than ViteJS due to its bundling process at each change. Even with a cache system, it still lags behind Vite in terms of speed.

I adopted ViteJS early on (even before its v1.0.0 release) and it has been one of the most incredible experiences in my developer life. Webpack used to take over 30 seconds to update even small changes, but with ViteJS, these updates take less than a second, just the time it takes to switch to the browser. Speed is one of ViteJS's biggest advantages. This is achieved by not bundling the app during development, but instead using the module script tag to improve module dependencies, which are all served as HTTP endpoints. For the build, Rollup is used to create the final bundle.

Another key advantage over Webpack is its simple configuration. No complicated setup is required. I can't count the number of hours I spent configuring Webpack, but it was a frustrating experience. Vite supports popular web frameworks with official plugins and has a large collection of plugins maintained by the community. It works seamlessly. I even created a plugin for Vite, a simple one for generating a custom-element.json manifest for web components.

import vue from '@vitejs/plugin-vue'

export default {
  plugins: [vue()],
}

For example, it's super easy to configure a vue app using vitejs.

As someone who has used both ViteJS and Webpack, I can attest to the superiority of ViteJS in many ways. Its lightning-fast update speeds and effortless configuration make it a joy to work with, compared to the headaches of configuring Webpack. The support for popular web frameworks and the wealth of community-maintained plugins only add to its appeal. I have even created a plugin myself, which further highlights the ease of customization. I highly recommend ViteJS to any web developer seeking a hassle-free and efficient build tool.

My First Mobile Game: Falling Square is Officially Out on App Store and Play Store

Emilien Leroy — Wed, 25 Jan 2023 19:00:54 +0000

I am excited to announce that my first mobile game, Falling Square, is officially out on the App Store and Play Store! Falling Square is a fun and challenging game that is easy to pick up and play, but difficult to master.

In Falling Square, the goal is to touch the square before it leaves the screen. The game starts with a single square falling from the top of the screen, and the player must tap the square before it reaches the bottom of the screen. As the player progresses through the game, more squares will fall at a faster pace, making the game more challenging.

The game also features a life system, where the player starts with three lives. If the player misses a square, they will lose a life. If the player loses all their lives, it's game over. The game features simple yet challenging gameplay, colorful graphics, and a catchy soundtrack. The game is available for free on both the App Store and Play Store.

Overall, Falling Square is a fun and addictive game that is perfect for anyone looking for a new mobile game to play. I hope you enjoy it as much as I enjoyed creating it!

Links:

Join the beta test for Falling Square on iOS

Emilien Leroy — Wed, 18 Jan 2023 14:00:00 +0000

Hello everyone,

I am excited to announce that the iOS version of Falling Square is currently in testing. You can download it on TestFlight using this direct link. I welcome any feedback from players. Your input will help me to make the game even better for everyone. I'm thrilled to bring this game to iOS users and can't wait for you to try it out. So, download the game now and let us know what you think!

Falling Square is a fast-paced and highly addictive mobile game that will put your reflexes to the test. The goal of the game is to touch the squares that are falling from the top of the screen before they leave the screen. The game is simple, yet challenging, and it requires quick reflexes.

Download link: https://testflight.apple.com/join/FDwsjAQR

Thank you for reading this article!

The framework that revolutionized my workflow.

Emilien Leroy — Thu, 12 Jan 2023 14:00:00 +0000

As a developer, it's always important to find ways to streamline the development process and save time. For the past two years, I've been using Ts.ED as the framework for all of my applications and it's been a game-changer. Not only has it allowed me to gain back lost development time, but it's also been the foundation for my open-source project HighScore.

Abstraction

One of the key features of the Ts.ED framework is its abstraction layer, which allows developers to use Express, Koa, or any other HTTP server of their choice. This gives developers the freedom to leverage the vast number of third-party Node.js modules available for the underlying platform, enabling them to build highly customized and feature-rich applications. The abstraction layer provided by Ts.ED makes it easy to integrate with various databases and APIs, and to add additional functionality to your applications.

Decorators

Another standout feature of Ts.ED is the implementation of decorators, which makes it easy to describe controllers and services within the framework. The decorators provided by Ts.ED allows developers to clearly define the functionality of their controllers and services, making it easy to understand and maintain their code. Additionally, the dependency injection system in Ts.ED makes it simple to access services from any file, further streamlining the development process.

import {Get} from "@tsed/schema";
import {Controller} from "@tsed/di";
import {PathParams} from "@tsed/platform-params";

interface Calendar {
  id: string;
  name: string;
}

@Controller("/calendars")
export class CalendarCtrl {
  @Get("/:id")
  async get(@PathParams("id") id: string): Promise<Calendar> {
    return {
      id,
      name: "test"
    };
  }
}

A simple example of controller using Ts.ED !

Documentation

Another advantage of Ts.ED is its extensive documentation and support. The Ts.ED team has done a great job of providing detailed documentation on how to use the framework and its various features, as well as maintaining an active community of users who are willing to help answer questions and offer support. This has made it easy for me to get up and running with Ts.ED, and troubleshoot any issues that have arisen along the way.

Third-party

The Ts.ED team has already created implementations for a wide range of popular modules, such as Swagger, Mongoose, and Socket.io. This allows developers to easily integrate these tools into their Ts.ED projects, saving time and effort. For a complete list of the available integrations, see the Ts.ED documentation. I have also personally contributed to the development of the Terminus package for Ts.ED. These integrations demonstrate the commitment of the Ts.ED team to support a diverse and growing ecosystem of tools and resources for developers.

A list of modules available on Ts.ED !

The team

The Ts.ED framework is primarily maintained by Romain Lenzotti, who does an incredible job keeping the framework up-to-date and reliable. One of the standout features of Ts.ED is its frequent releases, which ensure that the framework is continuously improving and addressing any potential issues. This is a major advantage for a framework like Ts.ED, as it helps to ensure that it stays current and relevant in the fast-paced world of web development.

Conclusion

In conclusion, there are many compelling reasons to consider using Ts.ED for your next project. Its simplicity and ease of use, extensive documentation and support, and reliable performance make it a standout choice for web development. As someone who has personally used the framework to build applications I highly recommend giving Ts.ED a try. Whether you are a beginner or an experienced developer, Ts.ED has something to offer and can help you to streamline your workflow and build better applications.

Maximizing Your Leaderboards with Highscore's New Category System and Meta Field

Emilien Leroy — Wed, 04 Jan 2023 14:00:00 +0000

Hi everyone! Before the holiday, I released a new version of Highscore, an open-source leaderboard for indie game developers. This release includes a new category system and some additional small features. If you're not familiar with Highscore, it's a great tool for indie game developers to track and compare the scores of their games. I hope you'll check it out and let us know what you think!

Category system

One of the main features of this release is the new category system, which allows you to create an unlimited number of leaderboards using a single field for the score. To use it, simply add the category field with the name of the desired category. Scores submitted with a category will not appear on the main leaderboard, but you can now retrieve all scores for a specific category by including the category field in your request. This is a great way to track scores for different groups or categories within your game or application.

The meta field

This release also introduces a new field called the meta field in the score model. This field allows you to pass in any object with your data, with no restrictions on what you can include. For example, you could use this field to attach additional stats or metadata to a score, such as the number of turns taken or the difficulty level of the game. The meta field is a flexible and powerful way to add more context and information to your scores, and can be used to tailor your leaderboards to your specific needs.

Privacy policy view

Highscore now includes a default privacy policy that can be customized using environment variables. You can view the privacy policy by accessing the endpoint /privacy. Using the environment variables, you can configure the country, email, and website information included in the policy. By providing a clear and transparent privacy policy, you can help build trust with your users and ensure that their personal information is protected.

What's next

The next release of Highscore is expected to include a new achievement system, which will allow you to add goals and milestones to your game. In addition, we will be adding websocket events, which will allow you to listen when new scores are added. We hope these new features will be useful and help you get even more out of Highscore.

Thanks for reading!