General Instructions

=begin

================================================================================
---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.
  * SCRIPT CREADO POR NEWOLD, FEBRERO-MARZO 2011, VERSIÓN 1.0
  * BASADO EN EL JUEGO ORIGINAL CREADO POR SQUARESOFT: TRIPLE TRIAD.
  * Se ha elegido a Naruto para la colección de cartas incluidas. (125 cartas)
  * USO NO COMERCIAL
---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·---·
================================================================================


                        INSTRUCCIONES GENERALES

    * Índice:
      -------------------------------------------------------------------------
      CÓMO ASIGNAR CARTAS AL MAZO DEL JUGADOR ....................... Línea 25
      CÓMO ASIGNAR CARTAS AL MAZO DE UN ENEMIGO ..................... Línea 71
      CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN ENEMIGO ............... Línea 98
      CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN MAPA ESPECÍFICO ....... Línea 219
      CÓMO EMPEZAR A JUGAR AL JUEGO DE CARTAS ....................... Línea 264
      OTROS NUEVOS COMANDOS ÚTILES .................................. Línea 351
      CÓMO AÑADIR MÁS ELEMENTALES ................................... línea 504
      CÓMO TRANSLADAR EL SCRIPT DE TRIPLE TRIAD A TUS PROYECTOS ..... Línea 523
      -------------------------------------------------------------------------


********************************************************************************
                  CÓMO ASIGNAR CARTAS AL MAZO DEL JUGADOR
********************************************************************************

  Tienes 2 métodos disponibles para hacerlo:

  - Método 1: En un evento pon un comando de llamar script y pon dentro esto:

      getcard(id1.id2.id3,id4,idn)

    Este método añadirá todas las cartas dadas al mazo de cartas del jugador

  - Método 2: En un evento pon un comando de llamar script y pon dentro esto:

      getcardrandom(N,id1.id2.id3,id4,idn)

    Este método añadirá un número N de cartas elegidas al azar entre la lista
    de cartas dada

  id1, id2... idn Son las ids de las cartas (Para saber que ID basta con irse
  al sript módule CARDS, buscar la carta que se quiera, y su ID será el número
  dentro de los corchetes ( [] ) después de Cards -> Cards[ID]).
  Deben estar separadas por comas (,)
  En el método 2, N es el número de cartas que se le va a asignar al jugador
  Si no te caben todas las ids en una línea puedes poner varias líneas de ids
  pero debes asegurarte de terminar cada línea con una coma (,) por ejemplo:

    getcard(0,0,0,5,5,1,1,1,1,
    1,6,7,8,9,10,11,
    12,13,14)

  Las IDs que correspondan a cartas únicas solo serán añadidas una vez. Si
  se le intenta dar una carta única al jugador que ya está añadida a algún
  mazo de cartas enemigo, Ésta no será añadida (para conseguir esa carta
  el jugador tendría que jugar contra quien la tuviera y ganársela en
  una partida)
  Si se usa el método getcardrandom, asegúrate que una de las ids por lo menos
  sea una id de una carta normal (Si se usara solo ids de cartas únicas y éstas
  ya estuvieran añadidas a algún mazo enemigo o al mazo del jugador,
  provocarías un desbordamiento en el script que causaría un error
  fatal y cerraría el juego)



********************************************************************************
                  CÓMO ASIGNAR CARTAS AL MAZO DE UN ENEMIGO
********************************************************************************

  Para asignar cartas al mazo de un enemigo tienes el siguiente método:

    - Método 1: En un evento pon un comando de llamar script y pon dentro esto:

        buildeck(id1,id2,id3,id4,idn)

    Este método Comprueba si el mazo de cartas enemigo existe. Si existe,
    comprueba que éste tenga al menos 10 cartas y en caso de que tenga menos,
    se le añadirán cartas aleatorias entre las dadas hasta que el mazo de cartas
    tenga 10 cartas. Si por el contrario no existe dicho mazo de cartas, lo crea
    asignandole las cartas dadas

  id1, id2... idn Son las ids de las cartas ((Para saber que ID basta con irse
  al sript módule CARDS, buscar la carta que se quiera, y su ID será el número
  dentro de los corchetes ( [] ) después de Cards). Deben estar separadas por (,)

  Asegúrate que una de las ids por lo menos
  sea una id de una carta normal (Si se usara solo ids de cartas únicas y éstas
  ya estuvieran añadidas a algún mazo enemigo o al mazo del jugador,
  provocarías un desbordamiento en el script que causaría un error
  fatal y cerraría el juego)


********************************************************************************
              CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN ENEMIGO
********************************************************************************

  Para asignar un conjunto de reglas a un enemigo tienes el siguiente método:

    - Método 1: En un evento:

    pon un comando de llamar script y copia dentro esto:

@levelenemy = A
@comboenemy = B
@igualenemy = C
@sumaenemy = D
@paredenemy = E
@elementalenemy = F
@abiertoenemy = G
@randomenemy = H
@hastalamuerteenemy = I
@pagoenemy = J
@usepluswall = K
@usecombowithwall = L

    pon otro comando de llamar script debajo del primero y copia esto

@checkallcardsenemy = M
forcecards = [N]

addenemyrule(@levelenemy,@comboenemy,
@igualenemy,@sumaenemy,@paredenemy,
@elementalenemy,@abiertoenemy,@randomenemy,
@hastalamuerteenemy,@pagoenemy,
@usepluswallenemy,@usecombowithwallenemy,
@checkallcardsenemy,forcecards)

    Y ahora sustituye las letras por valores correctos:

    A) Nivel del enemigo. Un número de 1 a 10 (más es mejor)
    B) Regla Combo. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Combo por defecto
    C) Regla igual. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Igual por defecto
    D) Regla Suma. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Suma por defecto
    E) Regla Pared. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Pared por defecto
    F) Regla Elemental. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Elemental por defecto
    G) Regla Abierto. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Abierto por defecto
    H) Regla Random. Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla Random por defecto
    I) Regla Hasta La Muerte. Puede ser:
        - true    =>  Activar regla
        - false   =>  Desactivar regla
        - nil     =>  Aleatorio entre true y false
        - -1      =>  Toma el valor que tiene la Regla Hasta La Muerte por defecto
    J) Regla de pago. Puede ser:
        - 0     =>  Una
        - 1     =>  Directo
        - 2     =>  Diferencia
        - 3     =>  Todas
        - 4     =>  Ninguna
        - nil     =>  Aleatorio entre las 5 tipos de reglas de pago
        - -1      =>  Toma el valor que tiene la Regla de Pago por defecto
    K) Regla usepluswall. (Regla no disponible en el Juego Original) Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla usepluswall por defecto
    L) Regla usecombowithwall. (Regla no disponible en el Juego Original) Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla usecombowithwall por defecto
    M) Regla checkallcards. (Regla no disponible en el Juego Original) Puede ser:
        - true    =>    Activar regla
        - false   =>    Desactivar regla
        - nil     =>    Aleatorio entre true y false
        - -1      =>    Toma el valor que tiene la Regla checkallcards por defecto
    N) N = conjunto de IDS de cartas que el enemigo chequeará al final del combate.
        ID1,ID2,ID3,ID4, ...
        (Cada id va separada por coma ',' Ejemplo:
        Cartas con id 1, 2, 3 y 4, tendrías que ponerlo así:
        forcecards = [1,2,3,4] )
       Al acabar la batalla, si el vencedor es el enemigo y tiene este parámetro
       definido, comprobará si el jugador a utilizado alguna de las cartas
       definidas en N, y en caso afirmativo se la quedará. Si el jugador no ha
       usado ninguna de esas cartas el enemigo eligirá al azar entre las cartas
       seleccionadas por el jugador.
       Si no quieres definir este parámetro puedes hacerlo de estas dos formas:
       forcecards = nil
       ó
       forcecards = []


  LAS REGLAS AÑADIDAS PARA ENEMIGOS ESPECÍFICOS SE ANTEPONEN A LAS REGLAS
  ESPECÍFICAS PARA CADA MAPA Y A LAS REGLAS POR DEFECTO


********************************************************************************
          CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN MAPA ESPECÍFICO
********************************************************************************

  Para asignar un conjunto de reglas a un enemigo tienes el siguiente método:

    - Método 1: En un evento:

    pon un comando de llamar script y copia dentro esto:

@levelenemy = A
@comboenemy = B
@igualenemy = C
@sumaenemy = D
@paredenemy = E
@elementalenemy = F
@abiertoenemy = G
@randomenemy = H
@hastalamuerteenemy = I
@pagoenemy = J
@usepluswallenemy = K
@usecombowithwallenemy = L

    pon otro comando de llamar script debajo del primero y copia esto

@checkallcardsenemy = M

addmaprule(@levelenemy,@comboenemy,
@igualenemy,@sumaenemy,@paredenemy,
@elementalenemy,@abiertoenemy,@randomenemy,
@hastalamuerteenemy,@pagoenemy,
@usepluswall,@usecombowithwall,
@checkallcardsenemy)

    Y ahora sustituye las letras por valores correctos (Ver el apartado
    "CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN ENEMIGO" para saber que valores
    pueden tomar cada una de las letras)
    El nivel enemigo definido para un mapa será el nivel que tendrán todos
    (los enemigos en ese mapa a menos que tengan sus propias reglas definidas)


  LAS REGLAS AÑADIDAS PARA MAPAS ESPECÍFICOS SE ANTEPONEN A LAS
  REGLAS DEFINIDAS POR DEFECTO


********************************************************************************
                  CÓMO EMPEZAR A JUGAR AL JUEGO DE CARTAS
********************************************************************************

    Sigue este pequeño tutorial para crear un NPC con el que poder
    echar una buena partida de cartas (Esta sería la mejor forma):

    1) Crea el evento
    2) Añades todo lo que quiera que pase al interactuar con ese evento
       y le añades las páginas que quieras
    3) Le creas otra página
    4) Le pones como condición de inicio el Interruptor Local B
    5) Cambia el gráfico de esa página al que debería tener.
    6) Vamos a empezar a añadir comandos a esa página:

      1º Comando: Añadimos un comentario y escribimos dentro esto:

          cardgame

         (escribe 'cardgame' tal cual, sin espacios ni comillas ni nada)

         Esto es necesario para no dejar inutilizado el interruptor local
         'B', y que este pueda ser usado en eventos que no sean para jugar al
         triple triad.

      2º Comando: Operación de Interruptor Local, B, Desactivar.

      3º Comando: Comando llamar script. Dentro poner el comando para asignarle
        un mazo de cartas (Ver el apartado "CÓMO ASIGNAR CARTAS AL MAZO
        DE UN ENEMIGO" de esta ayuda)

      # ------------------------------------------------------------------------
        COMANDOS OPCIONALES
      # ------------------------------------------------------------------------

      4º Comando: Aquí podemos poner una animación de sorpresa sobre el evento

      5º Comando: Aquí podemos mostrar un mensaje que diga "vamos a echar
        una partida" o algo similar.

      6º Comando Aquí podemos definir unas reglas específicas para el juego
        de este personaje (y para asignarle un nivel de dificultad del 1 al 10)
        Para ello, sigue las instrucciones del apartado
        "CÓMO ASIGNAR UN CONJUNTO DE REGLAS A UN ENEMIGO"

      # ------------------------------------------------------------------------

      7º Comando: Condiciones y Efectos, 4ª pestaña y seleccionamos script
        y pegamos dentro esto:

            checkplayercards >= 5

        marcamos añadir excepción y aceptamos. En la excepción podemos poner
        un mensaje diciéndole al jugador  que no tiene suficientes cartas
        para poder echar una partida contra él. Dentro de la condición ponemos
        un comando de llamar script y pegamos dentro esto:

            playgamecard



    Ya estaría listo el NPC para poder jugar contra el.
    Para poder jugar contra los NPC que hayas creado con este método debes
    acercarte a ellos y hablarles con el botón A (tecla Z por defecto). Esto
    simula la forma que había en FFVIII para poder jugar contra los NPC.

    PARA PODER JUGAR DIRECTAMENTE CONTRA UN NPC HABLÁNDOLE CON EL BOTÓN DE
    ACCIÓN NORMAL (BOTÓN C) TAN SOLO SIGUE LOS PASOS ANTERIORES PERO USA
    ESOS COMANDOS EN LA PÁGINA QUE SE ACTIVA CUANDO INTERACTUAS CON EL NPC
    (PERSONALMENTE ME GUSTA MÁS EL PRIMER MÉTODO QUE ÉSTE)

    Nota: Puedes hacer que suene una música determinada si en vez de poner
          playgamecard   pones   playgamecard('Ruta del tema musical')

    Nota final: Puedes crear varias páginas con los comandos para jugar al
    juego de cartas. Para ello, crea las páginas al final siempre, y vas
    jugando con las diferentes condiciones de inicio de página para que se
    active cada página.
    El único requisito es que cada página tenga como condición de inicio
    el interruptor local 'B' y un comentario con la palabra 'cardgame' escrita
    dentro, sin comillas ni espacios ni nada ,solo la palabra cardgame.
    (Con esto por ejemplo puedes definir 3 niveles de
    dificultad para un mismo evento, dependiendo de si tal o cual interruptor
    está activo, o 3 conjuntos de reglas diferentes, o 4 ... o las que quieras)


********************************************************************************
                        OTROS NUEVOS COMANDOS ÚTILES
********************************************************************************

    En un evento puedes usar el comando llamar script y usar las siguientes
    funciones:


    *  cardsmenu

    LLama al menú de cartas

    -------------------------------------------------------------------------

    *  checkcardplayer(ID)

    Comprueba si el jugador tiene una carta específica (id de la carta = ID)
    Devuelve 'true' en caso afirmativo y 'false' en caso negativo

    -------------------------------------------------------------------------

    *  checkcardenemy(ID)

    Comprueba si el NPC con el que se está hablando tiene una carta específica
    (id de la carta = ID)
    Devuelve 'true' en caso afirmativo y 'false' en caso negativo

    -------------------------------------------------------------------------

    *  checkplayercards

    Devuelve el Total de cartas poseidas por el jugador.

    -------------------------------------------------------------------------

    *  cards_enemy?(enemyid)

    Devuelve la cantidad de cartas totales del enemigo cuya id = enemyid

    -------------------------------------------------------------------------

    *  checkplayercollection

    Devuelve el Porcentaje completado de la colección de cartas

    -------------------------------------------------------------------------

    *  playercollectionperc_tovar(ID)

    Le da a la variable especificada (ID) el valor del porcentaje completado
    de la colección de cartas formateado con 2 decimales

    -------------------------------------------------------------------------

    *  deletecardplayer(id1,id2,id3,...,idn)

    Borra las cartas con las ids dadas del mazo del jugador
    En caso de tener varias cartas de ese tipo, la carta borrada será
    elegida aleatoriamente entre las mismas.
    Devuelve '1' en caso de haber borrado alguna carta del mazo de cartas
    del jugador y '-1' en caso de no haber podido borrar ninguna

    -------------------------------------------------------------------------

    *  deletecardenemy(id1,id2,id3,...,idn)

    Borra las cartas con las ids dadas del mazo del NPC con el que
    se está hablando. En caso de tener varias cartas de ese tipo, la carta
    borrada será elegida aleatoriamente entre las mismas.
    Devuelve '1' en caso de haber borrado alguna carta del mazo de cartas
    del NPC y '-1' en caso de no haber podido borrar ninguna

    -------------------------------------------------------------------------

    *  deletecardenemy_byid(enemyid,id1,id2,id3,...,idn)

    Borra las cartas con las ids dadas del mazo del NPC en el mapa con
    la id dada (enemyid). En caso de tener varias cartas de ese tipo, la carta
    borrada será elegida aleatoriamente entre las mismas.
    Devuelve '1' en caso de haber borrado alguna carta del mazo de cartas
    del NPC y '-1' en caso de no haber podido borrar ninguna

    -------------------------------------------------------------------------

    *  findanddeletecard(id)

    Esta función Busca entre todos los mazos de cartas de los NPC por una
    carta con la id dada y la borra cuando la encuentra.
    Esta función solo se aplica cuando la carta es única.
    Devuelve '1' cuando ha encontrado y borrado la carta y '-1' cuando la
    carta que se intentaba buscar no era única o no la ha encontrado.

    -------------------------------------------------------------------------

    *  findcard(id)

    Esta función Busca entre todos los mazos de cartas de los NPC por una
    carta con la id dada.
    Devuelve 'true' cuando ha encontrado la carta y 'false' cuando no la encontró

    -------------------------------------------------------------------------

    *  check_stats_enemy(id1,id2,id3,id4,id5)

    Devuelve las estadísticas del enemigo con el que se está hablando
    Le da a las variables especificadas (id1,id2,id3,id4,id5) estos valores:
    # Variable 1 (id1) => Número de juegos completados
    # Variable 2 (id2) => Número de juegos Ganados
    # Variable 3 (id3) => Número de juegos Perdidos
    # Variable 4 (id4) => Porcentaje de juegos ganados
    # Variable 4 (id5) => Porcentaje de juegos perdidos

    -------------------------------------------------------------------------

    *  check_stats_player(id1,id2,id3,id4,id5)

    Devuelve las estadísticas del jugador
    Le da a las variables especificadas (id1,id2,id3,id4,id5) estos valores:
    # Variable 1 (id1) => Número de juegos completados
    # Variable 2 (id2) => Número de juegos Ganados
    # Variable 3 (id3) => Número de juegos Perdidos
    # Variable 4 (id4) => Porcentaje de juegos ganados
    # Variable 4 (id5) => Porcentaje de juegos perdidos

    -------------------------------------------------------------------------

    NOTA: Las funciónes que devuelven valores pueden ser usadas con el comando
    'Condiciones y Efectos'
    (4ª pestalla, seleccionar script, y escribir la condición - Ver Ejemplos)

    Ejemplos:

    *   findcard(4) == true

    Esta igualdad se cumple si la función findcard encuentra la carta con ID 4
    en algún mazo de cartas de algún NPC

    * checkplayercards > 5

    Esta condición se cumple si la función checkplayercards devuelve un número
    mayor a 5 (Ese número se correspondería con el total de cartas del jugador)

    * checkcardenemy(12) == true

    Esta condición se cumple si la carta con ID 12 está en posesión del
    NPC con el que se está hablando

    * checkcardplayer(12) == false

    Esta condición se cumple si la carta con ID 12 NO está
    en posesión del Jugador


********************************************************************************
                   CÓMO AÑADIR MÁS ELEMENTALES
********************************************************************************

  Para añadir más elementales vete al final del script 'Scripts Complementarios'
  y busca $deck['elementallist'] = {. Ahí debajo verás los elementales que
  están ya definidos. Para añadir más, te vas debajo del último que haya añadido
  y pones esto:

      Elemental ID => ["Ruta de la imagen","Nombre del elemento"],

    * Elemental ID: Es la ID que tendrá el elemento.
    * "Ruta de la imagen": Ubicación del archivo de imagen del elemento
    * "Nombre del elemento": Pues eso, nombre del elemento


    NOTA: No olvides añadir la coma ',' al final de cada elemento creado


********************************************************************************
          CÓMO TRANSLADAR EL SCRIPT DE TRIPLE TRIAD A TUS PROYECTOS
********************************************************************************

  1) COPIA LOS SIGUIENTES SCRIPTS A TU PROYECTO:
      - INSTRUCCIONES GENERALES
      - module SAVE & LOAD BACKUP
      - module CARDS
      - module IA
      - module TUTORIAL
      - JUEGO - TRIPLE TRIAD
      - MENÚ DE CARTAS
      - Scripts Complementarios
  2) COPIA LA CARPETA "CardsGame" Y TODAS SUS SUBCARPETAS A LA CARPETA
     DE TU JUEGO
  3) CREA TUS PROPIAS CARTAS CON LAS PLANTILLAS Y TUTORIALES ADJUNTOS Y
     AÑÁDELAS EN EL SCRIPT "module CARDS" O USA LAS QUE YO HE HECHO ;)
     (YO HE USADO EL PHOTOSHOP CS5 PARA CREAR LAS CARTAS)
  4) LISTO. YA TIENES EL JUEGO TIPLE TRIAD AÑADIDO A TU PROYECTO. YA SOLO TE
     QUEDARÍA CREAR LOS NPC CON LOS QUE JUGAR (LAS INSTRUCCIONES ESTÁN EN EL
     APARTADO "CÓMO EMPEZAR A JUGAR AL JUEGO DE CARTAS" DE ESTAS INSTRUCCIONES)

=end