The pass allows visitors and locals to enjoy roughly a dozen of Portis' favorite spots in Milwaukee at a discounted price and be entered for a chance to win prizes.

Experience Milwaukee like Bobby Portis with VISIT Milwaukee's 'Bobby Portis Pass'

Elena Grigorian recently took over as CEO of My.Games, the former Russian game company that moved to Amsterdam. We spoke with her.

How Elena Grigorian plans to guide European game publisher My.Games

Death May Die, though, there is already a ton of content available at retail (and some extra content for those lucky enough to find it on the secondary market.) We’ve recently been able to complete our collection of Cthulhu: Death May Die content thanks to our friends at Asmodee,

A board gamer’s guide to ‘Cthulhu: Death May Die’

Why would I want anyone to benefit from that when they think so little of me? (Picture: Getty) My solicitor looked at me carefully. ‘You can go away and think about it if you’re not 100% sure ...

My sister-in-law turned my nephews against me so I took them out of my £250,000 will

As was widely expected, Xbox fans should not expect any Activision Blizzard King games to appear on Xbox Game Pass until 2024. When Microsoft closed its blockbuster deal to buy the Call of Duty ...

No Activision Blizzard Games On Xbox Game Pass Until 2024, Phil Spencer Confirms

Get the lowdown on Mighty Boy Studio's upcoming sci-fi fantasy epic, Babylon X, which is coming to PC and consoles.

Babylon X To Unleash Sci-Fi Fantasy Action On Consoles & PC From Mighty Boy Studio

Set in an alternative history of the Ancient World where the Tower of Babel is being built and humanity faces with the impending apocalypse, Babylon X combines the best elements of western and eastern narrative and directing, taking inspiration from ...

Sci-fi fantasy action RPG Babylon X announced for consoles, PC

When you have the best iPhone, you pretty much have infinite possibilities for keepingbusy and entertained, no matter where you are. Sure, the iPhone may not be marketed as a gaming phone ...

The best iPhone games in 2023: 31 games you need to play right now

I love pouring over maps. Whether it be a map plucked from the past in a history textbook, or one found among the pages of a fantasy novel, they offer windows into worlds from the comfort of your ...

The Starfield map is the one thing stopping me from living my spaceflight fantasy

Board games are a great way to break the ice, whether you’re at a party or hosting a get-together with folks you haven’t seen in a while. But with so many options available — from strategy ...

The Best Adult Board Games, According to Cool People

MyGames

mygames

The choice of a suitable network topology is critical for effective and stable multiplayer. We'll talk about the pros and cons of the main network topologies for real-time multiplayer: P2P, authoritative servers, relay servers, and more. Greetings again everyone, I'm Dmitrii Ivashchenko, Lead Software Engineer at MY.GAMES. Our article series on the landscape of Unity realtime multiplayer in 2023 continues — and today's topic concerns the main network topologies for realtime multiplayer. Network Topology The key factor in ensuring the effective and stable operation of a multiplayer game is the choice of a suitable network architecture, or topology. This decision affects both the way data is transmitted and processed in the game, as well as performance and resource consumption. Let's look at some possible models. P2P (Peer-to-Peer) P2P, or peer-to-peer architecture, is a model in which each player connects to every other player and exchanges data about game state and events. In “pure” P2P, there is no single "host". Instead, each client is responsible for managing its own game character (or units) while receiving updates about events from each of the other clients. Advantages of P2P: No need to develop or maintain dedicated servers. Clients create direct connections with each other, providing the most direct connection (which usually, but not always, corresponds to a low ping). Disadvantages of P2P: The absence of a single authoritative host makes cheat detection significantly more difficult. This also makes compensation for delays less effective. Additionally, a "desynchronization" of clients is possible, leading to differences in game state between them. Each client creates multiple outgoing connections and accepts incoming connections, so each client has to deal with firewall settings and port forwarding. Authoritative servers In this model, one of the nodes of the game network (this is usually initially selected or based on network connection features) becomes the "authoritative server", controlling the game state and processing all game events. The other nodes (clients) send their actions to this server and receive updated game state from it. Server-client with the authoritative dedicated game server (DSG) In a client-server architecture with an authoritative dedicated game server, all clients connect to a single game server. The dedicated game server (DGS) runs the game engine and is the source of the game's final state. It receives updates from connected clients, incorporates them into its game state, and sends the resulting state to each client. MMORPGs and other games with persistent online worlds also fall into this category. In such cases, DGS also includes databases that store data about the persistent world. Advantages of DGS: The game server is "authoritative": it has the final say on whether events created by clients are valid or not. This allows for a wide range of delay compensation mechanisms and fraud prevention, as well as eliminating synchronization issues, as the server overrides the state of clients. Disadvantages of DGS: It is necessary to develop and manage a dedicated game server, and doing this has certain costs associated with it. Leveraging a client-server architecture with an authoritative dedicated game server is one of the most common approaches in large multiplayer games and provides a high degree of control over the state of the game and combating fraud. Server-client with authoritative client-host In a client-server architecture with an authoritative client-host, instead of using a dedicated game server to maintain authoritative game state, it's possible to use one of the client machines as a server. This client becomes a client-host; simultaneously the host of the game session as well as a participant in the game. Advantages of client-host: Client-host has advantages as a dedicated game server but without the additional cost of running one. Disadvantages of client-host: The host machine must perform additional calculations to simultaneously perform host and client functions. Locally connected clients have much lower connection latency to the host compared to other clients, which can create a competitive advantage (known as "host advantage"). The client-server architecture with an authoritative client-host allows players to independently organize multiplayer sessions without the need to connect to a dedicated game server. However, it's necessary to consider the load on the host machine and potential issues with "host advantage". Relay server In architecture with a relay/matchmaking server for finding opponents, the server exists to facilitate connections and data transmission between clients, but does not actively participate in the game. Although a dedicated server is still required because it does not need to run a game engine, creation and management of this can be relatively inexpensive. Moreover, most P2P games can easily switch to using a relay server, since the network code only differs in the way clients connect to each other. : Advantages of relay servers Since an external server is used, clients only need to establish outgoing connections, so they don't need to configure port forwarding or firewalls. : Disadvantages of relay servers Relay severs have the same drawbacks as P2P, but the delay is higher because the connections are no longer direct. The operation of a relay server still requires certain costs, although they are lower than those of a dedicated game server. The relay/server architecture for finding opponents provides a simple and inexpensive solution for ensuring connections and data transmission between clients. It avoids problems related to port forwarding and firewalls, but it may have some delay due to the intermediate server. Here's an example of the class in C# that uses TCP to listen for incoming client connections and then add them to a list of active clients. The server then asynchronously handles each client connection by reading data and forwarding it to all connected clients: RelayServer public class RelayServer
{
    private TcpListener _listener;
    private List<TcpClient> _clients = new List<TcpClient>();

    public async Task StartAsync(int port)
    {
        _listener = new TcpListener(IPAddress.Any, port);
        _listener.Start();
        Console.WriteLine($"Server started on port {port}");

        while (true)
        {
            TcpClient client = await _listener.AcceptTcpClientAsync();
            _clients.Add(client);

            Task.Run(() => HandleClientAsync(client));
        }
    }
} The code below represents the function , which is responsible for processing each connected client in asynchronous mode. HandleClientAsync First, the function creates a buffer for reading data and obtains a stream for reading and writing data. Next, in an infinite loop, the function asynchronously reads data from the stream. If no data is received (i.e. the client disconnected), the function removes the client from the list and stops processing. Otherwise, the received data is converted to a string and sent to all connected clients: private async Task HandleClientAsync(TcpClient client)
{
    byte[] buffer = new byte[1024];
    NetworkStream stream = client.GetStream();

    while (true)
    {
        int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);

        if (bytesRead == 0)
        {
            _clients.Remove(client);
            return;
        }

        string message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
        BroadcastMessage(message);
    }
} To send the received message to all connected clients, we will need the function : BroadcastMessage private void BroadcastMessage(string message)
{
    foreach (var client in _clients)
    {
        NetworkStream stream = client.GetStream();
        byte[] buffer = Encoding.UTF8.GetBytes(message);
        stream.Write(buffer, 0, buffer.Length);
    }
} The function takes a message as a string, iterates through the list of connected clients, and for each of them converts the message to bytes and writes it to the corresponding network connection stream. This way, the message is successfully transmitted to all clients. Conclusion In this article, we discussed the main network topologies for real-time multiplayer games — including P2P, authoritative server, and relay server. Each topology has its advantages and disadvantages, such as direct connections and low ping in P2P, and effective cheat detection and fraud prevention in authoritative server; relay server provides a simple and inexpensive solution for ensuring connections and data transmission between clients. Choosing the right topology is crucial for ensuring a smooth gaming experience in real-time multiplayer games. But this decision also concerns infrastructure cost and project scalability. In the next article, we will consider the main patterns of network architecture in different game genres.

Unity Realtime Multiplayer, Part 6: Game Network Topologies

I've been picking away at a new board game for a few years now. I made some progress early on but got stalled with other priorities. I'm now going to push to get the game done. I think it might be a fun experiment to share my design progress online — and create a better game with live feedback from you — where you can influence the design. If people choose to follow and post feedback in the comments, I will take your direction with the design of the game, continue to post my progress with gameplay refinements and design sketches, and continue to ask for your feedback. About The Game This will be an educational board game to help players learn personal finance — but more broadly about life, money, and happiness. I know what you are thinking — The Game of Life! Wikipedia says this game was created in 1860 with the more modern version in 1960. The game has an iconic three-dimensional board with a colorful spinner in the middle. This game is exciting to look at and nicely tactile. It's a vivid childhood memory for many of us. But, to be honest, in IMO, it's not a great game to play. The gameplay is dated. I have no intention of duplicating any part of this game. Our game will have a fresh start (as I try to do with all of my games). I have already designed board games and software games and simulations for personal finance, so I have a good foundation for our new game. I want this game to be like a simulation that recreates realistic decisions people make in the real world. Player & Customer Profile The primary target customers will be schools. But if we can attract home users that will be great too. Designing a product for education first, instead of entertainment, is particularly challenging. It's even more challenging to design a game that crosses over from schools to homes. But we'll give it a shot! (I've written about this here — Using Entertainment Games for Education). Knowing your customer is super important when designing a product. To refine the player profile further, the target age range is likely to be 13 to adult. This encompasses middle schools and high schools. The game may also play well for 11 and 12-year-olds, but here's an interesting fact — we can save thousands of dollars in production costs by setting the minimum age to 13. Why? Because toys and games for ages 12 and under require comprehensive materials testing for child safety. Of course, we always source and use safe materials for our games, but when costly double-testing is not necessary, then we should consider our options. Goals The first step — choosing the goals of the game. This is an interesting challenge with personal finance — because there are no clear right and wrong answers — everyone has their own path in life. Some may choose to pursue financial wealth over everything else, while others focus on personal lifestyle or relationships with friends and family. Some may try to have it all. Our game goals must reflect this reality of personal choice. We must refrain from applying our own biases in an educational product. With this in mind, here is what I'm currently thinking — The overall goal should be Happiness. I feel like this is a good term that can be applied on a personal level regardless of individual life goals. The player with the most Happiness Points (HP) wins the game — although "win" may not be the right term here as we still have to decide if this will be a cooperative or competitive game or something in between. Reminder — the educational objective of the game is to help you gain the personal finance knowledge and skills to achieve your definition of happiness. Next, we have to define Happiness — my current thinking is that it should be made up of three metrics — Financial Wealth + Lifestyle + Friends & Family. Each player may put more or less emphasis on any combination of these three metrics. BTW, our brains like to work in threes. Fours become too complicated. Two is even better but may be too restrictive for the gameplay we want to design. You will see the word "Relationship" in my graphic above because I don't like that "Friends & Family" uses two words, so I'm thinking about alternatives. Where is Health? I carefully considered whether health should be one of the three metrics since it is perhaps the single most important influence on happiness. But I decided not to include in the three metrics because: Everyone wants good health (even if they may not make healthy choices).
Health influences all of our life goals.
Adding a fourth metric breaks our 3-metric rule. So, the best way to include health is to have it applied throughout the game as various choices and events, such as personal care, nutrition, fitness, routine checkups, health insurance, etc. There you have it ... that's where we are so far. I have more to share in the next post. My direction will be influenced by the feedback you provide. Share Your Thoughts In the Comments Am I on track? Am I missing something? Do you have any suggestions? Should I keep posting about this game? PS: Please only share ideas if you are willing to allow me or anyone following this discussion to use them for free without any obligation. If you contribute an idea that has a significant influence on the design of my game, I will be pleased to gift you a copy of the game. I've been picking away at a new board game for a few years now. I made some progress early on but got stalled with other priorities. I'm now going to push to get the game done. I think it might be a fun experiment to share my design progress online — and create a better game with live feedback from you — where you can influence the design. If people choose to follow and post feedback in the comments, I will take your direction with the design of the game, continue to post my progress with gameplay refinements and design sketches, and continue to ask for your feedback. About The Game This will be an educational board game to help players learn personal finance — but more broadly about life, money, and happiness. I know what you are thinking — The Game of Life! Wikipedia says this game was created in 1860 with the more modern version in 1960. The game has an iconic three-dimensional board with a colorful spinner in the middle. This game is exciting to look at and nicely tactile. It's a vivid childhood memory for many of us. But, to be honest, in IMO, it's not a great game to play. The gameplay is dated. I have no intention of duplicating any part of this game. Our game will have a fresh start (as I try to do with all of my games). I have already designed board games and software games and simulations for personal finance, so I have a good foundation for our new game. I want this game to be like a simulation that recreates realistic decisions people make in the real world. board games software games and simulations Player & Customer Profile The primary target customers will be schools. But if we can attract home users that will be great too. Designing a product for education first, instead of entertainment, is particularly challenging. It's even more challenging to design a game that crosses over from schools to homes. But we'll give it a shot! (I've written about this here — Using Entertainment Games for Education ). Using Entertainment Games for Education Knowing your customer is super important when designing a product. To refine the player profile further, the target age range is likely to be 13 to adult. This encompasses middle schools and high schools. The game may also play well for 11 and 12-year-olds, but here's an interesting fact — we can save thousands of dollars in production costs by setting the minimum age to 13. Why? Because toys and games for ages 12 and under require comprehensive materials testing for child safety. Of course, we always source and use safe materials for our games, but when costly double-testing is not necessary, then we should consider our options. Goals The first step — choosing the goals of the game. This is an interesting challenge with personal finance — because there are no clear right and wrong answers — everyone has their own path in life. Some may choose to pursue financial wealth over everything else, while others focus on personal lifestyle or relationships with friends and family. Some may try to have it all. Our game goals must reflect this reality of personal choice. We must refrain from applying our own biases in an educational product. With this in mind, here is what I'm currently thinking — The overall goal should be Happiness. I feel like this is a good term that can be applied on a personal level regardless of individual life goals. The player with the most Happiness Points (HP) wins the game — although "win" may not be the right term here as we still have to decide if this will be a cooperative or competitive game or something in between. Reminder — the educational objective of the game is to help you gain the personal finance knowledge and skills to achieve your definition of happiness. Next, we have to define Happiness — my current thinking is that it should be made up of three metrics — Financial Wealth + Lifestyle + Friends & Family. Each player may put more or less emphasis on any combination of these three metrics. BTW, our brains like to work in threes. Fours become too complicated. Two is even better but may be too restrictive for the gameplay we want to design. You will see the word "Relationship" in my graphic above because I don't like that "Friends & Family" uses two words, so I'm thinking about alternatives. Where is Health? I carefully considered whether health should be one of the three metrics since it is perhaps the single most important influence on happiness. But I decided not to include in the three metrics because: Everyone wants good health (even if they may not make healthy choices). Health influences all of our life goals. Adding a fourth metric breaks our 3-metric rule. Everyone wants good health (even if they may not make healthy choices). Health influences all of our life goals. Adding a fourth metric breaks our 3-metric rule. So, the best way to include health is to have it applied throughout the game as various choices and events, such as personal care, nutrition, fitness, routine checkups, health insurance, etc. There you have it ... that's where we are so far. I have more to share in the next post. My direction will be influenced by the feedback you provide. Share Your Thoughts In the Comments Am I on track? Am I missing something? Do you have any suggestions? Should I keep posting about this game? PS: Please only share ideas if you are willing to allow me or anyone following this discussion to use them for free without any obligation. If you contribute an idea that has a significant influence on the design of my game, I will be pleased to gift you a copy of the game.

Assist Me in Designing a Board Game - Part 1

How to Optimize UIs in Unity: Slow Performance Causes and Solutions

ঐক্যে UIs কিভাবে অপ্টিমাইজ করা যায়: ধীর কর্মক্ষমতা কারণ এবং সমাধান

So optimieren Sie Benutzeroberflächen in Unity: Ursachen und Lösungen für langsame Leistung

Cómo optimizar las interfaces de usuario en Unity: causas y soluciones del bajo rendimiento

Comment optimiser les interfaces utilisateur dans Unity : causes et solutions des performances lentes

यूनिटी में UI को कैसे अनुकूलित करें: धीमी प्रदर्शन के कारण और समाधान

Unity で UI を最適化する方法: パフォーマンス低下の原因と解決策

Unity에서 UI를 최적화하는 방법: 성능 저하 원인 및 해결책

Como otimizar UIs no Unity: causas e soluções de desempenho lento

Как оптимизировать пользовательский интерфейс в Unity: причины низкой производительности и решения

Unity'de Kullanıcı Arayüzleri Nasıl Optimize Edilir: Yavaş Performans Nedenleri ve Çözümleri

Cách tối ưu hóa giao diện người dùng trong Unity: Nguyên nhân và giải pháp hiệu suất chậm

如何优化 Unity 中的 UI：性能缓慢的原因及解决方案

Singularity: Streamlining Game Development with a Universal Backend Framework

এককতা: একটি ইউনিভার্সাল ব্যাকএন্ড ফ্রেমওয়ার্ক সহ গেম ডেভেলপমেন্টকে স্ট্রীমলাইন করা

Singularity: Optimierte Spieleentwicklung mit einem universellen Backend-Framework

Singularidad: agilización del desarrollo de juegos con un marco de backend universal

Singularity : rationaliser le développement de jeux avec un framework backend universel

सिंगलेरिटी: यूनिवर्सल बैकएंड फ्रेमवर्क के साथ गेम डेवलपमेंट को सुव्यवस्थित करना

Singularity: ユニバーサル バックエンド フレームワークによるゲーム開発の効率化

Singularity: 범용 백엔드 프레임워크로 게임 개발 간소화

Singularidade: simplificando o desenvolvimento de jogos com uma estrutura de back-end universal

Singularity: оптимизация разработки игр с помощью универсальной серверной платформы

Tekillik: Evrensel Arka Uç Çerçevesiyle Oyun Geliştirmeyi Kolaylaştırma

Điểm kỳ dị: Hợp lý hóa quá trình phát triển trò chơi với Khung phụ trợ phổ quát

Singularity：使用通用后端框架简化游戏开发

Today, I would like to share my personal story. I hope it helps you get to know me better and maybe benefits your own journey. https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true Visit my YouTube Channel A Bit of History My love for gaming has a long history. I was lucky because my parents could buy a computer when I was very young. It was an IBM 486 🙂 and it belonged to my brother. My First Games The first games I remember playing were Wolf and Doom. Wolf is a first-person shooter action game that still sticks in my memory. Doom is a similar type of game to Wolf, but it was very scary, so I didn’t play it at night. 🙂 It was such an exciting game that I still remember the cheat codes: IDDQD (God Mode) and IDKFA (full set of weapons). Then came Duke Nukem, Sin City, Blood, and more. Actually, Blood was the first PVP game for me. I remember trying to connect through a Dial-Up modem with my uncle. 🙂 It was a terrible experience, but we managed to see each other in the game. However, there was no chance to have real PVP actions. I think some of you don’t know what Dial-Up is. Dial-Up or Usenet was a UNIX-based system that used a dial-up connection to transfer data through telephone modems. Sounds of Dial-Up https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true PVP Games As time went on, more PVP games appeared on the market, and I started playing more seriously, even participating in local competitions in my hometown. We played: Quake 3
Counter Strike
StarCraft
Etc. PVP games took a lot of my time. I loved playing and could play for many hours. Sometimes, after school, my friends and I would go to a computer club and spend 6 or more hours there. In the computer club, I saw Ultima Online for the first time. First Learning I believe that games helped me learn various things about computers. At that time, I felt like I knew almost everything about computers, both software and hardware. I started with DOS, then Norton Commander, then Windows 3.1, and so on. I could replace certain parts of the computer, like HDDs and RAM, and connect multiple computers together, etc. Many of my friends called me to fix their devices or reinstall Windows. I felt that I had some skills that others didn’t. This probably influenced my direction. After school, I joined Mathematics College and started my software engineering journey. My major was “Organization and Technology of Information Security.” We learned many things, some of which I liked and some I didn’t, but I never had a problem spending time in front of a computer. 🙂 In college, I first learned HTML. I liked studying, but I loved playing games even more. Ultima Online Ultima Online is a fantasy massively multiplayer online role-playing game released on September 24, 1997, by Origin Systems. Set in the Ultima universe, it is known for its extensive player-versus-player (PVP) combat system. To this day, I think it is the best game ever. 🙂 You played with real people like yourself. In this game, you had to develop not only your character’s skills (which could take more than a year) but also personal skills like trading, negotiation, business, saving, and more. You had to spend many days, and sometimes months, to grow your character’s skill from 0 to grandmaster level. You had to travel around the universe to find different things for crafting, hunting, and so on. The most exciting part was when you left the guarded zone. This was when you could lose everything if someone killed you. That’s why you had to think carefully about where you went and what you took with you. 🙂 It was a really good game, and I still have good memories of it. I played pretty well and often stayed on the ranking tables for PVP battles. Time to Change Since I spent so much time playing this game, I sometimes felt like I was wasting my time. However, I didn’t want to stop. 🙂 One day, during a very important PVP battle, I lost. I was so sad that I decided to stop playing. I’m not sure why, but that loss helped me change my habits. I don’t think it was easy, but I don’t remember suffering during that time, so maybe it wasn’t that bad :). Even though I still spent a lot of time on the computer, I tried to find new ways to fill that time. Since I was very young and still studying, I didn’t think about getting a job. But one day, I heard about freelancing and online work. It was interesting because I saw the opportunity to earn money. First Freelance Job I don’t remember if fl.ru was the first website I registered on, but I think it was where I found my first web task. 🙂 That was more than 18 years ago! 🙂 Wow! The task was to convert a .psd file into an HTML page. I had never done such a job before, but I wasn’t afraid to try (haha, I think I was very afraid). I wasn’t very skilled with Photoshop, so I cut some parts of the layout using MS Paint (I took screenshots and then pasted them into MS Paint). It was the first time I found out that the .bmp format is not suitable for the web. It was too heavy, and the page loaded very slowly. 🙂 After many hours of work, I finished my HTML code and sent it to my customer. He was happy with the result and transferred my first payment. I was so happy! An extra level of happiness came when I learned that he wanted to work with me on another project because the speed of my page and the quality of my work were good. Making money was an enjoyable process, just like playing a game, so I started to spend more time learning HTML coding and doing different freelance work. After about 3–6 months, I found a job that allowed me to study and work at the same time. My first position was as a webmaster. 🙂 From that time until today, I have almost never given up on computers and web development. I’ve learned a lot of different things over these 18 years and continue my journey to this day. 🙂 From time to time, I go back to playing games, but it’s not the same anymore. 🙂 Today, I would like to share my personal story. I hope it helps you get to know me better and maybe benefits your own journey. https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true Visit my YouTube Channel Visit my YouTube Channel Visit my YouTube Channel A Bit of History My love for gaming has a long history. I was lucky because my parents could buy a computer when I was very young. It was an IBM 486 🙂 and it belonged to my brother. My First Games The first games I remember playing were Wolf and Doom. Wolf is a first-person shooter action game that still sticks in my memory. Doom is a similar type of game to Wolf, but it was very scary, so I didn’t play it at night. 🙂 It was such an exciting game that I still remember the cheat codes: IDDQD (God Mode) and IDKFA (full set of weapons). Then came Duke Nukem, Sin City, Blood, and more. Actually, Blood was the first PVP game for me. I remember trying to connect through a Dial-Up modem with my uncle. 🙂 It was a terrible experience, but we managed to see each other in the game. However, there was no chance to have real PVP actions. I think some of you don’t know what Dial-Up is. Dial-Up or Usenet was a UNIX-based system that used a dial-up connection to transfer data through telephone modems. Sounds of Dial-Up https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true https://youtu.be/QNcSEuLWqdY?si=t-zTxt2sS91ymLID&t=117&embedable=true PVP Games As time went on, more PVP games appeared on the market, and I started playing more seriously, even participating in local competitions in my hometown. We played: Quake 3 Counter Strike StarCraft Etc. Quake 3 Counter Strike StarCraft Etc. PVP games took a lot of my time. I loved playing and could play for many hours. Sometimes, after school, my friends and I would go to a computer club and spend 6 or more hours there. In the computer club, I saw Ultima Online for the first time. First Learning I believe that games helped me learn various things about computers. At that time, I felt like I knew almost everything about computers, both software and hardware. I started with DOS, then Norton Commander, then Windows 3.1, and so on. I could replace certain parts of the computer, like HDDs and RAM, and connect multiple computers together, etc. Many of my friends called me to fix their devices or reinstall Windows. I felt that I had some skills that others didn’t. This probably influenced my direction. After school, I joined Mathematics College and started my software engineering journey. My major was “Organization and Technology of Information Security.” We learned many things, some of which I liked and some I didn’t, but I never had a problem spending time in front of a computer. 🙂 In college, I first learned HTML. I liked studying, but I loved playing games even more. Ultima Online Ultima Online is a fantasy massively multiplayer online role-playing game released on September 24, 1997, by Origin Systems. Set in the Ultima universe, it is known for its extensive player-versus-player (PVP) combat system. To this day, I think it is the best game ever. 🙂 You played with real people like yourself. In this game, you had to develop not only your character’s skills (which could take more than a year) but also personal skills like trading, negotiation, business, saving, and more. You had to spend many days, and sometimes months, to grow your character’s skill from 0 to grandmaster level. You had to travel around the universe to find different things for crafting, hunting, and so on. The most exciting part was when you left the guarded zone. This was when you could lose everything if someone killed you. That’s why you had to think carefully about where you went and what you took with you. 🙂 It was a really good game, and I still have good memories of it. I played pretty well and often stayed on the ranking tables for PVP battles. Time to Change Since I spent so much time playing this game, I sometimes felt like I was wasting my time. However, I didn’t want to stop. 🙂 One day, during a very important PVP battle, I lost. I was so sad that I decided to stop playing. I’m not sure why, but that loss helped me change my habits. I don’t think it was easy, but I don’t remember suffering during that time, so maybe it wasn’t that bad :). Even though I still spent a lot of time on the computer, I tried to find new ways to fill that time. Since I was very young and still studying, I didn’t think about getting a job. But one day, I heard about freelancing and online work. It was interesting because I saw the opportunity to earn money. First Freelance Job I don’t remember if fl.ru was the first website I registered on, but I think it was where I found my first web task. 🙂 fl.ru That was more than 18 years ago! 🙂 Wow! The task was to convert a .psd file into an HTML page. I had never done such a job before, but I wasn’t afraid to try (haha, I think I was very afraid). I wasn’t very skilled with Photoshop, so I cut some parts of the layout using MS Paint (I took screenshots and then pasted them into MS Paint). It was the first time I found out that the .bmp format is not suitable for the web. It was too heavy, and the page loaded very slowly. 🙂 After many hours of work, I finished my HTML code and sent it to my customer. He was happy with the result and transferred my first payment. I was so happy! An extra level of happiness came when I learned that he wanted to work with me on another project because the speed of my page and the quality of my work were good. Making money was an enjoyable process, just like playing a game, so I started to spend more time learning HTML coding and doing different freelance work. After about 3–6 months, I found a job that allowed me to study and work at the same time. My first position was as a webmaster. 🙂 From that time until today, I have almost never given up on computers and web development. I’ve learned a lot of different things over these 18 years and continue my journey to this day. 🙂 From time to time, I go back to playing games, but it’s not the same anymore. 🙂

How I Replaced Gaming with Coding and Became a Web Developer

Mission Generation Using Classic Machine Learning and Recurrent Neural Networks in Zombie State

জম্বি রাজ্যে ক্লাসিক মেশিন লার্নিং এবং পুনরাবৃত্ত নিউরাল নেটওয়ার্ক ব্যবহার করে মিশন জেনারেশন

Missionsgenerierung mit klassischem maschinellem Lernen und rekurrierenden neuronalen Netzwerken im Zombie-Zustand

Generación de misiones utilizando aprendizaje automático clásico y redes neuronales recurrentes en estado zombie

Génération de mission à l'aide de l'apprentissage automatique classique et des réseaux de neurones récurrents dans un état zombie

ज़ोंबी स्टेट में क्लासिक मशीन लर्निंग और रीकरंट न्यूरल नेटवर्क का उपयोग करके मिशन जनरेशन

ゾンビ状態での古典的な機械学習とリカレントニューラルネットワークを使用したミッション生成

좀비 상태에서 고전적인 기계 학습과 순환 신경망을 사용한 미션 생성

Geração de missão usando aprendizado de máquina clássico e redes neurais recorrentes no estado zumbi

Генерация миссий с использованием классического машинного обучения и рекуррентных нейронных сетей в состоянии зомби

Zombie State'te Klasik Makine Öğrenimi ve Tekrarlayan Sinir Ağlarını Kullanarak Görev Oluşturma

Tạo nhiệm vụ bằng cách sử dụng mạng lưới thần kinh định kỳ và học máy cổ điển ở trạng thái Zombie

在僵尸状态下使用经典机器学习和循环神经网络生成任务

Moving to the upcoming WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics. But this migration will turn out better with preparation and understanding — and this article will get you ready. Hello everyone, my name is Dmitrii Ivashchenko and I'm a software engineer at MY.GAMES. In this article, we'll discuss the differences between WebGL and the upcoming WebGPU, and we'll lay out how to prepare your project for migration. Content Overview Timeline of WebGL and WebGPU The current state of WebGPU, and what's to come High-level Conceptual Differences Initialization • WebGL: The Context Model • WebGPU: The Device Model Programs and Pipelines • WebGL: Program • WebGPU: Pipeline Uniforms • Uniforms in WebGL 1 • Uniforms in WebGL 2 • Uniforms in WebGPU Shaders • Shader Language: GLSL vs WGSL • Comparison of Data Types • Structures • Function Declarations • Built-in functions • Shader Conversion Convention Differences Textures • Viewport Space • Clip Spaces WebGPU Tips & Tricks • Minimize the number of pipelines you use. • Create pipelines in advance • Use RenderBundles Summary Timeline of WebGL and WebGPU , like many other web technologies, has roots that stretch back quite far into the past. To understand the dynamics and motivation behind the move towards WebGPU, it's helpful to first take a quick look at the history of WebGL development: WebGL The desktop version of OpenGL debuts. OpenGL desktop (1993) : This was the first stable release of WebGL, based on OpenGL ES 2.0, which was itself introduced in 2007. It provided web developers with the ability to use 3D graphics directly in browsers, without the need for additional plugins. WebGL 1.0 (2011) : Introduced six years after the first version, WebGL 2.0 was based on OpenGL ES 3.0 (2012). This version brought with it a number of improvements and new capabilities, making 3D graphics on the web even more powerful. WebGL 2.0 (2017) In recent years, there has been a surge of interest in new graphics APIs that provide developers with more control and flexibility: : Created by the Khronos group, this cross-platform API is the "successor" to OpenGL. Vulkan provides lower-level access to graphics hardware resources, allowing for high-performance applications with better control over graphics hardware. Vulkan (2016) : This API was created by Microsoft and is exclusively for Windows and Xbox. D3D12 is the successor to D3D10/11 and provides developers with deeper control over graphics resources. D3D12 (2015) : Created by Apple, Metal is an exclusive API for Apple devices. It was designed with maximum performance on Apple hardware in mind. Metal (2014) The current state of WebGPU, and what's to come Today, WebGPU is available on multiple platforms such as Windows, Mac, and ChromeOS through the Google Chrome and Microsoft Edge browsers, starting with version 113. Support for Linux and Android is expected in the near future. Here are some of the engines that already support (or offer experimental support) for WebGPU: : Full support for WebGPU. Babylon JS : Experimental support at the moment. ThreeJS : In development, but with very promising prospects. PlayCanvas : Very early and experimental WebGPU support was announced in version 2023.2 alpha. Unity : Officially supports WebGPU, making it one of the pioneers in this area. Cocos Creator 3.6.2 : currently supported in v113+ for Windows, macOS, and ChromeOS only. Construct Considering this, transitioning to WebGPU or at least preparing projects for such a transition appears to be a timely step in the near future. High-level Conceptual Differences Let's zoom out and take a look at some of the high-level conceptual differences between WebGL and WebGPU, starting with initialization. Initialization When starting to work with graphics APIs, one of the first steps is to initialize the main object for interaction. This process differs between WebGL and WebGPU, with some peculiarities for both systems. WebGL: The Context Model In WebGL, this object is known as "context", which essentially represents an interface for drawing on an HTML5 canvas element. Obtaining this context is quite simple: const gl = canvas.getContext('webgl'); The context of WebGL is actually tied to a specific canvas. This means that if you need to render on multiple canvases, you will need multiple contexts. WebGPU: The Device Model WebGPU introduces a new concept called "device". This device represents a GPU abstraction that you will interact with. The initialization process is a bit more complex than in WebGL, but it provides more flexibility: const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const context = canvas.getContext('webgpu');
context.configure({
   device,
   format: 'bgra8unorm',
}); One of the advantages of this model is that one device can render on multiple canvases or even none. This provides additional flexibility; for example, one device may control rendering in multiple windows or contexts. Programs and Pipelines WebGL and WebGPU represent different approaches to managing and organizing the graphics pipeline. WebGL: Program In WebGL, the main focus is on the shader program. The program combines vertex and fragment shaders, defining how vertices should be transformed and how each pixel should be colored. const program = gl.createProgram();
gl.attachShader(program, vertShader);
gl.attachShader(program, fragShader);
gl.bindAttribLocation(program, 'position', 0);
gl.linkProgram(program); Steps for creating a program in WebGL: : The source code for shaders is written and compiled. Creating Shaders : Compiled shaders are attached to the program and then linked. Creating Program : The program is activated before rendering. Using Program : Data is transmitted to the activated program. Data Transmission This process allows for flexible graphics control, but can also be complex and prone to errors, especially for large and complex projects. WebGPU: Pipeline WebGPU introduces the concept of a "pipeline" instead of a separate program. This pipeline combines not only shaders but also other information, which in WebGL, is established as states. So, creating a pipeline in WebGPU looks more complex: const pipeline = device.createRenderPipeline({
 layout: 'auto',
 vertex: {
   module: shaderModule, entryPoint: 'vertexMain',
   buffers: [{
     arrayStride: 12,
     attributes: [{
       shaderLocation: 0, offset: 0, format: 'float32x3'
     }]
   }],
 },
 fragment: {
   module: shaderModule, entryPoint: 'fragmentMain',
   targets: [{ format, }],
 },
}); Steps to create a pipeline in WebGPU: : The shader source code is written and compiled, similar to how it's done in WebGL. Shader definition : Shaders and other rendering parameters are combined into a pipeline. Pipeline creation : The pipeline is activated before rendering. Pipeline usage While WebGL separates each aspect of rendering, WebGPU tries to encapsulate more aspects into a single object, making the system more modular and flexible. Instead of separately managing shaders and rendering states, as is done in WebGL, WebGPU combines everything into one pipeline object. This makes the process more predictable and less prone to errors: Uniforms Uniform variables provide constant data that is available to all shader instances. Uniforms in WebGL 1 In basic WebGL, we have the ability to set variables directly through API calls. uniform : GLSL uniform vec3 u_LightPos;
uniform vec3 u_LightDir;
uniform vec3 u_LightColor; : JavaScript const location = gl.getUniformLocation(p, "u_LightPos");
gl.uniform3fv(location, [100, 300, 500]); This method is simple, but requires multiple API calls for each variable. uniform Uniforms in WebGL 2 With the arrival of WebGL 2, we now have the ability to group variables into buffers. Although you can still use separate uniform shaders, a better option is to group different uniforms into a larger structure using uniform buffers. Then you send all this uniform data to the GPU at once, similar to how you can load a vertex buffer in WebGL 1. This has several performance advantages, such as reducing API calls and being closer to how modern GPUs work. uniform : GLSL layout(std140) uniform ub_Params {
   vec4 u_LightPos;
   vec4 u_LightDir;
   vec4 u_LightColor;
}; : JavaScript gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, gl.createBuffer()); To bind subsets of a large uniform buffer in WebGL 2, you can use a special API call known as . In WebGPU, there is something similar called dynamic uniform buffer offsets where you can pass a list of offsets when calling the API. bindBufferRange setBindGroup Uniforms in WebGPU WebGPU offers us an even better method. In this context, individual variables are no longer supported, and work is done exclusively through buffers. uniform uniform : WGSL [[block]] struct Params {
   u_LightPos : vec4<f32>;
   u_LightColor : vec4<f32>;
   u_LightDirection : vec4<f32>;
};
[[group(0), binding(0)]] var<uniform> ub_Params : Params; : JavaScript const buffer = device.createBuffer({
  usage: GPUBufferUsage.UNIFORM,
  size: 8
}); Modern GPUs prefer data to be loaded in one large block, rather than many small ones. Instead of recreating and rebinding small buffers each time, consider creating one large buffer and using different parts of it for different draw calls. This approach can significantly increase performance. WebGL is more imperative, resetting global state with each call, and striving to be as simple as possible. WebGPU, on the other hand, aims to be more object-oriented and focused on resource reuse, which leads to efficiency. Transitioning from WebGL to WebGPU may seem difficult due to differences in methods. However, starting with a transition to WebGL 2 as an intermediate step can simplify your life. Shaders Migrating from WebGL to WebGPU requires changes not only in the API, but also in shaders. The WGSL specification is designed to make this transition smooth and intuitive, while maintaining efficiency and performance for modern GPUs. Shader Language: GLSL vs WGSL WGSL is designed to be a bridge between WebGPU and native graphics APIs. Compared to GLSL, WGSL looks a bit more verbose, but the structure remains familiar. Here's an example shader for texture: : GLSL sampler2D myTexture;
varying vec2 vTexCoord;
void main() {
  return texture(myTexture, vTexCoord);
} : WGSL [[group(0), binding(0)]] var mySampler: sampler;
[[group(0), binding(1)]] var myTexture: texture_2d<f32>;
[[stage(fragment)]]
fn main([[location(0)]] vTexCoord: vec2<f32>) -> [[location(0)]] vec4<f32> {
  return textureSample(myTexture, mySampler, vTexCoord);
} Comparison of Data Types The table below shows a comparison of the basic and matrix data types in GLSL and WGSL: Transitioning from GLSL to WGSL demonstrates a desire for stricter typing and explicit definition of data sizes, which can improve code readability and reduce the likelihood of errors. Structures The syntax for declaring structures has also changed: GLSL: struct Light {
  vec3 position;
  vec4 color;
  float attenuation;
  vec3 direction;
  float innerAngle;
  float angle;
  float range;
}; WGSL: struct Light {
  position: vec3<f32>,
  color: vec4<f32>,
  attenuation: f32,
  direction: vec3<f32>,
  innerAngle: f32,
  angle: f32,
  range: f32,
}; Introducing explicit syntax for declaring fields in WGSL structures emphasizes the desire for greater clarity and simplifies understanding of data structures in shaders. Function Declarations : GLSL float saturate(float x) {
	return clamp(x, 0.0, 1.0);
} : WGSL fn saturate(x: f32) -> f32 {
  return clamp(x, 0.0, 1.0);
} Changing the syntax of functions in WGSL reflects the unification of the approach to declarations and return values, making the code more consistent and predictable. Built-in functions In WGSL, many built-in GLSL functions have been renamed or replaced. For example: Renaming built-in functions in WGSL not only simplifies their names, but also makes them more intuitive, which can facilitate the transition process for developers familiar with other graphics APIs. Shader Conversion For those who are planning to convert their projects from WebGL to WebGPU, it's important to know that there are tools for automatically converting GLSL to WGSL, such as **[Naga](https://github.com/gfx-rs/naga/)**, which is a Rust library for converting GLSL to WGSL. It can even work right in your browser with the help of WebAssembly. Here are Naga supported end-points: Convention Differences Textures After migration, you may encounter a surprise in the form of flipped images. Those who have ever ported applications from OpenGL to Direct3D (or vice versa) have already faced this classic problem. In the context of OpenGL and WebGL, textures are usually loaded in such a way that the starting pixel corresponds to the bottom left corner. However, in practice, many developers load images starting from the top left corner, which leads to the flipped image error. Nevertheless, this error can be compensated by other factors, ultimately leveling out the problem. Unlike OpenGL, systems such as Direct3D and Metal traditionally use the upper-left corner as the starting point for textures. Considering that this approach seems to be the most intuitive for many developers, the creators of WebGPU decided to follow this practice. Viewport Space If your WebGL code selects pixels from the frame buffer, be prepared for the fact that WebGPU uses a different coordinate system. You may need to apply a simple "y = 1.0 - y" operation to correct the coordinates. Clip Spaces When a developer faces a problem where objects are clipped or disappear earlier than expected, this is often related to differences in the depth domain. There's a difference between WebGL and WebGPU in how they define the depth range of the clip space. While WebGL uses a range from -1 to 1, WebGPU uses a range from 0 to 1, similar to other graphics APIs such as Direct3D, Metal, and Vulkan. This decision was made due to several advantages of using a range from 0 to 1 that were identified while working with other graphics APIs. The main responsibility for transforming your model's positions into clip space lies with the projection matrix. The simplest way to adapt your code is to ensure that your projection matrix outputs results in the range of 0 to 1. For those using libraries such as gl-matrix, there is a simple solution: instead of using the function, you can use ; similar functions are available for other matrix operations. perspective perspectiveZO if (webGPU) {
	// Creates a matrix for a symetric perspective-view frustum
  // using left-handed coordinates
  mat4.perspectiveZO(out, Math.PI / 4, ...);
} else {
  // Creates a matrix for a symetric perspective-view frustum
  // based on the default handedness and default near
  // and far clip planes definition.
  mat4.perspective(out, Math.PI / 4, …);
} However, sometimes you may have an existing projection matrix and you can't change its source. In this case, to transform it into a range from 0 to 1, you can pre-multiply your projection matrix by another matrix that corrects the depth range. WebGPU Tips & Tricks Now, let's discuss some tips and tricks for working with WebGPU. Minimize the number of pipelines you use. The more pipelines you use, the more state switching you have, and the less performance; this may not be trivial, depending on where your assets come from. Create pipelines in advance Creating a pipeline and using it immediately may work, but this is not recommended. Instead, create functions that return immediately and start working on a different thread. When you use the pipeline, the execution queue needs to wait for pending pipeline creations to finish. This can result in significant performance issues. To avoid this, make sure to leave some time between creating the pipeline and first using it. Or, even better, use the variants! The promise resolves when the pipeline is ready to use, without any stalling. create*PipelineAsync device.createComputePipelineAsync({
 compute: {
   module: shaderModule,
   entryPoint: 'computeMain'
 }
}).then((pipeline) => {
  const commandEncoder = device.createCommandEncoder();
  const passEncoder = commandEncoder.beginComputePass();
  passEncoder.setPipeline(pipeline);
  passEncoder.setBindGroup(0, bindGroup);
  passEncoder.dispatchWorkgroups(128);
  passEncoder.end();
  device.queue.submit([commandEncoder.finish()]);
}); Use RenderBundles Render bundles are pre-recorded, partial, reusable render passes. They can contain most rendering commands (except for things like setting the viewport) and can be "replayed" as part of an actual render pass later on. const renderPass = encoder.beginRenderPass(descriptor);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.executeBundles([renderBundle]);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.end(); Render bundles can be executed alongside regular render pass commands. The render pass state is reset to defaults before and after every bundle execution. This is primarily done to reduce the JavaScript overhead of drawing. GPU performance remains the same regardless of the approach. Summary Transitioning to WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics, combining successful features and practices from various graphics APIs. This migration requires a thorough understanding of technical and philosophical changes, but the benefits are significant. Useful Resources & Links: WebGPU — All of the cores, none of the canvas From WebGL to WebGPU in Construct by Alain Galvan Raw WebGPU tutorial by Brandon Jones WebGPU Best Practices WebGL + WebGPU Meetup - July 2023 Link

Migrating from WebGL to WebGPU

WebGL থেকে WebGPU-তে স্থানান্তরিত হচ্ছে

Migration von WebGL zu WebGPU

Migrando de WebGL a WebGPU

Migration de WebGL vers WebGPU

WebGL से WebGPU पर माइग्रेट किया जा रहा है

WebGL から WebGPU への移行

WebGL에서 WebGPU로 마이그레이션

Migrando de WebGL para WebGPU

Переход с WebGL на WebGPU

WebGL'den WebGPU'ya geçiş

Di chuyển từ WebGL sang WebGPU

从 WebGL 迁移到 WebGPU

Hopefully, the title caught your attention. Is it real? Not yet. It's only 2023 :) But, a headline like this may be closer than you think. Let me tell you why I believe this is all but assured to happen. I have spent a lifetime developing games, graphics algorithms, and hardware and implementing AI in my games. was my main area of research during my CS and Math degrees and my lifelong passion. I have read about it, written about it, developed it, made money from it, and watched AI grow over the years. I have watched the fads come and go. People thought that neural nets would change the world, then dismissed them as nothing more than simplistic linear algebra operations masquerading as some sort of model of how living organisms solve problems, learn and " " and in the case of humans exhibit self-awareness, consciousness -- whatever that is... AI think Then the world of AI was set afire by a real problem to solve -- email! Then it was all about , then shortly thereafter, we all wanted chatbots, so or natural language processing became all the rage. But, I for one, have always put my faith in neural nets. From the first time I read the paper as a teenager by which outlined the idea of artificial neurons, and the mathematical basis for them. I was hooked. SPAM Bayesian Filters NLP McCulloch and Pitts 1943, "A Logical Calculus of the Ideas Immanent in Nervous Activity" Over the years, as I developed games, I would try and use NNs (neural nets) anywhere I could. To me, they naturally mirrored the biological wet-ware brains of humans. A network of interconnected neurons that could signal each other. The signaling could cause other neurons to " " or be " ". The mathematical representation simplified much of the organic evolutionary processes that resulted in our current biological neurons. Instead of pulsating electrochemical ion signaling across connections (synapses), McCulloch Pitts modeled the neurons as simple summation functions, each neuron has a number of inputs, these inputs have weights, then the final sum is computed and the output is feed through a final function to allow for non-linear functional mappings. fire suppressed All of this seemed exactly right to me, evolution isn't clever, in fact, its very frugal and brute force, it wants to solve a problem and then be done with it, it may be elegant, or messy, but it finds a way to do it with the least amount of fuss. The artificial neurons in McCulloch Pitts paper seemed to me to be more than enough to build a "brain". A brain that could learn by programming the weights, a brain that could predict, find subtle differences no human could discern, and would be the basis some day for an " " machine or AI. Then couple this with the ideas of and imagine neural nets each competing, having offspring, oh my, made my head spin. intelligent genetic algorithms But, I would have to wait... I would wait decades before we would reach the computational horsepower, memory requirements, and the shear amount of training data needed to make the dream of a truly intelligent artificial intelligence, one that could pass the , one that was smarter than us. Turing test And then as if out of nowhere it happened... At first, I was skeptical, I knew it would happen, should happen, could happen, but no one seemed to have the right recipe to make a quantum leap in the field until now. Well, a few years ago-ish. I won't bore you with the details, but the model and idea of are outlined here in this paper for those with the math chops to follow: Generative Pre-Trained Transformer attention https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf?embedable=true But, the bottom line is before this idea, it was very hard to create a system that could predict the next token, idea, or element in a sequence. In other words, given a set of tokens, what is the most likely next token in the sequence given a desired context? This is a really hard problem to solve and is harder the longer you want to maintain any kind of coherence to the predictions as they proceed. Now, let's skip forward a moment to now. We have all heard of and these new (large language models), and many of you have even played with them and may have started new companies based on them. But, I am here to tell you my story of using ChatGPT colored by decades of watching computer science advance from 8-bit microprocessors to quantum computers. And in all that time, countless tools have been developed that the industry thought would not only disrupt the industry but put programmers out of business. ChatGPT LLMs For example, when the transition was made from assembly language programming to high-level languages and compilers, everyone thought that " " programmers would no longer be needed. And then when graphical drag-and-drop IDEs came out, again, pundits warned this would put programmers out of business. And the list goes on and on. real However, and I say this with a very serious tone and trepidation, in the past, all those tools were not " " and surely . But, I am afraid to say, that ChatGPT and similar LLMs , it's as simple as that. intelligent not smarter than their makers are smarter than us And they are doing a lot more than text prediction, they are intelligent in my opinion, creative, and can be interacted with as you would a human. I know because I have been playing with LLMs for years, and ChatGPT for last year almost every day developing a course on (more on that later). But, the conclusion I have come to is that ChatGPT is intelligent, it is sentient (as if we know what that means.) I don't believe it is self-aware. It's just data and enormous amounts of computing. But still, in the same way a fruit fly is intelligent, or a honey bee, or a colony of ants, ChatGPT . Who cares if it isn't self-aware or sentient? Put it in the flight controller of an F-22 and you better not be in the same airspace, it would win in a dogfight! Game Development with AI not is intelligent Now, in the last year, my goal was to develop a new course on udemy about . I wanted to see if I could really use ChatGPT to create working games from text prompts. I worked with this AI for 100s of hours, going back and forth as if it was a colleague or intern (with a genius-level IQ), and I have to say that I literally can't believe the results. ChatGPT not only exhibits intelligence, but it has a sense of humor, it knows when it makes mistakes, and it gets confused, but it ultimately passed the with flying colors. It was able to create working games that no human could have made as fast, they worked and played, and aside from the block graphics and placeholders for sounds and music (which will be remedied in months to a year I suspect with add-ons to ChatGPT 4.0 or version 5.0), the games only required me to skin them with graphics, clean them up, add some final touches and they worked. Game Development with JavaScript and AI programming Turing test It took about 6 months for me to finish the course which just launched on udemy (link below): "Fast and Furious Game Development with JavaScript and AI" https://www.udemy.com/course/fast-and-furious-game-development-with-javascript-and-ai/?couponCode=DNSTUFF In the course, I teach , CSS, and from the ground up (for beginners) then we cover graphics and game dev and finish the course by collaborating in real-time with ChatGPT to create over half a dozen games. Some example images below from the games: HTML JavaScript Conclusions and Predictions Never predict anything, and you will never be wrong. But, in this case, I am fairly sure I am not predicting anything. AI has momentum, and inertia now. I have played with these LLMs for years, and ChatGPT since its launch about a year ago and in that short time, I can clearly see the trend. What I predict is going to happen is a number of punctuated milestones in the field. In the area relating to the title of this article. I am 99% certain that within 1-2 years, ChatGPT will be able not only to write the code for a game 10X more complex than Space Invaders (which I was able to get it to pull off), but ChatGPT will be able to use either pre-sourced art, sounds, music we provide or generate all of it on the fly and use it as assets for a game. I predict that tools and plugins for Unity and Unreal will have the ability to leverage AI to allow "game designers" to literally not write a line of code, drag an object, put down a single pixel, but to act as "directors" instructing the AI to make changes, try this, that, and the other, and all at a breakneck pace and result in a complete game built by a single person with the help of an AI. I suspect this will be the same in many industries, AI will start doing the heavy lifting and humans will be the puppet masters. But, all good things will come to an end, and when these AIs are 10, 100, 1000, a million times bigger, faster and smarter does it matter if they are sentient? Does it matter if we don't think they are? The bottom line is that these super intelligences will be able to do things humans couldn't do in 1000 years let alone understand. We will see what happens :) But, in the meantime, if you want to see the first moments of this evolution and a real-world example of an AI making real games check out my "Fast and Furious Game Development with JavaScript and AI". And thanks for stopping by to check out this article. udemy course Also published here.

AI Will Put Programmers out of Work in 2025

Is a Career in Game Development Right for You? 

গেম ডেভেলপমেন্টে ক্যারিয়ার কি আপনার জন্য সঠিক?

Ist eine Karriere in der Spieleentwicklung das Richtige für Sie?

¿Es adecuada para usted una carrera en desarrollo de juegos?

Une carrière dans le développement de jeux est-elle faite pour vous ?

क्या गेम डेवलपमेंट में करियर आपके लिए सही है?

ゲーム開発のキャリアはあなたに適していますか?

게임 개발 경력이 당신에게 적합합니까?

Uma carreira em desenvolvimento de jogos é ideal para você?

Подходит ли вам карьера в разработке игр?

Oyun Geliştirmede Kariyer Size Uygun mu?

Nghề phát triển trò chơi có phù hợp với bạn không?

游戏开发职业适合您吗？

In multiplayer games, clients need to be synced. It's possible to exchange data packets directly from your transport, but this can be complex for devs with little experience. So, let's look at some ready-made networking solutions for all sorts of use cases. Hello! I'm Dmitrii Ivashchenko, a Lead Software Engineer at MY.GAMES. Our series of articles about the Unity realtime multiplayer landscape in 2023 continues! Today's topic concerns the ready-made solutions for real-time multiplayer that are available for us. Let's get started. A quick note on transports In multiplayer games, servers and clients exchange data by sending packets over the network. In order to create a shared virtual space for players who are connecting from different locations, events in the game process (like character movements or object creation) are synchronized with other clients by sending them data packets. The responsible party for sending and receiving packets over the network is called the transport layer. It's theoretically possible to send these packets by directly calling the send functions of your transport, this approach can quickly become inconvenient for developers who have little experience working with multiplayer games. So, it's a better idea to use one of those listed below, stead of writing your own from scratch. Let's look at those solutions. Unity Relay & Netcode Unity offers two Netcode packages: Netcode for GameObjects (in the preview release stage), Netcode for Entities (in experimental mode), and the deprecated UNET. It also provides the Unity Relay service to connect game clients — let's touch on that now. Unity Relay Unity Relay is a for game developers to provide enhanced connectivity between players via a join code mechanism, without the need for investing in third-party solutions, maintaining dedicated game servers (DGS), or worrying about network complexities in multiplayer games. Instead of using DGS, the Relay service provides connectivity through a universal Relay server, acting as a proxy. way The Relay service allows players to communicate over several different protocols, including UDP, DTLS, and secure WebSocket (WSS). After selecting a Relay server, clients communicate directly with the Relay server using one of the aforementioned protocols. WebSocket connections allow for multiplayer connectivity in browsers using WebGL. Relay supports working with any game engine. If you are using Relay with Unity, it's a best practice to use the Relay SDK, which is integrated with the Unity Transport Package (UTP). Unity Transport Package Unity Transport is a low-level for developing multiplayer games. It Netcode for GameObjects and Netcode for Entities, but you can also use it with your solution. networking library underpins Unity Transport effortlessly supports all of the platforms supported by Unity Engine, thanks to a connection-based abstraction layer (built-in network driver) provided on top of UDP and WebSockets. You can configure UDP and WebSockets with or without encryption. You can also use pipelines to get additional functionality such as reliability, packet ordering, and packet fragmentation. The main features of Transport 2.0 include added support for WebGL; this allows the Unity Transport package to be used on all supported platforms of Unity Engine. Transport users now have access to our implementation of Websocket transport, with or without TLS. Players on the move can now take advantage of transparent network migration, typically between cellular towers. This feature is currently limited to the client side and for UDP transport. To work with Unity Transport, you need to install Unity Editor version 2022.2 or later and also install package. com.unity.transport Relay works with Unity Transport (UTP), which allows clients to connect that otherwise wouldn't be able to communicate due to routing restrictions, such as strict firewalls. Unity Relay Limitations Relay has the following limitations: There is currently no region-locking functionality; anyone can request allocation in any region if there is enough capacity to serve the request. The Relay service routes all traffic through one selected host region. As a result, inter-regional communication may not provide optimal latency. A maximum of 100 players can join a host within a single game session. The Relay service uses rate limiting to control network traffic by limiting the number of requests received by the API within any given second. For "Create allocation", "Create join code", "Join a Relay" and "List regions" requests, a limit of 60 requests per minute is set. The limit is applied to each authenticated player. Despite the limitations, the Relay service is a powerful tool for simplifying player connectivity and providing a smooth multiplayer gaming experience. Netcode for GameObjects Two of the most popular solutions for Relay's main game network code include Netcode for GameObjects (NGO) and API Mirror Networking. The recommended best practice is to use NGO (in most cases) because it offers a stable set of core features such as network variables, scene management, remote procedure calls (RPCs), and messaging. However, with its simplicity and ease of use, API Mirror Networking is also great for games that don't require the complete set of features provided by NGO. Photon Realtime Photon Realtime is the for multiplayer games (and more complex network solutions from Photon). It deals with problems like player matchmaking and fast communication using a scalable approach. Photon Realtime is used both in games and in more specific multiplayer solutions. core layer Photon Realtime does not include game state and simulation synchronization mechanisms like those found in Fusion or Quantum solutions, but instead focuses on message transport over the network. The term Photon Realtime also encompasses our extensive framework of APIs, tools, and services, defining the interaction between clients and servers. All Photon Realtime clients connect to a sequence of dedicated servers, divided into three distinct tasks: authentication and regional distribution (Name Server), player matching (Master Server), and gameplay (Game Server). All of these servers are managed through the Realtime API, so you don't need to worry about them — although knowledge of them can certainly be helpful. Photon Cloud is a fully-managed service that provides global hosting for Photon Realtime clients. The game code communicates with Photon Cloud, connecting to the cloud, and using its API to perform actions such as connection, joining a random room, or raising events. In Photon Realtime, room data can be easily saved and loaded, and webhooks can be set up to connect Photon Cloud with an external web server. Photon Fusion Photon Fusion is a new for network state synchronization for Unity. It supports two fundamentally different network topologies and a mode for one player without a network connection using a single API. high-performance library Fusion is designed with simplicity in mind for integration into the Unity workflow, and offers advanced features such as data compression, client-side prediction, and delay compensation "out of the box". In Fusion, for example, RPC and network state are defined by attributes on methods and properties, without the need for explicit serialization code, and network objects can be defined as prefabs, using all the latest Unity prefab features. MonoBehaviour Fusion uses a modern compression algorithm to reduce bandwidth requirements with minimal overhead on the processor. Data is sent either as full compressed snapshots or as partial blocks with subsequent consistency achieved. In the latter case, a fully customizable interest area system is provided, allowing for very large player counts. Fusion implements tick-based simulation and operates either in Shared mode or Host mode. The main difference is who has authority over network objects, but this in turn determines which other SDK features are available. Fusion was developed to replace two existing Photon products for Unity (Bolt and PUN). The important core components of Fusion are and . can be considered as the core of Fusion - there is one runner in the scene that manages network operations and simulation. NetworkRunner NetworkObject NetworkRunner Fusion offers various pre-built for fast game or prototype creation. NetworkBehaviours Fusion separates input processing into two steps: collecting input from local hardware and placing it into a structure, then reading that input to change the game state (advancing the simulation). Fusion supports RPC (Remote Procedure Calls) for cases where standard Fusion input or use of properties is not the most practical solution. To get started with Fusion, we recommend the Fusion Getting Started Guide. [Networked] studying Photon Quantum Photon Quantum is a for multiplayer games. It's based on the prediction/rollback approach, which is perfect for online games that are sensitive to delays, such as action RPGs, sports games, fighting games, FPS, and so on. fully deterministic engine When using this engine, there is no need for netcode; all game elements are networked by default and 100% synchronized. You just need to create one simulation with multiple connected players, as when developing a local multiplayer experience. Quantum's deterministic subsystems ensure that simulations on each client are always synchronized and without delays, including: physics, bots, pathfinding, animation. Deterministic games are inherently resistant to cheating. The fight against cheaters is carried out by checking replays or server-judge simulations (the most effective anti-cheating measure). Player input is sent to the Photon Cloud servers and is then distributed among the other players. Webhooks can be used to connect your own backend and plugins for executing custom code on the server side. Photon Quantum is built on an ECS architecture, and high performance is claimed for running even physically intensive multiplayer games on PC, consoles, VR, and mobile phones. Simulations encoded in Quantum have no dependencies on Unity and can run anywhere. All local actions are performed without delay, and remote inputs are predicted and rolled back. Quantum has the ability to view replays. Replays can be saved on the backend or used in-game. To get started, you can the Quantum 100 series. check out Normcore Normcore is a for adding a multiplayer mode to any Unity-based project. Normcore includes network physics, persistent spaces, voice chat, and XR support. high-performance tool Normcore automatically synchronizes all object transformations when you add the component to it. This doesn't require any coding. Additionally, Normcore offers state-dependent interpolation and reliable network physics for perfect movement in any connection. RealtimeTransform One of the key advantages of Normcore is its fast data transport based on WebRTC. It uses the maximum packet size that does not cause fragmentation during transmission, which speeds up the data transfer process. All data packets in Normcore are encrypted by default, ensuring the security and confidentiality of user data. Normcore also uses a delta update system. This means that it tracks all changes since the last packet was sent, and when it's time to send a new packet, it already knows what to include in it. This saves resources and improves performance. Data serialization features in Normcore allow for CPU usage optimization. All serialization code is automatically generated prior to project compilation, ensuring fast and efficient resource usage. Normcore servers operate in regions worldwide and are connected through a private fiber optic network, which provides low latency. You can host Normcore on your own servers or allow Normcore to host a private copy of our cloud infrastructure for you. Mirror Mirror Networking is a for Unity, optimized for ease of use and reliability. This library is designed to simplify the process of working with network connections, allowing developers to focus on creating their projects. high-level network library Mirror Networking is compatible with over a dozen low-level protocols and constantly evolves and improves. It includes features for remote procedure calls and context management over the network and also supports working with physics in networked applications. The library offers over a dozen built-in network adapters and five network management system options, allowing developers to create custom versions. Several complete usage examples are also included to facilitate the learning and coding process. Nakama Nakama by Heroic Labs is a open-source game server that allows you to own your entire infrastructure in one open package. Nakama includes all the necessary real-time gaming APIs and social and competitive features. popular Equipped with all the necessary features for your game, such as real-time multiplayer and social and competitive functions, Nakama allows you to customize all aspects both on the client and server-side using Go, TypeScript, and Lua. With Nakama, you can create real-time multiplayer competitive games, customize matchmaking algorithms, add daily rewards, create leaderboards, implement in-game currencies, and provide real-time chat. FishNet Fish-Networking is a free, open-source library for networking solutions in Unity, developed by an experienced game designer. It offers an extensive set of features that are usually only available with paid solutions. The main advantages of Fish-Networking are bandwidth and resource optimization (which can save on server costs), support for a large number of players (from dozens to hundreds), and built-in features such as client prediction, latency compensation, server load balancing, and support for nested network objects. An overview of the solutions The following table provides an overview of various network solutions for game development on Unity, comparing them by the protocols used, supported topologies, maximum number of players per session, the minimum supported Unity version and current status as of mid-2023. Solution Protocols Topologies Max. players per session Min Unity version Status Netcode for Entities UDP, WebSockets Unity Relay, P2P, Client hosted, DGS 100 (Limitation of Unity Relay) 2022.3 🧪 Experimental Netcode for GameObjects UDP, WebSockets Relay (over Unity Relay), P2P, Client hosted, DGS 100 (Limitation of Unity Relay) 2021.3 ℹ️ Pre-Release Photon Realtime Reliable UDP, TCP, HTTP or WebSockets Relay (over Photon Cloud), DGS 32 2018.4 ✅ Production Ready Photon Fusion TCP, RUDP, WebSockets Relay (over Photon Cloud), P2P, Client hosted, DGS 200 2020.3 ✅ Production Ready Photon Quantum RUDP Relay (over Photon Cloud) 32 2018.4 ✅ Production Ready Normcore over UDP and TCP WebRTC Relay (over Normcore Cloud) 100 2020 LTS ✅ Production Ready Mirror Networking , WebSockets KCP Client hosted, DGS, P2P, Relay 200 2020 LTS ✅ Production Ready Nakama RUDP , , Client hosted Relay Authoritative Limited by server performance 2018.4 ✅ Production Ready FishNet RUDP, WebSockets Relay, P2P, DGS 200 2019.4 ✅ Production Ready Photon PUN UDP, TCP, WebSockets DGS, Relay, P2P, Client hosted 32 2019.4 ⚠️ Deprecated Photon BOLT UDP, TCP P2P, DGS 50 2019.4 ⚠️ Deprecated UNET TCP, UDP Client hosted, DGS Limited by server performance 5.1 ⚠️ Deprecated The variety of the available solutions allow developers to choose a tool that fits their specific needs. Many solutions support different types of topologies, which allows them to be adapted to the specific requirements of a game. Some of the old network solutions, such as Photon PUN, Photon BOLT, and UNET, are outdated and not recommended for use in new projects, while Netcode for Entities and Netcode for GameObjects are still in the experimental or pre-release stage, which also does not yet allow them to be used for production.

Unity Realtime Multiplayer, Part 8: Exploring Ready-Made Networking Solutions

Multijugador en tiempo real de Unity, Parte 8: Exploración de soluciones de red listas para usar

Unity Realtime Multiplayer, Partie 8 : Explorer des solutions réseau prêtes à l'emploi

यूनिटी रीयलटाइम मल्टीप्लेयर, भाग 8: रेडी-मेड नेटवर्किंग समाधानों की खोज

Unity リアルタイム マルチプレイヤー、パート 8: 既製のネットワーキング ソリューションの探索

Unity Realtime Multiplayer, Parte 8: Explorando soluções de rede prontas

Unity Realtime Multiplayer, Phần 8: Khám phá các giải pháp mạng có sẵn

Unity 实时多人游戏，第 8 部分：探索现成的网络解决方案

Stories, News & Mentions about MYGAMES

Mygames’s Stories on HackerNoon

Mygames's News & Mentions