Condición de salida y conclusiones

Clase 38 de 39 • Curso de Ruby

Contenido del curso

Introducción

Bases del lenguaje

Proyecto

Tomar examen

Comentarios

Ricardo Betancourt Correa

student•

Hola a todos: Esta es mi propuesta para el aumento gradual de velocidad. Las modificaciones solo ocurren en el archivo app.rb (Un atributo en la app que inicializa la velocidad, un método que incrementa la velocidad gradualmente y una modificación en la función init_timer que se asegura de incrementar la velocidad cuando la serpiente come)

require_relative "view/ruby2d"
require_relative "model/state"
require_relative "actions/actions"

class App
  def initialize
    @state = Model.initial_state
    # Atributo inicial de velocidad
    @speed = 0.5
  end
  
  def start
    @view = View::Ruby2dView.new(self)
    timer_thread = Thread.new { init_timer }
    @view.start(@state)
    timer_thread.join
  end
  
  def init_timer
    # Capturamos la longitud inicial de la serpiente
    snake_length = @state.snake.positions.length
    loop do
      if @state.game_finished
        puts "Juego Finalizado"
        puts "Puntaje: #{@state.snake.positions.length}"
        break
      end
      @state = Actions::move_snake(@state)
      @view.render(@state)
      # Se evalúa si la longitud de la serpiente ha cambiado, lo que indica si ha comido
      if snake_length < @state.snake.positions.length
        # Se actualiza la longitud de la serpiente para estar al día con la próxima iteración
        snake_length = @state.snake.positions.length
        # Se recalcula la velocidad, restando un %5 de la velocidad actual por cada llamado, resultando en una disminución gradual que nunca llega a cero
        calculate_speed_increment
        # Este puts es para debugear la velocidad en consola. Pueden retirarlo a gusto
        puts "Current speed: #{@speed}"
      end
      sleep @speed
    end
  end

  def send_action(action, params)
    new_state = Actions.send(action, @state, params)
    if new_state.hash != @state
      @state = new_state
      @view.render(@state)
    end
  end

  private

  def calculate_speed_increment
    if @speed > 0.001
      # "Reduce la velocidad de la serpiente en un %5"
      @speed = @speed - (@speed * 0.05)
      if(@speed < 0.001)
        @speed = 0.001
      end
    end
  end
end

app = App.new
app.start```

Daniel Morán

student•

Excelente, gracias!

Harold David Molina Figueroa

student•

Excelente curso, ya conocía algunas cosas de ruby, pero gracias a este curso pude ver muchas que aun me hacía falta por aprender. El proyecto me pareció genial para entender como es un flujo real, y la parte de TDD me aclaró varias dudas que tenia respecto a la implementación de ese tema

Julian Pineda

student•

Este curso me pareció un poco avanzado ya que pensé que era una introducción, creo que faltó un poco más explicación teórica. Sin embargo aprendí mucho! Gracias Platzi

Oscar Téllez

student•

Excelente curso!
Donde estan los retos que se mencionan en la ultima clase??

Israel Elias Laura Rosas

student•

Se le olvido implementar el incremento de velocidad…

para ello aumente un atributo al modelo State que es :speed

module Model
	class State < Struct.new(:grid, :snake, :food, :game_over, :speed)
		INITIAL_SPEED = 0.5
		
		def calculate_speed!
			self.speed = INITIAL_SPEED - (0.05 * (snake.size / 3))
			#snake.size = snake.positions.length
		end

end

module Actions
	def self.move_snake(state)
		#...
		if food_position?(state, next_position)
			snake.grow!(next_position)
			state.calculate_speed!
			state.generate_food!
		elsif #...
		# ...
		end
		#...

end

El problema con esto es que solo llega al nivel 30 y en el nivel 31 el speed se vuelve negativo. y el timer falla.
Se necesita implementar una funcion logaritmica aqui… Si alguien puede hacerlo aporte por favor

Israel Elias Laura Rosas

student•

Olvide decir que es necesario modificar el init_timer

  def init_timer
    loop do 
      # ...
      @view.render(@state)
      sleep @state.speed
    end
  end

Daymer Alberto Alviz Alvarez

student•

Excelente Curso. el profesor explica de forma detallada todos los temas en la practica del juego. Simon muchas gracias por compartir tu conocimiento. Saludos a todos.

Roger Christian Cansaya Olazabal

student•

Muy interesante el lenguaje,

David Arturo Giraldo Castrillón

student•

Hola a tod@s,

Les comparto que he seguido el curso y he aprendido cosas nuevas y más que soy nuevo en el mundo de ruby, les queria compartir una pequeña modificación al codigo del archivo ruby2d.rb donde por iniciativa propia quize personalizar un poco más la culebra y explorar un poco más como funciona los objetos en ruby, en esta ocasión lo que quise probar fue como cambiar el color a la cabeza de la culebra para darle un poco más de estilo al programa del curso, espero que les agrade.

    def render_snake(state)
        
        @snake_positions.each(&:remove) if @snake_positions
        extend Ruby2D::DSL
        snake = state.snake
        @snake_positions = snake.positions.map do |pos|
            Square.new(
                x: pos.col * @pixel_size, 
                y: pos.row * @pixel_size,
                size: @pixel_size,
                color: 'green'
            )
        end
        #Cambiar el color del primer elemento de la culebra 
        @snake_positions.first.color = 'red'
    end

Saludos

Ricardo Celis

teacher•

Retos del curso:

Mario Vizcaino

student•

Excelente curso, aunque me gustaría que hubiera uno enfocado más al testing usando rspec

Ricardo Celis

teacher•

trabajaremos en eso mario! qué bien que te gustó el curso, hoy estará disponible el examen

Mario Vizcaino

student•

Muchas gracias, lo esperaré con gusto!

Fernando Eladio Alvarez Noya

student•

Estupendo curso, me puso a prueba ya que varias veces me encontraba con errores y al solucionarlos pude entender un poco mas!

Horacio Sanchez Corvera

student•

Me gustó la manera de armar el proyecto, desde los diagramas a mano hasta los test, nunca había usado test para desarrollar y ahora entiendo cual es la importancia.

Gracias.

Diego Hernández Delgado

student•

¡Muchas gracias, Simón! Buen proyecto para aprender Ruby. Sólo como recomendación, procura no saltarte cambios de nombres de variables o cualquier cosa en el código porque luego hay que andar debugeando.

Santiago Patiño

student•

Solo a mí me pasa que si presionas dos direcciones muy rápido cuenta como que has perdido?, como si se estuvieran superponiendo las posiciones pero sin verse reflejado en el render? Se puede implementar alguna especie de delay en la acción? o se ejecutaría un detector para ver si justo en ese momento no se ha renderizado, como se podría hacer? ;D Buen curso

Emanuel Sarria Cruz

student•

Para todas las personas que tuvieron problemas en el curso, yo les recomiendo usar un poco de prompt engineering con ChatGPT, me sirvió demasiado para poder entender algunos errores o temas, aquí les dejo el link de lo que yo utilicé:

https://chat.openai.com/share/71b5c635-0574-4f9c-a528-4eff08122617

Luis Miguel Espinosa Martinez

student•

Me gustaria compartir con ustedes mi proyecto finalizado, le di un acercamiento diferente, trate de usar una arquitectura un poco mas limpia, no fue facil, se que se puede mejorar mas.

https://github.com/BettoISC/snake/

Pronto implementare el cambio de velocidad y un contador de puntos, quiero que la velocidad aumente segun el puntaje.

Cualquier sugerencia es bienvenida!! :D

Por cierto yo no use el DSL de ruby2D, la clase Window tiene un metodo update que genera un hilo de actualizacion, a este le mande el bloque de renderizado que llame draw! :)

Karol Liseth Rojas Bermúdez

student•

Hola, clone tu proyecto y lo ejecuté. Te quedo brutal. Estudiaré tu código, gracias por compartir

Oscar Julio Silvera Cruz

student•

Muy buen curso, como recomendación, solo maneja en pantalla las ventanas mínimas para las explicaciones, ya que en muchas oportunidades las lineas superaban el borde y eso era molesto a la hora de copiar o verificar los códigos, otra cosa, es el cambio de las variables, en algunos casos no se comentaba a que archivo se estaba haciendo referencia y si bien se podía mirar en la pantalla siempre es útil la indicación a que archivo se apunta, fuera eso un muy buen curso, aunque se me hizo un poco mas avanzado que una introductorio al lenguaje los que exige un poco mas de solo quedarse con lo que explica el profe, así que a practicar y no parar de aprender :)

Israel Elias Laura Rosas

student•

Donde estan los retos??? !

Israel Elias Laura Rosas

student•

Genial el curso!

Eduardo Bravo

student•

Muy buen curso, como es la primera vez que me meto de lleno con la programación, pensé que no podía terminar el curso, más sin embargo ya lo termine. Gracias a Dios todo poderoso.

Eduardo Vera Sánchez

student•

Muy buen curso! La verdad me costó un poco porque voy empezando en la programación. Gracias Simón!

require_relative "view/ruby2d"
require_relative "model/state"
require_relative "actions/actions"

class App
  def initialize
    @state = Model.initial_state
    # Atributo inicial de velocidad
    @speed = 0.5
  end
  
  def start
    @view = View::Ruby2dView.new(self)
    timer_thread = Thread.new { init_timer }
    @view.start(@state)
    timer_thread.join
  end
  
  def init_timer
    # Capturamos la longitud inicial de la serpiente
    snake_length = @state.snake.positions.length
    loop do
      if @state.game_finished
        puts "Juego Finalizado"
        puts "Puntaje: #{@state.snake.positions.length}"
        break
      end
      @state = Actions::move_snake(@state)
      @view.render(@state)
      # Se evalúa si la longitud de la serpiente ha cambiado, lo que indica si ha comido
      if snake_length < @state.snake.positions.length
        # Se actualiza la longitud de la serpiente para estar al día con la próxima iteración
        snake_length = @state.snake.positions.length
        # Se recalcula la velocidad, restando un %5 de la velocidad actual por cada llamado, resultando en una disminución gradual que nunca llega a cero
        calculate_speed_increment
        # Este puts es para debugear la velocidad en consola. Pueden retirarlo a gusto
        puts "Current speed: #{@speed}"
      end
      sleep @speed
    end
  end

  def send_action(action, params)
    new_state = Actions.send(action, @state, params)
    if new_state.hash != @state
      @state = new_state
      @view.render(@state)
    end
  end

  private

  def calculate_speed_increment
    if @speed > 0.001
      # "Reduce la velocidad de la serpiente en un %5"
      @speed = @speed - (@speed * 0.05)
      if(@speed < 0.001)
        @speed = 0.001
      end
    end
  end
end

app = App.new
app.start```

module Model
	class State < Struct.new(:grid, :snake, :food, :game_over, :speed)
		INITIAL_SPEED = 0.5
		
		def calculate_speed!
			self.speed = INITIAL_SPEED - (0.05 * (snake.size / 3))
			#snake.size = snake.positions.length
		end

end

module Actions
	def self.move_snake(state)
		#...
		if food_position?(state, next_position)
			snake.grow!(next_position)
			state.calculate_speed!
			state.generate_food!
		elsif #...
		# ...
		end
		#...

end

    def render_snake(state)
        
        @snake_positions.each(&:remove) if @snake_positions
        extend Ruby2D::DSL
        snake = state.snake
        @snake_positions = snake.positions.map do |pos|
            Square.new(
                x: pos.col * @pixel_size, 
                y: pos.row * @pixel_size,
                size: @pixel_size,
                color: 'green'
            )
        end
        #Cambiar el color del primer elemento de la culebra 
        @snake_positions.first.color = 'red'
    end

Condición de salida y conclusiones

Introducción

Lo que aprenderás sobre Ruby

Qué es Ruby y para qué sirve este lenguaje

Instalación de Ruby

Bases del lenguaje

Tipos de datos I: Integer, float

Tipos de datos II: Strings

Tipos de datos III: Symbols

Tipos de datos IV: Arrays

Tipos de datos V: Hashes

Uso de condicionales

Uso de ciclos

Rangos

Uso de Regex

Procs y lambdas

Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Programación Orientada a Objetos en Ruby: Módulos

Programación Orientada a Objetos: Clases y Objetos

Concurrencia vs Paralelismo: Threads en Ruby

Bundler y gemas

Testing en Ruby

Testing con MiniTest

Diferencias entre Ruby 2.5 y 3

Proyecto

Introducción al proyecto

Instalar Ruby 2D

Overview Ruby 2D

Arquitectura

Estructurando el proyecto

Vista básica

Programando la base para los movimientos

Programando el movimiento de nuestro snake

Test de nuestras acciones

Implementando el timer del movimiento

Actualizando la vista

Preparando el cambio de dirección

Recapitulación de la arquitectura

Moviendo la serpiente con el teclado

Creciendo la serpiente y programando la condición de derrota

Generando comida aleatoria: uso de rand y stub en pruebas

Condición de salida y conclusiones

Retos del curso