pacmanx 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a38cf4a118a4ee9e1c27b8f19b603896aa5a6546
+  data.tar.gz: a7aa399345721a67320a4d9fa47f61f63c61e728
+SHA512:
+  metadata.gz: 58b90c93229efe35f6963625e7a14f774577d0a7d762c2dceabe55a7276a71af476dcc03aed0cf40d17da74ea04b3ffa62161d97e7258a56784f74cd8f5bd5fd
+  data.tar.gz: bcf9890d7d891dda69133ae5bf7a1bff2e04bf4f233af179a21fc7cfef751bd06b71505156b8137a6a117aa76e423e48ecfe6caf915a9f982b16aea86790e827

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pacman.gemspec
+gem "gosu", ">= 0.8.6"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 fajmanjir
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,19 @@
+# Pacman
+
+Classic Pacman game remake
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pacman'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pacman

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/pacmanx

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'pacman/controller'
+# require 'controller'
+
+game = Pacman::Game.new("lib/pacman/")
+game.show

data/bin/pacman~

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'pacman/pacman'
+# require 'controller'
+
+# game = Pacman::Game.new
+# game.show

data/lib/pacman/animated_object.rb

@@ -0,0 +1,10 @@
+module Pacman
+  # Objext using animation
+  class AnimatedObject
+    def initialize
+      @animation_index = 0
+    end
+
+    attr_accessor :animation_index
+  end
+end

data/lib/pacman/cage.rb

@@ -0,0 +1,14 @@
+module Pacman
+  # base point for ghosts
+  class Cage
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    def passable?
+      true
+    end
+
+    attr_accessor :x, :y
+  end
+end

data/lib/pacman/controller.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'gosu'
+require_relative 'level_builder'
+require_relative 'level_renderer'
+require_relative 'ghosts_controller'
+require_relative 'ghosts_renderer'
+
+module Pacman
+  # controller
+  class Game < Gosu::Window
+    def initialize(rel_path = '')
+      super(1280, 800, false)
+      @last_milliseconds = 0
+
+      self.caption = 'PacMan'
+      @level = 1
+
+      @renderer = LevelRenderer.new(self, rel_path)
+
+      # affects pacman and creatures speed
+      @timer_default = 20
+      @rel_path = rel_path
+
+      load_level
+
+      @ghosts_controller = GhostsController.new(@level)
+
+      @state = :running
+    end
+
+    def load_level
+      file = File.open(@rel_path + "levels/level#{@level}.lvl", 'r')
+      dsl = file.read
+      file.close
+
+      @level = LevelBuilder.build(dsl)
+
+      @timer = @timer_default
+    end
+
+    # this is a callback for key up events or equivalent (there are
+    # constants for gamepad buttons and mouse clicks)
+    def button_up(key)
+      close if key == Gosu::KbEscape
+    end
+
+    def button_down(key)
+      case @state
+      when :running
+        @level.player.direction = :left if (key == Gosu::KbLeft)
+        @level.player.direction = :right if (key == Gosu::KbRight)
+        @level.player.direction = :up if (key == Gosu::KbUp)
+        @level.player.direction = :down if (key == Gosu::KbDown)
+      end
+    end
+
+    def draw
+      @renderer.render(@level, @state)
+    end
+
+    def update
+      update_delta
+      # with a delta we need to express the speed of our entities in
+      # terms of pixels/second
+
+      case @state
+      when :running
+        @timer -= 1
+
+        if (@timer % 10 == 0)
+          # update animation
+          @level.player.animation_index = (@level.player.animation_index + 1)
+        end
+
+        if (@timer == 0)
+          update_player
+          @ghosts_controller.update
+          @state = :win if @ghosts_controller.colission
+          @timer = @timer_default
+        end
+      end
+    end
+
+    def update_player
+      player = @level.player
+      case @level.player.direction
+      when :left
+        next_obj = @level.get(player.x - 1, player.y)
+        player.x -= 1 if player.x > 0 && (next_obj.nil? || next_obj.passable?)
+      when :right
+        next_obj = @level.get(player.x + 1, player.y)
+        player.x += 1 if player.x < @level.width - 1 && (next_obj.nil? ||
+            next_obj.passable?)
+      when :up
+        next_obj = @level.get(player.x, player.y - 1)
+        player.y -= 1 if player.y > 0 && (next_obj.nil? || next_obj.passable?)
+      when :down
+        if player.y + 1 < @level.height - 1
+          next_obj = @level.get(player.x, player.y + 1)
+          player.y += 1 if next_obj.nil? || next_obj.passable?
+        end
+      end
+
+      return unless next_obj != 0 && next_obj.class.ancestors.include?(Item)
+
+      @level.pellets_left -= 1 if next_obj.instance_of?(Pellet)
+      @state = :win if @level.pellets_left == 0
+
+      eat_power_pellet if next_obj.instance_of?(PowerPellet)
+
+      @level[player.y][player.x] = nil
+    end
+
+    def eat_power_pellet
+      @level.ghosts_frozen = 10 # frozen for x steps
+    end
+
+    def update_delta
+      # Gosu::millisecodns returns the time since the game_window was created
+      # Divide by 1000 since we want to work in seconds
+      current_time = Gosu.milliseconds / 1000.0
+      # clamping here is important to avoid strange behaviors
+      @delta = [current_time - @last_milliseconds, 0.25].min
+      @last_milliseconds = current_time
+    end
+  end
+end

data/lib/pacman/ghost.rb

@@ -0,0 +1,41 @@
+module Pacman
+  # model of ghost
+  class Ghost < AnimatedObject
+    def initialize(x, y, direction)
+      super()
+      @x, @y = x, y
+      @direction = direction
+      @stopped = false # used for slow ghost
+    end
+
+    attr_accessor :x, :y, :direction, :stopped
+  end
+
+  # red ghost
+  class BlinkyGhost < Ghost
+    def initialize(x, y, direction)
+      super(x, y, direction)
+    end
+  end
+
+  # pink ghost
+  class PinkyGhost < Ghost
+    def initialize(x, y, direction)
+      super(x, y, direction)
+    end
+  end
+
+  # cyan ghost
+  class InkyGhost < Ghost
+    def initialize(x, y, direction)
+      super(x, y, direction)
+    end
+  end
+
+  # orange ghost
+  class ClydeGhost < Ghost
+    def initialize(x, y, direction)
+      super(x, y, direction)
+    end
+  end
+end

data/lib/pacman/ghosts_controller.rb

@@ -0,0 +1,253 @@
+module Pacman
+  # handles behaviour of ghosts
+  class GhostsController
+    def initialize(level)
+      @level = level
+      @colission = false
+    end
+
+    def update
+      @level.ghosts_frozen -= 1 unless (@level.ghosts_frozen == 0)
+      return unless (@level.ghosts_frozen == 0)
+
+      update_blinky ||
+      update_pinky ||
+      update_inky ||
+      update_clyde
+    end
+
+    attr_accessor :colission
+
+    private
+
+    def update_blinky
+      ghost = @level.ghosts[:blinky]
+      dirs = update_ghost(ghost)
+
+      behave_smart(ghost, dirs)
+    end
+
+    def update_pinky
+      ghost = @level.ghosts[:pinky]
+      dirs = update_ghost(ghost)
+
+      behave_random(ghost, dirs)
+    end
+
+    def update_inky
+      ghost = @level.ghosts[:inky]
+      dirs = update_ghost(ghost)
+
+      behave_random(ghost, dirs)
+    end
+
+    def update_clyde
+      ghost = @level.ghosts[:clyde]
+      dirs = update_ghost(ghost)
+
+      behave_slow_random(ghost, dirs)
+    end
+
+    def behave_smart(ghost, dirs)
+      return if dirs.nil?
+
+      if continue_forward?(ghost, dirs)
+        move(ghost, ghost.direction)
+        return
+      end
+
+      return if try_simply_continue(ghost, dirs)
+
+      dir = nil
+      if (ghost.x - @level.player.x).abs > (ghost.y - @level.player.y).abs
+        # prefer horizontal direction
+        if ghost.x - @level.player.x > 1
+          dir = :left if can_move_left?(ghost)
+        else
+          dir = :right if can_move_right?(ghost)
+        end
+
+        if dir.nil?
+          if ghost.y - @level.player.y > 1
+            dir = :up if can_move_up?(ghost)
+          else
+            dir = :down if can_move_down?(ghost)
+          end
+        end
+      else
+        # prefer vertical direction
+        if ghost.y - @level.player.y > 1
+          dir = :up if can_move_up?(ghost)
+        else
+          dir = :down if can_move_down?(ghost)
+        end
+
+        if dir.nil?
+          if ghost.y - @level.player.y > 1
+            dir = :left if can_move_left?(ghost)
+          else
+            dir = :right if can_move_right?(ghost)
+          end
+        end
+      end
+      dir = random_direction(dirs) if dir.nil?
+      move(ghost, dir)
+    end
+
+    def behave_slow_random(ghost, dirs)
+      if ghost.stopped
+        ghost.stopped = false
+        return
+      end
+
+      ghost.stopped = true
+
+      behave_random(ghost, dirs)
+    end
+
+    def behave_random(ghost, dirs)
+      return if dirs.nil?
+
+      if continue_forward?(ghost, dirs)
+        move(ghost, ghost.direction)
+      else
+        if (dirs.size == 2)
+          if (dirs.first == inverse_direction(ghost.direction))
+            move(ghost, dirs.last)
+          else
+            move(ghost, dirs.first)
+          end
+          return
+        end
+
+        dir = random_direction(dirs)
+
+        move(ghost, dir)
+      end
+    end
+
+    # return possible directions if decision needed, nil otherwise
+    def update_ghost(ghost)
+      dirs = possible_directions(ghost)
+      case
+      when dirs.size > 1
+        return dirs
+      when dirs.size == 1
+        move(ghost, dirs.first)
+      end
+      nil
+    end
+
+    def possible_directions(ghost)
+      res = []
+      res << :left if can_move_left?(ghost)
+      res << :right if can_move_right?(ghost)
+      res << :up if can_move_up?(ghost)
+      res << :down if can_move_down?(ghost)
+
+      res
+    end
+
+    def random_direction(dirs)
+      dir = nil
+      loop do
+        d = rand(4)
+        case d
+        when 0
+          dir = :left
+        when 1
+          dir = :right
+        when 2
+          dir = :up
+        when 3
+          dir = :down
+        end
+        break if dirs.include?(dir)
+      end
+      dir
+    end
+
+    def can_move_left?(ghost)
+      return false unless ghost.x > 0
+      obj = @level.get(ghost.x - 1, ghost.y)
+      obj.nil? || obj.passable?
+    end
+
+    def can_move_right?(ghost)
+      return false unless ghost.y < @level.width - 1
+      obj = @level.get(ghost.x + 1, ghost.y)
+      obj.nil? || obj.passable?
+    end
+
+    def can_move_up?(ghost)
+      return false unless ghost.y > 0
+      obj = @level.get(ghost.x, ghost.y - 1)
+      obj.nil? || obj.passable?
+    end
+
+    def can_move_down?(ghost)
+      return false unless ghost.y < @level.height
+      obj = @level.get(ghost.x, ghost.y + 1)
+      obj.nil? || obj.passable?
+    end
+
+    def continue_forward?(ghost, dirs)
+      return false if dirs.size > 2
+      return true if dirs.size == 1 && ghost.direction == dirs.first
+      (dirs.include?(:left) && dirs.include?(:right) &&
+      (ghost.direction == :left || ghost.direction == :right)) ||
+      (dirs.include?(:up) && dirs.include?(:down) &&
+      (ghost.direction == :up || ghost.direction == :down))
+    end
+
+    def inverse_direction(direction)
+      case direction
+      when :left
+        :right
+      when :right
+        :left
+      when :up
+        :down
+      when :down
+        :up
+      end
+    end
+
+    def move(ghost, direction)
+      if colission_with_player?(ghost)
+        @colission = true
+        return
+      end
+
+      ghost.direction = direction
+      case direction
+      when :left
+        ghost.x -= 1
+      when :right
+        ghost.x += 1
+      when :up
+        ghost.y -= 1
+      when :down
+        ghost.y += 1
+      end
+      @colission = true if colission_with_player?(ghost)
+    end
+
+    def colission_with_player?(ghost)
+      ghost.x == @level.player.x && ghost.y == @level.player.y
+    end
+
+    def try_simply_continue(ghost, dirs)
+      if (dirs.size == 2)
+        # neotoci se uprostred cesty
+        if (dirs.first == inverse_direction(ghost.direction))
+          move(ghost, dirs.last)
+        else
+          move(ghost, dirs.first)
+        end
+        return true
+      end
+      false
+    end
+  end
+end