DEV Community: Wen Jun

Telegram Games: An Intermediate Guide

Wen Jun — Mon, 01 Aug 2022 06:07:57 +0000

I recently created a game on Telegram. This was not my first Telegram bot, but it would be my first game. Hence, I first checked the official Telegram documentation for their gaming platform.

While reading it, I felt it was rather skimpy on the details. I also wished they would link to the bot API documentation directly, so that I could see the exact objects, methods and fields involved.

This guide is meant to provide slightly more details (and useful links) than the existing documentation, but is not meant to be a step-by-step guide. It is language-agnostic so that you can apply these concepts regardless of which language you choose to write your bot and game in.

Creating a Game

Create a Telegram Bot using /newbot on @BotFather
Enable inline mode for the bot using /setinline
Create a new game using /newgame

After this process, you will have your bot token and your game_short_name, which will be used later.

Launching the Game

Here's what the documentation says:

Once the game is created, your bot can send it to chats as regular messages, or offer them via inline mode.

Let's break that down.

It may help to read about inline mode and callback buttons first.

Sending games to chats as regular messages

For example, you could have the bot respond to the /start command (or any other command/phrase of your choice) by sending the game.

Here's a sequence diagram for what goes on behind the scenes.

The user initiates the conversation with your chosen phrase
Your bot will receive a Message object containing the message that was sent
You may respond using the sendGame API, which is fairly straightforward as the only required fields are chat_id and game_short_name (from the set up process)
The bot sends a message with the game and a "Play Game Name" callback button

Next, the callback interactions occur.

The user clicks on "Play Game Name"
Telegram sends a CallbackQuery with game_short_name to your bot
Your bot calls answerCallbackQuery with a url to the game
Telegram opens the url to the game

Offering games via inline mode

This was the part that confused me the most.

Here is the equivalent sequence diagram for the interactions between the user, Telegram and your bot.

The user initiates the interaction by typing "@your_bot_username" in any chat
Telegram sends an InlineQuery to your bot
Your bot calls answerInlineQuery with an array of InlineQueryResultGame
Telegram displays the results to the user
The user selects a game from the list
The user sends a message (via your bot) the game and a "Play Game Name" callback button.

The remaining flow for launching the game via callback interactions is the same as before.

Conclusion

This guide provides more elaboration on the interactions between the user, Telegram and your bot when launching a game.

An interesting difference between these two methods is that in the first, the bot is the one who sends the message containing the game. In the second, the user who initiated the inline query is the one who sends the game. This is because the bot may not be a part of the group chat (as it is an inline interaction).

Hope this guide helped you, and happy coding!

What I learnt from Advent of Code 2021

Wen Jun — Sun, 26 Dec 2021 03:30:20 +0000

Advent of Code (AoC) is a yearly coding challenge in the form of an Advent calendar. Every day from Dec 1 to 25, a small programming puzzle is released and hundreds of thousands of people attempt to solve the problems.

As this year’s Advent of Code comes to a close, I wanted to reflect on my AoC journey thus far.

I first attempted AoC in 2018. However, I was somewhat “under levelled” back then, as I did not have much experience in object-oriented programming or data structures and algorithms. Since then, I have accumulated much more experience and taken modules that helped refine my computational thinking and hone my programming skills. As a result, I was much better equipped to tackle the challenges this year and managed to achieve all 50 stars by Christmas.

Technical aspects

I found that the difficulty level of this year’s puzzles scaled somewhat linearly, which made for a very enjoyable experience. My friend and I remarked that "the difficulty creeps up on you, and you only realise how far you’ve come when you look back at your solutions from a week ago, or even a few days ago". From Dijkstra’s algorithm to the Inclusion-Exclusion Principle, I was certainly challenged technically.

For a more detailed rundown of notable problems, check out my other article: Notable problems from Advent of Code 2021.

Non-technical aspects

I found that I learned more in terms of non-technical aspects than technical ones.

It’s all about the community

My sister told me that her biggest mistake in university was “trying to do it alone”. I tend to be an individualist, but her advice resonated with me during this year’s AoC.

During the pandemic, I found it harder to feel a sense of belonging and it was something I craved. For example, I missed the feeling of being physically in the same room as my classmates at school.

After solving each problem, I would reward myself by visiting the AoC subreddit in search of memes, cool visualisations and other people’s solutions. Reading about everyone’s experience and approaches to the problems contributed greatly to me feeling like I belonged to a community of like-minded people.

It also helped that I had friends who were also participating in AoC. After we had independently solved the day’s problem, we would discuss and compare our approaches and code.

Dealing with imposter syndrome / fixed mindset

One issue I remember having in 2018 was imposter syndrome / having a fixed mindset. I’d struggle through the problems with my limited knowledge of data structures and algorithms, and then I’d come across a solution that was far cleverer or more efficient than mine. My response to this would be to berate myself with “Ah dang, why didn’t I think of that?”, when a more reasonable response would have been “I still have lots to learn. What principles can I pick up from this solution so that I may come up with something like this in future?”.

This year, I was able to come up with better solutions, although they were not the fastest, nor the shortest or the most elegant. Moreover, I was better able to deal with imposter syndrome and could switch to a growth mindset more easily, which is a testament to my personal growth since then. As a result, I could read about what others had done and learn from them.

Know your purpose

AoC is many different things to different people. Some do it to learn a new language, or just to practice. Others take a more competitive route and make use of features like the global leaderboard or the private leaderboard.

Although I had not decided what my purpose was when I first started AoC, I did eventually distil out a few points through some soul-searching during the last week.

I’m doing it:

For myself
For fun
To practise object-oriented principles
To practise writing good quality code

Equally importantly, I’m not doing it:

For the leaderboard
To get the fastest solution
To get the shortest solution
To compete with my friends

These principles guided my behaviour; I focused on writing clear, concise code that communicated the computational processes well.

In particular, “for fun” allowed me to make better decisions about when it was time to get some help. I did this on two occasions.

Day 22: Reactor Reboot

My approach for this day involved implementing functions based on the Inclusion-Exclusion Principle. After spending 3 hours implementing it, I realised a fundamental flaw in my algorithm. I suspected that my approach of using the inclusion-exclusion principle was not wrong, but I could not figure out how to fix or work around the flaw. I eventually checked the Reddit megathread and found someone who had used a similar approach. From that solution, I was able to understand the proper way to apply the principle to the problem. To make sure that I fully understood their solution, I re-implemented the algorithm without referring to their solution and was able to solve the problem.

Day 24: Arithmetic Logic Unit

This was a bizarre problem. I had re-implemented the ALU as the instructions seemed to imply I was supposed to but was faced with the prospect of having to brute force 9¹⁴ possible values. I tried reading the instructions in the puzzle input and running them by hand, but gave up after a few lines as I didn’t think it would lead me anywhere. This was my first time feeling completely lost on where to begin tackling a problem.

I was distinctly not having fun, and rather than continue bashing my head at the problem, I decided I could justify turning to Reddit for a hint. The first small hint did not help much, at which point I dived into the solutions megathread. This was a good move as it turned out that this problem required a great deal of reverse engineering, far more than I was expecting. I did eventually repeat the steps of reverse engineering on my own and write a script to solve the problem, just to prove to myself that I did understand it. I learned from other Reddit users that most years have at least one problem that requires reverse-engineering the puzzle input, so perhaps I will be better prepared next year, with this knowledge.

Beyond a certain point, the chances of me coming up with a solution on my own become rather slim. Turning to Reddit for help on these two days allowed me to keep AoC a fun experience (which was my purpose), rather than a painfully mind-bending one.

Closing Remarks

A month ago, I never would have thought I would finish all 25 days of AoC, (mostly) unscathed, and I’m very happy to have made it this far.

I am incredibly grateful to Eric for putting in the effort to create such a fantastic challenge for the AoC community every year. I learned a lot from the past month and, most importantly, had lots of fun while doing it. I will miss jumping out of bed in the morning to refactor my previous day’s code. Perhaps next year, I’ll attempt AoC 2022 using a new language (Clojure? Go? C?) / library (NumPy) I’ve always wanted to try or get better at.

That being said, I am glad it’s over. I could start to feel myself getting burnt out towards the end as I spent up to 6 hours a day stuck on the same problem. I look forward to a good break from AoC over the next few days.

Notable problems from Advent of Code 2021

Wen Jun — Sun, 26 Dec 2021 03:26:21 +0000

As this year’s Advent of Code comes to a close, I wanted to reflect on my AoC journey thus far.

These are some of the notable problems from this year.

(Top favourite) Day 16: Packet Decoder

This was by far my favourite problem. Although my solution was not the shortest, I used object-oriented principles/features like inheritance and abstract classes and was very pleased with how my abstractions turned out. I’ve heard that the 2019 Intcode problems were similar to this and I’m excited to work on them next!

(Most enlightening) Day 6: Lanternfish

This problem involved simulating a bunch of fish that would spawn new fish every 7 days. Like many others, my first instinct was to treat each Lanternfish as an individual entity (e.g. as a Python object) and iterate through an array of individual fish to spawn new fish. This worked fine for part 1 but not for part 2, which involved simulating more than 10¹² fish.

This was clearly not feasible and I was forced to try a new approach. I realised that each individual fish was not important and that I could group the fish based on the number of days until they next spawn a new fish. Hence, the only relevant piece of information was how many fish there were in each group. I was glad that I had arrived at this realisation all on my own, which made for a far more memorable learning experience compared to if someone had told me the trick directly.

This concept (stop trying to deal with things as individuals, group them and keep track of only the relevant aggregated information) seemed to be a recurring theme and it came in useful for Day 14: Extended Polymerisation (my solution) and Day 21: Dirac Dice (my solution). To this day, I remember this strategy as the “Lanternfish optimisation”.

Later, I discussed my solution with two other friends who were also doing AoC and we realised that we had each come up with a different solution to the problem. We had a blast ~~arguing about fish~~ explaining our solutions to each other and we learned a lot from the discussion.

(Most interesting) Day 8: Seven Segment Search

This problem involved spotting patterns in the given problem statement and devising an algorithm that could eliminate possibilities, finally narrowing down to the last one. This was not particularly difficult, but there were many different ways to approach the problem. Some methods were more complicated and painful to code than others, while others were simpler and more elegant. I was not particularly pleased with my first solution, so I picked a cool algorithm on Reddit and re-implemented it from scratch.

My main takeaway from this day was to identify the best/simplest algorithm on paper first, before starting to code. Perhaps if I had taken more time to look for the simplest pattern, I would have been able to come up with a simpler and more elegant solution on my own.

(Most interesting) Day 23: Amphipod

One challenge I had solving this problem was figuring out how to represent the problem in terms of code. I eventually treated it as a standard shortest path graph problem to be solved using Dijkstra’s. What was unique to this problem was the way of generating neighbours, which was highly visual and involved generating possible next states given a current state.

(Most challenging) Day 19: Beacon Scanner

I did not particularly enjoy this one, but I’m glad I ploughed through and finished it. I did learn a lot from having to wrestle with the complexity of the problem. There are still optimisations I could make to my solution, but I’m in no rush to relive this day…

(Most satisfying) Day 13: Transparent Origami

This problem involved simulating folding a piece of paper with dots on it and printing the final output. This was not computationally difficult, but it made the list because the answer was extremely satisfying, in a visual way. It felt incredible to run my program on the puzzle input and have it print out the letters very clearly in the terminal.