This one is probably the longest episode in the entire series (at least so far), which is why it’s taken me a bit longer to finish. (I’m still not 100% sure I’ve caught every mistake, so if you see any code errors or script typos, don’t hesitate to email me, or leave a comment here).

Enjoy!

- Tyler

Have fun!

- Tyler

This episode has text drawing and players scoring on each other, I hope you like it

- Tyler

This episode has the ball boucing off the sides of the screen and the paddles, so it’s pretty cool, I hope you like it!

- Tyler

Enjoy!

- Tyler

So you know that Making Games With Ruby series that I’ve been neglecting for a while? I’m working on it again!

So here’s what you need to know:

• I’ve decided to write the entire series before I make any more videos
• You can see a text version of the tutorials here: http://devel.manwithcode.com/making-games-with-ruby.html (so far I’ve gotten through episode 4)
• If you see anything I say that’s wrong, is confusing, needs more explanation, or if there’s any code that doesn’t work, tell me about it and I’ll fix it as soon as I can

Sorry for the wait, and I hope you like the tutorials!

Covered In This Episode

• I’m sorry
• Why I’ve been gone
• Making Games with Ruby update
• Thank you donators!

Covered In This Episode:

• Creating a Window
• Basic Event Handling

Transcript:

Hello Everybody and welcome to making games with Ruby episode 3, Basics. I’m Tyler and these videos are brought to you by manwithcode.com.

Today we’re just going to be talking about the very basics of game creation, just getting a window on the screen. The code for this episode is on manwithcode.com, if you’re not there already. http://manwithcode.com/322/making-games-with-ruby-ep-3-basics

Lets get started!

We’re going to start by requiring in the libraries we need, which for now is only rubygems and rubygame:

require 'rubygems'
require 'rubygame'

Then we’re going to create the main Game class, and stub out all the methods in it:

class Game
	def initialize
	end

	def run!
	end

	def update
	end

	def draw
	end
end

And after that we’re going to add the code to run the game:

g = Game.new
g.run!

So far this is just some very basic structure, nothing really happens yet. I’m going to run the code just to double check we have no syntax errors…

The first thing we’re going to do is initialize everything we’ll need:

def initialize
	@screen = Rubygame::Screen.new [640, 480], 0, [Rubygame::HWSURFACE, Rubygame::DOUBLEBUF]
	@screen.title = "Pong"

	@queue = Rubygame::EventQueue.new
	@clock = Rubygame::Clock.new
	@clock.target_framerate = 60
end

Some of this is self explaitory, but let’s break it down. The first line of initialize creates the window for our game, Rubygame calls this a Screen. The first argument [640, 480] is the size of the screen, the second is the screen depth (you don’t need to worry about this), the last one is a list of flags we pass to rubygame. HWSURFACE means we want it to be accelerated on the graphics card if available, and DOUBLEBUF means we want the screen to be double buffered. Double buffering is a way of drawing to the screen. I won’t go into too much detail right now to explain double buffering, but I will in a later episode.

The second line has an obvious purpose, it sets the title at the top of the screen to Pong

The fifth line is setup so we can handle events, I’ll talk more about this later.

The last two lines are the setup so we can limit the framerate to 60 frames per second. The frame rate is how many times the screen is drawn every second (we’ll be doing our drawing in the Game#draw method). If we let this go unchecked, our game will run as fast as possible which isn’t desireable since top speed will be different on different computers, and depending on what the game is doing at a particular moment in time. I think 60 is a good number, but we can easily change it later if we want.

Next we’re going to setup the main game loop:

def run!
	loop do
		update
		draw
		@clock.tick
	end
end

This loops indefinately until we decide in a different part of the code to end the game. @clock.tick is what allows us to limit our framerate. You can now run the game, it should just be a black screen. You can see the title at the top, like we set in the initialize function.

But if you try to close the window… Nothing happens!!! To close it try pressing CTRL+C in the command prompt window, or you may have to go to the task manager and kill it from there. To fix this problem, we need to talk about the event queue.

We’re going to start by defining the update method:

def update
	@queue.each do |ev|
		case ev
			when Rubygame::QuitEvent
				Rubygame.quit
				exit
		end
	end
end

Whenever the user gives us some input, presses a key, moves the mouse, etc. the Rubygame adds an event for this input onto the queue. We handle these events in our update method.

@queue.each loops over each event, and we have a case statement that handles the event depending on the type. For closing the window, the event type is Rubygame::QuitEvent, which is generated whenever the user presses the close window button or ALT+F4.

Now if you run the game, the window should appear and you should be able to close it now! Yay!

This is the final source listing for this episode:

require 'rubygems'
require 'rubygame'

class Game
	def initialize
		@screen = Rubygame::Screen.new [640, 480], 0, [Rubygame::HWSURFACE, Rubygame::DOUBLEBUF]
		@screen.title = "Pong"

		@queue = Rubygame::EventQueue.new
		@clock = Rubygame::Clock.new
		@clock.target_framerate = 60
	end

	def run!
		loop do
			update
			draw
			@clock.tick
		end
	end

	def update
		@queue.each do |ev|
			case ev
				when Rubygame::QuitEvent
					Rubygame.quit
					exit
			end
		end
	end

	def draw
	end
end

g = Game.new
g.run!

This brings us to the end of the episode.

If you have any questions, comments, or suggestions, leave a comment on this page or email me at tyler@manwithcode.com.

Thank you very much for watching! Goodbye!

gem install rubygame

Mac:

Linux:

sudo apt-get install -y libsdl1.2debian libsdl1.2-dev libsdl-image1.2 libsdl-image1.2-dev libsdl-ttf2.0-0 libsdl-ttf2.0-dev libsdl-mixer1.2 libsdl-mixer1.2-dev libsdl-gfx1.2-4 libsdl-gfx1.2-dev

sudo gem install rubygame

Links:

• Rubygame Installation guides
• Rubygame windows dependencies

Covered in This Episode:

• How to get set up for this series on Windows, Mac, and Linux

Links:

• Programming with Ruby Video Tutorials

Covered In This Episode:

• What you’ll learn
• What we’re using
• What I’m assuming about you
• Why I’m teaching this

Transcript:

Hello Everybody, and Welcome to the first episode of Making Games With Ruby! I’m Tyler, and this video is brought to you by manwithcode.com

In this episode I’ll be covering what you will be learning in this series, what we’re using to develop our games, what I’m assuming about you, and why I’m teaching you.

What you’ll learn

If you couldn’t tell by the title, you’re going to learn how to make games using the Ruby programming language. More specifically I’m going to teach you how to make Pong. Though Pong may sound a little simplistic, and I’m not claiming it isn’t, learning how to make Pong will teach you almost everything you’ll need to know to make any game, with out getting bogged down in game specific details.

What we’re using

Of course we’re using the Ruby programming language. To create games, we’ll have the help of the Rubygame library, which is many things including a wrapper around SDL, and a nice framework for developing games.

In the creation of this series I will be using Ruby 1.8.7-p174, and Rubygame 2.6.2. Theoretically The code in this series should run on Ruby 1.8.whatever and Rubygame 2.whatever, no promises though, since languages and libraries change.

And if you want to know about my environment, I’ll be running Ubuntu 9.10 as my Operating System, and using Gedit as my text editor. You can write and run the code on any platform you wish, but this is what I prefer.

What I’m assuming about you

So I don’t have to explain every line of code to you, I’m going to be assuming that you already know the Ruby programming language. If you don’t there are many books available, as well as my own video series Programming With Ruby at http://manwithcode.com/ruby-programming-tutorials/

Just reading one book, or watching my video series probably isn’t enough. I’ll be easier if you have used Ruby for a while, and are comfortable with it. This isn’t
a requirement, but it would help make things easier on yourself.

Why I’m teaching this

There are many reasons why, but I’ll talk about the most important few:

1) I love making games.
2) I love teaching.
3) Teaching teaches me something. – When you actually sit down and think about what you do, things become more concrete, and you know why you do what you do, or even see bad habits that you need to correct
4) I’m trying to make money – Yep, I’m not going to try and hide this. Some of the videos in this series will be put up for sale, you’ll be able to see them as I put out more videos.

Thank you very much for watching! I’ll see you in the next video.

Making Games with Ruby is the next video series!

Updates on the status of Man With Code, what’s been going on, what’s to come.

Links:

• Donate: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4222118
• Submit This Link: http://manwithcode.com/ruby-programming-tutorials/
• Vote: http://manwithcode.com/tutorials-under-consideration/
• Leave Feedback Here: http://manwithcode.com/235/leave-feedback-here-programming-with-ruby-feedback/

Covered In This Episode:

• $1000 or 1000 comments
• Submit to Social Media

Transcript:

Hello Everybody and welcome to Programming With Ruby, Feedback. I’m
Tyler, and this video is brought to you by manwithcode.com.

In this video I’m going to be going over what needs to happen for me
to produce the next series of video tutorials.

All links I mention will be in the video description

First things first, if you head on over to
http://manwithcode.com/tutorials-under-consideration/

You can vote on what the next video series will be.

So if you vote I will know what YOU want, now you need to know what I
want for the next series to happen.

I’ve had well over 1,000 unique viewers of this video series, so I
need you viewers to donate a total of $1000 before I make the next
series. This may seem like a high amount, but if only 200 people
donate $5, that is a thousand dollars.

Donate: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4222118

Now, what if you don’t have the money to donate? I will be making a
post on manwithcode.com named Ruby Video Tutorial Feedback, if 1000
people leave feedback (i.e. What they liked, what they didn’t like).

So whatever comes first, 1000 comments or $1000 will cause me to start
the next video series.

For updates on how close we are to each goal, I will be on twitter at
the account tylerjchurch and with the tag #manwithcode.

Now what if you can’t donate money, and you can’t write me feedback?
Then there is something else you can do!
http://manwithcode.com/ruby-programming-tutorials/

• Tweet on Twitter
• Give a thumbs up on StumbleUpon
• Submit to Digg
• Submit to Reddit
• Bookmark on delicious
• Blog about
• or you can just Tell a friend

And hopefully one of those people who come along will donate or leave
feedback.

So don’t forget to donate, leave feedback, or submit the provided link
to social media!

Thanks for watching, bye!

Covered In This Episode:

• Where to go from here
• Books
• Libraries
• A few other things…

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 18, Out
Into The World. I’m Tyler and this video is brought to you by
manwithcode.com.

In this episode I will be telling you where to go from here, now that
you know the basics of Ruby. I’ll show you some books, some common
libraries. And I’ll go over a few more things.

Where to go from here

Now that this series is almost done, you may be wondering what you
should do. First, I recommend you start writing your own
programs. Find something you would like to write and just try writing
it.

You may also want to read a few other resources like books and online
tutorials about Ruby for things I didn’t cover and to reinforce what
you have learned.

For books I would recommend:

• Beginning Ruby, From Novice to Professional
• The Ruby Programming Language

If you are trying to make something, but can’t do it with Ruby alone,
here are some libraries in a few common areas. I won’t be providing
links, but a quick Google search will find them for you.

Web Development

• Ruby on Rails
• Sinatra
• Merb

Game Development

• Rubygame
• rubysdl
• Gosu

Testing

• rspec
• cucumber

Images

• RMagic

GUI Toolkits

• Ruby-WxWidgets
• Ruby-GNOME2
• Shoes

If you need a library for something I didn’t cover, you can check
Ruby’s documentation at ruby-doc.org, you can try and find a project
by searching at rubyforge.org and github.com. If all else fails, just
Google it.

This is actually the end of the episode, but though this video is
purported as the end of the series, there is going to be at least one
more video, so stay tuned.

If you’ve liked this series, please donate!

If you have and questions, comments, or suggestions about this series
or Man With Code, you can leave a comment on this page or email me at
tyler@manwithcode.com

Thanks for watching, goodbye!

Covered In This Episode:

• Symbols
• eval
• Bindings
• Running Other Programs
• Safe Levels

Transcript:

Hello Everybody and welcome to Programming With Ruby Episode 17,
Getting Advanced. I’m Tyler, and this video is brought to you by
manwithcode.com.

By now, you know a large amount about Ruby, so in this episode we will
be going over some advanced features that Ruby has.

More specifically I will be teaching you what Symbols are, and when to
use them. I will be showing you how to use eval, and how to use
bindings with eval. You will learn how to run other programs from
Ruby. Finally I will show you what safe levels are.

Lets get started!

Symbols

Symbols are a type of variable that are very much like strings, but
more lightweight. Symbols look like this:

:variable

Symbols can’t be manipulated like strings can, which seems like a huge
drawback, but they do have a couple benefits.

Each time you use a string, to say access a hash. Ruby creates an
instance of that string. Where if you use a symbol, it is only ever
instanced once. Meaning that the use of symbols will take up less
memory than strings will, if you are, say accessing a hash many times.

Symbols are also slightly easier to type since the colon is on the
home row on US keyboards.

eval

eval is a way of running Ruby code that is contained in a string. For
example, lets say you have a string that looks like this:

"puts 'Hello World'"

It is just a simple string, so it does nothing. But, if you use the
method eval on that string it will execute the code inside. So this
will print Hello World! on to the screen:

eval "puts 'Hello World!'"

This isn’t always useful, but you can use it if you want your users to
be able to enter Ruby code into your program.

You can also pass bindings to eval. So if we had this method

def my_method my_binding
    eval "puts x", my_binding
end

x = 5
my_method binding

This outputs:

5

Some of you may notice that the variable x isn’t defined in the method my_method. By using the binding method, we can make variable scopes portable!

Running Other Programs

There comes a time when you will want to be able to run a program from
Ruby, maybe you want to automate something, or simply get the output
from an external program.

There are a few ways of doing this.

The first is with the method exec, which runs an external programs,
and quits the Ruby script at the same time:

exec('ls') # dir on windows
# Program never gets here

There is also system, which does the same thing, but doesn’t quit the
Ruby script, and returns true or false if the program was successful:

system('ls') # dir on windows
# we do get this far

Finally we have the “back-tick” `. Which looks like a sideways single
quote. On my keyboard it is above the tab key. You surround your
command in the back-ticks, like you would for a sting. Unlike the other
two methods of running a program, this method also returns the output
of the program you run.

variable = `ls`

Safe Levels

If you are running a Ruby interpreter online or in another environment
where users can enter in and run Ruby code. They hold the ability to
wreak havoc on your system.

The way to prevent this from happening is by using safe levels. Safe
levels are a way of preventing the user from getting access to the
file system, or changing any variables that the program has.

You set safe levels by setting the $SAFE variable. By default it is
set to zero.

$SAFE = 4

Ruby “taints” objects that could be dangerous.

There are five different safe levels.
0 => The default, you can do anything
1 => Can’t use environment variable, eval, load, require, and more.
2 => Same as above and also can’t use files
3 => All objects created are tainted, can’t be untainted
4 => You can do almost nothing… Can’t modify the untainted, can’t
use exit. Basically completely safe and sand-boxed.

That brings us to the end of the episode. If you liked these videos,
please donate. It costs me in both money and time to make them.

If you have any questions, comments, or suggestions please don’t
hesitate to leave a comment on this page or email me at
tyler@manwithcode.com

Thanks for watching, goodbye!