DEV Community: Breno Viana

Installing Unity Hub on Ubuntu 22.04

Breno Viana — Wed, 06 Jul 2022 17:08:00 +0000

Introduction

There are two problems in the Unity Hub installation tutorial (Installing the Unity Hub on Linux):

Ubuntu 22.04 uses OpenSSL 3 while Unity Editors use OpenSSL 1.0 (Workaround for libssl issue on Ubuntu 22.04);
The second instruction uses the apt-key command, which is deprecated on Ubuntu 22.04 (apt-key Is Deprecated. How To Add OpenPGP Repository Signing Keys Without It).

Thus, I decided to provide this brief tutorial with the appropriate commands.

Tutorial

Downloading OpenSSL 1.0:

Download libssl1.0.0_1.0.2n-1ubuntu5.10_amd64.deb from http://archive.ubuntu.com/ubuntu/pool/main/o/openssl1.0/.

Installing OpenSSL 1.0:

sudo dpkg -i libssl1.0.0_1.0.2n-1ubuntu5.10_amd64.deb

Adding the Unity3D repository:

sudo sh -c 'echo "deb https://hub.unity3d.com/linux/repos/deb stable main" > /etc/apt/sources.list.d/unityhub.list'

Adding the public signing key:

wget -qO - https://hub.unity3d.com/linux/keys/public | sudo tee /etc/apt/trusted.gpg.d/unityhub.asc

Installing the Unity Hub:

sudo apt update
sudo apt install unityhub

Uninstalling the Unity Hub:

sudo apt remove unityhub

Introduction to Procedural Content Generation

Breno Viana — Tue, 24 May 2022 16:49:16 +0000

Introduction

Several games from the industry make use of Procedural Content Generation (PCG) to generate levels (e.g., Moonlighter), maps (e.g., Minecraft), weapons (e.g., Borderlands franchise), among other types of content. And such a feature interests so much the public that it is highlighted in advertisements for these games. But what is PCG? According to Togelius et al. [1], Procedural Content Generation "is the algorithmic creation of game content with limited or indirect user input." Thus, the creative process of PCG methods can be entirely performed by computers or associated with human designers or gamers [2].

The use of PCG brings several advantages to game developers since it can:

decrease the need for human game designers to create content;
increase the productivity of these designers;
increase the creativity through design suggestions;
provide the control of game features (e.g., difficulty balancing);
act as a game feature to provide content variety.

The definition of Togelius et al. is good; however, to better understand how PCG methods work, we also need to understand their classifications. Thus, following, I describe the taxonomy of PCG defined by Togelius, Shaker, and Nelson [2]. In addition, a former advisor and I renamed the title of each class to better refer to each one of them [3].

Taxonomy

Content Requirement

Content requirement refers to necessary and optional game content. Content is necessary when it is required to finalize the game, e.g., a key to open a locked door that gives access to a boss room. In contrast, players can ignore the optional content without penalization, e.g., any common coin in a level. Thus, when generating necessary content may require tests to ensure feasibility.

Outcome Randomness

Outcome Randomness regards the generated content if it presents or not randomness. Thus, a PCG technique is considered deterministic when it generates the same content for the same parameters. On the other hand, it is stochastic when, given the same parameters, it always generates different content. Although it is not common, it is possible to create deterministic PCG algorithms.

Generation Time

Generation Time refers to the moment of the game content generation. The content can be generated before the gameplay, i.e., offline, or during the gameplay, while the player is playing the game, i.e., online. Offline content is the most common in the industry. In contrast, online content generation is mostly applied in Infinite Runner games.

Generation Control

Generation Control defines the method regarding its degrees of control provided. Such control is provided basically through parameters that can be composed of a single random seed (a single dimension of control) or by a set of parameters (two or more dimensions of control). For instance, a PCG method can receive the number of locked doors, the number of keys to open these doors, and a list of enemies that may spawn in the level's rooms.

Generation Method

The generation method can be carried out in different ways. The most common in the industry is the constructive method; this method generates the content at once in a single execution without checking feasibility. In contrast, generate-and-test methods perform tests to validate the content feasibility, quality, or both. Besides, there are also Machine Learning and Reinforcement Learning-based PCG approaches.

Generality

Generality regards the target audience for which the content is generated. Thus, if a PCG method creates content for all players, its generation is generic. On the other hand, when a technique learns the gamers' tastes and uses them to generate targeted content, the approach is performing adaptive generation. For example, Left 4 Dead (Valve Corporation, 2008) adjusts the difficulty of enemies based on the emotional intensity [2]. However, adaptation is not trivial to implement in a game, mainly if multiple contents are involved.

Content Authorship

Regarding content authorship, we call a PCG method an automatic generation if the content is generated only by a computer (the user sets only the algorithm's inputs). On the other hand, we classify a tool as mixed authorship when it presents support to human game designers by providing suggestions based on the designer changings. Unfortunately, I do not know if mixed-initiative tools are available in the industry. But there is a very interesting tool being developed by the gamer research group of Malmö University [4]. It is called Evolutionary Dungeon Designer.

Conclusion

That is it! I hope you learned a bit more of PCG with this post. If you are interested in developing PCG algorithms, check my post: What do you need to learn to develop robust PCG techniques?

References

[1] What is procedural content generation? Mario on the borderline (https://doi.org/10.1145/2000919.2000922).
[2] Procedural Content Generation in Games, Introduction, (http://pcgbook.com/wp-content/uploads/chapter01.pdf).
[3] Procedural Dungeon Generation: A Survey (https://doi.org/10.5753/jis.2021.999).
[4] Evolutionary Dungeon Designer (https://games.mau.se/research/eddy/).

What do you need to learn to develop robust PCG techniques?

Breno Viana — Sat, 21 May 2022 15:22:43 +0000

Introduction

The game industry has become the most popular and profitable entertainment industry globally [1]. Since then, more and more games provide massive maps, a high number of game features, and, thus, different ways of gameplay. However, there is a high cost of production to develop such game features. Therefore, to help decrease the cost and increase the speed of the game development is wise to use Procedural Content Generation (PCG) techniques. For instance, PCG techniques may create 3D maps to work as sketches for human designers that can fine-tune the places that require careful designs. We can apply this process to any game level. Besides, we can also use PCG as a game feature by creating content during the game session, thus, providing different playthroughs.

To help beginners, I made this list of things that I think are essential to learning to create robust PCG techniques: programming, data structures, software architecture, and randomness.

1. Programming

PCG techniques are software, so there is no way to develop them without learning to program them. The specific programming language does not matter; we can develop PCG methods with any language. The most important is knowing the programming logic to create the sequence of steps required to build content. However, since you want to develop games, it is wise to learn a language used for a game engine, for instance, learn C# and create games with Unity.

2. Data Structures

We need to know data structures well and how to create new ones to define good representations (encodings) for the content we want to generate. The way we represent the content is crucial for any PCG technique. For instance, it may be better to represent levels with grids instead of graphs (a more advanced data representation) since we easily control the level space in grids.

3. Software Architecture

It is important to maintain our projects well designed when developing software. To do so, we need to learn software architecture and design patterns. Thus, we can fix errors and extend the PCG method more easily. For instance, if we want to add locked doors and keys to our levels, we will need to redesign the data structure that represents our levels. Therefore, it will be easier if we maintain our project well designed.

4. Randomness

Finally, we need to understand how the randomness method we use works. Yes, we can develop PCG techniques without randomness; however, we could not generate a wide variety of content, which is the most interesting thing about PCG. Therefore, randomness is crucial when developing PCG techniques. We need to save the seed we use to feed the random number generator. Thus, we can reproduce the sequence of random numbers and, hence, possible errors in our PCG methods.

References

[1] Gaming: The Most Lucrative Entertainment Industry By Far (https://www.statista.com/chart/22392/global-revenue-of-selected-entertainment-industry-sectors/).

My experience using Unity3D on Manjaro i3

Breno Viana — Sun, 25 Oct 2020 15:00:46 +0000

Introduction

Last year Unity Technologies have announced the Linux support for Unity3D. Currently, the company grants support for Ubuntu and CentOS distros (You can see more details in this post). However, I'm currently a Manjaro i3 user, and, in this post, I'm briefly describing my experience using Unity3D in this distro.

Background

I'm a Linux user for almost 7 years. I see myself as an intermediate user since I can solve some problems without much difficulty (yes, I'm talking about the NVidia drivers). Last year a friend of mine presented the Manjaro i3 to me. I found out the i3 to be an amazing window manager, and I already knew that Manjaro is an excellent OS.

This year I started my master's at USP-ICMC (Universidade de São Paulo - Instituto de Ciências Matemáticas e de Computação), and I joined the Games Research Group. Since Unity3D is the default game engine of our group, I started to learn it. Although there is no official support for Manjaro, I decided to use the engine in this distro. Moreover, I'm a novice game developer.

My experience

I have been using the 2019 LTS version of Unity3D for just over two months. Despite being a short time, I think I have interesting things to share. In general, Unity3D has good support for Linux, but I did find some problems.

The first annoying thing is: since Unity3D is compiled as an AppImage, it is not possible to run the engine directly on dmenu. To open the Unity3D from dmenu, I had to create a bin file. It wasn't difficult, but the need to do this is annoying.

Second, Unity3D (in Majaro i3) is quite slow to load new assets, and to update them. It is even slower to compile the C# scripts. But, maybe, I think it's slow because I'm used to not using such a heavy editor.

Third, and the most annoying problem is the GUI bug:

Fourth, my account was not recognized by the editor after I logged in to the UnityHub. When I needed to download some assets from the Asset Store, I couldn't. I had to log in again to the Asset Store in the editor (I saw this solution online, but I lost the link and didn't find). However, it seems that this problem was solved this week.

Fifth, the real big problem of using Unity3D on Manjaro i3 is the crashes. This problem doesn't happen so frequently. Hardly ever, while I was searching for some solution or while I was watching a tutorial video, the editor crashed (maybe because the Unity3D consumes too much memory). The crashes are more frequent when in the build, but when the builds turned out successful, they work well.

Conclusion

I don't know if all those problems happen on the officially supported distros or if they happen only because I'm using Manjaro i3 (probably some of them). Although those problems, it's been nice to develop games with Unity3D. Since the games I develop aren't too big, I don't build games frequently, and the build is usually fast, so I think I can live with this problem.

And that is it. Thanks for reading!

Downloading Unity3D on Manjaro

There are two ways of using Unity3D on Manjaro, or you download the official AppImage, or you download from AUR (currently experimental).

Using multiple footnotes in float environments

Breno Viana — Fri, 11 Sep 2020 01:06:50 +0000

The problems

I was writing my MSc thesis when I just tried to add two footnotes in the captions of two subfigures. The result of my first try was something like this:

Well, the problem is that I expected the footnotes to be at the bottom of the page. And I solved it quite fast by using \footnotemark[...] and \footnotetext[...]{...}. However, another problem arose: only the label of the last footnote was linkable and I wanted both to be linkable.

The fix

I googled a lot but no solution was good enough to solve both problems. I found some solutions proposing using the footnotehyper package but they did not help with the first problem. After some hours I found this 2012 post showing the savenotes environment of footnote package. It did not solve my second problem, but I realized that the footnotehyper could be based on the footnote so I could use the savenotes environment as well. And it worked finely! More about the footnotehyper documentation here.

The code

\documentclass{article}

\usepackage{geometry}
\geometry{a5paper,landscape,margin=0.5in}

\usepackage{hyperref}
\usepackage{graphicx}
\usepackage{caption,subcaption}
\usepackage{footnotehyper}

\begin{document}

\pagestyle{empty}

\begin{savenotes}
    \begin{figure}[ht]
        \centering
        \caption{Animals.}
        \label{fig:animals}
        \begin{subfigure}[b]{0.48\textwidth}
            \centering
            \caption{A cat.}
            \label{fig:cat}
            \includegraphics[width=\textwidth]{cat.jpg}
            \caption*{Source: \href{https://unsplash.com}{Unsplash}\footnote{Source: \href{https://unsplash.com/photos/kjERLXaHjXc}{https://unsplash.com/photos/kjERLXaHjXc}.}.}
        \end{subfigure}
        ~
        \begin{subfigure}[b]{0.48\textwidth}
            \centering
            \caption{A dog.}
            \label{fig:dog}
            \includegraphics[width=\textwidth]{dog.jpg}
            \caption*{Source: \href{https://unsplash.com}{Unsplash}\footnote{Source: \href{https://unsplash.com/photos/N04FIfHhv_k}{https://unsplash.com/photos/N04FIfHhv\_k}.}.}
        \end{subfigure}
    \end{figure}
\end{savenotes}

\end{document}

The result

References

I took the images of the cat and the dog from Unsplash.