DEV Community: Andy Terekhin

The demo of my game development skills has suddenly transformed into an indie video game

Andy Terekhin — Tue, 15 Oct 2024 17:22:59 +0000

There’s a story to tell. As a Unity developer with extensive experience primarily in 3D and virtual and augmented reality, I often hear requests from clients for specializations like “we have 2D,” “we have a tile grid,” “we have casual puzzles,” “we have online casinos,” and they ask to show examples specifically from those areas.

So, I thought, I’ll create a demo featuring core game mechanics in various graphic styles and decided to go straight through the history of computer games. Since this is not a direct order and not a commercial project, I fully dedicated myself to the creative impulse and my imagination.

First, I created a level in the style of the very first “Spacewar!” from 1954, then a level in the style of “Space Invaders” from 1978, followed by a text quest in the style of Zork (1980). I added a unified storyline and transitions from level to level, as well as a lot of narrative that transforms the game from mere jumps from level to level into a truly engaging journey.

In other words, I ended up with a unique game, in my opinion, more like a journey through the history of computer games, where each level has its own gameplay mechanics and graphics corresponding to those present at the time of the first game release in that genre. Resources earned in some levels are transferred to others, becoming, for example, the points collected in a 2D arcade game that turn into basic capital in a strategic simulator.

I also created the transitions between levels in an interesting format; for instance, those who remember the history of loading games via audio cassettes will appreciate the second level of the game, where I wrote a simulation of such a loading process with memorable voice scripts.

When using original mechanics, I’m not actually copying them, but reinterpreting, trying to move away from the typical arcade style toward exploring the game and oneself.

It begins with the very first level, where the hint text instead of a regular message contains, “Press Space to start, then use WASD or the arrow keys to control your life and reach your goal, regardless of the circumstances.”

For example, in the text quest stage inspired by Zork, you can use the command ‘wake up,’ and the scenario suddenly changes to a realistic description of you coming to in your room, looking at the text on your monitor. The suggested actions thereafter essentially mirror the user, prompting them to reflect on the difference between the real and the virtual. To the point that by using the command “Turn off computer” in the game, you actually shut down the game in reality.

In the end, the game, despite pretending to be an arcade, actually transforms into a quest narrative genre that tells a cohesive story through various gameplay mechanics.

I’m currently finishing the arcade level in the style of the first Mario Bros 2D, and next in the storyline, I will have a small logic puzzle referencing Tetris (1984), followed by creating a stage of a simple RPG in the style of Final Fantasy (1987), and then a shooter in the spirit of the first Doom (1993). I plan to finish the game using virtual and augmented reality with modern graphics, but with an alternative gameplay option for devices that do not support these features.

I believe I’m creating a great indie project, firstly, because both from the perspective of gameplay mechanics and stylistically, it’s a very unusual approach that ensures variety and keeps the player engaged; secondly, it’s essentially the history of all computer games in one game, like visiting a museum; thirdly, it results in an amazing narrative.

I uploaded a gameplay video on YouTube, so you can see it.

Understanding Algorithm Complexity Through 7 Simple Examples of Choosing a Book to Read

Andy Terekhin — Sun, 13 Oct 2024 10:09:25 +0000

When we talk about computers and programming, we often encounter algorithms. Algorithms are like instructions that help computers perform tasks. However, not all algorithms work the same way. Depending on how much data they need to process, the time they take can vary significantly.

Imagine you have a large library of books, and you want to choose one to read. If you have only three books, you can quickly decide which one to pick. But if there are hundreds of books in the library, it may take you longer to figure out which one you like.

In this article, we will explain how different algorithms work using a simple analogy of choosing books. We will start with the simplest algorithms and move to more complex ones so that you can better understand how and why some algorithms can be faster or slower.

1. O(1) — Constant Complexity

What it means: The execution time does not depend on the size of the data.
Analogy: Imagine you are a huge fan of “1984” by George Orwell, and your books are arranged alphabetically by the author’s last name. You simply take the book you want to read from the shelf.

def get_book(books):
    return books[0]  # Always returns the first book

2. O(n) — Linear Complexity

What it means: The execution time increases proportionally to the amount of data.
Analogy: Your books are in a random order on the shelf, and you have no idea where anything is. You want to find “All Quiet on the Western Front” by Erich Maria Remarque and start taking books one by one to check which is which. You begin with the first book in line and move on to the next, continuing until you find what you need. The more books you have on the shelf, the more time it will take.

def find_book(books, target):
    for book in books:
        if book == target:
            return book
    return None  # If the book is not found

3. O(log n) — Logarithmic Complexity

What it means: The execution time grows slowly compared to the increase in the amount of data. If the data is sorted, you can use methods that allow you to reduce the search.
Analogy: Your books are still arranged in alphabetical order, and you want to find “Fahrenheit 451” by Ray Bradbury. Instead of checking each book, you open the middle of the shelf. If the book in the middle starts with “M,” you know your book must be to the left. You then take the middle of the remaining books and continue this way until you find your book. Thus, with each check, you reduce the number of books you need to examine.

def binary_search(books, target):
    left, right = 0, len(books) - 1
    while left <= right:
        mid = (left + right) // 2
        if books[mid] == target:
            return mid
        elif books[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return None  # If the book is not found

4. O(n²) — Quadratic Complexity

What it means: The execution time increases proportionally to the square of the size of the data. This occurs when each data element is compared to every other element.
**Analogy: **You decided to organize your books by title. To do this, you need to compare each book to every other book to determine the correct order. You start with the first book and compare it with all the others. Then you move to the second book and compare it with all the others. If you have 10 books, you’ll need to make 10 × 10 = 100 comparisons to sort them correctly. The more books you have, the longer the process will take.

def bubble_sort(books):
    n = len(books)
    for i in range(n):
        for j in range(0, n-i-1):
            if books[j] > books[j+1]:
                books[j], books[j+1] = books[j+1], books[j]  # Swap places
    return books

5. O(2^n) — Exponential Complexity

What it means: The execution time of the task grows very rapidly as the amount of data increases.
Analogy: Imagine you have 3 books, and you want to organize a reading evening. For each book, you can decide whether to read it or not. This means you have several ways to choose books:
• Read nothing.
• Read only the first book.
• Read only the second book.
• Read only the third book.
• Read the first and second books.
• Read the first and third books.
• Read the second and third books.
• Read all three books.
So you have 8 different ways to choose books for reading. If you add a 4th book to your list, the number of ways will grow to 16! The more books you have, the more confusing it becomes.

def get_combinations(books):
    result = []
    n = len(books)

    for i in range(2**n):
        combination = []
        for j in range(n):
            if (i >> j) & 1:
                combination.append(books[j])
        result.append(combination)
    return result

6. O(n!) — Factorial Complexity

What it means: The execution time of the task increases in such a way that it can make the task practically impossible.
Analogy: Imagine you are choosing the order of books to read. You have only 4 books in your list, and you can start with any of them, then choose any of the remaining ones, then from the remaining two, and finally read the last one.
Since you can read these books in any order, for 4 books, you have many options:

Book A, then Book B, then Book C, then Book D.
Book A, then Book B, then Book D, then Book C.
Book A, then Book C, then Book B, then Book D.
And so on. If you add another book to your list, the number of possible reading orders will increase even more, and this number grows very rapidly! For example, for 4 books, there are 24 different orders (that’s 4!). If you add a 5th book, it becomes 120 options. The more books you have, the harder it is to decide how to read them because the options become too many!

from itertools import permutations

def get_reading_orders(books):
    return list(permutations(books))

Understanding algorithm complexity helps us choose the right approach to solving problems. When we know how fast or slow an algorithm works, we can organize our actions more effectively — whether it’s selecting a book to read or developing a business process.

If you’d like to receive more content like this, including insights on AI, machine learning, and technology trends, subscribe to our newsletter at www.terekhindt.com.

How to Stop Facebook from Using My Data and Prevent Arresting Social Network Owners for Refusing Data Requests

Andy Terekhin — Wed, 04 Sep 2024 00:18:55 +0000

Okay, this will be challenging, but I’ll try to explain it in simple terms, and believe me, it's worth it.

I'll start with a question: do you like the fact that Facebook stores your data and might use you as a cash cow for selling personalized ads?

Or another question: do you like that any social network will eventually have to disclose your data under pressure from police and intelligence services?

So, the problem is that every platform stores your data, monetizes you, and can easily throw you under the bus by leaking your personal information at the right moment.

Here’s a solution that came to mind (and now it’s going to get complex). We can, in the best traditions of programming, separate the model from the logic and the user interface. Don’t be scared; I’ll explain it all now. We can create your personal data in a separate space, allowing social networks to use only what you deem necessary and in the way you see fit.

Those who understand technology a bit might already sense the problem: user data still needs to be stored somewhere. Another database? What then distinguishes it in terms of personalized ads or leaks?

This is where decentralized identification on the blockchain comes into play.

Instead of storing data on centralized servers, which can be vulnerable to leaks and misuse, blockchain allows data to be stored in a distributed network. This means there is no single center that could be attacked or used for data collection. Decentralized Identification (DID) uses blockchain to create unique and secure digital identifiers that belong only to you.

How does it work? Imagine you create a digital wallet that stores all your identification data. This wallet is not only cryptographically protected but also managed in a decentralized manner. When you want to register on a new platform or grant access to your data, you do it through your digital wallet. The platform does not get direct access to your data, only to the parts you choose.

Thus, you control which data you share and with whom. If a platform wants to use your data for advertising, it only gets the data you have permitted and nothing more. Additionally, all information is encrypted and protected from unauthorized access.

To summarize: The current model of the internet implies that each service (Facebook, Telegram, LinkedIn, etc.) contains a user database, sells it, and is responsible for the risk of data leaks. In this model, your data can be vulnerable to misuse and leaks.

The blockchain-based decentralized identification model ensures that your data remains under your full control. Data is stored in a secure and distributed network, and access can be granted only under the conditions you set. This avoids leaks, misuse, and protects your personal information while maintaining the convenience and functionality of interacting with services.

In simple terms: anonymity, freedom, no need to write silly texts on Facebook like “I did not permit sharing my personal data,” and no possibility of arresting the social network owner for refusing to provide data they don’t have.

What do you think, folks? Who’s up for investing in this startup?

What kind of programmer are you?

Andy Terekhin — Tue, 21 May 2024 14:34:02 +0000

My First Mobile Game With Flutter

Andy Terekhin — Fri, 03 May 2024 06:33:23 +0000

In my life, I've had extensive experience working as a volunteer and leading a volunteer organization. I have organized numerous social activities, including food drives for the homeless, emergency aid for victims of natural disasters, cultural events, and political actions. I have experienced many consequences of this work, from emotional burnout to political oppression and arrests. Thus, the idea emerged in my mind to create a simple mobile clicker game that narrates a volunteer's journey from an activist to a world organization leader. I want to acquaint players with aspects of a volunteer's life, introduce them to tools, prepare them for difficulties, and inspire them to pursue their own dreams of changing the world.

An important aspect of the game is the opportunity to understand the workings of international organizations like the UN, along with the game's communication platform (multiplayer), where players can create their own petitions and collect signatures from other players. This is the point where the game can be translated into reality.

So, I started developing the game with Flutter. It was my first experience as a Flutter developer. I worked on it for several hours a day, beyond my usual working hours, for a month.

This isn't the final version of the game, but it's an engine created by me to make the full game, and I am going to finish it in the near future.

Be that as it may, I've gained good experience in Flutter development and added a new programming language to my knowledge.

I've submitted it to the Global Gamers Challenge, so wish me good luck.

Peace and love to everyone!