Algoritmo simulador de batallas

[0xDani]

Me gustaría ver código C++ si sale un simulador potente. Sugiero que se miren las especificaciones de C++ 11 

Lo que veo es que todavía no habéis hablado del simulador en sí como objeto. Con esto quiero decir que el simulador debería poder simular batallas con soldados distintos de las clases predefinidas para ello, tal vez clases derivadas, y debería haber mucho código reusable. Todo esto para que no haya que cambiar todo el mecanismo del simulador para cambiar de ejército, o modificar funciones internas del simulador para añadir características. Incluso el mismo simulador podría ser de una clase heredable.

[GeorgArming]

Me gustaría ver código C++ si sale un simulador potente. Sugiero que se miren las especificaciones de C++ 11  

Lo que veo es que todavía no habéis hablado del simulador en sí como objeto. Con esto quiero decir que el simulador debería poder simular batallas con soldados distintos de las clases predefinidas para ello, tal vez clases derivadas, y debería haber mucho código reusable. Todo esto para que no haya que cambiar todo el mecanismo del simulador para cambiar de ejército, o modificar funciones internas del simulador para añadir características. Incluso el mismo simulador podría ser de una clase heredable.

Es interesante lo que dices.

A ver, yo lo que había pensado para el simulador es que leyese los datos de los ejércitos a partir de una base de datos y a partir de ahí asignase los atributos. En ningún momento he dicho que en el propio código del simulador ya vayan predefinidos los valores de los atributos.

¿Sabes C++, no? ¿Te gustaría trabajar con nosotros?

Yo he estado codeando algo:

unity.hpp

Código [Seleccionar] Expandir

#include <string>

class Unity {
  public:
    std::string id;
    std::string generalType;
    std::string name;
    int numberOfSoldiers;
    int numberOfInjuredSoldiers;
    float motivation;
    float physicalState;
    std::string favourableWeather;
    std::string harmfulWeather;
    std::string favourableTerrain;
    std::string harmfulTerrain;
    float meleeAttack;
    float meleeDefense;
    float longDistanceAttack;
    float longDistanceDefense;
    float discipline;
    float speed;
    std::string generalTypeFavourable;
    std::string generalTypeHarmful;
    std::string concreteTypeFavourable;
    std::string concreteTypeHarmful;
    float nutrition;
    float resistence;
};


box.hpp (casilla)

Código [Seleccionar] Expandir

#include <string>

class Box {
  public:
    std::string id;
    std::string terrain;
    bool occupied;
    std::string unityId;
    float height;
};

mapcreator.hpp

Código [Seleccionar] Expandir

#include <iostream>
#include "box.hpp"
#include "unity.hpp"


int createMap() {
 Box box[10][10];
 for(int x = 0; x < 10; x++){
  for(int y = 0; y < 10; y++) {
  /*Asignar valores a cada casilla según parámetros leídos, por                ejemplo:box[x][y].id = ...
  box[x][y].terrain = ...
  box[x][y].occupied = ...
  box[x][y].unityId =
  box[x][y].height =
              */
  }
 }
 return 0;
}

Es muy poca cosa, porque para el codeo en sí he tenido poco tiempo... Pero esta noche avanzaré más. Los que estáis interesados en darle al código, podríamos buscar una forma de colaborar, no? Bitbucket?

Y por cierto, he comenzado con C++ pero si decidís otro lenguaje lo votamos o acordamos o algo...

Lo que me está bloqueando es qué valores asignar a las casillas, qué hacemos, creamos un mapa "de prueba"? Un .txt?

Saludos.

[za.asi]

Las características secundarias como la moral o el terreno favorable/desfaborable yo las marcaría como booleano que luego actuaría como modificador del porcentaje de exito global de la unidad.
Las casillas deben tener una correspondencia entre ellas: no puede ser que haya una casilla de montaña a 50m, al lado una de agua profunda a 0m, debajo una de bosque a 30m y en medio de estas dos una de llanura a 70m. Lo mas facil que se me ocurre para el mapa es crear varios mapas y despues elegir uno al azar.

Al menos para empezar creo que sería comodo trabajar con google docs.

[avesudra]

Hola, me parece un proyecto bastante interesante, no dudaría en colaborar. Para comunicarnos y organizarnos, voto por Google Docs para el proyecto y para hablar pues se crea un grupo en Google Groups y listo.

El simulador tendría que organizar la batalla con la táctica introducida por el usuario, mover las unidades y en cuanto éstas estén en el rango de alcance y en su turno, atacar. Estamos intentando crear una IA.

Bien, digamos que el desarrollo de este simulador podría ser el siguiente:

• 1. Mover ***¿según táctica?***.
• 2. Mirar el rango de alcance de cada una de las unidades y ver si hay enemigos.
• 3. Si está en el turno atacar.
• 4. Según las unidades, la fuerza del ataque, la defensa, la orografía del mapa y demás restar salud a ambas unidades únicamente si las dos están en su rango de alcance. Pongamos un ejemplo, si una unidad de arqueros ataca a una unidad de legionarios, los legionarios si no es cuerpo a cuerpo no provocan daño a los arqueros. Sin embargo si una unidad de caballería ataca a una de legionarios provocará más daño la de caballería, pero los legionarios también provocarán daño.
  

¡Un saludo!

[za.asi]

Yo dejaría las unidades así:

unity.hpp

Código [Seleccionar] Expandir

#include <string>

class Unity {
  public:
    std::string id;
    std::string generalType;
    std::string name;
    float meleeAttack;
    float meleeDefense;
    float longDistanceAttack;
    float longDistanceDefense;
    float rangeLongDistanceAttack
    float speed;
    std::string generalTypeFavourable;
    std::string generalTypeHarmful;
    std::string concreteTypeFavourable;
    std::string concreteTypeHarmful;
  private:
    int numberOfSoldiers;
    int numberOfInjuredSoldiers;
    float motivation;
    float physicalState;
    std::bool weather;
    std::bool terrain;
    float discipline;
    float nutrition;
    float resistence;
};


[0xDani]

Sí, en principio no tengo problema en colaborar, tengo tiempo.

En el código que habéis puesto sugiero que se establezcan los atributos de las clases como privados, y métodos getters y setters.

Qué opináis de usar C++ 11?

[avesudra]

Sí, en principio no tengo problema en colaborar, tengo tiempo.

En el código que habéis puesto sugiero que se establezcan los atributos de las clases como privados, y métodos getters y setters.

Qué opináis de usar C++ 11?

Yo también voto por poner los atributos como privados, es más lo iba a publicar ahora. En  cuanto a lo de C++11 me parece una buena idea, así practicamos. Solo tengo el header de momento pero bueno, las funciones get ya están implementadas:

Código (cpp) [Seleccionar] Expandir

#ifndef UNITY_H
#define UNITY_H
#include <string>

class Unity
{
    public:
        Unity();

        void        setID                           (std::string newID);
        void        setGeneralType                  (std::string newType);
        void        setName                         (std::string newName);
        void        setNumberOfSoldiers             (int newNumberOfSoldiers);
        void        setInjuredSoldiers              (int newInjuredSoldiers);
        void        setMotivation                   (float newMotivation);
        void        setPhysicalState                (float newPhysicalState);
        void        setFavourableWeather            (std::string newFavourableWeather);
        void        setHarmfulWeather               (std::string newHarmfulWeather);
        void        setFavourableTerrain            (std::string newFavourableTerrain);
        void        setHarmfulTerrain               (std::string newHarmfulTerrain);
        void        setMeleeAttack                  (float newMeleeAttack);
        void        setMeleeDefense                 (float newMeleeDefense);
        void        setLongDistanceAttack           (float newLongDistanceAttack);
        void        setLongDistanceDefense          (float newLongDistanceDefense);
        void        setDiscipline                   (float newDiscipline);
        void        setSpeed                        (float newSpeed);
        void        setGeneralTypeFavourable        (std::string newGeneralTypeFavourable);
        void        setGeneralTypeHarmful           (std::string newGeneralTypeHarmful);
        void        setConcreteTypeFavourable       (std::string newConcreteTypeFavourable);
        void        setConcreteTypeHarmful          (std::string newConcreteTypeHarmful);
        void        setNutrition                    (float newNutrition);
        void        setResistence                   (float newResistence);
       
        std::string getID()                         const{return id;}
        std::string getGeneralType()                const{return generalType;}
        std::string getName()                       const{return name;}
        int         getNumberOfSoldiers()           const{return numberOfSoldiers;}
        int         getInjuredSoldiers()            const{return numberOfInjuredSoldiers;}
        float       getMotivation()                 const{return motivation;}
        float       getPhysicalState()              const{return physicalState;}
        std::string getFavourableWeather()          const{return favourableWeather;}
        std::string getHarmfulWeather()             const{return harmfulWeather;}
        std::string getFavourableTerrain()          const{return favourableTerrain;}
        std::string getHarmfulTerrain()             const{return harmfulTerrain;}
        float       getMeleeAttack()                const{return meleeAttack;}
        float       getMeleeDefense()               const{return meleeDefense;}
        float       getLongDistanceAttack()         const{return longDistanceAttack;}
        float       getLongDistanceDefense()        const{return longDistanceDefense;}
        float       getDiscipline()                 const{return discipline;}
        float       getSpeed()                      const{return speed;}
        std::string getGeneralTypeFavourable()      const{return generalTypeFavourable;}
        std::string getGeneralTypeHarmful()         const{return generalTypeHarmful;}
        std::string getConcreteTypeFavourable()     const{return concreteTypeFavourable;}
        std::string getConcreteTypeHarmful()        const{return concreteTypeHarmful;}
        float       getNutrition()                  const{return nutrition;}
        float       getResistence()                 const{return resistence;}

        virtual ~Unity();

    private:

        std::string id;
        std::string generalType;
        std::string name;
        int numberOfSoldiers;
        int numberOfInjuredSoldiers;
        float motivation;
        float physicalState;
        std::string favourableWeather;
        std::string harmfulWeather;
        std::string favourableTerrain;
        std::string harmfulTerrain;
        float meleeAttack;
        float meleeDefense;
        float longDistanceAttack;
        float longDistanceDefense;
        float discipline;
        float speed;
        std::string generalTypeFavourable;
        std::string generalTypeHarmful;
        std::string concreteTypeFavourable;
        std::string concreteTypeHarmful;
        float nutrition;
        float resistence;
};


#endif // UNITY_H

[GeorgArming]

Perfecto, también estoy de acuerdo en ponerlos como privados. C++ 11 mola.

A ver, si os parece, los que estemos interesados nos apuntamos en una lista. Los posibles interesados:

avesudra: CONFIRMADO
0xDani: CONFIRMADO
za.asi: CONFIRMADO
xustyx: CONFIRMADO
eferion
GeorgArming: CONFIRMADO

Vamos confirmando, si os parece.

Confirmo.

[za.asi]

Confirmo

[avesudra]

Confirmo.

PD: ya he terminado las implementaciones y la documentación de todos los métodos setters y getters.