Hi folks,
Just for fun I implemented a quick and dirty version of
turtle_viewer.rb using Java/Swing. It must be run using JRuby 0.9.1.
Just put the file alongside turtle_viewer.rb and call:
jruby jturtle_viewer.rb
Here it is:
# jturtle_viewer.rb
require 'java'
require "lib/turtle"
class TurtleView
DEFAULT_FRAME = [[-200.0, 200.0], [200.0, -200.0]]
attr_accessor :frame
def initialize(turtle, canvas, frame=DEFAULT_FRAME)
@turtle = turtle
@canvas = canvas
@frame = frame
@turtles = []
end
def handle_map_event(w, h)
top_lf, btm_rt = frame
x0, y0 = top_lf
x1, y1 = btm_rt
@x_xform = make_xform(x0, x1, w)
@y_xform = make_xform(y0, y1, h)
end
def draw
g = @canvas.graphics
@turtle.track.each do |seqment|
if seqment.size > 1
pts = seqment.collect { |pt| transform(pt) }
g.drawLine(pts[0][0], pts[0][1], pts[1][0], pts[1][1])
end
end
end
def transform(turtle_pt)
x, y = turtle_pt
[@x_xform.call(x), @y_xform.call(y)]
end
private
def make_xform(u_min, u_max, v_max)
lambda { |u| v_max * (u - u_min) / (u_max - u_min) }
end
end
JFrame = javax.swing.JFrame
JPanel = javax.swing.JPanel
Dimension = java.awt.Dimension
BorderLayout = java.awt.BorderLayout
class TurtleViewer
def initialize(code)
@code = code
root = JFrame.new "Turtle Graphics Viewer"
@canvas = JPanel.new
root.get_content_pane.add @canvas, BorderLayout::CENTER
root.set_default_close_operation(JFrame::EXIT_ON_CLOSE)
root.set_preferred_size Dimension.new(440, 440)
root.set_resizable false
root.pack
root.set_visible true
run_code
end
def run_code
turtle = Turtle.new
view = TurtleView.new(turtle, @canvas)
view.handle_map_event(@canvas.width,
@canvas.height)
turtle.run(@code)
view.draw
end
end
# Commands to be run if no command line argument is given.
CIRCLE_DESIGN = <<CODE
def circle
pd; 90.times { fd 6; rt 4 }; pu
end
18.times { circle; rt 20 }
CODE
if ARGV.size > 0
code = open(ARGV[0]) { |f| f.read }
else
code = CIRCLE_DESIGN
end
TurtleViewer.new(code)
Ruby Quiz wrote:
> The three rules of Ruby Quiz:
>
> 1. Please do not post any solutions or spoiler discussion for this quiz until
> 48 hours have passed from the time on this message.
>
> 2. Support Ruby Quiz by submitting ideas as often as you can:
>
> http://www.rubyquiz.com/
>
> 3. Enjoy!
>
> Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone
> on Ruby Talk follow the discussion. Please reply to the original quiz message,
> if you can.
>
> -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
>
> by Morton Goldberg
>
> [Editor's Note: You can download the files for this quiz at:
>
> http://rubyquiz.com/turtle.zip
>
> --JEG2]
>
> Turtle Graphics
> ===============
>
> Turtle graphics is a form of computer graphics based on the ideas of turtle
> geometry, a formulation of local (coordinate-free) geometry. As a brief
> introduction to turtle graphics, I quote from [1]:
>
> Imagine that you have control of a little creature called a turtle
> that exists in a mathematical plane or, better yet, on a computer
> display screen. The turtle can respond to a few simple commands:
> FORWARD moves the turtle in the direction it is facing some
> number of units. RIGHT rotates it clockwise in its place some
> number of degrees. BACK and LEFT cause the opposite movements. ...
> The turtle can leave a trace of the places it has been: [its
> movements] can cause lines to appear on the screen. This is
> controlled by the commands PENUP and PENDOWN. When the pen is
> down, the turtle draws lines.
>
> For example, the turtle commands to draw a square, 100 units on a side, can be
> written (in a Ruby-ized form) as:
>
> pen_down
> 4.times { forward 100; right 90 }
>
> For more information, see [2] and [3].
>
> This quiz is a bit different from most. If the usual Ruby quiz can be likened to
> an essay exam, this one is a fill-in-the-blanks test. I'm supplying you with a
> complete turtle graphics package, except -- to give you something to do -- I've
> removed the method bodies from the key file, lib/turtle.rb. Your job is to
> repair the damage I've done and make the package work again.
>
> Turtle Commands
> ===============
>
> There are quite a few turtle commands, but that doesn't mean you have to write a
> lot of code to solve this quiz. Most of the commands can be implemented in a
> couple of lines. It took me a lot longer to write a description of the commands
> than it did for me to implement and test all of them.
>
> I use the following format to describe turtle commands:
>
> long_name | short_name <arg>
> description ...
> Example: ...
>
> All turtle commands take either one argument or none, and not all turtle
> commands have both a long name and a short name.
>
> Required Commands
> -----------------
>
> These commands are required in the sense that they are needed to reproduce the
> sample designs. Actually, you could get away without implementing 'back' and
> 'left', but implementing them is far easier than trying to write turtle code
> without them.
>
> pen_up | pu
> Raises the turtle's pen. The turtle doesn't draw (lay down a visible
> track) when its pen is up.
>
> pen_down | pd
> Lowers the turtle's pen. The turtle draws (lays down a visible track)
> when its pen is down.
>
> forward | fd <distance>
> Moves the turtle forwards in the direction it is facing.
> Example: forward(100) advances the turtle by 100 steps.
>
> back | bk <distance>
> Moves the turtle backwards along its line of motion.
> back <distance> == forward -<distance>
> Example: back(100) backs up the turtle by 100 steps.
>
> right | rt <angle>
> Turns the turtle clockwise by <angle> degrees.
> Example: right(90) turns the turtle clockwise by a right angle.
>
> left | lt <angle>
> Turns the turtle counterclockwise by <angle> degrees.
> left <angle> == right -<angle>
> Example: left(45) turns the turtle counterclockwise by 45 degrees.
>
> Traditional Commands
> --------------------
>
> These commands are not needed to reproduce any of the sample designs, but they
> are found in all implementations of turtle graphics that I know of.
>
> home
> Places the turtle at the origin, facing north, with its pen up. The
> turtle does not draw when it goes home.
>
> clear
> Homes the turtle and empties out it's track. Sending a turtle a clear
> message essentially reinitializes it.
>
> xy
> Reports the turtle's location.
> Example: Suppose the turtle is 10 turtle steps north and 15 turtle steps
> west of the origin, then xy will return [-15.0, 10.0].
>
> set_xy | xy= <point>
> Places the turtle at <point>. The turtle does not draw when this command
> is executed, not even if its pen is down. Returns <point>.
> Example: Suppose the turtle is at [10.0, 20.0], then self.xy = [50, 80]
> moves the turtle to [50.0, 80.0], but no line will drawn between the [10,
> 20] and [50, 80].
>
> heading
> Reports the direction in which the turtle is facing. Heading is measured
> in degrees, clockwise from north.
> Example: Suppose the turtle is at the origin facing the point [100, 200],
> then heading will return 26.565 (approximately).
>
> heading= | set_h <angle>
> Sets the turtle's heading to <angle>. <angle> should be given in degrees,
> measured clockwise from north. Returns <angle>.
> Example: After self.heading = 135 (or set_h(135) which is easier to
> write), the turtle will be facing southeast.
>
> pen_up? | pu?
> Reports true if the turtle's pen is up and false otherwise.
>
> pen_down? | pd?
> Reports true if the turtle's pen is down and false otherwise.
>
> Optional Commands
> -----------------
>
> These commands are only found in some implementations of turtle graphics. When
> they are implemented, they make the turtle capable of doing global (coordinate)
> geometry in addition to local (coordinate-free) geometry.
>
> I used one of these commands, go, to draw the mandala design (see
> designs/mandala.tiff and samples/mandala.rb). If you choose not to implement the
> optional commands, you might try writing a turtle program for drawing the
> mandala design without using go. But, believe me, it is much easier to implement
> go than to write such a program.
>
> go <point>
> Moves the turtle to <point>.
> Example: Suppose the turtle is home (at the origin facing north). After
> go([100, 200]), the turtle will be located at [100.0, 200.0] but will
> still be facing north. If its pen was down, it will have drawn a line
> from [0, 0] to [100, 200].
>
> toward | face <point>
> Turns the turtle to face <point>.
> Example: Suppose the turtle is at the origin. After toward([100, 200]),
> its heading will be 26.565 (approximately).
>
> distance | dist <point>
> Reports the distance between the turtle and <point>.
> Example: Suppose the turtle is at the origin, then distance([400, 300])
> will return 500.0 (approximately).
>
> Interfacing to the Turtle Graphics Viewer
> =========================================
>
> Implementing turtle graphics without being able to view what the turtle draws
> isn't much fun, so I'm providing a simple turtle graphics viewer. To interface
> with the viewer, turtle instances must respond to the message track by returning
> an array which the viewer can use to generate a line drawing.
>
> The viewer expects the array returned by track to take the following form:
>
> track ::= [segment, segment, ...] # drawing data
> segment ::= [point, point, ...] # points to be joined by line segments
> point ::= [x, y] # pair of floats
>
> Example: [[[0.0, 0.0], [200.0, 200.0]], [[200.0, 0.0], [0.0, 200.0]]]
>
> This represents an X located in the upper-right quadrant of the viewer; i.e.,
> two line segments, one running from the center of the viewer up to its
> upper-right corner and the other running from the center of the top edge down to
> the center of the right edge.
>
> [Editor's Note: I added a script to dump your turtle graphics output to PPM
> image files, for those that don't have TK up and running. It works identically
> to Morton's turtle_viewer.rb, save that it writes output to a PPM image file in
> the current directory. For example, to output the included tree image, use
> `ruby turtle_ppm_writer.rb samples/tree.rb`. --JEG2]
>
> Unit Tests
> ==========
>
> I'm including the unit tests which I developed to test turtle commands. For the
> purposes of the quiz, you can ignore tests/turtle_view_test.rb. But I hope you
> will find the other test suite, tests/turtle_test.rb, helpful. It tests every
> one of the turtle commands described above as well as argument checking by the
> commands. Don't hesitate to modify any of the unit tests to meet the needs of
> your quiz solution.
>
> References
> ==========
>
> [1] Abelson, H. & A. diSessa, "Turtle Geometry", MIT Press, 1981.
> [2] Harvey, B., "Computer Science Logo Style", Chapter 10.
> http://www.cs.berkeley.edu/~bh/pdf/v1ch10.pdf
> [3] Wikipedia, http://en.wikipedia.org/wiki/LOGO_programming_language