The Beginning

El juego llevará como título “Hungry Insects Wars” o lo que es lo mismo traducido al español y de donde surgió la idea del título original “Peleas de insectos esmayaos”.

El objetivo principal del juego será sobrevivir en el interior de una casa y dentro de los distintos cuartos de esta. Para sobrevivir, como cualquier animal, habrá que comer, como es normal y para comer habrá que luchar por la comida, pues no será un bien en abundancia. Se podrá golpear a los rivales, lanzarles objetos (desde cohetes a pulpos paralizantes), poner minas antipersona en el suelo para que al pisarlas resten vida y el insecto se traslade a otro punto de la habitación por efecto de la explosión, poner chicle o pegamento en el suelo para dejar inmovilizado al rival, … También habrá objetos especiales que incrementen nuestras capacidades (velocidad, fuerza…) que nos harán ser más competitivos en nuestra lucha por la supervivencia.

Por supuesto, cuando te golpeen o te lancen algo todos los objetos que poseas se caerán al suelo y habrá que recogerlos, si no te los han robado antes, claro está. xD.

Ya vimos en post anteriores unos bocetos de lo que serán los protagonistas de esta historia, los cuales se comunicarán entre sí mediante un chat y con envío de mensajes privados para poder organizarse en caso de querer reunirse en guerrillas para atacar más eficazmente.

Por ahora estamos en la fase de diseño de lo que será la interfaz gráfica (que haber como la programo después, que miedo!) y del diagrama UML de las clases del nivel de aplicación (otra cosa que no tengo ni idea como hacer pero que poco a poco y con ayuda de mi tutor voy solventando).

La capa inferior de esta aplicación proporcionarán QoS con técnicas como FEC o ARQ usadas normalmente en voz pero adaptadas para la transmisión de este tipo de datos.

Todo esto estará sustentado por tecnología DDS y SCRIBE, particularmente FreePastry, para distribuir los datos en tiempo real de los jugadores y las distintas acciones.

Poco a poco iré subiendo más cositas del juego y los posibles bocetos de la interfaz gráfica que haga (miedo me dan mis dotes pintoras).

Primeros bocetos HIW

Aquí os dejo los primeros o segundos… ya no lo sé, bocetos de los personajes de este reto que debo llevar a cabo.

Proximamente más y mejor.

Apuntes sobre FreePastry y tecnología SCRIBE

- Ver qué hace y cómo funciona freePASTRY.

-> cómo iniciarse en grupo de PASTRY.

public class DistTutorial {

public DistTutorial(int bindport, InetSocketAddress bootaddress, Environment env) throws Exception {

// Generate the NodeIds Randomly

NodeIdFactory nidFactory = new RandomNodeIdFactory(env);

// construct the PastryNodeFactory, this is how we use rice.pastry.socket

PastryNodeFactory factory = new SocketPastryNodeFactory(nidFactory, bindport, env);

// This will return null if we there is no node at that location

NodeHandle bootHandle = ((SocketPastryNodeFactory)factory).getNodeHandle(bootaddress);

// construct a node, passing the null boothandle on the first loop will

// cause the node to start its own ring

PastryNode node = factory.newNode(bootHandle);

// the node may require sending several messages to fully boot into the ring

synchronized(node) {

while(!node.isReady() && !node.joinFailed()) {

// delay so we don’t busy-wait node.wait(500);

// abort if can’t join

if (node.joinFailed()) {

throw new IOException(“Could not join the FreePastry ring. Reason:”+node.joinFailedReason());

}

}

}

System.out.println(“Finished creating new node “+node);

}

public static void main(String[] args) throws Exception {

// Loads pastry settings

Environment env = new Environment();

// disable the UPnP setting (in case you are testing this on a NATted LAN)

//env.getParameters().setString(“nat_search_policy”,”never”);

int bindport = 9001;

InetAddress bootaddr = InetAddress.getLocalHost();

int bootport = 9001;

InetSocketAddress bootaddress = new InetSocketAddress(bootaddr,bootport);

// launch our node!

DistTutorial dt = new DistTutorial(bindport, bootaddress, env);

}

}

-> ¿Se pueden definir grupos?

Sí. SCRIBE, envío de mensajes a grupos y recepción de mensajes de los grupos a los que este suscrito.

Creando un grupo

Topic myTopic = new Topic(new PastryIdFactory(), “example topic”);

Scribe myScribe;

Topic myTopic;

protected Endpoint endpoint;

public MyScribeClient(PastryNode node) {

// you should recognize this from lesson 3

this.endpoint = node.buildEndpoint(this, “myinstance”); //por si hay varias aplicaciones corriendo sobre freepastry

// construct

Scribe myScribe = new ScribeImpl(node,”myScribeInstance”);

// construct the topic

myTopic = new Topic(new PastryIdFactory(node.getEnvironment()), “example topic”); System.out.println(“myTopic = “+myTopic);

// now we can receive messages

endpoint.register();

}

enviando mensajes

class PublishContent implements Message {

public int getPriority() {

return 0;

}

}

public void startPublishTask(){

publishTask = endpoint.scheduleMessage(new PublishContent(), 5000, 5000);

// lo de endpoint simula que le llega un mensaje a este nodo a los 5s y se repita cada 5s de tal forma que se ejecute el método deliver cad 5s.

}

public void deliver(Id id, Message message) {

if (message instanceof PublishContent) {

sendMulticast();

sendAnycast();

}

}

Suscribir a un grupo

public void subscribe() {

myScribe.subscribe(myTopic, this);

}

Envío multicast

//ejemplo de creación de un contenido para envío multicast

public class MyScribeContent implements ScribeContent {

NodeHandle from;

int seq;

public MyScribeContent(NodeHandle from, int seq) {

this.from = from;

this.seq = seq;

}

public String toString() {

return “MyScribeContent #”+seq+” from “+from;

}

}

public void sendMulticast() {

System.out.println(“Node “+endpoint.getLocalNodeHandle()+” broadcasting “+seqNum);

//creamos el objeto MyScribeContent

MyScribeContent myMessage = new MyScribeContent(endpoint.getLocalNodeHandle(), seqNum);

//publicamos

myScribe.publish(myTopic, myMessage);

//Actualizamos seqNum

seqNum++;

}

Recibir mensajes

public void deliver(Topic topic, ScribeContent content){

System.out.println(“MyScribeClient.deliver(“+topic+”,”+content+”)”);

}
-> Ver tablas de rutas. ¿Se pueden ver? ¿Se pueden manipular?

Las tablas de ruta no se pueden ver ni manipular, tan solo se pude ver un árbol de la red, aunque creo que no es muy interesante para nuestra aplicación.
-> Ver el envío: más cercano y al que quieras

// construct a new MyApp

MyApp app = new MyApp(node);

// wait 10 seconds

env.getTimeSource().sleep(10000);

// as long as we’re not the first node

if (bootHandle != null) {

// route 10 messages

for (int i = 0; i < 10; i++) {

// pick a key at random

Id randId = nidFactory.generateNodeId();

// send to that key

app.routeMyMsg(randId);

// wait a sec

env.getTimeSource().sleep(1000);

}

// wait 10 seconds

env.getTimeSource().sleep(10000);

// send directly to my leafset

LeafSet leafSet = node.getLeafSet();

// this is a typical loop to cover your leafset. Note that if the leafset

// overlaps, then duplicate nodes will be sent to twice

for (int i=-leafSet.ccwSize(); i<=leafSet.cwSize(); i++) {

if (i != 0) { // don’t send to self

// select the item

NodeHandle nh = leafSet.get(i);

// send the message directly to the node

app.routeMyMsgDirect(nh);

// wait a sec

env.getTimeSource().sleep(1000);

}

public class MyApp implements Application {

/**

* The Endpoint represents the underlieing node. By making calls on the

* Endpoint, it assures that the message will be delivered to a MyApp on whichever

* node the message is intended for.

*/

protected Endpoint endpoint;

public MyApp(Node node) {

// We are only going to use one instance of this application on each PastryNode

this.endpoint = node.buildEndpoint(this, “myinstance”);

// the rest of the initialization code could go here

// now we can receive messages

this.endpoint.register();

}

/**

* Called to route a message to the id

*/

public void routeMyMsg(Id id) {

System.out.println(this+” sending to “+id);

Message msg = new MyMsg(endpoint.getId(), id);

endpoint.route(id, msg, null);

}

/**

* Called to directly send a message to the nh

*/

public void routeMyMsgDirect(NodeHandle nh) {

System.out.println(this+” sending direct to “+nh);

Message msg = new MyMsg(endpoint.getId(), nh.getId());

endpoint.route(null, msg, nh);

}

/**

* Called when we receive a message.

*/

public void deliver(Id id, Message message) {

System.out.println(this+” received “+message);

}

/**

* Called when you hear about a new neighbor.

* Don’t worry about this method for now.

*/

public void update(NodeHandle handle, boolean joined) {

}

/**

* Called a message travels along your path.

* Don’t worry about this method for now.

*/

public boolean forward(RouteMessage message) {

return true;

}

public String toString() {

return “MyApp “+endpoint.getId();

}

}

-> ¿Se puede consultar resto de nodos? ¿Y al vecino más cercano?

Comunicación con un nodo concreto, multicast dentro del grupo y anycast va probando hasta que alguno responda “true”.
-> Comprobar: si se envía al nodo más cercano, si éste es capaz de tratarlo.

Cuando un nodo recibe un mensaje siempre se ejecuta la rutina de tratamiento del mensaje recibido. En este caso habría que comprobar el destinatario del mensaje, si soy yo, lo paso a las capas superiores y ya se trata debidamente o si es para otro usuario pues se reenviaría a su vez al nodo más cercano.

Aunque de todas formas y como está basado en Scribe se pueden definir grupos a los que enviar mensajes y de los que recibir de tal forma que con un solo mensaje todos los miembros de un mismo grupo estén “al corriente” de todos los sucesos.
-> Ver qué tipos de tráfico define (QoS,…).

No viene nada en la guía de programación. Seguiré buscando.
-> Añadidos

Se pueden planificar tareas que se ejecuten cada cierto tiempo y/o cancelarlas. (TIMER)

Permite “personalizar” una capa de transporte pero en la guía de programación no viene nada acerca de UDP/TCP, solo pone que lo incluirán en un tutorial posterior. Da una idea que usa un transporte propio.

FreePastry has made some effort to work properly in reduced connectivity environments such as NATs and in the presence of temporary routing anomlies. For example FreePastry only requires 1 (UDP/TCP) port to be forwarded, and does not require any specific port, thus making it possible to run multiple nodes behind the same NAT. Also, FreePastry uses source routing to bridge connections during temporary internet anomalies. If your application opens its own sockets then it will be required to allocate additional ports, open them on NATs, and have its own source-routing infrastructure to get through the communication difficluties that FreePastry already handles. As we attempt to handle additional connectivity issues in the future, we plan to continue to support the AppSocket interface. The AppSocket interface is compatable with FreePastry’s simulator. The sockets are simulated rather than requiring sys-calls. Our solution scales better than opening potentially n-squared connections on a single computer that is simulating tens or hundreds of thousands of nodes.

Siguientes pasos

- Ver qué hace y cómo funciona freePASTRY.
- Ejemplos.
- > cómo iniciarse en grupo de PASTRY.
-> Se pueden definir grupos?
-> Ver tablas de rutas. Se pueden ver? se pueden manipular?
-> Ver el envío: más cercano y al que quieras
-> Se puede consultar resto de nodos? y vecino cercano?
-> Comprobar: si se envía al nodo más cercano, si éste es capaz de tratarlo.
-> Ver qué tipos de tráfico define (QoS, …).

- Diseño de Juego (Parte de aplicación).
-> Qué hacen.
-> Interfaz (cómo se ve el juego). Diseño de las pantallas.
-> Diseño de las clases, etc.

Comenzamos!!!

Registrando blog y forja para el Concurso.

Leyendo artículos sobre FEC y ARQ para aplicaciones multimedia (audio, video) y pensando como usarlo en transmisión de datos.

Probando JXTA para desarrollo de redes P2P con tráfico basado en TCP y HTTP.

Probando FreePastry para redes P2P con posibilidad de UPnP para configuración programada del NAT de los routers y tráfico UDP.

Probando distintas bibliotecas de sprites para la parte gráfica.