[Godot] Optimizar codigo de función

#1 No parece un código que debiera dar problemas para ir fluido. Leyéndolo se me ocurre alguna pequeña optimización pero no creo que hiciera una gran diferencia. Sospecho que puede tener que ver con cómo esté Python implementando las matrices (con qué estructuras de datos: arrays, listas, etc).

De todas formas, la función get_living_neighbors podrías optimizarla si a esas matrices les dejas una columa y fila extra vacías en cada extremo (por ejemplo si vas a 100x100, la matriz la haces de 102x102) y así te quitas todo ese cálculo de ver lo que pasa en los bordes, para cada pixel:

func get_living_neighbors(x, y):
    #función helper que cuenta celulas alrededor de una posición (x,y)
    #devuelve el número de celdas adyacentes
    var vecinos = 0
    for i in range(-1,2):
        for j in range(-1,2):
            if i != 0 and j != 0:
                vecinos += matrix[x + i][y + j]
    return vecinos

#2 Ese pequeño calculo me permite transformar la cuadrícula en un torus. De todas formas lo he probado tal y como has puesto y el resultado es el mismo, así que la pérdida de rendimiento no viene por ese cálculo.

#3 Bien visto. Lo he implementado y tampoco hay mejora alguna.

Lo que deduzco es que el motor pierde mucho tiempo al dibujar la matriz en pantalla (no en los cálculos). En lugar de dibujar cuadrados con draw_rect() he probado de dibujar circulitos con draw_circle(position, radius) y el rendimiento empeora x5.

Quizás representar el valor de una matriz con llamadas a draw() consume muchos recursos? De momento esto es lo que parece. Voy a cambiar el código para pintarlo de otra forma, por ejemplo instanciando sprites de colores... pero la lógica me dice que debería ir peor.

#5 Justo a ello voy

Opté primero por no instanciar sprites y tirar de draw() porque me pareció menos costoso. Ahora en unos minutos edito y os digo.

#7 Con sprites parece que el proceso es algo más fluido, pero es muchísimo más lento de inicializar.

Es decir, en el momento de empezar, tengo que instanciar en tiempo de ejecución 100x100 objetos, posicionarlos en pantalla en forma de cuadrícula. Este proceso es lento hasta el punto que la ventana se queda congelada.

Una vez termina, el trabajo sobre esta matriz de sprites es algo más rápido y fluido. Voy a seguir probando diferentes formas a ver...

#9 hummmm, con esto quizás? https://docs.godotengine.org/es/stable/classes/class_bitmap.html

Lo que tendría que mirar como pintar ese bitmap o asignarlo a un sprite. De momento he intentado usar la clase TileMap y es lo que mejor rendimiento tiene, pese a que no va fluido como otros ejemplos/implementaciones que he visto.

Y no sería mejor en cuanto generas el rand en la matriz, si uno está vivo (1) te guardas esa posición.
entonces para pintar el primer fondo lo pintas directamente todo negro que seguro que hay alguna forma de poder hacerlo más rápido al ser todo lo mismo y luego para pintar los blancos con loopear solo los que eran vivos es suficiente así pintas mucho menos.
y en la actualización algo similar, solo te guardas las celdas que realmente han cambiado y entonces loopeas solo estas.

#15 no sé que es eso.

#13 #14 voy a implementar esto, que seguramente sea lo más eficiente. La pérdida de rendimiento la tengo cuando quiero dibujar toda la matriz en pantalla, en cada frame. Debería poder detectar únicamente los cambios y pintar los nuevos (que serán pocos en cada ciclo). Eso debería funcionar. Gracias chicos.

Como soy un cabeza hueca, me he empezado a ir por las ramas y he terminado implementando una hormiga de Langton para hacer los tests.

Podéis probarla aquí: https://aikoncwd.ovh/langton-ant/

Se pueden establecer el tamaño del mapa, número de hormigas y velocidad. A partir del ciclo 10.000 aparece el atractor típico de la hormiga, así que la implementación de este autómata es correcto.

A la noche quizás limpie el proyecto y suba un hilo explicando un poco en que consiste y por qué es tan fascinante.

#17 aaah vale, se referia a eso xd.

El cuello está en la CPU, ya que todo el perfil de la GPU ni se entera.
draw_rect dibuja un rectangulo. Aquí hay una buena info en la entradilla y puede ser que no necesite llamar a _draw() en cada frame -> https://docs.godotengine.org/es/stable/classes/class_canvasitem.html

Estoy dibujando con batching. Te dejo 2 fotos, la primera sin batching y la segunda con batching

La rejilla era de 180x100. Sin batching meto 18000 calls al drawn y con batching bajo a los 1000 calls (a medida que las celulas van muriendo) pero empiezo haciendo apenas 4000 calls, así que el batching funciona.

Lo que me sorprende es que con batching tengo la misma latencia 120_130ms que usando batching.

edit:

Acabo de descubrir la pestaña profiler en godot xd. No sé utilizar la herramienta pero bueno, dejo una foto: