Últimos temas
» Pack de Rpg maker XP
por KRiZaLiD Ayer a las 7:17 pm

» (ACE) Succubus Academy
por Kuroneko Gore Ayer a las 4:34 am

» Good Lyca Demo
por nazo493 Vie Sep 22, 2017 6:52 am

» [VX ACE] Black Winter - Terror y Suspenso - Descargalo ya!
por lolachan-desuu Jue Sep 21, 2017 6:30 pm

» Hoseki (Versión de Prueba)
por The Ferydra Jue Sep 21, 2017 4:58 am

» Duda mapeado rpg maker xp
por LordIthacar Jue Sep 21, 2017 4:02 am

» La Historia Infinita (DEMO)
por Chioban Miér Sep 20, 2017 7:35 am

» The Legend of Celestia II: A World of Twilight Shadows Demo
por jlopez_96 Dom Sep 17, 2017 6:27 pm

» Pregunta sobre el RPG Maker Fes ¿está permitido hablar o presentar juegos con este nuevo maker?
por Muzgar Sáb Sep 16, 2017 11:21 am

» Rpg Maker VX Ace: Lampara que se apaguen y enciendan.
por Muzgar Jue Sep 14, 2017 10:39 pm

» Pregunta sobre colaboracion en linea
por Tomate Jue Sep 14, 2017 9:23 pm

» [ACE] Nuevas partes para el generador (solo para faces)
por MargarArts Jue Sep 14, 2017 8:08 pm


Tetris (XP)

Ver el tema anterior Ver el tema siguiente Ir abajo

Tetris (XP)

Mensaje por Alojzy el Miér Mar 05, 2014 3:34 pm

Hola otra vez!

Aqui os traigo un script que nos permite jugar a este clásico juego como lo es el tetris

Código:
#-------------------------------------------------------------------------------------------------------------------------------
#Dans un evenement, faire "inserer un script" et taper :
#Pour lancer le jeu
#Tetris.start(niveau)
#remplacer niveau par le niveau auquel le jeu commence (1 par défaut)
#-------------------------------------------------------------------------------------------------------------------------------
#Pour recuperer le score dans une variable :
#Tetris.score_to_var(num)
#En replaçant num par le numéro de la variable
#De même pour récuperer le nombre de ligne détruite ou le niveau atteint :
#Tetris.ligne_to_var(num)
#ou
#Tetris.niveau_to_var(num)
#=======================================================================

module Tetris
#Le fond d'écran : remplacer nil par le nom du fichier sans l'extension ( doit se trouver dans le dossier Pictures).
FOND_ECRAN = nil
#Changer les deux premieres coordonnés pour déplacer les différents éléments du jeu
  ECRAN_JEU = Viewport.new(52, 0, 210, 462)
  ECRAN_PIECE = Rect.new(400, 80, 116, 116)
  ECRAN_SCORE = Rect.new(360, 220, 200, 122)
  
  
#======================================================================
#Définitions des différentes pieces avec leurs couleurs
#======================================================================
  
  PIECES = [[[[false, false, false, false],
                        [false, true, true, false],
                        [false, true, true, false],
                        [false, false, false, false]],
                        Color.new(0, 0, 255)],
                      [[[false, true, false, false],
                        [false, true,false, false],
                        [false, true, false, false],
                        [false, true, false, false]],
                        Color.new(255, 0, 0)],
                      [[[false, false, false, false],
                        [false, true, false, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(255, 85, 0)],
                      [[[false, false, false, false],
                        [false, true,true, false],
                        [true, true, false, false],
                        [false, false, false, false]],
                        Color.new(0, 255, 0)],
                      [[[false, false, false, false],
                        [false, true,true, false],
                        [false, false, true, true],
                        [false, false, false, false]],
                        Color.new(255, 0, 255)],
                      [[[false, false, false, false],
                        [false, false,true, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(255, 255, 0)],
                      [[[false, false, false, false],
                        [true, false,false, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(119, 85, 136)]]
  
#=======================================================================
#Demarre le jeu
#=======================================================================
  def Tetris.start(n = 1)
    @score = 0
    @ligne = 0
    @niveau = 0
    $scene = Scene_Jeu.new(n)
  end
  
#=======================================================================
#Score, nombre de lignes détruites et niveau
#=======================================================================
  def Tetris.score(s = 0)
    @score += s
    return @score
  end
  
  def Tetris.score_to_var(n)
    $game_variables[n] = @score
  end
  
  def Tetris.ligne(l = 0)
    @ligne += l
    return @ligne
  end
  
  def Tetris.ligne_to_var(n)
    $game_variables[n] = @ligne
  end
  
  def Tetris.niveau(n = 0)
    @niveau += n
  return @niveau
  
  def Tetris.niveau_to_var(n)
    $game_variables[n] = @niveau
  end
    
  end
  
  
#=======================================================================
#PIECE
#=======================================================================
  class Piece < Sprite
  attr_reader :matrice
    def initialize
      super(ECRAN_JEU)
      @piece = PIECES[rand(7)]
      @matrice = @piece[0]
      self.bitmap = Bitmap.new(84, 84)
      @couleur = @piece[1]
      self.y = 0
      self.x = 42
      @undo = proc {self.visible = false}
      refresh
    end
    
    def refresh
      self.bitmap.clear
      4.times do |i|
        4.times do |j|
          if @matrice[j][i]
            rect1 = Rect.new(21 * i, 21 * j, 21, 21)
            rect2 = Rect.new(21 * i + 1, 21 * j + 1, 19, 19)
            self.bitmap.fill_rect(rect1, Color.new(0, 255, 255))
            self.bitmap.fill_rect(rect2, @couleur)
          end
        end
      end
    end
    
    def move_left
      @undo = proc {move_right}
      self.x -= 21
    end
    
    def move_right
      @undo = proc {move_left}
      self.x += 21
    end
    
    def rotate_right
      @undo = proc {rotate_left}
      piece = [[],[],[],[]]
      4.times do |i|
        4.times do |j|
          piece[i][j] = @matrice[3 - j][i]
        end
      end
      @matrice = piece
      refresh
    end
    
    def rotate_left
      @undo = proc {rotate_right}
      piece = [[],[],[],[]]
      4.times do |i|
        4.times do |j|
          piece[i][j] = @matrice[j][3 - i]
        end
      end
      @matrice = piece
      refresh
    end
    
    def move
      @undo = proc {self.y -= 21}
      self.y += 21
    end
    
    def undo
      @undo.call
    end
  end

#=======================================================================
#Affichage du score
#=======================================================================
  class Score < Window_Base
    def initialize
      super(ECRAN_SCORE.x, ECRAN_SCORE.y, ECRAN_SCORE.width, ECRAN_SCORE.height)
      self.contents = Bitmap.new(self.width - 32, self.height - 32)
      self.contents.font = Font.new($fontface , 24)
      self.contents.font.color = Color.new(255, 255, 0)
      self.opacity = 180
      self.z = 2
      refresh
    end
    
    def refresh
      self.contents.clear
      self.contents.draw_text(0, 0, 200, 30, "Nivel : #{Tetris.niveau}")
      self.contents.draw_text(0, 30, 200, 30, "Lineas : #{Tetris.ligne}")
      self.contents.draw_text(0, 60, 200, 30, "Puntaje : #{Tetris.score}")
    end
    
    def niveau(l)
      Tetris.niveau(1) if Tetris.ligne / 10 != Tetris.ligne(l) / 10
      Tetris.score(10 * l * (l + 1) / 2)
      refresh
    end
  end
  
#======================================================================
#fenetre pour afficher la piece suivante
#======================================================================
  class Window_Piece < Window_Base
    def initialize
      super(ECRAN_PIECE.x, ECRAN_PIECE.y, ECRAN_PIECE.width, ECRAN_PIECE.height)
      self.opacity = 180
      self.z = 2
    end    
  end
  
#=======================================================================
#Fenetre de fin du jeu
#=======================================================================
  class Window_Fin < Window_Base
    def initialize
      super(150, 100, 300, 100)
      self.contents = Bitmap.new(self.width - 32, self.height - 32)
      self.contents.font = Font.new($fontface, 40)
      self.contents.font.color = Color.new(255, 255, 0)
      self.z = 10
      refresh
    end
    
    def refresh
      self.contents.clear
      self.contents.draw_text(0, 14, self.width - 32, 40, "Puntaje : #{Tetris.score}", 1)
    end
  end
  
#=======================================================================
#Scene du jeu
#=======================================================================
  class Scene_Jeu
    def initialize(niveau = 1)
      @ecran_jeu = Sprite.new(ECRAN_JEU)
      @ecran_jeu.bitmap = Bitmap.new(210, 462)
      @window_piece = Window_Piece.new
      bgm_play = "mario"
      unless FOND_ECRAN == nil
        @fond = Plane.new
        @fond.bitmap = Bitmap.new("Graphics/Pictures/amigo")
        @fond.z = -1
      end      
      @piece = Piece.new
      @suivante = Piece.new
      @suivante.visible = false
      @window_piece.contents = @suivante.bitmap
      @puit = Array.new(24)
     24.times do |y|
        @puit[y] = Array.new(12, false)
        @puit[y][0] = @puit [y][11] = true
      end
      12.times do |x|
        @puit[22][x] = @puit[23][x] = true
      end
      afficher_puit
      @vitesse = 0.75**niveau
      @temps = Time.new
      Tetris.niveau(niveau)
      @ligne = 0
      @score = Score.new
    end
    
    def main
      Graphics.transition
      loop do
        Graphics.update
        Input.update
        update
        break if $scene != self
      end
      @piece.dispose
      @score.dispose
      @fond.dispose unless FOND_ECRAN == nil
      @suivante.dispose
      @ecran_jeu.dispose
      @murs.dispose
      @window_piece.dispose
    end
    
    def update
      @piece.move_left if Input.repeat?(Input::LEFT)
      @piece.move_right if Input.repeat?(Input::RIGHT)
      @piece.rotate_left if Input.trigger?(Input::C)
      @piece.undo if test_piece
      
      game_over if Input.trigger?(Input::B)
      
      if Input.press?(Input::DOWN)
        Graphics.update
        Graphics.update
        @temps = Time.new
        @piece.move
        pose_piece if test_piece
      elsif (Time.new - @temps) > @vitesse
        @temps = Time.new
        @piece.move
        pose_piece if test_piece
      end
    end
    
#=======================================================================
#Affiche le puit
#=======================================================================
    def afficher_puit
      @murs = Sprite.new
      @murs.bitmap = Bitmap.new(252,483)
      @murs.x = ECRAN_JEU.rect.x - 21
      @murs.y = ECRAN_JEU.rect.y
      @murs.z = 1
      23.times do |y|
        @murs.bitmap.fill_rect(0, 21 * y, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(1, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
        @murs.bitmap.fill_rect(231, 21 * y, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(232, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
      end
      for x in 1..10
        @murs.bitmap.fill_rect(21 * x, 462, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(21 * x + 1, 463, 19, 19, Color.new(67, 210, 154))
      end
    end

#=======================================================================
#Teste si la piece est bien placé
#=======================================================================
    def test_piece
      x = @piece. x / 21 + 1
      y = @piece.y / 21
      4.times do |j|
        4.times do |i|
          return true if @piece.matrice[ j][i] and @puit[y + j][x + i]
        end
      end
      return false
    end

#=======================================================================
#Pose la piece
#=======================================================================
    def pose_piece
      @piece.undo
      @ecran_jeu.bitmap.blt(@piece.x, @piece.y, @piece.bitmap, Rect.new(0, 0, 84, 84))
      x = @piece. x / 21 + 1
      y = @piece.y / 21
      4.times do |j|
        4.times do |i|
          @puit[y + j][x + i] = true if @piece.matrice[j][i]
        end
      end
      count = 0
      for i in y..[y + 4, 21].min  do
        if test_ligne(i)
          supprime_ligne(i)
          count += 1
        end
      end
      @score.niveau(count)
      @vitesse = 0.75**Tetris.niveau
      @piece.dispose
      @piece = @suivante
      @piece.visible = true
      if test_piece
        @piece.undo
        game_over
      end
      @suivante = Piece.new
      @suivante.visible = false
      @window_piece.contents = @suivante.bitmap
    end
    
#=======================================================================
#teste si une ligne est complété
#=======================================================================
    def test_ligne(y)
      r = true
      for x in 1..10 do
        unless @puit[y][x]
          r = false
          break
        end
      end
      return r
    end

#=======================================================================
#Supprime une ligne
#========================================================================
    def supprime_ligne(ligne)
      y = ligne * 21
      image = Bitmap.new(210, 462)
      image.blt(0, 21, @ecran_jeu.bitmap, Rect.new(0, 0, 210, y))
      image.blt(0, y + 21, @ecran_jeu.bitmap, Rect.new(0, y + 21, 210, 451 - y))
      @ecran_jeu.bitmap.clear
      @ecran_jeu.bitmap.blt(0, 0, image, Rect.new(0, 0, 210, 462))
      tableau = Array.new(24)
      24.times {|l| tableau[l] = Array.new(12, false)}
      24.times do |j|
        12.times do |i|
          if j < ligne
            tableau[j + 1][i] = @puit[j][i]
          elsif j > ligne
            tableau[j][i] = @puit[j][i]
          end
        end
      end
      tableau[0][0] = tableau [0][11] = true
      @puit = tableau
    end
    
    def game_over
      @window = Window_Fin.new
      loop do
        Graphics.update
        Input.update
        break if Input.trigger?(Input::C)
      end
      $scene = Scene_Map.new
      @window.dispose
    end
  
  end
end

Instrucciones:
- Pegarlo encima de Main
- Para jugar, es necesario llamar al script mediante este código:
Código:
Tetris.start
- Para rotar las figuras, usad la barra espaciadora

Screenshot:




* NO hacen falta gráficos. El script está en francés, pero el juego en español.

Cualquier duda, consultadme.

Eso es todo, un saludo!

_________________
Staff tú tienes que comprender, mi firma se pasa en excesooo:

==========================================================================
 

Nadie sabe que le pasó a esta mujer...
Las leyendas de Magvel dicen que tuvo una explosión cerebral causada por el torso desnudo de Ephraim, otros dicen que El Rey Demonio la tiene poseída, ¿quién sabe?... 
==========================================================================
Soy y me gusta:



avatar
Alojzy
Moderador
Moderador

Masculino
RPG Maker : Ace
Mensajes : 263
Monedas : 423
Reputación : 43
Edad : 26
Localización : Dónde te diga tu corazón *música melancólica*

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


 
Permisos de este foro:
No puedes responder a temas en este foro.