glitch-game 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a60d336dfa3cba758f03c1b349b8aa6ad6a6878d
+  data.tar.gz: b9411ce3b606516596dc824747021001056b8aa5
+SHA512:
+  metadata.gz: b42c21aa73bab39ec7bbe80067eea39e914b90f87dda61e95040cb2a62e91b81bd5d84bb3bb42b74845f00bfc6ba4a966538c251c6f232a1f8574a4ba20ae784
+  data.tar.gz: 0340ad3857521fd1296b5446604cf7b2631bff8400e7755a0f8ae8804c0a833e1c9df245ac2f37bb84a02355fda0edd0f5d3ad596054c3257f6f56a46205f43f

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.markdown

@@ -0,0 +1,16 @@
+# g̠̼͕̋ḻͤi͖͊̄̕t̞ͫͪ̆c̹̎̀h̞͙̀̚
+
+A terminal based [Cookie Clicker] style game.
+
+[![Build Status](https://travis-ci.org/twe4ked/glitch.svg?branch=master)](https://travis-ci.org/twe4ked/glitch)
+
+### Installing and Running
+
+```
+git clone git@github.com:twe4ked/glitch.git
+cd glitch
+bundle install
+bundle exec ./bin/glitch
+```
+
+[Cookie Clicker]: http://en.wikipedia.org/wiki/Cookie_Clicker

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+end

data/bin/glitch

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/glitch'
+
+Glitch::Game.run

data/glitch-game.gemspec

@@ -0,0 +1,19 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'glitch'
+
+Gem::Specification.new do |spec|
+  spec.name = 'glitch-game'
+  spec.version = Glitch::VERSION
+  spec.authors = ['Odin Dutton']
+  spec.summary = 'A terminal based Cookie Clicker style game.'
+  spec.homepage = 'https://github.com/twe4ked/glitch'
+  spec.license = 'MIT'
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables << 'glitch'
+  spec.require_paths = ['.']
+  spec.add_runtime_dependency 'curses', '~> 1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/game.rb

@@ -0,0 +1,169 @@
+require 'curses'
+
+module Glitch
+  class Game
+    def initialize
+      @player = Glitch::Player.new
+      @bit_multiplier = 0
+      @last_second = 0
+
+      @types = {}
+      [
+        Glitch::Type.new('atom', initial_price: 10, multiplier: 1, count_available: 20, :description => 'a boring little atom, so lonely'),
+        Glitch::Type.new('uber', initial_price: 100, multiplier: 10),
+        Glitch::Type.new('matrix', initial_price: 150, multiplier: 11),
+        Glitch::Type.new('hundo', initial_price: 99999, multiplier: 100),
+        Glitch::Type.new('board', initial_price: 500, multiplier: 0, count_available: 4, price_calc: -> (type) { [type.initial_price * (type.count + 1), 2000].min }),
+        Glitch::Type.new('clock', initial_price: 1337, multiplier: 0, count_available: 1, price_calc: -> (type) { type.initial_price }),
+      ].each { |type| @types[type.shortcut] = type }
+
+      @message_board_length = 30
+      @messages = [
+        'welcome to glitch',
+        'you need bits',
+        "you're not sure why",
+        'you know you do',
+        'survive...',
+      ]
+    end
+
+    def self.run
+      self.new.run
+    end
+
+    def run
+      draw_screen
+
+      Curses.curs_set 0
+      Curses.timeout = 1000
+      Curses.start_color
+
+      loop do
+        tick
+      end
+    end
+
+    def tick
+      input = Curses.getch
+
+      if input
+        case
+        when input == ' '
+          @player.increment_bits
+          add_message '1 bit'
+        when available_types.map(&:shortcut).include?(input)
+          type = @types[input]
+
+          case
+          when !type.available?
+            add_message 'none left :('
+          when @player.can_decrement_bits_by?(type.price)
+            @player.decrement_bits type.price
+            type.increment
+            @bit_multiplier = @bit_multiplier + type.multiplier
+            add_message "1 #{type.name}"
+          else
+            add_message "you've not enough bits for #{type.name}"
+          end
+        else
+          add_message 'nope'
+        end
+      end
+
+      # only once per second
+      this_second = Time.now.to_i
+      if this_second > @last_second
+        @player.increment_bits 1 * @bit_multiplier
+        @last_second = this_second
+      end
+
+      @messages = @messages.last(10)
+
+      draw_screen
+    end
+
+    def draw_screen
+      Curses.clear
+
+      print_line_break
+      print_glitch_string 'glitch!', 5
+      print_line_break
+
+      if @types['c'].count == 1
+        print_glitch_string 'clock: ', 1, false
+        print_glitch_string Time.now.to_s
+      end
+
+      @one_bit = true if !@one_bit && @player.bits > 0
+      if @one_bit
+        print_glitch_string 'bits: ', 1, false
+        print_glitch_string @player.bits.to_s + (@bit_multiplier > 5 ? " (#{@bit_multiplier}/bps)" : '')
+        print_line_break
+      end
+
+      print_glitch_string '-' * message_board_length
+      if @messages
+        @messages.each do |message|
+          print_glitch_string message[0..message_board_length-4], 3, false
+          if message.length > message_board_length-4
+            Curses.addstr '...'
+          end
+          print_line_break
+        end
+      else
+        print_glitch_string '...', 1, true, true
+      end
+      print_glitch_string '-' * message_board_length
+
+      draw_types
+
+      print_line_break
+      Curses.addstr ':'
+    end
+
+    private
+
+    def add_message(message)
+      @messages << message
+    end
+
+    def draw_types
+      unless available_types.empty?
+        print_line_break
+        available_types.each do |type|
+          print_type_info = -> (*args) {
+            Curses.addstr '- '
+            print_glitch_string type.info_string, 1, false
+            print_glitch_string " - #{type.description}"
+          }
+
+          if @player.can_decrement_bits_by?(type.price) && type.available?
+            print_type_info.call
+          else
+            Curses.attron(Curses.color_pair(8)|Curses::A_BOLD, &print_type_info)
+          end
+        end
+      end
+    end
+
+    def available_types
+      @types.values.select do |type|
+        @player.can_decrement_bits_by?(type.price - type.price/100.0*10) || type.count > 0
+      end
+    end
+
+    def message_board_length
+      @message_board_length + 10 * (@types['b'].count + 1)
+    end
+
+    def print_glitch_string(string, amount = 1, line_break = true, random = false)
+      string = Glitch::GlitchString.new.glitch(string, amount, random)
+      Curses.addstr string
+      print_line_break if line_break
+    end
+
+    def print_line_break
+      Curses.addstr "\n"
+    end
+  end
+end

data/lib/glitch.rb

@@ -0,0 +1,8 @@
+require_relative 'game'
+require_relative 'player'
+require_relative 'type'
+require_relative 'glitch_string'
+
+module Glitch
+  VERSION = '0.0.1'
+end

data/lib/glitch_string.rb

@@ -0,0 +1,53 @@
+module Glitch
+  class GlitchString
+    # http://en.wikipedia.org/wiki/Combining_Diacritical_Marks
+    COMBINING_DIACRITICAL_MARKS = ("\u0300".."\u036F").to_a
+
+    def glitch(string, amount = 1, random = false, index_offset = 0)
+      result = string.chars.map.each_with_index do |char, index|
+        index = index + index_offset
+        srand(string.chars.map(&:ord).join.to_i + index + (random ? Time.now.to_i : 0))
+
+        add_mark = case amount
+        when 1
+          index % 5 == 0
+        when 2
+          index % 4 == 0
+        when 3
+          index % 3 == 0
+        when 4
+          index % 3 == 0
+        when 5
+          true
+        else
+          raise 'invalid amount (0..5)'
+        end
+
+        case char
+        when ' '
+          char
+        else
+          if add_mark
+            mark = COMBINING_DIACRITICAL_MARKS.sample
+            char + mark
+          else
+            char
+          end
+        end
+      end.join
+
+      case amount
+      when 2
+        glitch result, 1, random, amount
+      when 3
+        glitch result, 2, random, amount
+      when 4
+        glitch result, 3, random, amount
+      when 5
+        glitch result, 4, random, amount
+      else
+        result
+      end
+    end
+  end
+end

data/lib/player.rb

@@ -0,0 +1,21 @@
+module Glitch
+  class Player
+    attr_reader :bits
+
+    def initialize
+      @bits = 0
+    end
+
+    def increment_bits(number = 1)
+      @bits = @bits + number
+    end
+
+    def can_decrement_bits_by?(number)
+      @bits >= number
+    end
+
+    def decrement_bits(number)
+      @bits = @bits - number
+    end
+  end
+end

data/lib/type.rb

@@ -0,0 +1,72 @@
+module Glitch
+  class Type
+    attr_reader :name, :multiplier, :count, :initial_price
+
+    def initialize(name, options = {})
+      @name = name
+      @initial_price = options[:initial_price]
+      @multiplier = options[:multiplier]
+      @count_available = options[:count_available] || :infinite
+      @price_calc = options[:price_calc]
+      @description = options[:description]
+      @count = 0
+    end
+
+    def shortcut
+      @name[0]
+    end
+
+    def name_with_shortcut
+      @name.sub(shortcut, "[#{shortcut}]")
+    end
+
+    def price
+      if @price_calc
+        @price_calc.call(self)
+      else
+        [
+          @initial_price,
+          @initial_price * @count * (@count >= 10 ? 10 : 1) + @count
+        ].max
+      end
+    end
+
+    def increment
+      @count = @count + 1
+      if @count_available.is_a? Integer
+        @count_available = @count_available - 1
+      end
+    end
+
+    def available?
+      infinite? || @count_available > 0
+    end
+
+    def total_available
+      if infinite?
+        '??'
+      else
+        @count + @count_available
+      end
+    end
+
+    def info_string
+      string = []
+      string << name_with_shortcut
+      string << "[#{price} bits]"
+      string << "(#{@count}/#{total_available})" if @count > 0
+      string << "*#{@multiplier}"
+      string.join ' '
+    end
+
+    def description
+      @description || '??'
+    end
+
+    private
+
+    def infinite?
+      @count_available == :infinite
+    end
+  end
+end

data/spec/lib/player_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../lib/player.rb'
+
+describe Glitch::Player do
+  let(:player) { Glitch::Player.new }
+
+  describe '#increment_bits' do
+    it 'increments by 1 if no argument is supplied' do
+      expect { player.increment_bits }.to change { player.bits }.from(0).to(1)
+      expect { player.increment_bits }.to change { player.bits }.from(1).to(2)
+    end
+
+    it 'increments by the number supplied as an argument' do
+      player.increment_bits
+      expect { player.increment_bits 41 }.to change { player.bits }.from(1).to(42)
+    end
+  end
+
+  describe '#can_decrement_bits_by?' do
+    it 'returns true if the player has enough bits' do
+      expect(player.can_decrement_bits_by? 0).to eq true
+      player.increment_bits
+      expect(player.can_decrement_bits_by? 1).to eq true
+    end
+
+    it "returns false if the player doesn't have enough bits" do
+      expect(player.can_decrement_bits_by? 42).to eq false
+    end
+  end
+
+  describe 'decrement_bits' do
+    it 'decrements bits by the number supplied' do
+      player.increment_bits
+      expect { player.decrement_bits 1 }.to change { player.bits }.from(1).to(0)
+    end
+  end
+end

data/spec/lib/type_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../../lib/type.rb'
+
+describe Glitch::Type do
+  let(:type) { Glitch::Type.new 'foo', initial_price: 10, multiplier: 1 }
+
+  describe '#shortcut' do
+    it 'returns a single letter shortcut' do
+      expect(type.shortcut).to eq 'f'
+    end
+  end
+
+  describe '#name_with_shortcut' do
+    it 'returns the name with the shortcut surrounded in brackets' do
+      expect(type.name_with_shortcut).to eq '[f]oo'
+    end
+  end
+
+  describe '#price' do
+    it 'returns different amounts based on the count' do
+      expect(type.price).to eq 10
+
+      type.instance_variable_set('@count', 1)
+      expect(type.price).to eq 11
+
+      type.instance_variable_set('@count', 9)
+      expect(type.price).to eq 99
+
+      type.instance_variable_set('@count', 10)
+      expect(type.price).to eq 1010
+
+      type.instance_variable_set('@count', 11)
+      expect(type.price).to eq 1111
+
+      type.instance_variable_set('@count', 99)
+      expect(type.price).to eq 9999
+
+      type.instance_variable_set('@count', 100)
+      expect(type.price).to eq 10100
+    end
+
+    it 'allows adding a lambda to change the price' do
+      type = Glitch::Type.new 'foo', initial_price: 40, multiplier: 1, price_calc: -> (type) { type.initial_price + 2 }
+      expect(type.price).to eq 42
+
+      type.instance_variable_set('@count', 1)
+      expect(type.price).to eq 42
+
+      type.instance_variable_set('@count', 2)
+      expect(type.price).to eq 42
+    end
+  end
+
+  describe '#increment' do
+    it 'increments the count' do
+      expect { type.increment }.to change { type.count }.from(0).to(1)
+      expect { type.increment }.to change { type.count }.from(1).to(2)
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: glitch-game
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Odin Dutton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: 
+executables:
+- glitch
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/glitch
+- glitch-game.gemspec
+- lib/game.rb
+- lib/glitch.rb
+- lib/glitch_string.rb
+- lib/player.rb
+- lib/type.rb
+- spec/lib/player_spec.rb
+- spec/lib/type_spec.rb
+homepage: https://github.com/twe4ked/glitch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A terminal based Cookie Clicker style game.
+test_files: []