Tag Archives: Week 5

CCOW Week 5 Wrapup


SeaCow- Fritzfranz Fride- flickr

This week I immersed myself in learning the basic principles, structure and commands of Python, so I did not do many of the week’s optional activities.  Here is a summary of how I approached week 5.

Help with Scripts:  I went on to the Help with Scripts discussion forum on the Scratch website a couple of times and read through the posts but I did not find any posts where I could give specific, constructive help that someone else had not already answered better.  Pro-tip:  When asking for help on a forum have a specific question in mind, and give as much detail as you can about the difficulties you are encountering.

Hardware and Extensions:   I did not do anything with this activity other than to think to myself, “Gee whiz there are a lot of neato gadgets that you can interact with using scratch”.

Unfocus Group:  I greatly enjoyed this activity but I ended up having an unfocus group of one.  I sent out emails to a musician friend who is also an open-source advocate and programmer, another tech crazy elementary teach in Nebraska, and a childhood friend who I learned to code with when we were 13 or 14.  Only Brad, my childhood friend was able to take some time  with me to discuss my project.  Unlike me, Brad continued to explore computer programming throughout his life.  He is a freelance programmer and database designer who now lives in northern Minnesota.  We had a wide ranging skype chat that meandered in the manner of  conversations between old friends.

Brad was fascinated by the concept of SCRATCH as a programming language to teach programming.   He also gave me several suggestions about choosing an Integrated Development Environment (IDE) including Eclipse (which is free and open source) and JetBrains, which is a commercial product but it has several cheaper or free options for teachers or open-source projects.  Brad’s point was if you choose get a multi-language, full-featured IDE, then you don’t need to relearn your programming environment every time you have a desire or need to learn a new programming language.

As I am writing this Brad popped up in my skype window… (I love years long, asynchronous text conversations).   He writes:

[10:47:50 AM] Brad: Heh, of course, there is a good argument to be made that no-one appreciates what an IDE does for them until they first use a text-based editor.  Notepad++ is a very nice text editor and has all the hooks into any language you want to use, plus user-customizable language settings too.  So maybe the need to pick an IDE is not as great as the need to just simply starting to build something.

I have used Notepad++ for years when I need to directly work in html code.  I have used it during my python explorations and it is very effective at color coding and indenting python code.  It does not have an integrated python interpreters or debuggers so you have to run your program within python or another IDE.  Otherwise it is a fantastic editor for almost any language or situation when you have to directly edit or write code.

Activity Extension:  I looked at the templates for making a Scratch card, but decided to devote more time to my Python Project instead.

Workshop Project: Reporting Out and Checking In 

Here’s our checklist for this activity…

  • Add a page in your design notebook and share an update about your independent workshop project progress, by responding to the red/yellow/green reflection prompts:



Red: What are some elements of your project that aren’t going well, that you’re worried about, or that you’d love advice about?

The thing I find most frustrating. is the amount of time it takes to type then to debug code.  I think the metaphor of programming language to spoken language is appropriate because they say it takes 1-2 years to gain facility in a new language.  This is beyond the scope of a 3 week project, but I have made a good start at learning.



Yellow: What are some elements of your project that you are just OK, or that you’re feeling ambivalent about?

I’m going to reinterpret this question to:  What else do you want to write about or explore?   A couple of times a commenter has asked me about how my project can help students jump into a career in IT.  As a podcaster and musician, I have a knee jerk reaction to “How do you make money doing THAT?” questions of “I don’t know and I don’t care”.  But this question needs a longer and more sensitive blog reflection which I would like to write this week. 




traffic_light_green_dan__01Green: What are some elements of your project that are awesome or that you’re excited about?

I am enjoying the problem solving and puzzle nature of learning to make games in a new programming language.  I would like to continue doing that, even after the CCOW workshop ends.


Other Posts for Week 5:  

And One More Thing:

This week I installed two wordpress plugins into my blog to display python code (and indeed almost any kind of programming code) with correct formatting and color coding:   W-P Code Highlight and  Sunburst Code Prettify.

Recreating a Python Simulation in Scratch

Cooriemungle_Water_Tank_Cow_Monster-wikimedia-commonsIn my last post, I added my own modifications to the tutorial  Making Breakout by Leonel at codeNtronix.   He also has a number of tutorials about drawing 3D graphics using python and pygame.  I was intrigued by his simulation of a 3D Starfield made using Python and Pygame.  (Thanks Leonel for creating such useful tutorials).


His simulation uses a few basic 3D to 2D algorithms, which I don’t fully understand but they are effective at creating the desired effect.  He created this effect with just 80 lines of source code,  Click here to download the full source code from CodeNTronics.

I analysed the code myself to see if I could recreate this simulation in Scratch.

3D Starfield

Scratch Code:  Takes 31 lines of code and painted backdrop and sprite costume in the paint editor.starfield-scratch-stage-codestarfield-scratch-starsprite-code


Python code:  81 lines from CodeNTronics, with comments added by me.

# """
# 3D Starfield Simulation
# Developed by Leonel Machava <leonelmachava@gmail.com>
# http://codeNtronix.com
# http://twitter.com/codentronix
# """
import pygame, math
from random import randrange

class Simulation:
    def __init__(self, num_stars, max_depth):  # SM- each star needs an individual variable for x,y,depth.  
        pygame.init()   # SM-- does a bunch of pygame stuff to set up screen and clock.

        self.screen = pygame.display.set_mode((640, 480))
        pygame.display.set_caption("3D Starfield Simulation (visit codeNtronix.com)")

        self.clock = pygame.time.Clock()
        self.num_stars = num_stars
        self.max_depth = max_depth

        self.init_stars()  # SM- Tells the program to make the list of stars

    def init_stars(self):
        """ Create the starfield """
        self.stars = []
        for i in range(self.num_stars):
            # A star is represented as a list with this format: [X,Y,Z]
            star = [randrange(-25,25), randrange(-25,25), randrange(1, self.max_depth)]

    def move_and_draw_stars(self):
       # """ Move and draw the stars   """   SM Converts the xy coordinates to cartesian to centre stars on screen
        origin_x = self.screen.get_width() / 2
        origin_y = self.screen.get_height() / 2

        for star in self.stars:
            # The Z component is decreased on each frame. SM-- Star Moves closer
            star[2] -= 0.19

            # If the star has past the screen (I mean Z<=0) then we
            # reposition it far away from the screen (Z=max_depth)
            # with random X and Y coordinates.
            if star[2] <= 0:
                star[0] = randrange(-25,25)
                star[1] = randrange(-25,25)
                star[2] = self.max_depth

            # Convert the 3D coordinates to 2D using perspective projection.
            k = 128.0 / star[2]   # SM I don't know where Leonel got this constant 128/depth but it works
            x = int(star[0] * k + origin_x)  #SM-- moves starfield origin towards centre of screen
            y = int(star[1] * k + origin_y)

            # Draw the star (if it is visible in the screen).
            # We calculate the size such that distant stars are smaller than
            # closer stars. Similarly, we make sure that distant stars are
            # darker than closer stars. This is done using Linear Interpolation.
            if 0 <= x < self.screen.get_width() and 0 <= y < self.screen.get_height():
                size = (1 - float(star[2]) / self.max_depth) * 5
                shade = (1 - float(star[2]) / self.max_depth) * 255

    def run(self):
        """ Main Loop """
        while 1:
            # Lock the framerate at 50 FPS.

            # Handle events.
            for event in pygame.event.get():
                if event.type == pygame.QUIT:


if __name__ == "__main__":
    Simulation(256, 32).run()


The python program presents a much more realistic starfield and is much more versatile. But the scratch program accomplishes the same task in 1/4 the length and it is much easier for me to tinker with the variables and formulas to change the appearance in SCRATCH. It is an accomplishment that I can understand enough of Python to recreate the essential features of a program in SCRATCH. To use the analogy of spoken languages, I think that I have progressed to the point that I can understand a bit of what I read and hear in PYTHONESE, but I cannot yet speak it like a native. This is very good progress for 10 days. To extend the spoken language analogy, one of the common exercises for people learning a second language is to translate passages from one language to another.  That is exactly what I attempted here, and I am quite satisfied with the results.

In which I Pursue Progress with Programming in Python

99er MagazineIn  1981 or so, my brother and I were 12 and 13 years old and we both had paper routes.  We pooled the fruits of our paper carrier jobs, and Dad took us down to the Alberta Treasury Branch where he co-signed a $1200 personal loan at a whopping 23% interest so that we could buy our first personal computer– a TI-99/4.  In fact it was the first personal computer anyone had in our neighbourhood.  We poured over the accompanying manuals, got all sorts of books from the library, and subscribed to 99er magazine.  These early computer enthusiast magazines offered articles about the future of computing, ads for enticing new peripherals and gadgets, and most importantly programs.  Each magazine contained printouts– recipes I guess, for dozens of programs.  We learned to program by painstakingly copying programs from printouts in these magazines, even more painstakingly debugging our errors then figuring out how to fix the inevitable mistakes in the magazine’s code.

30 year later, as I make the transition from SCRATCH, to PYTHON, I find myself transported back to the same learning process.  As I undertook to learn a new programming language, I found myself seeking out familiar “Teach yourself programming by copying these game’ books.  But this time I did not need to go to the magazine stand, or the library, or order in by mail.  The resources are all a google away.  I think it says something about my personal learning style that I chose the cookbook style of print resources over the many multimedia and video tutorials available on youtube.

I’ve spent most of the last week trying to understand some of the basic structure and commands of python, as I worked my way through a variety of tutorial programs.  First impression is compared to scratch there is alot more fiddly typing and figuring out exactly how to initialize then execute each step.  Unlike scratch, it is much harder in python to just poke around and see what will happen.  If you don`t know the precise order, structure, and syntax for any small part… the whole program may not even start.  I think here is a fundamental difference between Scratch and python.  Constructivist philosophy is at the core SCRATCH.  It is designed to be explored, tinkered with and discovered.  On the other hand, Python is designed to be functional, readable, and infinitely extensible.  Alex Martelli, author of the Python Cookbook, summed up the Python Philosophy:

To describe something as clever is not considered a compliment in the Python culture.” Python’s philosophy rejects the Perl “there is more than one way to do it” approach to language design in favor of “there should be one—and preferably only one—obvious way to do it”.  From:  Python Programming Language on Wikipedia.

Bricka by codeNtronix

Download the original Brika Source code from codeNtronix

and here is my revised source code for Bricka.

 bricka (a breakout clone)
 Developed by Leonel Machava <leonelmachava@gmail.com>

with revisions by Sean McGaughey http://edalchemy.mcgaughey.ca
during Creative Computing Online Workshop

import sys, pygame
from pygame.locals import *

SCREEN_SIZE   = 640,480

# Object dimensions
BALL_RADIUS   = int(BALL_DIAMETER / 2)   #source code was just BALL_DIAMETER / 2 This through an error of floating point vs Int error
                                        # I added an int function to make sure it is an integer value


# Paddle Y coordinate

# Color constants
BLACK = (0,0,0)
WHITE = (255,255,255)
BLUE  = (0,0,255)
BRICK_COLOR = (200,200,0)

# State constants

mousex = 0 #x coordinate of mouse event
mousey = 0 # y coordinate of mouse event

class Bricka:

    def __init__(self):

        self.screen = pygame.display.set_mode(SCREEN_SIZE)
        pygame.display.set_caption('bricka (a breakout clone by codeNtronix.com)')

        self.clock = pygame.time.Clock()

        if pygame.font:
            self.font = pygame.font.Font('freesansbold.ttf',20)
            self.font = None


    def init_game(self):
        self.lives = 3
        self.score = 0
        self.state = STATE_BALL_IN_PADDLE

        self.paddle   = pygame.Rect(300,PADDLE_Y,PADDLE_WIDTH,PADDLE_HEIGHT)
        self.ball     = pygame.Rect(300,PADDLE_Y - BALL_DIAMETER,BALL_DIAMETER,BALL_DIAMETER)

        self.ball_vel = [5,-5]


    def create_bricks(self):
        y_ofs = 35
        self.bricks = []
        for i in range(7):
            x_ofs = 35
            for j in range(8):
                x_ofs += BRICK_WIDTH + 10
            y_ofs += BRICK_HEIGHT + 5

    def draw_bricks(self):
        for brick in self.bricks:
            pygame.draw.rect(self.screen, BRICK_COLOR, brick)

    def check_input(self):
        for event in pygame.event.get(): # event handling loop
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
            elif event.type == MOUSEMOTION: # I added these mouse controls.  It works well.
                mousex, mousey = event.pos
                if mousex >= MAX_PADDLE_X:
                    self.paddle.left = MAX_PADDLE_X
                    self.paddle.left = mousex

            elif event.type == MOUSEBUTTONUP:
                mousex, mousey = event.pos
                self.paddle.left = mousex
                mouseClicked = True
                if self.state == STATE_BALL_IN_PADDLE:
                    self.state = STATE_PLAYING

        keys = pygame.key.get_pressed()

        if keys[pygame.K_LEFT]:
            self.paddle.left -= 5
        if self.paddle.left < 0:             self.paddle.left = 0         if keys[pygame.K_RIGHT]:             self.paddle.left += 5         if self.paddle.left > MAX_PADDLE_X:
            self.paddle.left = MAX_PADDLE_X

        if keys[pygame.K_SPACE] and self.state == STATE_BALL_IN_PADDLE:
             self.state = STATE_PLAYING
        elif keys[pygame.K_RETURN] and (self.state == STATE_GAME_OVER or self.state == STATE_WON):


    def move_ball(self):
        self.ball.left += self.ball_vel[0]
        self.ball.top  += self.ball_vel[1]

        if self.ball.left <= 0:             self.ball.left = 0             self.ball_vel[0] = -self.ball_vel[0]         elif self.ball.left >= MAX_BALL_X:
            self.ball.left = MAX_BALL_X
            self.ball_vel[0] = -self.ball_vel[0]

        if self.ball.top < 0:             self.ball.top = 0             self.ball_vel[1] = -self.ball_vel[1]         elif self.ball.top >= MAX_BALL_Y:
            self.ball.top = MAX_BALL_Y
            self.ball_vel[1] = -self.ball_vel[1]

    def handle_collisions(self):
        for brick in self.bricks:
            if self.ball.colliderect(brick):
                self.score += 3
                self.ball_vel[1] = -self.ball_vel[1]

        if len(self.bricks) == 0:
            self.state = STATE_WON

        if self.ball.colliderect(self.paddle):
            self.ball.top = PADDLE_Y - BALL_DIAMETER
            self.ball_vel[1] = -self.ball_vel[1]
        elif self.ball.top > self.paddle.top:
            self.lives -= 1
            if self.lives > 0:
                self.state = STATE_BALL_IN_PADDLE
                self.state = STATE_GAME_OVER

    def show_stats(self):
        if self.font:
            font_surface = self.font.render('SCORE: ' + str(self.score) + ' LIVES: ' + str(self.lives), False, WHITE)
            self.screen.blit(font_surface, (205,5))

    def show_message(self,message):
        if self.font:
            size = self.font.size(message)
            font_surface = self.font.render(message,False, WHITE)
            x = (SCREEN_SIZE[0] - size[0]) / 2
            y = (SCREEN_SIZE[1] - size[1]) / 2
            self.screen.blit(font_surface, (x,y))

    def run(self):
        while 1:
            for event in pygame.event.get():     # I added these lines from Sweigart, making Games with Python
                if event.type == pygame.QUIT:
                    sys.exit                    # To check for Quit


            if self.state == STATE_PLAYING:
            elif self.state == STATE_BALL_IN_PADDLE:
                self.ball.left = self.paddle.left + self.paddle.width / 2
                self.ball.top  = self.paddle.top - self.ball.height
                self.show_message('PRESS SPACE TO LAUNCH THE BALL')
            elif self.state == STATE_GAME_OVER:
                self.show_message('GAME OVER. PRESS ENTER TO PLAY AGAIN')
            elif self.state == STATE_WON:
                self.show_message('YOU WON! PRESS ENTER TO PLAY AGAIN')


            # Draw paddle
            pygame.draw.rect(self.screen, BLUE, self.paddle)

            # Draw ball

            pygame.draw.circle(self.screen, WHITE, (self.ball.left + BALL_RADIUS, self.ball.top + BALL_RADIUS), BALL_RADIUS)

            self.show_stats ()

if __name__ == '__main__':



Here is my first attempt at programming a game in Scratch from November of 2011.