monotony 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 794754b6881e940805c2ece03fb4a204ef8f40bf
+  data.tar.gz: 2e5a91ef47ee68cbc1c920ad8af18949881a2d63
+SHA512:
+  metadata.gz: 0dbbdc07c2e4007d6335b3edaa17f2fd5634599b5fb4dfe865066e312ef43d84f271934f0d03d075715092e2c34b5f84c66935c12751db60ea869faab52f9fe0
+  data.tar.gz: f68ae2180ee5880fa4d90479e164498d96fcd99d2b166db16aa4e02fe73c973f8e55c3aaf6f3fb591cbddc70784b9ebf3f3a3e899f03f068c1e9fa2c6a2f6dc9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rdoc_options

@@ -0,0 +1,17 @@
+--- !ruby/object:RDoc::Options
+encoding: UTF-8
+static_path: []
+rdoc_include:
+- .
+charset: UTF-8
+exclude: 
+hyperlink_all: false
+line_numbers: false
+main_page: 
+markup: markdown
+page_dir: 
+show_hash: false
+tab_width: 8
+title: 
+visibility: :protected
+webcvs: 

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in monotony.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 James Denness
+
+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,78 @@
+# Monotony
+
+This gem is an engine to simulate games of Monopoly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'monotony'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install monotony
+
+## Usage
+
+To play a quick game of Monopoly, with classic board layout and four randomly generated players"
+
+```ruby
+
+    game = Monotony::Game.new
+    game.play
+
+    # See the results of the game
+    game.summary
+
+```
+
+You can step through the game a few turns at a time, and use the ```summary``` method to view an ASCII representation of the state of the game.
+
+```ruby
+    game.play(10).summary
+```
+
+```ruby
+    monopoly_players = [
+        Player.new( name: 'James', behaviour: behaviour ),
+        Player.new( name: 'Jody',  behaviour: behaviour ),
+        Player.new( name: 'Ryan',  behaviour: behaviour ),
+        Player.new( name: 'Tine',  behaviour: behaviour )
+    ]
+
+    monopoly = Monotony::Game.new(
+        board: monopoly_board,
+        chance: chance,
+        community_chest: community_chest,
+        num_dice: 2,
+        die_size: 6,
+        starting_currency: 1500,
+        bank_balance: 12755,
+        num_hotels: 12,
+        num_houses: 48,
+        go_amount: 200,
+        max_turns_in_jail: 3,
+        players: monopoly_players
+    )```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/monotony.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "monotony"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/monotony.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+
+require 'pp'
+require 'colorize'
+
+require 'monotony/basicproperty'
+require 'monotony/chance'
+require 'monotony/communitychest'
+require 'monotony/game'
+require 'monotony/player'
+require 'monotony/purchasable'
+require 'monotony/square'
+require 'monotony/station'
+require 'monotony/utility'
+require 'monotony/variants'
+require 'monotony/behaviour'
+
+# The Monopoly Engine!
+# @author James Denness <james@recordlive.net>
+module Monotony
+
+end

data/lib/monotony/basicproperty.rb

@@ -0,0 +1,174 @@
+require 'monotony/square'
+require 'monotony/purchasable'
+
+module Monotony
+	# A property class representing the majority of properties on the board.
+	class BasicProperty < PurchasableProperty
+		# @return [Integer] Returns the cost of purchasing a house on this property.
+		attr_accessor :house_cost
+		# @return [Integer] Returns the cost of purchasing a hotel on this property.
+		attr_accessor :hotel_cost
+		# @return [Symbol] Returns the name of the set containing this property.
+		attr_accessor :set
+		# @return [Integer] Returns the number of houses on this property.
+		attr_accessor :num_houses
+		# @return [Integer] Returns the number of hotels on this property.
+		attr_accessor :num_hotels
+		# @return [Array<Integer>] Returns an array of six elements containing rent values for an property with no houses, one house, two houses, three houses, four houses, and a hotel.
+		attr_accessor :rent
+		# @param opts [Hash]
+		# @option opts [Array<Integer>] :rent An array of six elements containing rent values for an property with no houses, one house, two houses, three houses, four houses, and a hotel.
+		# @option opts [Integer] :house_cost The cost of purchasing a house on this property.
+		# @option opts [Integer] :hotel_cost The cost of purchasing a hotel on this property. Traditionally equal to house_cost.
+		# @option opts [Symbol] :set A symbol identifying this property as a member of a set of properties.
+		def initialize(opts)
+			super
+			@rent = opts[:rent]
+			@house_cost = opts[:house_cost]
+			@hotel_cost = opts[:hotel_cost]
+			@set = opts[:set]
+			@num_houses = 0
+			@num_hotels = 0
+			@action = Proc.new do |game, owner, player, property|
+				if owner
+					if set_owned?
+						rent_to_pay = (property.num_hotels  == 1 ? property.rent[5] : ( property.num_houses == 0 ? (@rent[0] * 2) :  property.rent[property.num_houses] ) )
+					else
+						rent_to_pay = property.rent[0]
+					end
+					if owner != player
+						if not owner.is_out? and not is_mortgaged?
+							puts '[%s] Due to pay £%d rent to %s for landing on %s with %s' % [ player.name, rent_to_pay, owner.name, property.name, ( property.num_hotels == 1 ? 'a hotel' : '%d houses' % property.num_houses) ]
+							player.pay(owner, rent_to_pay)
+						end
+					end
+				else
+					player.behaviour[:purchase_possible].call(game, player, self) if player.currency >= cost
+				end
+			end
+		end
+
+		# Mortgage the property to raise cash for its owner.
+		# @return [self]
+		def mortgage
+			super
+			properties_in_set(@owner.game).each do |other|
+				other.sell_hotel if @num_hotels > 0
+				other.sell_houses if @num_houses > 0
+			end
+			self
+		end
+
+		# Buy houses on the property.
+		# @param [Integer] number number of houses to add to the property.
+		# @return [self]
+		def add_houses(number)
+			housing_value = @house_cost * number
+			if @owner.game.num_houses >= number
+				if (@num_houses + number) > 4
+					puts '[%s] Cannot place more than 4 houses on %s' % [ @owner.name, @name ]
+				else
+					if @owner.currency < housing_value
+						puts '[%s] Unable to buy %d houses! (short of cash by £%d)' % [ @owner.name, number, (housing_value - @owner.currency) ]
+						false
+					else
+						@owner.currency = @owner.currency - housing_value
+						@owner.game.num_houses = @owner.game.num_houses - number
+						@num_houses = @num_houses + number
+						puts '[%s] Purchased %d houses on %s for £%d (new balance: £%d)' % [ @owner.name, number, @name, housing_value, @owner.currency ]
+						true
+					end
+				end
+			else
+				puts '[%s] Not enough houses left to purchase %d more for %s' % [ @owner.name, number, @name ]
+			end
+			self
+		end
+
+		# Sell houses from the property.
+		# @param [Integer] number number of houses to sell from the property.
+		# @return [self]
+		def sell_houses(number)
+			housing_value = (@house_cost / 2) * number
+			if number > @num_houses
+				puts "[%s] Can't sell %d houses on %s, as there are only %d" % [ @owner.name, number, @name, @num_houses ]
+				false
+			else
+				@num_houses = @num_houses - number
+				@owner.game.num_houses = @owner.game.num_houses + number
+				@owner.currency = @owner.currency + housing_value
+				puts '[%s] Sold %d houses on %s for £%d (%d remaining)' % [ @owner.name, number, @name, housing_value, @num_houses ]
+			end
+			self
+		end
+
+		# Buy a hotel on the property.
+		# @return [self]
+		def add_hotel
+			if @num_houses == 4
+				if @owner.game.num_houses > 0
+					if @owner.currency < @hotel_cost
+						puts '[%s] Unable to buy a hotel! (short of cash by £%d)' % [ @owner.name, (@hotel_cost - @owner.currency) ]
+					else
+						@owner.currency = @owner.currency - @hotel_cost
+						@num_houses, @num_hotels = 0, 1
+						@owner.game.num_houses = @owner.game.num_houses + 4
+						@owner.game.num_hotels = @owner.game.num_hotels - 1
+						puts '[%s] Purchased a hotel on %s for £%d (new balance: £%d)' % [ @owner.name, @name, @hotel_cost, @owner.currency ]
+					end			
+				else
+					puts '[%s] Not enough hotels left to purchase one for %s' % [ @owner.name, @name ]
+				end
+			end
+			self
+		end
+
+		# Sell hotels from the property.
+		# @return [self]
+		def sell_hotel
+			if @num_hotels < 1
+				puts "[%s] Can't sell hotel on %s, as there isn't one!" % [ @owner.name, @name ]
+			else
+			 	housing_value = (@hotel_cost / 2) 
+				@num_hotels = 0
+				@owner.game.num_hotels = @owner.game.num_hotels + 1
+				@owner.currency = @owner.currency + housing_value
+				puts '[%s] Sold hotel on %s for £%d' % [ @owner.name, @name, housing_value ]
+				case @owner.game.num_houses
+				when 1..3
+					sell_houses(4 - @owner.game.num_houses)
+					puts '[%s] Devolved %s to %d houses as 4 were not available' % [ @owner.name, @name, @num_houses ]
+				when 0
+					sell_houses(4)
+					puts '[%s] Devolved to undeveloped site as no houses were available' % [ @owner.name, @name, @num_houses ]
+				else
+					@owner.game.num_houses = @owner.game.num_houses - 4
+					@num_houses = 4
+					puts '[%s] Devolved %s to %d houses' % [ @owner.name, @name, @num_houses ]
+				end
+			end
+			self
+		end
+
+		# Draw an ASCII representation of this property's housing.
+		# @return [void]
+		def display_house_ascii
+			house_array = []
+			house_string = ''
+
+			if @num_hotels == 1
+				house_string << '   '.colorize(:background => :light_black) + '     '.colorize(:background => :red) + '   '.colorize(:background => :light_black)
+			else
+				until house_array.length == @num_houses
+					house_array << '  '.colorize(:background => :green) 
+				end
+				until house_array.length == 4
+					house_array << '  '.colorize(:background => :light_black)
+				end
+
+				house_string = house_array.join(' '.colorize(:background => :light_black))
+			end
+			house_string + ' '.colorize(:color => :default)
+		end
+	end
+end

data/lib/monotony/behaviour.rb

@@ -0,0 +1,103 @@
+module Monotony
+	# Conains predefined behaviours
+	class DefaultBehaviour
+		DEFAULT = {
+			purchase_possible: Proc.new { |game, player, property| 
+				if player.properties.collect{ |p| p.set }.include? property.set
+					# Will definitely buy if player already owns one or more of this set
+					property.sell_to(player)
+				elsif game.players.collect { |p| p.properties.collect { |p| p.set } }.flatten.include? property.set
+					# Less likely to buy if another player already owns one of the set
+					property.sell_to(player) if Random.rand(0..100) >= 75
+				else
+					# Will probably buy if nobody has bought any of this set yet
+					property.sell_to(player) if Random.rand(0..100) >= 25
+				end
+			},
+			unmortgage_possible: Proc.new { |game, player, property|
+				# Only bother unmortgaging something if I have the rest of the set, or it's less than 15% of my cash
+				if player.sets_owned.include? property.set
+					property.unmortgage
+				elsif ( property.cost.to_f / player.currency.to_f * 100.0 ) < 15.0
+					property.unmortgage
+				end
+			},
+			houses_available: Proc.new {|game, player, property|
+				# Buy houses when possible, but don't spend more than 40% of my money on them in any one turn
+				can_afford = ( ( player.currency * 0.4 ) / property.house_cost ).floor
+				max_available = 4 - property.num_houses
+				to_buy = [ can_afford, max_available ].min
+				property.add_houses(to_buy) if to_buy > 0 unless game.active_players == 1
+			},
+			hotel_available: Proc.new {|game, player, property|
+				# Buy a hotel, unless it's more than half my current balance.
+				property.add_hotel unless ( property.hotel_cost.to_f / player.currency.to_f * 100.0) > 50.0
+			},
+			money_trouble: Proc.new {|game, player, amount|
+				portfolio = player.properties.sort_by { |p| p.mortgage_value }
+				while player.currency < amount do
+					if portfolio.length > 0
+						property = portfolio.shift
+						if property.is_a? BasicProperty
+							if property.num_hotels == 1
+								property = property.sell_hotel
+							end
+							break if player.currency >= amount
+
+							while property.num_houses > 0
+								property = property.sell_houses(1)
+								break if player.currency >= amount
+							end
+							break if player.currency >= amount
+
+							property = property.mortgage
+						end
+					else
+						break
+					end
+				end
+			},
+			use_jail_card: Proc.new {|game, player|
+				# Unless less than 50% of active sets are mine, get out of jail with a card when possible
+				player.use_jail_card! unless ( player.sets_owned.count.to_f / game.all_sets_owned.count.to_f * 100.0 ) < 50
+			},
+			trade_possible: Proc.new {|game, player|
+				puts '[%s] Considering possible trades' % player.name
+			    invested_colours = player.properties.collect(&:set).uniq
+			    player.opponents.each do |opponent|
+			    	opponent.properties.select { |r| invested_colours.include? r.set }.each do |desirable_property|
+			    		factors = {}
+			    		# e.g. 66% chance of buying if one property is owned, 99% chance of buying if two are
+			    		factors[:number_owned] = ( desirable_property.number_of_set_owned.to_f + 1.0 ) / desirable_property.number_in_set(game).to_f
+			    		# More likely to trade if player has over £1000
+						factors[:currency] = player.currency.to_f / 1000.to_f
+			    		# More likely to trade if close to GO
+			    		factors[:proximity_to_go] = 1 - ( player.distance_to_go.to_f / game.board.length.to_f )
+
+			    		# We use these factors to work out how much to offer relative to how much we have
+			    		offer_amount = player.currency * factors.values.inject(&:*)
+			    		if offer_amount > desirable_property.cost and player.currency >= offer_amount
+							puts '[%s] Placing offer of £%d on %s (owned by %s) [%f]' % [ player.name, offer_amount, desirable_property.name, desirable_property.owner.name, factors.values.inject(&:*) * 100 ]
+
+				    		desirable_property.place_offer(player, offer_amount)
+				    	end
+			    	end
+			    end
+			},
+			trade_proposed: Proc.new {|game, player, proposer, property, amount|
+				factors = {}
+				# More likely to accept a trade the longer the game has been going on for (definitely at 100 turns)
+				factors[:longevity] = ( [0, game.turn, 100].sort[1].to_f / 100.0 ).to_f
+				# More likely to accept a trade if it is far over the list price
+				factors[:value_added] = 1 - ( property.cost.to_f / amount.to_f )
+				# More likely to accept a trade if low on cash
+				factors[:currency] = 1 - ( player.currency.to_f / 1000.to_f )
+
+				# Random element
+				factors[:random] = Random.rand(1..100)
+				puts '[%s] Considering offer of £%d for %s (from %s) [%f]' % [ player.name, amount, property.name, proposer.name, ( factors.values.collect{ |f| ( 100 / factors.count ) * f }.inject(:+) / 100 ) ]
+				property.sell_to(proposer, amount) if Random.rand(1..100) > ( factors.values.collect{ |f| ( 100 / factors.count ) * f }.inject(:+) / 100 )
+			}
+		}
+	end
+end