Sólo para recordar
From the category archives:
Otro juego de fútbol multiusuario en el cual colaboré con la programación del lado del servidor. Lo interesante que tuvo este proyecto es que había bots que jugaban junto con el jugador y en su contra utilizando agentes y máquinas de estado.
 "Juego contra la computadora"){kind=small}
 "Lobby del juego"){kind=small}
 "Programé en mi laptop, pero con monitor y teclado"){kind=small}
Otra cosa que me gustó de este proyecto es que apliqué "nuevas técnicas" que me permitieron desarrollarlo en tiempo récord desde cero.
{ 3 comments }
Una pequeña prueba de concepto para agregar figuras 3D a videos para juegos y otras aplicaciones.
Por supuesto que el guión no esta basado en algo que me haya pasado 
{ 3 comments }
Cuando manejamos herencia, a veces es necesario poder diferenciar entre varias clases heredadas. Una forma ordenada de hacerlo, es declarar una variable tipo que nos identifique con que clase estamos trabajando. Otra opción es realizando un casting dinámico para aprovechar las propiedades RTTI (Run-time type information) de los objetos de C++. Si el casting nos regresa NULL es que no es del tipo que nos interesa.
A continuación presento un ejemplo que ilustra esta técnica:
using namespace std;
class Figura {
public:
// Es importante que la clase base sea polimorfica agregándole al menos una función virtual:
virtual ~Figura() { };
};
class Triangulo : public Figura {
};
class Cuadrado : public Figura {
};
main() {
Figura *figura1 = new Cuadrado;
Figura *figura2 = new Triangulo;
if ( dynamic_cast<Cuadrado *>( figura1 ) )
cout <<"La figura1 es un Cuadrado" <<endl;
else if ( dynamic_cast<Triangulo *>( figura1 ) )
cout <<"La figura1 es un Triangulo" <<endl;
if ( dynamic_cast<Cuadrado *>( figura2 ) )
cout <<"La figura2 es un Cuadrado" <<endl;
else if ( dynamic_cast<Triangulo *>( figura2 ) )
cout <<"La figura2 es un Triangulo" <<endl;
return 0;
}
Aquí lo puedes ver en acción: http://www.ideone.com/xAmv72e5
{ 0 comments }
Esta es una pequeña prueba de concepto de como se pueden llamar objetos remotos java desde Flex usando Linux y Tomcat del lado del servidor.
1. Dentro del directorio webapps, creamos el directorio de nuestro proyecto (p.e. blazeds):
2. Bajamos la distribución binaria de BlazeDS de su página de Internet y la desempaquetamos en un directorio temporal.
3. Copiamos el archivo blazeds.war al directorio de nuestro proyecto y lo desempaquetamos.
4. Borramos el archivo .war.
5. Opcionalmente, agregamos la siguiente línea al archivo de configuración conf/server.xml dentro del tag de Host, para que tengamos bien definido el directorio de nuestra aplicación:
6. Agregamos el archivo de seguridad crossdomain.xml donde este el directorio raíz de nuestro dominio:
Para este ejemplo, creamos una pequeña clase en Java, en el directorio WEB-INF/src que simplemente nos de la hora:
La compilamos con:
La copiamos al directorio classes.
Ahora que todo esta listo del lado del servidor, declaramos nuestra clase agregando las siguientes lineas al tag service del archivo flex/Remoting-config.xml:
Del lado del cliente, necesitamos crear un archivo de configuración services-config.xml que más adelante se utilizará como un parámetro del comando mxmlc que compila nuestro código.
<service id="remoting-service" class="flex.messaging.services.RemotingService"
messageTypes="flex.messaging.messages.RemotingMessage">
<adapters>
<adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true" />
</adapters>
<!-- Con este id, llamamos al java desde flex -->
<destination id="blazeds">
<channels>
<channel ref="my-amf" />
</channels>
</destination>
</service>
</services>
<channels>
<channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel">
<!-- Aqui tengo la ruta de donde se va a jalar las cosas, proviene del war de flex -->
<endpoint uri="http://192.168.1.100:8080/blazeds/messagebroker/amf"
class="flex.messaging.endpoints.AMFEndpoint"/>
</channel-definition>
</channels>
</services-config>
Aquí tenemos el mxml (blazeds.mxml ) que vamos usar como ejemplo:
<mx:Script>
<![CDATA[
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
// Esta función se llama cuando se llamo exitosamente a nuestro objeto:
public function onMethodResult(event:ResultEvent):void {
bo.label = "Result "+event.result
bo.label += "nDataType "+ typeof(event.result)
}
]]>
</mx:Script>
<mx:RemoteObject id="ro" destination="blazeds" fault="Alert.show(event.fault.faultString, 'Error')" result="{onMethodResult(event)}">
<!-- Aquí declaramos todas las funciones que vamos a llamar del objeto Java -->
<mx:method name="getTime" result="{onMethodResult(event)}" />
</mx:RemoteObject>
<mx:Label id="bo" label="" click="ro.getTime()" />
</mx:Application>
Lo compilamos con la siguiente línea de comando:
Al ejecutar el mxml, veremos una etiqueta vacia que al darle doble click, nos imprimirá la hora del servidor.
De aquí en adelante, ya todo es creatividad. Por supuesto que se pueden usar frameworks como Spring para acelerar el desarrollo del lado del servidor. Pero lo importante de este post, era comprobar con una prueba de concepto lo bien que se llevan estas tecnologías y hacerlo "a manita" para aprender más. No es muy díficil hacer esto mismo con Flex Builder para el cliente y Eclipse para el servidor.
{ 8 comments }
Supongamos que tenemos las siguientes clases:
#include <boost/shared_ptr.hpp>
using namespace std;
class Base {
public:
virtual void imprime() { cout <<"Función imprime de la Clase Base" <<endl; }
virtual ~Base() { cout <<"Destructor de la Clase Base" <<endl; }
};
typedef boost::shared_ptr<Base> base_ptr;
class Derivada : public Base {
public:
virtual void imprime() { cout <<"Función imprime de la Clase Derivada" <<endl; }
virtual ~Derivada() { cout <<"Destructor de la Clase Derivada" <<endl; }
};
typedef boost::shared_ptr<Derivada> derivada_ptr;
Y queremos hacer esto:
derivada_ptr derivada( new Derivada );
base_ptr base( derivada );
base->imprime();
// La siguiente línea no va a compilar:
derivada_ptr regreso( base );
return EXIT_SUCCESS;
}
En la tercera declaración, nos va a marcar este error al compilar:
Obviamente, necesitamos un casting. La forma para hacerlo sería así:
derivada_ptr derivada( new Derivada );
base_ptr base( derivada );
base->imprime();
// Ahora si compila:
derivada_ptr regreso( boost::static_pointer_cast<Derivada>( base ) );
return EXIT_SUCCESS;
}
Al ejecutar el programa, obtenemos esta salida:
Como se ve, el smart pointer funcionó a la perfección a pesar de todas las transformaciones.
{ 0 comments }