tumblr-game 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb49313b5d2341aa1d5792bd1b0edca7085443e8
+  data.tar.gz: 6f73ae46e8a2dd4e9f29d4d5300d5d0b19e9c8c2
+SHA512:
+  metadata.gz: 07917b3af2116ff2c74d6d5b8e12669d3bb96fc193e2b3c83bee7f23a4ca8590cb667ac683004ab20d2843cf73ed09eb002a66f6307550e81910ef48ff71d7c3
+  data.tar.gz: 67d4cbc6426b34bbdf111ec8ec73e43e7929f214bddd51f7229ed81433a8496a7877610ba2e655aa0760670c7be5663a96ab711ead3c79f4da2958a782c984da

data/bin/Main

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'tumblr-game'
+
+myGame = Game.new(1250, 900)
+myGame.start

data/lib/game.rb

@@ -0,0 +1,33 @@
+require_relative 'tumblr-game/gosu.rb'
+require_relative 'tumblr-game/tumblr.rb'
+
+class Game
+
+  def initialize(w, h) # dimensions of 1250 x 900 are appropriate
+    @width = w
+    @height = h
+  end
+  
+  def start
+    # ask for user input to get the blog name
+    puts "Enter the name of the blog: "
+    blogName = gets.chop
+
+    if blogName.empty? then 
+      puts "Error: Please enter a Tumblr blog name."
+    else
+      ## create a new TumblrAPIObject so we can issue calls to the tumblr api for data
+      tumblr = TumblrAPIObject.new(blogName)
+
+      ## query the API. if there were enough results then advance, else issue an error
+      if (tumblr.query == 5) then
+        tumblr.create_images                                # create and save the images for the game
+
+        window = MyWindow.new(@width, @height)              # start the game
+        window.show
+      else
+        puts "Error downloading pictures from Tumblr. Please check your internet connection or the blog name you entered. Blogs need at least 5 pictures."
+      end
+    end
+  end
+end

data/lib/tumblr-game/board.rb

@@ -0,0 +1,60 @@
+require_relative 'tile.rb'
+
+class Board
+  
+	## initialize function of the board class: this will accept 10 parameters that are each a path to an image
+	# it will then populate the tile array appropriately with each image
+	def initialize(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+		@tile_Array = Array.new(10)
+		@tile_Array[0] = t1
+		@tile_Array[1] = t2
+		@tile_Array[2] = t3
+		@tile_Array[3] = t4
+		@tile_Array[4] = t5
+		@tile_Array[5] = t6
+		@tile_Array[6] = t7
+		@tile_Array[7] = t8
+		@tile_Array[8] = t9
+		@tile_Array[9] = t10
+    
+    # counter that will keep track of how many matches have occurred. when this counter reaches 5 before the time limit ends, the player wins
+    @matchedCount = 0
+	end
+	
+	# draw function of the board class: this will go through the tile array and draw each tile
+	def draw_board
+		for i in 0..9
+			@tile_Array[i].draw
+		end
+	end
+	
+	# this function will flip a given tile to the face indicated by the parameter bool. false = facedown, true = face up
+	def flip_tile(ind, bool)
+		@tile_Array[ind].flip(bool)
+	end
+
+	# this function will get the id from the desired tile
+	def get_id(ind)
+		return @tile_Array[ind].return_id
+	end
+	
+	# this function will set a tile to its "matched" configuration
+	def matchTile(ind)
+		@tile_Array[ind].set_match
+	end
+	
+	# this function will get the matched status of a specific tile and return it
+	def is_matched(ind)
+		return @tile_Array[ind].return_match
+	end
+  
+  # this function will increment the match counter to reflect a user successfully matching tiles
+  def inc_match
+    @matchedCount += 1
+  end
+  
+  # this function will return the amount of matched tiles
+  def return_count
+    return @matchedCount
+  end
+end

data/lib/tumblr-game/gosu.rb

@@ -0,0 +1,342 @@
+require 'gosu'
+require_relative 'board.rb'
+require_relative 'tile.rb'
+require_relative 'timer.rb'
+
+class MyWindow < Gosu::Window
+  
+  ## constants that will represent the background color for the window when the user loses
+  LTOP_COLOR = Gosu::Color.new(255, 225, 100, 100)
+  LBOTTOM_COLOR = Gosu::Color.new(255, 200, 125, 125)
+  
+  ## constants that will represent the background color for the window when the user wins
+  WTOP_COLOR = Gosu::Color.new(255, 100, 225, 100)
+  WBOTTOM_COLOR = Gosu::Color.new(255, 125, 225, 125)
+  
+  ## constants that will represent the background color for the window
+  TOP_COLOR = Gosu::Color.new(255, 44, 71, 98)
+  BOTTOM_COLOR = Gosu::Color.new(255, 125, 125, 125)
+
+  def initialize(w, h)
+  
+   ## define variables for the width and height of the window
+   @width = w
+   @height = h  
+   
+   ## variables for WIN or LOSE state
+   @win = false
+   @lose = false  
+   
+   ## initialize the window and caption it
+   super(@width, @height, false) 
+   self.caption = 'Tumblr Image Match!'
+   
+   ## define a variable that indicates what state the game is in
+   # when phase = 0, that indicates that the user is in the "picking" stage of the game and is selecting a face down card for an
+   # initial guess
+   # when phase = 1, that indicates that the user is in the "matching" stage of the game and is selecting another card to see if it
+   # matches the previous one. after the user clicks the mouse, the images will be shown and then they will be left face up if they match,
+   # otherwise both cards will go back to facedown. phase is always set to 0 after this stage.
+   @phase = 0
+   @frameCounter = 0
+   
+   ## define two variables that indicates the ID of the first card that was selected when phase was 0 and the ID of the second card selected when 
+   # phase = 1
+   @picked = 0
+   @picked2 = 0
+   
+   # variable that indicates the second card was actually picked
+   @pickedSecond = false
+	
+   ## initialize a Timer object that will keep track of the time remaining for the given game
+   # also create a Gosu font object that will be passed to the Timer object
+   font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+   @timer = Timer.new(font, @width/2, @height/2)
+   
+   ## create a font for the end of the game, either win or lose
+   @endFont = Gosu::Font.new(self, Gosu::default_font_name, 20)
+  
+   # create a pseudorandom number generator for shuffling
+   prng = Random.new(Random.new_seed())
+   
+   # create a hash of the image names that we are using along with their associated id
+   imgNames = Hash[
+   	'image1.png' => 0,
+   	'image2.png' => 1,
+   	'image3.png' => 2,
+   	'image4.png' => 3,
+   	'image5.png' => 4,
+   	'image6.png' => 0,
+   	'image7.png' => 1,
+   	'image8.png' => 2,
+   	'image9.png' => 3,
+   	'image10.png' => 4 ]
+   
+   ## Durstenfield's Shuffling Algorithm 
+   # convert the hash from above into a two-dimensional array that will be shuffled in order to
+   # randomize the appearance of the images on the board
+   imgArr = imgNames.to_a
+   for i in(9).downto(1)
+     j = prng.rand(i)
+     tempK = imgArr[i][0]
+     tempV = imgArr[i][1]
+     imgArr[i][0] = imgArr[j][0]
+     imgArr[i][1] = imgArr[j][1]
+     imgArr[j][0] = tempK
+     imgArr[j][1] = tempV
+   end
+   
+   # create the Gosu images so they can be put in to each Tile object
+   chk = Gosu::Image.new(self, "check.png", true)
+   img0 = Gosu::Image.new(self, "tumblr.png", true) #the back of each card
+   img1 = Gosu::Image.new(self, imgArr[0][0], true)
+   img2 = Gosu::Image.new(self, imgArr[1][0], true)
+   img3 = Gosu::Image.new(self, imgArr[2][0], true)
+   img4 = Gosu::Image.new(self, imgArr[3][0], true)
+   img5 = Gosu::Image.new(self, imgArr[4][0], true)
+   img6 = Gosu::Image.new(self, imgArr[5][0], true)
+   img7 = Gosu::Image.new(self, imgArr[6][0], true)
+   img8 = Gosu::Image.new(self, imgArr[7][0], true)
+   img9 = Gosu::Image.new(self, imgArr[8][0], true)
+   img10 = Gosu::Image.new(self, imgArr[9][0], true)
+   
+   # initialize the game board with the tile objects
+   @game_board = Board.new( Tile.new(img1, 0, 0, img0, imgArr[0][1], chk), 
+   							Tile.new(img2, 250, 0, img0, imgArr[1][1], chk), 
+   							Tile.new(img3, 500, 0, img0, imgArr[2][1], chk), 
+   							Tile.new(img4, 750, 0, img0, imgArr[3][1], chk), 
+   							Tile.new(img5, 1000, 0, img0, imgArr[4][1], chk), 
+   							Tile.new(img6, 0, 500, img0, imgArr[5][1], chk), 
+   							Tile.new(img7, 250, 500, img0, imgArr[6][1], chk), 
+   							Tile.new(img8, 500, 500, img0, imgArr[7][1], chk), 
+   							Tile.new(img9, 750, 500, img0, imgArr[8][1], chk), 
+   							Tile.new(img10, 1000, 500, img0, imgArr[9][1], chk) )
+  end
+  
+  ## update function. this function contains all of the game logic
+  def update
+  	## only allow the user to pick tiles if the frameCounter is at 0
+  	# this means that the user can only pick tiles when two tiles are not being displayed
+  	# after the 96 frames of display are over, we then call the check_match function and set the frameCounter back to 0 
+    if @frameCounter == 0 then 
+  		pick_tiles	
+  	elsif @frameCounter == 96 then
+  		check_match
+      check_win
+  	 	@frameCounter = 0
+  	end
+  	
+  	## if the user has picked their second tile then we increment the frame counter to display both of them for a few seconds
+  	if @phase == 1 and @pickedSecond then
+  	 @frameCounter += 1
+  	end
+    
+    ## update the Timer object
+    @timer.update
+  end
+  
+  ## draw function. this function will draw one of the three backgrounds for the game. if the game is in the LOSE state, if the time has run out and the
+  # player has not matched 5 tiles, the player loses. if the player matches 5 tiles before the time runs out, then they win. else, the regular game
+  # board is drawn for the user to play on
+  def draw
+    if (!@win and @lose) or (@frameCounter == 0 and @game_board.return_count < 5 and @timer.return_time == 0)
+      draw_lose
+    elsif (@win and !@lose)
+      draw_win
+    elsif (!@win and !@lose)
+      draw_background
+      @game_board.draw_board
+      @timer.draw  
+    end
+  end
+  
+  ## pick_tiles function
+  # this function has two parts. if the game is in phase 0, the user is picking an initial tile. the function will check the location
+  # of the user's mouse and flip the appropriate tile and keep track of which tile was flipped. then, the game is set to phase 1.
+  # in phase 1, the user is picking the tile they want to match with the first one. if a tile is successfully picked, the pickedSecond
+  # variable is set to true and the game stores which tile was picked and flipped.
+  def pick_tiles
+    if button_down? Gosu::KbEscape then
+      close
+    end
+  	if @phase == 0 
+  		if button_down? Gosu::MsLeft then
+  			# TILE 1
+  			if (mouse_x >= 0 and mouse_x <= 250) and (mouse_y >= 0 and mouse_y <= 250) and (!@game_board.is_matched(0)) then
+  				@game_board.flip_tile(0, true)
+  				@picked = 0
+  				@phase = 1
+  			# TILE 2
+  			elsif (mouse_x > 250  and mouse_x <= 500) and (mouse_y >= 0 and mouse_y <= 250) and (!@game_board.is_matched(1)) then
+  				@game_board.flip_tile(1, true)
+  				@picked = 1
+  				@phase = 1
+  			# TILE 3
+  			elsif (mouse_x > 500  and mouse_x <= 750) and (mouse_y >= 0 and mouse_y <= 250) and (!@game_board.is_matched(2)) then
+  				@game_board.flip_tile(2, true)
+  				@picked = 2
+  				@phase = 1
+  			# TILE 4
+  			elsif (mouse_x > 750  and mouse_x <= 1000) and (mouse_y >= 0 and mouse_y <= 250) and (!@game_board.is_matched(3))then
+  				@game_board.flip_tile(3, true)
+  				@picked = 3
+  				@phase = 1
+  			# TILE 5
+  			elsif (mouse_x > 1000  and mouse_x <= 1250) and (mouse_y >= 0 and mouse_y <= 250) and (!@game_board.is_matched(4)) then
+  				@game_board.flip_tile(4, true)
+  				@picked = 4
+  				@phase = 1
+  			# TILE 6
+  			elsif (mouse_x >= 0 and mouse_x <= 250) and (mouse_y > 500 and mouse_y <= 750) and (!@game_board.is_matched(5)) then
+  				@game_board.flip_tile(5, true)
+  				@picked = 5
+  				@phase = 1
+  			# TILE 7
+  			elsif (mouse_x > 250  and mouse_x <= 500) and (mouse_y > 500 and mouse_y <= 750) and (!@game_board.is_matched(6)) then
+  				@game_board.flip_tile(6, true)
+  				@picked = 6
+  				@phase = 1
+  			# TILE 8
+  			elsif (mouse_x > 500  and mouse_x <= 750) and (mouse_y > 500 and mouse_y <= 750) and (!@game_board.is_matched(7)) then
+  				@game_board.flip_tile(7, true)
+  				@picked = 7
+  				@phase = 1
+  			# TILE 9
+  			elsif (mouse_x > 750  and mouse_x <= 1000) and (mouse_y > 500 and mouse_y <= 750) and (!@game_board.is_matched(8)) then
+  				@game_board.flip_tile(8, true)
+  				@picked = 8
+  				@phase = 1
+  			# TILE 10
+  			elsif (mouse_x > 1000  and mouse_x <= 1250) and (mouse_y > 500 and mouse_y <= 750) and (!@game_board.is_matched(9)) then
+  				@game_board.flip_tile(9, true)
+  				@picked = 9
+  				@phase = 1
+  			end
+  			sleep(0.2) # needs delay because gosu's mouse click event seems to be hyper sensitive and picks up multiple clicks instead of 1
+  		end
+  	else @phase == 1
+  		if button_down? Gosu::MsLeft then
+    		# TILE 1
+  			if (mouse_x >= 0 and mouse_x <= 250) and (mouse_y >= 0 and mouse_y <= 250) and (@picked != 0) and (!@game_board.is_matched(0)) then
+  				@game_board.flip_tile(0, true)
+  				@picked2 = 0
+  				@pickedSecond = true
+  			# TILE 2
+  			elsif (mouse_x > 250  and mouse_x <= 500) and (mouse_y >= 0 and mouse_y <= 250) and (@picked != 1) and (!@game_board.is_matched(1)) then
+  				@game_board.flip_tile(1, true)
+  				@picked2 = 1
+  				@pickedSecond = true
+  			# TILE 3
+  			elsif (mouse_x > 500  and mouse_x <= 750) and (mouse_y >= 0 and mouse_y <= 250) and (@picked != 2) and (!@game_board.is_matched(2)) then
+  				@game_board.flip_tile(2, true)
+  				@picked2 = 2
+  				@pickedSecond = true
+  			# TILE 4
+  			elsif (mouse_x > 750  and mouse_x <= 1000) and (mouse_y >= 0 and mouse_y <= 250) and (@picked != 3) and (!@game_board.is_matched(3)) then
+  				@game_board.flip_tile(3, true)
+  				@picked2 = 3
+  				@pickedSecond = true
+  			# TILE 5
+  			elsif (mouse_x > 1000  and mouse_x <= 1250) and (mouse_y >= 0 and mouse_y <= 250) and (@picked != 4) and (!@game_board.is_matched(4)) then
+  				@game_board.flip_tile(4, true)
+  				@picked2 = 4
+  				@pickedSecond = true
+  			# TILE 6
+  			elsif (mouse_x >= 0 and mouse_x <= 250) and (mouse_y > 500 and mouse_y <= 750) and (@picked != 5) and (!@game_board.is_matched(5)) then
+  				@game_board.flip_tile(5, true)
+  				@picked2 = 5
+  				@pickedSecond = true
+  			# TILE 7
+  			elsif (mouse_x > 250  and mouse_x <= 500) and (mouse_y > 500 and mouse_y <= 750) and (@picked != 6) and (!@game_board.is_matched(6)) then
+  				@game_board.flip_tile(6, true)
+  				@picked2 = 6
+  				@pickedSecond = true
+  			# TILE 8
+  			elsif (mouse_x > 500  and mouse_x <= 750) and (mouse_y > 500 and mouse_y <= 750) and (@picked != 7) and (!@game_board.is_matched(7)) then
+  				@game_board.flip_tile(7, true)
+  				@picked2 = 7
+  				@pickedSecond = true
+  			# TILE 9
+  			elsif (mouse_x > 750  and mouse_x <= 1000) and (mouse_y > 500 and mouse_y <= 750) and (@picked != 8) and (!@game_board.is_matched(8)) then
+  				@game_board.flip_tile(8, true)
+  				@picked2 = 8
+  				@pickedSecond = true
+  			# TILE 10
+  			elsif (mouse_x > 1000  and mouse_x <= 1250) and (mouse_y > 500 and mouse_y <= 750) and (@picked != 9) and (!@game_board.is_matched(9)) then
+  				@game_board.flip_tile(9, true)
+  				@picked2 = 9
+  				@pickedSecond = true
+  			end
+			sleep(0.2) # needs delay because gosu's mouse click event seems to be hyper sensitive and picks up multiple clicks instead of 1
+  		end
+  	end
+  end
+  
+  ## the check_match function will be called after the the frameCounter has reached a certain point. 
+  # this function will check if the two tiles that have been selected match. it will compare the strings that determine each
+  # tile's id. if the strings are the same then the two tiles match; the strings are the path to that tile's main image.
+  # if the strings do not match then the tiles are flipped over and the game is set back to phase 0.
+  def check_match
+  	if @phase == 1 and @pickedSecond == true
+  		# check if they match
+  		if(@game_board.get_id(@picked) == @game_board.get_id(@picked2))
+  			@game_board.matchTile(@picked)
+  			@game_board.matchTile(@picked2)
+        
+        # increment match counter
+        @game_board.inc_match
+  		else
+  			# flip the tiles 
+  			@game_board.flip_tile(@picked, false)
+  			@game_board.flip_tile(@picked2, false)
+  		end
+  		@pickedSecond = false
+  		@phase = 0
+  	end
+  end
+  
+  ## this function specifies that the cursor should be displayed when it is inside the main gosu window
+  def needs_cursor?
+  	true
+  end
+  
+  ## function that will be used to draw a blue background with a slight gradient towards the bottom
+  def draw_background
+      draw_quad( 0, 0, TOP_COLOR,
+                 @width, 0, TOP_COLOR,
+                 0, @height, BOTTOM_COLOR,
+                 @width, @height, BOTTOM_COLOR,
+                 -1 )
+  end
+   
+  ## function that draws the background and winning font when the user wins the game 
+  def draw_win
+    draw_quad( 0, 0, WTOP_COLOR,
+               @width, 0, WTOP_COLOR,
+               0, @height, WBOTTOM_COLOR,
+               @width, @height, WBOTTOM_COLOR,
+               -1 )
+    @endFont.draw("You win!", @width/2 - 150, @height/2, 0, 4, 4, 0xFFFFFFFF)
+  end
+  
+  ## function that draws the background and losing font when the users loses the game
+  def draw_lose
+    draw_quad( 0, 0, LTOP_COLOR,
+               @width, 0, LTOP_COLOR,
+               0, @height, LBOTTOM_COLOR,
+               @width, @height, LBOTTOM_COLOR,
+               -1 )
+    @endFont.draw("You lose...", @width/2 - 150, @height/2, 0, 4, 4, 0xFFFFFFFF)
+  end
+  
+  ## this function is called at the end of the display period for images. since pictures display for a few seconds before flipping over again,
+  # this function will allow the user to win if they flip over the last pair when the time left is less than the display period.
+  def check_win
+    if @game_board.return_count == 5 and @timer.return_time >= 0
+      @win = true
+    end
+    if @game_board.return_count < 5 and @timer.return_time == 0
+      @lose = true
+    end
+  end
+end

data/lib/tumblr-game/tile.rb

@@ -0,0 +1,51 @@
+require 'gosu'
+
+class Tile
+	
+	## initialize function of the Tile class: this will create a Tile object with all necessary parameters
+	# Parameters: image name, xLocation, and yLocation. image name is the name of the image that was saved, and the location variables
+	# give the Tile's location on the board
+	# img2 will be used as the back of the image for when it is face-down
+	# idStr is the string that contains the path of the image for the given tile, it will be used for comparisons between tiles
+	def initialize( img, xL, yL, img2, idS, chkImg )
+		@image = img
+		@rev = img2
+		@xLocation = xL
+		@yLocation = yL
+		@flipped = false
+		@matched = false
+		@idStr = idS
+		@chkImage = chkImg
+	end
+	
+	# draw function of the Tile class: this will draw the image at the Tile's specified location
+	def draw
+		if !@flipped and !@matched then
+			@rev.draw(@xLocation, @yLocation, 0)
+		elsif @flipped and !@matched
+			@image.draw(@xLocation, @yLocation, 0)
+		else
+			@chkImage.draw(@xLocation, @yLocation, 0)
+		end
+	end
+	
+	# flip function of the Tile class: this will make the Tile be drawn with its true image
+	def flip( bool )
+		@flipped = bool
+	end
+	
+	# return_id function of the Tile class: this will return the given Tile's id to be used in comparisons
+	def return_id
+		return @idStr
+	end
+	
+	# sets the matched attribute of a Tile object to true. this will result in the tile displaying a checkmark for completion
+	def set_match
+		@matched = true
+	end
+	
+	# this function will return a tile's matched status
+	def return_match
+		return @matched
+	end
+end

data/lib/tumblr-game/timer.rb

@@ -0,0 +1,44 @@
+require 'gosu'
+
+class Timer
+  
+  ## initialize function of the timer class
+  # this will create a Timer object with parameters
+  # fontParam = a Gosu font object 
+  # pX = the x coordinate of where the font will display
+  # pY = the y coordinate of where the font will display
+  # the timer object also maintains a frame count and a count of the total time
+  def initialize(fontParam, pX, pY)
+    @font = fontParam
+    @frameCounter = 0
+    @totalTime = 30
+    @posX = pX
+    @posY = pY
+  end
+  
+  ## the update function of the timer class does most of the timing job
+  # the frame counter variable is updated every 16.666666 ms (Gosu's default refresh rate)
+  # this leads to about 60 frames per second, so every 60 frames the total time count will decrease by 1
+  def update
+    if @frameCounter < 60 then
+      @frameCounter += 1
+    else
+      @frameCounter = 0
+      if @totalTime != 0 then
+        @totalTime -= 1
+      end
+    end
+  end
+  
+  ## the draw function of the timer utilizes the draw function of the font object that was passed in
+  # it will draw the font object with text being the time remaining at location (posX, posY) in the window
+  def draw
+    @font.draw("Time: #{@totalTime}", @posX - 100, @posY, 0, 2, 2, 0xFFFFFFFF)
+  end
+  
+  ## the return time function of this class will return the time that is remaining in the game
+  def return_time
+    return @totalTime
+  end
+  
+end

data/lib/tumblr-game/tumblr.rb

@@ -0,0 +1,74 @@
+require 'open-uri'
+require 'tumblr_client'
+
+class TumblrAPIObject
+  
+  ## creates a new Tumblr API Object that is able to pull information from Tumblr's servers
+  # the initialize function has a single parameter that will accept a string that is the URL of the desired blog.
+  # this function will process and strip down the string into the following format: blogname.tumblr.com/
+  def initialize(input)
+    # Authenticate via OAuth
+    @client = Tumblr::Client.new({
+      :consumer_key => 'eYFF887FauAjtA92YZLBwPI0TmYCNrYOyVBGvPD8GOCvkCFyCy',
+      :consumer_secret => 'e888vLuYxDwPyWSfGJCfkNOwro8su3LX2CiUTMcZwfop7uhqPM',
+      :oauth_token => 'hlBXwpRcylfwZk5ZnTcRMfUxOYb6oQO8P9cnAjcL2PeUlJYaSh',
+      :oauth_token_secret => 'oOPzfs94gBGrSa6Fm5BjxZEFWouptnYeB6DbshQuzmsbkx84ao'
+    })
+    
+    # process the parameter string input to convert it into the right format
+    # store it in the variable url that will be usd in the query function
+    # the regular expression in the sub function will replace urls of the form http://blogname.tumblr.com or http://www.blogname.tumblr.com with
+    # blogname.tumblr.com/
+    @url = input.downcase.sub(/http:\/\/(www.){,1}/, '')
+  end
+  
+  ## uses the Tumblr API object to request pictures. It pulls 10 pictures right now but is only using 5.
+  # for each picture, it finds the url of that image with a width of 250px. it then stores that url in the imageArray.
+  # if the query to the Tumblr API was empty, this function returns a 0 indicating an error. If the results were nonempty, 
+  # the function returns the number of pictures grabbed.
+  def query
+    # Make the request
+    results = @client.posts(@url, :type => "photo", :limit => 5)
+    i = 0
+
+    # if there were no results, return 0 which will give an error in game.rb
+    if results.empty?
+      return 0
+    elsif (results.size != 2) and (results["posts"].size == 5) # results will have a size of two if there was an error with the tumblr API, also need 5 pictures
+      @imageArray = Array.new(5)
+      begin
+      	@imageArray[i] = results["posts"][i]["photos"][0]["alt_sizes"][1]["url"].sub(/_[4-5]00/, '_250') # regular expression will select pictures 250px wide
+      	i += 1
+      end while i < 5
+      return @imageArray.size
+    else
+      return results.size
+    end
+  end
+  
+  ## this function initializes a hash that maps each image to an identifier. we only grabbed 5 images but this function copies each one 
+  # to end up with 10 pictures. the function then opens each picture using modulo arithmetic to loop back around.
+  # FUTURE GOAL: INSTEAD OF COPYING EACH IMAGE ONCE, CHANGE THIS FUNCTION TO JUST OPEN THE 5 IMAGES.
+  def create_images
+    imgNames = Hash[
+       	'image1.png' => 0,
+       	'image2.png' => 1,
+       	'image3.png' => 2,
+       	'image4.png' => 3,
+       	'image5.png' => 4,
+       	'image6.png' => 0,
+       	'image7.png' => 1,
+       	'image8.png' => 2,
+       	'image9.png' => 3,
+       	'image10.png' => 4 ]
+   	
+    i = 0
+    imgNames.each_key do |imgN|
+      open(imgN, 'wb') do |file|
+        puts "Loading..."
+        file << open(@imageArray[i%5]).read
+      end
+      i += 1
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: tumblr-game
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Joe Canero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.9
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.50
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.50
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: tumblr_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: A simple game that allows users to download images from Tumblr blogs
+  and use them for an image matching game.
+email: caneroj1@tcnj.edu
+executables:
+- Main
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/game.rb
+- lib/tumblr-game/tumblr.rb
+- lib/tumblr-game/gosu.rb
+- lib/tumblr-game/tile.rb
+- lib/tumblr-game/board.rb
+- lib/tumblr-game/timer.rb
+- bin/Main
+homepage: http://rubygems.org/gems/hola
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Tumblr Image Matching game!
+test_files: []