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.

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.

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.

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 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!

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.

What's next

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.

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.

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.

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:

• App Store

• Play Store

• Github

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!

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.

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!

This year has been a great one for me in terms of personal and professional growth. I've had the opportunity to create my first game and work on some exciting projects at my job.

My Journey as an Indie Game Developer: From Beginner to Published

One of the highlights of the year for me was completing the development of my first game. It was a challenging and rewarding experience, and I learned a lot about the process of creating a game from start to finish.

In January 2022, I started learning how to develop games using the Godot game engine and Blender to gain some 3D skills. However, I quickly realized that learning two things at the same time was quite challenging. After three months of trying to juggle both, I decided to focus solely on learning how to create 2D games using Godot.

One of my first 3D games made with Godot and Blender.

During this time, I have made some small games with the help of tutorials. These projects have allowed me to get a better understanding of the Godot engine and the process of game development. While I'm still a beginner, I'm excited to continue learning and improving my skills.

This game was made following this tutorial from KidsCanCode.

In April 2022, I began developing my first game called "Falling Square". The goal of the game is to touch the falling squares as they enter a designated zone before they fall off the screen. Each time a square falls off the screen, the player loses a life. If the player loses three lives, the game is over. After a month of development, I released the first version of the game on Android.

This is the current version of Falling Square, after a few months of development. You can download the Android version here!

I received positive feedback from my friends who tested the game, and one of them suggested adding an online leaderboard to keep track of high scores. Inspired by this suggestion, I decided to create an open-source leaderboard for indie game developers.

In July 2022, I started working on "Highscore", an open-source leaderboard platform for indie game developers. After two weeks of development, I released the v0.1.0 version of the project. I also implemented it in my own game, "Falling Square". I'm excited to see how the community uses this tool and hope it helps other indie game developers create more engaging and competitive games.

You can find the HighScore repository here!

Since September 2022, I've been working on improving both my game "Falling Square" and my project "Highscore". I have big plans for both in the coming year. For "Falling Square", I'm planning to release an iOS version in 2023. This will allow more players to enjoy the game and hopefully bring in a larger audience. As for "Highscore", I'm looking to add more cool features that will make it even more useful for indie game developers. I'm always looking for feedback and ideas from the community, so if you have any suggestions for features you'd like to see, don't hesitate to reach out.

Overall, I'm excited to see what the future holds for both "Falling Square" and "Highscore". I'm looking forward to continuing to develop and improve both projects.

A Look Back at My Year at Savoy International: Developing Applications and More

Since 2016, I've been working as a Full Stack developer at Savoy International, an automobile industry company. My job is to develop applications that improve production activities. All the tools I develop are part of the Kami project, a range of applications designed to enhance the performance of industrial companies.

Initially, Kami was an internal project, but since 2019, we have been working on commercializing it. We are excited to share the benefits of these tools with other businesses and help them streamline their operations.

A screenshot of one application of the Kami range!

This year, we have had the opportunity to work with external companies to install our Kami applications within their businesses. It has been a very enriching experience for me as I've had the chance to meet a lot of new people and learn from their experiences.

In addition to working with external clients, I have also been continuously improving the tools for my company. We have added a lot of new, exciting features that enhance the functionality and usability of the applications. It's always rewarding to see the positive impact of my work on the company and our clients.

Savoy International has several new projects in the works, including Kilow, an electric car for daily use on the roads. For this project, I have had the opportunity to work on the car's dashboard display. It has been an exciting and unique experience for me, and I've enjoyed being a part of this innovative project.

The Kilow car called "La Bagnole" at the "Mondial de l'auto" into Paris!

The latest project I've been working on is a small plugin for ViteJS called "vite-plugin-cem". This plugin allows developers to generate the manifest of their web components using Vite. It's an open-source project, so anyone is welcome to use it in their own projects or contribute to its development. I'm excited to see how this plugin is used by the community and hope it helps make the process of creating web components with Vite even easier.

Documentation generated with <api-viewer\> web component, using my plugin to generate the manifest!

Conclusion

This year has been a productive and exciting one for me. Overall, I've had the opportunity to work on a variety of projects and learn new skills, which has been a rewarding experience. I'm looking forward to what the future holds.

Thank you for reading!

The last week I worked on my open-source project HighScore and I released a new version. HighScore is an open-source leaderboard and is an alternative to the Google Play Service, which allows you to create leaderboards for your games and add some others features to your game. Highscore is currently under development and a lot of features are missing, but you can try the leaderboards which allow you to store your game score easily. This new version contains a new bad words filter, a custom download link and a rate limit to prevent spam.

Filter bad words

This new feature allows you to prevent poorly words into the name of the score sent. To work I use this bad-words library which already contains a default list of words. However, you can also add your own words depending on your language.

For HighScore, I just created a middleware that cleans each request which contains the name field into his body. This is the sample of the middleware.

import { MiddlewareMethods, Middleware } from "@tsed/platform-middlewares";
import { Context, Next } from "@tsed/common";
import { words } from '../../config/ban.json';
import { envs } from "../config/envs";
import BadWordsFilter from "bad-words";

@Middleware()
export class ScoreMiddleware implements MiddlewareMethods {
    private filter: BadWordsFilter;

    constructor() {
        const { HIGHSCORE_DISABLE_BAD_WORDS } = envs;
        // Configure the bad word filter on the app start
        this.filter = new BadWordsFilter({
            emptyList: HIGHSCORE_DISABLE_BAD_WORDS === 'true'
        });

        // Add more custom words from 'config/ban.json'
        this.filter.addWords(...words);
    }


    use(@Context() $ctx: Context, @Next() next: Next) {
        // Prevent request without body
        if (!$ctx.request.body) {
            return next();
        }

        // Clean body name
        const { name } = $ctx.request.body;
        $ctx.request.body.name = this.filter.clean(name);
        return next();
    }
}

I use Ts.ed as the framework, go to this site to know more about this awesome framework.

Custom download link

The second feature of this release is the custom download link. This allows you to redirect to another page depending on the user platform. Why this feature? Because when you create a game for multiple platforms like Android, iOS, Windows, and Linux. You want to have a single entry point to download your app or game. For example, if you want to create a Qr code for your mobile game that is for Android and iOS you can use this endpoint in your QR code. When the QR code is scanned the user is redirected to the good application store.

Rate limit to prevent spam

The last feature is a rate limit to prevent spam. Highscore has no auth system all endpoints are public and can be accessible by anybody. That's why adding a rate limit is useful to prevent abuse requests for a malicious users. For this, I used the very good express-rate-limit library which does the job perfectly. Like all other features, you can configure the rate limit using env variables.

What's next

The next release will contain a custom privacy page pre-built for the application store, like Google Play or the AppStore. It will also contain a new category system to create a leaderboard for different categories. You can already try HighScore using the official docker image or contribute to it via the GitHub repository.

Thank you for reading this article!

Hi everybody, a new release of my game Falling Square was released the last week. In this release you will find new visual effects, new sound effects and a new statistics view to see how you are good at this game. The game is currently available only on Android, but an IOS version should be available begin of 2023.

Better visuals effects

In this release, the biggest improvement is in the design of the game. A lot of details had been added to improve the user experience. The first change is the touched item animation, which is much better. Before only the color changed, but now the item explodes in little particular, which is very satisfying. The second change is the design of the touch zone. Now this zone is animated which adds a bit of difficulty when the square is little. I have also added a red flash when you lose a life. This help knows when a square is out of the screen. This allows users to always focus on items and not on the number of life

Adding sounds effects

Music and sound effects are important parts of games. Now Falling Square has background music and sound effect for each item. This improves the user experience. I also added two options to disable music and sound effect. I didn't add a volume slider because this game is only on a phone and on this device, the user often updates the global sound of the phone using the physical button and not the direct app sound.

Statistics

The last feature of this release is the new statistics view. Now after each game, the number of each item touched is stored on the phone. You can access the data via the statistics view.

What's next

That's all for this release. The next release will come in current begin in 2023 with an IOS version of the game. For the moment, you can download Falling Square on Android and find the source of the game on the GitHub repository. Thank you for reading this article!

Last week I released a new version of my game Falling Square which add some new cool features. Falling Square is a simple arcade game where the main goal is to touch squares before they go out of the screen. It currently in development, but you can download the Android version to test it. This project is open source, you can contribute to it or create your own version of falling square.

New leaderboard

The main features of this version is the leaderboard. It adds a bit a challenge to the game. This feature use HighScore (an open source leaderboard I developed) to work. Highscore only store your username and your score. It uses a simple session id and a cookie to retrieve your score. No account is needed to send a score. Play to the game to send a score and try to beat the current top score!

Internationalization

The second new feature is the support of two langages: english and french. If you want add another language feel free to open a pull request.

Better home menu

In the previous version home page contain only a single button. Now in this version menu have been updated and you can easily access to the option view or the information view. I also add some pretty falling squares to the background of the home view.

What's next

If you want to support my work you can donwload Falling Square or leave a star to the github repository of the game. In the next version visual effect and sound effect will be improved. The github repository https://github.com/EmilienLeroy/FallingSquare.

Thanks you for reading this article !

About me

My name is Emilien Leroy, I'm 26 years old and I live in France. I work as FullStack developer into a manufacturing company since 2016. I'm passionate with new technologies and specially by the web! I like making web application from scratch to production build. I also love to play video game, piano and watch movies!

My skills

My favorites technologies are Nodejs, Typescript and Vuejs. I also master Mongodb, Web Component, Electron and many others. This is a list of all the technologies I master :

• Frontend: Javascript, Typescript, Vuejs, Lit, Electron, React Native,Webpack,Vitejs
• BackEnd: Node.js, Socket.io, Express, Ts.ED, MongoDB, Mysql
• DevOps: Docker, Gitlab CI, Github Action, Grafana, Loki, Prometheus, Nginx

I use all these skills at my work to build and maintain applications, but I also use these to build game and some OSS project.

Why this blog ?

I decide to create my own blog to write about my futures projects and my technical experiences. My first goal with this it to keep a trace of how I build all my projects and share it with some people. And if this can help somebody, I will be very glad to this ! The second goal is to improve my english skill. Like as say before, I'm french and my english is a bit terrible. I think this blog will help me to improve this!

See you soon

Thank you for having read this, your feedback and suggestion will be really appreciated. If you want to get more information about me see my personal site or my github profile. See you soon for my second article !