Diseñar un juego C++ con clases y orientación a objetos Vectores dinámicos o no

[candidatopardo]

¡Hola a todos! Os cuento un poco.
Se me ocurrió la idea de crear un sistema de modos de juego como el de League of Legends como práctica (no nos vayamos a pensar que trato de plagiar una idea que no es mía).

Yo estaba planteándome un sistema de clases que  es el que he empezado a desarrollar.

El problema lo tengo con la clase RegistroDeMuertes.. Os presento aquí lo que llevo hecho hasta ahora, en mi pseudocódigo inventado (espero, lo podáis entender)

Código: [Seleccionar]

-----------------------
Clase RegistroDeMuertes
-----------------------

[DEFINICIÓN]
El registro de muertes es una clase contenedor. Almacena los asesinatos, muertes, asistencias y su cuenta.

[VARIABLES PROTEGIDAS]
Variables contadores
Almacenan la suma de los asesinatos, muertes y asistencias del equipo
Se inicializan en 0. Numeros enteros con rango 0...X

asesinatos = 0
muertes = 0
asistencias = 0

Asesinato lAsesinatos[]
Muerte lMuertes[]
Asistencia lAsistencias[]

[PROTOTIPOS DE FUNCIONES PUBLICAS]
getAsesinatos() : Retorna asesinatos
getMuertes() : Retorna muertes
getAsistencias() : Retorna asistencias

nuevoAsesinato(ase,mue,equ) Añade un nuevo registro a la lista de asesinatos. E incrementa en 1 los asesinatos.

[DEFINICIÓN DE FUNCIONES PUBLICAS]
nuevoAsesinato(ase,mue,equ) {
asesinatos++
Asesinato nuevoAsesinato(ase,mue,equ)
Agregar nuevoAsesinato a lAsesinatos
// Su indice sera asesinatos-1
}
Quiero centrarme en el array lAsesinatos, que es un array que instancia objetos de la clase Asesinato. Así que también tenéis que conocer la clase Asesinato que es muy pequeña:

Código: [Seleccionar]

---------------
Clase Asesinato
---------------
[DEFINICIÓN]
Clase contenedora de un asesinato. Almacena asesino, equipo del asesinado y jugador asesinado.
En un futuro, almacenará tambien el minuto de la muerte.

[VARIABLES PROTEGIDAS]
asesino: Número entero. [Rango: 0 .. (Número de jugadores del equipo del asesino - 1)] Indice del asesino.
equipo: Número entero. [Rango: 0 .. (Número de equipos - 1)] Indice del equipo de la persona que ha muerto.
muerto: Número entero. [Rango: 0 .. (Número de jugadores del equipo del muerto - 1 )] Indice de la persona que ha muerto.

[FUNCIONES PÚBLICAS]
constructor(ase,mue,equ)

getAsesino()
getEquipo()
getMuerto()

setAsesino()
setEquipo()
setMuerto()
Mi juego, aunque utilice el mismo modo de juego que League of Legends, no es League of Legends. Es posible que en mi juego haya miles de asesinatos, que se van a ir almacenando en memoria si no hago nada al respecto. Suponiendo que sea un juego multijugador, con miles de partidas con miles de asesinatos, las maquinas para funcionar van a necesitar mucha memoria.

Entonces, son varias las preguntas que tengo y al final todas van a contestar una misma pregunta. ¿Cómo lo hago?

Antes de hacer las preguntas, tenéis que saber que los RegistroDeCombate completos (que se asocian a los equipos) los quiero almacenar en una base de datos MySQL, antes o después.

En lugar de almacenar en memoria los asesinatos, ¿Los envió directamente a la base de datos MySQL conforme vayan matándose los jugadores? ¿O los envió en bloques de 10 para aprovechar un poco la memoria? ¿O las envió cada cierto plazo de tiempo?

¡Gracias!

[César Krall]

Hola! Para dar una respuesta acertada habría que conocer bien el juego y yo no lo conozco además de que parece complejo. Al leer la descripción lo que me he preguntado es si realmente necesitas una clase Asesinato. Me pregunto primero si es necesario mantener tanta información. Por ejemplo de alguien que está muerto si necesitas mantener toda la información o si te bastaría contar que hay un muerto más y te da igual todo lo demás. Si te diera igual te ahorrarías estar almacenando información sobre los muertos.
Una opción que se me ocurre es que en cada jugador tengas un atributo:

asesinadoPor: integer

Si asesinadoPor vale -1 indicaría que el jugador está vivo. Si asesinadoPor vale otro número indicaría que el jugador está muerto y ha sido asesinado por el jugador con id el número que exista.

Si no necesitas información extra cada jugador llevaría su información y únicamente necesitarías mantener ciertos contadores generales.

Por otro lado, de cara a almacenar en bases de datos lo que tienes que tener en cuenta es que a base de datos fundamentalmente lo que debes enviar es información de la que requieras persistencia, es decir, que una vez apaguen el ordenador y lo vuelvan a encender se pueda recuperar. Para envío de datos frecuentes que puedas enviar en bloques siempre vería preferible el envío en bloques de modo que no tengas que estar accediendo a la base de datos continuamente. Son solo ideas, no sé si te servirán

Saludos!

[candidatopardo]

Hola César! La verdad es que lo creas que no, me has ayudado un montón. Ya sabes que las clases se lían muy rápido y quizás quería realizar un ejemplo demasiado complicado para la fase de aprendizaje en la que estoy.

Puedo simplificar todo con una simple variable en cada jugador, cosa que me ahorraría mucho trabajo. Y lo voy a hacer.

Lo de mandar información a la base de datos por bloques lo imaginaba, pero es que ahora lo tengo mas claro que antes. Y la teoría que me has dado también me viene bien. Es lo mismo de antes, con las bases de datos lo estoy complicando, voy a evitar utilizarlas por el momento.

Ya te contaré!