
Quando iniciei na programação meu principal interesse era desenvolvimento de jogos. Mas esse nunca foi fácil, sempre limitado por ferramentas, algumas pagas, outras tão complicadas em suas funcionalidades que se tornavam inacessíveis. Mas ao longo dos anos essa situação tem mudado, com o lançamento de ferramentas gratuitas, acessíveis, e com o aumento de tutoriais na rede.

Mesmo com essa maior acessibilidade, ao longo dos últimos anos, nunca consegui escolher e permanecer em uma ferramenta, sempre tinha algo faltando, ou sobrando. Até nos meus anos mais produtivos usando Godot, a forma como certas partes funcionavam me confundiam, me atrasavam e amedrontavam com suas documentações complicadas e falta de tutoriais.

Depois, focando mais em frameworks em puro código, esses também nunca me satisfizeram, ou me deram o entusiasmo necessário pra cair de cabeça, estudar e realmente construir algo. Ou bati em uma parece que não sabia como escalar, como [naquele post] . Mas depois de muitas tentativas, e minha última antes de voltar pro Godot, acredito que encontrei algo que realmente me contenta e satisfaz com desenvolvimento de jogos.

Dito isso, gostaria de compartilhar um pouco da minha primeira experiência com Ruby e DragonRuby, minhas primeiras impressões sobre a linguagem, a engine, a comunidade e meu primeiro projeto por aqui.

## Ruby

Pra mim Ruby sempre foi o colega mais estranho e menos popular do Python, e depois de tantos anos programando em Python, Ruby começou a se tornar uma opção cada vez mais interessante. Depois de ouvir um pouco sobre a história do DHH e do Ruby on Rails (antes de todas as polêmicas recentes), Ruby se tornou uma pequena paixonite pra mim. Aquele conhecido distante que pensamos sobre nos dias mais atoa.

Em seguida li alguns capítulos de [Poingnant Guide to Ruby](https://www.amazon.com/Whys-Poignant-Guide-Lucky-Stiff/dp/1838039503), fiz alguns experimentos com Rails decidi dar uma olhada naquele framework Ruby, que apesar de ser pago, tinha opção para estudantes.

Alguns e-mail depois, eu estava com uma nova e poderosa ferramenta em mãos, mas eu não esperava que me daria tão bem com ela.

## DragonRuby

Primeiro, todo e qualquer projeto que começa com uma filosofia, você pode ter certeza que algo grande esta sendo construído. Assim como Ruby tem toda sua filosofia do porque as coisas são como são, DragonRuby segue o mesmo princípio e expande as ideias por trás de sua linguagem interna, trazendo todo um ideal de software e comunidade com o objetivo de ser sustentável e sobre pessoas (e eu sou uma pessoa). A todos que lerem esse texto, recomendo ler a página sobre [A Filosofia de DragonRuby](https://docs.dragonruby.org/#/misc/philosophy). Mas o ponto principal pra mim é:

> We will prioritize the removal of pain. The aesthetics of Ruby make it such a joy to work with, and we want to capture that within the engine.

E também:

> There is a programming idiom in software called “The Pit of Success”. The term normalizes upfront pain as a necessity/requirement in the hopes that the investment will yield dividends “when you become successful” or “when the code becomes more complicated”. This approach to development is strongly discouraged by us. It leads to over-architected and unnecessary code; creates barriers to rapid prototyping and shipping a game; and overwhelms beginners who are new to the engine or programming in general.

Olhando em retrospecto para minha jornada frustrada com desenvolvimento de jogos, acredito que esses (e outros aspectos) da filosofia de DragonRuby meus principais impedimentos em produzir algo.

### E daí?

Tendo em vista essa filosofia, o framework corta diversas etapas chatas e trabalhosas e transforma tudo em algo simples: arrays. Arrays por toda parte (acesso global incentivado), e por baixo dos panos tudo acontece.

> Acompanhando vários devs ao longo dos anos, vejo que todos eles convergem pra esse mesmo tipo de implementação: tenha um objeto gigante e genérico pra controlar o estado de tudo e passe ele por todo o seu jogo de forma a evitar passar argumento por argumento de um lugar pro outro

Todos esses arrays estão dentro de um objeto global chamado `args`, dentro dele temos:

- State: um objeto genérico onde injetamos todo o estado do jogo, como : `args.state.life = 0`
- Outputs: um array de outputs, incluindo audio, sprites, formas geográficas, textos e etc
- Inputs: um objeto que guarda e registra eventos de entrada, como teclado, mouse, etc.
- Events: Eventos extras que podem ocorrer com o dispositivo ou a janela, como mudança de orientação, tamanho da janela, etc.

E com isso, se constrói praticamente qualquer coisa (até onde eu explorei). Existem também diversos helpers pra auxiliar no desenvolvimento, como Grid, Layout, Easing etc. Além de centenas de exemplos de implementações de funcionalidades comuns em jogos dentro da documentação que você pode usar como exemplo. Não tem como pedir por mais.

Por fim, temos a comunidade do Discord, apesar de ser meio confuso o uso de cada canal (pelo menos pra mim), a comunidade é bem ativa, de tempos em tempos gosto de checar o _show-and-tell_ pra ver o que tem sido feito com a ferramenta, e até o próprio criador compartilha alguns projetos dele ali.

### Meus destaques pessoais

Toda a graça de DragonRuby é não ter que se preocupar com nada, nada mesmo. Você só faz o jogo, coloca as coisas no array e segue em frente, já é otimizado o bastante pra você poder fazer muita coisa errada até isso se tornar um problema (não me ocorreu ainda). Todos os conflitos são evitados, e o dinamismo de Ruby torna tudo possível e melhor de se trabalhar.

> It just works

Toda a experiência de desenvolvimento é fluida, sem impedimentos, sem configuração, sem dor de cabeça. Se tive uma ideia pro jogo eu crio um array, interajo com as entidades que preciso através da variável global e jogo na tela da forma mais simples. Depois, se for necessário, posso transformar os itens do array em uma classe, organizar em funções e abstrair apenas o necessário.

Em nenhum momento tenho que parar pra ler documentação, são apenas algoritmos, iteração e lógica básica, simplesmente incrível. Para prototipação nem se fala.

Talvez futuramente as coisas se tornem confusas de mais pra serem encontradas e entendidas, mas acredito que, se isso acontecer, será totalmente culpa minha por falta de organização própria. Espero escrever sobre isso em breve, pois meu projeto esta começando a tropeçar em si mesmo. Cabe ai aquele estudo sobre _patterns_ que estou devendo a alguns anos.

> Um extra sobre as funções agregadas de formatação de texto e lidar com números, tudo fica muito mais confortável, e olha que não conheço nem metade desses métodos ainda.

## Limitações

Meu único problema é com o LSP de Ruby, atualmente estou usando SolarGraph com RoboCup, mas ele não consegue dar conta do trabalho. Algo sempre esta quebrado, atualmente não posso minimizar uma função e salvar o arquivo, que ele maximiza de novo; os importes mesmo sendo encontrados recebem um aviso de "não encontrado"; a substituição global troca tudo incorretamente, não sabendo diferenciar entre objeto, hash, variável e o nome que eu pretendia mudar mesmo;

Por último, o _grep_, como toda a documentação é embutida no framework, sempre que faço um _grep_ ele me traz resultados de todos os exemplos da documentação, preciso achar uma forma de limitar essa busca a arquivos do meu jogo apenas.

Mas note, nenhum desses problemas tem a ver com o DragonRuby, mas sim com meu ambiente de desenvolvimento.

## Meus Experimentos

Falando um pouco sobre meus experimentos no framework: estou tendo diversas ideias de jogos nos últimos meses, então prototipar no DragonRuby (o forte do framework) foi o que mais fiz. Primeiro fiz apenas um controle de câmera com zoom, nada de mais; Depois comecei um protótipo de um jogo de barco que eu tinha imaginado. Segui com esse protótipo por aproximadamente 1 mês. Mas como é um estilo de jogo que eu não entendo muito, estava ficando sem ideias e o desenvolvimento se complicou um pouco, acabei deixando o projeto de lado. Decidi aprender a fazer jogo recriando algumas funcionalidades de um dos meus jogos favoritos: [Nuclear Throne](https://store.steampowered.com/app/242680/Nuclear_Throne/).

E foi assim que caí na espiral do projeto pequeno que se torna um projeto grande, o medo e destino de todo desenvolvedor de jogos iniciante. Sim, ja passei por isso diversas vezes no passado, com diversos projetos diferentes, mas dessa vez foi curioso. Eu comecei definindo que não iria me perder trabalhando em coisas fora do escopo de funcionalidade, ou seja, nada de melhoria visual, nada de efeitos que demoram horas pra chegar no ponto certo, nada de se perder em algo que não importa pra um projeto simples.

Semanas depois e eu estou planejando qual o próximo game juice devo adicionar no jogo. E a sina se repete.

Eu estava planejando eventualmente fazer conteúdo sobre desenvolvimento de jogo, mais pro fim do ano. Mas acabei começando a fazer algumas lives desenvolvendo esse projeto, e daí comecei a fazer alguns clips e jogar em algumas plataformas. Parei com as lives pois estava sendo super estressante e demandando muita energia. Decidi fazer apenas 1 vídeo, pois estava muito animado. Depois de publicado esse video acabei gostando do engajamento que estava recebendo no TikTok, decidi continuar fazendo alguns vídeos por semana documentando o processo.

Apesar de odiar o formato, por ser muito limitado, acabei vendo a plataforma como uma forma de divulgar o jogo se eventualmente fosse virar um projeto real. Então decidi transformar esse projetinho no meu primeiro lançamento, mas coloquei uma data limite: tenho que lança-lo esse ano. Independente do que ele se tornar, ele é meu primeiro jogo e tem que ser lançado em 1 ano. Não é uma ideia nova, então não promete nada, mas quero ter um sandbox onde posso adicionar qualquer mecânica que acho interessante em um jogo num estilo que acho interessante. Sempre quis ter um projeto pra brincar assim, e acho que é num top-down-shooter que me encontrei.

## Conclusão

De qualquer forma, espero continuar postando meus vídeos sobre o desenvolvimento desse jogo tanto no [TikTok](https://www.tiktok.com/@renatogamedev) quanto no [Youtube](https://www.youtube.com/@vodsrenatogamedev). Vou tentar documentar um pouco do processo aqui também, entrando em mais detalhes, planos e ideias. Tem muito o que fazer e trabalhar nos próximos meses.

Sobre DragonRuby, acho que é a minha ferramenta de escolha pra próximos projetos, apesar das limitações de não ter shaders e outros tipos de manipulação de imagem e sprites. Escolho esse framework pois me possibilita sentar e adicionar algo no jogo em 1 hora. Me sinto produtivo, me sinto fluindo com as ideias. Recomendo a todo interessado experimentar.

Espero trazer Atualizações sobre o jogo aqui em breve, comentar um pouco sobre os planos e o processo. Até mais!


Minha experiência com DragonRuby

Since I [changed the Rings project to be an isometric tower defense](/blog/a-big-turn-in-the-rings-project) , I've been having some problems with the 2D representation of things in this perspective. Why, you may ask? The thing is that the isometric view is exactly what I described—a representation of the actual 2D top-down game. However, when I started this project, I wasn't considering that isometric would entail more than just a different way of drawing. Unfortunately, this oversight has led to some coding issues

# The beginning of the problem

When I first started making changes to the project's categories, I was only thinking about the mouse interaction with the isometric tiles. So, I followed a tutorial to accomplish this and continued from there.

Initially, my focus was primarily on how the mouse was interacting with the units on those tiles. I considered aspects such as hover detection and the potential problems that could arise, such as:

- What if the unit is taller than the tile? How can I prevent the selection from going to the wrong tile?
  ![test](behind-tower-selection.webp)
- What if there's a unit positioned behind another unit? How can I select the intended one?
  ![second](unselectable-tile.webp)

These small problems overshadowed the magnitude of the challenge I was facing.

# The realization

I implemented the unit placement and deletion functionalities, created a simple targeting system, and developed a Bullet class. I was about to start working on the actual defense mechanisms that the towers would perform.

Next, I began coding the system responsible for firing at the target as soon as it entered the unit's range. However, I encountered a roadblock and couldn't figure out a simple solution. On the surface, it was just a matter of calculating the intersection of circles. Yet, inexplicably, I couldn't make it work.

To create the range ellipse, I used an ellipse since the game had an isometric view. Technically, it wasn't a perfect circle. However, I found myself attempting to calculate ellipse intersections using 2D positions, needlessly complicating everything.

Eventually, when I stopped working on the project, I started reflecting on the issue.

> The state of enemy detection
> ![current-colision](current-colision.webp)

If I have the 2D grid of every tile and the tile position of every unit, why not calculate the range intersection in the top-down view of the tiles and then convert this result later before rendering?

That's precisely what I have started implementing this week as I return to the project after almost a year.

# Let's start by looking at things

Something that has always facilitated this kind of implementation for me is the visualization of the context. Whether it's a simple `print` statement to display the behavior of a variable or even coloring a `<div>` to understand how it affects the entire website's layout (yes, that has happened).

That's why I've decided to develop a top-down debug view for the game. This will not only facilitate the new implementation but also aid in understanding future features and identifying bugs. It's currently a work in progress.

The debug view has helped me realize the issue with my current approach to the isometric perspective. I was constantly thinking in isometric terms instead of considering the underlying 2D representation. In reality, the isometric view doesn't actually exist!

I encountered significant difficulties in determining the actual 2D positions of the elements, to the extent that I had to revisit sections of the code to understand how things were placed, drawn, and recognized in the game.

Questions like how the mouse determines the tile it is hovering over, how the tiles are stored to create a grid, and how to convert coordinates into tile positions (matrix positions) prompted me to reconsider a substantial portion of our rendering and computing pipeline.

> The complexity of the current pipeline far outweighs the simplicity it is meant to achieve."

# Get a step back and rethink the pipeline

Basically, my current plan is to refactor all the isometric-related code to create a simpler pipeline that the entire game can follow, and one that can be easily modified if necessary.

I will store the tile position of every entity and transform it to isometric coordinates during rendering.

> The current debug view ![current-debugger](current-debugger.webp)

Another issue I encountered is the abundance of variables that complicate matters. For instance:

Should the `Unit` class store both `screen_position` and `tile_position`? If I only need the screen position when necessary, wouldn't it be better to transform it dynamically? I don't believe it would require excessive computing power.

```python
class Unit(Entity):
	tile_position: Vector
	screen_position: Vector`
```

---



Why am I passing the game to the `UnitManager` instance? And why did I name the parameter `window`?

```python
class UnitManager:
	def __init__(self, window):
 		self.selected_unit = None
		self.window = window

class Game:
	def __init__(self):
		self.unit_manager = UnitManager(self)
```

As I rewrite this _Top-down to Isometric Logic_, I'm likely to come across more nonsensical code here and there. But for now, that's the plan.

Now, I'll proceed to complete my top-down visualization as I once again refactor this code. Take care not to disrupt your own pipeline in your project!

The Problem with Isometric Graphics


In the [last post](/blog/the-refactoring-process-in-rings-code) I presented you the Rings project, a repository where I (Renato) started implementing some basic systems that I would use in game development in the future. First, as I said in the last post, the idea was to make a rogue-like top-down shooter, but some days ago, I decided that to keep it simple and with the least amount of complexity, Rings should be a Tower Defense game.

# The complexity thing

When you start to think about how to manage multiple abilities that interfere with one another; hundreds of bullets can collide, bounce, go back and pass through stuff. You start to think that Python and Pygame maybe is not the right choice for the job, and starting everything from zero with a new language is kind of a hard decision as well.

But now imagine a game with static units, fixed targets, simple upgrades, and a stateless game loop, you can accept Python as a decent tool for the job.

But, to add more dynamics to the game, I decided to implement an isometric style. The main idea was to bring the semi-3D perspective and the strategi feeling that this kind of graphics brings to games. The first games of **Age of Empires** used those graphics for example. And I think that this is a way to make things more challenging.

![unit_selection](age-of-empires.webp)

# New inspirations and the main idea

Since the rogue-like games exploded in the last few years, the idea is to go against this, for more strategic gameplay. Recently I played [Rogue Tower](https://store.steampowered.com/app/1843760/Rogue_Tower/), rogue-like tower-defense with voxel graphics, its a pretty fun game, but I get bored with it after the first plays, the range of builds is not diverse enough that you want to experiment with other types of stats and machines.

A game that does this part very well is [ Despot's Game: Dystopian Army Builder](https://store.steampowered.com/app/1227280/Despots_Game_Dystopian_Army_Builder/), which goes for an auto-battle (TFT vibes) with class combinations and power-ups.

So, the idea is to mess up with those concepts in a [Bloons TD 6](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwjH36jBtbX6AhV7s5UCHYc0ALMQFnoECAsQAQ&url=https%3A%2F%2Fstore.steampowered.com%2Fapp%2F960090%2FBloons_TD_6%2F&usg=AOvVaw1Q3-OUytRLn3tVpRT1PUBm) style as well. With a variety of units each one with its purpose and class, so you can play with those kinds of combinations.

Since I'm a noobie game developer, my ideas and implementations probably will go pretty badly, but the idea is to experiment with everything before making a serious game.

# The Game so far

It's important to say that we don't have any style concept formed so far, don't have gameplay and the base of Pygame start code continues there. For the first interactions of the game, I focused on doing the isometric stuff (that is harder than it looks). Then I created an `UnitManager` to take care of the unit placement and delete.

To make the Unit selection I needed to work better on detecting which Tile and which Unit I was hovering with the mouse, It's kind of tricky but it does the job.
![unit_selection](unit_selection.webp)

I still need to improve the isometric-to-plane logic, because now I'm stuck on the code to detect if an enemy enters a unit range, and I cannot use the isometric position straight ahead, I need to make some kind of conversion. I need to calculate those collisions in the flat plane and then, only transform to isometric when needed (to draw and calculate mouse collision with units).

I made a simple shoot system just to try it out, but need to fix those collisions before showing anything.

# Some problems

Finally, as things progress it get's harder to develop some stuf, that's why we should build things different. But at the same time we need to make things work before refactoring it. Another thing that I'm facing is unit testing problems.

What, where and how to test thing in a video-game code? Should you test it with all things turned on? (like graphics) Or should you just test the intern things like sub-functions? Given that things change brutly during early development, those test can start to requiring more work then the real code, and it's kind ok to do that, since those tests hold your software together and protected from future mistakes.

Anyways, I need to start testing as soon as possible. I Will write abou testing when I make it.


A Big Turn in The Rings Project


Hi There! I would like to introduce to you one of my (and Back to Pixels) project **Rings**. And perhaps show some big refactorings
that I did some days ago.

# Presenting Rings

Rings is a pygame video-game project that initially was inspired by [Enter the Gungeon](https://enterthegungeon.com) and [Nuclear Throne](https://nuclearthrone.com) (even the sprite animation test was done using its sprites). But with time (and some studies) I realized that this scope was too big for my first game, and by the time I was pretty into [Vampire Survivors](https://store.steampowered.com/app/1794680/Vampire_Survivors/), so I decided to redirect Rings to be a "stand-still" rogue-like game. Aiming to try some video-game software architecture and push to the limits that python can do as a game development language!

> The name rings was referring to the upgrades in the game, that would be rings that you could use, a maximum of 10.

But a complete game is still a big scope for someone that studies and has a full-time job. So, my current idea is to develop each feature of a simple game development framework just to experiment with some module architectures.

And here today I will show you what was _Rings_ was before and after some cool structural changes that I made based on some simple things that I've learned recently.

# How It Was and Where it is Going

Since I'm just developing feature to feature, my architecture thing was not that important, so I kept the code struct as the simple pygame tutorial would give you, which is, extremely bad, but with the simple _check-events_, _update entities_, _render entities_ order.

But after seeing some [DaFluffyPotato](https://www.youtube.com/c/DaFluffyPotato) live streams I start to recognize a pattern in his code. He put everything into a _Game_ class, and passes this game class to everyone inside it (this part is pretty dangerous but ok), and inside this class, he has a _world_ attribute (of the class World) and an _Input_ attribute (of the class Input) and so on for every major thing in his game. He also had some classic structs such as a list of _entities_ and a list of projectiles.

Anyways, this architecture can help a lot such in debugging (because um can tear apart things easily) and in modularity.

So that's where I aimed to when refactoring Rings for (almost) the first time.

# Some Bad Code

Here I will show you how the code was (it is a little bit longer, so maybe I will change it in the future)

```python
configs = json.load(open('config.json'))

pygame.init()
pygame.mixer.pre_init(44100, -16, 2, 512)
pygame.mixer.set_num_channels(32)
pygame.display.set_caption("Rings")
pygame.mouse.set_visible(False)

FONT = pygame.font.Font("res/Pixellari.ttf", 22)

global debugging
game_time = 0
base_screen_size = configs['resolution']
screen = pygame.display.set_mode(
	(base_screen_size[0],base_screen_size[1]),0,32
)
display = pygame.Surface((300,200))
clock = pygame.time.Clock()
screen_real_size = display.get_size()
camera = Vector(0,0)

player = Player(Vector(10,10))
player.load_animations()

TILE_SIZE = 20

game_map = [...]

cursor_img = pygame.transform.scale(
	pygame.image.load('res/mouse.png').convert(), (44, 44)
)

cursor_img.set_colorkey((255, 0, 0))

camera_speed = 20
debugging = True
running = True

while running:

	for event in pygame.event.get():
		check_events(event,player)

	mx, my = pygame.mouse.get_pos()

	true_mx = mx
	true_my = my

	mx -= (screen.get_width() - base_screen_size[0]) // 3
	my -= (screen.get_height() - base_screen_size[1]) // 3
	mx /= base_screen_size[0] / display.get_width()
	my /= base_screen_size[1] / display.get_height()

	camera.x = player.position.x + 7 - screen_real_size[0] /2 # the +7 is half of the size of the player, to certralyze
	camera.y = player.position.y + 7 - screen_real_size[1] /2

	player.is_not_walking = not player.is_moving_right and not 		player.is_moving_up and not player.is_moving_down and not player.is_moving_left


	scroll = camera
	scroll.x = int(scroll.x)
	scroll.y = int(scroll.y)

	display.fill((30,30,30))

	collision_tiles = []
	tile_rects =[]

	y = 0

	for row in game_map:

	x= 0

	for tile in row:
		#<big tiles logic and draw>
		for t in row:
			#<more logic and draw world stuff>

	player.update(mx, collision_tiles,camera)
	player.draw(display,debugging)

	screen.blit(pygame.transform.scale(display, base_screen_size),

	((screen.get_width() - base_screen_size[0]) // 2,

	(screen.get_height() - base_screen_size[1]) // 2))

	screen.blit(cursor_img, (true_mx // 3 * 3 + 1, true_my // 3 * 3 + 1))

	if debugging:

		utils.draw_text(FONT, "FPS: " + str(int(clock.get_fps())), screen, (10,10))

	pygame.display.update()
	clock.tick(60)
```

> I removed some unnecessary parts

# Some less-bad code

```python
class Game:
	_entities: list
	game_time: int
	player: Player
	window: Window
	world: World
	mouse: Mouse
	camera: Camera

	def __init__(self):
		configs = json.load(open("config.json"))
		self.window = Window(configs)
		self.mouse = Mouse(self.window)
		self.world = World()
		self.player = Player(self)
		self.player.load_animations()
		self.camera = Camera(
				self.player,
				self.window.screen_real_size
		)


		self._entities = []
		self._entities.append(self.player)
		self.running = True
		self.clock = pygame.time.Clock()
		self.FONT = pygame.font.Font("res/Pixellari.ttf", 22)


	def update(self):
		self.world.update()
		self.mouse.update()
		self.camera.update()
		for entitiy in self._entities:
			entitiy.update()

		pygame.display.update()
		self.clock.tick(60)

	def draw(self):
		self.window.display.fill((30, 30, 30))
		self.world.draw(self.window.display, self.camera.position)

		for entitiy in self._entities:
			entitiy.draw(self.window.display, self.camera.position)


		self.window.blit_displays()
		self.mouse.draw(self.window.screen)

	def run(self):
		while self.running:
			self.check_events()
			self.update()
			self.draw()

game = Game().run()
```

Even with this "better" code, there are always things to improve everywhere. Such as an Input class to handle all the input commands and logic (that I hid in this example), or some particles and sound managers (that I didn't implement yet).

As Uncle Bob says in "Clean Architecture":

> Good (clean and well architectured) code, should look like a well-written poem

The new rings architecture looks like some Ok poem, but I think it could be better, mainly in the _Player_ class (the animation system is kind of messed up). In the end, all I did was hide things properly and reallocate them where they should be.

All the world logic and drawing are inside the _World_ class, for example, and the same thing applies to all the other pieces of the game. It's clear that I don't have much to organize, but it was a good starting point to do all these refactorings.

# What Rings have until now?

Rings started as an experiment, just me trying to implement some cool game-development features. So, the project doesn't have much, just some split, badly implemented simple features, like particles, animations, collisions, and sparks (that I just copied from DaFlufy). But those simple things that I have will be re-write and documented here in the future.

For now, the game looks something like this:

![game-screen-shot](game-screen-shot.webp)

> I used the Nuclear Throne animation to test some stuff ;)

# Conclusion

As I said, Rings are only the start, and I pretend to turn it into a simple rogue-like game, and that's some of the things I will bring her to the game-studio blog.

I will bring some cool implementations and mainly focus on game-design architecture.

Hope you like it and Thanks for reading! You can follow all **Rings** articles in [tag/rings](/blog/tag/rings)

You can check out this project on my [RenatoCesraF/Rings](https://github.com/RenatoCesarF/Rings)


Minha experiência com DragonRuby

Recomendations