#=======================================================
#         Triple Triad Script - Main Script
# Author: Raizen
# Comunity: www.centrorpg.com
# 
# NÃO CONFIGURE AQUI
#=======================================================




#=======================================================

#=======================================================



module Config_Triple_Triad
  def self.total_cards
    a = 0
    $game_timer.total_cards.dup.each{|card| a += card}
    a += $game_timer.hand_deck.size
    return a
  end
end




class Triple_Triad < Scene_Base
include Config_Triple_Triad
  #--------------------------------------------------------------------------
  # * Inicio do Processo
  #--------------------------------------------------------------------------
  def initialize
    @map_bgm = RPG::BGM.last
    @map_bgs = RPG::BGS.last
    RPG::BGM.stop
    RPG::BGS.stop
    @battle_info = $game_timer.game_triple_triad.dup
    load_variables
    load_score
    load_text_images
    load_images
    load_back_images
    load_hands
    load_cards
    load_rules
    choose_npc_play
    super
  end 
  #--------------------------------------------------------------------------
  # * carrega a janela de regras
  #--------------------------------------------------------------------------
  def load_rules
    @rules = Triple_Triad_Rules.new
    @rules.x = Graphics.width/2 - @rules.width/2
    @rules.y = Graphics.height/2 - @rules.height/2
    @rules.opacity = 0
    @rules.contents_opacity = 0
  end
  #--------------------------------------------------------------------------
  # * carrega as variáveis do jogo
  #--------------------------------------------------------------------------
  def load_variables
    @flip_npc_commands = true
    @phase = 0
    @count = 0
    @goto_x = 0
    @goto_y = 0
    @player_turn = 0
    @turn_move = 0
    @index = 0
    @speed_x = 0
    @speed_y = 0
    @card_speed_x = 0
    @card_speed_y = 0
    @npc_time = 0
    @npc_time = Normal_time + Random_time
    @player_cards_hand = Array.new(5){|n| n}
    @npc_cards_hand = Array.new(5){|n| n}
    @move_commands = Array.new
    @flip_commands = Array.new
    @board = Array.new(3)
    @board[-1] = Array.new(3, false)
    @board[0] = Array.new(3, false)
    @board[1] = Array.new(3, false)
    @board[2] = Array.new(3, false)
    @board[3] = Array.new(3, false)
    @npc_board_x = 0 
    @npc_board_y = 0
    @board_x = 0
    @board_y = 0
    @combo = false
  end
  #--------------------------------------------------------------------------
  # * carrega as imagens do placar do jogo
  #--------------------------------------------------------------------------
  def load_score
    @score_player1 = []
    @score_player2 = []
    @score = [5, 5]
    for n in 0...9
      @score_player1[n] = Sprite.new
      @score_player2[n] = Sprite.new
      @score_player1[n].bitmap = Cache.triple_triad(Numbers[n])
      @score_player2[n].bitmap = Cache.triple_triad(Numbers[n])
      @score_player1[n].x = Num_player1[0]
      @score_player1[n].y = Num_player1[1]
      @score_player2[n].x = Num_player2[0]
      @score_player2[n].y = Num_player2[1]
      @score_player1[n].z = 10
      @score_player2[n].z = 10
      @score_player1[n].opacity = 0
      @score_player2[n].opacity = 0
    end
  end
  #--------------------------------------------------------------------------
  # * carrega as imagens de text(triple triad, same, plus...)
  #--------------------------------------------------------------------------
  def load_text_images
    @text_array = Array.new
    @text_pics = Array.new
    @text_moves = 0
    for n in 0...7
      @text_pics[n] = Sprite.new
      @text_pics[n].bitmap = Cache.triple_triad(Texts[n])
      @text_pics[n].ox = @text_pics[n].bitmap.width/2
      @text_pics[n].oy = @text_pics[n].bitmap.height/2
      @text_pics[n].x = Graphics.width/2
      @text_pics[n].y = Graphics.height/2
      @text_pics[n].opacity = 0
      @text_pics[n].z = 100
    end
  end
  #--------------------------------------------------------------------------
  # * carrega as imagens auxiliares(tabuleiro, cursor...)
  #--------------------------------------------------------------------------
  def load_images
    @background = Sprite.new
    @background.bitmap = Cache.triple_triad(Table)
    @cursor = Sprite.new
    @cursor.bitmap = Cache.triple_triad(Cursor)
    @cursor.opacity = 0
    @cursor.z = 100
    @arrow = Sprite.new
    @arrow.bitmap = Cache.triple_triad(Arrow)
    @arrow.ox = @arrow.bitmap.width/2
    @arrow.oy = @arrow.bitmap.height/2
    @arrow.x = Graphics.width/2
    @arrow.y = Graphics.height/2
    @arrow.opacity = 0
    @background.opacity = 0
    @player_turn_pic = []
    for n in 0...2
    @player_turn_pic[n] = Sprite.new
    if n == 0
      @player_turn_pic[n].bitmap = Cache.triple_triad(Player_turn1)
      @player_turn_pic[n].x = (Pos1x + Pos2x)/2
    else
      @player_turn_pic[n].bitmap = Cache.triple_triad(Player_turn2)
      @player_turn_pic[n].x = (Pos1x + Pos2x)/2
    end
    @player_turn_pic[n].opacity = 0
    @player_turn_pic[n].ox = @player_turn_pic[n].bitmap.width/2
    @player_turn_pic[n].y = Tri_y
    @player_turn_pic[n].z = 80
    end
  end
  #--------------------------------------------------------------------------
  # * carrega as imagens do fundo das cartas
  #--------------------------------------------------------------------------
  def load_back_images
    @back_card = [[0, 0, 0],[0, 0, 0],[0, 0, 0]]
    for n in 0...3
      for i in 0...3
        @back_card[n][i] = Sprite.new
        @back_card[n][i].bitmap = Cache.triple_triad(Back_Card)
        @back_card[n][i].x = Board_Map[n][i][0]
        @back_card[n][i].y = Board_Map[n][i][1]
        @back_card[n][i].opacity = 0
        @back_card[n][i].ox = @back_card[n][i].bitmap.width/2
        @back_card[n][i].oy = @back_card[n][i].bitmap.height/2
      end
    end
  end
  #--------------------------------------------------------------------------
  # * carrega a mão do jogador e do adversário
  #--------------------------------------------------------------------------
  def load_hands
    @player_pics = Array.new(5)
    @player_pics2 = Array.new(5)
    @npc_pics = Array.new(5)
    @npc_pics2 = Array.new(5)
    @back_npc_cards = Array.new(5)
    @player_hand = $game_timer.hand_deck
    @npc_hand = $game_timer.npc_hand
  end
  #--------------------------------------------------------------------------
  # * Carrega as imagens das cartas
  #--------------------------------------------------------------------------
  def load_cards
    for n in 0...5
      @player_pics[n] = Sprite.new
      @player_pics2[n] = Sprite.new
      @npc_pics[n] = Sprite.new
      @npc_pics2[n] = Sprite.new
      @player_pics[n].bitmap = Cache.triple_triad(Card[@player_hand[n]]['Image1'])
      @player_pics2[n].bitmap = Cache.triple_triad(Card[@player_hand[n]]['Image2'])
        @npc_pics[n].bitmap = Cache.triple_triad(Card[@npc_hand[n]]['Image2'])
      @npc_pics2[n].bitmap = Cache.triple_triad(Card[@npc_hand[n]]['Image1'])
      @npc_pics[n].x = Pos2x
      @npc_pics2[n].x = Pos2x
      @player_pics[n].x = Pos1x
      @player_pics2[n].x = Pos1x
      @npc_pics[n].y = Pos2y
      @npc_pics2[n].y = Pos2y
      @player_pics[n].y = Pos1y
      @player_pics2[n].y = Pos1y
      @npc_pics[n].opacity = 0
      @npc_pics2[n].opacity = 0
      @player_pics[n].opacity = 0
      @player_pics2[n].opacity = 0
      @npc_pics[n].ox = @npc_pics[n].bitmap.width/2
      @npc_pics2[n].ox = @npc_pics2[n].bitmap.width/2
      @player_pics[n].ox = @player_pics[n].bitmap.width/2
      @player_pics2[n].ox = @player_pics2[n].bitmap.width/2
      @npc_pics[n].oy = @npc_pics[n].bitmap.height/2
      @npc_pics2[n].oy = @npc_pics2[n].bitmap.height/2
      @player_pics[n].oy = @player_pics[n].bitmap.height/2
      @player_pics2[n].oy = @player_pics[n].bitmap.height/2
      unless @battle_info[8]
        @npc_pics[n].zoom_x = 0 
        @back_npc_cards[n] = Sprite.new
        @back_npc_cards[n].bitmap = Cache.triple_triad(Back_Card)
        @back_npc_cards[n].x = Pos2x
        @back_npc_cards[n].y = Pos2y
        @back_npc_cards[n].opacity = 0
        @back_npc_cards[n].ox = @npc_pics[n].bitmap.width/2
        @back_npc_cards[n].oy = @npc_pics[n].bitmap.height/2
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização geral
  #--------------------------------------------------------------------------
  def update
    super
    update_window
    return if @phase == 2 && @rules.opacity == 255
    flip_npc_cards unless @flip_npc_commands
    update_texts unless @text_array.empty?
    update_turn_pics
    case @phase
    when 0
      update_opacity
    when 1
      update_draw
    when 2
      update_choose_player
    when 3
      update_cursor_hand
    when 4
      update_cursor_board
    when 5
      update_play
    when 6
      update_flip_play
    when 7
      update_results  
    when 8
      dispose_all_cards
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização da janela de regras
  #--------------------------------------------------------------------------
  def update_window
    if @phase == 2
      RPG::BGM.new(@battle_info[0]).play unless @battle_info[0].nil?
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização de imagens de turn
  #--------------------------------------------------------------------------
  def update_turn_pics
    return if @phase < 3
    if @player_turn == 1
      if @player_turn_pic[0].x > Pos1x
        @move_turn = 0
        @player_turn_pic[0].x -= 20
        @player_turn_pic[1].x -= 20
        @player_turn_pic[0].opacity += 20
        @player_turn_pic[1].opacity -= 20
      elsif @player_turn_pic[0].x <= Pos1x && @move_turn == 0
        @player_turn_pic[0].x = Pos1x if @player_turn_pic[0].x != Pos1x
        @player_turn_pic[1].x = Pos1x if @player_turn_pic[0].x != Pos1x
        @player_turn_pic[0].opacity = 255 if @player_turn_pic[0].opacity < 255
        @player_turn_pic[1].opacity = 0 if @player_turn_pic[0].opacity > 0
        @move_turn = 1
      elsif @move_turn == 1
        @player_turn_pic[0].y -= 1
        @player_turn_pic[1].y -= 1
        @move_turn = 2 if @player_turn_pic[0].y <= Tri_y - 10
      elsif @move_turn == 2
        @player_turn_pic[0].y += 1
        @player_turn_pic[1].y += 1
        @move_turn = 1 if @player_turn_pic[0].y >= Tri_y
      end
    else
      if @player_turn_pic[0].x < Pos2x
        @move_turn = 0
        @player_turn_pic[0].x += 20
        @player_turn_pic[1].x += 20
        @player_turn_pic[0].opacity -= 20
        @player_turn_pic[1].opacity += 20
      elsif @player_turn_pic[0].x >= Pos2x && @move_turn == 0
        @player_turn_pic[0].x = Pos2x if @player_turn_pic[0].x != Pos1x
        @player_turn_pic[1].x = Pos2x if @player_turn_pic[0].x != Pos1x
        @player_turn_pic[1].opacity = 255 if @player_turn_pic[0].opacity < 255
        @player_turn_pic[2].opacity = 0 if @player_turn_pic[0].opacity > 0
        @move_turn = 1
      elsif @move_turn == 1
        @player_turn_pic[0].y -= 1
        @player_turn_pic[1].y -= 1
        @move_turn = 2 if @player_turn_pic[0].y <= Tri_y - 10
      elsif @move_turn == 2
        @player_turn_pic[0].y += 1
        @player_turn_pic[1].y += 1
        @move_turn = 1 if @player_turn_pic[0].y >= Tri_y
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização de textos da tela
  #--------------------------------------------------------------------------
  def update_score
    @score_player1[@score[0]-1].opacity = 0
    @score_player2[@score[1]-1].opacity = 0
    if @player_turn == 1
      @score[0] += 1
      @score[1] -= 1
    else
      @score[0] -= 1
      @score[1] += 1
    end
    @score[0] = 1 if @score[0] < 1
    @score[0] = 9 if @score[0] > 9
    @score[1] = 1 if @score[0] < 1
    @score[1] = 9 if @score[0] > 9
    @score_player1[@score[0]-1].opacity = 255
    @score_player2[@score[1]-1].opacity = 255
  end
  #--------------------------------------------------------------------------
  # * Atualização de textos da tela
  #--------------------------------------------------------------------------
  def update_texts
    if @text_array.first == 0
      if @text_moves == 0
        @text_pics[@text_array.first].zoom_y = 0
        @text_pics[@text_array.first].opacity = 255
        @text_moves += 1
      elsif @text_moves == 1
        @text_pics[@text_array.first].zoom_y += 0.05
        if @text_pics[@text_array.first].zoom_y >= 1.0
          @text_pics[@text_array.first].zoom_y = 1.0
          @text_moves += 1
        end
      elsif @text_moves == 2
        @text_pics[@text_array.first].opacity -= 20
        if @text_pics[@text_array.first].opacity <= 0
          @text_moves = 0
          @text_array.shift
          RPG::SE.new(Card_sound).play 
          @phase = 1
        end
      end  
    elsif @text_array.first > 0 && @text_array.first < 4
      if @text_moves == 0
        @text_pics[@text_array.first].x = Graphics.width + @text_pics[@text_array.first].bitmap.width/2
        @text_moves = 1
      elsif @text_moves == 1
        @text_pics[@text_array.first].opacity += 10
        @text_pics[@text_array.first].x -= 20
        if @text_pics[@text_array.first].x <= Graphics.width/2
          RPG::SE.new(Combo_sound).play 
          @text_moves = 2 
        end
      elsif @text_moves == 2
        @text_pics[@text_array.first].opacity += 10
        @text_moves = 3 if @text_pics[@text_array.first].opacity >= 255
      elsif @text_moves == 3
        @text_pics[@text_array.first].opacity -= 10
        if  @text_pics[@text_array.first].opacity <= 0
          @text_moves = 0
          @text_array.shift
        end
      end
    elsif @text_array.first > 3 && @text_array.first < 7
      if @text_moves == 0
        @text_pics[@text_array.first].zoom_y = 0
        @text_pics[@text_array.first].opacity = 255
        @text_moves += 1
      elsif @text_moves == 1
        @text_pics[@text_array.first].zoom_y += 0.05
        if @text_pics[@text_array.first].zoom_y >= 1.0
          @text_pics[@text_array.first].zoom_y = 1.0
          @text_moves += 1
        end
        elsif @text_moves >= 2
        @text_moves += 1
        if @text_moves <= 120
          @text_moves = 0
          @text_array.shift
        end
      end 
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização dos gráficos iniciais de batalha
  #--------------------------------------------------------------------------
  def update_opacity
    if @background.opacity < 255
      @background.opacity += 10
    elsif @npc_pics[0].opacity < 255
      @score_player1[4].opacity += 5
      @score_player2[4].opacity += 5
      for n in 0...5
        @npc_pics[n].opacity += 5
        @back_npc_cards[n].opacity += 5 unless @battle_info[8]
        @player_pics[n].opacity += 5
      end
    else
      @text_array.push(0)
      @phase = -1
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 1 (fase de distribuir as cartas)
  #--------------------------------------------------------------------------
  def update_draw
    if @count < Disty
      @count += 1
      for n in 0...5
        @npc_pics[n].y += n
        @player_pics[n].y += n
        @back_npc_cards[n].y += n unless @battle_info[8]
      end
    else
      @count = 0
      @phase = 2
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 2 (fase de escolha do jogador inicial)
  #--------------------------------------------------------------------------
  def update_choose_player
    if @battle_info[1] != 1 && @battle_info[1] != 2
      @battle_info[1] = 1 + rand(2)
    end
    @player_turn = @battle_info[1]
    @arrow.opacity += 10 unless @count > 60
    if @arrow.angle % 180 == 0 && @count > 151
      @arrow.opacity -= 10
      @cursor.opacity += 10
    end
    if @arrow.opacity <= 0
      $game_timer.game_triple_triad[1] = 0
      Sound.play_cursor
      if @player_turn == 1
        @index = 4
        move_to_cursor(@player_pics[4].x + Cursor_x, @player_pics[4].y + Cursor_y)
      else
        @index = 4
        move_to_cursor(@npc_pics[4].x + Cursor_x, @npc_pics[4].y + Cursor_y)
      end
      @phase = 3
    end
    return if @arrow.opacity < 255
    @count += 1
    if @battle_info[1] == 2
      if @count <= 145
        @arrow.angle += (18 - @count/10)
      elsif @count > 145 && @arrow.angle % 180 != 0
        @arrow.angle += 1
      end
    else
      if @count <= 151
        @arrow.angle += (19 - @count/10)
      elsif @count > 151 && @arrow.angle % 180 != 0
        @arrow.angle += 1
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 3 (Atualização do cursor de jogo)
  #--------------------------------------------------------------------------
  def update_cursor_hand
    @player_turn == 1 ? update_player_hand : update_npc_hand
  end
  #--------------------------------------------------------------------------
  # * Continuação Atualização fase 3 (Atualização do cursor de jogador)
  #--------------------------------------------------------------------------
  def update_player_hand
    cursor_move
    for n in 0...5
      if @player_cards_hand.include?(n)
        if n == @index
          @player_pics[n].x += 2 if @player_pics[n].x < Pos1x + 14
        else
          @player_pics[n].x -= 2 if @player_pics[n].x > Pos1x
        end
      end
    end
    return if cursor_moving?
    if Input.repeat?(:UP)
      if @index == @player_cards_hand.first
        @index = @player_cards_hand.last
      else
        unless @player_cards_hand.size == 1
          @index -= 1
          @index -= 1 until @player_cards_hand.include?(@index)
        end
      end
      move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
    end
    if Input.repeat?(:DOWN)
      if @index == @player_cards_hand.last
        @index = @player_cards_hand.first
      else
        unless @player_cards_hand.size == 1
          @index += 1 
          @index += 1 until @player_cards_hand.include?(@index)
        end
      end
      move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
    end
    if Input.trigger?(:C)
      Sound.play_ok
      @board_x = 1
      @board_y = 1
      move_to_cursor(Board_Map[1][1][0]+Cursor_x, Board_Map[1][1][1]+Cursor_y)
      @phase = 4
    end
  end
  #--------------------------------------------------------------------------
  # * Continuação Atualização fase 3 (Atualização do cursor de npc)
  #--------------------------------------------------------------------------
  def update_npc_hand
    cursor_move
    @count += 1
    for n in 0...5
      if @npc_cards_hand.include?(n)
        if n == @index
          if !@battle_info[8]
            @back_npc_cards[n].x -= 2 if @back_npc_cards[n].x > Pos2x - 14
          end
          @npc_pics[n].x -= 2 if @npc_pics[n].x > Pos2x - 14
        else
          if !@battle_info[8]
            @back_npc_cards[n].x += 2 if @back_npc_cards[n].x < Pos2x
          end
          @npc_pics[n].x += 2 if @npc_pics[n].x < Pos2x
        end
      end
    end
      return if cursor_moving?
      if @count < @npc_time
        return
      elsif @count == @npc_time
        choose_npc_play
        return
      end
      if @npc_index == @index
        Sound.play_ok
        @board_x = 1
        @board_y = 1
        move_to_cursor(Board_Map[1][1][0]+Cursor_x, Board_Map[1][1][1]+Cursor_y)
        @phase = 4
      elsif @npc_index > @index
        @index += 1 
        @index += 1 until @npc_cards_hand.include?(@index)
      else
        @index -= 1
        @index -= 1 until @npc_cards_hand.include?(@index)
      end
      move_to_cursor(@npc_pics[@index].x + Cursor_x, @npc_pics[@index].y + Cursor_y)
    end
  #--------------------------------------------------------------------------
  # * Inteligência Artificial
  #--------------------------------------------------------------------------
  def choose_npc_play
    @npc_index = -1
    @npc_best_card = Array.new
    @npc_board_map = Array.new
    @npc_one_play = Array.new
    @npc_corner_play = Array.new
    @npc_corner_values = 0
    @npc_board = []
    @combo_count = []
    if @battle_info[7] == 0
      until @npc_cards_hand.include?(@npc_index)
        @npc_index = rand(5)
      end
      @npc_board_y = rand(3)
      @npc_board_x = rand(3)
      while @board[@npc_board_y][@npc_board_x] != false
        @npc_board_x = rand(3)
        @npc_board_y = rand(3)
      end
    elsif @battle_info[7] >= 1
      for n in 0...3
        for i in 0...3
          @npc_board_map.push([i, n]) unless @board[n][i]
        end
      end
      @npc_best_card = @npc_cards_hand.shuffle
      @npc_board_map.shuffle!
      for n in 0...@npc_best_card.size
        for i in 0...@npc_board_map.size
          @npc_board = [Card[@npc_hand[@npc_best_card[n]]]['UP'], Card[@npc_hand[@npc_best_card[n]]]['LEFT'], Card[@npc_hand[@npc_best_card[n]]]['RIGHT'], Card[@npc_hand[@npc_best_card[n]]]['DOWN'], @npc_best_card[n]]
          push_npc_flips(@npc_board_map[i][0], @npc_board_map[i][1])
          play_best_corner(@npc_board_map[i][0], @npc_board_map[i][1])
        end
      end
      if @npc_one_play.empty? && !@npc_corner_play.empty? && @battle_info[7] != 1
        @npc_one_play = [@npc_corner_play]
        @npc_index = @npc_one_play.first[0]
        @npc_board_x = @npc_one_play.first[1]
        @npc_board_y = @npc_one_play.first[2]        
      end
      if @npc_one_play.empty?
        until @npc_cards_hand.include?(@npc_index)
          @npc_index = rand(5)
        end
        @npc_board_y = rand(3)
        @npc_board_x = rand(3)
        while @board[@npc_board_y][@npc_board_x] != false
          @npc_board_x = rand(3)
          @npc_board_y = rand(3)
        end
      else
        @npc_one_play.shuffle! if @battle_info[7] == 1
        @npc_index = @npc_one_play.first[0]
        @npc_board_x = @npc_one_play.first[1]
        @npc_board_y = @npc_one_play.first[2]
      end
    end
  end
  #--------------------------------------------------------------------------
  # * AI do NPC, ele buscará cantos livres, e a melhor carta para jogar.
  #--------------------------------------------------------------------------
  def play_best_corner(x, y)
    if x == 0 && y == 0
        if @npc_corner_values <=  @npc_board[2] + @npc_board[3]
          @npc_corner_values = @npc_board[2] + @npc_board[3]
          @npc_corner_play = [@npc_board[4], 0, 0]
        end
    elsif x == 2 && y == 0
        if @npc_corner_values <=  @npc_board[1] + @npc_board[3]
          @npc_corner_values = @npc_board[1] + @npc_board[3]
          @npc_corner_play = [@npc_board[4], 2, 0]
        end
    elsif x == 0 && y == 2
        if @npc_corner_values <=  @npc_board[2] + @npc_board[0]
          @npc_corner_values = @npc_board[2] + @npc_board[0]
          @npc_corner_play = [@npc_board[4], 0, 2]
        end
    elsif x == 2 && y == 2
        if @npc_corner_values <=  @npc_board[1] + @npc_board[0]
          @npc_corner_values = @npc_board[1] + @npc_board[0]
          @npc_corner_play = [@npc_board[4], 2, 2]
        end
    end
  end
  #--------------------------------------------------------------------------
  # * Decisão se ocorre plus, same ou normal
  #--------------------------------------------------------------------------
  def push_npc_flips(x, y)
  up = 0
  left = 0
  down = 0
  right = 0
    if @board[y - 1][x] && y - 1 >= 0
      up = @board[y - 1][x][3]
    end
    if @board[y + 1][x] && y + 1 <= 2
      down = @board[y + 1][x][0]
    end	
    if @board[y][x - 1] && x - 1 >= 0
      left = @board[y][x - 1][2]
    end
    if @board[y][x + 1] && x + 1 <= 2
      right = @board[y][x + 1][1]
    end
    check_same_npc_condition(up, left, right, down, x, y) if @battle_info[2]
    check_plus_npc_condition(up, left, right, down, x, y) if @battle_info[3]
    check_normal_npc_condition(up, left, right, down, x, y)
  end
  #--------------------------------------------------------------------------
  # * Inteligência Artificial : Condição Same
  #--------------------------------------------------------------------------
  def check_same_npc_condition(up, left, right, down, x, y)
    count_cards = 0
    if up == @npc_board[0] && y - 1 >= 0
      count_cards += 1
    end
    if left == @npc_board[1] && x - 1 >= 0
      count_cards += 1
    end
    if right == @npc_board[2] && x + 1 <= 2
      count_cards += 1
    end
    if down == @npc_board[3] && y + 1 <= 2
      count_cards += 1
    end
    if @battle_info[5]
      if y == 0
        up = 10
        count_cards += 1 if up == @npc_board[0]
      elsif y == 2
        down = 10
        count_cards += 1 if down == @npc_board[3]
      end
      if x == 0
        left = 10
        count_cards += 1 if left == @npc_board[1]
      elsif x == 2
        right = 10
        count_cards += 1 if right == @npc_board[2]
      end
    end
    if count_cards >= 2
      if up == @npc_board[0] && y - 1 >= 0
        if @board[y - 1][x][4] != @player_turn
          @npc_one_play.unshift([@npc_board[4], x, y])
        end
      end
      if left == @npc_board[1] && x - 1 >= 0
        if @board[y][x - 1][4] != @player_turn
          @npc_one_play.unshift([@npc_board[4], x, y])
        end
      end
      if right == @npc_board[2] && x + 1 <= 2
        if @board[y][x + 1][4] != @player_turn
          @npc_one_play.unshift([@npc_board[4], x, y])
        end
      end
      if down == @npc_board[3] && y + 1 <= 2
        if @board[y + 1][x][4] != @player_turn
          @npc_one_play.unshift([@npc_board[4], x, y])
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Inteligência Artificial : Condição plus
  #--------------------------------------------------------------------------
  def check_plus_npc_condition(up, left, right, down, x, y)
  count_cards = 0
  opposite_card = false
  if @battle_info[6]
    up = 10 if up == 0 && y == 0
    left = 10 if left == 0 && x == 0
    right = 10 if right == 0 && x == 2
    down = 10 if down == 0 && y == 2
  end
	if up != 0
		up += @npc_board[0]
	end
	if left != 0
		left += @npc_board[1]
	end
	if right != 0
		right += @npc_board[2]
	end
	if down != 0
		down += @npc_board[3]
	end
	if up == left && up != 0 
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
	if up == right && up != 0
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if x + 1 <= 2
      if @board[y][x + 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
	if up == down && up != 0 
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
	if left == down && left != 0
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
	if left == right && left != 0
    if x + 1 <= 2 
      if @board[y][x + 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
	if right == down && right != 0 
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
    if x + 1 <= 2
      if @board[y][x + 1][4] != @player_turn
        @npc_one_play.unshift([@npc_board[4], x, y])
      end
    end
	end
end
  #--------------------------------------------------------------------------
  # * Inteligência Artificial : Condição Normal
  #--------------------------------------------------------------------------
  def check_normal_npc_condition(up, left, right, down, x, y)
     if up != 0
      if up < @npc_board[0] && y - 1 >= 0
        if @board[y - 1][x][4] != @player_turn
          @npc_one_play.push([@npc_board[4], x, y])
        end
      end
    end
    if left != 0
      if left < @npc_board[1] && x - 1 >= 0
        if @board[y][x - 1][4] != @player_turn
          @npc_one_play.push([@npc_board[4], x, y])
        end
      end
    end
    if right != 0 
      if right < @npc_board[2] && x + 1 <= 2
        if @board[y][x + 1][4] != @player_turn
          @npc_one_play.push([@npc_board[4], x, y])
        end	
      end
    end
    if down != 0
      if down < @npc_board[3] && y + 1 <= 2
        if @board[y + 1][x][4] != @player_turn
          @npc_one_play.push([@npc_board[4], x, y])
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 4 (Atualização do cursor no tabuleiro)
  #--------------------------------------------------------------------------
  def update_cursor_board
    @player_turn == 1 ? update_player_board : update_npc_board
  end
  #--------------------------------------------------------------------------
  # * Continuação Atualização fase 4 (Atualização do cursor de jogador)
  #--------------------------------------------------------------------------
  def update_player_board
    cursor_move
    return if cursor_moving?
    case Input.dir4
    when 2
      if @board_y < 2
        @board_y += 1 
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      end
    when 4
      if @board_x > 0
        @board_x -= 1
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      end    
    when 6
      if @board_x < 2
        @board_x += 1 
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      end
    when 8
      if @board_y > 0
        @board_y -= 1 
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
     end
    end
    if Input.trigger?(:B)
      Sound.play_cancel
       move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
      @phase = 3
    end
    if Input.trigger?(:C)
      unless @board[@board_y][@board_x]
        Sound.play_ok
        move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
        @phase = 5
        move_to_board(Board_Map[@board_y][@board_x][0], Board_Map[@board_y][@board_x][1], @index, true)
        @board[@board_y][@board_x] = [Card[@player_hand[@index]]['UP'], Card[@player_hand[@index]]['LEFT'], Card[@player_hand[@index]]['RIGHT'], Card[@player_hand[@index]]['DOWN'], 1, @index, 1]
      else
        Sound.play_buzzer
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Continuação Atualização fase 4 (Atualização do cursor de npc)
  #--------------------------------------------------------------------------
  def update_npc_board
    cursor_move
    return if cursor_moving?
      if @npc_board_y > @board_y
        @board_y += 1 
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      elsif @npc_board_y < @board_y
        @board_y -= 1
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      elsif @npc_board_x < @board_x
        @board_x -= 1
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      elsif @npc_board_x > @board_x
        @board_x += 1 
        move_to_cursor(Board_Map[@board_y][@board_x][0]+Cursor_x, Board_Map[@board_y][@board_x][1]+Cursor_y)
      else
        Sound.play_ok
        move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
        @phase = 5
        move_to_board(Board_Map[@board_y][@board_x][0], Board_Map[@board_y][@board_x][1], @index, false)
        @board[@board_y][@board_x] = [Card[@npc_hand[@index]]['UP'], Card[@npc_hand[@index]]['LEFT'], Card[@npc_hand[@index]]['RIGHT'], Card[@npc_hand[@index]]['DOWN'],2 , @index, 2]
      end
  end
  #--------------------------------------------------------------------------
  # * Continuação Atualização fase 5 (Atualização da movimentação de cartas)
  #--------------------------------------------------------------------------
  def update_play
    cursor_move
    card_move unless @move_commands.empty?
    return if cursor_moving? || card_moving?
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 6 (Atualização do flip das cartas)
  #--------------------------------------------------------------------------
  def update_flip_play
    flip_cards
    return unless @flip_commands.empty?
    @player_turn == 1 ? @player_turn = 2 : @player_turn = 1
    if @player_cards_hand.empty? || @npc_cards_hand.empty?
      @phase = 7
      RPG::BGM.stop
      if @score[0] > @score[1]
        RPG::ME.new(Victory).play
        @text_array.push(4)
        $game_variables[Variable] = 1
      elsif @score[0] < @score[1]
        RPG::ME.new(Defeat).play
        @text_array.push(6)
        $game_variables[Variable] = 3
      else
        @text_array.push(5)
        $game_variables[Variable] = 2
      end
    else
      @combo = false
      @phase = 3
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 7 (fase final)
  #--------------------------------------------------------------------------
  def update_results
    return unless @text_array.empty?
    if Input.trigger?(:B) || Input.trigger?(:C)
      Sound.play_ok
      $game_triple_results = []
      for n in 0...5
        if @npc_pics2[n].opacity == 255
          $game_triple_results.push(0)
        else
          $game_triple_results.push(1)
        end
      end
      for n in 0...5
        if @player_pics[n].opacity == 255
          $game_triple_results.push(0)
        else
          $game_triple_results.push(1)
        end
      end
      @phase = 8
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização fase 8 (fase de dispose)
  #--------------------------------------------------------------------------
  def dispose_all_cards
    @score_player1.each{|n| n.opacity -= 10}
    @score_player2.each{|n| n.opacity -= 10}
    @text_pics.each{|n| n.opacity -= 10}
    @background.opacity -= 10
    @cursor.opacity -= 10
    @arrow.opacity -= 10
    @player_pics.each{|n| n.opacity -= 10}
    @player_pics2.each{|n| n.opacity -= 10}
    @npc_pics.each{|n| n.opacity -= 10}
    @npc_pics2.each{|n| n.opacity -= 10}
    @player_turn_pic.each{|n| n.opacity -= 10}
    @back_npc_cards.each{|n| n.opacity -= 10} unless @battle_info[8]
    close_game if @cursor.opacity <= 0
  end
  
  def flip_npc_cards
    return if @flip_npc_commands
    if @back_npc_cards[@the_flip].zoom_x > 0
      @do_the_flip = false
      @back_npc_cards[@the_flip].zoom_x -= 0.1
    elsif @back_npc_cards[@the_flip].zoom_x <= 0 && @do_the_flip == false
      @do_the_flip = true
    elsif @npc_pics[@the_flip].zoom_x < 1 && @do_the_flip
      @npc_pics[@the_flip].zoom_x += 0.1
    elsif @npc_pics[@the_flip].zoom_x >= 1
      @npc_pics[@the_flip].zoom_x = 1
      @flip_npc_commands = true
    end
  end
  #--------------------------------------------------------------------------
  # * Realizar flip das cartas
  #--------------------------------------------------------------------------
  def flip_cards
    return if @flip_commands.empty?
	if @flip_commands.first[0]
		if @player_turn == 1
			if @flip_commands.first[2] == 1
				if @player_pics2[@flip_commands.first[1]].zoom_x > 0
					@first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
					@player_pics2[@flip_commands.first[1]].zoom_x -= 0.1
					@player_pics[@flip_commands.first[1]].zoom_x = 0
					@player_pics[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x += 0.2
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x -= 0.2
				elsif @player_pics[@flip_commands.first[1]].zoom_x < 1
					@player_pics[@flip_commands.first[1]].zoom_x += 0.1
				else
					@player_pics[@flip_commands.first[1]].zoom_x = 1
					@player_pics2[@flip_commands.first[1]].opacity = 0
					@player_pics2[@flip_commands.first[1]].zoom_x = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			else
		  if @npc_pics[@flip_commands.first[1]].zoom_x > 0
          @first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
          @npc_pics[@flip_commands.first[1]].zoom_x -= 0.1
          @npc_pics2[@flip_commands.first[1]].zoom_x = 0
          @npc_pics2[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x += 0.1
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x -= 0.2
				elsif @npc_pics2[@flip_commands.first[1]].zoom_x < 1
					@npc_pics2[@flip_commands.first[1]].zoom_x += 0.1
				else
					@npc_pics2[@flip_commands.first[1]].zoom_x = 1
					@npc_pics[@flip_commands.first[1]].opacity = 0
					@npc_pics[@flip_commands.first[1]].zoom_x = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			end
		else
			if @flip_commands.first[2] == 1
				if @player_pics[@flip_commands.first[1]].zoom_x > 0
					@first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
					@player_pics[@flip_commands.first[1]].zoom_x -= 0.1
					@player_pics2[@flip_commands.first[1]].zoom_x = 0
					@player_pics2[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x += 0.2
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x -= 0.2
				elsif @player_pics2[@flip_commands.first[1]].zoom_x < 1
					@player_pics2[@flip_commands.first[1]].zoom_x += 0.1
				else
					@player_pics2[@flip_commands.first[1]].zoom_x = 1
					@player_pics[@flip_commands.first[1]].opacity = 0
					@player_pics[@flip_commands.first[1]].zoom_x = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			else
		  if @npc_pics2[@flip_commands.first[1]].zoom_x > 0
          @first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
          @npc_pics2[@flip_commands.first[1]].zoom_x -= 0.1
          @npc_pics[@flip_commands.first[1]].zoom_x = 0
          @npc_pics[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x += 0.1
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x -= 0.2
				elsif @npc_pics[@flip_commands.first[1]].zoom_x < 1
					@npc_pics[@flip_commands.first[1]].zoom_x += 0.1
				else
					@npc_pics[@flip_commands.first[1]].zoom_x = 1
					@npc_pics2[@flip_commands.first[1]].opacity = 0
					@npc_pics2[@flip_commands.first[1]].zoom_x = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_x = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end		
      end
    end
	else
		if @player_turn == 1
			if @flip_commands.first[2] == 1
				if @player_pics2[@flip_commands.first[1]].zoom_y > 0
          @first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
          @player_pics2[@flip_commands.first[1]].zoom_y -= 0.1
          @player_pics[@flip_commands.first[1]].zoom_y = 0
          @player_pics[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y += 0.1
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y -= 0.2
				elsif @player_pics[@flip_commands.first[1]].zoom_y < 1
					@player_pics[@flip_commands.first[1]].zoom_y += 0.1
				else
					@player_pics[@flip_commands.first[1]].zoom_y = 1
					@player_pics2[@flip_commands.first[1]].opacity = 0
					@player_pics2[@flip_commands.first[1]].zoom_y = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			else
				if @npc_pics[@flip_commands.first[1]].zoom_y > 0
          @first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
          @npc_pics[@flip_commands.first[1]].zoom_y -= 0.1
          @npc_pics2[@flip_commands.first[1]].zoom_y = 0
          @npc_pics2[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y += 0.1
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y -= 0.2
				elsif @npc_pics2[@flip_commands.first[1]].zoom_y < 1
					@npc_pics2[@flip_commands.first[1]].zoom_y += 0.1
				else
					@npc_pics2[@flip_commands.first[1]].zoom_y = 1
					@npc_pics[@flip_commands.first[1]].opacity = 0
					@npc_pics[@flip_commands.first[1]].zoom_y = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			end	
		else
			if @flip_commands.first[2] == 1
				if @player_pics[@flip_commands.first[1]].zoom_y > 0
					@first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
					@player_pics[@flip_commands.first[1]].zoom_y -= 0.1
					@player_pics2[@flip_commands.first[1]].zoom_y = 0
					@player_pics2[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y += 0.2
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y -= 0.2
				elsif @player_pics2[@flip_commands.first[1]].zoom_y < 1
					@player_pics2[@flip_commands.first[1]].zoom_y += 0.1
				else
					@player_pics2[@flip_commands.first[1]].zoom_y = 1
					@player_pics[@flip_commands.first[1]].opacity = 0
					@player_pics[@flip_commands.first[1]].zoom_y = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end
			else
		  if @npc_pics2[@flip_commands.first[1]].zoom_y > 0
          @first_flip = false
          RPG::SE.new(Sound_flip).play if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity != 255
          @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 255
          @npc_pics2[@flip_commands.first[1]].zoom_y -= 0.1
          @npc_pics[@flip_commands.first[1]].zoom_y = 0
          @npc_pics[@flip_commands.first[1]].opacity = 255
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y < 1 && @first_flip == false
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y += 0.1
					@first_flip = true if @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y >= 1
				elsif @back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y > 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y -= 0.2
				elsif @npc_pics[@flip_commands.first[1]].zoom_y < 1
					@npc_pics[@flip_commands.first[1]].zoom_y += 0.1
				else
					@npc_pics[@flip_commands.first[1]].zoom_y = 1
					@npc_pics2[@flip_commands.first[1]].opacity = 0
					@npc_pics2[@flip_commands.first[1]].zoom_y = 1
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].opacity = 0
					@back_card[@flip_commands.first[4]][@flip_commands.first[3]].zoom_y = 1
					update_score
          push_combo_flips(@flip_commands.first[3], @flip_commands.first[4]) if @combo && @battle_info[4]
          @flip_commands.shift
				end		
		end
		end
	end
  end
  #--------------------------------------------------------------------------
  # * Atualização da posição do cursor
  #--------------------------------------------------------------------------
  def cursor_move
    if (@cursor.x - @goto_x).abs >= 10
      @cursor.x += @speed_x
    elsif (@cursor.x - @goto_x).abs != 0
      @cursor.x -= (@cursor.x - @goto_x)
    end
    if (@cursor.y - @goto_y).abs >= 10
      @cursor.y += @speed_y
    elsif (@cursor.y - @goto_y).abs != 0
      @cursor.y -= (@cursor.y - @goto_y)
    end
  end
  #--------------------------------------------------------------------------
  # * Cálculo da posição do cursor
  #--------------------------------------------------------------------------
  def move_to_cursor(x, y)
    Sound.play_cursor
    @goto_x = x
    @goto_y = y
    @speed_x = (x - @cursor.x)/ 10
    @speed_y = (y - @cursor.y)/ 10
  end
  #--------------------------------------------------------------------------
  # * Atualização da posição da carta
  #--------------------------------------------------------------------------
  def card_move
    @player_turn == 1 ? move_player_card : move_npc_card
  end
  #--------------------------------------------------------------------------
  # * Decisão se ocorre combos
  #--------------------------------------------------------------------------
  def push_combo_flips(x, y)
  up = 0
  left = 0
  down = 0
  right = 0
    if @board[y - 1][x] && y - 1 >= 0
      up = @board[y - 1][x][3]
    end
    if @board[y + 1][x] && y + 1 <= 2
      down = @board[y + 1][x][0]
    end	
    if @board[y][x - 1] && x - 1 >= 0
      left = @board[y][x - 1][2]
    end
    if @board[y][x + 1] && x + 1 <= 2
      right = @board[y][x + 1][1]
    end
    check_normal_condition(up, left, right, down, x, y)
  end
  #--------------------------------------------------------------------------
  # * Decisão se ocorre plus, same ou normal
  #--------------------------------------------------------------------------
  def push_flips(x, y)
  up = 0
  left = 0
  down = 0
  right = 0
    if @board[y - 1][x] && y - 1 >= 0
      up = @board[y - 1][x][3]
    end
    if @board[y + 1][x] && y + 1 <= 2
      down = @board[y + 1][x][0]
    end	
    if @board[y][x - 1] && x - 1 >= 0
      left = @board[y][x - 1][2]
    end
    if @board[y][x + 1] && x + 1 <= 2
      right = @board[y][x + 1][1]
    end
    check_same_condition(up, left, right, down, x, y) if @battle_info[2]
    check_plus_condition(up, left, right, down, x, y) if @battle_info[3]
    check_normal_condition(up, left, right, down, x, y)
  end
  #--------------------------------------------------------------------------
  # * Condição Same
  #--------------------------------------------------------------------------
  def check_same_condition(up, left, right, down, x, y)
    count_cards = 0
    if up == @board[y][x][0] && y - 1 >= 0
      count_cards += 1
    end
    if left == @board[y][x][1] && x - 1 >= 0
      count_cards += 1
    end
    if right == @board[y][x][2] && x + 1 <= 2
      count_cards += 1
    end
    if down == @board[y][x][3] && y + 1 <= 2
      count_cards += 1
    end
    if @battle_info[5]
      if y == 0
        up = 10
        count_cards += 1 if up == @board[y][x][0]
      elsif y == 2
        down = 10
        count_cards += 1 if down == @board[y][x][3]
      end
      if x == 0
        left = 10
        count_cards += 1 if left == @board[y][x][1]
      elsif x == 2
        right = 10
        count_cards += 1 if right == @board[y][x][2]
      end
    end
    if count_cards >= 2
      if up == @board[y][x][0] && y - 1 >= 0
        if @board[y - 1][x][4] != @player_turn
          @text_array.push(1) unless @text_array.first == 1
          @combo = true
          @flip_commands.push([false, @board[y - 1][x][5], @board[y - 1][x][6], x, y - 1]) 
        end
        @board[y - 1][x][4] = @player_turn
      end
      if left == @board[y][x][1] && x - 1 >= 0
        if @board[y][x - 1][4] != @player_turn
          @text_array.push(1) unless @text_array.first == 1
          @combo = true
          @flip_commands.push([true, @board[y][x - 1][5], @board[y][x - 1][6], x - 1, y]) 
        end
        @board[y][x - 1][4] = @player_turn
      end
      if right == @board[y][x][2] && x + 1 <= 2
        if @board[y][x + 1][4] != @player_turn
          @text_array.push(1) unless @text_array.first == 1
          @combo = true
          @flip_commands.push([true, @board[y][x + 1][5], @board[y][x + 1][6], x + 1, y]) 
        end
        @board[y][x + 1][4] = @player_turn	
      end
      if down == @board[y][x][3] && y + 1 <= 2
        if @board[y + 1][x][4] != @player_turn
          @text_array.push(1) unless @text_array.first == 1
          @combo = true
          @flip_commands.push([false, @board[y + 1][x][5], @board[y + 1][x][6], x, y + 1]) 
        end
        @board[y + 1][x][4] = @player_turn
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Condição plus
  #--------------------------------------------------------------------------
  def check_plus_condition(up, left, right, down, x, y)
  count_cards = 0
  opposite_card = false
  if @battle_info[6]
    up = 10 if up == 0 && y == 0
    left = 10 if left == 0 && x == 0
    right = 10 if right == 0 && x == 2
    down = 10 if down == 0 && y == 2
  end
	if up != 0
		up += @board[y][x][0]
	end
	if left != 0
		left += @board[y][x][1]
	end
	if right != 0
		right += @board[y][x][2]
	end
	if down != 0
		down += @board[y][x][3]
	end
	if up == left && up != 0 
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @board[y - 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y - 1][x][5], @board[y - 1][x][6], x, y - 1]) 
      end
    end
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @board[y][x - 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2 
        @combo = true
        @flip_commands.push([true, @board[y][x - 1][5], @board[y][x - 1][6], x - 1, y]) 
      end
    end
	end
	if up == right && up != 0
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @board[y - 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y - 1][x][5], @board[y - 1][x][6], x, y - 1]) 
      end
    end
    if x + 1 <= 2
      if @board[y][x + 1][4] != @player_turn
        @board[y][x + 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2 
        @combo = true
        @flip_commands.push([true, @board[y][x + 1][5], @board[y][x + 1][6], x + 1, y]) 
      end
    end
	end
	if up == down && up != 0 
    if y - 1 >= 0
      if @board[y - 1][x][4] != @player_turn
        @board[y - 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y - 1][x][5], @board[y - 1][x][6], x, y - 1]) 
      end
    end
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @board[y + 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y + 1][x][5], @board[y + 1][x][6], x, y + 1]) 
      end
    end
	end
	if left == down && left != 0
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @board[y][x - 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([true, @board[y][x - 1][5], @board[y][x - 1][6], x - 1, y]) 
      end
    end
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @board[y + 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y + 1][x][5], @board[y + 1][x][6], x, y + 1]) 
      end
    end
	end
	if left == right && left != 0
    if x + 1 <= 2 
      if @board[y][x + 1][4] != @player_turn
        @board[y][x + 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([true, @board[y][x + 1][5], @board[y][x + 1][6], x + 1, y]) 
      end
    end
    if x - 1 >= 0
      if @board[y][x - 1][4] != @player_turn
        @board[y][x - 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([true, @board[y][x - 1][5], @board[y][x - 1][6], x - 1, y]) 
      end
    end
	end
	if right == down && right != 0 
    if y + 1 <= 2
      if @board[y + 1][x][4] != @player_turn
        @board[y + 1][x][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([false, @board[y + 1][x][5], @board[y + 1][x][6], x, y + 1]) 
      end
    end
    if x + 1 <= 2
      if @board[y][x + 1][4] != @player_turn
        @board[y][x + 1][4] = @player_turn
        @text_array.push(2) unless @text_array.first == 2
        @combo = true
        @flip_commands.push([true, @board[y][x + 1][5], @board[y][x + 1][6], x + 1, y]) 
      end
    end
	end
end
  #--------------------------------------------------------------------------
  # * Condição Normal
  #--------------------------------------------------------------------------
  def check_normal_condition(up, left, right, down, x, y)
    if up != 0
      if up < @board[y][x][0] && y - 1 >= 0
        if @board[y - 1][x][4] != @player_turn
          @text_array.push(3) if @combo
          @flip_commands.push([false, @board[y - 1][x][5], @board[y - 1][x][6], x, y - 1]) 
        end
        @board[y - 1][x][4] = @player_turn
      end
    end
    if left != 0
      if left < @board[y][x][1] && x - 1 >= 0
        if @board[y][x - 1][4] != @player_turn
          @text_array.push(3) if @combo
          @flip_commands.push([true, @board[y][x - 1][5], @board[y][x - 1][6], x - 1, y]) 
        end
        @board[y][x - 1][4] = @player_turn
      end
    end
    if right != 0 
      if right < @board[y][x][2] && x + 1 <= 2
        if @board[y][x + 1][4] != @player_turn
          @text_array.push(3) if @combo
          @flip_commands.push([true, @board[y][x + 1][5], @board[y][x + 1][6], x + 1, y]) 
        end
        @board[y][x + 1][4] = @player_turn	
      end
    end
    if down != 0
      if down < @board[y][x][3] && y + 1 <= 2
        if @board[y + 1][x][4] != @player_turn
          @text_array.push(3) if @combo
          @flip_commands.push([false, @board[y + 1][x][5], @board[y + 1][x][6], x, y + 1]) 
        end
        @board[y + 1][x][4] = @player_turn
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Movimento da carta do jogador
  #--------------------------------------------------------------------------
  def move_player_card 
    if (@player_pics[@move_commands.first[4]].x - @move_commands.first[0]).abs >= 10
      @player_pics[@move_commands.first[4]].x += @move_commands.first[2]
    elsif (@player_pics[@move_commands.first[4]].x  - @move_commands.first[0]).abs != 0
     @player_pics[@move_commands.first[4]].x = @move_commands.first[0]
    end
    if (@player_pics[@move_commands.first[4]].y - @move_commands.first[1]).abs >= 10
      @player_pics[@move_commands.first[4]].y += @move_commands.first[3]
    elsif (@player_pics[@move_commands.first[4]].y  - @move_commands.first[1]).abs != 0
         @player_pics[@move_commands.first[4]].y = @move_commands.first[1]
    end
    if @player_pics[@move_commands.first[4]].y == @move_commands.first[1] && @player_pics[@move_commands.first[4]].x == @move_commands.first[0]
	@player_pics2[@move_commands.first[4]].y = @move_commands.first[1]
    @player_pics2[@move_commands.first[4]].x = @move_commands.first[0]
    @player_cards_hand.delete(@move_commands.first[4])
    @index = @npc_cards_hand.first
    move_to_cursor(@npc_pics[@index].x + Cursor_x, @npc_pics[@index].y + Cursor_y)
    @move_commands.shift
    @count = 0
    @npc_time = Normal_time + Random_time
    push_flips(@board_x, @board_y)
    @phase = 6
    end
  end
  #--------------------------------------------------------------------------
  # * Movimento da carta do NPC
  #--------------------------------------------------------------------------
  def move_npc_card 
    if (@npc_pics[@move_commands.first[4]].x - @move_commands.first[0]).abs >= 10
      @npc_pics[@move_commands.first[4]].x += @move_commands.first[2]
      @back_npc_cards[@move_commands.first[4]].x += @move_commands.first[2] unless @battle_info[8]
    elsif (@npc_pics[@move_commands.first[4]].x - @move_commands.first[0]).abs != 0
     @npc_pics[@move_commands.first[4]].x = @move_commands.first[0]
     @back_npc_cards[@move_commands.first[4]].x = @move_commands.first[0] unless @battle_info[8]
    end
    if (@npc_pics[@move_commands.first[4]].y - @move_commands.first[1]).abs >= 10
      @back_npc_cards[@move_commands.first[4]].y += @move_commands.first[3] unless @battle_info[8]
      @npc_pics[@move_commands.first[4]].y += @move_commands.first[3]
    elsif (@npc_pics[@move_commands.first[4]].y  - @move_commands.first[1]).abs != 0
         @npc_pics[@move_commands.first[4]].y = @move_commands.first[1]
         @back_npc_cards[@move_commands.first[4]].y = @move_commands.first[1] unless @battle_info[8]
    end
    if @npc_pics[@move_commands.first[4]].y == @move_commands.first[1] && @npc_pics[@move_commands.first[4]].x == @move_commands.first[0]
    @npc_pics2[@move_commands.first[4]].y = @move_commands.first[1]
    @npc_pics2[@move_commands.first[4]].x = @move_commands.first[0]
    @npc_cards_hand.delete(@move_commands.first[4])
    @index = @player_cards_hand.first
    unless @battle_info[8]
      @flip_npc_commands = false
      @the_flip = @move_commands.first[4]
      flip_npc_cards 
    end
    move_to_cursor(@player_pics[@index].x + Cursor_x, @player_pics[@index].y + Cursor_y)
    @move_commands.shift
    @count = 0
    @npc_time = 0
    push_flips(@board_x, @board_y)
    @phase = 6
    end
  end
  #--------------------------------------------------------------------------
  # * Cálculo da posição do cursor
  #--------------------------------------------------------------------------
  def move_to_board(x, y, index, p)
    if p == true
      @move_commands.push([x, y, (x - @player_pics[index].x)/ 10, (y - @player_pics[index].y)/ 10, index, p])
    else
      @move_commands.push([x, y, (x - @npc_pics[index].x)/ 10, (y - @npc_pics[index].y)/ 10, index, p])     
    end
  end
  #--------------------------------------------------------------------------
  # * Condição se há movimento de cartas no tabuleiro
  #--------------------------------------------------------------------------
  def card_moving?
    !@move_commands.empty? && !@flip_commands.empty? && @flip_npc_commands == false
  end
  #--------------------------------------------------------------------------
  # * Condição se há movimento de cursor
  #--------------------------------------------------------------------------
  def cursor_moving?
    @cursor.x != @goto_x || @goto_y != @cursor.y
  end
  #--------------------------------------------------------------------------
  # * Dispose de todos os gráficos
  #--------------------------------------------------------------------------
  def close_game
    @map_bgm.replay
    @map_bgs.replay
    @score_player1.each{|n| n.bitmap.dispose ; n.dispose}
    @score_player2.each{|n| n.bitmap.dispose ; n.dispose}
    @text_pics.each{|n| n.bitmap.dispose ; n.dispose}
    @background.bitmap.dispose
    @background.dispose
    @cursor.bitmap.dispose
    @cursor.dispose
    @arrow.bitmap.dispose
    @arrow.dispose
    for n in 0...3
      for i in 0...3
        @back_card[n][i].bitmap.dispose
        @back_card[n][i].dispose
      end
    end
    @player_pics.each{|n| n.bitmap.dispose ; n.dispose}
    @player_pics2.each{|n| n.bitmap.dispose ; n.dispose}
    @npc_pics.each{|n| n.bitmap.dispose ; n.dispose}
    @npc_pics2.each{|n| n.bitmap.dispose ; n.dispose}
    @player_turn_pic.each{|n| n.bitmap.dispose ; n.dispose}
    @back_npc_cards.each{|n| n.bitmap.dispose ; n.dispose} unless @battle_info[8]
    if @battle_info[8] == 0 || $game_variables[Variable] == 2 && @battle_info[8] != 2
      SceneManager.goto(Scene_Map)
    else
      SceneManager.call(Decision_Triple_Triad)
    end
  end
end


#==============================================================================
# ** Game_Timer
#------------------------------------------------------------------------------
#  Esta classe gerencia o cronômetro.
# A instância desta classe é referenciada por $game_timer.
#==============================================================================

class Game_Timer
alias :triple_triad_initialize :initialize
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor   :hand_deck               # Cartas escolhidas pelo personagem
  attr_accessor   :total_cards             # Cartas adquiridas
  attr_accessor   :game_triple_triad       # Detalhes do duelo
  attr_accessor   :npc_triple_triad        # Database de todas as cartas dos adversários
  attr_accessor   :npc_hand                # Mão do npc no duelo
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(*args, &block)
    @hand_deck = Array.new
    @total_cards = Array.new(Config_Triple_Triad::Card.size, 0)
    @game_triple_triad = Array.new(12, 0) 
    @game_triple_triad[2] = true # same
    @game_triple_triad[3] = true # plus
    @game_triple_triad[4] = true # combo
    @game_triple_triad[5] = true # same wall
    @game_triple_triad[6] = true # plus wall
    @game_triple_triad[7] = 1    # dificuldade do npc
    @game_triple_triad[8] = false #se as cartas vem fechadas
    @game_triple_triad[8] = 1 # condição de vitória
    @npc_triple_triad = Array.new
    for n in 0...Config_Triple_Triad::Enemy.size
      @npc_triple_triad[n] = Config_Triple_Triad::Enemy[n]['Cards']
    end
    @npc_hand = Array.new
    triple_triad_initialize(*args, &block)
  end
end


#==============================================================================
# ** Cache
#------------------------------------------------------------------------------
#  Este modulo carrega cada gráfico, cria um objeto de Bitmap e retém ele.
# Para acelerar o carregamento e preservar memória, este módulo matém o
# objeto de Bitmap em uma Hash interna, permitindo que retorne objetos
# pré-existentes quando mesmo Bitmap é requerido novamente.
#==============================================================================


module Cache
  #--------------------------------------------------------------------------
  # * Carregamento dos gráficos de animação
  #     filename : nome do arquivo
  #     hue      : informações da alteração de tonalidade
  #--------------------------------------------------------------------------
  def self.triple_triad(filename)
    load_bitmap("Graphics/Triple_Triad/", filename)
  end
end
$triple_force_5_cards = false
#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Um interpretador para executar os comandos de evento. Esta classe é usada
# internamente pelas classes Game_Map, Game_Troop e Game_Event.
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # * retorna número de cartas
  #--------------------------------------------------------------------------
  def total_triad_cards
    a = $game_temp.hand_deck
    a += $game_temp.total_cards.dup.sum
    return a
  end
  #--------------------------------------------------------------------------
  # * retorna número de cartas únicas
  #--------------------------------------------------------------------------
  def total_unique_cards
    a = $game_temp.total_cards.dup
    a.delete(0)
    return a.size
  end
  #--------------------------------------------------------------------------
  # * método principal que ativa o duelo
  #--------------------------------------------------------------------------
  def triple_triad(id)
    load_triad_enemy(id)
    $triple_force_5_cards = true
    SceneManager.call(Scene_Triad_Album)
  end
  #--------------------------------------------------------------------------
  # * força um jogador a iniciar a partida
  #--------------------------------------------------------------------------
  def force_player(play)
    $game_timer.game_triple_triad[1] = play
  end
  #--------------------------------------------------------------------------
  # * carregamento das info do adversário
  #--------------------------------------------------------------------------
  def load_triad_enemy(id)
    while $game_timer.npc_triple_triad[id].size < 5
      $game_timer.npc_triple_triad[id].push(Config_Triple_Triad::Enemy[id]['Reservecards'].shuffle.first)
    end
    $game_timer.npc_hand = $game_timer.npc_triple_triad[id].shuffle.take(5)
    $game_timer.game_triple_triad[0] = Config_Triple_Triad::Enemy[id]['Music']
    $game_timer.game_triple_triad[2] = Config_Triple_Triad::Enemy[id]['Same']
    $game_timer.game_triple_triad[3] = Config_Triple_Triad::Enemy[id]['Plus']
    $game_timer.game_triple_triad[4] = Config_Triple_Triad::Enemy[id]['Combo'] 
    $game_timer.game_triple_triad[5] = Config_Triple_Triad::Enemy[id]['Samewall'] 
    $game_timer.game_triple_triad[6] = Config_Triple_Triad::Enemy[id]['Pluswall']
    $game_timer.game_triple_triad[7] = Config_Triple_Triad::Enemy[id]['AI']   
    $game_timer.game_triple_triad[8] = Config_Triple_Triad::Enemy[id]['Open'] 
    $game_timer.game_triple_triad[9] = Config_Triple_Triad::Enemy[id]['Win'] 
    $game_timer.game_triple_triad[10] = id
  end
end

#==============================================================================
# ** Triple_Triad_Rules 
#------------------------------------------------------------------------------
#  Esta classe gerencia a tela de regras do duelo
#==============================================================================
class Triple_Triad_Rules < Window_Base
include Config_Triple_Triad
  #--------------------------------------------------------------------------
  # * Inicialização
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 272, 300)
    @battle_info = $game_timer.game_triple_triad.dup
    refresh
  end
  #--------------------------------------------------------------------------
  # * largura da janela
  #--------------------------------------------------------------------------
  def window_width
    272
  end
  #--------------------------------------------------------------------------
  # * atualização
  #--------------------------------------------------------------------------
  def refresh
    contents.clear
    contents.font.size = Text_size
    contents.font.name = Text_font
    contents.font.size += 8
    draw_text(0, 0, window_width, fitting_height(1), Title_Rule, 1)
    contents.font.size -= 8
    for n in 0..5
      draw_text(0, fitting_height(n+1), window_width - 50, fitting_height(1), Rule_Texts[n], 0)
    end
    for n in 0..4
      @battle_info[n + 2] == true ? a = 0 : a = 1
      draw_text(0, fitting_height(n+1), window_width - 50, fitting_height(1), Rule_Answ[a], 2)
    end
    case @battle_info[9]
    when 1
      draw_text(0, fitting_height(6), window_width - 50, fitting_height(1), Win_Tex[0], 2)
    when 2
      draw_text(0, fitting_height(6), window_width - 50, fitting_height(1), Win_Tex[1], 2)
    when 3
      draw_text(0, fitting_height(6), window_width - 50, fitting_height(1), Win_Tex[2], 2)
    end
    reset_font_settings
  end
end