if(Game.PrevScene=="Room")
{
actor.SkipTo(X, Y);
actor.Direction = DI_UP;
}
al principio la Room es la escena desde la que el personaje viene a esta escena, la posicion en la que aparece es X,Y que tu le tienes que poner el valor deseado y el direction es hacia donde mira, DI_UP hacia arriba, DI_LEFT hacia la izquierda etc, de todas formas esto viene muy bien explicado en el tutorial que trae el programa, echa un vistazo a los scripts switch(Game.PrevScene) // Acá establecés la variable a comparar, en este caso "Game.PrevScene".
{
case "UnaEscena": // Si la escena anterior se llamaba "UnaEscena", ejecutar el código siguiente hasta "break;".
actor.SkipTo(40, 267); // Llevar al personaje a las coordenadas señaladas (en este caso "40,267").
actor.Direction = DI_UP; // Poner al personaje mirando hacia arriba (de espaldas al jugador).
break;
case "OtraEscena": // Si, en cambio, se llamaba "OtraEscena", ejecutar el código siguiente hasta "break;"
actor.SkipTo(303, 86); // Llevar al personaje a estas otras coordenadas.
actor.Direction = DI_DOWN; // Ponerlo mirando hacia abajo (de cara al jugador).
break;
case "UnaEscenaMas": actor.SkipTo(27, 86);
actor.Direction = DI_LEFT;
break;
default: // Si la escena anterior no se llama "UnaEscena" ni "OtraEscena" ni "UnaEscenaMas", ejecutar el código siguiente hasta el final.
actor.SkipTo(23, 112);
actor.Direction = DI_RIGHT;
}
¿Podría, desde la entrada X de la scene A llegar a la entrada X de la scene B y viceversa? ¿Podría hacer lo mismo con el camino Y, en ambas direcciónes (de A a B y de B a A)?
on "LeftClick" // Al cliquear la salida...
{
global Entrada = "X"; // Declarar la variable global "Entrada" y darle el valor "X".
Game.ChangeScene("scenes\B\B.scene"); // Cambiar a la escena B.
}
global Entrada; // Declarar la variable "Entrada". Esto es sólo para poder usarla en el resto de este script.
switch(Entrada) // Acá establecés "Entrada" como la variable a comparar.
{
case "X": // Si "Entrada" tiene el valor "X"...
actor.SkipTo(40, 267); // Llevar al personaje a la entrada X de la escena B.
actor.Direction = DI_UP;
Game.Msg("¡Está en la entrada equis!"); // Líneas adicionales que lo hacen a uno sentirse mejor cuando el código funciona bien.
actor.Talk("¡Estoy en la entrada equis!");
break; // ¡Esta línea es muy importante! Si no el código no va a saber dónde termina el "case X".
case "Y": // Si, en cambio, tiene el valor "Y"...
actor.SkipTo(303, 86);
actor.Direction = DI_DOWN;
break; // Este "break" es opcional, ya que acá termina el comando "switch", no hay necesidad real de decirle a WME que se detenga.
}
La pantalla empieza en la izquierda, y se desliza hasta la derecha, hasta que se encuentra con el personaje y luego sigue normal. No es que sea especialmente molesto, ya que el personaje sigue respondiendo y demás, pero me gustaría saber cómo colocar desde el comienzo la pantalla en el lugar adecuado.
Scene.SkipTo(actor);
#include "scripts\base.inc"
// here comes the stuff which initializes the scene (Opcion B)(en caso de que el lugar tenga accesos desde mas de una scene:)
switch(Game.PrevScene) // Acá establecés la variable a comparar, en este caso "Game.PrevScene".
{
case "new_scene": // Si la escena anterior se llamaba "UnaEscena", ejecutar el código siguiente hasta "break;".
actor.SkipTo(586, 361); // Llevar al personaje a las coordenadas señaladas (en este caso "40,267").
actor.Direction = DI_DOWNLEFT; // Poner al personaje mirando hacia arriba (de espaldas al jugador).
break;
case "BUS": // Si, en cambio, se llamaba "OtraEscena", ejecutar el código siguiente hasta "break;"
actor.SkipTo(52, 584); // Llevar al personaje a estas otras coordenadas.
actor.Direction = DI_UPRIGHT; // Ponerlo mirando hacia abajo (de cara al jugador).
break;
default: // Si la escena anterior no se llama "UnaEscena" ni "OtraEscena" ni "UnaEscenaMas", ejecutar el código siguiente hasta el final.
actor.SkipTo(400, 400);
actor.Direction = DI_RIGHT;
}
////////////////////////////////////////////////////////////////////////////////
// scene state
global StateRoom;
// default values
if(StateRoom==null)
{
StateRoom.Visited = false;
// add scene states here
}
////////////////////////////////////////////////////////////////////////////////
// setup scene according to state variables
////////////////////////////////////////////////////////////////////////////////
if(!StateRoom.Visited)
{
StateRoom.Visited = true;
// this is our first visit in this scene...
}
Este es el código que tengo en scene_init de la room que tiene (o debería tener) 2 entradas con la escena "BUS" y una con la escena "new scene". ¿dónde he de colocar ese código que me diste Juan? Yo lo coloqué en el caso "BUS", pero está visto que no lo hice adecuadamente.#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
global Entrada = "X"; // O el nombre que tenga, claro.
Game.ChangeScene("scenes\caca\caca.scene"); // Y acá la dirección real de tu segunda escena.
}
(Tené en cuenta que este es un ejemplo simple, tu entrada puede tener más código, como por ejemplo un buen actor.GoTo() para que tu personaje camine hacia la entrada antes de cambiar la escena. Lo importante es que el cambio de escena sea la úlitma línea antes de la llave de cierre.)#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
global Entrada = "Y";
Game.ChangeScene("scenes\caca\caca.scene");
}
#include "scripts\base.inc"
// here comes the stuff which initializes the scene
global Entrada;
switch(Entrada)
{
case "X": actor.SkipTo(143, 422); break;
case "Y": actor.SkipTo(637, 417);
}
(Cambiando "X" e "Y" por los respectivos valores que le hayas asignado a Entrada en los scripts anteriores. Después de este código vendría el actor.Active = true y el Scene.SkipTo(actor). Para mantenerlo simple, resumí cada caso (el X y el Y) en una sola línea que solamente manda al actor a su posición. En un ejemplo real tendrías que agregar la dirección a la que mira y cualquier otra cosa que quieras que pase según cuál entrada cliqueaste. Y siempre conviene poner saltos de línea en el código para que se vea más organizado.)#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
global Entrada = "Camino1";
Game.ChangeScene("scenes\BUS\BUS.scene");
}
Sin embargo, el camino 2 no da ningún problema en ninguno de los dos sentidos (de una escena a otra y viceversa), y el código es idéntico excepto por el nombre del objeto:#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
global Entrada = "Camino2";
Game.ChangeScene("scenes\BUS\BUS.scene");
}
on "Take"
{
actor.GoToObject(this);
Game.Interactive = false;
// get the fan entity
var EntFan = Scene.GetNode("fan");
// set the fan etity sprite depending on the state variable
// (0-off, 1-normal, 2-false)
if(StateRoom.FanSpeed==0)
{
actor.Talk("It's turned off. I'll turn it on...");
actor.PlayAnim("actors\molly\ur\take1.sprite");
EntFan.PlaySound("sounds\fan_start.ogg");
actor.PlayAnim("actors\molly\ur\take2.sprite");
Sleep(1400);
EntFan.SetSprite("scenes\room\sprites\fan.sprite");
StateRoom.FanSpeed = 1; // save the new fan state
}
else if(StateRoom.FanSpeed==1)
{
actor.Talk("It's running at normal speed. Let's make it spin faster...");
actor.PlayAnim("actors\molly\ur\take1.sprite");
EntFan.SetSprite("scenes\room\sprites\fan_fast.sprite");
actor.PlayAnim("actors\molly\ur\take2.sprite");
StateRoom.FanSpeed = 2;
}
else if(StateRoom.FanSpeed==2)
{
actor.Talk("OK, I'll turn it off.");
actor.PlayAnim("actors\molly\ur\take1.sprite");
EntFan.PlaySound("sounds\fan_stop.ogg");
EntFan.SetSprite("scenes\room\sprites\fan_off.sprite");
actor.PlayAnim("actors\molly\ur\take2.sprite");
StateRoom.FanSpeed = 0;
}
Game.Interactive = true;
}
on "Take" // Al usar la acción en el objeto...
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\MiEscena\sprites\fuente_normal.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("Voy a cambiar el ''sprite'' de esta fuente");
this.PlaySound("sounds\AguaCorriendo.ogg",true); // Que la fuente reproduzca el sonido y que lo repita.
this.SetSprite("scenes\MiEscena\sprites\fuente_haciendo_algo.sprite"); // Asignarle otro "sprite".
break; // ¡Línea importante! Nunca la olvides.
case "scenes\MiEscena\sprites\fuente_haciendo_algo.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Mejor la vuelvo a como estaba antes.");
this.StopSound(); // Detener el sonido que estaba reproduciendo.
this.SetSprite("scenes\MiEscena\sprites\fuente_normal.sprite"); // Devolverle su "sprite" anterior.
}
Game.Interactive = true;
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.GoToObject(this);
actor.Talk("Es una fuente apagada. Tiene un botón.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite(scenes\BUS\fuente.sprite)) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\BUS\fuente.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("Voy a cambiar el ''sprite'' de esta fuente");
this.PlaySound("scenes\BUS\stream-3.wav",true); // Que la fuente reproduzca el sonido y que lo repita.
this.SetSprite("scenes\BUS\fuenteon.sprite"); // Asignarle otro "sprite".
break; // ¡Línea importante! Nunca la olvides.
case "scenes\BUS\fuenteon.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Mejor la vuelvo a como estaba antes.");
this.StopSound(); // Detener el sonido que estaba reproduciendo.
this.SetSprite("scenes\BUS\fuente.sprite"); // Devolverle su "sprite" anterior.
break;
}
Game.Interactive = true;
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.GoToObject(this);
actor.Talk("Fuentecita fuentecita, ¿quien es de todas la mas fresquita?");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.Talk("¡¡Ya voy!!");
actor.GoToObject(this);
}
switch(this.GetSprite())
dejando el parámetro de GetSprite() en blanco, es decir no escribiendo nada entre sus paréntesis.#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.GoToObject(this);
actor.Talk("Es una fuente apagada. Tiene un botón.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\BUS\fuente.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("Voy a cambiar el ''sprite'' de esta fuente");
this.PlaySound("scenes\BUS\stream-3.wav",true); // Que la fuente reproduzca el sonido y que lo repita.
this.SetSprite("scenes\BUS\fuenteon.sprite"); // Asignarle otro "sprite".
break; // ¡Línea importante! Nunca la olvides.
case "scenes\BUS\fuenteon.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Mejor la vuelvo a como estaba antes.");
this.StopSound(); // Detener el sonido que estaba reproduciendo.
this.SetSprite("scenes\BUS\fuente.sprite"); // Devolverle su "sprite" anterior.
break;
}
Game.Interactive = true;
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.GoToObject(this);
actor.Talk("Fuentecita fuentecita, ¿quien es de todas la mas fresquita?");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.Talk("¡¡Ya voy!!");
actor.GoToObject(this);
}
on "LeftDoubleClick" // Al darle doble clic izquierdo...
{
Game.ChangeScene("scenes\otraescena.scene"); // ...cambiar la escena.
}
que, como verás, es remitirnos a la acción "LeftDoubleClick" (doble clic izquierdo) en vez del común "LeftClick" y poner exactamente el mismo código pero sin el actor.GoToObject(this). O sea, decirle a WME que al hacer doble clic cambie de escena y nada más.var Fuente = Scene.GetNode("fuente"); // Crear una variable Fuente que sea tu objeto "fuente", si es que se llama así.
switch(Fuente.GetSprite()) // ¿Qué sprite tiene tu fuente?
{
case "scenes\escena\fuenteon.sprite": // Si tiene la animación "fuenteon.sprite"...
Fuente.PlaySound("sonidoareproducir.ogg",true); // ...que reproduzca su sonido.
}
Es decir, al comenzar tu escena le preguntás a WME qué sprite tiene tu fuente, y si es "fuenteon" que reproduzca el sonido correspondiente. Le puse saltos de línea para los comentarios, pero también debería funcionar algo así comovar Fuente = Scene.GetNode("fuente");
switch(Fuente.GetSprite()) {case "scenes\escena\fuenteon.sprite":Fuente.PlaySound("sonidoareproducir.ogg",true);}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("puaj, basura.");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Antes he tocado algo muy blando... y húmedo...");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("A ver qué encuentro...");
actor.Talk("Un segundo.");
this.SetSprite("scenes\Room\basuraopen.sprite"); // Asignarle otro "sprite".
Game.TakeItem("albal");
actor.Talk("esto podrá serme util. A ver algo más...");
actor.Talk("...");
Game.TakeItem("martillo");
actor.Talk("¡Un martillo y un trozo de papel albal!");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Bastante he buscado ya. ¿No crees?");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("¿saldrá el bicho de barrio sésamo?");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.Talk("¡¡Ya voy!!");
actor.GoToObject(this);
}
¿Dónde está mi problema?on "goma"
{
actor.Talk("Pongamos la goma en la rama.");
Game.DropItem("goma");
Game.DropItem("rama");
Game.TakeItem("tirachinas");
}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.Talk("Una caja azul MUY bien cerrada.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
Game.SelectedItem = "caja";
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("¿Hay alguien dentro?");
}
on "martillo"
{
actor.Talk("DESTROY!!");
Game.DropItem("martillo");
Game.TakeItem("jarro");
actor.Talk("¡Bien! ahora tengo un jarrico.");
Game.DeleteItem("caja");
}
on "martillo"
{
actor.GoToObject(this);
actor.Talk("DESTROY!!");
Game.DropItem("martillo");
Game.DeleteItem(this);
Game.TakeItem("jarro");
actor.Talk("¡Bien! ahora tengo un jarrico.");
}
Este avance me mola. XDon "Take" // Al agarrar la caja.
{
actor.TakeItem("caja"); // Sumar el ítem "caja" al inventario...
this.Active = false; // ...y volver la caja invisible.
}
Haciendo esto tendrías el mismo resultado, y DropItem() no devolvería la caja a su sitio.on "martillo" // Al usar el martillo en la caja...
{
actor.Talk("Primero voy a agarrarla.");
this.ApplyEvent("Take"); // ...agarrar la caja...
actor.Talk("Ahora sí los combino...");
var CajaDelInventario = Game.GetItem("caja");
CajaDelInventario.ApplyEvent("martillo"); // ...y usar el martillo con el ítem "caja".
}
Al usar el método ApplyEvent() podés hacer que la caja sea agarrada sin que el jugador lo haga intencionalmente y podés combinar el martillo con la caja de la misma manera. Lo que hacés es forzar el evento "Take" en la caja en vez de hacerlo por acción del jugador. Sé que de momento no te ahorra tanto código, pero te lo comento porque quizá en el futuro agarrar un objeto desate muchas acciones (variables cambiando, mucho diálogo que va y viene) y de esta forma te asegurás que pase todo tal y como si lo hubieras agarrado antes de combinarlos.
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.GoToObject(this);
actor.Talk("Anda! una cajita azul!");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this);
actor.Talk("pa la saca.");
Game.TakeItem("caja");
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.GoToObject(this);
actor.Talk("Cajita cajita, vaya que eres feita.");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
}
////////////////////////////////////////////////////////////////////////////////
on "martillo"
{
actor.GoToObject(this);
actor.Talk("DESTROY!!");
Game.DropItem("martillo");
Game.DeleteItem(this);
Game.TakeItem("jarro");
actor.Talk("¡Bien! ahora tengo un jarrico.");
}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.Talk("Una caja azul MUY bien cerrada.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
Game.SelectedItem = "caja";
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("¿Hay alguien dentro?");
}
on "martillo"
{
actor.Talk("DESTROY!!");
Game.DropItem("martillo");
Game.TakeItem("jarro");
actor.Talk("¡Bien! ahora tengo un jarrico.");
Game.DeleteItem("caja");
}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.Talk("¿un bicharraco amarillo flotando?");
this.Talk("El coco.");
actor.Talk("Qué sitio mas raro.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.Talk("No llego.");
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("Hola coco.");
this.Talk("Hola Tarzana, ¿cómo estás?");
Game.AddResponse(0, "Tururú");
Game.AddResponse(1, "Flufluturutú");
Game.AddResponse(2, "Debería irme");
var Res = Game.GetResponse();
actor.Talk("bueno chico, aquí te quedas.");
this.Talk("Venga Tarzana, feliz navidad.");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("puaj, basura.");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Antes he tocado algo muy blando... y húmedo...");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("A ver qué encuentro...");
actor.Talk("Un segundo.");
this.SetSprite("scenes\Room\basuraopen.sprite"); // Asignarle otro "sprite".
Game.TakeItem("albal");
actor.Talk("esto podrá serme util. A ver algo más...");
actor.Talk("...");
Game.TakeItem("martillo");
actor.Talk("¡Un martillo y un trozo de papel albal!");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Bastante he buscado ya. ¿No crees?");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("¿saldrá el bicho de barrio sésamo?");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.Talk("¡¡Ya voy!!");
actor.GoToObject(this);
}
function BillDialogue()
{
var Responses;
var Selected;
var Loop = true;
while(Loop)
{
// prepare the sentences
if (!Bill_flores)
Responses[0] = Game.ExpandString("/WOF0001038/");
else
Responses[0] = Game.ExpandString("/WOF0001039/");
if (!Bill_curro)
Responses[1] = Game.ExpandString("/WOF0001040/");
else
Responses[1] = Game.ExpandString("/WOF0001041/");
if (!Bill_dani)
Responses[2] = Game.ExpandString("/WOF0001042/");
else
Responses[2] = Game.ExpandString("/WOF0001043/");
Responses[3] = Game.ExpandString("/WOF0001044/");
// fill the response box
Game.AddResponse(0, Responses[0]);
Game.AddResponse(1, Responses[1]);
Game.AddResponse(2, Responses[2]);
Game.AddResponse(3, Responses[3]);
// let the player choose one
Selected = Game.GetResponse();
// let the actor say the selected sentence
// (that's why I use the array for storing the sentences)
actor.PlayAnimAsync("Hablar");
WinNarrator.DisplayText(Responses[Selected], "Jhonny", -1); //Dejamos que la máquina calcule el tiempo que se muestra la frase.
actor.PlayAnimAsync("IdleHablar");
// now let Bill reply depending on the selected sentence
if(Selected==0)
{
if (!Bill_flores)
{
this.PlayAnimAsync("Hablando");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001045/"),"Bill",-1);
this.PlayAnimAsync("Idle");
actor.PlayAnimAsync("Hablar");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001046/"),"Jhonny",-1);
actor.PlayAnimAsync("IdleHablar");
this.PlayAnimAsync("Hablando");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001047/"),"Bill",-1);
this.PlayAnimAsync("Idle");
actor.PlayAnimAsync("Hablar");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001048/"),"Jhonny",-1);
actor.PlayAnimAsync("IdleHablar");
this.PlayAnimAsync("Hablando");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001049/"),"Bill",-1);
this.PlayAnimAsync("Idle");
actor.PlayAnimAsync("Hablar");
WinNarrator.DisplayText(Game.ExpandString("/WOF0001050/"),"Jhonny",-1);
actor.PlayAnimAsync("IdleHablar");
Bill_flores=true;
}
else
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001051/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001052/"),"Jhonny",-1);
}
}
else
{
if(Selected==1)
{
if (!Bill_curro)
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001053/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001054/"),"Jhonny",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001055/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001056/"),"Jhonny",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001057/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001058/"),"Jhonny",-1);
Bill_curro=true;
}
else
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001059/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001060/"),"Jhonny",-1);
}
}
else
{
if(Selected==2)
{
if (!Bill_dani)
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001061/"),"Bill",-1);
BillDialogue2();
Bill_dani=true;
}
else
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001062/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001063/"),"Jhonny",-1);
}
}
else
{
if(Selected==3)
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001064/"),"Bill",-1);
Loop = false; // we want to end the dialogue
}
}
}
}
}
// Comprobamos si Bill le ha contado todo y en caso afirmativo
// se puede ya cerrar el cementerio
if(Bill_flores && Bill_curro && Bill_dani)
EstadoJuego.CementerioCerrado = true;
else
EstadoJuego.CementerioCerrado = false;
}
////////////////////////////////////////////////////////////////////////////////
function BillDialogue2()
{
var Responses;
var Selected;
var Loop = true;
while(Loop)
{
// prepare the sentences
Responses[0] = Game.ExpandString("/WOF0001065/");
Responses[1] = Game.ExpandString("/WOF0001066/");
Responses[2] = Game.ExpandString("/WOF0001067/");
// fill the response box
Game.AddResponse(0, Responses[0]);
Game.AddResponse(1, Responses[1]);
Game.AddResponse(2, Responses[2]);
// let the player choose one
Selected = Game.GetResponse();
// let the actor say the selected sentence
// (that's why I use the array for storing the sentences)
WinNarrator.DisplayText(Responses[Selected], "Jhonny", -1);
// now let the Old Guy reply depending on the selected sentence
if(Selected==0)
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001068/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001069/"),"Jhonny",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001070/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001071/"),"Jhonny",-1);
}
else
{
if(Selected==1)
{
WinNarrator.DisplayText(Game.ExpandString("/WOF0001072/"),"Bill",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001073/"),"Jhonny",-1);
WinNarrator.DisplayText(Game.ExpandString("/WOF0001074/"),"Bill",-1);
}
else
{
if(Selected==2) Loop = false;
}
}
}
}
this.Active = false;
en el código de la caja —ese que ni te planteás resumirlo— después de agarrar el ítem, y de ahí en más usar DropItem(). Como invisibilizaste la caja, no hay posibilidad de que DropItem() la devuelva a su sitio.
on "martillo"
{
actor.Talk("DESTROY!!");
Game.DropItem("caja");
Game.DropItem("martillo");
this.Active = false;
Game.TakeItem("jarro");
actor.Talk("¡Bien! ahora tengo un jarrico.");
Game.DropItem("caja");
}
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
actor.Talk("¿un bicharraco amarillo flotando?");
this.Talk("El coco.");
actor.Talk("Qué sitio mas raro.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.Talk("No llego.");
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("Hola coco.");
this.Talk("Hola Tarzana, ¿cómo estás?");
Game.AddResponse(0, "Tururú");
Game.AddResponse(1, "Flufluturutú");
Game.AddResponse(2, "Debería irme");
var Res = Game.GetResponse();
actor.Talk("bueno chico, aquí te quedas.");
this.Talk("Venga Tarzana, feliz navidad.");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
}
Este código pertenece a un bicho flotante amarillo. Pues bien, hay dos cosas que me gustaría solucionar en su código.#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("puaj, basura.");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Antes he tocado algo muy blando... y húmedo...");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.GoToObject(this); // Que el actor vaya a él (opcional).
Game.Interactive = false; // Que el juego deje de ser interactivo (opcional).
switch(this.GetSprite()) // Establecemos el "sprite" de la fuente como variable a comparar.
{
case "scenes\Room\basuraclosed.sprite": // Si la fuente tiene su "sprite" por defecto.
actor.Talk("A ver qué encuentro...");
actor.Talk("Un segundo.");
this.SetSprite("scenes\Room\basuraopen.sprite"); // Asignarle otro "sprite".
Game.TakeItem("albal");
actor.Talk("esto podrá serme util. A ver algo más...");
actor.Talk("...");
Game.TakeItem("martillo");
actor.Talk("¡Un martillo y un trozo de papel albal!");
break; // ¡Línea importante! Nunca la olvides.
case "scenes\Room\basuraopen.sprite": // Si la fuente ya tiene su otro "sprite".
actor.Talk("Bastante he buscado ya. ¿No crees?");
break;
}
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.Talk("¿saldrá el bicho de barrio sésamo?");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.Talk("¡¡Ya voy!!");
actor.GoToObject(this);
}
Siempre comienzo las pruebas en la escena en la que está la basura. Pues bien:#include "scripts\base.inc"
//este script está asociado a la caja de madera de debajo de la estantería
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
TurnToObject();
ego.Talk("/HABFRED012/Pone frágil.");
ego.Talk("/HABFRED013/Esa caja ya estaba ahí cuando me instale hace 10 años.");
ego.Talk("/HABFRED014/Nunca ha sido abierta, la de misterios que debe esconder.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
GoToObject();
Game.Interactive = false;
ego.Talk("/HABFRED015/¡NO! Yo no seré quien profane...");
ego.TurnTo(DI_DOWN);
ego.Talk("/HABFRED016/...LA CAJA...", "scenes\HabitFred\chan.ogg");
ego.Talk("/HABFRED017/Además, conlleva ejercicio físico.");
Game.Interactive = true;
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
GoToObject();
}
////////////////////////////////////////////////////////////////////////////////
function GoToObject()
{
ego.GoTo(385, 420);
ego.TurnTo(DI_UP);
}
///////////////////////////////////////////////////////////////////////////////
function TurnToObject()
{
var ActX = ego.X;
var ActY = ego.Y;
var Entity = Scene.GetNode(self.Name);
var EntityX = Entity.X;
var EntityY = Entity.Y;
if(ActY > EntityY + 20)
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_UPLEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_UPRIGHT);
return;
}
else if(ActX >= EntityX)
{
ego.TurnTo(DI_UP);
return;
}
else if(ActX <= EntityX)
{
ego.TurnTo(DI_UP);
return;
}
}
else if(ActY < EntityY - 20)
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_DOWNLEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_DOWNRIGHT);
return;
}
else if(ActX >= EntityX)
{
ego.TurnTo(DI_DOWN);
return;
}
else if(ActX <= EntityX)
{
ego.TurnTo(DI_DOWN);
return;
}
}
else
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_LEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_RIGHT);
return;
}
else if(ActX >= EntityX)
{
GoToObject();
return;
}
else if(ActX <= EntityX)
{
GoToObject();
return;
}
}
}
En el evento "LookAt" hay una llamada al método TurnToObject() (línea 9), que no es de WME, sino que es creado por el programador en el mismo script (a partir de la línea 37). Cualquier manera posible de explicarlo se me hace igual de complicada que el mismo código, y no creo que pertenezca al nivel básico de programación que estamos barajando aquí.on "LookAt" // Al mirar al bicho
{
actor.GoToObjectAsync(this); // comenzar a caminar hacia él,
Sleep(100); // esperar una décima de segundo
actor.Reset(); // y dejar de caminar.
actor.Talk("Si tenemos suerte, estoy mirando hacia el bicho en cuestión.");
}
Los métodos GoToAsync() y GoToObjectAsync() hacen lo mismo que GoTo() y GoToObject() respectivamente, sólo que en vez de esperar a que el actor llegue a destino, continúan ejecutando el código. Es como darle el puntapié inicial para que comience a caminar. Lo que hacemos es meter un Sleep() de 100 milisegundos para que el actor camine un poquitín hacia el bicho y luego lo detenemos en seco con un Reset(), que lo que hace es resetear cualquier acción que esté ejecutando —como hablar o caminar o reproducir un sonido—. No estoy completamente seguro, pero se supone que si el actor comienza a caminar hacia el bicho debería estar apuntando hacia él cuando lo frenás, consiguiendo lo que querías.var Basura = Scene.GetNode("basura");
Basura.Active = true;
en el scene_init de tu escena, pero sería mejor averiguar por qué cazzo desaparece en primer lugar. No veo nada fuera de lo común en el script que mostraste, fijate que todos los sprites estén bien escritos, porque puede ser que le asignaras un sprite inexistente y que por lo tanto se borrara. Si algo está mal, tiene que ser en alguno de los scripts en que cambiás la escena.
#include "scripts\base.inc"
////////////////////////////////////////////////////////////////////////////////
on "LookAt"
{
TurnToObject();
actor.Talk("Una chabola muy muy fea.");
}
////////////////////////////////////////////////////////////////////////////////
on "Take"
{
actor.Direction = DI_DOWN;
actor.Talk("¿Y despues me la guardo en el bolsillo?");
}
////////////////////////////////////////////////////////////////////////////////
on "Talk"
{
actor.GoToObject(this);
actor.Talk("Hola, Chozaca fea y espantosa.");
}
////////////////////////////////////////////////////////////////////////////////
on "LeftClick"
{
actor.GoToObject(this);
}
function GoToObject()
{
ego.GoTo(385, 420);
ego.TurnTo(DI_UP);
}
function TurnToObject()
{
var ActX = ego.X;
var ActY = ego.Y;
var Entity = Scene.GetNode(self.Name);
var EntityX = Entity.X;
var EntityY = Entity.Y;
if(ActY > EntityY + 20)
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_UPLEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_UPRIGHT);
return;
}
else if(ActX >= EntityX)
{
ego.TurnTo(DI_UP);
return;
}
else if(ActX <= EntityX)
{
ego.TurnTo(DI_UP);
return;
}
}
else if(ActY < EntityY - 20)
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_DOWNLEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_DOWNRIGHT);
return;
}
else if(ActX >= EntityX)
{
ego.TurnTo(DI_DOWN);
return;
}
else if(ActX <= EntityX)
{
ego.TurnTo(DI_DOWN);
return;
}
}
else
{
if(ActX > EntityX + 30)
{
ego.TurnTo(DI_LEFT);
return;
}
else if(ActX < EntityX - 30)
{
ego.TurnTo(DI_RIGHT);
return;
}
else if(ActX >= EntityX)
{
GoToObject();
return;
}
else if(ActX <= EntityX)
{
GoToObject();
return;
}
}
}
Game.ChangeScene("\scenes\lobby\lobby.scene");
Game.ChangeScene("scenes\lobby\lobby.scene");
function TurnToObject() // Acá declara la función —o método— y la llama "TurnToObject" (voltear hacia el objeto).
{ // Todo lo que sigue hasta que se cierre esta primera llave es la función TurnToObject().
/*
A continuación declara algunas variables que se van a usar en la función. En este caso las variables no son
necesarias. Es decir, podríamos sacar la línea "var ActX = actor.X;" siempre y cuando reemplacemos luego todos los
"ActX" por "actor.X". Al progamador simplemente le pareció que, ya que lo iba a tipear muy seguido, convenía algo
corto como "ActX" y no "actor.X", que tiene más letras y encima requiere el meñique de la mano derecha, que debe de
ser el dedo que menos se usa al teclear.
*/
var ActX = actor.X; /* La variable ActX será la posición X del actor. O sea, su posición horizontal. O sea, el
largo —medido en pixeles— de la recta más corta entre los pies del actor y el borde izquierdo del juego. */
var ActY = actor.Y; // Lo mismo, pero con la posición vertical. Del borde superior hasta sus pies.
var Entity = Scene.GetNode(self.Name); /* Entity será nuestro objeto hacia el que hay que mirar.
Supongo que también valdría "var Entity = self;". */
var EntityX = Entity.X; // Aquí tenemos cómo nos referiremos a la posición X del objeto (equivale a "self.X").
var EntityY = Entity.Y; // Y aquí su posición Y.
/*
Muy bien, a continuación empieza el código en serio.
*/
// Acá empieza la PRIMERA PARTE (hay tres), se ejecuta si el actor está más de 20 pixeles por debajo del objeto.
if(ActY > EntityY + 20)
{
if(ActX > EntityX + 30) // Si el actor está más de 30 pixeles a la derecha del objeto...
{
actor.TurnTo(DI_UPLEFT); // ...que mire arriba a la izquierda.
return;
}
else if(ActX < EntityX - 30) // Si está más de 30 pixeles a su izquierda...
{
actor.TurnTo(DI_UPRIGHT); // ...que mire arriba a la derecha.
return;
}// Y si no está tan a su izquierda ni tan a su derecha...
else if(ActX >= EntityX)
{
actor.TurnTo(DI_UP); // ...que mire directamente hacia arriba.
return;
}
else if(ActX <= EntityX) // Y aquí repite un poco. Pone una nueva condición que de todos modos hace mirar
{ // al actor hacia arriba. No sé por qué lo hace, pero lo hace.
actor.TurnTo(DI_UP);
return;
}
}
// Acá empieza la SEGUNDA PARTE, se ejecuta si el actor está más de 20 pixeles por encima del objeto.
else if(ActY < EntityY - 20)
{
if(ActX > EntityX + 30) // Si el actor está más de 30 pixeles a la derecha del objeto...
{
actor.TurnTo(DI_DOWNLEFT); // ...que mire abajo a la izquierda.
return;
}
else if(ActX < EntityX - 30) // Si está más de 30 pixeles a la izquierda...
{
actor.TurnTo(DI_DOWNRIGHT); // ...que mire abajo a la derecha.
return;
} // Si nada de lo anterior...
else if(ActX >= EntityX)
{
actor.TurnTo(DI_DOWN); // ...que mire directo hacia abajo.
return;
}
else if(ActX <= EntityX)
{
actor.TurnTo(DI_DOWN);
return;
}
}
// Acá empieza la TERCERA PARTE, se ejecuta si el actor está a 20 pixeles o menos de la altura del objeto.
else
{
if(ActX > EntityX + 30) // Si el actor está más de 30 pixeles a la derecha del objeto...
{
actor.TurnTo(DI_LEFT); // ...que mire a la izquierda.
return;
}
else if(ActX < EntityX - 30) // Si está más de 30 pixeles a la izquierda...
{
actor.TurnTo(DI_RIGHT); // ...que mire a la derecha.
return;
} // Y si no está tan a la derecha ni a la izquierda, teniendo en cuenta que tampoco está tan arriba ni abajo...
else if(ActX >= EntityX)
{
GoToObject(); // ...que directamente vaya hacia el objeto.
return;
}
else if(ActX <= EntityX)
{
GoToObject();
return;
}
}
}
No sé si es de lo mejor, porque digamos que corta la pantalla en cuadrícula para fijarse cuál es la posición del actor con respecto a la del objeto, cuando en realidad daría un efecto más realista cortarla en ocho partes, como de pizza. Pero bueno, me dejo de metáforas y explico un poco.function Dialogo()
{
var Responses;
var Selected;
var Loop = true;
while(Loop)
{
// preparamos las frases, hablar_barco y hablar_coche lo usamos para saber si ya ha hecho la pregunta con anterioridad y cambiar la foma de hacerla
// en función de si se ha hablado o no
// Se entiende que previamente estas variables estan declaradas globalmente e inicializadas a false, o sea:
// global hablar_barco = false; // y lo mismo con hablar_coche
// De esta forma, la primera vez que se ejecute el código, se dice la primera frase y se indica que ya se ha hablado para que las sucesivas veces
// Salga lo de "Vuelveme a contar"
if (!hablar_barco)
Responses[0] = "Hablame del barco";
else
Responses[0] = "Vuelveme a contar lo del barco");
if (!hablar_coche)
Responses[1] = "Hablame del coche";
else
Responses[1] = "Vuelveme a contar lo del coche");
// Creamos el cuadro de conversación con las frases que hemos preparado
Game.AddResponse(0, Responses[0]);
Game.AddResponse(1, Responses[1]);
// Ahora lo presentamos en pantalla para que el jugador seleccione una, el resultado se almacena en Selected
Selected = Game.GetResponse();
// El actor repite lo que hemos seleccionado
actor.Talkt(Responses[Selected]);
// Ahora el personaje contesta en función de la pregunta que se ha hecho y si ya se habia hecho antes o no
if(Selected==0) // Pregunta de los barcos
{
if (!hablar_barco)
{
personaje.Talk("Los barcos flotan");
hablar_barco=true;
}
else
{
personaje.Talk("Como ya te dije, los barcos flotan, excepto si tienen un agujero, claro");
}
}
if(Selected==1) // Pregunta de los coches
{
if (!hablar_barco)
{
personaje.Talk("Los coches van rodando");
hablar_barco=true;
}
else
{
personaje.Talk("Como ya te dije, los coches van rodando, excepto por cuestiones de gasolina, pinchazos y similares, por supuesto");
}
}
}
Responses[0] = "Vuelveme a contar lo del barco");
Responses[0] = "Vuelveme a contar lo del barco";
Responses[1] = "Vuelveme a contar lo del coche");
Responses[1] = "Vuelveme a contar lo del coche";
¿eso no tendría mucho mas código, al tener que dividir la pantalla de manera diagonal?Sí, cortar la pantalla en diagonal requeriría mucho más código o mucho más conocimiento de trigonometría del que tengo de momento.
¿podrían hacerse animaciones para que, al girarse a un lado o a otro, quedara mas natural?Sí, WME maneja animaciones intermedias para que los actores giren más naturalmente. Molly, el actor por defecto de WME, tiene para cada dirección un sprite llamado turn.sprite, y en la definición del actor —molly.actor— tiene dos campos llamados "turnleft" y "turnright" (girar a la izquierda y girar a la derecha). El problema es que por defecto está vacío, y yo nunca investigué mucho de eso. En la documentación dice que sirve para dar más naturalidad a los actores, como por ejemplo el hecho de que las personas en realidad giramos los pies primero para cambiar de dirección.
¿no podría activar un script para todas estas situaciones aparte, y enlazarlo desde los objetos para, así, tener menos código?Sí. Tendrías que definir el método en un script aparte, usando la palabra method en lugar de function. Luego, en algún script del actor —preferentemente el que viene en la misma carpeta que su definición y sus animaciones— añadir
this.AttachScript(/* Acá, el script en que definiste tu método */);
y listo, ya podrás usar el TurnToObject() con la misma soltura que el Talk() o el GoToObject(), sin tener que definirlo cada vez. El script podrías añadirlo a cualquier objeto, pero me parece más conveniente al actor, sólo por una cuestión de organización.el codigo para activar otra animación en el prota (y ya que estamos, en el otro personaje), ¿cómo se haría?Es muy fácil. Tendrías que crear un sprite con tu animación y luego
actor.PlayAnim("actors\molly\golpear.sprite");
donde quieras que ejecute la animación.