¿Cómo se compararían de manera sucinta los valores y se llamaría a las funciones de la clase base de muchas clases derivadas?

16 Jul, 2023 Programación 0

Tengo un motor de física 2D que he estado programando en C++ usando SFML; he implementado un sistema de detección de colisiones básico para todos los SandboxObjects (la clase base para cada tipo de objeto de física), pero tengo un dilema.

Planeo tener muchas clases derivadas diferentes de SandboxObjects, como Circles, Rects, y así sucesivamente, pero quiero una forma de verificar si el roughHitbox de cada SandboxObject colisiona con otro.

Cuando el programa comienza, reserva memoria para, digamos, 10,000 Circles como este:
c++ int circleCount = 0; // el número de Circles activos constexpr int m_maxNumberOfCircles = 10000; // el mayor número de círculos que pueden estar activos Circle* m_circles = new Circle[m_maxNumberOfCircles]; // crea un arreglo de círculos que no están activos de forma predeterminada

y cada vez que el usuario crea un nuevo Circle, el código se ejecuta así:
c++ (m_circles + circleCount)->setActive(); circleCount++

Los Circles que no están activos básicamente no existen en absoluto; podrían tener posiciones y radios, pero esa información nunca se utilizará si ese Circle no está activo.

Dado todo esto, lo que quiero hacer es recorrer todas las matrices diferentes de clases derivadas de SandboxObject porque SandboxObject es la clase base que implementa las cosas relacionadas con el hitbox básico, pero como habrá muchas clases derivadas diferentes, no sé cuál es la mejor manera de hacerlo.

Un enfoque que intenté (con poco éxito) fue tener un puntero a un SandboxObject como este:
c++ SandboxObject* m_primaryObjectPointer = nullptr;
este puntero estaría nulo a menos que haya más de 1 SandboxObject activo. Con él, intenté usar funciones de incremento y decremento que comprobaran si puede apuntar al siguiente SandboxObject, pero no pude hacer que funcionara correctamente porque un puntero de clase base a una clase derivada se comporta de manera extraña. :/

No estoy buscando implementaciones de código exactas, solo un método probado para trabajar con la clase base de muchas clases derivadas diferentes.

Avísame si hay algo que deba editar en esta pregunta o si hay más información que pueda proporcionar.

Luego, cuando llegue el momento de recorrer el vector y verificar colisiones, podrías hacer algo como esto: ```c++ // Recorrer todos los objetos en el vector for (auto obj : objects) { // Solo verificar la roughHitbox si el objeto está activo if (obj->isActive()) { // Llamar a la función roughHitbox en el objeto actual sf::FloatRect roughHitbox = obj->roughHitbox(); // Recorrer todos los objetos nuevamente para verificar colisiones for (auto obj2 : objects) { // Solo verificar colisiones si ambos objetos están activos y no son el mismo objeto if (obj != obj2 && obj2->isActive()) { // Verificar colisión entre los dos objetos sf::FloatRect roughHitbox2 = obj2->roughHitbox(); if (roughHitbox.intersects(roughHitbox2)) { // Manejar la colisión } } } } }

Answer

davy.ai

July 16, 2023 at 2:35 pm
Un enfoque que puede funcionar para iterar sobre todos los diferentes arreglos de clases derivadas de SandboxObject es usar un std::vector de punteros SandboxObject*. Cada objeto de clase derivada que se genere podría agregarse a este vector. Luego, cuando llegue el momento de verificar colisiones, podrías recorrer este vector y llamar a la función roughHitbox en cada puntero SandboxObject.

Este enfoque permitiría agregar y eliminar objetos fácilmente de la verificación de colisiones sin tener que preocuparse por los índices, y funcionaría bien con la función setActive() que has implementado para tus objetos Circle.

Para implementar este enfoque, debes asegurarte de que cada objeto de clase derivada se agregue al vector como un puntero SandboxObject*. Por ejemplo, si tienes un objeto Circle llamado myCircle, podrías agregarlo al vector de la siguiente manera:

“`c++
std::vector<sandboxobject*> objects;

// Generar un nuevo círculo
Circle* myCircle = new Circle();
myCircle->setActive();

// Agregar el círculo al vector
objects.push_back(myCircle);
```
Luego, cuando llegue el momento de recorrer el vector y verificar colisiones, podrías hacer algo como esto:

```c++
// Recorrer todos los objetos en el vector
for (auto obj : objects) {
    // Solo verificar la roughHitbox si el objeto está activo
    if (obj->isActive()) {
        // Llamar a la función roughHitbox en el objeto actual
        sf::FloatRect roughHitbox = obj->roughHitbox();

        // Recorrer todos los objetos nuevamente para verificar colisiones
        for (auto obj2 : objects) {
            // Solo verificar colisiones si ambos objetos están activos y no son el mismo objeto
            if (obj != obj2 && obj2->isActive()) {
                // Verificar colisión entre los dos objetos
                sf::FloatRect roughHitbox2 = obj2->roughHitbox();
                if (roughHitbox.intersects(roughHitbox2)) {
                    // Manejar la colisión
                }
            }
        }
    }
}
```
En general, utilizar un std::vector de punteros SandboxObject* debería permitirte recorrer fácilmente todos los diferentes arreglos de clases derivadas de SandboxObject y verificar colisiones entre objetos activos.</sandboxobject*>

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

¿Cómo se compararían de manera sucinta los valores y se llamaría a las funciones de la clase base de muchas clases derivadas?

Answer

davy.ai