Mini juego sudoku

[Sampi 0]

Se puede quitar el sdk

Instrucciones en el script

CODE

#==============================================================================
# ** Sudoku Puzzles
#------------------------------------------------------------------------------
# SephirothSpawn
# Version 1
# 2006-08-06
#------------------------------------------------------------------------------
# * Description:
#
#  ~ Creates Randomized Sudoku Puzzles and Allows the Player to Solve Them
#  ~ This Script will create a data file for all solutions the engine will
#    come up with. Make sure you run the solution maker enough times for
#    random solutions
#------------------------------------------------------------------------------
# * Controls:
#
#  ~ Direction Keys : Moves Cursor From Cell to Cell
#  ~ L & R : Increase and Decrease Cell Number
#------------------------------------------------------------------------------
# * Installation:
#
#  ~ Place the Script below the RMXP SDK and above main
#  ~ Customize the Sudoku_Puzzles module for puzzle data (Customization Below)
#------------------------------------------------------------------------------
# * Instructions:
#
#  ~ To Create A Solution File, use a Call script with:
#    Call Script : SudokuPuzzles.generate_solution
#
# ** Note that the game can crash. This is normal. Just run it again.
#    It happens because it retries too many times to create a table without
#    success.
#
#  ~ To Open a Puzzle, use the syntax:
#    $scene.open_sudokupuzzle(puzzle_id, numbers_given)
#    numbers_given is the number of cells maker gives you
#
#  ~ To Reset a Puzzle, use the syntax:
#    $game_sudokupuzzles.reset_puzzle_data(puzzle_id)
#
#  ~ To Test for solved puzzle, use the syntax:
#    $game_sudokupuzzles[puzzle_id].solved?
#------------------------------------------------------------------------------
# * Customization:
#   (refer to module SudokuPuzzles)
#
#  ~ To Create a Solution File in the Game Folder:
#    Create_Solution_File = true (ON) or false (OFF)
#
#  ~ Sound Effects
#    Puzzle_Solved_SE = RPG::AudioFile
#    Puzzle_Unsolved_SE = RPG::AudioFile
#
#  ~ Default Number of Cells Given
#    Default_Difficulty = N
#------------------------------------------------------------------------------
# * Thanks To Zeriab for bug fix
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
SDK.log('Sudoku Puzzles', 'SephirothSpawn', 1, '2006-08-06')

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
if SDK.state('Sudoku Puzzles') == true
 
#==============================================================================
# ** SudokuPuzzles
#==============================================================================

module SudokuPuzzles
 #--------------------------------------------------------------------------
 # * Create Solution File
 #--------------------------------------------------------------------------
 Create_Solution_File = true
 #--------------------------------------------------------------------------
 # * Sound Effects
 #--------------------------------------------------------------------------
 Puzzle_Solved_SE = load_data("Data/System.rxdata").decision_se
 Puzzle_Unsolved_SE = load_data("Data/System.rxdata").buzzer_se
 #--------------------------------------------------------------------------
 # * Default Difficulty
 #
 #  ~ How Many Will be showed upon start up
 #--------------------------------------------------------------------------
 Default_Difficulty = 35
 #--------------------------------------------------------------------------
 # * This Will Save All Solutions the Maker Comes Up With
 #--------------------------------------------------------------------------
 def self.save_solution(solution_table)
   # Test For Saved Solution File
   unless FileTest.exist?('Data/SudokuSolutions.rxdata')
     save_data({}, 'Data/SudokuSolutions.rxdata')
   end
   # Collects Saved Solution List
   saved_solutions = load_data('Data/SudokuSolutions.rxdata')
   # Saves List to Data File
   saved_solutions << solution_table
   # Resaves New Solution to File
   save_data(saved_solutions, 'Data/SudokuSolutions.rxdata')
 end
 #--------------------------------------------------------------------------
 # * Generate Solution
 #--------------------------------------------------------------------------
 def self.generate_solution
   # Creates Solution Table Data
   @solution = Table.new(9, 9)
   # Assigns Each Tile a Number
   81.times do
     # Collects Cell Ranges
     ranges = self.collect_cell_ranges
     # If No Ranges
     if ranges.nil?
       self.generate_solution
       return
     end
     # Gets Min Range
     min_range = ranges.values.min
     # Gets Index of Min Range
     index = ranges.index(min_range)
     # Gets Index X Y Coordinates
     x = index % 9
     y = index / 9
     # Collects Ranges
     range = self.collect_range(x, y)
     # Sets Solution Value
     @solution[x, y] = range[rand(range.size)]
   end
   # Saves Solution to Data File
   self.save_solution(@solution)
 end
 #--------------------------------------------------------------------------
 # * Collect Cell Ranges
 #--------------------------------------------------------------------------
 def self.collect_cell_ranges
   # Starts Ranges Hash
   ranges = {}
   # Checks All Cells
   for i in 0...81
     # Gets X Y Coordinates
     x = i % 9
     y = i / 9
     # If No Number in Cell
     if @solution[x, y] == 0
       # If No Possible Range For Cell
       if self.collect_range(x, y).size == 0
         # Restart Setup Solution
         self.generate_solution
         return
       end
       # Store Range
       ranges[i] = collect_range(x, y).size
     end
   end
   # Return Ranges
   return ranges
 end
 #--------------------------------------------------------------------------
 # * Collects Possible Numbers For Cell
 #--------------------------------------------------------------------------
 def self.collect_range(x, y)
   # Gets All Possible Numbers
   range = (1..9).to_a
   # Checks Column & Row Numbers And Removes Impossible Numbers
   for i in 0...9
     if range.include?(@solution[i, y])
       range.delete(@solution[i, y])
     end
     if range.include?(@solution[x, i])
       range.delete(@solution[x, i])
     end
   end
   # Checks Sub-Cell And Removes Impossible Numbers
   subcell_size = 3
   subcell_x = x / subcell_size
   subcell_y = y / subcell_size
   for y_count in 0...subcell_size
     for x_count in 0...subcell_size
       x_ = subcell_x * subcell_size + x_count
       y_ = subcell_y * subcell_size + y_count
       if range.include?(@solution[x_, y_])
         range.delete(@solution[x_, y_])
       end
     end
   end
   # Returns Possible Numbers
   return range
 end
end

#==============================================================================
# ** Game_SudokuPuzzles
#==============================================================================

class Game_SudokuPuzzles
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
   # Starts Data
   @data = []
 end
 #--------------------------------------------------------------------------
 # * Get Puzzle Data
 #--------------------------------------------------------------------------
 def [](puzzle_id, number_cells = SudokuPuzzles::Default_Difficulty)
   # Creates Unstarted Data
   if @data[puzzle_id].nil?
     @data[puzzle_id] = Game_SudokuPuzzle.new(number_cells)
   end
   return @data[puzzle_id]
 end
 #--------------------------------------------------------------------------
 # * Reset Puzzle Data
 #--------------------------------------------------------------------------
 def reset_puzzle_data(puzzle_id)
   n = number_cells = SudokuPuzzles::Default_Difficulty
   unless @data[puzzle_id].nil?
     n = @data[puzzle_id].number_cells
   end
   @data[puzzle_id] = Game_SudokuPuzzle.new(n)
 end
end

#==============================================================================
# ** Game_SudokuPuzzle
#==============================================================================

class Game_SudokuPuzzle
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader :number_cells
 attr_reader :showncells
 attr_reader :player_numbers
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize(number_cells = SudokuPuzzles::Default_Difficulty)
   # Picks Random Solution File
   saved_solutions = load_data('Data/SudokuSolutions.rxdata')
   @solution = saved_solutions[rand(saved_solutions.size)]
   # Sets Up Shown Cell Numbers & Player Cells
   @number_cells = number_cells
   setup_showncells(number_cells)
   # Creates Solution File
   if SudokuPuzzles::Create_Solution_File
     @solution.create_file('Sudoku Solution File.txt')
   end
 end
 #--------------------------------------------------------------------------
 # * Sets Up Shown Cells
 #--------------------------------------------------------------------------
 def setup_showncells(number_cells)
   @showncells = Table.new(9, 9)
   @player_numbers = Table.new(9, 9)
   i = 0
   until i == number_cells
     x, y = rand(9), rand(9)
     if @showncells[x, y] == 0
       @showncells[x, y] = @solution[x, y]
       @player_numbers[x, y] = @solution[x, y]
       i += 1
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Solved
 #--------------------------------------------------------------------------
 def solved?
   # Test Player Entered Each Number
   for x in 0..8
     for y in 0..8
       return false if @player_numbers[x, y] == 0
     end
   end
   # Test Rows
   for i in 0..8
     return false unless test_rows(i)
   end
   # Test Columns
   for i in 0..8
     return false unless test_columns(i)
   end
   # Test Sub-Cells
   for i in 0..8
     return false unless test_subcells(i)
   end
   # Return Solved
   return true
 end
 #--------------------------------------------------------------------------
 # * Test Row Numbers
 #--------------------------------------------------------------------------
 def test_rows(y)
   numbers = []
   for i in 0..8
     return false if numbers.include?(@player_numbers[i, y])
     numbers << @player_numbers[i, y]
   end
   return numbers.sort == (1..9).to_a
 end
 #--------------------------------------------------------------------------
 # * Collect Column Numbers
 #--------------------------------------------------------------------------
 def test_columns(x)
   numbers = []
   for i in 0..8
     return false if numbers.include?(@player_numbers[x, i])
     numbers << @player_numbers[x, i]
   end
   return numbers.sort == (1..9).to_a
 end
 #--------------------------------------------------------------------------
 # * Collect Sub-Cell Numbers
 #--------------------------------------------------------------------------
 def test_subcells(n)
   numbers = []
   subcell_x = n % 3
   subcell_y = n / 3
   for x in 0..2
     for y in 0..2
       i = subcell_x * 3 + x
       j = subcell_y * 3 + y
       return false if numbers.include?(@player_numbers[i, j])
       numbers << @player_numbers[i, j]
     end
   end
   return numbers.sort == (1..9).to_a
 end
 #--------------------------------------------------------------------------
 # * Reset
 #--------------------------------------------------------------------------
 def reset
   @player_numbers = @showncells.dup
 end
end

#==============================================================================
# ** Window_SudokuPuzzle
#==============================================================================

class Window_SudokuPuzzle < Window_Base
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader :puzzle
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize(puzzle_id)
   super(196, 100, 249, 280)
   self.contents = Bitmap.new(width - 32, height - 32)
   # Sets Puzzle Data
   @puzzle = $game_sudokupuzzles[puzzle_id]
   @puzzle_id = puzzle_id
   # Refresh Contents
   refresh
   @index = 0
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   # Draws Grid
   for i in [1, 2, 4, 5, 7, 8]
     self.contents.fill_rect(0, i * 24, 216, 1, Color.new(0, 0, 0, 255))
     self.contents.fill_rect(i * 24, 0, 1, 216, Color.new(0, 0, 0, 255))
   end
   for i in [0, 3, 6, 9]
     color =
     self.contents.fill_rect(0, i * 24, 216, 1, Color.new(200, 0, 0, 255))
     self.contents.fill_rect(i * 24, 0, 1, 216, Color.new(200, 0, 0, 255))
   end
   # Redraws Cell Data
   for x in 0..9
     for y in 0..9
       refresh_celldata(x, y)
     end
   end
   # Draws Puzzle Options
   self.contents.draw_text(0, 220, 108, 24, 'Restart', 1)
   self.contents.draw_text(108, 220, 108, 24, 'New Puzzle', 1)
 end
 #--------------------------------------------------------------------------
 # * Refresh Cell Data
 #--------------------------------------------------------------------------
 def refresh_celldata(x, y)
   # Gets Cell Rect
   rect = Rect.new(x * 24 + 1, y * 24 + 1, 23, 23)
   # Clears Rect
   self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
   # If Given Cell
   unless @puzzle.showncells[x, y] == 0
     self.contents.font.color = system_color
     self.contents.draw_text(rect, @puzzle.showncells[x, y].to_s, 1)
     self.contents.font.color = normal_color
     return
   end
   # Gets Player Number
   n = @puzzle.player_numbers[x, y]
   # Draws Player Number
   unless n == 0
     self.contents.draw_text(rect, n.to_s, 1)
   end
 end
 #--------------------------------------------------------------------------
 # * Update
 #--------------------------------------------------------------------------
 def update
   super
   # If Right is Pressed
   if Input.repeat?(Input::RIGHT)
     $game_system.se_play($data_system.cursor_se)
     @index = @index == 82 ? 0 : @index + 1
   # If Left is Pressed
   elsif Input.repeat?(Input::LEFT)
     $game_system.se_play($data_system.cursor_se)
     @index = @index == 0 ? 82 : @index - 1
   # If Up is Pressed
   elsif Input.repeat?(Input::UP)
     $game_system.se_play($data_system.cursor_se)
     if @index > 80
       @index -= 9
       return
     end
     top_index = (0..8).to_a
     bottom_index = (72..80).to_a
     if top_index.include?(@index)
       @index = bottom_index[top_index.index(@index)]
     else
       @index -= 9
     end
   # If Down is Pressed
   elsif Input.repeat?(Input::DOWN)
     return if @index > 80
     $game_system.se_play($data_system.cursor_se)
     top_index = (0..8).to_a
     bottom_index = (72..80).to_a
     if bottom_index.include?(@index)
       @index = 81 # top_index[bottom_index.index(@index)]
     else
       @index += 9
     end
   end
   # Collects X and Y
   x = @index % 9
   y = @index / 9
   # If L is Pressed
   if Input.trigger?(Input::R)
     # If Non-Shown Cell
     unless @puzzle.showncells[x, y] == 0
       # Play Buzzer Se
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Increases Player Number Cell
     @puzzle.player_numbers[x, y] = @puzzle.player_numbers[x, y] == 9 ?
       0 : @puzzle.player_numbers[x, y] + 1
     # Refreshes Cell Number
     refresh_celldata(x, y)
   # If R Button is Pressed
   elsif Input.trigger?(Input::L)
     # If Non-Shown Cell
     unless @puzzle.showncells[x, y] == 0
       # Play Buzzer Se
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Decreases Player Number Cell
     @puzzle.player_numbers[x, y] = @puzzle.player_numbers[x, y] == 0 ?
       9 : @puzzle.player_numbers[x, y] - 1
     # Refreshes Cell Number
     refresh_celldata(x, y)
   end
   # If C Button Is Pressed
   if Input.trigger?(Input::C)
     # Return if Not Puzzle Option
     return unless [81, 82].include?(@index)
     # Play decision Se
     $game_system.se_play($data_system.decision_se)
     # If Restart Puzzle
     if @index == 81
       @puzzle.reset
       refresh
     end
     # If New Puzzle
     if @index == 82
       $game_sudokupuzzles.reset_puzzle_data(@puzzle_id)
       @puzzle = $game_sudokupuzzles[@puzzle_id]
       refresh
     end
   end
   # Update Cursor Rect
   update_cursor_rect
 end
 #--------------------------------------------------------------------------
 # * Cursor Rectangle Update
 #--------------------------------------------------------------------------
 def update_cursor_rect
   # If Grid Index
   if @index < 81
     self.cursor_rect.set(@index % 9 * 24 + 1, @index / 9 * 24 + 1, 23, 23)
   else
     self.cursor_rect.set(@index == 81 ? 0 : 108, 220, 108, 24)
   end
 end
end

#==============================================================================
# ** Table
#==============================================================================

class Table
 #--------------------------------------------------------------------------
 # * Create File with Data
 #--------------------------------------------------------------------------
 def create_file(filename = 'Table Inspection.txt')
   file = File.open(filename, 'wb')
   for z in 0...self.zsize
     for y in 0...self.ysize
       for x in 0...self.xsize
         file.write("#{self[x, y]}")
       end
       file.write('\n')
     end
     file.write('\n\n')
   end
   file.close
 end
end

#==============================================================================
# ** Scene_Map
#==============================================================================

class Scene_Map
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias seph_sudokupuzzles_scnmap_update update
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
   # If Shift Puzzle Active
   unless @seph_sudokupuzzle_window.nil?
     update_seph_sudokupuzzle
     return
   end
   # Original Update
   seph_sudokupuzzles_scnmap_update
 end
 #--------------------------------------------------------------------------
 # * Frame Update : Seph Sudoku Puzzle
 #--------------------------------------------------------------------------
 def update_seph_sudokupuzzle
   # Update Shift Puzzle Window
   @seph_sudokupuzzle_window.update
   # Update Map and Spriteset
   $game_map.update
   $game_system.map_interpreter.update
   $game_system.update
   $game_screen.update
   @spriteset.update
   @message_window.update
   # If B Button is Pressed
   if Input.trigger?(Input::B)
     # If Puzzle Solved
     if @seph_sudokupuzzle_window.puzzle.solved?
       # Play Solved SE
       $game_system.se_play(SudokuPuzzles::Puzzle_Solved_SE)
     else
       # Play Unsolved SE
       $game_system.se_play(SudokuPuzzles::Puzzle_Unsolved_SE)
     end
     # Dispose Window
     @seph_sudokupuzzle_window.dispose
     @seph_sudokupuzzle_window = nil
   end
 end
 #--------------------------------------------------------------------------
 # * Open Sudoku Puzzle
 #--------------------------------------------------------------------------
 def open_sudokupuzzle(puzzle_id = 1)
   # Creates Shift Puzzle Window
   @seph_sudokupuzzle_window = Window_SudokuPuzzle.new(puzzle_id)
 end
end

#==============================================================================
# ** Scene_Title
#==============================================================================

class Scene_Title
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias seph_sudokupuzzles_scnttl_cng command_new_game
 #--------------------------------------------------------------------------
 # * Command : New Game
 #--------------------------------------------------------------------------
 def command_new_game
   # Original Command New Game
   seph_sudokupuzzles_scnttl_cng
   # Creates Sudoku Puzzle Game Data
   $game_sudokupuzzles = Game_SudokuPuzzles.new
 end
end

#==============================================================================
# ** Scene_Save
#==============================================================================

class Scene_Save
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias seph_sudokupuzzles_scnsave_wd write_data
 #--------------------------------------------------------------------------
 # * Command : New Game
 #--------------------------------------------------------------------------
 def write_data(file)
   # Original Write Data
   seph_sudokupuzzles_scnsave_wd(file)
   # Saves Sudoku Puzzle Data
   Marshal.dump($game_sudokupuzzles, file)
 end
end

#==============================================================================
# ** Scene_Load
#==============================================================================

class Scene_Load
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias seph_sudokupuzzles_scnload_rd read_data
 #--------------------------------------------------------------------------
 # * Command : New Game
 #--------------------------------------------------------------------------
 def read_data(file)
   # Original Write Data
   seph_sudokupuzzles_scnload_rd(file)
   # Saves Sudoku Puzzle Data
   $game_sudokupuzzles = Marshal.load(file)
 end
end

#------------------------------------------------------------------------------
# * End SDK Enable Test
#------------------------------------------------------------------------------
end

[Fegarur 0]

Eso no me lo esperaba, u juego de Sudokus. xD
Pero no lo pienso usar en el juego... no queda muy bien... interesante de todas formas.

[Sampi 0]

Eso no me lo esperaba, u juego de Sudokus. xD
Pero no lo pienso usar en el juego... no queda muy bien... interesante de todas formas.
[right][snapback]278[/snapback][/right]

es para poner k en el juego le salga un sudoku

[xXDarkDragonXx 1]

Jajaja, un script hecho por el dios SephirothSpawn. Muy bueno este mini-juego.

[Soramar0 0]

perdonen mi ignorancia pero ¿sudokus?

[DeathRPG 0]

como no vas a saber?
apuesto que aya en venezuela, ese comunista del hugo chavez encontró que los sudokus promovían el capitalismo y los prohibió. En fin, aki te enteras de lo que es:
http://www.sudokumania.com.ar/reglas-sudoku.htm

[Soramar0 0]

asha lo jugue una vez en nintendo ds xDD (me aburrio por cierto) xDD

[elneo 0]

el soduko no me gusta XDD,pero bueno es script rulez.

[Fegarur 0]

Dadle una oportunidad... sólo echadle paciencia... el script mola, pero sencillamente no lo veo en un juego de rol.

[Soramar0 0]

es interesante un juego asi en el maker

[Bahamut_12 0]

Muy buen aporte

te lo digo por que el sodoku salio este año en colombia barranquilla

[edugonrod 0]

sudoku en rpg maker

os habeis preguntado al gunavez por que el nombre parece japones si lo invento un matematico europeo (no me acuertdo de donde)

[sLiVeR 0]

Lo veo muy bien, tanta gente pidiendo minijuegos originales, pues un sudoku me parece un muy buen minujuego que ponga a prueba al jugador, muy bien

[DeathRPG 0]

sudoku en rpg maker

os habeis preguntado al gunavez por que el nombre parece japones si lo invento un matematico europeo (no me acuertdo de donde)
[right][snapback]10002[/snapback][/right]

Porque el nombre es japonés, en japón fue el primer lugar donde se masificaron y donde se establecieron la mayoría de las reglas del sudoku que conocemos

[Guest viktorkrumluisunoss]

puedes poner una screen de como queda por favor?