Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #=======================================================
- # 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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement