Main Module

=begin

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

=end

class TripleTriad
  include Newold::CARDS # Incluye la lista de cartas definidas
  include Newold::IA # Incluye la IA que usará el enemigo
  include Newold::Tutorial # Incluye el tutorial
  # ---------------------------------------------------------------------------
  def initialize(enemy,mapid,tutorial = false,music=nil)
    @enemyid = enemy # Id del enemigo con el que te enfrentas
    @mapid = mapid # Id del mapa en el que te encuentras
    @tutorial = tutorial
    @forcemusic = music
    if $deck['stats'][@enemyid] == nil
      $deck['stats'][@enemyid] = {}
      $deck['stats'][@enemyid]['games'] = 0
      $deck['stats'][@enemyid]['wingames'] = 0
      $deck['stats'][@enemyid]['lostgames'] = 0
      $deck['stats'][@enemyid]['drawgames'] = 0
    end
    # *************************************************************************
    #    INICIO DEL APARTADO DE CONFIGURACIÓN
    # *************************************************************************
    # ------------------------------------------------------------------
    # Textos que se reproducen en el juego
    # ------------------------------------------------------------------
    @textos = [
      ["Reglas","Igual","Suma","Pared","Pared + Suma","Pared + Igual",
      "Combo","Elemental"],
      ["Modo de juego","Abierto","Hasta la Muerte"],
      ["Selección de cartas","Aleatorio","Manual"],
      ["Método de pago","Una","Directo","Diferencia","Todas","Ninguna"],
      ["Otras Frases","Has  Ganado","Tú Pierdes","Empezar Partida",
      "Abandonar", "Empate","¿Jugar con las cartas seleccionadas?","Sí","No",
      "Elige","carta","¿Quiéres esta/s carta/s?","Obtienes","Pierdes",
      "la","siguiente","carta","Fin de la partida...",
      "No has perdido ni ganado ninguna carta...","Página","de",
      "Usa las teclas de dirección para seleccionar las cartas",
      "Usa los botones L y R para cambiar de página",
      "El rival está pensando...","Carta única",
      "Ya tienes esta carta en tu colección","Falta esta carta en tu colección"]
    ]

    # ------------------------------------------------------------------
    # Consiguración referente a los sonidos
    # ------------------------------------------------------------------
    # Música que se reproduce durante el juego (Ubicación)
    # (La música se eligirá aleatoriamente de esta lista)
    @listsongs = [
      "CardsGame/music/Hero's Come Back",
      "CardsGame/music/Naruto Shippuden Ending 1 Full",
      "CardsGame/music/Original Triple Triad"
    ]
    # Sonido que se produce al mover una carta
    @soundmovecard = "CardsGame/sound/fx12"
    # Sonido que se produce depositar una carta en
    # el tablero
    @soundmovecardoverdeck = "CardsGame/sound/fx13"
    # Sonido que se produce al mover el cursor
    @soundcursor = "CardsGame/sound/cursor1"
    # Sonidos que se produce al mover el selector de
    # turnos
    @soundselectioninitialturnbegin = "CardsGame/sound/fx1"
    @soundselectioninitialturnend = "CardsGame/sound/fx3"
    # Sonido que se produce al cancelar
    @soundcancel = "CardsGame/sound/fx4"
    # Sonido que se produce al situar una carta en una casilla
    # elemental siendo ésta de distinto elemento al de la carta
    # (La carta se downgradea 1 punto en sus ataques (ATK - 1))
    @sounddowngradecard = "CardsGame/sound/fx5"
    # Sonido que se produce al situar una carta en una casilla
    # elemental siendo ésta del mismo elemento al de la carta
    # (La carta se upgradea 1 punto en sus ataques (ATK + 1))
    @soundupgradecard = "CardsGame/sound/fx6"
    # sonido que se produe al capturar las cartas en el tablero
    @soundgaincards = "CardsGame/sound/fx8"
    # Sonido que se produce al conseguir una pared en una jugada
    @soundpared = "CardsGame/sound/fx7"
    # Sonido que se produce al conseguir capturar cartas con una suma
    @soundsuma = "CardsGame/sound/fx9"
    # Sonido que se produce al conseguir capturar cartas con un igual
    @soundigual = "CardsGame/sound/fx10"
    # Sonido que se produce al conseguir un Combo
    @soundcombo = "CardsGame/sound/fx14"
    # Sonido que se produce al acabar una partida en empate estando
    # la regla hasta la muerte activa (Empieza inmediatamente
    # otra partida con las cartas actuales de los jugadores
    # hasta que alguien gane o pierda)
    @soundhastalamuerte = "CardsGame/sound/fx11"
    # Música que se reproduce al terminar la partida
    @endmusic = "CardsGame/music/victory"
    # ------------------------------------------------------------------
    # Consiguración referente a las imágenes
    # ------------------------------------------------------------------
    # Ruta Imagen del cursor
    @cursorbitmap = "CardsGame/cursor/1"
    # Ruta Imagen de la ventana de selección de cartas manualmente
    @winselectioncardsbitmapmanual = "CardsGame/background/win0"
    # Ruta Imagen para otras ventanas
    @winselectioncardsbitmap = "CardsGame/background/win1"
    # Ruta Imagen de la ventana de ayuda (Selección de cartas & Ayuda final)
    @winhelpcardsbitmap1 = "CardsGame/background/winhelp1"
    # Ruta Imagen de la ventana de ayuda (Fase de pago y juego normal)
    @winhelpcardsbitmap2 = "CardsGame/background/winhelp2"
    # Ruta imagen del selector en la ventana de selección
    # de cartas manualmente
    @winselectioncardsselectorbitmap = "CardsGame/cursor/selector1"
    # Ruta imágenes para los colores de las cartas
    # (carta Enemiga o del jugador)
    @playercolorcardbitmap = "CardsGame/cards/playerb"
    @enemycolorcardbitmap = "CardsGame/cards/enemyb"
    # Ruta que contiene la imagen de sombra de las cartas
    @cardshadow = "CardsGame/cards/sombra"
    # Ruta a la imagen de carta volteada
    @reversecard = 'CardsGame/cards/0a'
    # Ruta que contiene las cartas del juegos
    @foldercards = "CardsGame/cards/"
    # Imagen de fondo del tablero
    @backgroundimage1 = 'CardsGame/background/tablero1'
    # Imagen de fondo al terminar la partida
    @backgroundimage2 = 'CardsGame/background/fondo'
    # Imágenes para el selector de turnos
    @turnimagedown = 'CardsGame/cursor/indicador1' # Abajo
    @turnimageleft = 'CardsGame/cursor/indicador2' # Izquierda
    @turnimageright = 'CardsGame/cursor/indicador3' # Derecha
    # ------------------------------------------------------------------
    # Consiguración referente a las reglas
    # ------------------------------------------------------------------
    # Activar esto para usar el nuevo sistema de animaciones
    # (No usar el viejo modo porque está obsoleto)
    @usenewsystemani = true # DEJAR EN TRUE
    # La regla Plus wall (Suma + pared) no está incluida en el
    # Juego original Trile Triad,
    # Desactiva esta variable (false) para no usar esta regla
    @usepluswall = true
    # En el juego original la regla de combo solo se activa con las
    # reglas suma e igual. Desactiva esta variable (false) para
    # que la regla pared no ejecute ningún combo.
    # (wall / same wall / plus wall  //
    #  pared / pared + igual / pared + suma)
    @usecombowithwall = true
    # En el juego original la regla combo siempre está activa cuando
    # la regla igual o la regla suma están activas. Activa esta variable
    # para que esto sea así aquí también
    @activatecombowithplusorsame = true
    # Con esta variable activa (true) para comprobar las reglas suma e
    # igual se tendrá en cuenta cualquier color de las cartas que rodean
    # a la carta jugada.
    # Si se desactiva (false) solo se tendrá en cuenta las cartas de
    # diferente color alrededor de la carta jugada. (false = Modo original)
    @checkallcards = false
    # ------------------------------------------------------------------
    # Configuración de las reglas por defecto (se aplican estas reglas
    # si el enemigo no tiene definido un conjunto de reglas)
    # ------------------------------------------------------------------
    # Nivel de difultad del enemigo (1-10) (más nivel = más difícil)
    @defaultenemylevel = 4
    # true =    Activar Regla
    # false =   Desactivar Regla
    # (rand(2) == 0 ? true : false) = Elegir aleatoriamente entre true / false
    @defaultreglacombo = false
    @defaultreglaigual = true
    @defaultreglasuma = true
    @defaultreglapared = false
    @defaultreglaelemental = (rand(2) == 0 ? true : false)
    @defaultreglaabierto = true
    @defaultreglarandom = false
    @defaultreglahastalamuerte = (rand(2) == 0 ? true : false)
    # Método de pago
    # (0 = Una, 1 = Directo, 2 = Diferencia, 3 = Todas,
    #  4 = Ninguna y rand(5) para elegir aleatoriamente entre los 5 tipos)
    @defaultreglapago = 1 # 0 por defecto (Una carta)
    # ------------------------------------------------------------------
    # Otras configuraciones
    # ------------------------------------------------------------------
    # Hace que las animaciones al voltear las cartas sean más rápidas
    # (En fastmode, la cartas voltean sin mostrar el reverso, cuando se
    # desactiva, las cartas muestran el reverso dando una vuelta completa,
    # por lo que la animación tarda el doble de lo que tarda en fastmode, pero
    # también es más bonita)
    @fastmode = false # En la versión VX, esta opción siempre estará desactivada
                      # ya que las animaciones aquí son mucho más rápidas que en XP
    # ------------------------------------------------------------------
    # *************************************************************************
    #    FIN DEL APARTADO DE CONFIGURACIÓN
    # *************************************************************************
  end
  # ---------------------------------------------------------------------------
  def main
    Graphics.freeze
    # ----------------------------------------------
    @initializing = true
    @index = 0
    @indexboardx = 0
    @indexboardy = 0
    @page = 0
    @frameglobal = 0
    @lastcursorx = 0
    @lastcursory = 0
    @anicursor1 = 0
    @anicursor2 = 0
    @fastmode = false
    # ----------------------------------------------
    # Animación del Cursor
    # ----------------------------------------------
    @aniglobal = [-1,-1,0,0,0,0,0,1,1,1,0,0,0,-1]
    @aniglobal.concat(@aniglobal.reverse)
    # ----------------------------------------------
    # Animación para mover las cartas en la selección manual
    # ----------------------------------------------
    @animatecardselection = [[3,-7],[3,-7],[3,-14],[6,-14],[10,-14],[10,-7],
    [10,-7],[15,-7],[15,-7],[15,0],[20,0],[16,0],[14,7],[12,7],[0,0],[0,14],
    [0,14],[0,14],[0,14],[0,20],[0,20],[0,25],[0,25],[0,30],[0,40],[0,50],
    [0,50],[0,50]]
    @playerdeck = [] # mazo de cartas del jugador
    @enemydeck = []  # Mazo de cartas del enemigo
    # Mazo de cartas en el tablero
    @boarddeck = [Array.new(3),Array.new(3),Array.new(3)]
    # Array que controla las casillas del tablero elementales
    @boardelemental = [Array.new(3),Array.new(3),Array.new(3)]
    # Array que controla las imágenes elementales del tablero
    @boardelementalima = [Array.new(3),Array.new(3),Array.new(3)]
    # -----------------------------------------------------
    # lista de elementalese imágenes elementales
    # -----------------------------------------------------
    @elementallist = []
    @elementalimagelist = {}
    $deck['elementallist'].each do  |key,value|
      @elementallist.push(key)
      @elementalimagelist[key] = value[0]
    end
    # -----------------------------------------------------
    # Almacenar la música y sonidos sonando actualmente
    # -----------------------------------------------------
    #$game_system.bgm_memorize
   # $game_system.bgs_memorize
    # -----------------------------------------------------
    # Parar la música y sonidos sonando actualmente
    # -----------------------------------------------------
    Audio.bgs_stop
    Audio.bgm_stop
    # -----------------------------------------------------
    # Musica que se reproduce mientras se juega al triple triad
    if @forcemusic == nil
      Audio.bgm_play(@listsongs[rand(@listsongs.size)],85)
    else
      Audio.bgm_play(@forcemusic,85)
    end
    getplayercards
    @tablero = Sprite.new
    # Imagen del tablero
    @tablero.bitmap = Bitmap.new(@backgroundimage1)
    @tablero.z = -2
    @cursor = Sprite.new
    @cursor.z = 1010
    @cursor2 = Sprite.new
    @cursor2.z = 1010
    @selector1 = Sprite.new
    @selector1.opacity = 110
    @selector1.blend_type = 2
    @selector1.z = 1000
    @selector2 = Sprite.new
    @selector2.z = 1000
    @numbercardsplayer = Sprite.new
    @numbercardsplayer.bitmap = Bitmap.new(58,72)
    @numbercardsplayer.x = 546
    @numbercardsplayer.y = 413
    @numbercardsplayer.z = 1000
    @numbercardsenemy = Sprite.new
    @numbercardsenemy.bitmap = Bitmap.new(58,72)
    @numbercardsenemy.x = 37
    @numbercardsenemy.y = 413
    @numbercardsenemy.z = 1000
    # Imágenes usadas en el selector de turnos
    @anicursor2image = Bitmap.new(@turnimagedown)
    @anicursor2image2 = Bitmap.new(@turnimageleft)
    @anicursor2image3 = Bitmap.new(@turnimageright)
    @selector2frame = 0
    @cardpreview = Sprite.new
    @cardpreview.z = 10
    @totalcards = @data.size
    @maxpages = (@totalcards / 17) + (@totalcards % 17 != 0 ? 1 : 0)
    # Hash que guardará las imágenes de las cartas para evitar lag
    @previewimas = {}
    # -----------------------------------------------------
    # Fase 1:
    # Selección de reglas y cartas del enemigo
    # -----------------------------------------------------
    # Selección de reglas
    getrules if !@tutorial
    # Mostrar la ventana de confirmación con las reglas
    # para empezar la partida
    drawwin0 if !@tutorial
    if !@endgame and !@tutorial
      # Si la regla Elemental está activada, actualizar
      # tablero con casillas elementales
      iselementalgame?
      Graphics.transition
      # Conseguir las cartas que va a jugar el enemigo
      getenemycards
      # Voltear Las cartas del enemigo inicialmente
      flipcardsback(0,@enemydeck,false,true)
      # -----------------------------------------------------
      # Selección de las cartas con las que se va a jugar.
      # Si la regla @reglarandom está activada, las cartas
      # se seleccionarán aleatoriamente para el jugador.
      # Si está desactivada el jugador podrá elegir que
      # cartas jugar en esta partida
      # -----------------------------------------------------
      if @reglarandom == false
        # Selección de cartas manualmente
        drawwin1
        # Comprobar que se quiere jugar con las cartas seleccionadas
        drawwin2(@textos[4][6])
        while @index_window == 1
          @playerdeck.each do |item|
            item[0].dispose
          end
          @playerdeck = []
          getplayercards
          @begingame = false
          @cursor.visible = true
          drawwin1 # Selección de cartas manualmente
          drawwin2(@textos[4][6]) # Comprobar si se quiere jugar con esas cartas
        end
        opendeckenemy?
      else
        getplayerdeck
        # Comprobar si se aplica o no la regla abierto
        opendeckenemy?(false)
        soundcount = 0
        while nowmovingini
          animatedeckini
          Audio.se_play(@soundmovecard,85) if soundcount % 2 == 0
          soundcount += 1
          Graphics.update
        end
        animatedeckini
        Graphics.update
      end
      # -----------------------------------------------------
      # Actualizar las estádisticas del jugador y el enemigo
      # -----------------------------------------------------
      $deck['stats'][@enemyid]['games'] += 1
      $deck['stats']['player']['games'] += 1
      # -----------------------------------------------------
      # Dibujar la cantidad de cartas para cada jugador
      # -----------------------------------------------------
      checknumbercardsindeck
      # -----------------------------------------------------
      # Establecer turno Inicial:
      # -----------------------------------------------------
       getfirstturn
       draw_text_action
      # -----------------------------------------------------
      # Dibujar la ayuda In-Game
      # -----------------------------------------------------
      draw_help_in_game
      # -----------------------------------------------------
      # Establecer otras variables iniciales:
      # -----------------------------------------------------
      @initializing = false
      @noselection = nil
      @simulation = false
      # -----------------------------------------------------
      # Arrays para reconstruir los decks del jugador y la
      # máquina al acabar la partida (Toma la id única)
      # Si el método de pago es 'directo' cada jugador
      # recibirá las cartas de su color tras la partida, y si
      # es 'todas' el ganador se quedará con todas las cartas
      # -----------------------------------------------------
      @playerreconstructor = [] # Modo antiguo
      @enemyreconstructor = [] # Modo antiguo
      @newplayerdeckbackup = [] # Modo actual
      @newenemydeckbackup = [] # Modo actual
      @playerdeck.each do |item| # Modo antiguo
        id = item[2][0]
        @playerreconstructor.push(id)
        @newplayerdeckbackup.push(item.dup)
      end
      @enemydeck.each do |item| # Modo antiguo
        id = item[2][0]
        @enemyreconstructor.push(id)
        @newenemydeckbackup.push(item.dup)
      end
      for i in 0...@newplayerdeckbackup.size # Modo actual
        s = Sprite.new
        s.z = @newplayerdeckbackup[i][0].z
        s.x = -600
        s.y = -600
        s.bitmap = @newplayerdeckbackup[i][0].bitmap.dup
        @newplayerdeckbackup[i][0] = s
      end
      for i in 0...@newenemydeckbackup.size # Modo actual
        s = Sprite.new
        s.z = @newenemydeckbackup[i][0].z
        s.x = -600
        s.y = -600
        s.bitmap = @newenemydeckbackup[i][0].bitmap.dup
        @newenemydeckbackup[i][0] = s
      end
      # -----------------------------------------------------
      # Comienzo del loop principal del juego
      # -----------------------------------------------------
      loop do
        Graphics.update
        Input.update
        @frameglobal += 1
        if @frameglobal >= 100
          @frameglobal = 0
          Graphics.frame_reset
        end
        animateselector2 if @frameglobal % 3 == 0
        animatecursor1
        animatetextaction if @fase != -1
        # Comprobar turno
        case @fase
        when -2 # Salir del Triple Triad
          $scene = Scene_Map.new
          break
        when -1: # Partida acabada
          if (@playercardsgainingame != @enemycardsgainingame and
            @reglapago < 4) or @reglapago == 1
            begin_fase_pago
          else
            $scene = Scene_Map.new
            break
          end
        when 0: # Turno Jugador (Fase 1)
          update_fase0
        when 2: # Turno Jugador (Fase 2)
          update_fase2
          animatecursor2
        when 3:
          update_fase3
        when 1: # Turno Enemigo
          update_fase1
        when 10: # Cuando ganas y el método de pago es 1 o diferencia, se activa
          update_fase_pago
        when 100
          $scene = Scene_Map.new
          break
        end
        if @newgame
          @newgame = nil
        end
      end
    end
    if @tutorial
      showtutorial
      $scene = Scene_Map.new
    end
    Audio.bgm_stop
    Graphics.freeze
    dispose
    # -----------------------------------------------------
    # Restaurar la música y sonidos almacenados
    # -----------------------------------------------------
    #$game_system.bgm_restore
    #$game_system.bgs_restore
    # -----------------------------------------------------
    Graphics.transition(10)
    # Eliminando datos inservibles en la lista de cartas del jugador
    #for i in 0...$deck['player'].size
      #if $deck['player'][i] == []
        #$deck['player'][i] = nil
      #end
    #end
  end
  # ---------------------------------------------------------------------------
  def flipcardsback(dir,cards,animatemode = true,nowin = false)
    # Hace que las cartas indicadas (cards) volteen mostrando el dorso
    flipcardsbacknew
  end
  # ---------------------------------------------------------------------------
  def flipcardsfront(dir,cards, animatemode = true,nowin = false)
    # Hace que las cartas volteadas indicadas (cards)
    # volteen mostrando la imagen de la carta
    flipcardsfrontnew
  end
  # ---------------------------------------------------------------------------
  def flipcardsbacknew(backreverse = false)
    # Método para voltear las cartas
    # backreverse = false => Las cartas voltean mostrando el dorso
    # backreverse = true => Las cartas voltean mostrando la imagen de la carta
    return if @animatecardsflip == nil
    return if @animatecardsflip.size == 0
    ima0 = @previewimas[@reversecard]
    shadow = Bitmap.new(@cardshadow)
    imas = []
    realx = @indexboardx
    realy = @indexboardy
    if @fase != -1
      if @boarddeck[realx][realy] != nil and
        @boarddeck[realx][realy] != -1 and backreverse
        @boarddeck[realx][realy][2][5] == 0 ?
            imatop = Bitmap.new(@playercolorcardbitmap) :
            imatop = Bitmap.new(@enemycolorcardbitmap)
      elsif @boarddeck[realx][realy] != nil and
            @boarddeck[realx][realy] != -1 and !backreverse
         @boarddeck[realx][realy][2][5] == 0 ?
            imatop = Bitmap.new(@enemycolorcardbitmap) :
            imatop = Bitmap.new(@playercolorcardbitmap)
      else
        imatop = Bitmap.new(@playercolorcardbitmap)
      end
    else
      imatopplayer = Bitmap.new(@enemycolorcardbitmap)
      imatopenemy = Bitmap.new(@playercolorcardbitmap)
    end
    case @animatecardsflip.size
    when 1
      suavize = 2
    when 2
      suavize = 1
    else
      suavize = 0
    end
    suavize = 2
    for i in 0...@animatecardsflip.size
      if @fase == -1 and !backreverse
        @animatecardsflip[i][0][2][5] == 0 ?
        imatop = Bitmap.new(@enemycolorcardbitmap) :
        imatop = Bitmap.new(@playercolorcardbitmap)
      elsif @fase == -1 and backreverse
        @animatecardsflip[i][0][2][5] == 0 ?
        imatop = Bitmap.new(@playercolorcardbitmap) :
        imatop = Bitmap.new(@enemycolorcardbitmap)
      end
      card = @animatecardsflip[i][0] # real card = card[2], card[0] = Sprite
      x = @animatecardsflip[i][1]
      y = @animatecardsflip[i][2]
      if @animatecardsflip[i][3] != nil
        realx = @animatecardsflip[i][3]
        realy = @animatecardsflip[i][4]
      end
      realbitmap = Bitmap.new("#{@foldercards}#{card[2][7]}")#@previewimas["#{@foldercards}#{card[2][7]}"].dup
      im = Bitmap.new(133,164)
      im.blt(0,0,realbitmap,Rect.new(0,0,133,164))
      bitmap = im
      s1 = Sprite.new
      s1.bitmap = bitmap
      s1.x = card[0].x - 16
      s1.y = card[0].y - 24
      s1.z = 3000
      s1.zoom_x = s1.zoom_y = 1.00
      im = Bitmap.new(133,164)
      im.blt(0,0,imatop,Rect.new(0,0,133,164))
      bitmap = im
      s2 = Sprite.new
      s2.bitmap = bitmap
      s2.x = card[0].x - 16
      s2.y = card[0].y - 24
      s2.z = 3000
      s2.zoom_x = s2.zoom_y = 1.00
      s3 = Sprite.new
      s3.bitmap = Bitmap.new(@cardpreview.bitmap.width,@cardpreview.bitmap.height)
      s3.bitmap.stretch_blt(s3.bitmap.rect,shadow,shadow.rect)
      s3.x = card[0].x + 4
      s3.y = card[0].y + 10
      s3.z = 2999
      if realx == x
        if realy > y
          type = 0 # Posición arriba
          modx = 5
          mody = -4
        else
          type = 3 # Posición abajo
          modx = 5
          mody = 4
        end
      elsif realy == y
        if realx > x
          type = 1 # Posición izquierda
          modx = 5
          mody = 20
        else
          type = 2 # Posición derecha
          modx = -5
          mody = 20
        end
      else
        type = 2
        modx = -5
        mody = 20
      end
      imas.push([realbitmap,s1,s2,type,modx,mody,s3])
    end
    imas.each do |item|
      item[1].x += item[4]
      item[1].y += item[5]
      item[2].x += item[4]
      item[2].y += item[5]
    end
    zoomer = 0.16
    if backreverse
      s1.zoom_x += zoomer
      s1.zoom_y += zoomer
      s2.zoom_x += zoomer
      s2.zoom_y += zoomer
    end
    for i in 0...3
      #break if @fastmode and backreverse
      cnt = 0
      imas.each do |item|
        if @fase == -1
          @animatecardsflip[cnt][0][2][5] == 0 ?
            imatop = imatopenemy : imatop = imatopplayer
          cnt += 1
        end
        bitmap = (!backreverse ? item[0] : ima0)
        type = item[3]
        s1 = item[1]
        s2 = item[2]
        s1.bitmap.clear
        s2.bitmap.clear
        s3 = item[6]
        s3.opacity -= 44
        case type
        when 0
          x = (6 -i) * 133
          y = 164
          x -= 3 if i == 0
        when 1
          x = (6 -i) * 133
          y = 0
          x -= 3 if i == 0
        when 2
          x = 133 + (133 * i)
          y = 0
          x -= 3 if i == 2
        when 3
          x = 133 + (133 * i)
          y = 164
          x -= 3 if i == 2
        end
        s1.bitmap.blt(0,0,bitmap,Rect.new(x,y,133,164))
        s2.bitmap.blt(0,0,imatop,Rect.new(x,y,133,164)) if !backreverse
      end
      if @initializing
        movecardpreview
        s1.y = s2.y = @cardpreview.y - 24
      end
      animatetextaction if @forzechain
      if !backreverse
        s1.zoom_x += zoomer / 6
        s1.zoom_y += zoomer / 6
        s2.zoom_x += zoomer / 6
        s2.zoom_y += zoomer / 6
      else
        s1.zoom_x -= zoomer / 6
        s1.zoom_y -= zoomer / 6
        s2.zoom_x -= zoomer / 6
        s2.zoom_y -= zoomer / 6
      end
      Graphics.update
      Graphics.update
      animatetextaction if @forzechain and suavize > 0
      Graphics.update if suavize > 0
    end
    for i in 0...3
      #break if @fastmode and !backreverse
      cnt = 0
      imas.each do |item|
        if @fase == -1
          @animatecardsflip[cnt][0][2][5] == 0 ?
            imatop = imatopenemy : imatop = imatopplayer
          cnt += 1
        end
        bitmap = (!backreverse ? ima0 : item[0])
        type = item[3]
        s1 = item[1]
        s2 = item[2]
        s1.bitmap.clear
        s2.bitmap.clear
        s3 = item[6]
        s3.opacity -= 44
        case type
        when 0
          x = (133 * 3) - (133 * i)
          y = 164
          x -= 3 if i == 0
        when 1
          x = (133 * 3) - (133 * i)
          y = 0
          x -= 3 if i == 0
        when 2
          x = (133 * 4) + (133 * i)
          y = 0
          x -= 3 if i == 2
        when 3
          x = (133 * 4) + (133 * i)
          y = 164
          x -= 3 if i == 2
        end
        s1.bitmap.blt(0,0,bitmap,Rect.new(x,y,133,164))
        s2.bitmap.blt(0,0,imatop,Rect.new(x,y,133,164)) if backreverse
      end
      if @initializing
        movecardpreview
        s1.y = s2.y = @cardpreview.y - 24
      end
      animatetextaction if @forzechain
      if !backreverse
        s1.zoom_x += zoomer / 6
        s1.zoom_y += zoomer / 6
        s2.zoom_x += zoomer / 6
        s2.zoom_y += zoomer / 6
      else
        s1.zoom_x -= zoomer / 6
        s1.zoom_y -= zoomer / 6
        s2.zoom_x -= zoomer / 6
        s2.zoom_y -= zoomer / 6
      end
      Graphics.update
      Graphics.update
      animatetextaction if @forzechain and suavize > 1
      Graphics.update if suavize > 1
    end
    imas.each do |item|
      item[1].x -= item[4]
      item[1].y -= item[5]
      item[2].x -= item[4]
      item[2].y -= item[5]
    end
    cnt = 0
    imas.each do |item|
      if @fase == -1
        @animatecardsflip[cnt][0][2][5] == 0 ?
          imatop = imatopenemy : imatop = imatopplayer
        cnt += 1
      end
      bitmap = (!backreverse ? ima0 : item[0])
      type = item[3]
      s1 = item[1]
      s2 = item[2]
      s1.bitmap.clear
      s2.bitmap.clear
      s1.bitmap.blt(0,0,bitmap,Rect.new(0,0,133,164))
      s2.bitmap.blt(0,0,imatop,Rect.new(0,0,133,164)) if backreverse
      animatetextaction if @forzechain
    end
    Graphics.update
    Audio.se_play(@soundmovecardoverdeck,85) if backreverse
    imas.each do |item|
      item[0].dispose
      item[1].dispose
      item[2].dispose
      item[6].dispose
    end
  end
  # ---------------------------------------------------------------------------
  def flipcardsfrontnew
    # Hace que las cartas volteadas indicadas (cards)
    # volteen mostrando la imagen de la carta
    flipcardsbacknew(true)
    @animatecardsflip = []
  end
  # ---------------------------------------------------------------------------
  def drawwin0
    # Dibuja la venta que muestra las reglas del juego activas
    texto0 = "#{@textos[0][0]}:"
    texto1 = ""
    texto1 += "  * #{@textos[1][2]}" if @reglahastalamuerte
    texto2 = "  * #{@textos[2][0]}: " +
              (@reglarandom ? @textos[2][1] : @textos[2][2])
    texto3 = ""
    texto3 += (texto3 != "" ? ", " : "") + "#{@textos[0][1]}" if @reglaigual
    texto3 += (texto3 != "" ? ", " : "") + "#{@textos[0][2]}" if @reglasuma
    texto3 += (texto3 != "" ? ", " : "") + "#{@textos[0][3]}" if @reglapared
    texto3 += (texto3 != "" ? ", " : "") + "#{@textos[0][6]}" if @reglacombo
    texto3 += (texto3 != "" ? ", " : "") + "#{@textos[1][1]}" if @reglaabierto
    texto3 = "  * #{texto3}" if texto3 != ""
    texto4 = ""
    texto4 += "  * #{@textos[0][7]}" if @reglaelemental
    texto5 = "  * #{@textos[3][0]}: " +
            (case @reglapago
            when 0:
              "#{@textos[3][1]}"
            when 1:
              "#{@textos[3][2]}"
            when 2:
              "#{@textos[3][3]}"
            when 3:
              "#{@textos[3][4]}"
            when 4:
              "#{@textos[3][5]}"
            end)
    texto6 = "#{@textos[4][3]}"
    texto7 = "#{@textos[4][4]}"
    win = Bitmap.new(1,1)
    win.font.size = 20
    h = (@noselection == nil ? 110 : 55)
    h += 22 if texto1 != ""
    h += 22 if texto2 != ""
    h += 22 if texto3 != ""
    h += 22 if texto4 != ""
    h += 22 if texto5 != ""
    w = 0
    w = 40 + win.text_size(texto1).width if w < 40 + win.text_size(texto1).width
    w = 40 + win.text_size(texto2).width if w < 40 + win.text_size(texto2).width
    w = 40 + win.text_size(texto3).width if w < 40 + win.text_size(texto3).width
    w = 40 + win.text_size(texto4).width if w < 40 + win.text_size(texto4).width
    w = 40 + win.text_size(texto5).width if w < 40 + win.text_size(texto5).width
    if @noselection == nil
      w = 80 + win.text_size(texto6).width if w < 80 + win.text_size(texto6).width
      w = 80 + win.text_size(texto7).width if w < 80 + win.text_size(texto7).width
    end
    @win0 = Sprite.new
    @win0.bitmap = Bitmap.new(w,h)
    @win0.bitmap.font.size = 20
    win = Bitmap.new(@winselectioncardsbitmap)
    @win0.bitmap.stretch_blt(@win0.bitmap.rect,win,win.rect)
    @win0.x = 320 - (@win0.bitmap.width / 2)
    @win0.y = 240 - (@win0.bitmap.height / 2)
    @win0.z = 20000 if @noselection
    mod_pos = [[1,0],[-1,0],[0,-1],[0,1]]
    @win0.bitmap.font.color = Color.new(0,0,0,255)
    for i in 0...mod_pos.size
      x = 15
      y = 15
      x1 = x + mod_pos[i][0]
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto0)
      y += 30
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto1)
      y += 20 if texto1 != ""
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto2)
      y += 20 if texto2 != ""
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto3)
      y += 20 if texto3 != ""
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto4)
      y += 20 if texto4 != ""
      y1 = y + mod_pos[i][1]
      @win0.bitmap.draw_text(x1,y1,w-30,20,texto5)
      if @noselection == nil
        y += 30
        y1 = y + mod_pos[i][1]
        @win0.bitmap.draw_text(x1+40,y1,w-30,20,texto6)
        y += 20
        y1 = y + mod_pos[i][1]
        @win0.bitmap.draw_text(x1+40,y1,w-30,20,texto7)
      end
    end
    @win0.bitmap.font.color = Color.new(255,255,255,255)
    x = 15
    y = 15
    @win0.bitmap.draw_text(x,y,w-30,20,texto0)
    y += 30
    @win0.bitmap.draw_text(x,y,w-30,20,texto1)
    y += 20 if texto1 != ""
    @win0.bitmap.draw_text(x,y,w-30,20,texto2)
    y += 20 if texto2 != ""
    @win0.bitmap.draw_text(x,y,w-30,20,texto3)
    y += 20 if texto3 != ""
    @win0.bitmap.draw_text(x,y,w-30,20,texto4)
    y += 20 if texto4 != ""
    @win0.bitmap.draw_text(x,y,w-30,20,texto5)
    if @noselection == nil
      y += 30
      @win0.bitmap.draw_text(x+40,y,w-30,20,texto6)
      y += 20
      @win0.bitmap.draw_text(x+40,y,w-30,20,texto7)
      @cursor.bitmap = Bitmap.new(@cursorbitmap)
      @cursor.x = @win0.x + 20
      @cursor.y = @win0.y + y - 18
      Graphics.transition
      index = 0
      loop do
        Graphics.update
        Input.update
        animatecursor1
        if Input.trigger?(Input::C) and index == 0
          Audio.se_play(@soundcursor,85)
          if @reglarandom
            @cursor.visible = false
          end
          @win0.dispose
          break
        end
        if Input.trigger?(Input::B) or
          (Input.trigger?(Input::C) and index == 1)
          Audio.se_play(@soundcancel,85)
          if index == 0 and Input.trigger?(Input::B)
            index = 1
            for i in 0...2
              @cursor.y += 10
              animatecursor1
              Graphics.update
            end
          end
          Graphics.freeze
          @endgame = true
          @win0.dispose
          @cursor.visible = false
          $scene = Scene_Map.new
          Graphics.transition(5)
          break
        end
        if Input.repeat?(Input::UP) or Input.repeat?(Input::DOWN)
          Audio.se_play(@soundcursor,85)
          if Input.repeat?(Input::UP)
            index == 0 ? index = 1 : index = 0
          end
          if Input.repeat?(Input::DOWN)
            index == 0 ? index = 1 : index = 0
          end
          for i in 0...2
            index == 0 ? @cursor.y -= 10 : @cursor.y += 10
            animatecursor1
            Graphics.update
          end
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def drawwin1
    # Dibuja la ventana de selección de cartas manual
    @win = Sprite.new
    @win.bitmap = Bitmap.new(@winselectioncardsbitmapmanual)
    @win.x = 0
    @win.y = 0
    v = Viewport.new(112,61,261,@win.bitmap.height)
    @data_win = Sprite.new(v)
    @data_win.bitmap = Bitmap.new(@win.bitmap.width,@win.bitmap.height)
    @data_win.bitmap.font.size = 18
    drawcontentwin1
    @cursor.bitmap = Bitmap.new(@cursorbitmap)
    @cursor.x = 82
    @cursor.y = 74
    @selector1.bitmap = Bitmap.new(@winselectioncardsselectorbitmap)
    @selector1.x = 118
    @selector1.y = @cursor.y  - 2
    createcardpreview
    @pagenumber = Sprite.new
    @pagenumber.bitmap = Bitmap.new(201,22)
    @pagenumber.bitmap.font.size = 20
    @pagenumber.x = 142
    @pagenumber.y = 414
    drawpageinwin1
    @help = Sprite.new
    @help.bitmap = Bitmap.new(@winhelpcardsbitmap1)
    @help.x = 8
    @help.y = 6
    draw_help_manual_selection_cards
    maxsound = 5
    playsoundcnt = 0
    n = 0
    loop do
      Graphics.update
      Input.update
      break if @begingame
      updatemovewin1
      animatecursor1
      animatecontentwin1
      animatedeckini
      movecardpreview
      if playsoundcnt % 2 == 0 and maxsound > 0
        Audio.se_play(@soundmovecard,85)
        maxsound -= 1
      end
      playsoundcnt += 1
      n += 1
      if n == 300
        n = 0
        Graphics.frame_reset
      end
    end
    @win.dispose
    @pagenumber.dispose
    @data_win.viewport.dispose
    @data_win.dispose
    @help.dispose
  end
  # ---------------------------------------------------------------------------
  def drawpageinwin1
    # Dibuja el número de página en la ventana de selección de cartas manual
    @pagenumber.bitmap.clear
    data_pos = [[1,0],[0,2],[0,1],[-1,0],[0,-1]]
    color1 = Color.new(0,0,0,255)
    color2 = Color.new(219,158,12,255)
    texto1 = @textos[4][19] # Página...
    texto2 = @textos[4][20] # De...
    page = @page + 1
    if @maxpages > 1
      text = "#{texto1} #{page} #{texto2} #{@maxpages}"
    else
     text = "#{texto1} #{page}"
    end
    @pagenumber.bitmap.font.color = color1
    for i in 0...data_pos.size
      x = 0 + data_pos[i][0]
      y = 0 + data_pos[i][1]
      @pagenumber.bitmap.draw_text(x,y,201,22,text,1)
    end
    @pagenumber.bitmap.font.color = color2
    @pagenumber.bitmap.draw_text(0,0,201,22,text,1)
  end
  # ---------------------------------------------------------------------------
  def draw_help_manual_selection_cards
    # Dibuja la ayuda cuando la ventana de selección de cartas manual está activa
    text1 = @textos[4][21]
    text2 = @textos[4][22]
    data_pos = [[1,0],[-1,0],[0,1],[0,-1],[0,2]]
    color1 = Color.new(0,0,0,255)
    color2 = Color.new(255,255,255,255)
    @help.bitmap.font.size = 18
    @help.bitmap.font.color = color1
    for i in 0...data_pos.size
      x = 12 + data_pos[i][0]
      y = 6  + data_pos[i][1]
      @help.bitmap.draw_text(x,y,386,20,text1,1)
      @help.bitmap.draw_text(x,y+20,386,20,text2,1)
    end
    @help.bitmap.font.color = color2
    @help.bitmap.draw_text(12,6,386,20,text1,1)
    @help.bitmap.draw_text(12,26,386,20,text2,1)
  end
  # ---------------------------------------------------------------------------
  def drawcontentwin1(individual = false,last_index = -1)
    # Dibuja el contenido de la ventana de selección de cartas manual
    @data_win.bitmap.clear if !individual
    x = 10
    y = 10
    pos_mod = [[1,0],[-1,0],[0,1],[0,-1]]
    n1 = @page * 17
    n2 = n1 + 17
    for i in n1...n2
      return if i >= @data.size
      if individual and i != @index and i != last_index
        y += 20
        next
      end
      item = @data[i]
      if item == nil or item == []
        return
      end
      cards = item[1]
      current_card = item[0] + 1
      cards_in_use = item[2]
      n = cards.size
      name = cards[0][1]
      @data_win.bitmap.font.color = Color.new(0,0,0,255)
      if i == @index
        mod_x = 6
        if cards.size - cards_in_use > 0
          textcolor = Color.new(169,192,237,255)
        else
          textcolor = Color.new(158,158,158,255)
        end
        @data_win.bitmap.fill_rect(x,y,246,20,Color.new(0,0,0,0))
      elsif i == last_index
        mod_x = 0
        if cards.size - cards_in_use > 0
          textcolor = Color.new(255,255,255,255)
        else
          textcolor = Color.new(158,158,158,255)
        end
        @data_win.bitmap.fill_rect(x,y,246,20,Color.new(0,0,0,0))
      else
        mod_x = 0
        if cards.size - cards_in_use > 0
          textcolor = Color.new(255,255,255,255)
        else
          textcolor = Color.new(158,158,158,255)
        end
      end
      for z in 0...pos_mod.size
        x1 = x + pos_mod[z][0]
        y1 = y + pos_mod[z][1]
        @data_win.bitmap.draw_text(x1+mod_x,y1,208,20,"#{name.capitalize}")
        @data_win.bitmap.draw_text(x1+200,y1,38,20,"#{current_card}/#{n}",2)
      end
      @data_win.bitmap.font.color = textcolor
      @data_win.bitmap.draw_text(x+mod_x,y,208,20,"#{name.capitalize}")
      @data_win.bitmap.draw_text(x+200,y,38,20,"#{current_card}/#{n}",2)
      y += 20
    end
  end
  # ---------------------------------------------------------------------------
  def drawwin2(text)
    # Dibuja una ventana de selección Sí / No
    texto1 = text # Título
    texto2 = @textos[4][7] # Sí
    texto3 = @textos[4][8] # No
    win = Bitmap.new(1,1)
    win.font.size = 22
    h = 100
    w = 20 + win.text_size(texto1).width
    @win2 = Sprite.new
    @win2.bitmap = Bitmap.new(w,h)
    @win2.bitmap.font.size = 22
    win = Bitmap.new(@winselectioncardsbitmap)
    @win2.bitmap.stretch_blt(@win2.bitmap.rect,win,win.rect)
    @win2.x = 320 - (@win2.bitmap.width / 2)
    @win2.y = 240 - (@win2.bitmap.height / 2)
    @win2.z = 20000
    mod_pos = [[1,0],[-1,0],[0,-1],[0,1],[2,0],[-2,0],[0,-2],[0,2]]
    @win2.bitmap.font.color = Color.new(0,0,0,255)
    for i in 0...mod_pos.size
      x = 15
      y = 15
      x1 = x + mod_pos[i][0]
      y1 = y + mod_pos[i][1]
      @win2.bitmap.draw_text(x1,y1,w-30,22,texto1)
      y += 30
      y1 = y + mod_pos[i][1]
      @win2.bitmap.draw_text(x1+40,y1,w-30,22,texto2)
      y += 20
      y1 = y + mod_pos[i][1]
      @win2.bitmap.draw_text(x1+40,y1,w-30,22,texto3)
    end
    @win2.bitmap.font.color = Color.new(255,255,255,255)
    x = 15
    y = 15
    @win2.bitmap.draw_text(x,y,w-30,22,texto1)
    y += 30
    @win2.bitmap.draw_text(x+40,y,w-30,22,texto2)
    y += 20
    @win2.bitmap.draw_text(x+40,y,w-30,22,texto3)
    @index_window = 0
    @cursor.bitmap = Bitmap.new(@cursorbitmap)
    @cursor.x = @win2.x + 20
    @cursor.y = @win2.y + y - 18
    @cursor.visible = true
    bakcursor = @cursor.z
    @cursor.z = 200000
    n = 0
    loop do
      Graphics.update
      Input.update
      animatecursor1
      if Input.trigger?(Input::B) or Input.trigger?(Input::C)
        Audio.se_play(@soundcancel,85)
        if @index_window == 0 and Input.trigger?(Input::B)
          @index_window = 1
          for i in 0...2
            @cursor.y += 10
            animatecursor1
            Graphics.update
          end
        end
        Graphics.freeze
        @win2.dispose
        @cursor.visible = false
        Graphics.transition(5)
        @index = 0 + (@page * 17)
        break
      end
      if Input.repeat?(Input::UP) or Input.repeat?(Input::DOWN)
        Audio.se_play(@soundcursor,85)
        if Input.repeat?(Input::UP)
          @index_window == 0 ? @index_window = 1 : @index_window = 0
        end
        if Input.repeat?(Input::DOWN)
          @index_window == 0 ? @index_window = 1 : @index_window = 0
        end
        for i in 0...2
          @index_window == 0 ? @cursor.y -= 10 : @cursor.y += 10
          animatecursor1
          Graphics.update
        end
      end
      n += 1
      if n == 300
        n = 0
        Graphics.frame_reset
      end
    end
    @cursor.z = bakcursor
  end
  # ---------------------------------------------------------------------------
  def animatetextaction
    # Mueve el texto que se dibuja al realizar un Combo, Suma, Pared...
    if @textaction != nil
      @textaction.x -= 35
    end
  end
  # ---------------------------------------------------------------------------
  def animatecontentwin1
    # Movimiento del texto en la ventana de selección de cartas manual
    # cuando se cambia de página
    @data_win.ox += 16 if @data_win.ox < 0
    @data_win.ox -= 16 if @data_win.ox > 0
  end
  # ---------------------------------------------------------------------------
  def createcardpreview(nomove = false,backmode = false,cardfix = nil,
    forcecreate = false,forcecolor = nil)
    # Método para dibujar las diferentes cartas (le añade los valores
    # de ataque y el color que indica quién es el propietario actual)
    if @data != nil
      if @data[@index] == nil and !forcecreate
        @cardpreview.bitmap.clear
        return
      end
    end
    if @previewimas[@playercolorcardbitmap] == nil
      @previewimas[@playercolorcardbitmap] = Bitmap.new(@playercolorcardbitmap)
    end
    if @previewimas[@enemycolorcardbitmap] == nil
      @previewimas[@enemycolorcardbitmap] = Bitmap.new(@enemycolorcardbitmap)
    end
    if @previewimas[@reversecard] == nil
      @previewimas[@reversecard] = Bitmap.new(@reversecard)
    end
    if nomove
      @cardpreview.visible = false
      flipcardsback(1,[@cardpreview])
      @cardpreview.visible = true
    end
    if !backmode
      if cardfix == nil
        card_list = @data[@index][1]
        current_card = @data[@index][0]
        name = card_list[current_card][1]
        ima0 = @previewimas[@reversecard]
        @previewimas[@reversecard]
        im = Bitmap.new(91,128)
        im.stretch_blt(im.rect,ima0,Rect.new(16,25,91,128))
        ima0 = im
        im = Bitmap.new("#{@foldercards}#{card_list[current_card][7]}")
        if @previewimas["#{@foldercards}#{card_list[current_card][7]}"] == nil
          @previewimas["#{@foldercards}#{card_list[current_card][7]}"] = im.dup
        else
          im = @previewimas["#{@foldercards}#{card_list[current_card][7]}"].dup
        end
        ima = Bitmap.new(91,128)
        ima.stretch_blt(ima.rect,im,Rect.new(16,25,91,128))
        # Color para la carta ..............................
        if forcecolor == nil
          card_list[current_card][5] == 0 ?
          ima1 = @previewimas[@playercolorcardbitmap].dup :
          ima1 = @previewimas[@enemycolorcardbitmap].dup rescue ima1 = Bitmap.new(@playercolorcardbitmap)
        else
          forcecolor == 0 ?
          ima1 = @previewimas[@playercolorcardbitmap].dup :
          ima1 = @previewimas[@enemycolorcardbitmap].dup rescue ima1 = Bitmap.new(@playercolorcardbitmap)
        end
        im = Bitmap.new(91,128)
        im.stretch_blt(im.rect,ima1,Rect.new(16,25,91,128))
        ima1 = im
        # ..................................................
      else
        name = cardfix[1]
        ima0 = @previewimas[@reversecard]
        im = Bitmap.new(91,128)
        im.stretch_blt(im.rect,ima0,Rect.new(16,25,91,128))
        ima0 = im
        im = Bitmap.new("#{@foldercards}#{cardfix[7]}")
        if @previewimas["#{@foldercards}#{cardfix[7]}"] == nil
          @previewimas["#{@foldercards}#{cardfix[7]}"] = im.dup
        else
          im = @previewimas["#{@foldercards}#{cardfix[7]}"].dup
        end
        ima = Bitmap.new(91,128)
        ima.stretch_blt(ima.rect,im,Rect.new(16,25,91,128))
        # Color para la carta ..............................
        if forcecolor == nil
          cardfix[5] == 0 ?
          ima1 = @previewimas[@playercolorcardbitmap].dup :
          ima1 = @previewimas[@enemycolorcardbitmap].dup
        else
          forcecolor == 0 ?
          ima1 = @previewimas[@playercolorcardbitmap].dup :
          ima1 = @previewimas[@enemycolorcardbitmap].dup
        end
        im = Bitmap.new(91,128)
        im.stretch_blt(im.rect,ima1,Rect.new(16,25,91,128))
        ima1 = im
        # ..................................................
      end
    else
      ima0 = @previewimas[@reversecard]
      im = Bitmap.new(91,128)
      im.stretch_blt(im.rect,ima0,Rect.new(16,25,91,128))
      ima0 = im
    end
    @cardpreview.bitmap = Bitmap.new(91,128)
    if !backmode
      @cardpreview.bitmap.blt(0,0,ima,ima.rect)
      @cardpreview.bitmap.stretch_blt(Rect.new(-2,0,93,128),ima1,ima1.rect)
    else
      @cardpreview.bitmap.blt(0,0,ima0,ima0.rect)
    end
    if !nomove
      @cardpreview.x = 378
      @cardpreview.y = 570
      @cardpreview.opacity = 20
    end
    # Añadir los valores de ataque y el nombre
    # en la carta en la posición indicada
    if !backmode
      if cardfix == nil
        pos = card_list[current_card][8]
        atks = card_list[current_card][3]
      else
        pos = cardfix[8]
        atks = cardfix[3]
      end
      pos_mod = [[1,0],[-1,0],[0,1],[0,-1],[2,0],[-2,0],[0,2],[0,-2]]
      atk_arr = (atks[0] == 10 ? "A" : atks[0])
      atk_izq = (atks[1] == 10 ? "A" : atks[1])
      atk_der = (atks[2] == 10 ? "A" : atks[2])
      atk_aba = (atks[3] == 10 ? "A" : atks[3])
      case pos
      when 0 # Arriba Izquierda
        x = -15
        y = 6
      when 1 # Arriba Derecha
        x = 28
        y = 6
      when 2 # Inferior Izquierda
        x = -15
        y = 70
      when 3 # Inferior Derecha
        x = 28
        y = 70
      end
      @cardpreview.bitmap.font.color = Color.new(0,0,0,255)
      for i in 0...pos_mod.size
        x1 = x + pos_mod[i][0]
        y1 = y + pos_mod[i][1]
        @cardpreview.bitmap.font.size = 20
        # Posición Ataque Arriba
        @cardpreview.bitmap.draw_text(x1,y1,80,20,"#{atk_arr}",1)
        # Posición Ataque Izquierda / Derecha
        @cardpreview.bitmap.draw_text(x1,y1+15,80,20,"#{atk_izq} #{atk_der}",1)
        # Posición Ataque Abajo
        @cardpreview.bitmap.draw_text(x1,y1+30,80,20,"#{atk_aba}",1)
        # nombre de la carta
        @cardpreview.bitmap.font.size = 13
        #@cardpreview.bitmap.draw_text(5+pos_mod[i][0],112+pos_mod[i][1],
        #61,20,"#{name}",1)
      end
      @cardpreview.bitmap.font.color = Color.new(255,255,255,255)
      @cardpreview.bitmap.font.size = 20
      # Posición Ataque Arriba
      @cardpreview.bitmap.draw_text(x,y,80,20,"#{atk_arr}",1)
      # Posición Ataque Izquierda / Derecha
      @cardpreview.bitmap.draw_text(x,y+15,80,20,"#{atk_izq} #{atk_der}",1)
      # Posición Ataque Abajo
      @cardpreview.bitmap.draw_text(x,y+30,80,20,"#{atk_aba}",1)
      # nombre de la carta
      @cardpreview.bitmap.font.size = 13
      #@cardpreview.bitmap.draw_text(5,112,61,20,"#{name}",1)
    end
    if nomove
      @cardpreview.visible = false
      flipcardsfront(1,[@cardpreview])
      @cardpreview.visible = true
    end
  end
  # ---------------------------------------------------------------------------
  def drawonlycardscolor(card,color)
    # Dibuja solo el color del propietario de la carta indicada a la misma
    color == 0 ?
    ima1 = @previewimas[@playercolorcardbitmap].dup :
    ima1 = @previewimas[@enemycolorcardbitmap].dup
    im = Bitmap.new(91,128)
    im.stretch_blt(im.rect,ima1,Rect.new(16,25,91,128))
    ima1 = im
    card.bitmap.stretch_blt(Rect.new(-2,0,93,128),ima1,ima1.rect)
  end
  # ---------------------------------------------------------------------------
  def drawelementalvals
    # Método que se encarga de dibujar el modificador de ataque a una carta
    # cuando esta es depositada en el tablero y la regla elemental está activa
    for x in 0...3
      for y in 0...3
        card = @boarddeck[x][y]
        next if @boardelemental[x][y] == nil
        next if card == nil or card == -1
        card_element = card[2][2]
        pos_mod = [[1,0],[-1,0],[0,1],[0,-1],[2,0],[-2,0],[0,2],[0,-2]]
        if @boardelemental[x][y] == card_element
          plus_atk = "+1"
        else
          plus_atk = "-1"
        end
        card[0].bitmap.font.size = 44
        card[0].bitmap.font.color = Color.new(0,0,0,255)
        card[0].bitmap.font.italic = true
        for i in 0...pos_mod.size
          x1 = 0 + pos_mod[i][0]
          y1 = 35 + pos_mod[i][1]
          card[0].bitmap.draw_text(x1,y1,91,128,"#{plus_atk}",1)
        end
        if @boardelemental[x][y] == card_element
          card[0].bitmap.font.color = Color.new(0,180,0,255)
        else
          card[0].bitmap.font.color = Color.new(200,0,0,255)
        end
        card[0].bitmap.draw_text(0,35,91,128,"#{plus_atk}",1)
        card[0].bitmap.font.italic = false
      end
    end
  end
  # ---------------------------------------------------------------------------
  def movecardpreview
    # Mueve la carta de previsualización que se muestra en la ventana de
    # selección de cartas manual de abajo a arriba
    @cardpreview.y -= 40
    @cardpreview.y = 160 if @cardpreview.y < 160
    @cardpreview.opacity += 27
  end
  # ---------------------------------------------------------------------------
  def getplayercards
    # Método que devuelve las cartas en posesión del jugador
    @data = []
    $deck['player'].each do |cards|
      if cards != nil and cards.size > 0
        # [Index Carta Actual,Lista de cartas,Cartas en uso,Nombre de la Carta]
        @data.push([0,cards.dup,0,cards[0][1]])
      end
    end
  end
  # ---------------------------------------------------------------------------
  def updatemovewin1
    # Update Selección Manual de cartas iniciales para el jugador
    # Mostrar las reglas activas
    if @limitframehere == nil
      @limitframehere = 0
    end
    if @fase == 3
      update_fase3
      return
    end
    if Input.trigger?(Input::Y) or Input.trigger?(Input::Z)
      @backupfase = @fase
      @noselection = true
      drawwin0
      @noselection = nil
      @blackbackground = Sprite.new
      @blackbackground.bitmap = Bitmap.new(640,480)
      @blackbackground.bitmap.fill_rect(0,0,640,480,Color.new(0,0,0,180))
      @blackbackground.z = 15000
      @fase = 3
      return
    end
    last_index = @index
    # Abajo
    if Input.press?(Input::DOWN) and @limitframehere == 0
      Audio.se_play(@soundcursor,92)
      if @cursor.y < 394
        @index += 1
        if @data[@index] != nil
          Audio.se_play(@soundmovecard,85)
        end
        for i in 0...2
          @cursor.y += 9
          @selector1.y = @cursor.y  - 2
          movecardpreview
          animatedeckini
          Graphics.update
        end
        @cursor.y += 2
        @selector1.y = @cursor.y  - 2
      else
        @index -= 16
        if @data[@index] != nil
          Audio.se_play(@soundmovecard,85)
        end
        for i in 0...4
          @cursor.y -= 80
          @selector1.y = @cursor.y  - 2
          movecardpreview
          animatedeckini
          Graphics.update
        end
      end
      drawcontentwin1(true,last_index)
      createcardpreview
      @limitframehere = 2
      return
    end
    # Arriba
    if Input.press?(Input::UP) and @limitframehere == 0
      Audio.se_play(@soundcursor,85)
      if @cursor.y > 74
        @index -= 1
        if @data[@index] != nil
          Audio.se_play(@soundmovecard,85)
        end
        for i in 0...2
          @cursor.y -= 9
          @selector1.y = @cursor.y  - 2
          movecardpreview
          animatedeckini
          Graphics.update
        end
        @cursor.y -= 2
        @selector1.y = @cursor.y  - 2
      else
        @index += 16
        if @data[@index] != nil
          Audio.se_play(@soundmovecard,85)
        end
        for i in 0...4
          @cursor.y += 80
          @selector1.y = @cursor.y  - 2
          movecardpreview
          animatedeckini
          Graphics.update
        end
      end
      drawcontentwin1(true,last_index)
      createcardpreview
      @limitframehere = 2
      return
    end
    @limitframehere -= 1 if @limitframehere > 0
    # Derecha
    if Input.repeat?(Input::RIGHT)
      return if @data[@index] == nil
      card_list = @data[@index][1]
      return if card_list.size <= 1
      @data[@index][0] = @data[@index][0] + 1
      if @data[@index][0] >= @data[@index][1].size
        @data[@index][0] = 0
      end
      Audio.se_play(@soundmovecard,85)
      drawcontentwin1(true,last_index)
      ima = @cardpreview
      card = @data[@index][1][@data[@index][0]].dup
      @animatecardsflip = [[[ima,0,card,0],-1,0]]
      bak_fast_mode = @fastmode
      @fastmode = false
      createcardpreview(true)
      flipcardsfrontnew
      @fastmode = bak_fast_mode
      return
    end
    # Izquierda
    if Input.repeat?(Input::LEFT)
      return if @data[@index] == nil
      card_list = @data[@index][1]
      return if card_list.size <= 1
      @data[@index][0] = @data[@index][0] - 1
      if @data[@index][0] < 0
        @data[@index][0] = @data[@index][1].size - 1
      end
      Audio.se_play(@soundmovecard,85)
      drawcontentwin1(true,last_index)
      ima = @cardpreview
      card = @data[@index][1][@data[@index][0]].dup
      @animatecardsflip = [[[ima,0,card,0],1,0]]
      bak_fast_mode = @fastmode
      @fastmode = false
      createcardpreview(true)
      flipcardsfrontnew
      @fastmode = bak_fast_mode
      return
    end
    # Aceptar (Seleccionar carta)
    if Input.trigger?(Input::C)
      return if @playerdeck.size == 5
      return if @data[@index] == nil
      return if @data[@index][1].size - @data[@index][2] <= 0
      Audio.se_play(@soundmovecard,100)
      @cardpreview.y = 160
      ima = Sprite.new
      ima.x = @cardpreview.x
      ima.y = @cardpreview.y
      ima.bitmap = @cardpreview.bitmap.dup
      ima.z = @playerdeck.size + 1
      card = @data[@index][1][@data[@index][0]].dup
      # [Copia de la imagen de la carta,frame de animación,carta,plus atk]....
      @playerdeck.push([ima,0,card,0])
      # .............................................................
      @data[@index][1].delete_at(@data[@index][0])
      @data[@index][0] = 0
      if @data[@index][1].size == 0
        @data.delete_at(@index)
        drawcontentwin1
      end
      rebuilddatawin1
      createcardpreview
      drawcontentwin1(true,last_index)
      if @playerdeck.size == 5
        @cursor.visible = false
        @selector1.visible = false
        @pagenumber.visible = false
        @help.visible = false
        while nowmovingini
          animatedeckini
          Graphics.update
          @win.opacity = @data_win.opacity -= 20
        end
        animatedeckini
        Graphics.update
        @cardpreview.bitmap.clear
        @win.visible = false
        @data_win.visible = false
        @begingame = true
      end
      return
    end
    # R (Desplazamiento página a la derecha)
    if Input.trigger?(Input::R)
      return if @maxpages == 1
      Audio.se_play(@soundcursor,85)
      @page += 1
      if @page == @maxpages
        @page = 0
        @index -= (17 * (@maxpages-1))
      else
        @index += 17
      end
      @data_win.ox = -112
      drawcontentwin1
      createcardpreview
      drawpageinwin1
      return
    end
    # L (Desplazamiento página a la izquierda)
    if Input.trigger?(Input::L)
      return if @maxpages == 1
      Audio.se_play(@soundcursor,85)
      @page -= 1
      if @page == -1
        @page = @maxpages-1
        @index += (17 * (@maxpages-1))
      else
        @index -= 17
      end
      @data_win.ox = 112
      drawcontentwin1
      createcardpreview
      drawpageinwin1
      return
    end
  end
  # ---------------------------------------------------------------------------
  def rebuilddatawin1
    # Al seleccionar las cartas manualmente antes de jugar aparece una ventana
    # de confirmación, si se decide cambiar las cartas seleccionadas, este
    # método se encarga de reconstruir la ventana de selección de cartas manual
    data = []
    @data.each do |item|
      if item[1] != []
        data.push(item)
      end
    end
    @data = data
    @totalcards = @data.size
    @maxpages = (@totalcards / 17) + (@totalcards % 17 != 0 ? 1 : 0)
    if @page == @maxpages
      @page -= 1
      @index -= 17
      drawcontentwin1
    end
    drawpageinwin1
  end
  # ---------------------------------------------------------------------------
  def nowmovingini
    # Este método se encarga de que las cartas no se muevan tras posicionarse
    # en el lugar donde deberían estar
    for i in 0...@playerdeck.size
      ima = @playerdeck[i][0]
      frame = @playerdeck[i][1]
      return true if frame <= @animatecardselection.size - 1 or
                     ima.y > 36 + (i * 74)
    end
    return false
  end
  # ---------------------------------------------------------------------------
  def animatecursor1
    # Animación del cursor 1
    return if @fase == 2
    @anicursor1 = 0 if @anicursor1 == @aniglobal.size
    @cursor.x += @aniglobal[@anicursor1]
    @anicursor1 += 1
    # Animar selector
    case @aniglobal[@anicursor1]
    when -1:
      @selector1.opacity -= 10
    when 1:
      @selector1.opacity += 10
    end
    if @begingame
      @selector1.visible = false
    else
      @data[@index] == nil ?
        @selector1.visible = false : @selector1.visible = true
    end
  end
  # ---------------------------------------------------------------------------
  def animatecursor2
    # Animación del cursor 2
    @anicursor2 = 0 if @anicursor2 == @aniglobal.size
    @cursor2.x += @aniglobal[@anicursor2]
    @anicursor2 += 1
  end
  # ---------------------------------------------------------------------------
  def animatedeckini(frame = 2)
    # Método que se encarga de posicionar las cartas en sus lugares correctos
    for i in 0...@playerdeck.size
      item = @playerdeck[i]
      ima = item[0]
      frame = item[1] + 1
      item[1] = frame
      if frame <= @animatecardselection.size - 1 and ima.y < 460
        ima.x += @animatecardselection[frame][0]
        ima.y += @animatecardselection[frame][1]
      else
        item[1] = @animatecardselection.size
        if ima.y > (36 + (i * 74)) + ((5-@playerdeck.size) * 74)
          ima.y -= 21
        else
          ima.y += frame
          if ima.y > (36 + (i * 74)) + ((5-@playerdeck.size) * 74)
            ima.y = (36 + (i * 74)) + ((5-@playerdeck.size) * 74)
          end
        end
      end
    end
    for i in 0...@enemydeck.size
      item = @enemydeck[i]
      ima = item[0]
      if ima.y > (36 + (i * 74)) + ((5-@enemydeck.size) * 74)
        ima.y -= 21
      else
        ima.y += frame
        if ima.y > (36 + (i * 74)) + ((5-@enemydeck.size) * 74)
          ima.y = (36 + (i * 74)) + ((5-@enemydeck.size) * 74)
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def movecardstodecks
    # Método que se encarga de mover una carta desde su posición en el tablero
    # hasta su posición original en su respectivo mazo de cartas
    deck1 = []
    deck2 = []
    for i in 0...5
      item = @playerdeck[i]
      item[1] = @animatecardselection.size
      item[3] = 0
      createcardpreview(false,false,item[2],true)
      item[0].bitmap = @cardpreview.bitmap.dup
      createcardpreview(false,false,item[2],true)
      ima = item[0]
      ima.z = i
      x = (527-ima.x) / 16
      y = 36 + (i * 74)
      deck1.push([x,(y-ima.y)/16,527,y])
      item = @enemydeck[i]
      item[3] = 0
      createcardpreview(false,false,item[2],true)
      item[0].bitmap = @cardpreview.bitmap.dup
      ima = item[0]
      ima.z = i
      x = (ima.x-20) / 16
      y = 36 + (i * 74)
      deck2.push([x,(y-ima.y)/16,20,y])
    end
    for n in 0...16
      Audio.se_play(@soundmovecard,85) if n % 3 == 0
      for i in 0...5
        item1 = @playerdeck[i]
        item2 = @enemydeck[i]
        ima1 = item1[0]
        ima2 = item2[0]
        ima1.x += deck1[i][0]
        ima2.x -= deck2[i][0]
        ima1.y += deck1[i][1]
        ima2.y += deck2[i][1]
      end
      animatetextaction
      Graphics.update
    end
    for i in 0...5
      item1 = @playerdeck[i]
      item2 = @enemydeck[i]
      ima1 = item1[0]
      ima2 = item2[0]
      ima1.x = deck1[i][2]
      ima2.x = deck2[i][2]
      ima1.y = deck1[i][3]
      ima2.y = deck2[i][3]
    end
    animatetextaction
    Graphics.update
  end
  # ---------------------------------------------------------------------------
  def animateselector2
    return if @selector2.bitmap == nil
    @selector2.bitmap.clear
    @selector2frame += 1
    @selector2frame = 0 if @selector2frame == 9
    @selector2.bitmap.blt(0,0,@anicursor2image,
    Rect.new(@selector2frame*39,0,39,18))
  end
  # ---------------------------------------------------------------------------
  def opendeckenemy?(animatemode = true)
    # ------------------------------------------------
    # Da la vuelta a todas las cartas del enemigo
    # Si la regla @reglaabierto está activada
    # ------------------------------------------------
    if @reglaabierto
      # ------------------------------------------------
      Audio.se_play(@soundmovecard,100)
      bitmapsnew = []
      @animatecardsflip = []
      @enemydeck.each do |item|
        card = item[2]
        createcardpreview(false,false,card,true)
        item[0].bitmap = @cardpreview.bitmap.dup
        item[0].visible = false
        bitmapsnew.push(item[0])
        @animatecardsflip.push([item,1,0])
        drawonlycardscolor(item[0],1)
      end
      @cardpreview.y = 560
      @cardpreview.visible = false
      @fase = -1
      @initializing = false
      flipcardsfrontnew
      @initializing = true
      bitmapsnew.each do |ima|
        #ima.dispose
      end
      @enemydeck.each do |item|
        item[0].visible = true
      end
      # ------------------------------------------------
    end
    # ------------------------------------------------
  end
  # ---------------------------------------------------------------------------
  def getenemycards
    # Construye el mazo de cartas que usará el enemigo en la batalla
    enemycards = $deck['enemy'][@enemyid].dup
    enemycards = enemycards.rsort # Desordenar lista
    stolencards = []
    owncards = []
    maxcards = 5
    allcardsinuse = false
    backmode = true
    # Separar cartas robadas de cartas propias
    enemycards.each do |cards|
      next if cards == nil
      cards.each do |card|
        if card[6] == 0
          stolencards.push(card.dup)
        else
          owncards.push(card.dup)
        end
      end
    end
    # Recorrer cada carta robada y comprobar si se va a jugar con ella
    for i in 0...stolencards.size
      card = stolencards[i]
      cardid = i
      atk_perc = ((card[3][0] + card[3][1] + card[3][2] + card[3][3]) * 2) +
               (card[4] == 1 ? 20 : 0)
      # atk será el porcentaje para usar esa carta en la batalla
      if rand(101) <= atk_perc
        createcardpreview(false,backmode,card,true)
        ima = Sprite.new
        ima.x = 20
        ima.y = 36 + (@enemydeck.size * 74) + (480 + (20 * @enemydeck.size))
        ima.bitmap = @cardpreview.bitmap.dup
        ima.z = @enemydeck.size
        # [Copia de la imagen de la carta,frame de animación,carta,plus atk]....
        @enemydeck.push([ima,0,card,0])
        #owncards.delete_at(cardid)
        if @enemydeck.size == 5
          allcardsinuse = true
          break
        end
      end
    end
    # Seleccionar aleatoriamente las demás cartas a jugar
    if allcardsinuse == false
      n = 5-@enemydeck.size
      for i in 0...n
        cardid = rand(owncards.size)
        card = owncards[cardid]
        createcardpreview(false,backmode,card,true)
        ima = Sprite.new
        ima.x = 20
        ima.y = 36 + (@enemydeck.size * 74) + (480 + (74 * @enemydeck.size))
        ima.bitmap = @cardpreview.bitmap.dup
        ima.z = @enemydeck.size
        # [Copia de la imagen de la carta,frame de animación,carta,plus atk]....
        @enemydeck.push([ima,0,card,0])
        owncards.delete_at(cardid)
        # .............................................................
      end
    end
  end
  # ---------------------------------------------------------------------------
  def getplayerdeck
    # Construye el mazo de cartas que usará el jugador cuando la regla Random
    # está activa
    playercards = $deck['player'].dup
    owncards = []
    maxcards = 5
    backmode = false
    # Crear un array con todas las cartas
    playercards.each do |cards|
      next if cards == nil
      cards.each do |card|
        owncards.push(card.dup)
      end
    end
    # Seleccionar aleatoriamente las cartas a jugar
    for i in 0...5
      cardid = rand(owncards.size)
      card = owncards[cardid]
      createcardpreview(false,backmode,card)
      ima = Sprite.new
      ima.x = 527
      ima.y = 36 + (@playerdeck.size * 74) + (480 + (74 * @playerdeck.size))
      ima.bitmap = @cardpreview.bitmap.dup
      ima.z = @playerdeck.size
      # [Copia de la imagen de la carta,frame de animación,carta,plus atk]....
      @playerdeck.push([ima,0,card,0])
      owncards.delete_at(cardid)
      # .............................................................
    end
  end
  # ---------------------------------------------------------------------------
  def getfirstturn(newgame = false)
    # Método que se encarga de establecer quién empezará jugando (Enemigo o Jugador)
    @index = 0
    @indexboardx = @indexboardy = 1
    bitmap1 = @anicursor2image2
    bitmap2 = @anicursor2image3
    @selector2.bitmap = Bitmap.new(18,39)
    @selector2.zoom_x = 2.3
    @selector2.zoom_y = 1.5
    @selector2.x = 290
    @selector2.y = 218
    turn = rand(2)
    frame = 0
    maxframes = 9
    maxloop = 15 + rand(15)
    maxloop += 1 if turn == 1 and maxloop % 2 == 0
    for i in 0...(maxloop)
      (i % 2 == 0 ? bitmap = bitmap1 : bitmap = bitmap2)
      @selector2.bitmap.clear
      @selector2.bitmap.blt(0,0,bitmap,Rect.new(0,frame*39,18,39))
      frame += 1 if i % 3 == 0
      frame = 0 if frame == maxframes
      Audio.se_play(@soundselectioninitialturnbegin,100) if i % 3 == 0
      Graphics.update
    end
    for i in 0...12
      (turn == 1 ? bitmap = bitmap1 : bitmap = bitmap2)
      @selector2.bitmap.clear
      @selector2.bitmap.blt(0,0,bitmap,Rect.new(0,frame*39,18,39))
      frame += 1 if i % 3 == 0
      frame = 0 if frame == maxframes
      Graphics.update
    end
    @selector2.bitmap = Bitmap.new(39,18)
    @selector2.bitmap.blt(0,0,@anicursor2image,
    Rect.new(@selector2frame*39,0,39,18))
    Audio.se_play(@soundselectioninitialturnend,100)
    for i in 0...10
      if turn == 0 # Turno del jugador
        @selector2.x += 26
      else # Turno Enemigo
        @selector2.x -= 25
      end
      @selector2.y -= (i * 10 + 19) - (5/3)
      @selector2.y = 17 if @selector2.y < 17
      @selector2.zoom_x -= 0.13
      @selector2.zoom_y -= 0.05
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      Graphics.update
    end
    for i in 0...2
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      Graphics.update
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      Graphics.update
    end
    if turn == 1
      @selector2.x += 6
      @fase = 1
    else
      @fase = 0
      poscursoroverplayerdeck if !newgame
    end
  end
  # ---------------------------------------------------------------------------
  def update_fase0
    # Turno Jugador (Seleccionar que carta se va a jugar)
    # (Fase 3 - Mostrar las reglas activa si se pulsa Y o Z)
    if Input.trigger?(Input::Y) or Input.trigger?(Input::Z)
      @backupfase = @fase
      @noselection = true
      drawwin0
      @noselection = nil
      @blackbackground = Sprite.new
      @blackbackground.bitmap = Bitmap.new(640,480)
      @blackbackground.bitmap.fill_rect(0,0,640,480,Color.new(0,0,0,180))
      @blackbackground.z = 15000
      @fase = 3
      return
    end
    if Input.press?(Input::DOWN)
      Audio.se_play(@soundmovecard,85)
      Audio.se_play(@soundcursor,85)
      lastindex = @index
      @playerdeck[lastindex][0].z = lastindex
      @index += 1
      @index = 0 if @index >= @playerdeck.size
      @playerdeck[@index][0].z = 10
      newy = 95 + (@index * 74) + ((5-@playerdeck.size)* 74)
      sum = ((newy - @cursor.y) / 2)
      for i in 0...2
        @playerdeck[lastindex][0].x += 17
        @playerdeck[@index][0].x -= 17
        @playerdeck[lastindex][0].y -= 6
        @playerdeck[@index][0].y += 6
        @cursor.y += sum
        @frameglobal += 1
        animateselector2 if @frameglobal % 3 == 0
        animatecursor1
        Graphics.update
      end
      @cursor.y = newy
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      animatecursor1
      draw_help_in_game
      Graphics.update
      return
    end
    if Input.press?(Input::UP)
      Audio.se_play(@soundmovecard,85)
      Audio.se_play(@soundcursor,85)
      lastindex = @index
      @playerdeck[lastindex][0].z = lastindex
      @index -= 1
      @index = @playerdeck.size - 1 if @index < 0
      @playerdeck[@index][0].z = 10
      newy = 95 + (@index * 74) + ((5-@playerdeck.size)* 74)
      sum = ((newy - @cursor.y) / 2)
      for i in 0...2
        @playerdeck[lastindex][0].x += 17
        @playerdeck[@index][0].x -= 17
        @playerdeck[lastindex][0].y -= 6
        @playerdeck[@index][0].y += 6
        @cursor.y += sum
        @frameglobal += 1
        animateselector2 if @frameglobal % 3 == 0
        animatecursor1
        Graphics.update
      end
      @cursor.y = newy
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      animatecursor1
      draw_help_in_game
      Graphics.update
      return
    end
    if Input.trigger?(Input::C)
      Audio.se_play(@soundcursor,85)
      @indexboardx = 1
      @indexboardy = 1
      @cursor2.x = @cursor.x
      @cursor2.y = @cursor.y
      @cursor.opacity = 160
      @cursor2.visible = true
      desx = ((177 + (@indexboardx * 98))  - @cursor2.x) / 3
      desy = ((77  + (@indexboardy * 132)) - @cursor2.y) / 3
      for i in 0...3
        @cursor2.x += desx
        @cursor2.y += desy
        animatetextaction
        Graphics.update
      end
      @cursor2.x = 177 + (@indexboardx * 98)
      @cursor2.y = 77  + (@indexboardy * 132)
      animatetextaction
      Graphics.update
      @fase = 2
    end
  end
  # ---------------------------------------------------------------------------
  def update_fase2
    # Turno Jugador (Seleccionar en que parte del tablero se va a posicionar
    # la carta seleccionada)
    # (Fase 3 - Mostrar las reglas activa si se pulsa Y o Z)
    if Input.trigger?(Input::Y) or Input.trigger?(Input::Z)
      @backupfase = @fase
      @noselection = true
      drawwin0
      @noselection = nil
      @blackbackground = Sprite.new
      @blackbackground.bitmap = Bitmap.new(640,480)
      @blackbackground.bitmap.fill_rect(0,0,640,480,Color.new(0,0,0,180))
      @blackbackground.z = 15000
      @fase = 3
      return
    end
    lastx = @indexboardx
    lasty = @indexboardy
    if Input.press?(Input::DOWN)  or Input.press?(Input::UP) or
       Input.press?(Input::RIGHT) or Input.press?(Input::LEFT)
      if Input.press?(Input::DOWN)
        @indexboardy += 1 if @indexboardy < 2
      end
      if Input.press?(Input::UP)
        @indexboardy -= 1 if @indexboardy > 0
      end
      if Input.press?(Input::LEFT)
        @indexboardx -= 1 if @indexboardx > 0
      end
      if Input.press?(Input::RIGHT)
        @indexboardx += 1 if @indexboardx < 2
      end
      if lastx != @indexboardx or lasty != @indexboardy
        Audio.se_play(@soundcursor,85)
        desx = ((177 + (@indexboardx * 98))  - @cursor2.x) / 2
        desy = ((77 +  (@indexboardy * 132)) - @cursor2.y) / 2
        for i in 0...2
          @cursor2.x += desx
          @cursor2.y += desy
          animatecursor1
          animatecursor2
          @frameglobal += 1
          animateselector2 if @frameglobal % 3 == 0
          Graphics.update
        end
        @cursor2.x = 177 + (@indexboardx * 98)
        @cursor2.y = 77  + (@indexboardy * 132)
        animatecursor1
        animatecursor2
        @frameglobal += 1
        animateselector2 if @frameglobal % 3 == 0
        animatetextaction
        Graphics.update
      end
      return
    end
    if Input.trigger?(Input::B) # Cancelar
      Audio.se_play(@soundcancel,100)
      desx = (@cursor.x  - @cursor2.x) / (8 - @index)
      desy = (@cursor.y  - @cursor2.y) / (8 - @index)
      for i in 0...(8 - @index)
        @cursor2.x += desx
        @cursor2.y += desy
        animatecursor1
        animatecursor2
        @frameglobal += 1
        animateselector2 if @frameglobal % 3 == 0
        animatetextaction
        Graphics.update
      end
      @cursor2.visible = false
      @cursor.opacity = 255
      @fase = 0
      return
    end
    if Input.trigger?(Input::C) # Seleccionar
      return if @boarddeck[@indexboardx][@indexboardy] != nil
      Audio.se_play(@soundcursor,85)
      @cursor.visible = false
      @cursor2.visible = false
      movecardtoboard(0)
      checkplay(0)
      if @endgame != true and !@newgame
        changeselector(0)
        @fase = 1
        draw_help_in_game
      end
      return
    end
  end
  # ---------------------------------------------------------------------------
  def update_fase3
    # Turno Jugador (Fase 3: Mostrando las reglas)
    if !Input.press?(Input::Y) and !Input.press?(Input::Z)
      @win0.dispose
      @blackbackground.dispose
      @fase = @backupfase
    end
  end
  # ---------------------------------------------------------------------------
  def update_fase1
    # Turno enemigo
    # ---------------------------------------------------
    # IA
    # ---------------------------------------------------
    level = rand(101)
    @indexani = nil
    if level <= (@enemylevel * 10)
      # Jugada simulada
      # .............................................................
      # Cálculo obsoleto para calcular el número de simulaciones
      # .............................................................
      #simulationnumber = [0,1,3,4,7,10,15,20,25,30,100]
      #maxsimulations = simulationnumber[@enemylevel] + @enemylevel
      # .............................................................
      # .............................................................
      # Cálculo actual de simulaciones
      # .............................................................
      l = @enemylevel
      maxsimulations = (l*l*3) - (2*l) # 1 mín, 280 máx
      # .............................................................
      if @enemydeck.size == 1
        @index = rand(@enemydeck.size)
        casillasjugables = checkcasillasjugables
        casilla = casillasjugables[rand(casillasjugables.size)]
        @indexboardx = casilla[0]
        @indexboardy = casilla[1]
      else
        maxsimulations = (@enemylevel * @enemylevel) + @enemylevel
        # ------------------------------------
        # Comenzar simulaciones
        @simulation = true
        ia(maxsimulations)
        @simulation = false
        # Finalizar simulación
        # ------------------------------------
      end
    else
      # Jugada aleatoria
      @index = rand(@enemydeck.size)
      casillasjugables = checkcasillasjugables
      casilla = casillasjugables[rand(casillasjugables.size)]
      @indexboardx = casilla[0]
      @indexboardy = casilla[1]
    end
    # ---------------------------------------------------
    # Animar deck
    # ---------------------------------------------------
    if @indexani == nil
      index = 0
      for i in 0...@enemydeck.size
        card = @enemydeck[i]
        card[0].x += 17
        card[0].y += 6
        card[0].z = 10
        Graphics.update
        waitsec(0.1)
        m = rand(10)
        n = rand(100)
        while n > 20 - m
          n = rand(100)
          animatetextaction
          @frameglobal += 1
          @frameglobal = 0 if @frameglobal >= 100
          animateselector2 if @frameglobal % 3 == 0
          Graphics.update
        end
        card[0].x -= 17
        card[0].y -= 6
        card[0].z = i
        index += 1
      end
      @indexani = index
    end
    index = @indexani
    while index != @index
      @index > index ? index += 1 : index -= 1
      card = @enemydeck[index]
      card[0].x += 17
      card[0].y += 6
      card[0].z = 10
      animatetextaction
      @frameglobal += 1
      @frameglobal = 0 if @frameglobal >= 100
      animateselector2 if @frameglobal % 3 == 0
      Graphics.update
      waitsec(0.1)
      card[0].x -= 17
      card[0].y -= 6
      card[0].z = index
    end
    waitsec(0.1)
    # ---------------------------------------------------
    # Finalizar el turno enemigo
    # ---------------------------------------------------
    Audio.se_play(@soundcursor,85)
    movecardtoboard(1)
    checkplay(1)
    if @endgame != true and !@newgame
      changeselector(1)
      @fase = 0
      poscursoroverplayerdeck
      draw_help_in_game
    end
    # ---------------------------------------------------
  end
  # ---------------------------------------------------------------------------
  def checkcasillasjugables
    # indica al enemigo que casillas están libres en el tablero
    casillasjugables = []
    for x in 0...3
      for y in 0...3
        if @boarddeck[x][y] == nil
          casillasjugables.push([x,y])
        end
      end
    end
    return casillasjugables
  end
  # ---------------------------------------------------------------------------
  def checkplay(type)
    # inicia la comprobación de reglas tras ser depositada una carta en el
    # tablero
    card = @boarddeck[@indexboardx][@indexboardy]
    atacante = card[2][5] # 0 = Jugador   1 = Enemigo
    power_atk = card[2][3].dup # Valores de ataque
    plus_atk = card[3] # Plus de ataque de la carta (según elemental)
    for i in 0...4
      power_atk[i] += plus_atk
      power_atk[i] = 1  if power_atk[i] < 1
      power_atk[i] = 10 if power_atk[i] > 10
    end
    @gaincards = []
    @chaincards = []
    @animatecardsflip = []
    cardsbattle = getcardsvs(atacante)
    check_atk(power_atk,atacante,cardsbattle) if cardsbattle.size > 0
    check_battle_result(atacante)
    @forzechain = true
    firstchain = true
    # ********************************************************************
    # Inicio Combo System
    # ********************************************************************
    while @chaincards.size > 0 and @reglacombo
      cards = @chaincards.dup
      @chaincards = []
      @gaincards = []
      combosoundoandtextoneonly = false
      cards.each do |item|
        card = item[0]
        x = item[1]
        y = item[2]
        @indexboardx = x
        @indexboardy = y
        cardsbattle = getcardsvs(atacante)
        power_atk = card[2][3].dup # Valores de ataque
        plus_atk = card[3] # Plus de ataque de la carta (según elemental)
        for i in 0...4
          power_atk[i] += plus_atk
          power_atk[i] = 1  if power_atk[i] < 1
          power_atk[i] = 10 if power_atk[i] > 10
        end
        checknormalatk(power_atk,cardsbattle)
      end
      if @gaincards.size > 0
        if !combosoundoandtextoneonly and !@simulation
          text = "#{@textos[0][6]}!"
          if firstchain
            Audio.se_play(@soundcombo,100)
            draw_text_action(text)
            firstchain = false
          else
            animatetextaction
            Audio.se_play(@soundcombo,100)
            draw_text_action(text)
          end
          combosoundoandtextoneonly = true
        end
        check_battle_result(atacante)
      else
        break
      end
      checknumbercardsindeck
    end
    @forzechain = false
    # ********************************************************************
    # Fin Combo System
    # ********************************************************************
    checknumbercardsindeck
    checkendgame
    return
  end
  # ---------------------------------------------------------------------------
  def getcardsvs(atacante)
    # Devuelve un array con las cartas a las que van a afectar las reglas
    cardsbattle = []
    if @indexboardx-1 >= 0
      x = @indexboardx-1
      y = @indexboardy
      if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
        own = @boarddeck[x][y][2][5]
        cardsbattle.push([@boarddeck[x][y],x,y]) if own != atacante
      end
    end
    if @indexboardx+1 <= 2
      x = @indexboardx+1
      y = @indexboardy
      if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
        own = @boarddeck[x][y][2][5]
        cardsbattle.push([@boarddeck[x][y],x,y]) if own != atacante
      end
    end
    if @indexboardy-1 >= 0
      x = @indexboardx
      y = @indexboardy-1
      if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
        own = @boarddeck[x][y][2][5]
        cardsbattle.push([@boarddeck[x][y],x,y]) if own != atacante
      end
    end
    if @indexboardy+1 <= 2
      x = @indexboardx
      y = @indexboardy+1
      if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
        own = @boarddeck[x][y][2][5]
        cardsbattle.push([@boarddeck[x][y],x,y]) if own != atacante
      end
    end
    return cardsbattle
  end
  # ---------------------------------------------------------------------------
  def check_atk(power_atk,atacante,cardsbattle)
    # Comprueba las diferentes reglas para ver si alguna/s de las cartas
    # afectadas pierde contra la carta atacante
    checkreglapared(power_atk,atacante)  if @reglapared
    checkreglaigual(power_atk,atacante)  if @reglaigual
    checkreglasuma(power_atk,atacante)   if @reglasuma
    checknormalatk(power_atk,cardsbattle)
  end
  # ---------------------------------------------------------------------------
  def check_battle_result(atacante)
    # Muestra un mensaje si alguna regla surtió efecto (pared, suma o igual)
    if !@simulation
      if @pared and @gaincards.size > 0
        if @samewall
          text = "#{@textos[0][5]}!"
          Audio.se_play(@soundpared,100)
        elsif @pluswall
          text = "#{@textos[0][4]}!"
          Audio.se_play(@soundpared,100)
        else
          text = nil
        end
        draw_text_action(text) if text != nil
      elsif @igual and @gaincards.size > 0
        text = "#{@textos[0][1]}!"
        Audio.se_play(@soundigual,100)
        draw_text_action(text)
      elsif @suma and @gaincards.size > 0
        text = "#{@textos[0][2]}!"
        Audio.se_play(@soundsuma,100)
        draw_text_action(text)
      end
    end
    # Si alguna carta se vio afectada, el método verifycheck se encargará
    # de cambiar la posesión de esa carta a su nuevo dueño, el atacante
    if @gaincards.size > 0
      Audio.se_play(@soundgaincards,100) if !@simulation
      verifycheck(atacante,@gaincards)
    end
    @pared = false
    @igual = false
    @suma = false
  end
  # ---------------------------------------------------------------------------
  def checkreglapared(atk,atacante)
    # La regla pared no toma en cuenta el modificador elemental
    @samewall = false
    @pluswall = false
    return if (@indexboardx == 1 and @indexboardy == 1)
    x = @indexboardx
    y = @indexboardy
    atk = @boarddeck[x][y][2][3]
    jugadas = {
    # pos => [[lugares con valor 10],[cartas enfrentadas]]
      '00' => [[0,1],[[[x+1,y],[2,1]],[[x,y+1],[3,0]]]],
      '01' => [[1],[[[x+1,y],[2,1]],[[x,y+1],[3,0]],[[x,y-1],[0,3]]]],
      '02' => [[1,3],[[[x+1,y],[2,1]],[[x,y-1],[0,3]]]],
      '10' => [[0],[[[x+1,y],[2,1]],[[x-1,y],[1,2]],[[x,y+1],[3,0]]]],
      '12' => [[3],[[[x+1,y],[2,1]],[[x-1,y],[1,2]],[[x,y-1],[0,3]]]],
      '20' => [[0,2],[[[x-1,y],[1,2]],[[x,y+1],[3,0]]]],
      '21' => [[2],[[[x-1,y],[1,2]],[[x,y-1],[0,3]],[[x,y+1],[3,0]]]],
      '22' => [[2,3],[[[x-1,y],[1,2]],[[x,y-1],[0,3]]]]
    }
    id = "#{x}#{y}"
    jugada = jugadas[id]
    jugada[1].each do |card|
      x = card[0][0]
      y = card[0][1]
      atkv = card[1][0]
      defv = card[1][1]
      next if @boarddeck[x][y] == nil or @boarddeck[x][y] == -1
      def_real = @boarddeck[x][y][2][3][defv] #+ @boarddeck[x][y][3]
      def_real = 10 if def_real > 10
      def_real = 1  if def_real < 1
      next if @boarddeck[x][y] == nil or @boarddeck[x][y] == -1
      next if @boarddeck[x][y][2][5] == atacante
      jugada[0].each do |value|
        if atk[value] == 10 and def_real == atk[atkv]
          if !@gaincards.include?(@boarddeck[x][y])
            @gaincards.push(@boarddeck[x][y])
          end
          if @usecombowithwall
            if !@chaincards.include?([@boarddeck[x][y],x,y])
              @chaincards.push([@boarddeck[x][y],x,y])
            end
            includeanimate = false
            @animatecardsflip.each do |item|
              arr = item[0]
              if arr == @boarddeck[x][y]
                includeanimate = true
                break
              end
            end
            if !includeanimate
              @animatecardsflip.push([@boarddeck[x][y],x,y,
              @indexboardx,@indexboardy])
            end
          end
          @pared = true
          @samewall = true
        elsif (atk[value] + 10) == (def_real + atk[atkv]) and @usepluswall
          if !@gaincards.include?(@boarddeck[x][y])
            @gaincards.push(@boarddeck[x][y])
          end
          if @usecombowithwall
            if !@chaincards.include?(@boarddeck[x][y])
              @chaincards.push([@boarddeck[x][y],x,y])
            end
            includeanimate = false
            @animatecardsflip.each do |item|
              arr = item[0]
              if arr == @boarddeck[x][y]
                includeanimate = true
                break
              end
            end
            if !includeanimate
              @animatecardsflip.push([@boarddeck[x][y],x,y,
              @indexboardx,@indexboardy])
            end
          end
          @pared = true
          @pluswall = true
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def checkreglaigual(atk,atacante)
    # La regla igual no toma en cuenta el modificador elemental
    x = @indexboardx
    y = @indexboardy
    atk = @boarddeck[x][y][2][3]
    jugadas = [
      #  [carta1,carta2,check1,check2]
      [[x,y-1],[x+1,y],[0,3],[2,1]],
      [[x,y-1],[x,y+1],[0,3],[3,0]],
      [[x,y-1],[x-1,y],[0,3],[1,2]],
      [[x+1,y],[x,y+1],[2,1],[3,0]],
      [[x+1,y],[x-1,y],[2,1],[1,2]],
      [[x-1,y],[x,y+1],[1,2],[3,0]]
    ]
    jugadas.each do |jugada|
      x1 = jugada[0][0]
      y1 = jugada[0][1]
      x2 = jugada[1][0]
      y2 = jugada[1][1]
      check1a = jugada[2][0]
      check1b = jugada[2][1]
      check2a = jugada[3][0]
      check2b = jugada[3][1]
      next if x1 < 0 or x1 > 2 or x2 < 0 or x2 > 2 or
              y1 < 0 or y1 > 2 or y2 < 0 or y2 > 2
      if @boarddeck[x1][y1] != nil and @boarddeck[x1][y1] != -1 and
         @boarddeck[x2][y2] != nil and @boarddeck[x2][y2] != -1
         if (@boarddeck[x1][y1][2][5] != atacante and
            @boarddeck[x2][y2][2][5] != atacante and !@checkallcards) or
            @checkallcards
            def1 = @boarddeck[x1][y1][2][3][check1b] #+ @boarddeck[x1][y1][3]
            def2 = @boarddeck[x2][y2][2][3][check2b] #+ @boarddeck[x2][y2][3]
            def1 = 10 if def1 > 10
            def1 = 1 if def1 < 1
            def2 = 10 if def2 > 10
            def2 = 1 if def2 < 1
            if def1 == atk[check1a] and
               def2 == atk[check2a]
               if @boarddeck[x1][y1][2][5] != atacante
                 if !@gaincards.include?(@boarddeck[x1][y1])
                  @gaincards.push(@boarddeck[x1][y1])
                 end
                 if !@chaincards.include?([@boarddeck[x1][y1],x1,y1])
                  @chaincards.push([@boarddeck[x1][y1],x1,y1])
                 end
               end
               if @boarddeck[x2][y2][2][5] != atacante
                 if !@gaincards.include?(@boarddeck[x2][y2])
                  @gaincards.push(@boarddeck[x2][y2])
                 end
                 if !@chaincards.include?([@boarddeck[x2][y2],x2,y2])
                  @chaincards.push([@boarddeck[x2][y2],x2,y2])
                 end
               end
              includeanimate = false
               @animatecardsflip.each do |item|
                 arr = item[0]
                 if arr == @boarddeck[x1][y1]
                    includeanimate = true
                    break
                 end
               end
               if !includeanimate and @boarddeck[x1][y1][2][5] != atacante
                  @animatecardsflip.push([@boarddeck[x1][y1],x1,y1,
                  @indexboardx,@indexboardy])
               end
               includeanimate = false
               @animatecardsflip.each do |item|
                 arr = item[0]
                 if arr == @boarddeck[x2][y2]
                   includeanimate = true
                   break
                 end
               end
               if !includeanimate and @boarddeck[x2][y2][2][5] != atacante
                 @animatecardsflip.push([@boarddeck[x2][y2],x2,y2,
                 @indexboardx,@indexboardy])
               end
               @igual = true
            end
         end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def checkreglasuma(atk,atacante)
    # La regla suma no toma en cuenta el modificador elemental
    x = @indexboardx
    y = @indexboardy
    atk = @boarddeck[x][y][2][3]
    jugadas = [
      #  [carta1,carta2,checkatk1,checkatk2]
      [[x,y-1],[x+1,y],[0,3],[2,1]],
      [[x,y-1],[x,y+1],[0,3],[3,0]],
      [[x,y-1],[x-1,y],[0,3],[1,2]],
      [[x+1,y],[x,y+1],[2,1],[3,0]],
      [[x+1,y],[x-1,y],[2,1],[1,2]],
      [[x-1,y],[x,y+1],[1,2],[3,0]]
    ]
    jugadas.each do |jugada|
      x1 = jugada[0][0]
      y1 = jugada[0][1]
      x2 = jugada[1][0]
      y2 = jugada[1][1]
      check1a = jugada[2][0]
      check1b = jugada[2][1]
      check2a = jugada[3][0]
      check2b = jugada[3][1]
      next if x1 < 0 or x1 > 2 or x2 < 0 or x2 > 2 or
              y1 < 0 or y1 > 2 or y2 < 0 or y2 > 2
      if @boarddeck[x1][y1] != nil and @boarddeck[x1][y1] != -1 and
         @boarddeck[x2][y2] != nil and @boarddeck[x2][y2] != -1
         if (@boarddeck[x1][y1][2][5] != atacante and
            @boarddeck[x2][y2][2][5] != atacante and !@checkallcards) or
            @checkallcards
            def1 = @boarddeck[x1][y1][2][3][check1b] #+ @boarddeck[x1][y1][3]
            def2 = @boarddeck[x2][y2][2][3][check2b] #+ @boarddeck[x2][y2][3]
            def1 = 10 if def1 > 10
            def1 = 1 if def1 < 1
            def2 = 10 if def2 > 10
            def2 = 1 if def2 < 1
            if def1 + atk[check1a] == def2 + atk[check2a]
               if @boarddeck[x1][y1][2][5] != atacante
                 if !@gaincards.include?(@boarddeck[x1][y1])
                  @gaincards.push(@boarddeck[x1][y1])
                 end
                 if !@chaincards.include?([@boarddeck[x1][y1],x1,y1])
                  @chaincards.push([@boarddeck[x1][y1],x1,y1])
                 end
               end
               if @boarddeck[x2][y2][2][5] != atacante
                 if !@gaincards.include?(@boarddeck[x2][y2])
                  @gaincards.push(@boarddeck[x2][y2])
                 end
                 if !@chaincards.include?([@boarddeck[x2][y2],x2,y2])
                  @chaincards.push([@boarddeck[x2][y2],x2,y2])
                 end
               end
               includeanimate = false
               @animatecardsflip.each do |item|
                 arr = item[0]
                 if arr == @boarddeck[x1][y1]
                    includeanimate = true
                    break
                 end
               end
               if !includeanimate and @boarddeck[x1][y1][2][5] != atacante
                  @animatecardsflip.push([@boarddeck[x1][y1],x1,y1,
                  @indexboardx,@indexboardy])
               end
               includeanimate = false
               @animatecardsflip.each do |item|
                 arr = item[0]
                 if arr == @boarddeck[x2][y2]
                   includeanimate = true
                   break
                 end
               end
               if !includeanimate and @boarddeck[x2][y2][2][5] != atacante
                 @animatecardsflip.push([@boarddeck[x2][y2],x2,y2,
                 @indexboardx,@indexboardy])
               end
               @suma = true
            end
         end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def checknormalatk(atk,cards)
    # Ataque normal: toma en cuenta valores ataque y el modificador elemental
    cards.each do |card|
      power_atk = card[0][2][3].dup
      plus_atk = card[0][3] # Plus de ataque de la carta (según elemental)
      for i in 0...4
        power_atk[i] += plus_atk
        power_atk[i] = 1  if power_atk[i] < 1
        power_atk[i] = 10 if power_atk[i] > 10
      end
      if (card[1] == @indexboardx-1 and card[2] == @indexboardy and
        atk[1] > power_atk[2]) or
        (card[1] == @indexboardx+1 and card[2] == @indexboardy and
        atk[2] > power_atk[1]) or
        (card[1] == @indexboardx and card[2] == @indexboardy-1 and
        atk[0] > power_atk[3]) or
        (card[1] == @indexboardx and card[2] == @indexboardy+1 and
        atk[3] > power_atk[0])
        @gaincards.push(card[0]) if !@gaincards.include?(card[0])
        x = (card[1] != @indexboardx ? card[1] : @indexboardx)
        y = (card[2] != @indexboardy ? card[2] : @indexboardy)
        if @forzechain
          if !@chaincards.include?([card[0],x,y])
            @chaincards.push([card[0],x,y])
          end
        end
        includeanimate = false
        @animatecardsflip.each do |item|
          arr = item[0]
          if arr == card[0]
            includeanimate = true
            break
          end
        end
        if !includeanimate
          @animatecardsflip.push([card[0],x,y,@indexboardx,@indexboardy])
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def verifycheck(atacante,cards)
    # Método que se encarga de cambiar las cartas de propietario, las voltea
    # y les cambia elcolor
    imas = []
    cards.each do |item|
      item[2][5] = atacante
      id = item[2][0]
      @newplayerdeckbackup.each do |item2|
        id2 = item2[2][0]
        if id2 == id
          item2[2][5] = atacante
          break
        end
      end
      @newenemydeckbackup.each do |item2|
        id2 = item2[2][0]
        if id2 == id
          item2[2][5] = atacante
          break
        end
      end
      if !@simulation
        imas.push(item[0])
        item[0].visible = false
      end
    end
    if !@simulation
      Audio.se_play(@soundselectioninitialturnbegin,100)
      flipcardsback(1,imas,true,true)
      bitmapsnew = []
      cards.each do |item|
        card = item[2]
        drawonlycardscolor(item[0],atacante)
        bitmapsnew.push(item[0])
      end
      flipcardsfront(1,bitmapsnew,true,true)
      cards.each do |item|
        item[0].visible = true
      end
      drawelementalvals if @reglaelemental
    end
  end
  # ---------------------------------------------------------------------------
  def checkendgame
    # Método que se encarga de comprobar el estado actual del juego y
    # actua en consecuencia
    n = 0
    for x in 0...3
      for y in 0...3
        n += 1 if @boarddeck[x][y] != nil
      end
    end
    @newgame = false
    if n == 9 and !@simulation
      @helpingame.visible = false
      if @reglapago == 1
        text = @textos[4][17]
        @fase = -1
        @endgame = true
      elsif @playercardsgainingame == @enemycardsgainingame and @reglahastalamuerte
        Audio.se_play(@soundhastalamuerte,100)
        text = @textos[1][2]
        @newgame = true
      elsif @playercardsgainingame > @enemycardsgainingame
        text = @textos[4][1]
        @fase = -1
        @endgame = true
      elsif @playercardsgainingame == @enemycardsgainingame
        text = @textos[4][5]
        @fase = -1
        @endgame = true
        $deck['stats'][@enemyid]['drawgames'] += 1
        $deck['stats']['player']['drawgames'] += 1
      else
        text = @textos[4][2]
        @fase = -1
        @endgame = true
      end
      if @fase == -1
        Audio.bgm_play(@endmusic,85)
      end
      draw_text_action(text)
      waitsec(0.5)
      if @newgame
        @helpingame.visible = true
        beginnewgame
      end
    end
  end
  # ---------------------------------------------------------------------------
  def beginnewgame
    # Con la regla hasta la muerte activa y habiendo quedando el juego
    # en empate, este método se encarga de empezar un nuevo juego
    # Cada jugador empezará a jugar con las cartas de su color que tenía
    # al acabar la partida anterior
    for x in 0...3
      for y in 0...3
        if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
          own = @boarddeck[x][y][2][5]
          if own == 0
            @playerdeck.push(@boarddeck[x][y])
          else
            @enemydeck.push(@boarddeck[x][y])
          end
        end
      end
    end
    @boarddeck = [Array.new(3),Array.new(3),Array.new(3)]
    movecardstodecks # Mueve las cartas del tablero a los  mazos
                     # de cartas del jugadr y el enemigo
    getfirstturn # Establece el primer turno
    draw_help_in_game # Updatea la ayuda
  end
  # ---------------------------------------------------------------------------
  def changeselector(type)
    # Cambia el selector de turnos a la posición del jugador que tenga el turno
    x1 = 46
    x2 = 556
    desx = (type == 0 ? -51 : 51)
    Audio.se_play(@soundselectioninitialturnbegin,100)
    for i in 0...10
      @selector2.x += desx
      animatetextaction
      Graphics.update
    end
    @selector2.x = (type == 0 ? x1 : x2)
  end
  # ---------------------------------------------------------------------------
  def checknumbercardsindeck
    # método que se encarga de mostrar el número de cartas en posesión de cada
    # jugador durante la partida (el número de cartas de su color)
    @numbercardsplayer.bitmap.clear
    @numbercardsenemy.bitmap.clear
    playercardsinboard = 0
    enemycardsinboard = 0
    for x in 0...3
      for y in 0...3
        if @boarddeck[x][y] != nil and @boarddeck[x][y] != -1
          if @boarddeck[x][y][2][5] == 0
            playercardsinboard += 1
          else
            enemycardsinboard += 1
          end
        end
      end
    end
    n1 = (@playerdeck.size + playercardsinboard).to_s
    n2 = (@enemydeck.size + enemycardsinboard).to_s
    data_pos = [[1,0],[-1,0],[0,1],[0,-1],[2,0],[-2,0],[0,2],[0,-2]]
    @numbercardsplayer.bitmap.font.size = 64
    @numbercardsenemy.bitmap.font.size = 64
    @numbercardsplayer.bitmap.font.color = Color.new(0,0,0,255)
    @numbercardsenemy.bitmap.font.color = Color.new(0,0,0,255)
    for i in 0...data_pos.size
      x = 0 + data_pos[i][0]
      y = 0 + data_pos[i][1]
      @numbercardsplayer.bitmap.draw_text(x,y,58,72,n1,1)
      @numbercardsenemy.bitmap.draw_text(x,y,58,72,n2,1)
    end
    @numbercardsplayer.bitmap.font.color = Color.new(255,255,255,255)
    @numbercardsenemy.bitmap.font.color = Color.new(255,255,255,255)
    @numbercardsplayer.bitmap.draw_text(0,0,58,72,n1,1)
    @numbercardsenemy.bitmap.draw_text(0,0,58,72,n2,1)
    @playercardsgainingame = n1.to_i
    @enemycardsgainingame = n2.to_i
  end
  # ---------------------------------------------------------------------------
  def poscursoroverplayerdeck
    # Se encarga de posicionar el cursor sobre el mazo de cartas del jugador
    # cuando es su turno
    @index = 0
    for i in 0...2
      @playerdeck[0][0].x -= 17
      @playerdeck[0][0].y += 6
      @frameglobal += 1
      animateselector2 if @frameglobal % 3 == 0
      animatetextaction
      Graphics.update
    end
    @playerdeck[0][0].x += 1
    @playerdeck[0][0].z = 10
    @cursor.bitmap = Bitmap.new(@cursorbitmap)
    @cursor.visible = true
    @cursor.x = 465
    @cursor.y = 95 + ((5-@playerdeck.size)* 74)
    @cursor2.bitmap = @cursor.bitmap
    @cursor2.visible = false
    @cursor.opacity = 255
  end
  # ---------------------------------------------------------------------------
  def movecardtoboard(type)
    # Método que se encarga de mover una carta desde su posición original
    # hasta el lugar designado en el tablero
    type == 0 ? deck = @playerdeck : deck = @enemydeck
    @cardpreview.bitmap = deck[@index][0].bitmap
    @cardpreview.x = deck[@index][0].x
    @cardpreview.y = deck[@index][0].y
    @cardpreview.z = 100
    @cardpreview.opacity = 255
    @cardpreview.visible = true
    x = 10
    @cardpreview.zoom_x = @cardpreview.zoom_y = 1.0
    card = deck[@index].dup
    s = Sprite.new
    s.bitmap = deck[@index][0].bitmap.dup
    s.visible = false
    card[0] = s
    deck[@index][0].dispose
    deck.delete_at(@index)
    Audio.se_play(@soundmovecard,85)
    for i in 0...9
      @cardpreview.x -= (type == 0 ? x : -x)
      @cardpreview.y -= 60 + ((5-deck.size)*15) + (@index * 15)
      @cardpreview.zoom_x += 0.14
      @cardpreview.zoom_y = @cardpreview.zoom_x
      @frameglobal += 1
      @frameglobal = 0 if @frameglobal >= 100
      animateselector2 if @frameglobal % 3 == 0
      animatedeckini(1)
      Graphics.update
      @frameglobal += 1
      @frameglobal = 0 if @frameglobal >= 100
      animateselector2 if @frameglobal % 3 == 0
      animatetextaction
      Graphics.update
    end
    if (type != 0 and @reglaabierto == false) or @reglaelemental
      x = @cardpreview.x
      y = @cardpreview.y
      createcardpreview(false,false,card[2],true)
      @cardpreview.x = x
      @cardpreview.y = y
      @cardpreview.opacity = 255
      card[0].bitmap = @cardpreview.bitmap.dup
    end
    desx = 179 + (@indexboardx * 98)
    desy = 47  + (@indexboardy * 132)
    movx = (desx-@cardpreview.x) / 16
    movy = (desy-@cardpreview.y) / 16
    s = Sprite.new
    s.bitmap = Bitmap.new(@cardpreview.bitmap.width,@cardpreview.bitmap.height)
    shadow = Bitmap.new(@cardshadow)
    s.bitmap.stretch_blt(s.bitmap.rect,shadow,shadow.rect)
    s.zoom_x = s.zoom_y = 0.2
    s.x = desx + (type == 0 ? 208 : -98)
    s.y = desy + (type == 0 ? 132 : -132)
    s.opacity = 20
    s.z = 99
    for i in 0...16
      @cardpreview.x += movx
      @cardpreview.y += movy
      @cardpreview.zoom_x -= 0.0875
      @cardpreview.zoom_y = @cardpreview.zoom_x
      if @cardpreview.zoom_x < 1
        @cardpreview.zoom_x = @cardpreview.zoom_y = 1.0
      end
      if i % 2 == 0
        s.zoom_x += 0.1
        s.zoom_y += 0.1
      end
      s.x += (type == 0 ? -13 : 6)
      s.y += (type == 0 ? -8 : 8)
      s.opacity += 14
      @frameglobal += 1
      @frameglobal = 0 if @frameglobal >= 100
      animateselector2 if @frameglobal % 3 == 0
      animatetextaction
      Graphics.update
    end
    @cardpreview.x = desx
    @cardpreview.y = desy
    animatetextaction
    Graphics.update
    Audio.se_play(@soundmovecardoverdeck,85)
    if @reglaelemental
      card_element = card[2][2]
      if @reglaelemental and @boardelemental[@indexboardx][@indexboardy] != nil
        if @boardelemental[@indexboardx][@indexboardy] == card_element
          card[3] = 1
          r = 0
          g = 20
          Audio.se_play(@sounddowngradecard,100)
        else
          card[3] = -1
          r = 20
          g = 0
          Audio.se_play(@soundupgradecard,100)
        end
        for i in 0...10
          tone = Tone.new(r+(r*i),g+(g*i),0,160)
          @cardpreview.tone = tone
          @frameglobal += 1
          @frameglobal = 0 if @frameglobal >= 100
          animateselector2 if @frameglobal % 3 == 0
          animatetextaction
          Graphics.update
        end
        @cardpreview.tone = Tone.new(0,0,0,0)
      end
    end
    @boarddeck[@indexboardx][@indexboardy] = card
    drawelementalvals if @reglaelemental
    @cardpreview.visible = false
    card[0].x = @cardpreview.x
    card[0].y = @cardpreview.y
    card[0].visible = true
    s.dispose
  end
  # ---------------------------------------------------------------------------
  def iselementalgame?
    # Si la regla elemental está activa, este método distribuirá aleatoriamente
    # elementos por las casillas del tablero
    perc = 100 # Porcentaje de que la casilla sea elemental
    # El porcentaje de que una casilla sea elemental
    # será el porcentaje real (perc) menos el porcentaje
    # resto (perc_rest) por el número de casillas elementales
    # (Mínimo : 1 Casilla Elemental   Máximo: 9 Casillas Elementales)
    perc_rest = rand(25)
    casillaselementales = 0
    if @reglaelemental
      for i in 0...9
        n = rand(100)
        if n <= perc
          x = rand(3)
          y = rand(3)
          while @boardelemental[x][y] != nil
            x = rand(3)
            y = rand(3)
          end
          @boardelemental[x][y] = @elementallist[rand(@elementallist.size)]
          casillaselementales += 1
          perc -= (perc_rest * casillaselementales)
        end
      end
    end
    for x in 0...3
      for y in 0...3
        if @boardelemental[x][y] != nil
          imaname = @elementalimagelist[@boardelemental[x][y]]
          s = Sprite.new
          s.bitmap = Bitmap.new(imaname)
          s.x = 203 + (x * 98)
          s.y = 90 + (y * 132)
          s.z = -1
          @boardelementalima[x][y] = s
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def draw_help_in_game
    # Dibuja la ayuda mientars se está jugando
    if @helpingame == nil
      @helpingame = Sprite.new
      @helpingame.x = 220
      @helpingame.y = 426
      @helpingame.z = 10000
    end
    @helpingame.bitmap = Bitmap.new(@winhelpcardsbitmap2)
    @helpingame.bitmap.font.size = 21
    text = ""
    case @fase
    when 0 # Turno del jugador
      if @playerdeck[@index] == nil
        if @playerdeck[0] == nil
          return
        else
          data = @playerdeck[0][2]
        end
      else
        data = @playerdeck[@index][2]
      end
      name = data[1]
      uniq = data[4]
      text = name.to_s
      color = (uniq == 1 ? 2 : 1)
    when 1 # Turno del Enemigo
      text = @textos[4][23]
      color = 1
    end
    color1 = Color.new(0,0,0,255)
    color2 = Color.new(255,255,255,255)
    color3 = Color.new(229,197,46,255)
    data_pos = [[1,0],[-1,0],[0,1],[0,-1],[0,2]]
    @helpingame.bitmap.font.color = color1
    for i in 0...data_pos.size
      x = 4 + data_pos[i][0]
      y = 17 + data_pos[i][1]
      @helpingame.bitmap.draw_text(x,y,226,20,text,1)
    end
    @helpingame.bitmap.font.color = (color == 1 ? color2 : color3)
    @helpingame.bitmap.draw_text(4,17,226,23,text,1)
  end
  # ---------------------------------------------------------------------------
  def draw_text_action(text = "",noanimate = false)
    # Dibuja un texto animado (Generalmente dibuja las palabras Combo,Suma...)
    return if text == nil or text == ""
    b = Bitmap.new(1,1)
    b.font.size = 68
    w = b.text_size(text).width + 3
    h = b.text_size(text).height + 3
    text = text.split(" ")
    w += text.size * 10
    w_real = w
    if @textaction != nil
      @textaction.bitmap.clear
    end
    @textaction = Sprite.new
    @textaction.bitmap = Bitmap.new(w,h)
    @textaction.bitmap.font.size = 68
    @textaction.x = 640
    @textaction.y = 240 - (h/2)
    @textaction.z = 10000
    x = 0
    y = 0
    data_pos1 = [[1,0],[-1,0],[0,-1],[0,1],[2,0],[-2,0],[0,-2],[0,2]]
    data_pos2 = [[3,0],[-3,0],[0,-3],[0,3],[4,3],[-4,3],[3,-4],[3,4]]
    text.each do |word|
      text1 = word[0,1].upcase
      text2 = word[1,word.size].downcase
      w = @textaction.bitmap.text_size(text1).width
      @textaction.bitmap.font.italic = false
      @textaction.bitmap.font.color = Color.new(0,0,0,255)
      for i in 0...data_pos2.size
        x1 = x + data_pos2[i][0]
        y1 = y + data_pos2[i][1]
        @textaction.bitmap.draw_text(x1,y1,w,h,text1,1)
      end
      @textaction.bitmap.font.color = Color.new(255,255,255,255)
      for i in 0...data_pos1.size
        x1 = x + data_pos1[i][0]
        y1 = y + data_pos1[i][1]
        @textaction.bitmap.draw_text(x1,y1,w,h,text1,1)
      end
      r = rand(100) + 70
      g = rand(100) + 70
      b = rand(100) + 70
      @textaction.bitmap.font.color = Color.new(r,g,b,255)
      @textaction.bitmap.draw_text(x,y,w,h,text1,1)
      x += w
      if word.size == 1
        x += 10
        next
      end
      @textaction.bitmap.font.italic = true
      w = @textaction.bitmap.text_size(text2).width
      h = @textaction.bitmap.text_size(text2).height
      @textaction.bitmap.font.color = Color.new(0,0,0,255)
      for i in 0...data_pos2.size
        x1 = x + data_pos2[i][0]
        y1 = y + data_pos2[i][1]
        @textaction.bitmap.draw_text(x1,y1,w,h,text2,0)
      end
      @textaction.bitmap.font.color = Color.new(255,255,255,255)
      for i in 0...data_pos1.size
        x1 = x + data_pos1[i][0]
        y1 = y + data_pos1[i][1]
        @textaction.bitmap.draw_text(x1,y1,w,h,text2,0)
      end
      @textaction.bitmap.font.color = Color.new(112,128,154,255)
      @textaction.bitmap.draw_text(x,y,w,h,text2,0)
      x += w + 10
   end
   des = (((320 - (w_real/2)) - 40) - 640) / 9
   if !noanimate
     for i in 0...9
       @textaction.x += des
       @frameglobal += 1
       @frameglobal = 0 if @frameglobal >= 100
       animateselector2 if @frameglobal % 3 == 0
       Graphics.update
     end
     @textaction.x = 320 - (w_real/2)
     Graphics.update
     waitsec(0.2)
   else
     @textaction.x = 320 - (w_real/2)
     waitsec(0.1)
   end
  end
  # ---------------------------------------------------------------------------
  def begin_fase_pago
    # Al terminar la partida este método se encarga de establecer al ganador,
    # el número de cartas ganadas, las cartas ganadas (en caso de que el
    # ganador sea el enemigo o la cantidad de cartas ganadas sea 5)
    Graphics.freeze
    # Ocultar algunos gráficos
    @numbercardsplayer.visible = false
    @numbercardsenemy.visible = false
    @cursor.visible = false
    @selector2.visible = false
    if @textaction != nil
      @textaction.visible = false
    end
    if @reglaelemental
      for x in 0...3
        for y in 0...3
          if @boardelementalima[x][y].is_a?(Sprite)
            @boardelementalima[x][y].visible = false
          end
        end
      end
    end
    # reconstruir los decks
    # ** Nuevo Modo **
    for x in 0...3
      for y in 0...3
        card =  @boarddeck[x][y]
        next if card == nil or card == -1
        card[0].dispose
      end
    end
    @playerdeck.each do |item|
      item[0].dispose
    end
    @enemydeck.each do |item|
      item[0].dispose
    end
    @playerdeck = @newplayerdeckbackup.dup
    @enemydeck = @newenemydeckbackup.dup
    # ** Fin Nuevo Modo **
    # Posicionar las cartas antes de animar
    for i in 0...@playerdeck.size
      item = @playerdeck[i]
      item[0].x = 575
      item[0].y = 269
      item[0].z = 5-i
      # Reconstruir la carta original y su color # modo antiguo
      #createcardpreview(false,false,item[2],true,0)
      #item[0].bitmap = @cardpreview.bitmap.dup
    end
    for i in 0...@enemydeck.size
      item = @enemydeck[i]
      item[0].x = -43
      item[0].y = 95
      item[0].z = 5-i
      # Reconstruir la carta original y su color # modo antiguo
      createcardpreview(false,false,item[2],true,1)
      item[0].bitmap = @cardpreview.bitmap.dup
    end
    # Poner el nuevo fondo
    @tablero.bitmap = Bitmap.new(@backgroundimage2)
    # Ejecutar transision
    Graphics.transition(20)
    # animar cartas
    maxX = []
    for i in 0...5
      maxX[i] = 51 + (i * 111)
    end
    for n in 0...8
      for i in 0...5
        next if @playerdeck[i] == nil
        @playerdeck[i][0].x -= maxX[i] / 8
        next if @enemydeck[i] == nil
        @enemydeck[i][0].x += maxX[i] / 8
      end
      Graphics.update
    end
    for i in 0...5
      next if @playerdeck[i] == nil
      @playerdeck[i][0].x -= 40
      next if @enemydeck[i] == nil
      @enemydeck[i][0].x += 40
      Graphics.update
    end
    # Re-ordenar los decks para que coincidan con la posición de las cartas
    @playerdeck = @playerdeck.reverse
    # Determinar quien es el vencedor
    if @playercardsgainingame > @enemycardsgainingame
      @winner = 0
    else
      @winner = 1
    end
    # Actualizar estadísticas del enemigo (1 de 2)
    if @playercardsgainingame == @enemycardsgainingame
      $deck['stats'][@enemyid]['drawgames'] += 1
      $deck['stats']['player']['drawgames'] += 1
    elsif @winner == 0
      $deck['stats'][@enemyid]['lostgames'] += 1
      $deck['stats']['player']['wingames'] += 1
    else
      $deck['stats'][@enemyid]['wingames'] += 1
      $deck['stats']['player']['lostgames'] += 1
    end
    # Determinar que hacer en función del método de pago activo
    if @reglapago == 0 or @reglapago == 2 or @reglapago == 3
      # Determinar Cuántas cartas tienes que coger del rival
      if @reglapago == 0 # Una sola carta
        @maxgetcards = 1
      elsif @reglapago == 3 # Todas las cartas para el ganador
        @maxgetcards = 5
      else # Diferencia
        if @winner == 0
          # El jugador ha ganado
          @maxgetcards = @playercardsgainingame - @enemycardsgainingame
        else
          # El enemigo ha ganado
          @maxgetcards = @enemycardsgainingame - @playercardsgainingame
        end
      end
      @maxgetcards = 5 if @maxgetcards > 5
      @maxgetcards = 1 if @maxgetcards < 1
      if @winner == 1 # Enemigo = Ganador
        # Determinar que cartas se va a quedar el enemigo
        # (Siempre se quedará las mejores al menos que tenga definidas
        # una o más cartas preferidas, en cuyo caso primero se quedaría
        # con estas si estuvieran presentes y después escogería el resto
        # de entre las disponibles)
        @enemydeck.each do |item|
          item[2][5] = 1 # Cambia el color de las cartas a color enemigo
        end
        @playerdeck.each do |item|
          item[2][5] = 0 # Cambia el color de las cartas a color jugador
        end
        cards = []
        n = @maxgetcards
        deckbackup = @playerdeck.dup
        # loop para determinar que carta es mejor basado en sus ataques
        while n > 0
          bestcard = []
          for i in 0...deckbackup.size
            item = deckbackup[i]
            # Comprobar si la carta es una de sus preferidas.
            itemid = item[2][0].split('_')[0]
            breakloop = false
            if @preferredenemycards != nil and @preferredenemycards != []
              @preferredenemycards.each do |preferredcardid|
                if preferredcardid.to_i == itemid.to_i
                  bestcard = [0,item]
                  breakloop = true
                  break
                end
              end
            end
            break if breakloop
            # Si la carta no es una de sus preferidas mirar su ataque para
            # saber si se va a quedar con ella o no.
            atk = ((item[2][3][0] + item[2][3][1] + item[2][3][2] +
                  item[2][3][3]) * 2) + (item[2][4] == 1 ? 20 : 0)
            if bestcard == []
              bestcard = [atk,item]
            else
              if bestcard[0] < atk
                bestcard = [atk,item]
              end
            end
          end
          cards.push(bestcard[1])
          deckbackup.delete(bestcard[1])
          n -= 1
        end
        cards.each do |item|
          item[2][5] = 1 # Cambiar el color a color del enemigo
        end
        getcardsbycolor # Efectiar pago
        waitsec(0.2)
      elsif @maxgetcards == 5 # Ganador = Jugador > Todas las cartas
        @fase = 100
        @enemydeck.each do |item|
          item[2][5] = 0 # Cambia el color de las cartas a color jugador
        end
        @playerdeck.each do |item|
          item[2][5] = 0 # Cambia el color de las cartas a color jugador
        end
        getcardsbycolor # Efectiar pago
        waitsec(0.2)
        @fase = 100
      else # Ganador = Jugador > n cartas (n = @maxgetcards), Selección Manual
        # Empezar el loop para que el jugador coja las cartas que quiera
        @backupmaxgetcards = @maxgetcards
        @cursor.visible = true
        @cursor.opacity = 255
        @cursor.x = 25
        @cursor.y = 119
        @index = 0
        @fase = 10
        draw_last_help
        draw_last_help_complement
      end
    elsif @reglapago == 1 # Aplicar la regla directo
      sum1 = 0
      sum2 = 0
      for x in 0...3
        for y in 0...3
          card =  @boarddeck[x][y]
          next if card == nil or card == -1
          cardid = card[2][0]
          cardcolor = card[2][5]
          cardcolor == 0 ? sum1 += 1 : sum2 += 1
          for i in 0...@playerdeck.size
            itemid = @playerdeck[i][2][0]
            @playerdeck[i][2][5] == cardcolor if itemid == cardid
          end
          for i in 0...@enemydeck.size
            itemid = @enemydeck[i][2][0]
            @enemydeck[i][2][5] == cardcolor if itemid == cardid
          end
        end
      end
      getcardsbycolor # Efectuar pago
      waitsec(0.2)
      @fase = 100
    end
  end
  # ---------------------------------------------------------------------------
  def getcardsbycolor
    # Según las cartas elegidas por el ganador, éste método se encarga de
    # animarlas volteándolas y cambiándole el color
    cards = []
    @fastmode = false
    @indexboardx = @indexboardy = 0
    @boarddeck[0][0] = nil
    @animatecardsflip = []
    for i in 0...5
      next if @playerdeck[i] == nil or @enemydeck[i] == nil
      cardcolor1 = @playerdeck[i][2][5]
      cardcolor2 = @enemydeck[i][2][5]
      if cardcolor1 == 1 or cardcolor2 == 0
        Audio.se_play(@soundmovecard,85)
        if cardcolor1 == 1
          @playerdeck[i][0].y = 249
          @playerdeck[i][0].opacity = 255
          cards.push([@playerdeck[i],1,0])
        else
          @playerdeck[i][0].opacity = 120
        end
        if cardcolor2 == 0
          @enemydeck[i][0].y = 75
          @enemydeck[i][0].opacity = 255
          cards.push([@enemydeck[i],0,0])
        else
          @enemydeck[i][0].opacity = 120
        end
      end
    end
    for i in 0...5
      next if @playerdeck[i] == nil or @enemydeck[i] == nil
      @enemydeck[i][0].opacity = 120 if @enemydeck[i][0].y != 75
      @playerdeck[i][0].opacity = 120 if @playerdeck[i][0].y != 249
    end
    for i in 0...cards.size
      cards[i][0][0].visible = false
      @animatecardsflip.push([cards[i][0],1,0])
    end
    Audio.se_play(@soundgaincards,85)
    flipcardsbacknew
    for i in 0...cards.size
      drawonlycardscolor(cards[i][0][0],cards[i][1])
      cards[i][0][2][5] = cards[i][1]
    end
    flipcardsfrontnew
    for i in 0...cards.size
      cards[i][0][0].visible = true
    end
    draw_last_window
  end
  # ---------------------------------------------------------------------------
  def draw_last_help
    # Dibjula la ayuda en la fase final (selección de cartas del ganador)
    if @lastwin != nil
      @lastwin.bitmap.clear
    else
      @lastwin = Sprite.new
      @lastwin.y = 5
    end
    text1 = @textos[4][9]
    text2 = @textos[4][10]
    text3 = @maxgetcards != 1 ? 's' : ''
    text = "#{text1} #{@maxgetcards} #{text2}#{text3}"
    bitmap = Bitmap.new(1,1)
    bitmap.font.size = 22
    w = bitmap.text_size(text).width + 60
    @lastwin.bitmap = Bitmap.new(w,46)
    win = Bitmap.new(@winhelpcardsbitmap2)
    mod_pos = [[1,0],[-1,0],[0,-1],[0,1],[2,0],[-2,0],[0,-2],[0,2]]
    @lastwin.bitmap.font.size = 22
    @lastwin.bitmap.stretch_blt(@lastwin.bitmap.rect,win,win.rect)
    @lastwin.bitmap.font.color = Color.new(0,0,0,255)
    for i in 0...mod_pos.size
      x = 0 + mod_pos[i][0]
      y = 0 + mod_pos[i][1]
      @lastwin.bitmap.draw_text(x,y,w,46,text,1)
    end
    @lastwin.bitmap.font.color = Color.new(255,255,255,255)
    @lastwin.bitmap.draw_text(0,0,w,46,text,1)
    @lastwin.x = 320 - (@lastwin.bitmap.width / 2)
    @lastwin.visible = true
  end
  # ---------------------------------------------------------------------------
  def draw_last_help_complement
    # Complemento para la ayuda anterior (draw_last_help) Se encarga de dibujar
    # una segunda ayuda (Abajo del todo) Indicando al jugador si la carta
    # que tiene seleccionada ya está en su colección o no
    # ---------
    if @last_help_complement == nil
      @last_help_complement = Sprite.new
      @last_help_complement.x = 115
      @last_help_complement.y = 420
      @last_help_complement.z = 10000
    end
    # ---------
    color1 = Color.new(0,0,0,255)
    color2 = Color.new(255,255,255,255)
    color3 = Color.new(229,197,46,255)
    color4 = Color.new(244,72,72,255)
    color5 = Color.new(80,227,8,255)
    data_pos = [[1,0],[-1,0],[0,1],[0,-1],[0,2]]
    # ---------
    text1 = @textos[4][24] # Carta única
    text2 = @textos[4][25] # Ya posees la carta
    text3 = @textos[4][26] # Aún no posees la carta
    data = @enemydeck[@index][2]
    name = data[1]
    uniq = data[4]
    if uniq == 1
      texto1 = "#{name} (#{text1})"
      colora = color3
    else
      texto1 = "#{name}"
      colora = color2
    end
    if check_card_in_deck_player
      texto2 = " «#{text2}»"
      colorb = color5
    else
      texto2 = " «#{text3}»"
      colorb = color4
    end
    # ---------
    @last_help_complement.bitmap = Bitmap.new(@winhelpcardsbitmap1)
    @last_help_complement.bitmap.font.size = 19
    @last_help_complement.bitmap.font.color = color1
    for i in 0...data_pos.size
      x = 7 + data_pos[i][0]
      y = 5 + data_pos[i][1]
      @last_help_complement.bitmap.draw_text(x,y,399,20,texto1)
      @last_help_complement.bitmap.draw_text(x+3,y+20,399,20,texto2)
    end
    @last_help_complement.bitmap.font.color = colora
    @last_help_complement.bitmap.draw_text(7,5,399,23,texto1)
    @last_help_complement.bitmap.font.color = colorb
    @last_help_complement.bitmap.draw_text(10,25,399,23,texto2)
    # ---------
  end
  # ---------------------------------------------------------------------------
  def check_card_in_deck_player
    # Comprueba si la carta seleccionada del enemigo está ya incluida en la
    # colección del jugador (usado por draw_last_help_complement)
    data = @enemydeck[@index][2]
    id = (@enemydeck[@index][2][0].split("_"))[0].to_i
    if $deck['player'][id] != nil
      if $deck['player'][id] != []
        return true
      else
        return false
      end
    end
    return false
  end
  # ---------------------------------------------------------------------------
  def draw_last_window
    # ventana que muestra las cartas que gana y pierde el jugador tras terminar
    # la fase de pago y updatea los mazos de cartas relaes del jugador
    # y el enemigo con las cartas perdidas y ganadas
    Graphics.freeze
    win = Bitmap.new(@winselectioncardsbitmap)
    win1 = Sprite.new
    win1.z = 2000
    textplayer = ""
    textenemy = ""
    cntcardsplayer = 0
    cntcardsenemy = 0
    Audio.bgm_fade(3000)
    for i in 0...5
      if @playerdeck[i][2][5] != 0
        text = @playerdeck[i][2][1].to_s
        textenemy += (textenemy == "" ? text : ", #{text}")
        cntcardsenemy += 1
        # Añadir esta carta al deck del enemigo para futuras partidas
        addcardtoenemydeck(@playerdeck[i][2])
      else
        # Añadir esta carta al deck del jugador para usarla posteriormente
        addcardtoplayerdeck(@playerdeck[i][2],true)
      end
      if @enemydeck[i][2][5] != 1
        text = @enemydeck[i][2][1].to_s
        textplayer += (textplayer == "" ? text : ", #{text}")
        cntcardsplayer += 1
        # Añadir esta carta al deck del jugador para usarla posteriormente
        addcardtoplayerdeck(@enemydeck[i][2])
      else
        # Añadir esta carta al deck del enemigo para futuras partidas
        addcardtoenemydeck(@enemydeck[i][2],true)
      end
    end
    s1 = cntcardsplayer != 1 ? 's' : ''
    s2 = cntcardsenemy != 1 ? 's' : ''
    t = @textos[4]
    if textplayer != ""
      title1 = "#{t[12]} #{t[14]}#{s1} #{t[15]}#{s1} #{t[16]}#{s1}:"
    else
      title1 = ""
    end
    if textenemy != ""
      title2 = "#{t[13]} #{t[14]}#{s2} #{t[15]}#{s2} #{t[16]}#{s2}:"
    else
      title2 = ""
    end
    if title1 == "" and title2 == ""
      title1 = @textos[4][18]
    end
    win2 = Bitmap.new(1,1)
    win2.font.size = 20
    w = win2.text_size(textplayer).width
    w = win2.text_size(textenemy).width if win2.text_size(textenemy).width > w
    w = win2.text_size(title1).width if win2.text_size(title1).width > w
    w = win2.text_size(title2).width if win2.text_size(title2).width > w
    w += 40
    w = 620 if w > 620
    h = 50 - (title1 == "" ? 10 : 0) - (title2 == "" ? 10 : 0)
    h += 22 if title1 != ""
    h += 22 if textplayer != ""
    h += 22 if title2 != ""
    win1.bitmap = Bitmap.new(w,h)
    win1.bitmap.stretch_blt(win1.bitmap.rect,win,win.rect)
    win1.x = 320 - (w/2)
    win1.y = 240 - (h/2)
    win1.bitmap.font.color = Color.new(255,255,255,255)
    win1.bitmap.draw_text(10,10,w-15,22,title1,1)
    nh = (title1 != "" ? 60 : 10)
    win1.bitmap.draw_text(10,nh,w-15,22,title2,1)
    win1.bitmap.font.color = Color.new(212,174,22,255)
    win1.bitmap.draw_text(10,33,w-15,22,textplayer,1)
    nh = (title1 != "" ? 83 : 33)
    win1.bitmap.draw_text(10,nh,w-15,22,textenemy,1)
    Graphics.update
    Graphics.transition(10)
    Graphics.update
    #waitsec(4.0)
    for i in 0...60
      Graphics.update
    end
    if @lastwin != nil
      @lastwin.visible = false
    end
    Graphics.freeze
    win1.dispose
    Graphics.transition(4)
    @fase = -2
    @endgame= true
  end
  # ---------------------------------------------------------------------------
  def update_fase_pago
    # Update para la selección de cartas que te vas a quedar tras terminar
    # una partida (selección manual de la/s carta/s enemiga/s que vas a quedarte)
    if @maxgetcards == 0
      @lastwin.visible = false
      @last_help_complement.visible = false
      @enemydeck.each do |item|
        if item[0].y != 75
          item[0].opacity = 120
        end
      end
      backupindex = @index
      drawwin2(@textos[4][11])
      @index = backupindex
      if @index_window == 1
        @maxgetcards = @backupmaxgetcards
        Audio.se_play(@soundmovecard,85)
        @enemydeck.each do |item|
          if item[0].y == 75
            item[0].y = 95
            item[0].x += 10
          end
          item[0].opacity = 255
        end
        @cursor.visible = true
        @cursor.y = 119
        @cursor.x = 25 + (113 * @index)
        draw_last_help
        @lastwin.visible = true
        @last_help_complement.visible = true
        return
      else
        @playerdeck.each do |item|
          item[2][5] = 0
        end
        @enemydeck.each do |item|
          item[0].y == 75 ? item[2][5] = 0 : item[2][5] = 1
        end
        getcardsbycolor
        @endgame = true
      end
      return
    end
    if Input.trigger?(Input::C)
      Audio.se_play(@soundmovecard,85)
      card = @enemydeck[@index]
      return if card == [] or card == nil
      if card[0].y == 95
        card[0].y = 75
        card[0].x -= 10
        @maxgetcards -= 1
      else
        card[0].y = 95
        card[0].x += 10
        @maxgetcards += 1
      end
      draw_last_help
      return
    end
    if Input.repeat?(Input::RIGHT)
      Audio.se_play(@soundcursor,85)
      @index += 1
      @index = 0 if @index == @enemydeck.size
      @cursor.x = 25 + (113 * @index)
      @anicursor1 = 0
      draw_last_help_complement
      Graphics.update
      return
    end
    if Input.repeat?(Input::LEFT)
      Audio.se_play(@soundcursor,85)
      @index -= 1
      @index = @enemydeck.size - 1 if @index == -1
      @cursor.x = 25 + (113 * @index)
      @anicursor1 = 0
      draw_last_help_complement
      Graphics.update
      return
    end
  end
  # ---------------------------------------------------------------------------
  def waitsec(time)
    # Comando para congelar la pantalla 'time' segundos (puede ser decimal)
    sleep(time)
  end
  # ---------------------------------------------------------------------------
  def getrules
    # Establece que reglas estarán activas durante la partida en curso
    if $deck['emenyIA'][@enemyid] != nil # Enemigo con reglas específicas
      @enemylevel = $deck['emenyIA'][@enemyid][0]
      @reglacombo = $deck['emenyIA'][@enemyid][1]
      @reglaigual = $deck['emenyIA'][@enemyid][2]
      @reglasuma = $deck['emenyIA'][@enemyid][3]
      @reglapared = $deck['emenyIA'][@enemyid][4]
      @reglaelemental = $deck['emenyIA'][@enemyid][5]
      @reglaabierto = $deck['emenyIA'][@enemyid][6]
      @reglarandom = $deck['emenyIA'][@enemyid][7]
      @reglahastalamuerte = $deck['emenyIA'][@enemyid][8]
      @reglapago = $deck['emenyIA'][@enemyid][9]
      usepluswall = $deck['emenyIA'][@enemyid][10]
      usecombowithwall = $deck['emenyIA'][@enemyid][11]
      checkallcards = $deck['emenyIA'][@enemyid][12]
      preferredenemycards = $deck['emenyIA'][@enemyid][13]
    elsif $deck['maprule'][@mapid] != nil # Mapa con reglas específicas
      @enemylevel = $deck['maprule'][@mapid][0]
      @reglacombo = $deck['maprule'][@mapid][1]
      @reglaigual = $deck['maprule'][@mapid][2]
      @reglasuma = $deck['maprule'][@mapid][3]
      @reglapared = $deck['maprule'][@mapid][4]
      @reglaelemental = $deck['maprule'][@mapid][5]
      @reglaabierto = $deck['maprule'][@mapid][6]
      @reglarandom = $deck['maprule'][@mapid][7]
      @reglahastalamuerte = $deck['maprule'][@mapid][8]
      @reglapago = $deck['maprule'][@mapid][9]
      usepluswall = $deck['maprule'][@enemyid][10]
      usecombowithwall = $deck['maprule'][@enemyid][11]
      checkallcards = $deck['maprule'][@enemyid][12]
    else # Reglas por defecto
      @enemylevel = @defaultenemylevel
      @reglacombo = @defaultcombo
      @reglaigual = @defaultreglaigual
      @reglasuma = @defaultreglasuma
      @reglapared = @defaultreglapared
      @reglaelemental = @defaultreglaelementa
      @reglaabierto = @defaultreglaabierto
      @reglarandom = @defaultreglarandom
      @reglahastalamuerte = @defaultreglahastalamuerte
      @reglapago = @defaultreglapago
      usepluswall = -1
      usecombowithwall = -1
      checkallcards = -1
    end
    # Convirtiendo las reglas nil en true o false aleatoriamente
    # Añadiendo un valor aleatorio al nivel si este es nil
    @reglacombo = (rand(2) == 0 ? true : false) if @reglacombo == nil
    @reglaigual = (rand(2) == 0 ? true : false) if @reglaigual == nil
    @reglasuma = (rand(2) == 0 ? true : false) if @reglasuma == nil
    @reglapared = (rand(2) == 0 ? true : false) if @reglapared == nil
    @reglaelemental = (rand(2) == 0 ? true : false) if @reglaelemental == nil
    @reglaabierto = (rand(2) == 0 ? true : false) if @reglaabierto == nil
    @reglarandom = (rand(2) == 0 ? true : false) if @reglarandom == nil
    @reglahastalamuerte = (rand(2) == 0 ? true : false) if @reglahastalamuerte == nil
    # Añadiendo un valor aleatorio al nivel si este es nil
    if @enemylevel == nil
      @enemylevel = rand(10) + 1
    end
    # Añadiendo valores por defecto a las reglas -1
    @enemylevel = @defaultenemylevel if @enemylevel == -1
    @reglacombo = @defaultcombo if @reglacombo == -1
    @reglaigual = @defaultreglaigual if @reglaigual == -1
    @reglasuma = @defaultreglasuma if @reglasuma == -1
    @reglapared = @defaultreglapared if @reglapared == -1
    @reglaelemental = @defaultreglaelementa if @reglaelemental == -1
    @reglaabierto = @defaultreglaabierto if @reglaabierto == -1
    @reglarandom = @defaultreglarandom if @reglarandom == -1
    @reglahastalamuerte = @defaultreglahastalamuerte if @reglahastalamuerte == -1
    @reglapago = @defaultreglapago if @reglapago == -1
    # Comprobar las reglas especiales
    if usepluswall == nil
      @usepluswall = (rand(2) == 0 ? true : false)
    elsif usepluswall != -1
      @usepluswall = usepluswall
    end
    if usecombowithwall == nil
      @usecombowithwall = (rand(2) == 0 ? true : false)
    elsif usecombowithwall != -1
      @usecombowithwall = usecombowithwall
    end
    if checkallcards == nil
      @checkallcards = (rand(2) == 0 ? true : false)
    elsif checkallcards != -1
      @checkallcards = checkallcards
    end
    # Asignando una regla aleatoria de pago si esta es nil
    @reglapago = rand(5) if @reglapago == nil
    # Asegurar que los valores de las reglas sean correctos
    if @activatecombowithplusorsame
      @reglacombo = true if @reglaigual or @reglasuma
    end
    @enemylevel = 1 if @enemylevel == nil
    @enemylevel = 1 if @enemylevel < 1
    @enemylevel = 10 if @enemylevel > 10
    @reglapago = 0 if @reglapago < 0 or @reglapago > 4
    # Si la regla pago es directo queda inhabilitada la regla hasta la muerte
    @reglahastalamuerte = false if @reglapago == 1
    # Añadiendo las preferencias de cartas que quiere obtener el enemigo
    @preferredenemycards = preferredenemycards
  end
  # ---------------------------------------------------------------------------
  def addcardtoplayerdeck(card,pushmode = false)
    # Añade la carta dada (card) al mazo de cartas del jugador.
    # Si ésta ya existe, primero la borra del mazo de cartas del jugador.
    # Añade la carta al principio del array, así cuando se entra a jugar
    # otra vez la carta aparecerá primera en caso de tenr varias del mismo tipo.
    deletecardfromdeckenemy(card)
    deletecardfromdeckplayer(card)
    cardid = card[0]
    realidindeck = cardid.split("_")[0].to_i
    cardplayer = $deck['player'][realidindeck]
    if cardplayer != nil
      if !pushmode
        arr = []
        arr.push(card)
        for i in 0...cardplayer.size
          item = cardplayer[i]
          id = item[2][0]
          next if id == cardid
          arr.push(item)
        end
        $deck['player'][realidindeck] = arr
        return
      else
        arr = []
        arr.push(card)
        for i in 0...cardplayer.size
          item = cardplayer[i]
          arr.push(item) if item != nil and item != []
        end
        $deck['player'][realidindeck] = arr
        return
      end
    end
    $deck['player'][realidindeck] = []
    $deck['player'][realidindeck].push(card)
  end
  # ---------------------------------------------------------------------------
  def addcardtoenemydeck(card,pushmode = false)
     # Añade la carta dada (card) al mazo de cartas del enemigo.
    # Si ésta ya existe, primero la borra del mazo de cartas del enemigo.
    # Añade la carta al principio del array, así cuando se entra a jugar
    # otra vez la carta aparecerá primera en caso de tenr varias del mismo tipo.
    deletecardfromdeckplayer(card)
    deletecardfromdeckenemy(card)
    cardid = card[0]
    realidindeck = cardid.split("_")[0].to_i
    cardplayer = $deck['enemy'][@enemyid][realidindeck]
    if cardplayer != nil
      if !pushmode
        arr = []
        arr.push(card)
        for i in 0...cardplayer.size
          item = cardplayer[i]
          id = item[2][0]
          next if id == cardid
          arr.push(item)
        end
        $deck['enemy'][@enemyid][realidindeck] = arr
        return
      else
        $deck['enemy'][@enemyid][realidindeck].push(card)
        return
      end
    end
    $deck['enemy'][@enemyid][realidindeck] = []
    $deck['enemy'][@enemyid][realidindeck].push(card)
  end
  # ---------------------------------------------------------------------------
  def deletecardfromdeckplayer(card)
    # Borra la carta dada del mazo de cartas del jugador
    cardid = card[0]
    realidindeck = cardid.split("_")[0].to_i
    if $deck['player'][realidindeck] != nil
      $deck['player'][realidindeck].each do |item|
        id = item[0]
        if id == cardid
          $deck['player'][realidindeck].delete(item)
          return
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
  def deletecardfromdeckenemy(card)
    # Borra la carta dada del mazo de cartas del enemigo
    cardid = card[0]
    realidindeck = cardid.split("_")[0].to_i
    if $deck['enemy'][@enemyid][realidindeck] != nil
      $deck['enemy'][@enemyid][realidindeck].each do |item|
        id = item[0]
        if id == cardid
          $deck['enemy'][@enemyid][realidindeck].delete(item)
          return
        end
      end
    end
  end
 # ---------------------------------------------------------------------------
  def dispose
    # Borra todos los sprites usados en el script
    @tablero.dispose
    @cursor.dispose
    @cursor2.dispose
    @selector1.dispose
    @selector2.dispose
    @anicursor2image.dispose
    @cardpreview.dispose
    @anicursor2image2.dispose
    @anicursor2image2.dispose
    @numbercardsplayer.dispose
    @numbercardsenemy.dispose
    @helpingame.dispose if @helpingame != nil
    @last_help_complement.dispose if @last_help_complement != nil
    if @textaction != nil
      @textaction.dispose
    end
    @playerdeck.each do |item|
      item[0].dispose
    end
    @enemydeck.each do |item|
      item[0].dispose
    end
    for x in 0...3
      for y in 0...3
        if @boarddeck[x][y].is_a?(Array)
          @boarddeck[x][y][0].dispose
        end
        if @boardelementalima[x][y].is_a?(Sprite)
          @boardelementalima[x][y].dispose
        end
      end
    end
    @previewimas.each do |item|
      item.each do |i|
        if i.is_a?(Bitmap) or i.is_a?(Sprite)
          i.dispose
        end
      end
    end
  end
  # ---------------------------------------------------------------------------
end