La descripción del problema que das es bastante vaga. ¿Es un para un RTS tipo Age of Empires u otra cosa más sencilla? Dependerá del nivel de complejidad que quieras alcanzar pero no te recomiendo una máquina de estados.

Lo primero es que probablemente no necesites un único sistema de IA. Por ejemplo, dices que hay que comerciar y construir por lo que la IA tendrá que decidir qué construye y dónde. Atacar y defender tampoco son cosas sencillas si quieres hacer algo interesante: ¿Habrá coordinación entre las unidades? ¿Atacarán con una formación? ¿Atacarán por flancos o por la retaguardia?. Para defender, ¿dónde situo las unidades? ¿Son todas las unidades iguales o algunas tienen mayor rango de tiro y es mejor ponerlas en sitios elevados?

A poco que quieras hacer algo complejo necesitarás muchas cosas. Lo normal en estos casos es tener varios niveles de IA. En el más bajo podría encajar una máquina de estados aunque sigo sin recomendarlas.

Quizás primero deberías aclarar exactamente qué quieres conseguir.

P.D.: Yo también soy de Las Palmas. Me alegra ver más gente de la tierra por aquí.

Esto funciona en el Visual 2005:

Código [Seleccionar] Expand


class A
{
   virtual A *Clone() const {  return new A; }
};

class B : public A
{
 virtual B *Clone() const {  return new B; }
};

B b;
A* ese = b.Clone();


En cualquier caso, que use el que más le guste hasta que encuentre un problema que no pueda solucionar (yo los he tenido con el Borland).

_SECURE_SCL es una de las macros. La otra que yo conozco es _HAS_ITERATOR_DEBUGGING.

Lo mejor para deshabilitarlos es añadirlas en las opciones de todos los proyectos de la solución /D_SECURE_SCL=0 por ejemplo.

Es un patron de diseño, no me refiero a poner virtual antes de un constructor.

A eso me referia con idiom. Si no recuerdo mal, para implementarlo sólo se hace uso de dos métodos virtuales (create y clone), por eso decía que no sé dónde encontraste el problema.

El Visual 2005 trae una implementación de la STL que añade muchos checks por seguridad que no había en otras versiones. Es probable que encuentres diferencias de rendimiento incluso entre Visual 2003 y Visual 2005. Existen macros que desactivan esos checks pero no las recuerdo porque no uso esta versión del compilador. Busca en google, hay varias discusiones relativas a pérdidas de rendimiento en la STL en el 2005.

Para mi el mejor compilador es el GCC, esta mas actualizado que cualquiera, si intentas usar constructores virtuales en los demas (Borland C++ Builder 6.0, Visual C++, Visual Studio, Open Watcom) no te compilara.

¿Constructores virtuales? Esto no existe, a no ser que te refieras a implementar el idiom en cuyo caso no veo que problema hay con cualquiera de los compiladores que indicas.

Como dice Helius, lo mejor es que mires el PSPLink.

Yo lo único que hago es compilar el ejecutable (ni siquiera genero el pbp) y desde una consola conectada a la PSP le digo que lo ejecute (o bien que lo cargue para ser depurado desde el pc). Así que ni siquiera hay que cambiar a la conexión usb para pasar el programa a la consola.

Este programa es fundamental para poder trabajar bien.

una preguntilla, sabes si el pspbrew se puede hacer servir en modo batch? Es que me parece un conyazo tener que ejecutar el programa, cargar, clicar, ... cuando en el makefile se podria meter todo directamente y ya lo copiaria automaticamente a la psp.

No se si sabes que en el makefile hay reglas para generar los eboots e incluso te genera las carpetas para usarlas en 1.5. Lo de cargar automáticamente ya deja de ser necesario con el PSPLink aunque yo al principio lo hacía con una regla de makefile que me montaba el dispositivo, copiaba las carpetas y desmontaba.

Hay más tutoriales de programación en http://www.psp-programming.com. Yo estoy siguiendo ahora los de que están en la sección Code/C Tutorials. Aquí están los primeros capítulos de los tutoriales NeHe de OpenGL pero en PSP.

Yo ya llevo un tiempo trabajando con el SDK. Hasta ahora sólo había hecho un par de aplicaciones sencillas a base de modificar los ejemplos que vienen con el SDK pero ya estoy empezando un pequeño motor. Las aspiraciones no son grandes, simplemente conocer lo que es programar para una consola.

De lo mejor que he visto multiplataforma es el Poseidon for UML http://www.gentleware.com/products.html

De hecho, si no recuerdo mal, esta compañía partió del ArgoUML para crear este producto. Tienen una versión libre (Communitiy edition) sin algunas características pero nada que no te permita usarlo para crear los diagramas.

¿Qué programa usas?

Yo tengo instalado el Bookr pero si pongo el zoom de tal manera que quepa todo el ancho del párrafo, las letras se ven muy pequeñas.

Saludos.

Yo también uso el Bookr. Por lo general depende del documento pero yo prefiero hacer zoom y desplazar a izquierda y derecha para ir leyendo. De todas formas, el que estoy leyendo ahora con zoom 1x cabe el párrafo completo y se lee perfectamente.

Yo uso mi PSP para leer PDFs y va muy bien. Es más barata que alguna de las opciones comentadas y hay aplicaciones de todo tipo. Por supuesto, también sirve para jugar :D. Lo único sería comprar una cuyo firmware permita la ejecución de estas aplicaciones.

Creo que el problema es que no estás importando las definiciones en el fichero que usa la dll. Para usar una dll hay dos pasos:

1. Crear la dll, tal y como tú hiciste.
2. Importar la dll en el fichero en el que quieras usarla.

Lo que te falla es el paso 2. Cuando incluyes my_dLL.h en game.cpp, CmyDLL no tiene que tener __declspec(dllexport) sino __declspec(dllimport). Para no tener dos ficheros .h con la misma declaración y diferente atributo se suele usar un truco con macros:

Código [Seleccionar] Expand


my_DLL.h
----------------------
#ifdef _DLL_CPP_
#define DLL_DECL_SPEC __declspec(dllexport)
#else
#define DLL_DECL_SPEC __declspec(dllimport)
#endif

class DLL_DECL_SPEC CmyDLL { ... };

my_DLL.cpp
----------------------

#define _DLL_CPP_
#include "my_DLL.h"

// .... Resto del fichero sustituyendo __declspec(dllexport) por DLL_DECL_SPEC (aunque creo que no es necesario)


Y game.cpp lo dejas tal y como está. Al incluir my_DLL.h desde game.cpp _DLL_CPP_ no estará definido por lo que DLL_DECL_SPEC será __declspec(dllimport). En cambio, al compilar my_DLL.cpp, DLL_DECL_SPEC será __declspec(dllexport).

Creo que con esto resolverás el problema.

Sin ver la declaración de la clase y el error exacto es difícil saber cuál es el problema.

Imagino que en el proyecto de prueba te faltará por añadir el fichero ".lib" que se genera junto con la DLL.

En eso no puedo ayudarte. Hace mucho que dejé el Visual 6 y no tengo ninguno a mano para comprobarlo.

El problema es que si una función espera un point y recibe un pointD me peta, el sistema no sabe hacer el cast de uno a otro.

Point y PointD son dos tipos completamente distintos, el compilador no sabe como convertir entre ellos por lo que tienes que proporcionar los métodos adecuados si quieres conversiones automáticas:

Código [Seleccionar] Expand


template <typename Type>
struct VECTOR3
{
 VECTOR3()
   : x (0), y(0), z(0) { }

 template <typename OtherType>
 VECTOR3(const OtherType &other)
 {
   *this = other;
 }
 
 template <typename OtherType>
 VECTOR3 &operator=(const OtherType &other)
 {
   x = static_cast<Type>(other.x);
   y = static_cast<Type>(other.y);
   z = static_cast<Type>(other.z);

   return *this;
 }

 Type x, y, z;
};

typedef VECTOR3<float> Point;
typedef VECTOR3<double> PointD;

void f(const Point &p)
{
}

void g(const PointD &pd)
{
}

int main(int, char **)
{
 Point p;
 PointD pd;

 f(p);
 f(pd);
 g(p);
 g(pd);

 return 0;
}



El constructor y operator= son templates cuyo tipo es distinto del que usas para instanciar VECTOR3 por lo que te permiten usar un VECTOR3<float> donde requieres un VECTOR3<double>.

Los static_cast te evitan los warnings cuando hay, por ejemplo, conversiones de float a int.

El problema es que esto genera variables temporales. Las llamadas f(pd) y g(p) construyen una variable temporal que es la que pasan al método. Si quieres evitar la creación de variables automáticas haz que el constructor sea "explicit":

Código [Seleccionar] Expand


 template <typename OtherType>
 explicit VECTOR3(const OtherType &other)
 {
   *this = other;
 }

 ...

 f(p);
 f(Point(pd));
 g(PointD(p));
 g(pd);



Espero que esto te sirva de ayuda.

Hace tiempo ya de este hilo pero por si sigues buscando la respuesta:

Código [Seleccionar] Expand


template <int n> class x {  };
class y { template <class> friend class x; };