Ayuda con movimientos con el raton

[fmadrid]

Hola!

Estoy creando mi propio juego y ya se me ha presentado el primer problema.

En otros foros no e tenido mucha ayuda pero espero que aqui me podais ayudar mejor.

Se trata, por ahora, de un juego en un mapa bidimensional, con un jugador que se debe mover con el raton. Mi problema se presenta en que solo e sido capaz de que el jugador se mueva en forma de L (usando baldosas) y necesito que se mueve donde clicka el raton en linea recta.

Espero que me podais ayudar por que no consigo hacerlo. Supongo que se debera primero hacer que el jugador rote, y acontinuacion, se diriga donde pincho con el raton, pero por mas que lo intento no lo consigo. :(

Saludos a todos :)

[Mars Attacks]

Pues echando mano de las reglas trigonométricas del instituto puedes calcular qué ángulo tienes que girar, y como sabes (o deberías saber) la posición original del jugador y la posición final a la que tiene que ir, el resto es una simple interpolación de movimiento en ese vector (posicion_final-posicion_inicial).

Si tienes alguna duda más concreta...

[fmadrid]

sip , conseguí hacerlo pero usando las flechas del ordenador pero a la hora de sustituir por el raton no funciona, y no encuentro el problema...

debe ser lo que mencionas de la posicion final, pero no  sabria como implementarlo y como colocarlo en el codigo final (debido a que en los manuales no se habla demasiado sobre el uso del raton de esta manera)

si quieres posteo el codigo fuente k llevo y lo examinamos mejor... no se me ocurre nada mas.

oye, muchas gracias por el interes.

saludos!

[Mars Attacks]

Para eso estamos.

A ver, el tema está en que el movimiento por cursores y el movimiento por click de ratón son dos estrategias de movimiento completamente distintas. En una le dices que, mientras esté pulsado un botón determinado, haga un incremento determinado de su posición hacia donde esté mirando. En la otra, le dices cuál quieres que sea su destino final, y en cada refresco de la lógica, una parte del programa deberá encargarse de comprobar si se ha acercado lo suficiente a ese punto final (nunca intentes comparar si ha llegado al mismo punto exacto, estas cosas se hacen siempre con tolerancias) y, de no ser así, hacer ese incremento determinado de su posición hacia esa dirección.

Si quieres, postea el código y alguien podrá indicarte mejor. De todas formas, estaría bien que dieras datos más concretos de qué es lo que quieres hacer (qué tipo de juego es y por qué necesitas esos dos tipos distintos de movimiento).

[fmadrid]

OK!

Lo que quiero hacer es que el jugador se pueda mover en un mapa bidimensional solamente utilizando el raton. Y como explique antes, donde pinche el raton, hacia alli se debe dirigir el jugador.

Por ahora simplemente es eso, ya que posteriormente la camara debera seguir al jugador (no se si me e explicado bien en esto), añadiremos enemigos, objetos y miscelaneos.

Pero para seguir un orden, primero hay que conseguir la instancia y el correcto movimiento del jugador.

Aqui os aclaro el codigo:

Este es el codigo completo haciendo que el jugador rote con izquierda y derecha, y se mueva con arriba y abajo usando las flechas.

Código [Seleccionar] Expand

fscommand("allowscale", false);
fscommand("allowscale", false);
//our map is 2-dimensional array
myMap1 = [[1, 1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 0, 0, 0, 1], [1, 0, 1, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 1, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 1]];
//declare game object that holds info
game = {tileW:30, tileH:30, currentMap:1};
//walkable tile
game.Tile0 = function () { };
game.Tile0.prototype.walkable = true;
game.Tile0.prototype.frame = 1;
//wall tile
game.Tile1 = function () { };
game.Tile1.prototype.walkable = false;
game.Tile1.prototype.frame = 2;
//non-existing tile
game.Tile4 = function () { };
game.Tile4.prototype.walkable = false;
game.Tile4.prototype.frame = 20;
//declare char object, xtile and ytile are tile where chars center is
char = {xtile:1, ytile:1, speed:4};
//building the world
function buildMap(map) {
//attach empty mc to hold all the tiles and char
_root.attachMovie("empty", "tiles", 1);
//get map dimensions
var mapWidth = map[0].length;
var mapHeight = map.length;
//declare clip in the game object
game.clip = _root.tiles;
//loop to place tiles on stage
for (var y = 0; y<mapHeight; ++y) {
for (var x = 0; x<mapWidth; ++x) {
//name of new tile
var name = "t_"+y+"_"+x;
//make new tile object in the game
game[name] = new game["Tile"+map[y][x]]();
//attach tile mc and place it
game.clip.attachMovie("tile", name, 1+y*100+x*2);
game.clip[name]._x = (x*game.tileW);
game.clip[name]._y = (y*game.tileH);
//send tile mc to correct frame
game.clip[name].gotoAndStop(game[name].frame);
}
}
//add the character mc
game.clip.attachMovie("char", "char", 10000);
//declare clip in the game object
char.clip = game.clip.char;
//calculate starting position
char.x = (char.xtile*game.tileW)+game.tileW/2;
char.y = (char.ytile*game.tileW)+game.tileH/2;
//add char dimensions to char object, half of clips width and height
char.width = char.clip._width/2;
char.height = char.clip._height/2;
//place char mc
char.clip._x = char.x;
char.clip._y = char.y;
}
function getMyCorners(x, y, ob) {
//find corner points
ob.downY = Math.floor((y+ob.height-1)/game.tileH);
ob.upY = Math.floor((y-ob.height)/game.tileH);
ob.leftX = Math.floor((x-ob.width)/game.tileW);
ob.rightX = Math.floor((x+ob.width-1)/game.tileW);
//check if they are walls
ob.upleft = game["t_"+ob.upY+"_"+ob.leftX].walkable;
ob.downleft = game["t_"+ob.downY+"_"+ob.leftX].walkable;
ob.upright = game["t_"+ob.upY+"_"+ob.rightX].walkable;
ob.downright = game["t_"+ob.downY+"_"+ob.rightX].walkable;
}
function moveChar(ob, dirx, diry) {
//vertical movement
//where are our edges?
//first we look for y movement, so x is old
getMyCorners(ob.x, ob.y+diry, ob);
//move got dammit... and check for collisions.
//going up
if (diry<-0.5) {
if (ob.upleft and ob.upright) {
//no wall in the way, move on
ob.y += diry;
} else {
//hit the wall, place char near the wall
ob.y = ob.ytile*game.tileH+ob.height;
}
}
//if going down
if (diry>0.5) {
if (ob.downleft and ob.downright) {
ob.y += diry;
} else {
ob.y = (ob.ytile+1)*game.tileH-ob.height;
}
}
//horisontal movement
//changing x with speed and taking old y
getMyCorners(ob.x+dirx, ob.y, ob);
//if going left
if (dirx<-0.5) {
if (ob.downleft and ob.upleft) {
ob.x += dirx;
} else {
ob.x = ob.xtile*game.tileW+ob.width;
}
}
//if going right
if (dirx>0.5) {
if (ob.upright and ob.downright) {
ob.x += dirx;
} else {
ob.x = (ob.xtile+1)*game.tileW-ob.width;
}
}
//update char position
ob.clip._x = ob.x;
ob.clip._y = ob.y;
//calculate the tile where chars center is
ob.xtile = Math.floor(ob.x/game.tileW);
ob.ytile = Math.floor(ob.y/game.tileH);
return (true);
}
function detectKeys() {
var ob = _root.char;
var keyPressed = false;
if (Key.isDown(Key.RIGHT)) {
ob.clip._rotation += 5;
} else if (Key.isDown(Key.LEFT)) {
ob.clip._rotation -= 5;
}
if (Key.isDown(Key.UP)) {
ob.speedx = ob.speed*Math.cos((ob.clip._rotation)*Math.PI/180);
ob.speedy = ob.speed*Math.sin((ob.clip._rotation)*Math.PI/180);
keyPressed = _root.moveChar(ob, ob.speedx, ob.speedy);
} else if (Key.isDown(Key.DOWN)) {
ob.speedx = -ob.speed*Math.cos((ob.clip._rotation)*Math.PI/180);
ob.speedy = -ob.speed*Math.sin((ob.clip._rotation)*Math.PI/180);
keyPressed = _root.moveChar(ob, ob.speedx, ob.speedy);
}
//walk animation
if (!keyPressed) {
ob.clip.char.gotoAndStop(1);
} else {
ob.clip.char.play();
}
}
//make the map
buildMap(_root["myMap"+game.currentMap]);
stop();

y en este otro es el movimiento con el raton en forma de L.

Código [Seleccionar] Expand

fscommand("allowscale", false);
fscommand("allowscale", false);
//our map is 2-dimensional array
myMap1 = [[1, 1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 0, 0, 0, 1], [1, 0, 1, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 1, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 1]];
//declare game object that holds info
game = {tileW:30, tileH:30};
//walkable tile
game.Tile0 = function () { };
game.Tile0.prototype.walkable = true;
game.Tile0.prototype.frame = 1;
//wall tile
game.Tile1 = function () { };
game.Tile1.prototype.walkable = false;
game.Tile1.prototype.frame = 2;
//declare char object, xtile and ytile are tile where chars center is
char = {xtile:2, ytile:1, speed:2, moving:false};
//building the world
function buildMap(map) {
//attach mouse cursor
_root.attachMovie("mouse", "mouse", 2);
//attach empty mc to hold all the tiles and char
_root.attachMovie("empty", "tiles", 1);
//declare clip in the game object
game.clip = _root.tiles;
//get map dimensions
var mapWidth = map[0].length;
var mapHeight = map.length;
//loop to place tiles on stage
for (var i = 0; i<mapHeight; ++i) {
for (var j = 0; j<mapWidth; ++j) {
//name of new tile
var name = "t_"+i+"_"+j;
//make new tile object in the game
game[name] = new game["Tile"+map[i][j]]();
//attach tile mc and place it
game.clip.attachMovie("tile", name, i*100+j*2);
game.clip[name]._x = (j*game.tileW);
game.clip[name]._y = (i*game.tileH);
//send tile mc to correct frame
game.clip[name].gotoAndStop(game[name].frame);
}
}
//add the character mc
game.clip.attachMovie("char", "char", 10000);
//declare clip in the game object
char.clip = game.clip.char;
//calculate starting position
char.x = (char.xtile*game.tileW)+game.tileW/2;
char.y = (char.ytile*game.tileW)+game.tileW/2;
//place char mc
char.clip._x = char.x;
char.clip._y = char.y;
char.clip.gotoAndStop(char.frame);
}
function moveChar(ob) {
//is char in the center of tile
if ((ob.x-game.tileW/2)%game.tileW == 0 and (ob.y-game.tileH/2)%game.tileH == 0) {
//calculate the tile where chars center is
ob.xtile = Math.floor(ob.x/game.tileW);
ob.ytile = Math.floor(ob.y/game.tileH);
//choose direction
//right
if (game["t_"+ob.ytile+"_"+(ob.xtile+1)].walkable and game.targetx>ob.xtile) {
ob.dirx = 1;
ob.diry = 0;
//left
} else if (game["t_"+ob.ytile+"_"+(ob.xtile-1)].walkable and game.targetx<ob.xtile) {
ob.dirx = -1;
ob.diry = 0;
//up
} else if (game["t_"+(ob.ytile+1)+"_"+ob.xtile].walkable and game.targety>ob.ytile) {
ob.dirx = 0;
ob.diry = 1;
//down
} else if (game["t_"+(ob.ytile-1)+"_"+ob.xtile].walkable and game.targety<ob.ytile) {
ob.dirx = 0;
ob.diry = -1;
//none
} else {
ob.moving = false;
return;
}
}
//move
ob.y += ob.speed*ob.diry;
ob.x += ob.speed*ob.dirx;
//update char position
ob.clip._x = ob.x;
ob.clip._y = ob.y;
//face the direction
ob.clip.gotoAndStop(ob.dirx+ob.diry*2+3);
}
function getTarget() {
//must click on walkable tile
if (game["t_"+game.ymouse+"_"+game.xmouse].walkable) {
//update target tile
game.targetx = game.xmouse;
game.targety = game.ymouse;
//get moving
char.moving = true;
}
}
function work() {
//find on which tile mouse is
game.xmouse = Math.round((_root._xmouse-game.tileW/2)/game.tileW);
game.ymouse = Math.round((_root._ymouse-game.tileH/2)/game.tileH);
//place mouse mc
_root.mouse._x = game.xmouse*game.tileW;
_root.mouse._y = game.ymouse*game.tileH;
var ob = char;
//move char
if (!ob.moving) {
//stop walk animation
ob.clip.char.gotoAndStop(1);
} else {
moveChar(ob);
//walk animation
ob.clip.char.play();
}
}
//make the map
buildMap(_root["myMap1"]);
stop();

En ambos casos estoy usando un mapa echo con baldosas.

Cualquier cosa decidme, yo voy a seguir intentar hacer lo que has mencionado   :)


Gracias por la ayuda y cualquier duda sobre el codigo os lo explico detalladamente

Saludos!

[HarvesterOfAcorns]

Pues me picó la curiosidad de como se podría hacer y no he parado hasta que no he conseguido algo parecido y es que tengo unas obsesiones rarísimas Oo , mira a ver si te puede servir esto:

Código (actionscript) [Seleccionar] Expand


//creamos un documento nuevo, de 550x400, por ejemplo
//marcamos los límites del mapa, que serán los de nuestro documento
var limit_O:Number = 0;
var limit_N:Number = 0;
//para el límite Este y Sur le restamos al tamaño del documento
//el grosor y la altura de la unidad
var limit_E:Number = 550 - 8;
var limit_S:Number = 400 - 8;
//creamos el mapa
this.createEmptyMovieClip("mapa", 0);
mapa._x = limit_O;
mapa._y = limit_N;
mapa._width = limit_E;
mapa._height = limit_S;
//dibujamos nuestro personaje, un rectángulo de 8x8 en este caso
this.createEmptyMovieClip("unidad", 1);
unidad.beginFill(0xFF0000);
unidad.lineTo(8, 0);
unidad.lineTo(8, 8);
unidad.lineTo(0, 8);
unidad.lineTo(0, 0);
unidad.endFill();
//si tomamos como referencia para la posición del personaje
//la esquina superior izquierda del rectángulo
//ahora estaría colocado en la posición (0,0), marcamos
//su posición actual
var pos_x:Number = 0;
var pos_y:Number = 0;
//función que inicia el juego
function init(){
unidad._x = 200;
unidad._y = 200;
intervalo = setInterval(juego,40);
}
//creamos el bucle del juego
var intervalo:Number;
function juego(){
clearInterval(intervalo);
posiciona_unidad();
intervalo = setInterval(juego,40);
}
var iniciado:Boolean = false;
//empezamos a jugar
if(iniciado == false){
init();
iniciado = true;
}
//declaramos las variables que guardarán la posición
//donde pulsamos el ratón
var destino_x:Number;
var destino_y:Number;
//creamos dos variables que guardarán el diferencial de
//movimiento para cada frame
var dx:Number = 0;
var dy:Number = 0;
//para conocer la posición absoluta de la zona donde pulsamos
//usaré una referencia a un movieclip situado en (0,0)
this.createEmptyMovieClip("origen",2);
//recogemos las pulsaciones en el ratón y calculamos dx, dy
mapa.onMouseDown = function (){
destino_x = origen._xmouse;
destino_y = origen._ymouse;
};
//posicionamos la unidad
function posiciona_unidad(){
//tenemos ocho posibles posiciones para cada movimiento
//los ocho pixeles (o tiles según sea) que rodean al
//punto de referencia de la unidad
//tomamos la que más se aproxime a la dirección del movimiento

if((destino_x - unidad._x) == 0){
if((destino_y - unidad._y) == 0){
dx = 0;
dy = 0;
}else{
if((destino_y - unidad._y) > 0){
dy = 1;
}else{
dy = -1;
}
dx = 0;
}
}else{
//calculamos el ángulo relativo al eje x del punto final
//en relación al punto de partida y medido en sentido
//antihorario desde el centro de coordenadas
var pendiente:Number = Math.atan2((unidad._y - destino_y),(destino_x - unidad._x));
//atan2 solo devuelves valores de ángulo exacto para
//valores comprendidos entre PI positivo y PI negativo
//para ángulos superiores a PI devuelve valores negativos
//luego para esos valores restamos a 2PI el propio valor devuelto
if(pendiente < 0)
pendiente = 6.24 + pendiente;
if(pendiente == 0){
dx = 1;
dy = 0;
}
else if(pendiente < 0.39 || pendiente > 5.89){
dx = 1;
dy = 0;
}
else if(pendiente > 0.39 && pendiente <= 1.17){
dx = 1;
dy = -1;
}
else if(pendiente > 1.17 && pendiente <= 1.96){
dx = 0;
dy = -1;
}
else if(pendiente > 1.96 && pendiente <= 2.74){
dx = -1;
dy = -1;
}
else if(pendiente > 2.74 && pendiente <= 3.53){
dx = -1;
dy = 0;
}
else if(pendiente > 3.53 && pendiente <= 4.31){
dx = -1;
dy = 1;
}
else if(pendiente > 4.31 && pendiente <= 5.10){
dx = 0;
dy = 1;
}
else if(pendiente > 5.10 && pendiente <= 5.89){
dx = 1;
dy = 1;
}
}
unidad._x += dx;
unidad._y += dy;
}



Eso sí, como ejemplo del buen programar no te va a servir de mucho, ni OOP ni Estructurada ni na... que uno es un aficionadillo
;)

[fmadrid]

 :o :o

Tio se acercca completamente a lo que buscaba  :D

El movimiento (aunque con algun fallillo) se ejecuta correctamente.

Gracias!! aunque ayer buscando yo tb encontre esto: http://www.flashkit.com/tutorials/Games/Detectin-Flash_Ju-79/index.php

En esa te enseña a detectar donde se situa el raton, y apartir de ahi tb se podria crear el movimiento.

Bueno con eso es suficiente, graicas por la ayuda.

Saludos!

[fmadrid]

aaah :'( :'( :'( ya encontre el problema... y esque el jugador no rota  :-\ ...

dime, como lo puedo hacer?? lo he intenta insertando para de mi codigo pero no consigo nada...  :grrr:

:S si lo consigues me lo dices .

Saluds!!

[HarvesterOfAcorns]

Pos si, la verdad que no gira.
En este he modificado un poco el código anterior, he cambiado la forma de calcular el desplazamiento, ahora es más "exacta", más corta, más trigonométrica >.< , pero para usarla con tiles habría que retocarla bastante, mejor pensado habrá que retocarla bastante de cualquier manera si se pretende que el resultado sea un movimiento fluido, pero como muestra creo que puede servir.
He añadido la función 'gira_unidad()' que orienta la figura en la dirección del movimiento, muy sencilla también y con enormes posibilidades de mejora.
Ahí va:

Código (actionscript) [Seleccionar] Expand


//creamos un documento nuevo, de 550x400, por ejemplo
//marcamos los límites del mapa, que serán los de nuestro documento
var limit_O:Number = 0;
var limit_N:Number = 0;
//para el límite Este y Sur le restamos al tamaño del documento
//el grosor y la altura de la unidad
var limit_E:Number = 550 - 8;
var limit_S:Number = 400 - 8;
//creamos el mapa
this.createEmptyMovieClip("mapa", 0);
mapa._x = limit_O;
mapa._y = limit_N;
mapa._width = limit_E;
mapa._height = limit_S;
//para poder apreciar el giro de la figura necesitamos
//que esta sea asimétrica luego un cuadrado no nos sirve
//dibujaré un triángulo isósceles para indicar la dirección
//del movimiento
this.createEmptyMovieClip("unidad", 1);
unidad.beginFill(0xFF0000);
unidad.lineTo(-10, 15);
unidad.lineTo(-10, -15);
unidad.lineTo(0, 0);
unidad.endFill();
//si tomamos como referencia para la posición del personaje
//la esquina superior izquierda del rectángulo
//ahora estaría colocado en la posición (0,0), marcamos
//su posición actual
var pos_x:Number = 0;
var pos_y:Number = 0;
//marcamos igualmente la dirección en la que apunta la unidad
//para ello usaré una variable que guarde el ángulo, en radianes,
//de la rotación, empezamos con un ángulo de cero
var rot:Number = 0;
//función que inicia el juego
function init(){
unidad._x = 200;
unidad._y = 200;
intervalo = setInterval(juego,40);
}
//creamos el bucle del juego
var intervalo:Number;
function juego(){
clearInterval(intervalo);
gira_unidad();
posiciona_unidad();
intervalo = setInterval(juego,40);
}
var iniciado:Boolean = false;
//empezamos a jugar
if(iniciado == false){
init();
iniciado = true;
}
//declaramos las variables que guardarán la posición
//donde pulsamos el ratón
var destino_x:Number;
var destino_y:Number;
//creamos dos variables que guardarán el diferencial de
//movimiento para cada frame
var dx:Number = 0;
var dy:Number = 0;
//para conocer la posición absoluta de la zona donde pulsamos
//usaré una referencia a un movieclip situado en (0,0)
this.createEmptyMovieClip("origen",2);
//recogemos las pulsaciones en el ratón y calculamos dx, dy
mapa.onMouseDown = function (){
destino_x = origen._xmouse;
destino_y = origen._ymouse;
};
//A diferencia de antes debemos declarar la variable que
//guarde el ángulo de la dirección de desplazamiento
//como variable global para que sea accesible a la función
//de desplazamiento y a la de giro también
var pendiente:Number;
//posicionamos la unidad
function posiciona_unidad(){
//distancia que separa la posición actual de
//la posición de destino medida en los ejes x e y
var desplazamiento_x:Number = destino_x - unidad._x;
var desplazamiento_y:Number = destino_y - unidad._y;

//para evitar que la unidad titile cuando se supone debería
//estar parado, ya que al usar las funciones trigonométricas
//seno y coseno es posible que no alcancemos con exactutud el
//punto de destino, esto haría que estuviera corrigiendo
//constantemente su posición, como si tuviera el baile
// de San Vito pues para evitarlo le damos cierta
//tolerancia a la posición de parada
if(desplazamiento_x < 4 && desplazamiento_x > -4){
if(desplazamiento_y < 4 && desplazamiento_y > -4){
dx = 0;
dy = 0;
}else{
//desplazamiento en vertical:
if(desplazamiento_y > 4){
dy = 4;
}else if(desplazamiento_y < -4){
dy = -4;
}
dx = 0;
}
}else{
//calculamos el ángulo relativo al eje x del punto final
//en relación al punto de partida y medido en sentido
//antihorario desde el centro de coordenadas
pendiente = Math.atan2((desplazamiento_y),(desplazamiento_x));
//desplazamiento en vertical
if(pendiente == 0){
if(desplazamiento_x > 4){
dx = 4;
}else if(desplazamiento_x < -4){
dx = -4;
}
dy = 0;
}else{
//para un desplazamiento que no sea horizontal ni vertical
//el incremento horizontal la calculamos con referencia al
//coseno del angulo que forma la dirección del movimiento
//con el eje x positivo y el incremento vertical en relación
//al seno del mismo ángulo
//deplazamiento en oblicuo:
dx = 8 * Math.cos(pendiente);
dy = 8 * Math.sin(pendiente);
}
}
unidad._x += dx;
unidad._y += dy;
}
function gira_unidad(){
//si el ángulo de de la figura es diferente al de la
//dirección de movimiento lo igualamos:
if(rot != pendiente){
rot = pendiente;
//giramos el movieclip para colocarlo en la dirección
//del movimiento, el ángulo rot lo pasamos a
//grados sexagesimales
unidad._rotation = rot*180/Math.PI;
}
}


En cuanto a como insertarlo en tu código, pues no lo tengo muy claro, lo mejor sería que lo hicieras específico para tu programa
en función de la idea que tengas del resultado final y si éste te sirve de algo, pues aprovéchalo cuanto puedas.

Supongo que lo fundamental es tener el concepto claro, que luego ya se encontrará la forma de desarrollarlo.

Suerte con él.

[fmadrid]

esta bastane bien ;)

mi intecion principal no era usar tiles, eso solo fue porque lo vi en un tutorial  :P

bueno  voy a seguir practicando con el njuevo codigo y ya te cuento como va.

saludos!

[fmadrid]

ok ya lo e revisado y para lo que quiero hacer va perfecto  ;)

ahora... toca marear la perdiz.

Se trata de hacer un mapa mas grande... digamos que 2 ó 3 veces la pantalla de un ordenador (vamos a darle unos 2000px X 1600px) y un enfoque de 550px X 400px(lo que se ve) por ejemplo. Y ahora tendriamos que conseguir que el jugador se mantuviera en el centro de la pantalla. Esto creo que se puede hacer moviendo lo que es el terreno y no el jugador... pero no lo se con seguridad. Alguien me podria decir como hacerlo?? ??? ???

saludos!

[urkel]

Hola Fernando,

Como te comente por mail hago publico el código que te envie para que sea de ayuda a todo el que quiera utilizarlo. Codigo "Star Combat" (no es un juego, es solo un trozo de codigo interaccionable). Las naves las he tomado prestadas de Star Trash, y son del maestro David Ferriz.

Por ultimo, queria hacer referencia a un pequeño crack italiano que esta haciendo mucho por la escena Flash con sus tutoriales, Emmanuele Feronato. Este chico siente verdadera pasion por la enseñanza de los videojuegos, tutoriales bastantes buenos, sin muchos rollos y bien explicados. Ha tocado temas esenciales como mapeados tileados, fisicas, monetizacion. Recientemente tambien ha tocado como realizar una website de juegos en WordPress(http://wordpress.org/), aunque dale un ojo a otros gestores de contenidos como Drupal(http://drupal.org/) o Joomla(www.joomla.org), temas ideales para montar un website propio de calidad.

[zwiTTeR]

Jejeje Urkel, vaya pedazo de tutorial!, la comunidad te lo agradecerá. Un poco más y le haces el juego entero a fmadrid xDD

[urkel]

Que va! Precisamente estaba trabajando con este codigo en una idea que al final he abandonado. No me costo mucho cambiar el fondo y orientarlo a naves. Quizas si me animo acabo este "Star Combat" como un juego senzillote de defensa y lo cuelgo en la web a modo de tutorial con todo el codigo fuente, pero ya veremos...