// // Procedimientos de usuario // // NOTA: los procedimientos de este módulo permiten "enganchar" código de usuario // a las respuestas y al bucle principal del juego. // Los procedimientos de este módulo son los únicos que deberían // modificarse. // // v2.0 (15.03.2000) // // ******************************************************** // Los siguientes procedimientos (USR_...) son enganches desde el módulo 'Librería'. // Estos procedimientos se llaman cuando el jugador teclea alguna de las acciones // asociadas y antes de que la librería los procese con lo que se puede // colocar código que responda a casos especiales. // // Algunos reciben parámetros que pueden usarse para determinar su comportamiento. // // En todos ellos se debe devolver un valor para indicar si se ha respondido // o no a la acción. // ******************************************************** // -------------------------------------------------------- // aquí podemos añadir información a la línea de estado // para ello sólo tenemos que imprimirla con Print ya que // al entrar a este procedimiento ya estará seleccionada // la línea de estado y el cursor posicionado justo detrás // de la descripción corta de la localidad // si se quiere posicionar con exactitud el texto a imprimir // se usará ScreenAt(pant_info,x,y) donde 'x' e 'y' marcan // la posición dentro de la línea de estado // -------------------------------------------------------- Sub USR_LineaEstado() ScreenAt(pant_info,400,0) Print("Turnos: " + turnos) ScreenAt(pant_info,500,0) Print("Puntos: " + puntos) Return // -------------------------------------------------------- // a este procedimiento se le llama antes de mover al jugador // recibe: // 'dir' verbo de movimiento que indica la dirección hacia // donde quiere moverse el jugador // debe devolver TRUE si el jugador se mueve o FALSE si se queda donde está // -------------------------------------------------------- Sub USR_MueveJugador(dir) Declare(ret) declare(loc) declare(lista) declare(longlista) declare(dado) declare(exito) declare(psizombie) loc:=PSI[PSIJugador].Localidad ret:=TRUE // NOTAS: // en este procedimiento pueden hacerse comprobaciones de si una puerta // está abierta para permitir o impedir el paso del jugador en una // determinada dirección, si devolvemos FALSE se le impedirá el paso // al jugador, por ejemplo: // // If (PSI[PSIJugador].Localidad="HABITACION") & Not(LOC[dir].Abierta) Then // Print("La puerta " + dir + " está cerrada." + CR) // ret:=FALSE // EndIf // // También se puede decir aquí el porqué de no poder moverse en una dirección // para prescindir del monótono: "NO PUEDES IR POR AHI" // Tambien para poner una salida no contemplada en el mapa. // PERO ME PARECE ABSURDO METER LAS RAZONES POR LAS QUE NO SE PUEDA MOVER AQUI. // MIRAR USR_NoMueve() un poco más abajo. // WARNING: Si alguna localidad tiene conexión hacia si misma, con lo ke se contempla // en la descripción de las salidas; si quieres poner una razón para la que no vaya // por ella, fijate en la habitación de 18JULIO4, deberás poner aqui ese texto y no // en USR_NoMueve(), ya que ese sitio solo se ejecuta cuando falló el intento de // movimiento, y este no es el caso de las conexiones a si mismas, ya que son // un movimiento seguro (a menos que esté la puerta cerrada). Select loc Case "TECHO" if (dir="ESTE") then print("Por instinto levitas hacia la puerta. Tu avance parece imparable, ") print("pero al comenzar a travesarla, la sensación es demasiado fuerte y..." + CR) USR_Fin(2) ret:=FALSE endif Case "18JULIO4" Print("Caminas entre este mar de niebla con dificultad. A pesar de que ") print("logras divisar poco, te das cuenta de apenas avanzas, y a cada paso ") print("es como un pequeño saltito, notas que su espesura te eleva para ") print("después dejarte suavemente cerca de donde estabas." + CR) ret:=FALSE Case "CALLE1" if (dir="NORTE") then print("Todos esos zombies se dirijen hacia aqui poco a poco. Es un suicidio ir ") print("en esa dirección." + CR) ret:=FALSE endif Case "CALLE2" if (dir="ESTE") then print("\[N]¡¡¡IMPOSIBLE!!!:\[N] ¡Está atestado de zombies.!" + CR) ret:=FALSE endif Case "CALLEJON" if (dir="NORTE") then print("No es aconsejable echarte en los brazos de todos esos zombies." + CR) ret:=FALSE EndIf Case * // Aqui voy a chequear que no hay un PSI hostil boqueando una salida. if dir="NORTE" then lista:=Search("*","VIENE_DE=NORTE,HOSTIL=1",3) endif if dir="SUR" then lista:=Search("*","VIENE_DE=SUR,HOSTIL=1",3) endif if dir="ESTE" then lista:=Search("*","VIENE_DE=ESTE,HOSTIL=1",3) endif if dir="OESTE" then lista:=Search("*","VIENE_DE=OESTE,HOSTIL=1",3) endif longlista:=ArrayLen(lista) if longlista>0 then // hay algún zombie. psizombie:=ArrayItem(lista,1) print("Empiezas a avanzar en dirección "+LCase(dir)+" pero ") if longlista=1 then print(PSI[psizombie].DescCorta+" bloquea el paso."+CR) else print("varios zombies bloquean el camino."+CR) endif dado:=Random(1,100) exito:=10+((50*PSI[PSIJugador].fuerza)/100) if dado0) then print("¡¡¡Es un tesoro valioso!!!" + CR) ret:=TRUE endif endselect endif Return ret // -------------------------------------------------------- // EXAMINAR DETALLES // recibe: // 'espsi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver el texto sobre los detalles adicionales del // PSI o el objeto que se imprimirán al examinarlo // -------------------------------------------------------- Sub USR_ExaminarDetalles(espsi,nombre) Declare(txt) txt:="" // NOTA: // el EXAMINAR estándar llamará a esta procedimiento para obtener detalles // adicionales sobre el objeto o PSI en cuestión // detalles como si una botella está abierta o cerrada, o si un PSI // está herido, etc... por ejemplo: // // If psi Then // // suponemos que hemos definido una propiedad 'Herido' para los PSIs // If PSI[nombre].Herido Then // txt:="Tiene una herida por la que mana sangre en abundancia." // Else // txt:="Parece que está en buena forma." // EndIf // Else // // suponemos que hemos definido una propiedad 'Lleno' para los objetos // // que contendrá una cadena vacía si el objeto está vacío o una descripción // // del líquido que contiene si está lleno // If OBJ[nombre].Lleno="" Then // txt:="Está vacío." // Else // txt:="Contiene un poco de " + OBJ[nombre].Lleno + "." // EndIf // EndIf if espsi then // si hemos examinado un PSI if nombre=PSIJugador then EstadoJugador(TRUE) else // si es un PSI diferente al jugador if PSI[nombre].vida_cabeza<=0 then txt:=txt+"No tiene cabeza. " endif if PSI[nombre].vida_cuerpo<=0 then txt:=txt+"Tiene el cuerpo destrozado. " endif if (PSI[nombre].vida_brazo_izq<=0)|(PSI[nombre].vida_brazo_izq<=0) then if (PSI[nombre].vida_brazo_izq<=0)&(PSI[nombre].vida_brazo_izq<=0) then txt:=txt+"No tiene brazos. " else if PSI[nombre].vida_brazo_izq<=0 then txt:=txt+"Le falta el brazo izquierdo. " endif if PSI[nombre].vida_brazo_dch<=0 then txt:=txt+"Le falta el brazo izquierdo. " endif endif endif if (PSI[nombre].vida_pierna_izq<=0)|(PSI[nombre].vida_pierna_izq<=0) then if (PSI[nombre].vida_pierna_izq<=0)&(PSI[nombre].vida_pierna_izq<=0) then txt:=txt+"Le faltan ambas piernas. " else if PSI[nombre].vida_pierna_izq<=0 then txt:=txt+"No tiene pierna izquierda. " endif if PSI[nombre].vida_pierna_dch<=0 then txt:=txt+"No tiene pierna izquierda. " endif endif endif endif // si el psi es el propio jugador ELSE // si hemos examinado un objeto if OBJ[nombre].gore>0 then if (OBJ[nombre].gore>0)&(OBJ[nombre].gore<=4) then print("Tiene unas manchas de sangre. "+CR) endif if (OBJ[nombre].gore>4)&(OBJ[nombre].gore<=9) then print("Tiene sangre por todas partes. "+CR) endif if (OBJ[nombre].gore>9) then print("Tiene abundante sangre chorreante y trozos de carne adheridos. "+CR) endif endif endif // añadimos un espacio adicional a los detalles If txt<>"" Then txt:=" " + txt EndIf Return txt // -------------------------------------------------------- // COGER // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Coger(psi,nombre) Declare(ret) declare(locjugador) locjugador:=PSI[PSIJugador].Localidad ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta COGER // un objeto o PSI, podemos obviar la acción estándar de COGER // si se devuelve TRUE, por ejemplo: // // If psi Then // // suponemos que se ha definido una propiedad 'Cogido' para los PSIs // If PSI[nombre].Cogido Then // Print("Ya llevas en brazos a " + PSI[nombre].DescCorta + "." + CR) // PSI[nombre].Cogido:=TRUE // Else // Print("Coges en brazos a " + PSI[nombre].DescCorta + "." + CR) // EndIf // ret:=TRUE // Else // // la típica acción de COGER PIEDRA que aumenta las que lleva el jugador // If (nombre="PIEDRA") & (PSI[PSIJugador].Localidad="CAMINO") Then // Print("Coges una piedra de la muchas que hay por el suelo." + CR) // piedras:=piedras+1 // ret:=TRUE // EndIf // EndIf if parsenombre1="NIEBLA" then if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then print("Coges un puñado de niebla, notas el tacto gélido ") print(" y la humedad en tu mano. Al rato se funde en el aire." + CR) ret:=TRUE endif endif Return ret // -------------------------------------------------------- // DEJAR // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Dejar(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta DEJAR // un objeto o PSI, podemos obviar la acción estándar de DEJAR // si se devuelve TRUE, por ejemplo: // // If psi Then // // suponemos que se ha definido una propiedad 'Cogido' para los PSIs // If PSI[nombre].Cogido Then // Print("Dejas a " + PSI[nombre].DescCorta + " en el suelo." + CR) // PSI[nombre].Cogido:=FALSE // Else // Print("No llevas a " + PSI[nombre].DescCorta + " en brazos." + CR) // EndIf // ret:=TRUE // Else // // la típica acción de DEJAR PIEDRA que decrementa las que lleva el jugador // If nombre="PIEDRA" Then // If piedras>0 Then // Print("Dejas una piedra." + CR) // piedras:=piedras-1 // Else // Print("No tienes piedras." + CR) // EndIf // ret:=TRUE // EndIf // EndIf Return ret // -------------------------------------------------------- // METER // recibe: // 'nombre' nombre del objeto al que nos referimos // 'nombre_contenedor' nombre del objeto dónde queremos meterlo // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Meter(nombre,nombre_contenedor) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta METER // un objeto dentro de otro, podemos obviar la acción estándar // de METER si se devuelve TRUE, por ejemplo: // // If (nombre="PIEDRA") & (nombre_contenedor="SACO") Then // If piedras>0 Then // Print("Metes una piedra en el saco." + CR) // piedras:=piedras-1 // piedras_saco:=piedras_saco+1 // Else // Print("No llevas ninguna piedra." + CR) // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // SACAR // recibe: // 'nombre' nombre del objeto al que nos referimos // 'nombre_contenedor' nombre del objeto dónde queremos meterlo // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Sacar(nombre,nombre_contenedor) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta SACAR // un objeto de otro, podemos obviar la acción estándar // de SACAR si se devuelve TRUE, por ejemplo: // // If (nombre="PIEDRA") & (nombre_contenedor="SACO") Then // If piedras_saco>0 Then // Print("Sacas una piedra del saco." + CR) // piedras_saco:=piedras_saco-1 // piedras:=piedras+1 // Else // Print("No hay ninguna piedra dentro del saco." + CR) // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // ABRIR // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Abrir(nombre) Declare(ret) Declare(loc) ret:=FALSE loc:=PSI[PSIJugador].Localidad // NOTAS: // este procedimiento se ejecuta cada vez que se intenta ABRIR // un objeto, podemos obviar la acción estándar de ABRIR si se // devuelve TRUE, por ejemplo: // // If nombre="PUERTA" Then // If PSI[PSIJugador].Localidad:="HABITACION" Then // If LOC["HABITACION"].Abierta("NORTE") Then // Print("La puerta ya está abierta." + CR) // Else // Print("Abres la puerta." + CR) // LOC["HABITACION"].Abrir("NORTE") // EndIf // ret:=TRUE // EndIf // EndIf if nombre="PUERTA" then if loc="EXPLANADA2" then print("Es imposible. Está cerrada por dentro, y de noche no hay nadie ahí..."+CR) endif endif Return ret // -------------------------------------------------------- // CERRAR // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Cerrar(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta CERRAR // un objeto, podemos obviar la acción estándar de CERRAR si se // devuelve TRUE, por ejemplo: // // If nombre="PUERTA" Then // If PSI[PSIJugador].Localidad:="HABITACION" Then // If LOC["HABITACION"].Abierta("NORTE") Then // Print("Cierras la puerta." + CR) // LOC["HABITACION"].Cerrar("NORTE") // Else // Print("La puerta ya está cerrada." + CR) // EndIf // ret:=TRUE // EndIf // EndIf Return ret // -------------------------------------------------------- // PONER // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Poner(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta PONER // un objeto, podemos obviar la acción estándar de PONER si se // devuelve TRUE, por ejemplo: // // If nombre="ESCAFANDRA" Then // Print("No estás entrenado para ponerte una escfandra. Quizá deberías pedir ayuda." + CR) // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // QUITAR // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Quitar(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta QUITAR // un objeto, podemos obviar la acción estándar de QUITAR si se // devuelve TRUE, por ejemplo: // // If (nombre="ESCAFANDRA") & (PSI[PSIJugador].Localidad:="FONDO MARINO") Then // Print("Primero deberías salir del agua, ¿no crees?." + CR) // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // ENCENDER // recibe: // 'nombre' nombre del objeto/PSI sobre el que se actúa // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Encender(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta ENCENDER // un objeto, podemos obviar la acción estándar de ENCENDER si se // devuelve TRUE, por ejemplo: // // If nombre="TELEVISION" Then // If OBJ[nombre].Encendido Then // Print("La televisión ya está encendida." + CR) // Else // Print("Enciendes la televisión." + CR) // OBJ[nombre].Encendido:=TRUE // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // APAGAR // recibe: // 'nombre' nombre del objeto/PSI sobre el que se actúa // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Apagar(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta APAGAR // un objeto, podemos obviar la acción estándar de APAGAR si se // devuelve TRUE, por ejemplo: // // If nombre="TELEVISION" Then // If OBJ[nombre].Encendido Then // Print("Apagas la televisión." + CR) // OBJ[nombre].Encendido:=FALSE // Else // Print("La televisión está apagada." + CR) // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // SABOREAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Saborear(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta SABOREAR o CHUPAR // un objeto o PSI, podemos obviar la acción estándar de SABOREAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- Return ret // -------------------------------------------------------- // OLER // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Oler(psi,nombre) Declare(ret) declare(locjugador) locjugador:=PSI[PSIJugador].Localidad ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta OLER // un objeto o PSI, podemos obviar la acción estándar de OLER si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then if (ParseNombre1="NIEBLA") then print("¿A que huelen las cosas que no huelen?"+CR) ret:=TRUE endif endif Return ret // -------------------------------------------------------- // ESCUCHAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Escuchar(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta ESCUCHAR // un objeto o PSI, podemos obviar la acción estándar de ESCUCHAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- Return ret // -------------------------------------------------------- // TOCAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Tocar(psi,nombre) Declare(ret) declare(locjugador) ret:=FALSE locjugador:=PSI[PSIJugador].Localidad // NOTAS: // este procedimiento se ejecuta cada vez que se intenta TOCAR // un objeto o PSI, podemos obviar la acción estándar de TOCAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- if (ParseNombre1="NIEBLA") then if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then print("Realizas el gesto de palpar la niebla y ") print("notas como se hace hebras al pasar por tus dedos." + CR) ret:=TRUE endif endif Return ret // -------------------------------------------------------- // LANZAR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Lanzar() Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se llama cuando se intenta LANZAR algo // la acción por defecto de LANZAR es dejar el objeto // podemos obviar la acción estándar codificándola aquí // y devolviendo TRUE, por ejemplo: // // If ParseNombre1:="PIEDRA" Then // If piedras>0 Then // Print("Arrojas la piedra muy lejos." + CR) // piedras:=piedras-1 // Else // Print("No llevas ninguna piedra." + CR) // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // GOLPEAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Golpear(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta GOLPEAR // un objeto o PSI, podemos obviar la acción estándar de GOLPEAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- Return ret // -------------------------------------------------------- // CORTAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Cortar(psi,nombre) Declare(ret) declare(locjugador) ret:=FALSE locjugador:=PSI[PSIJugador].Localidad // NOTAS: // este procedimiento se ejecuta cada vez que se intenta CORTAR // un objeto o PSI, podemos obviar la acción estándar de CORTAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- if (ParseNombre1="NIEBLA") then if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then print("Sesgas la niebla, separándola de un tajo, pero ") print("al rato, toda su densidad ocupa el espacio rajado." + CR) ret:=TRUE endif endif Return ret // -------------------------------------------------------- // ATAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Atar(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta ATAR // un objeto o PSI, podemos obviar la acción estándar de ATAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- Return ret // -------------------------------------------------------- // DESATAR // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Desatar(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta DESATAR // un objeto o PSI, podemos obviar la acción estándar de DESATAR si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- Return ret // -------------------------------------------------------- // MOVER // recibe: // 'psi' TRUE si nos referimos a un PSI o FALSE a un objeto // 'nombre' nombre del objeto o PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Mover(psi,nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta MOVER // un objeto o PSI, podemos obviar la acción estándar de MOVER si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_COGER --- if (ParseNombre1="NIEBLA") then if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then print("Con amplios movimientos de brazos, desplazas la niebla ") print("de un lado para otro, sin conseguir nada." + CR) ret:=TRUE endif endif Return ret // -------------------------------------------------------- // MATAR // recibe: // 'nombre' nombre del PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Matar(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta MATAR // a un PSI, podemos obviar la acción estándar de MATAR si se // devuelve TRUE, por ejemplo: // // If EstaPresentaPSI(nombre) Then // If PSI[PSIJugador].Contiene("PISTOLA") Then // If PSI[nombre].Muerto Then // Print(PSI[nombre].DescCorta + " ya está muerto. ¿No querrás matarlo dos veces?." + CR) // Else // Print("Disparas contra " + PSI[nombre].DescCorta + " y este cae muerto al suelo." + CR) // PSI[nombre].Muerto:=TRUE // EndIf // Else // Print("No tienes ningún arma que puedas usar para matar a " + PSI[nombre].DescCorta + "." + CR) // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // BEBER // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Beber(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta BEBER // algo, podemos obviar la acción estándar de BEBER si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_ENCENDER --- Return ret // -------------------------------------------------------- // COMER // recibe: // 'nombre' nombre del objeto al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Comer(nombre) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta COMER // algo, podemos obviar la acción estándar de COMER si se // devuelve TRUE, por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_ENCENDER --- Saborear() ret:=true Return ret // -------------------------------------------------------- // SALTAR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Saltar() Declare(ret) declare(locjugador) ret:=FALSE locjugador:=PSI[PSIJugador].Localidad // NOTAS: // este procedimiento se ejecuta cada vez que se intenta SALTAR // podemos obviar la acción estándar de SALTAR si se devuelve TRUE // por ejemplo: // // If ParseNombre1="ABISMO" Then // If PSI[PSIJugador].Localidad="ABISMO" Then // Print("Con total despreocupación por la vida, te lanzas al vacío..." + CR) // Print("*** Estás muerto ***" + CR) // Abandonar() // Else // Print("¿A qué abismo?. Creo que deliras." + CR) // EndIf // ret:=TRUE // EndIf if (locjugador="18JULIO4") then print("Te elevas con facilidad en esta niebla tan rara." + CR) print("\[N]\[C]¡¡¡Estás volando!!!\[C]\[N] Sin poder evitarlo te mueves ") print("como en el agua, agitando los brazos que a cada impulso te ") print("elevan un poco más.") print("Te sientes nadador del cielo, pero falta la frustrante fricción ") print("del agua, ligero de movimientos, libre para ir donde quieras...") pause() PSI[PSIJugador].Localidad:="CUARTO" PSI[PSIJugador].estado:="despierto" RobaObjetos(PSIJugador) PSI[PSIJugador].Vitalidad:=100 // esto es pa que deje de sangrar. PSI[PSIJugador].Vida_Cabeza:=60 PSI[PSIJugador].Vida_Cuerpo:=90 PSI[PSIJugador].Vida_Brazo_Izq:=60 PSI[PSIJugador].Vida_Brazo_Dch:=60 PSI[PSIJugador].Vida_Pierna_Izq:=80 PSI[PSIJugador].Vida_Pierna_Dch:=80 ScreenCls(0) DescripcionLocalidad() ret:=TRUE else if (locjugador="18JULIO3") then print("Saltas en el sitio sin conseguir nada... \[N]\[C]ESPERA\[C]\[N] el pequeño impulso se amplifica elevandote un poco más de lo esperado." + CR) print("Vuelves a bajar lentamente. ") print(dialogo_psi1 + "¡¡¡Que extraño!!! ¿será cosa de la niebla?" + dialogo_psi2 + color_letra + " piensas.") ret:=TRUE else print("Saltas en el sitio sin conseguir nada.") ret:=TRUE endif Endif Return ret // -------------------------------------------------------- // GRITAR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Gritar() Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta GRITAR // podemos obviar la acción estándar de GRITAR si se devuelve TRUE // por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_SALTAR --- Return ret // -------------------------------------------------------- // CANTAR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Cantar() Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta CANTAR // podemos obviar la acción estándar de CANTAR si se devuelve TRUE // por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_SALTAR --- Return ret // -------------------------------------------------------- // BESAR // recibe: // 'psi' nombre del PSI al que nos referimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Besar(psi) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta BESAR a un PSI // podemos obviar la acción estándar de BESAR si se devuelve TRUE // por ejemplo: // // If psi="NIÑA" Then // If EstaPresentePSI(psi) Then // Print("La niña se pone muy contenta." + CR) // EndIf // ret:=TRUE // EndIf if EstaPresentePSI(psi) then print("Claaaaro hombre, pónselo más facil..."+CR) ret:=TRUE endif Return ret // -------------------------------------------------------- // DORMIR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Dormir() Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta DORMIR // podemos obviar la acción estándar de DORMIR si se devuelve TRUE // por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_SALTAR --- Return ret // -------------------------------------------------------- // DECIR // recibe: // 'nombre' nombre del PSI al que nos referimos // 'frase' frase que le decimos // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Decir(nombre,frase) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta DECIR A PSI "xxx" // podemos obviar la acción estándar de DECIR si se devuelve TRUE // por ejemplo: // // If nombre="NIÑA" Then // Parse(frase) // If (ParseVerbo="COMO") & (ParseNombre1="LLAMAS") Then // HablaPSI("Me llamo María pero mi mamá me llama Mari.","dice la niña.") // Else // HablaPSI("No te entiendo.","dice la niña.") // EndIf // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // DAR // recibe: // 'objeto' nombre del objeto que queremos dar // 'psi' nombre del PSI a quien le queremos dar el objeto // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Dar(objeto,psi) Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta DAR OBJ A PSI // podemos obviar la acción estándar de DAR si se devuelve TRUE // por ejemplo: // // If (objeto="ESPADA") & (psi="SOLDADO") Then // Print("El soldado coge la espada que le entregas y de un mandoble mortal decapita al troll.") // HablaPSI("Gracias, por poco no lo contamos.","dice el soldado al tiempo que te devuelve la espada.") // ret:=TRUE // EndIf Return ret // -------------------------------------------------------- // ESPERAR // debe devolver TRUE si dió respuesta a la acción, FALSE si no // -------------------------------------------------------- Sub USR_Esperar() Declare(ret) ret:=FALSE // NOTAS: // este procedimiento se ejecuta cada vez que se intenta ESPERAR // podemos obviar la acción estándar de ESPERAR si se devuelve TRUE // por ejemplo: // // --- PARA UN EJEMPLO SIMILAR SE PUEDE CONSULTAR EL DE USR_SALTAR --- Return ret // -------------------------------------------------------- // acciones anteriores a que se procese el comando del jugador // aquí se llega después de analizar el comando pero antes // de que se ejecute la acción asociada (si hubiese alguna) // -------------------------------------------------------- Sub USR_Ant() declare(locjugador) locjugador:=PSI[PSIJugador].Localidad // NOTAS: // uno de los usos de este procedimiento es convertir // ciertas acciones del jugador en otras // por ejemplo: // // suponemos que hemos codificado la respuesta a LLENAR VASO y queremos que // el jugador pueda también teclear VERTER o VACIAR LICOR EN VASO y // VERTER o VACIAR BOTELLA EN VASO sin tener que codificar una respuesta independiente // a estas acciones, podemos conseguir esto de la siguiente manera: // // If ((ParseVerbo="VERTER") | (ParseVerbo="VACIAR")) & ((ParseNombre1="LICOR") | (ParseNombre1="BOTELLA")) & (ParseNombre2="VASO") Then // ParseVerbo:="LLENAR" // ParseNombre1:="VASO" // ParseNombre2:="" // Endif // // ahora la aventura entenderá tanto LLENAR VASO, VERTER LICOR EN VASO, // VACIAR BOTELLA EN VASO como la misma acción y dará respuesta como si // hubiésemos tecleado LLENAR VASO en cualquier caso if (locjugador="18JULIO4")&(parseverbo="NADAR") then parseverbo:="SALTAR" endif if parseverbo="MATAR" then parseverbo:="GOLPEAR" endif If (parseverbo="COGER")&(parsepreposicion="EN") then parseverbo:="SACAR" endif if (parseverbo="DEJAR")&(parsepreposicion="EN") then parseverbo:="METER" endif if (parseverbo="QUITAR")&(parsenombre1="ROPA") then parseverbo:="DESNUDAR" endif Return // -------------------------------------------------------- // respuestas a otras acciones no contempladas en la librería estándar // debe devolver TRUE si se dió una respuesta a al acción o FALSE si no // -------------------------------------------------------- Sub USR_Respuesta() Declare(ret) Declare(obj) declare(locjugador) locjugador:=PSI[PSIJugador].Localidad ret:=FALSE // NOTAS: // la estructura más común del código en este procedimiento // consiste en una sentencia SELECT que discrimine el verbo // tecleado y ejecute la acción correspondiente, por ejemplo: // Procesos sinónimos: // Select de Verbos Select ParseVerbo Case "BLANDIR" Blandir() ret:=TRUE Case "EMPUJAR" Empujar() ret:=TRUE Case "DESNUDAR" print("Claaaaro hombre... así los zombies te devorarán sin tener que pelarte...") ret:=TRUE Case "SOPLAR" if (locjugador="18JULIO2")|(locjugador="18JULIO3")|(locjugador="18JULIO4") then if (ParseNombre1="NIEBLA") Then print("Soplas y creas un vacío sin la mancha translúcida, ") print("pero no tarda la niebla en volver a ocupar su espacio vital."+CR) ret:=TRUE endif endif Case "XYZZY" if (locjugador="TECHO") then secret:=TRUE print("\[N]\[C]¡¡¡Comienzas a elevarte a una velocidad vertiginosa!!!.\[C]\[N]" + CR) print("Atraviesas rápidamente el techo, ves a la vecina del sexto, ") print("atraviesas el tejado, y te elevas y elevas...." + CR) print("La tierra se aleja, viajas a la velocidad de la luz a otra zona ") print("del planeta, comienzas a caer, una región aislada: un volcán, ") print("un bosque, un barranco, tierra, tierra..." + CR) print("Atraviesas la tierra, viajas entre ella... y la velocidad por fin cede." + CR) print(dialogo_psi1 + "¡¿QUE SITIO ES ESTE?!" + dialogo_psi2) print(tipo_letra + color_letra + " piensas.") PSI[PSIJugador].Localidad:="RECOLECTOR" ret:=TRUE else if (locjugador="RECOLECTOR") then print("\[C]De nuevo atravesando la tierra hacia el cielo, vuelas sobre el mundo ") print("hasta divisar tu país. Caes a una velocidad vertiginosa, la tierra ") print("se acerca peligrosamente. \[N]¡Te vas a estrellar contra ese edificio!\[N] ") print("Atraviesas el tejado, ves a la vecina del sexto, atraviesas el techo... \[C]" + CR) print("Y paras en seco de nuevo en tu dormitorio, gravitando cerca del techo." + CR) PSI[PSIJugador].Localidad:="TECHO" ret:=TRUE else print("\[C]Nothing happens...\[C]" + CR) ret:=TRUE EndIf EndIf ret:=TRUE Case "NADAR" print("No hay fluido en el que nadar."+CR) ret:=TRUE endselect Return ret // -------------------------------------------------------- // mensajes de copyright // -------------------------------------------------------- Sub USR_Copyright() Declare(spc) Declare(copyright) Declare(email) Declare(web) Declare(descripcion) spc:=" " copyright:="(c) Clérigo Urbatain." email:="ruberalbert@bigfoot.com" web:="" descripcion:="¡¡¡LA CIUDAD ESTÁ INVADIDA POR LOS ZOMBIES!!!" Print(CR + " \[Times New Roman]\[12]\[RGB(FFFFCC)]\[N]" + titulo + "\[N]" + CR) Print("\[10]\[C]" + spc + copyright + "\[C]" + CR) Print(spc + "\[RGB(8080FF)]\[S]" + email + "\[S] " + web) Print(CR + spc + "\[RGB(FFCCCC)]" + descripcion) Print(CR + spc + "Versión " + version + " / intérprete " + VerVS) // inicializamos el tipo de letra y color del texto Print(tipo_letra + color_letra + CR + CR) Return // -------------------------------------------------------- // introducción // -------------------------------------------------------- Sub USR_Inicio() print("\[C]El virus se ha extendido por toda la zona... es normal: la multinacional SOMBRILLA ") print("CORPORATION S.L. compró, hará poco, la fábrica de ELECTROQUÍMICA ANDALUZA S.A., con motivo de ") print("un acuerdo económico entre paises. Como ") print("SOMBRILLA CORP. tuvo problemas en la ciudad de Ricoon City, en U.S.A., con la policía de allí, ") print("aparte de arrasar con toda la población de la ciudad, decidieron venirse a un pais donde la ") print("opinión de los ciudadanos pintaba poco, y los delitos ecológicos se acallaban fácilmente con dinero."+CR) print("Como era de esperar, la fábrica no tardó en reventar, propagando un peligroso virus que ") print("aunque de poco radio y corta vida de existencia, bastó contaminar unos inofensivos animales ") print("para convertirlos en unos asesinos sanguinarios deseosos de sangre y entrañas. ") print("De ahí a una población de zombies, hay sólo un paso..."+CR) print("Así que te ves escapando por tu ciudad, de noche, silenciosa, sólo perturbada por el olor ") print("nauseabundo que arroja a tu cara el viento, sople de donde sople, y por los murmullos y el ") print("arrastrar de pies de los espectros, que desplazan sus carcasas por las calles en busca de ") print("comida fresca... y tú aún estás fresco...\[C]"+CR) pause(0) ScreenCls(0) Print(CR+"\[RGB(E0E000)]\[Times New Roman]\[C](Teclea \[N]AYUDA\[N] para leer cómo jugar a este juego.)\[C]" + tipo_letra + color_letra + CR + CR) Return // -------------------------------------------------------- // música de fondo // -------------------------------------------------------- Sub USR_MusicaFondo() If hay_sonido Then musica_fondo:=LoadSong("#9999") PlaySong(musica_fondo) EndIf Return // -------------------------------------------------------- // pantalla de ayuda // -------------------------------------------------------- Sub USR_Ayuda() ScreenCls(0) Print(CR+"\[RGB(FFFFCC)]\[Times New Roman]") print("Una parte importantísima de este juego es luchar contra los zombies, por tanto haré incapié en las reglas y comandos del ") print("\[N]\[C]SISTEMA DE LUCHA:\[C]\[N]"+CR+CR) print("Para atacar usa \[N]GOLPEAR \[N]. Si existe ambiguedad por haber varios PSIs enemigos presentes y no se ha metido el adjetivo, ") print("el parser eligirá uno de ellos semialeatoriamente. O sea que como hay varios ZOMBIES, si no pones un adjetivo pa' diferenciar ") print("a quién quieres atacar concretamente, el juego decidirá por ti."+CR+CR) print("Puedes elegir la zona del cuerpo donde descargar tu golpe: \[N]CABEZA, CUERPO o TORSO, ") print("BRAZO IZQUIERDO, BRAZO DERECHO, PIERNA IZQUIERDA y PIERNA DERECHA.\[N] Esto se hace con \[N]GOLPEAR EN \[N]. Si no escribes ") print("una zona a golpear, el parser eligirá una zona por ti al azar. Respecto a los BRAZOS y las PIERNAS, hay que concretar si ") print("deseas golpear la derecha o la izquierda. Si no lo haces así, el parser eligirá entre los dos al azar."+CR+CR) print("Debes saber que puedes usar cualquier objeto que encuentres como arma. Por supuesto cada cual tiene sus propias ") print("características dependiendo de lo contundentes que sean y de su peso."+CR) print("Para elegir un objeto como arma pon \[N]BLANDIR \[N], y este pasará a ser el arma al golpear por defecto ") print("(Si no, deberás luchar con las manos desnudas, que no es muy aconsejable...), ") print("aunque también puedes poner \[N]GOLPEAR CON \[N], que hace lo mismo que \[N]BLANDIR\[N], pero asesta un golpe con ella, ") print("lo cual es muy efectivo para comenzar un ataque."+CR) Pause(0) ScreenCls(0) print(CR+"\[N]\[C]EJEMPLOS:\[C]\[N]"+CR) print("\[N]GOLPEAR ZOMBIE\[N] (sin elegir arma ni zona. El parser lo hará automáticamente)"+CR) print("\[N]GOLPEAR ZOMBIE CON BARRA\[N] (zona se elige al azar y blandes el arma)"+CR) print("\[N]GOLPEAR ZOMBIE EN BRAZO IZQUIERDO \[N](esto es lo ideal para concentrar los golpes en una zona hacer más daño en ella)"+CR) print("\[N]GOLPEAR ZOMBIE EN PIERNA \[N](no se ha especificado cual de las dos piernas, el parser lo hará al azar)"+CR+CR) print("\[N]\[C]NOTA:\[N]\[C]"+CR+"Olvídate de poner \[N]GOLPEAR ZOMBIE EN CABEZA CON BARRA\[N] o similares. Esto no es INFORM y el parser es muy limitado ") print("a ese respecto, así que entenderá sólo la primera preposición que le pongas y omitirá la segunda."+CR) print("No olvides poner siempre el objetivo, o sea, que \[N]GOLPEAR EN CABEZA o GOLPEAR\[N] simplemente, no serán entendidos por el parser."+CR) print("Yo te recomiendo que incialmente comiences blandiendo el arma, después ataques a un zombie al azar, y una vez concretado ") print("el zombie atacado y su zona corporal, empieza a fustigarle en esa parte del cuerpo concreta. Un ejemplo:"+CR) print("\[N]BLANDIR BARRA o GOLPEAR ZOMBIE CON BARRA\[N]"+CR) print("\[N]GOLPEAR ZOMBIE\[N] (el parser informa: golpeas al zombie putrefacto en la cabeza)"+CR) print("\[N]GOLPEAR ZOMBIE PUTREFACTO EN CABEZA \[N](¡¡¡¡yeeeeeeeeaaaaah!!!! ¡se la has reventado!)"+CR+CR) pause(0) ScreenCls(0) print(CR+"Cada golpe que des, cada ataque que recibas, caminar, y casi pensar, gastan energía: ") print("Si pierdes muchas fuerzas, tus ataques serán más lentos y débiles y harás menos daño al enemigo. También si te quedas sin fuerzas ") print("te quedarás indefenso durante unos instantes hasta que recuperes el aliento. Así que mide bien tus golpes y acciones o serás carne ") print("para zombie."+CR+"Procura descansar de vez en cuando, simplemente no haciendo nada, esperando o cualquier acción que no sea ni ") print("atacar ni moverte. El programa te informará de vez en cuando si tus fuerzas bajan o suben, así que vigila esos mensajes."+CR) print("También te informa de las heridas que tienes, si estas son graves y pierdes sangre, con lo que perderás fuerza en cada turno, ") print("así que intenta no ir manchando las calles con tu propia sangre, ¿ok?."+CR+CR) print("Aparte de golpear, puedes \[N]EMPUJAR \[N] a los zombies, que si tienes éxito, los dejarás desorientados un ratito."+CR+CR) print("\[N]\[C]RECUERDA:\[N]\[C] un zombie sin brazos, tiene menos fuerza; y sin piernas serán más lentos; y sin brazos ni piernas serán como peces ") print("fuera del agua."+CR+CR) print("También el sistema de puntos, sólo crece por magullar zombies, como si de un arcade se tratase, asi que es independiente de pasarse el juego."+CR) pause(0) ScreenCls(0) print(CR+"Aparte del sistema de lucha, en este juego se interactúa con las órdenes normales en este tipo de juegos:"+CR) Print("\[N]COGER, DEJAR, MIRAR (M), EXAMINAR (EX), INVENTARIO (I), METER, SACAR, ABRIR, CERRAR, PONER, QUITAR, ENCENDER, APAGAR, ") Print("GOLPEAR, MATAR, ATAR, DESATAR, CORTAR, MOVER, OLER, SABOREAR, TOCAR, ESCUCHAR, LANZAR, BEBER, COMER, ") Print("SALTAR, GRITAR, CANTAR, BESAR, DORMIR, DAR, XYZZY\[N] (¿¡Como!?, ¿que no sabes que es XYZZY?, entonces no eres muy ") print("aventurero... Bájate ahora mismo la Aventura Original y cuando lo sepas vuelves. Pero bueno... si lo deseas saber: ") print("es una palabra \[C]mágica\[C]."+CR+CR) Print("Se pueden teclear acciones múltiples en una sola línea sin más que encadenarlas con comas (,) o con \[N]Y\[N]. ") Print("Además se pueden usar pronombres para referirse al último objeto referenciado dentro de una acción, por ejemplo:" + CR) Print("\[N]COGER EL LIBRO, LEERLO Y DEJARLO\[N]" + CR) Print("En cualquier momento puedes hacer que la acción transcurra sin que tú hagas nada usando el verbo \[N]ESPERAR (Z)\[N]" + CR) print("Y para saber las direcciones hacia donde ir, escribe: \[N]SALIDAS (X).\[N]"+CR) // Print("Además puedes guardar y recuperar el estado del juego con los comandos \[N]GUARDAR y CARGAR\[N]" + CR) Print("Para salir del juego debes teclear \[N]FIN o ABANDONAR\[N]." + CR) Print("\[N]TURNOS\[N] muestra los turnos que llevas de juego." + CR+CR) Print("Pero lo mejor es que olvides todo esto y pongas lo que te salga del alma. El parser intentará entenderte lo más que pueda."+CR) Print("\[N]NOTA:\[N] He quitado la opción de \[N]CARGAR\[N] y \[N]GRABAR\[N], pues el juego es muy breve y puede terminarse sin problemas de una sentada.") Print("Además le da un tinte más arcade a la cosa, y tendrás que te tener más cuidado con los zombies."+CR) print(CR+"\[N]\[C]¡¡¡SUERTE!!!\[C]\[N]"+CR) pause(0) Print(tipo_letra + color_letra) Return sub USR_DescObjs(loc) // Esto es igualito a USR_DescPsis(loc), más arriba, sólo que aplicado a Objetos declare(objs) declare(numobjs) declare(lista) declare(i) declare(c) declare(obj) objs:=LOC[loc].Objetos() numobjs:=ArrayLen(objs) If numobjs>0 Then lista:="" For i:=1 To numobjs obj:=ArrayItem(objs,i) If Not(OBJ[obj].Invisible) Then c:=OBJ[obj].DescCorta lista:=ArrayInsert(lista,ArrayLen(lista)+1,c) EndIf Next EndIf return lista // Fin, con posibilidad de meter varios finales sub USR_Fin(n) Select n Case 0 // muerto por marabunta print("Una avalancha de zombies se te echa encima. Te derriban y caes sepultado entre un mar de cuerpos, brazos y piernas. ") print("Un hedor nauseabundo te golpea el olfato, casi pierdes el sentido ante la profanación de tanta putrefacción. ") print("Por un momento la confusión es total, y no puedes sino gritar de horror y desesperación, pues no tardan mucho ") print("en localizar tu blanda y fresca sangre, morderla, desgarrarla...."+CR) print("El dolor es inmenso, no hay zona de tu cuerpo que no haya sido mordida y atacada, y pronto caes insconsciente ") print("ante el asalto de dolor y hedor al que te enfrentas. Aún desmayado sigues sintiendo como engullen tus ") print("entrañas, sacan tus vísceras... cuando por fin a uno le da por abrirte la cabeza y sorberte los sesos..."+CR) print("En ese instante, el alivio viene a tu ser..."+CR) pause(0) ScreenCls(0) ScreenAt(0,240,170) print("\[RGB(FF0000)]\[18]\[N]GAME OVER\[N]"+CR+tipo_letra+color_letra) pause(2000) ScreenAt(0,0,270) Abandonar() CASE 1 // Devorado por zombies print("Al caer en la insconsciencia, sientes como ") print("más y más zombies se unen al festín."+CR) pause(0) ScreenCls(0) ScreenAt(0,240,170) print("\[RGB(FF0000)]\[18]\[N]GAME OVER\[N]"+CR+tipo_letra+color_letra) pause(2000) ScreenAt(0,0,270) Abandonar() CASE 2 // Final relatado del juego print("En un instante hay un flash que te ciega, no es sino la velocidad con la que te ") print("precipitas a tu cuerpo, el cual reclama lo que es tuyo/suyo..." + CR) print("El retorno es doloroso, los nervios inactivos reclaman información, el ") print("cerebro se reactiva originando una tormenta." + CR) print("Todo se vuelve oscuro, mientras notas como los rayos se expanden por tus ") print("nervios adormilados.... el dolor... tu cuerpo se convulsina por la descarga que ") print("está recibiendo. Observas miles de luces viajando al infinito. Durante un ") print("instante te sientes infinito..." + CR) pause() ScreenCls(0) print("La tormenta se apaga al fin, la vista se vuelve nublosa y observas la pared.") print("Tienes la cabeza ladeada. Una baba caida resbala por tu barbilla. Te cuesta ") print("controlar tu cuerpo." + CR) print("Al fin reunes fuerzas para incorporarte un poco. La cabeza te late aún con fuerza ") print("después de la 'extraña' experiencia. No puedes reprimir un sollozo. Has pasado ") print("mucho miedo. El salto ha sido increible, pero la tormenta terrible. No sabes si ") print("reir o llorar por lo acontecido:" + CR) print("\[N]\[C]¡¡¡Has tenido un viaje Astral!!!\[C]\[N]" + CR) print("Aún aturdido te levantas y enciendes el ordenador. Se te hace extraño el tacto ") print("del botón de arranque: solidez." + CR) print("Te sientas delante del ordenador y te dispones a relatar la maravillosa ") print("experiencia vivida.") pause() Screen(pant_info) ScreenCls(pant_info) ScreenAt(pant_info,250,0) print("\[C]\[N]EL FIN\[N]\[C]") screen(0) ScreenCls(0) print("\[C] Debo de estar loco, o al menos eso me repetía a mi mismo hace un rato. No por lo que me ") print("ha pasado, que lo tengo más que asumido, sino por el hecho de haberme decidido a narrarlo, y narrar ") print("también todo lo relacionado con ello. Y a narrarlo a las 5:13 horas de la madrugada del domingo ") print("al lunes, en noviembre, a finales del mes y del año 96." + CR) print(" Me ha costado eso de un cuarto de hora decidirme a levantarme y escribir. Un cuarto de ") print("hora pensando y dándole vueltas a la idea, acongojado en la oscuridad, con la piel de gallina y ") print("temblando a las sombras. Miedo y a la vez gozo: no quepo en mi gozo de lo que he ") print("experimentado esta noche, y esa alegría ha hecho que esté aqui. No se porqué ni a quién va ") print("dirigido esto, pero ya veré que hago, quizás un juego..." + CR) print(" Pues bien, estaba yo durmiendo plácidamente, cuando he entrado en uno de estos sueños ") print("que se vuelven controlables, sueños en los que estoy semiconsciente y puedo controlar a mi ") print("voluntad el curso del sueño, o por lo menos si soy yo el protagonista. Yo soy muy propicio a estos ") print("tipos de sueños, no digo que los tenga todos los días, quizás ni siquiera sean mensuales. Pero tengo ") print("presente que me han pasado a menudo y que puedo recordar siquiera un poco de que iban, ya que ") print("yo suelo olvidar rapidamente mis sueños (esa ha sido otra razón para levantarme y no escribir esto" ) print("a otras horas más decentes)." + CR) print(" En estos sueños, como ya he dicho yo soy el entero protagonista, y controlo mis acciones ") print("sin saber lo que va a pasar, aunque a veces incluso puedo controlar acontecimientos, o ") print("simplemente despertarme de una pesadilla y continuarla en estado de duermevela porque me ") print("interesaba el desarrollo de la historia; o todo lo contrario, de estando inmerso en un terrible ") print("sueño, cortar por lo sano y despertarme a caso hecho, o sea: yo en el sueño pienso que tengo ") print("que despertarme, hago un esfuerzo y lo consiguo." + CR) pause() ScreenCls(0) print(" Bueno pues yo estaba soñando que en Úbeda, cerca del Hospital de Santiago, había como ") print("unos zombies con la cara deformada, y era como un videojuego, no paraban de salir y yo no ") print("paraba de matarlos, pero se acumulaban demasiado y tenía que escapar y rodearles por otro lado ") print("(ultimamente juego demasiado al Duke Nukem 3d) para seguir la carnicería. Hasta que decido ") print("escapar por el 18 Julio abajo. Naturalmente, todo esto narrado con inmensas lagunas de sueño ") print("olvidado, pues al pasar a la segunda fase del sueño, se me iba olvidando el principio, de manera ") print("que siempre me acuerdo sobre todo del final. Además aunque el Hospital y la calle cuesta abajo ") print("del 18 Julio existen, en el sueño no se parecían mucho al real, aunque yo tenía consciencia de los ") print("lugares donde me hallaba. Bueno, pues yo iba cuesta abajo (de mayor pendiente que la real), con ") print("un paisaje muy amplio, de gran altura, y conforme ") print("bajaba se estaba formando y se divisaba más abajo una espesa niebla muy propicia para más ") print("zombies (o al menos eso pensaba yo en el sueño). La niebla ya era alcanzable con la mano, y quería ") print("cogerla, comprobar que estaba ahí, y al rato pensaba que podría nadar en ella de lo espesa que era. ") print("Así que de un salto y agitando los brazos me elevaba y me elevaba... Y aqui se produce el salto ") print("del sueño a la 'experiencia'. El sueño se desvanece y noto que me quiero dejar ir, abandonar y ") print("salir. Yo sé lo que me pasa, o lo intuyo (soy del todo consciente), me dejo llevar y no me ") print("resisto, y hoy me ha ocurrido lo que jamás me atreví a continuar tan lejos..." + CR) pause() ScreenCls(0) print(" La sensación, en un instante breve de tiempo normal (unos 3 segundos), es que veo por ") print("mis ojos, tumbado en la cama y me elevo, como si mis pies se descolgaran de mis pies, y hago un ") print("movimiento de ascenso, enganchado por un pelo con un pelo de mi cabeza, un movimiento con ") print("el eje de simetría en la cabeza y el punto de movimiento el los pies. Veo por mis ojos que me pongo boca ") print("abajo, suavemente pero en un instante (no lo puedo narrar bien, es inexplicable, como los horrores ") print("de Lovecraft), en un scroll la vista de mi ventana pasa ante mis ojos y lo veo todo al revés. Pero ") print("me asusto (como siempre me pasa), la sensación es muy fuerte y decido volver. Lo decido al igual ") print("que me despierto de esas pesadillas, bruscamente, como meneando la cabeza violentamente para ") print("zafarse de una vista borrosa, y borroso es el regreso. Poco a poco se me aclara todo, y continuo ") print("agazapado en la misma posición en la que he vuelto. Al principio flipado y alegre por ") print("la experiencia, ya que nunca la había sentido tan vívida, y nunca lo había hecho tanto tiempo. O ") print("sea que..." + CR) print(" Que esto ya me ha ocurrido muchísimas veces, pero nunca durante tanto tiempo, o con ") print("tanta consciencia de ello. No es que haya sido más tiempo que las otras veces, sino que ") print("ahora sabía lo que pasaba y antes no. Y pasaba 'el paseo' embobado hasta que me asustaba y ") print("regresaba de forma hasta dolorosa." + CR) print(" Tengo cierta reminiscencia que de pequeño tenía sueños sobre que yo me convertía en ") print("infinito, como un haz de luz viajando en el vacío durante un tiempo infinito, hasta que me ") print("'despertaba' y me cuesta recuperar el control de su cuerpo, con la ") print("boca abierta y babeando. Eran sueños hasta que hace poco, hará un ") print("año, que lo relacioné con todas estas experiencias 'raras' que tengo. Yo creo que son viajes astrales ") print("(cortos porque todavía no he viajado a lugares remotos), pero siempre me asusto ") print("y regreso, y entonces o a veces, me dan convulsiones...." + CR) pause() ScreenCls(0) print(" Todo comenzó una vez de pequeño, mi madre me dijo que ibamos al ") print("médico, que le iban a sacar sangre a ella. -¿Y yo tengo que ir? - preguntaba Alberto infeliz. No ") print("recuerdo al final para que leches era aquel análisis de sangre que me hicieron. El caso es que yo me ") print("sometía tranquilo a la enfermera y me hablaba con buenas palabras sobre la jeringa y la goma. ") print("­¡Pelleja! - le diría ahora. Me pincharon, y yo tan normal miraba por la ventana, y me vino un ") print("pensamineto de que: 'Yo voy a aprobar, y todos mis compañeros no, y yo pasaré de curso y ellos ") print("se quedarán atrás, Gonzalo, Ricardo, Carlos, y ya no los veré más...'. Me acuerdo perfectamente. Lo pensaba ") print("repetitívamente, hasta que me vino la 'caida de las estrellas' que ya he narrado antes. Cuando ") print("desperté, estaba en el suelo, y oía todo, el vuelo de las moscas, los roces de zapatos y zapatillas de ") print("mi madre y la emfermera, aumentadas de volumen que me atronaban. Fui recuperándome poco a ") print("poco, y me dijo mi madre que me había desmayado y que en el suelo había tenido convulsiones ") print("fuertes (Y me seco las lágrimas de los ojos: ¡¡¡tengo los pelos de punta mientras escribo!!!). ") print("Recuerdo, que iba por el ambulatorio como un zombie, con los oidos atronados todavía, y me tenía que tumbar ") print("para no caerme. Me recuperé, y supongo que mi madre me compró un Mortadelo y Filemón ") print("(como cada vez que íbamos al médico), y yo feliz y contento." + CR) print(" Y pasaron los años, y desarrollé una fobia tremenda a las jeringas, y más si están pinchadas ") print("en brazos, y más si es el mío. Y aún les tengo pánico. Yo no lo sabía por entonces, ni siquiera me ") print("dan miedo, es un repelús, y un rechazo instintivo." + CR) pause() ScreenCls(0) print(" Una vez, el 'despertar' me costó mucho, y me asusté especialmente: simplemente, mis ") print("miembros no me respondían, y mi cabeza permanecía recostada de lado, la boca abierta y una ") print("baba caida. Poco a poco me recuperé. Siempre al despertar me daba esa sensación de NO ") print("CONTROL, y es muy desagradable." + CR) print(" Con el tiempo y en COU, tuve casos de esos pero ya no eran tan desmayos, eran más ") print("sueños y la sensación de que me iba a flotar por ahí, pero volvía y me daban las tormentas más o ") print("menos fuertes y poco a poco fui tomandole el interés al asunto, y soñaba y entonces decidía ") print("'viajar', etc etc, como esta misma noche me ha ocurrido." + CR) print(" Una vez me tumbé cansado en unos sillones, y decidí intentar hacerlo. La sensación de que ") print("me iba vino, pero un tremendo chispazo en mi interior me hizo despertar de un salto. A partir de ") print("ahí asocié los ataques con las salidas de paseo del alma, y desarrollé esta teoría:"+CR) print(" El alma intenta ") print("salir del cuerpo, soy consciente y la sensación es muy fuerte, siempre me he asustado o el cuerpo ") print("me ha recuperado. Es como al desprenderse del alma, el cuerpo se muriera, y al volver el alma, ") print("tiene que recuperar el control aletargado de la parte física con una descarga de energía a través de ") print("todos los nervios del cuerpo. Todo el mundo sabe que pensamos y nos movemos por impulsos del ") print("cerebro, pues imaginaos que ese impulso fueran unos cuantos voltios... Yo creo que es una ") print("defensa de mi cerebro contra una 'muerte' del cuerpo si el alma se va." + CR) pause() ScreenCls(0) print(" Hay que tener en cuenta que cada vez que me pasaba algo por el estilo, me paraba a ") print("reflexionar, y son muchos años ya de meditación y experiencia. Pero le tengo miedo: ¿y si la ") print("reactivación del cuerpo no funcionase y la pelase de verdad?, ¿y si mi alma se quedase vagando ") print("por el limbo, y mi cuerpo en coma?. La curiosidad me dice una y otra vez que lo intente, que lo ") print("haga, pero ¡no quiero morir tan joven!. Después de esta noche no creo que lo intente por mi sólo, ") print("por mi propia voluntad como cuando el 'chispazo' que me despertó. Pero si me viene en un sueño ") print("como me ha pasado esta noche, lo haría, y quizás llege un poco más lejos, y me contemple a mi ") print("mismo en la cama desde lo alto del techo, y quizás suba a ver como es la vecina del sexto, o ") print("viajaría a Ubeda." + CR) print(" He oido hablar por ahí de drogas naturales que potencian la mente y propician los viajes ") print("astrales, como 'la soga del ahorcado', una liana de las selvas de porahíyquiensabedonde. También ") print("he leido casos de gente normal y chavales con experiencias parecidas a la mía. Pero todos ") print("coincidimos en esto: la sensación es casi un éxtasis, la sensación de ingravidez. ¿Alguien pasa ") print("lianas de esas a precio de 'costo'?." + CR) print(" Todo esto contado es verídico, no es ningún cuento (yo no tengo estilo para escribir). ") print("Ahora bien, si lees esto, o te lo crees o no te lo crees, eso es cosa tuya. Mientras tanto, yo seguiré ") print("probando, y si algún día sientes mi presencia, aún separados por kilometros físicos, acuérdate de ") print("mi y deséame suerte. Son las 7:31 de la mañana..." + CR) pause() ScreenCls(0) ScreenAt(0,240,170) print("buenas noches a todos."+CR) Pause(700) Abandonar() CASE * Abandonar() EndSelect If hay_sonido Then UnloadWav(sonido) EndIf Exit // FIN DEL JUEGO return