Complementary Script

=begin

  *** SCRIPT CREADO POR NEWOLD, FEBRERO-MARZO 2011, TRIPLE TRIAD 1.0 ***

=end


# =============================================================================
# *****************************************************************************
# =============================================================================
class Game_Interpreter
  # ---------------------------------------------------------------------------
  def getcard(*ids)
    # Función para asignar cartas al mazo del jugador y de los enemigos
    # -------------------------------------------------------------------------
    # Debug_mode: En modo debug a todas las cartas se le otorgan estos valores
    # de ataque: Ataques Arriba e Izquierdo 8 | Ataques Abajo y Derecho = 10
    # (Útil para comprobar las reglas y combos de forma rápida)
    # No olvidar desactivar esta variable para salir del modo debug
    debug_mode = true
    # -------------------------------------------------------------------------
    min_atk = 1  # Ataque mínimo que tendrán las cartas
    max_atk = 10 # Ataque Máximo que tendrán las cartas
    cards_add = false # flaq para indicar si la operación de añadir cartas
                      # se ha podido efectuar con éxito
    # *************************************************************************
    # Loop para recorrer todos los parámetros pasados
    # *************************************************************************
    ids.each do |id|
      # Conseguir la carta
      card = Newold::CARDS::Cards[id]
      # Valor que indica si la carta es una carta única
      cartaunica = card[4]
      # Si la carta es única se comprueba que no haya sido ya añadida a algún
      # mazo de cartas enemigo o al del jugador y en caso de que ya esté
      # añadida se descartará esta carta
      if cartaunica == 1
        if $deck['uniquecards'].include?(id)
          if ids.size == 1
            return false
          else
            next
          end
        end
      end
      next if card == nil
      # Creando una id única para la carta
      if $deck['uniqueid'][id] != nil
        $deck['uniqueid'][id] += 1
      else
        $deck['uniqueid'][id] = 0
      end
      size = $deck['uniqueid'][id]
      uniqid = "#{id}_#{size}"
      # Nombre de la imagen de la carta
      cardimagename = card[0]
      # Posición de los valores de ataque
      posvalatk = card[5]
      # Nombre del personaje o técnica
      name = card[1]
      # Elemento de la carta
      element = card[2]
      # Propietario de la carta (Se usa para asignar el color a la carta en el
      # tablero de juego y puede ser 0 = Jugador y 1 = Enemigo)
      owner = (!@enemybuild ? 0 : 1)
      # Dueño original de la carta. Este valor se usa para decidir cuando una
      # carta formaba parte de la baraja del jugador pero fue robada por un
      # enemigo o viceversa (las cartas robadas por el enemigo tendrán
      # porcentajes de ser jugadas por éste en otra partida. Contra mejor sea
      # la carta más fácil será que la juegue)
      # (0 = Jugador y 1 = Enemigo))
      oldowner = (!@enemybuild ? 0 : 1)
      # Valores de ataque de la carta
      if card[4] == 0 # Carta de ataque variable
        mod = [-3,-2,-1,0,1,2,3] # variabilidad del ataque
        v = rand(mod.size)
        atk_arr = card[3][0] + mod[v] # Ataque Arriba
        v = rand(mod.size)
        atk_izq = card[3][1] + mod[v] # Ataque Izquierda
        v = rand(mod.size)
        atk_der = card[3][2] + mod[v] # Ataque Derecha
        v = rand(mod.size)
        atk_aba = card[3][3] + mod[v] # Ataque Abajo
      else # Carta de ataque fijo
        atk_arr = card[3][0]
        atk_izq = card[3][1]
        atk_der = card[3][2]
        atk_aba = card[3][3]
      end
      # Aplicar límites a los valores de ataque
      # -----------------------------------------------------
      # Limitando Ataque Arriba
      if atk_arr > max_atk then atk_arr = max_atk end
      if atk_arr < min_atk then atk_arr = min_atk end
      # Limitando Ataque Izquierda
      if atk_izq > max_atk then atk_izq = max_atk end
      if atk_izq < min_atk then atk_izq = min_atk end
      # Limitando Ataque Derecha
      if atk_der > max_atk then atk_der = max_atk end
      if atk_der < min_atk then atk_der = min_atk end
      # Limitando Ataque Abajo
      if atk_aba > max_atk then atk_aba = max_atk end
      if atk_aba < min_atk then atk_aba = min_atk end
      # -----------------------------------------------------
      # Categoria de la carta
      categoria = card[6]
      # -----------------------------------------------------
      # Construyendo la nueva carta
      if debug_mode
        atk_der = atk_aba = 10
        atk_arr = atk_izq = 8
      end
      newcard = [uniqid,name,element,[atk_arr,atk_izq,atk_der,atk_aba],
      cartaunica,owner,oldowner,cardimagename,posvalatk,categoria]
      # Asignando la carta al deck (mazo de cartas) para que pueda ser usada.
      # (En caso de que la carta sea única, solo será añadida una vez)
      if !@enemybuild
        # Mazo del jugador
        if $deck['player'][id] != nil
          $deck['player'][id].push(newcard)
        else
          $deck['player'][id] = []
          $deck['player'][id].push(newcard)
        end
      else
        # Mazo del enemigo
        if @especificid != nil
          enemyid = "#{@especificid}_#{@map_id}"
        else
          enemyid = "#{@event_id}_#{@map_id}"
        end
        if $deck['enemy'][enemyid] == nil
          $deck['enemy'][enemyid] = []
        end
        if $deck['enemy'][enemyid][id] != nil
          $deck['enemy'][enemyid][id].push(newcard)
        else
          $deck['enemy'][enemyid][id] = []
          $deck['enemy'][enemyid][id].push(newcard)
        end
      end
      if cartaunica == 1
        $deck['uniquecards'].push(id)
      end
      cards_add = true
    end
    # *************************************************************************
    if cards_add
      return 1
    else
      return -1
    end
    # -------------------------------------------------------------------------
  end
  # ---------------------------------------------------------------------------
  def getcardrandom(n,*ids)
    # Asigna un número 'n' de cartas al jugador de entre las 'ids' dadas
    cards = []
    s = 0
    while n > 0
      r = getcard(ids[rand(ids.size)])
      while r == -1
        r = getcard(ids[rand(ids.size)])
      end
      n -= 1
    end
  end
  # ---------------------------------------------------------------------------
  def buildeck(*ids)
    # Funcion para asignar cartas al NPC con el que se está hablando
    @enemybuild = true
    enemyid = "#{@event_id}_#{@map_id}"
    if $deck['enemy'][enemyid] != nil
      while cards_enemy?(enemyid) < 10
        getcard(ids[rand(ids.size)]) # Aleatorio
      end
      @enemybuild = nil
      return -1
    end
    cards = []
    for i in 0...ids.size
      #getcard(ids[rand(ids.size)]) # Aleatorio
      getcard(ids[i])
    end
    @enemybuild = nil
  end
  # ---------------------------------------------------------------------------
  def buildeck_byid(id,*ids)
    # Funcion para asignar cartas al NPC en el mapa actual con id igual a id dada
    @enemybuild = true
    @especificid = id
    enemyid = "#{id}_#{@map_id}"
    if $deck['enemy'][enemyid] != nil
      while cards_enemy?(enemyid) < 10
        getcard(ids[rand(ids.size)]) # Aleatorio
      end
      @enemybuild = nil
      @especificid = nil
      return -1
    end
    for i in 0...ids.size
      getcard(ids[i])
    end
    @enemybuild = nil
    @especificid = nil
  end
  # ---------------------------------------------------------------------------
  def forze_addcard_toenemy(id,*ids)
    # Añade 1 o más cartas al deck del NPC cuya id es igual a la id dada
    enemyid = "#{id}_#{@map_id}"
    @enemybuild = true
    @especificid = id
    for i in 0...ids.size
      getcard(ids[i])
    end
    @enemybuild = nil
    @especificid = nil
  end
  # ---------------------------------------------------------------------------
  def playgamecard(music=nil)
    # Ejecuta el juego triple Triad
    $scene = TripleTriad.new("#{@event_id}_#{@map_id}",@map_id,false,music)
  end
  # ---------------------------------------------------------------------------
  def play_tutorial
    # Ejecuta el juego Triple Triad en modo Tutorial
    $scene = TripleTriad.new(nil,nil,true)
  end
  # ---------------------------------------------------------------------------
  def addenemyrule(level = 5,combo=-1,igual=-1,suma=-1,pared=-1,
    elemental=-1,abierto=-1,random=-1,hastalamuerte=-1,pago=0,
    usepluswall=-1,usecombowithwall=-1,checkallcards=-1,forzegetcard=nil)
    # Añade un conjunto de reglas al NPC con el que se está hablando
      id = "#{@event_id}_#{@map_id}"
      $deck['emenyIA'][id] = [level,combo,igual,suma,pared,elemental,
                             abierto,random,hastalamuerte,pago,
                             usepluswall,usecombowithwall,checkallcards,
                             forzegetcard]
  end
  # ---------------------------------------------------------------------------
  def addmaprule(level = 5,combo=nil,igual=nil,suma=nil,pared=nil,
    elemental=nil,abierto=nil,random=nil,hastalamuerte=nil,pago=0,
    usepluswall=-1,usecombowithwall=-1,checkallcards=-1)
    # Añade un conjunto de reglas específicas al mapa en curso
      id = @map_id
      $deck['maprule'][id] = [level,combo,igual,suma,pared,elemental,
                             abierto,random,hastalamuerte,pago,
                             usepluswall,usecombowithwall,checkallcards]
  end
  # ---------------------------------------------------------------------------
  def cardsmenu
    # LLama al menú de cartas
    $scene = CardsMenu.new
    #menu.main
  end
  # ---------------------------------------------------------------------------
  def checkcardplayer(id)
    # Comprueba si el jugador tiene una carta específica
    # Devuelve 'true' en caso afirmativo y 'false' en caso negativo
    return ($deck['player'][id] != nil and $deck['player'][id] != [])
  end
  # ---------------------------------------------------------------------------
  def checkcardenemy(id)
    # Comprueba si el NPC con el que se está hablando tiene una carta específica
    # Devuelve 'true' en caso afirmativo y 'false' en caso negativo
    enemyid = "#{@event_id}_#{@map_id}"
    return ($deck['enemy'][enemyid][id] != nil and
            $deck['enemy'][enemyid][id] != [])
  end
  # ---------------------------------------------------------------------------
  def checkplayercards
    # Devuelve el Total de cartas poseidas por el jugador
    totalcards = 0
    $deck['player'].each do |cards|
      if cards != nil and cards != []
        cards.each do |card|
          totalcards += 1
        end
      end
    end
    return totalcards
  end
  # ---------------------------------------------------------------------------
  def cards_enemy?(enemyid)
    # Devuelve la cantidad de cartas totales del enemigo cuya id = enemyid
    return 0 if $deck['enemy'][enemyid] == nil
    totalcards = 0
    $deck['enemy'][enemyid].each do |cards|
      if cards != nil and cards != []
        cards.each do |card|
          totalcards += 1
        end
      end
    end
    return totalcards
  end
  # ---------------------------------------------------------------------------
  def checkplayercollection
    # Devuelve el Porcentaje completado de la colección de cartas
    total_cards = Newold::CARDS::Cards.size
    player_cards = 0.0
    for i in 0...$deck['player'].size
      next if $deck['player'][i] == nil or $deck['player'][i] == []
      player_cards += 1
    end
    return (player_cards / total_cards) * 100
  end
  # ---------------------------------------------------------------------------
  def 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
    n = checkplayercollection
    n = sprintf('%.2f', n)
    $game_variables[id] = n.to_f
  end
  # ---------------------------------------------------------------------------
  def check_stats_enemy(id1,id2,id3,id4,id5,id6,id7)
    # 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) => Número de juegos Empatados
    # Variable 5 (id5) => Porcentaje de juegos ganados
    # Variable 6 (id6) => Porcentaje de juegos perdidos
    # Variable 7 (id7) => Porcentaje de juegos empatados
    enemyid = "#{@event_id}_#{@map_id}"
    if $deck['stats'][enemyid] != nil
      $game_variables[id1] = $deck['stats'][enemyid]['games']
      $game_variables[id2] = $deck['stats'][enemyid]['wingames']
      $game_variables[id3] = $deck['stats'][enemyid]['lostgames']
      $game_variables[id4] = $deck['stats'][enemyid]['drawgames']
      sum = $game_variables[id2] + $game_variables[id3] +
            $game_variables[id4] + 0.0
      if sum != 0.0
        n1 = sprintf('%.2f', ($game_variables[id2] / sum))
        n2 = sprintf('%.2f', ($game_variables[id3] / sum))
        n3 = sprintf('%.2f', ($game_variables[id4] / sum))
        $game_variables[id5] = (n1.to_f * 100).to_i
        $game_variables[id6] = (n2.to_f * 100).to_i
        $game_variables[id7] = (n3.to_f * 100).to_i
      else
        $game_variables[id5] = 0
        $game_variables[id6] = 0
        $game_variables[id7] = 0
      end
    else
      $game_variables[id1] = $game_variables[id2] = $game_variables[id3] =
      $game_variables[id4] = $game_variables[id5] = $game_variables[id6] =
      $game_variables[id7] = 0
    end
  end
  # ---------------------------------------------------------------------------
  def check_stats_player(id1,id2,id3,id4,id5,id6,id7)
    # 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) => Número de juegos Empatados
    # Variable 5 (id5) => Porcentaje de juegos ganados
    # Variable 6 (id6) => Porcentaje de juegos perdidos
    # Variable 7 (id7) => Porcentaje de juegos empatados
    $game_variables[id1] = $deck['stats']['player']['games']
    $game_variables[id2] = $deck['stats']['player']['wingames']
    $game_variables[id3] = $deck['stats']['player']['lostgames']
    $game_variables[id4] = $deck['stats']['player']['drawgames']
    sum = $game_variables[id2] + $game_variables[id3] +
          $game_variables[id4] + 0.0
      if sum != 0.0
        n1 = sprintf('%.2f', ($game_variables[id2] / sum))
        n2 = sprintf('%.2f', ($game_variables[id3] / sum))
        n3 = sprintf('%.2f', ($game_variables[id4] / sum))
        $game_variables[id5] = (n1.to_f * 100).to_i
        $game_variables[id6] = (n2.to_f * 100).to_i
        $game_variables[id7] = (n3.to_f * 100).to_i
      else
        $game_variables[id5] = 0
        $game_variables[id6] = 0
        $game_variables[id7] = 0
      end
  end
  # ---------------------------------------------------------------------------
  def deletecardplayer(*ids)
    # 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
    deleteitem = false
    for i in 0...ids.size
      id = ids[i]
      if $deck['player'][id] != nil and $deck['player'][id] != []
        cardid = rand($deck['player'][id].size)
        $deck['player'][id].delete_at(cardid)
        if $deck['uniquecards'].include?(id)
          $deck['uniquecards'].delete(id)
        end
        deleteitem = true
      end
    end
    if deleteitem
      return 1
    else
      return -1
    end
  end
  # ---------------------------------------------------------------------------
  def deletecardenemy(*ids)
    # 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
    enemyid = "#{@event_id}_#{@map_id}"
    return -1 if $deck['enemy'][enemyid] == nil
    deleteitem = false
    for i in 0...ids.size
      id = ids[i]
      if $deck['enemy'][enemyid][id] != nil and
        $deck['enemy'][enemyid][id] != []
        cardid = rand($deck['enemy'][enemyid][id].size)
        $deck['enemy'][enemyid][id].delete_at(cardid)
        if $deck['uniquecards'].include?(id)
          $deck['uniquecards'].delete(id)
        end
        deleteitem = true
      end
    end
    if deleteitem
      return 1
    else
      return -1
    end
  end
  # ---------------------------------------------------------------------------
  def deletecardenemy_byid(id,*ids)
    # Borra las cartas con las ids dadas del mazo del NPC en el mapa con
    # la id dada. 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
    enemyid = "#{id}_#{@map_id}"
    return -1 if $deck['enemy'][enemyid] == nil
    deleteitem = false
    for i in 0...ids.size
      id = ids[i]
      if $deck['enemy'][enemyid][id] != nil and
        $deck['enemy'][enemyid][id] != []
        cardid = rand($deck['enemy'][enemyid][id].size)
        $deck['enemy'][enemyid][id].delete_at(cardid)
        if $deck['uniquecards'].include?(id)
          $deck['uniquecards'].delete(id)
        end
        deleteitem = true
      end
    end
    if deleteitem
      return 1
    else
      return -1
    end
  end
  # ---------------------------------------------------------------------------
  def 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.
    return -1 if Newold::CARDS::Cards[id] == nil # Carta no definida
    return -1 if Newold::CARDS::Cards[id][4] != 1 # Carta definida pero no es única
    # Carta definida y única. Empieza el loop para buscarla entre los mazos de
    # los NPC definidos
    $deck['enemy'].each do |key,value|
      next if value[id] == nil or value[id] == []
      $deck['enemy'][key].delete_at(id)
      if $deck['uniquecards'].include?(id)
        $deck['uniquecards'].delete(id)
      end
      return 1 # Carta encontrada y borrada, Devuelve 1 y termina el loop
    end
    return -1 # No se ha encontrado la carta, Devuelve -1 y termina
  end
  # ---------------------------------------------------------------------------
  def 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ó
    return false if Newold::CARDS::Cards[id] == nil # Carta no definida
    # Carta definida.
    # Empieza el loop para buscarla entre los mazos de los NPC definidos
    $deck['enemy'].each do |key,value|
      next if value[id] == nil or value[id] == []
      return true # Carta encontrada, Devuelve true y termina
    end
    return false # No se ha encontrado la carta, Devuelve false y termina
  end
  # ---------------------------------------------------------------------------
end
# =============================================================================
# *****************************************************************************
# =============================================================================


# =============================================================================
# *****************************************************************************
# =============================================================================
class Array # Añadiendo un nuevo método a la clase Array (Creador: Newold)
  # Con esto se desordenada un Array aleatoriamente
  def rsort
    new_array = []
    while self.size > 0
      n = rand(self.size)
      new_array.push(self[n])
      self.delete_at(n)
    end
    return new_array
  end
end
# =============================================================================
# *****************************************************************************
# =============================================================================

# =============================================================================
# *****************************************************************************
# =============================================================================
class Scene_Map
  alias updatenewoldtripletriadgame update
  def update
    updatenewoldtripletriadgame
    if $game_map.interpreter.running?
      return
    end
    if Input.trigger?(Input::A)
      # Activar página para jugar a las cartas con el NPC seleccionado
      # pulsando el botón A
      case $game_player.direction
      when 8
        x,y = $game_player.x, $game_player.y - 1
      when 4
        x,y = $game_player.x - 1, $game_player.y
      when 6
        x,y = $game_player.x + 1, $game_player.y
      when 2
        x,y = $game_player.x, $game_player.y + 1
      end
      for ev in $game_map.events.values
        if ev.x == x and ev.y == y
          for page in ev.event.pages.reverse
          #page = ev.event.pages[ev.event.pages.size - 1]
            c = page.condition
            # Switch 1 condition confirmation
            if c.switch1_valid
              if $game_switches[c.switch1_id] == false
                next
              end
            end
            # Switch 2 condition confirmation
            if c.switch2_valid
              if $game_switches[c.switch2_id] == false
                next
              end
            end
            # Variable condition confirmation
            if c.variable_valid
              if $game_variables[c.variable_id] < c.variable_value
                next
              end
            end
            # Self switch condition confirmation
            if c.self_switch_valid
              switch = c.self_switch_ch
              if switch != 'B'
                next
              end
            end
            breakthis = true
            for item in page.list
              if item.code == 108
                if item.parameters.include?('cardgame')
                  breakthis = false
                  break
                end
              end
            end
            break if breakthis
            key = [$game_map.map_id, ev.id, "B"]
            $game_self_switches[key] = true
            $game_map.refresh
            ev.start
          end
          break
        end
      end
    end
  end
end
# =============================================================================
# *****************************************************************************
# =============================================================================


# =============================================================================
# *****************************************************************************
# =============================================================================
class Game_Event
  attr_reader     :event
end
# =============================================================================
# *****************************************************************************
# =============================================================================


# =============================================================================
# *****************************************************************************
# =============================================================================
class Scene_File < Scene_Base
  # ---------------------------------------------------------
  alias write_save_data_add_cards_by_newold write_save_data
  def write_save_data(file)
    write_save_data_add_cards_by_newold(file)
    Marshal.dump($deck, file)
  end
  # ---------------------------------------------------------
  alias read_save_data_add_cards_by_newold read_save_data
  def read_save_data(file)
    read_save_data_add_cards_by_newold(file)
    $deck = Marshal.load(file)
  end
  # ---------------------------------------------------------
end
# =============================================================================
# *****************************************************************************
# =============================================================================

# =============================================================================
# *****************************************************************************
# =============================================================================
class Scene_Title
  # ----------------------------------------------------------------------
  alias command_new_game_title_mod_for_triple_triad command_new_game
  def command_new_game
    $deck['player'] = []
    # El deck que controla las cartas de todos los enemigos
    $deck['enemy'] = {}
    # El deck que controla que cartas unicas han sido ya añadidas a alguna baraja.
    $deck['uniquecards'] = []
    # El deck que controla las ids únicas para las nuevas cartas creadas.
    $deck['uniqueid'] = []
    # Espacio reservado para guardar configuraciones de partidas para enemigos
    # específicos (Usar el comando addenemyrule con el comando llamar script)
    $deck['emenyIA'] = {}
    # Espacio reservado para guardar configuraciones de partidas para mapas
    # específicos (Usar el comando addmaprule con el comando llamar script)
    $deck['maprule'] = {}
    command_new_game_title_mod_for_triple_triad
  end
end
# =============================================================================
# *****************************************************************************
# =============================================================================


# =============================================================================
# *****************************************************************************
# =============================================================================
class TripleTriad
  # ----------------------------------------------------------------------
  alias backupsaveinmain main
  def main
    $deck['backupresolution'][0] = Graphics.width
    $deck['backupresolution'][1] = Graphics.height
    Graphics.resize_screen(640, 480)
    backupsaveinmain
    Graphics.resize_screen($deck['backupresolution'][0], $deck['backupresolution'][1])
  end
  # ----------------------------------------------------------------------
  alias deletebackupsaveindispose dispose
  def dispose
    deletebackupsaveindispose
  end
  # ----------------------------------------------------------------------
end
# =============================================================================
# *****************************************************************************
# =============================================================================


# =============================================================================
# *****************************************************************************
# =============================================================================
# ---------------------------------------------------------------------------
# VARIABLE GLOBAL QUE CONTIENE LOS MAZOS DE CARTAS Y CONFIGURACIONES VARIAS
$deck = {}
# Aquí se guadra la resolución actual de la pantalla antes de cambiar a la
# resolución del juego Triple Triad (640x480)
$deck['backupresolution'] = []
# Guarda las veces jugadas con un enemigo, veces ganadas, perdidas.
$deck['stats'] = {}
# Guarda las veces jugadas totales, ganadas totales, perdidas totales. (Jugador)
$deck['stats']['player'] = {'games'=>0,'wingames'=>0,'lostgames'=>0,'drawgames'=>0}
# El deck que controla las cartas del jugador
$deck['player'] = []
# El deck que controla las cartas de todos los enemigos
$deck['enemy'] = {}
# El deck que controla que cartas unicas han sido ya añadidas a alguna baraja.
$deck['uniquecards'] = []
# El deck que controla las ids únicas para las nuevas cartas creadas.
$deck['uniqueid'] = []
# Espacio reservado para guardar configuraciones de partidas para enemigos
# específicos (Usar el comando addenemyrule con el comando llamar script)
$deck['emenyIA'] = {}
# Espacio reservado para guardar configuraciones de partidas para mapas
# específicos (Usar el comando addmaprule con el comando llamar script)
$deck['maprule'] = {}
# Lista de elementales para usar con las cartas (ID + Nombre)
$deck['elementallist'] = {
      # Elemental ID => ["Ruta de la imagen","Nombre del elemento"],
      1 => ["CardsGame/icons/iconelemental1","Viento"],   # Viento
      2 => ["CardsGame/icons/iconelemental2","Fuego"],     # Fuego
      3 => ["CardsGame/icons/iconelemental3","Trueno"],    # Trueno
      4 => ["CardsGame/icons/iconelemental4","Tierra"],    # Tierra
      5 => ["CardsGame/icons/iconelemental5","Agua"],      # Agua
    }
# =============================================================================
# *****************************************************************************
# =============================================================================