domingo, 21 de agosto de 2016

Generación procedural de circuitos de carreras - Parte 2 | Race Track Procedural Generation - Part 2

Español | English


Esta va a ser la 2da parte de una serie de Posts en donde explico como crear pistas de carreras generadas aleatoriamente. La primer parte la pueden encontrar en mi blog.

En la parte anterior, había definido la siguiente estructura lógica que iba a utilizar el algoritmo de geneación:
  1. Generar un elemento de forma aleatoria
  2. Si ese elemento es una recta, seguir de largo, si es una curva, girar
  3. Repetir 1-2 hasta tener una cierta cantidad de elementos
  4. Buscar la forma de el último elemento con la posición inicial
Esta manera fue descartada, ya que había muchas cuestiones a tener en cuenta, como las rotaciones de las distintas partes y como estas influyen a las siguientes.

Así también como el hecho de que no era capaz de indicar el tamaño del mapa, ya que cada vez que se generaba, se creaba un camino hacia un sentido aleatorio, de esta forma no se podía limitar a que el mapa ocupe "10 unidades del eje Y".

Por eso que decidí cambiar la idea, teniendo primero una "grilla" que si puedo dimensionar y luego eligiendo las partes que van a ser usadas para la pista. Entonces el algoritmo se modificó a que recorra la siguiente secuencia:

  1. Crear una grilla de dimensiones X  e Y indicadas.
  2. Seleccionar los nodos eligiendo lugares aleatorios de la grilla
  3. Unir los nodos.

Esta idea de nodos esta pensada a base de Grafos:



En donde para generar el circuito, elijo cuantos nodos quiero que existan y luego busco la manera en la cual pueda unirlos (generar las aristas) de formas aleatorias, para que de una misma posición de nodos, pueda tener distintas variantes.

Por ahora estoy en la etapa 2. Estoy creando la forma en la cual se puedan elegir los nodos de forma aleatoria sin repeticiones y en lo posible que no estén juntos.



En la imagen se pueden ver: Los parámetros para la creación de la grilla, la grilla con sus elementos en gris y los nodos seleccionados aleatoriamente en rojo.

Lo siguiente es indicarle a las posiciones que se eligieron que van a representar nodos. Luego de eso, empieza la etapa 3 de pathfinding, en la cual a partir de esos puntos, hay que crear las formas de unirlos para generar los circuitos.

-L 


-------------------------------------------------------------------------------------------------------------------------
English


This is going to be the second part of a series of Posts where I explain who to create procedural generated racing tracks. You can find the first part on my blog.

On the previous part, I've defined the next series of steps that were going to be part of the generator algorithm:
  1. Generate a random element
  2. If that element is a straight line, move forward, if it is a curve, turn
  3. Repeat 1-2 until there are a certain amount of elements
  4. Find the way to join the final position with the starting position
This way was thrown away, as there were too many things to take into consideration, like the rotations of the different parts and how they influence on the next parts.

As well as the fact that I wasn't able to set the size of he map, because every time the map was generated, a different path as created, so I couldn't limit the size map by saying that the map should be "10 units on the Y axis".

That's why I decided to change the idea, using a grid which in fact I can set the size and then selecting the parts that are going to be used for the track. So the algorithm changed to follow the next steps.
  1. Create a grid of X and Y dimensions.
  2. Select the nodes by selecting a random positions of the grid.
  3. Join the nodes
This node-idea was thought thinking of Graphs:



Where to generate the track, I choose how many nodes I want and then I find the way to join them together (generate the edges) in random ways, so the same set of positions of nodes can generate different variatons.

Right now I'm on stage 2. I'm creating the way in which I can select the nodes from the random positions of the grid without repeating and if possible, not side by side.




On the image it can be seen: The parameters for the creating of the grid, the grid with its grey elements and the nodes, randomly selected in red.

The next step is to indicate to those positions that were chosen that they will represent nodes. After that, the 3 stage begins, pathfinding. In which I'll have to create different ways to join the nodes to generate the racing tracks.

-L 

lunes, 15 de agosto de 2016

Generación procedural de circuitos de carreras - Parte 1 | Race Track Procedural Generation - Part 1

Español | English 


Hoy vengo a presentar un nuevo proyecto/desafío. Me propuse crear un algoritmo para crear circuitos de carreras de forma aleatoria en Unity. Esta va a ser la parte 1 de no se cuantas en las que voy a explicar como hago para lograr mi objetivo.

La idea básica sobre la cual va a funcionar el algoritmo es:

  1. Generar un elemento de forma aleatoria
  2. Si ese elemento es una recta, seguir de largo, si es una curva, girar
  3. Repetir 1-2 hasta tener una cierta cantidad de elementos
  4. Buscar la forma de el último elemento con la posición inicial
Hasta ahora estoy en el paso 3. En la cual puedo generar varios elementos y colocarlos como hijos de un elemento llamado "Track". Lo que puedo generar por ahora es esto:


Los elementos rojos son Curvas rectas, los marrones son curvas hacia la izquierda y los violeta curvas hacia la derecha. Por ahora solo quería probar como resultaba el paso 1 y el paso 2.

La lógica (mal hecha) fue: si se crea una recta, mover hacia adelante y generar otro elemento, si es una curva, mover hacia el costado y generar otro elemento y así sucesivamente. 

¿Por qué esta mal? Porque no tomé en cuenta las rotaciones que generan las curvas, para poder apreciarlas voy a necesitar más que una imagen de un cuadrado.

Pero como primera etapa, lo considero adecuado. Lo que tengo que hacer para tener esta etapa bien definida es no solo desplazar la posición antes de generar un nuevo elemento, sino que también rotarlo si el anterior era un curva, para crear un nuevo sentido.

Lo más difícil va a ser la etapa 4, en la cual tengo que hacer que desde la posición final, se creen los elementos necesarios para volver al inicio, algo que se me viene a la mente para hacer esto es utilizar un simple algoritmo de A* path-finding. 

Eso es todo por ahora, espero que les guste el nuevo desafío, cualquier duda o sugerencia pueden dejarla en los comentarios.


-L


-----------------------------------------------------------------------------------------------------------

English


Today I'm here to present a new project/challenge. I made up my mind to create an algorithm that creates race tracks randomly in Unity. This is going to be part 1 of I don't know how many, in which I'll be explaining what I'm thinking in order to achieve my goal.

The basic idea on which the algorithm works is:
  1. Generate a random element
  2. If that element is a straight line, move forward, if it is a curve, turn
  3. Repeat 1-2 until there are a certain amount of elements
  4. Find the way to join the final position with the starting position
For now I'm on step 3. In which I can create several elements and put them as child of a GameObject named "Track". What I can generate by now is this:


The logic (poorly made) was: If a straight line is created, move forward and generate another element, if it is a curve, move to the side and generate another element and so on...

Why it is poorly made? Because I didn't take into consideration the rotations that the curves generate, to be able to see them more clearly I'll have to use something else than a red square.

But for the first stage, I found it right. What I have to do in order to make this stage properly is to not only move the position of the next element that is going to be generated, but also rotate it if the previous element was a curve, in order to create a new direction.

The most difficult stage is going to be stage 4, where I have to figure out a way in which, from the final position, create the necessary elements that are needed to come back to the starting point. Something that comes to my mind for this task might be a simple A* path-finding algorithm.

That's all for now, I hope you like this new challenge, for any doubt or suggestion you can write me a comment.


-L

domingo, 14 de agosto de 2016

¿Y ahora qué? | And now what?

Español | English

Ahora que terminé el proyecto Nerdy Run, debo elegir si quiero algún nuevo proyecto para enfocarme, aunque también no hay que dejar de lado la tarea de seguir haciendo promoción para mis juegos.

Entre todos los proyectos que tengo para hacer, debería elegir por cual inclinarme más, también como decidir si volver a desarrollar para Android o pasar a la PC... Aunque por otro lado también tengo que practicar más mis habilidades artísticas.

Por eso es que tenía pensado más que nada realizar arte variado, ilustraciones, temas musicales, crear "Assets" que tal vez me sirvan para un futuro juego. Así también como practicar conceptos de programación, ver como crear un FPS o un Tower Defense por más simple que sea.

Así que mi objetivo por ahora es variado, practicar un poco de todo antes de meterme de lleno en un solo proyecto, de esta forma voy a poder practicar varias áreas dentro de el desarrollo de video-juegos, así también como subir nuevos tutoriales.

Así que estén atentos al blog!


-L

------------------------------------------------------------------------------------------------------------
English

Now that I've finished the project Nerdy Run, I must choose if I want a new project to focus all my time to, although I shouldn't leave aside the task of promoting my games. 

Between all the projects I have to do, I should choose which one to focus my attention to and decide whether I should continue developing for Android or go to PC... Although on the other hand I also have to practice my art skills

That it why I was thinking of doing varied art, illustrations, music themes, create "Assets" that I might one day use for a game. As well as practice my programming skills, like how to create a basic FPS or a Tower Defense, as simple as it can be.

So my goal now is varied, practice a little bit of everything before stepping into a new project, in this way, I can practice several areas that merge together to make the development of games, as well as uploading new tutorials.


So stay tuned to the blog!

-L

viernes, 5 de agosto de 2016

Nerdy Run publicado!!! | Nerdy Run released!!!

Español |  English



Al fin! Nerdy Run ya está disponible para descargar en la tienda de Google Play. Hasta ahora tuve buenas respuestas de parte de amigos/conocidos. 

Hasta mañana no voy a tener ningún tipo de dato como cantidad de descargas o similares, también tengo que esperar hasta que Admob reconozca la aplicación en Google Play para poder vincular la cuenta.

A partir de ahora mi trabajo va a ser compartir el juego, promocionarlo y escuchar las devoluciones de los usuarios. También voy a trabajar en una actualización en donde esté integrado Tappx para utilizar el servicio de Closs-Promotion.

Eso es todo por ahora, espero que disfruten el juego.



-L




------------------------------------------------------------------------------------------------------

 English



Finally! Nerdy Run is available on the Google Play store. So far I had good responses from my friends and people I know.

Until tomorrow I won't be able to tell how many downloads the game has or that kind of information, I have to wait for Admob too to recognize the game on the Play Store so I can link the app.

From now on my job will be to share the game, promote it and listen to the users' feedback. I'll also be working on an update where I'll implement Tappx so I can use the Cross-Promotion service.

That's all for now, I hope you enjoy the game.


-L

jueves, 4 de agosto de 2016

Preparando todo para mañana | Setting up everything for tomorrow

Español | English



Nerdy Run ya esta completamente terminado. Fue probado varias veces y todo funciona. Solo queda esperar hasta  mañana para ya subirlo a la tienda de Google Play.

Al final decidí lanzarlo solo con Admob, sin Tappx ya que para implementar Tapps necesito que la App ya esté publicada, por eso, primero la publicaré y luego haré las cosas necesarias para que ambos servicios funcionen al mismo tiempo.

Un dato curioso es que salió una nueva versión del plug-in de Admob para Unity, lo que generó nuevos conflictos a la hora de implementarlo, pero afortunadamente encontré una solución. Espero que no haya nuevos conflictos entre Admob y Tappx.

Fue un lindo momento cuando me di cuenta que finalmente estaba terminado, ya todo corregido, ya no más cosas pendientes. Ahora solo queda publicar y esperar a ver la opinión de la gente.


-L


------------------------------------------------------------------------------------------------------

English



Nerdy Run is completely finished. I was tested several times and it works. I just need to wait until tomorrow to launch it on the Google Play Store.

I decided finally to launch it only with Admob, as Tappx needs the App to be already launched, so I'll launch it with Admob and then take the steps needed to implement Tappx and make sure they both work properly at the same time.

Something unexpected was that Admob released a new plug-in for Unity, which has generated many problems when people tried to use it but luckily I've found a solution. I hope there aren't new conflicts between Tappx and Admob.

It was a nice moment when I realized it was finally over, everything fixed, no more things to add. Now I have to publish it and see what people think about my game.

-L

miércoles, 3 de agosto de 2016

De idea a proyecto | From an idea to a project

Español | English



Como pueden ver en la foto de la izquierda, todo empezó con cuadrados rojos y sin fondo. De a poco se fuero agregando los detalles, corrigiendo las mecánicas y mejorando todo.

Si bien este proyecto me llevó más tiempo de lo que le tenía planeado, estoy contento con lo que se logró. Se pudo combinar de una forma divertida la base de Infinite Runner con los mini-juegos para resolver.


Esta bueno ver estas fotos y ver la diferencia entre lo que se pensó y lo que resultó ser.


La primera idea que tuve fue de hacer el juego en donde el personaje corría hacia abajo y nos desplazamos de izquierda a derecha.



También para algunos mini-juegos hubieron conceptos que después fueron descartados.


De cuadrados rojos a personajes y puntuación. El juego claramente evolucionó desde su etapa inicial, por mi lado voy a seguir trabajando para tener el juego listo para el viernes!



-L

--------------------------------------------------------------------------------------------

English


As you can see on the foto of the left, it all stated with red squares and without a background. Little by little the details were being added, the mechanics fixed and everything was improved.

Although this project took me more time than what I had planned, I'm happy with what I've achieved. The Infinite Runner base was successfully combined with the mini-games.



It is nice to look at this pictures and see the difference between what was first thought and what it become.


The first idea I had was to make the game so that the character run downwards and we move to the left or right.


There were some concepts of the mini-games that were also thrown away.


From red squares to characters and score. The game clearly evolved since its initial stage, by my side I'll continue working on the game so its ready for Friday!


-L

lunes, 1 de agosto de 2016

Fecha de lanzamiento de Nerdy Run! | Nerdy Run Release Date!


Español | English




Hola a todos, hoy les vengo a comentar una buena noticia: Nerdy Run tiene fecha de lanzamiento!

Estoy trabajando en los últimos detalles y haciendo las últimas pruebas. La fecha de lanzamiento es este viernes 5/8/16. Por lo que el juego estará disponible el día siguiente,sábado, en la tienda de Google Play.

El juego es completamente gratis. Durante la semana iré publicando más detalles sobre los programas que usé y voy a contar algunas historias y anécdotas. Así también como subir más tutoriales sobre las mecánicas que fui utilizando.

Así que sigan al tanto por más noticias!

-L

---------------------------------------------------------------------------------------------------------


English





Hello everyone, today I'm here to tell some good news: Nerdy Run has a release date!

I'm working on the last details of the game and doing the last tests. The release date is this Friday 5/8/16. So the game will be available on Google Play the next day, Saturday.

The game is completely free. During the week I'll be posting more details about the programs that I used and I'm going to tell some stories and anecdotes that happened to me. Also, I'll be uploading more tutorials about the mechanics I used for the game.

So stay tuned for more news!

-L