PyGame Simplified

A simple, user-friendly programming language that hopes to make game development easier and faster! This project is a PyCharm Community Edition 5.0.4 Project. PyGame Simplified (PGS) translates *.pgs files into *.py (Python 3.5) files that import pygame.

Documentation

Click here for documentation on each individual class provided. Syntax, tokens and phrases can be found below.

How to use

To create a new project, run SetupProject.py. To get PGS to interpret your project and translate it into Python, run Interpreter.py.

Syntax

PGS is object-oriented. It works around the basis of 'phrases', groups of tokens that connect to form one function or statement. See list below for all possible tokens, phrases and their Python translations.

Tokens

Here are all of the valid tokens (not organised very well). Token names are as stated in, for example, the source code and error handling messages.

Math/Maths (MATH_*)

Keywords (KWD_*)

Classes (CLA_*)

Variables (VAR_*)

Functions (FUN_*)

Miscellaneous (MISC_*)

Phrases

Certain sequences of characters do not make phrases (but are still valid), for example, comments, e.g.:

# This is a comment.

# This is a multi-line
# comment. You need a '#'
# symbol at the start of
# every line.

Here are the other phrases, translations and definitions. When a phrase increases or decreases the resulting indent in Python, the terms (ind+) and (ind-) are used, respectively. arg1, arg2 etc refer to the values of the tokens, respectively. For example, the phrase Function Str Begin could be translated from function draw begin into def draw():. If a specific string is required for certain behaviour, it is listed in the Usage column.

Naming and Spacing Conventions

All of these are optional, but give clarity.

Naming

• Class names and file names: UpperCamelCase
• Function names and variables: lower_underscore
• Constants: UPPER_UNDERSCORE

Spacing

• Indentation: Indent four spaces after a begin statement.
• Outdentation: Outdent four spaces just before an end statement.
• Line spaces: Each begin and end statement should have their own new line.
• Furthermore, phrases should not share lines with other phrases, and they should not span more than one line, except in cases of very long lines (over 79 chars).
• Comments: Place comments two or more spaces away from code. One space only should be allowed after the # symbol before commented documentation.
• Use long continuous lines of #s (over 10) to separate parts of code.
• To title certain parts of code, use 5 #s then the title name in all caps then 5 #s again, e.g.:
  ##### DRAW CALLS #####
• Between classes/functions: allow two line breaks between two classes, two functions or the beginning of a class. Documentation in comments counts as lines IN the class/function.
• Inline Documentation: Documentation should be immediately one line before the item it is documenting, leaving one blank line before it to separate it from previous code. Classes should have class name on the first line of documentation, then an empty line (still with # symbol), then further documentation. Certain documentation items can be given using this set of annotations (with NO hash symbol):
  • @author NAME states who authored the file.
  • @date DD/MM/YY is the date the file was CREATED, not last updated.
  • @param NAME is a parameter or argument to a specific function.
  • @return VAR_TYPE NAME or @return NAME shows what this function returns, e.g. @return StrLit greeting. It is recommended to use @return Str/String as opposed to @return StrLit because Python does not support pointers to variables (so the String keyword would be unused). Do NOT put extra code on the same line as annotations (it will be marked as comments)
  • @todo is what the user indends to add in the future.
  • @see FILE_NAME/CLASS_NAME recommends to the user to also look at said file/class for extra information.
  • @see CLASS_NAME's FUNCTION_NAME/VARIABLE_NAME is as above but shows functions and variables instead.
  • @override shows that this overrides another (parent) function.

Examples of these rules in action:

import Window  # Window.pgs


# Main class
#
@author Oli's Programming
@date 24/04/16
# Main class for sample PGS project.
class Main
begin
    initfunction
    begin
        write "Main init"

        @see Main's write_hello
        # This is where "hello_message" is used.
        set my hello_message to "hello"
    end


    # Writes "hello" to the screen.
    #
    @return String hello_message
    # The message that was just written to the screen.
    #
    @todo add the user's name, to write for example "hello, user!"
    function write_hello
    begin
        write hello_message  # and possibly do something else
        return hello_message
    end
end

Example Code

Here are some example code files, showing usage of code, phrases and stylistic conventions.

Main.pgs

import Window  # Window.pgs

# Main class
#
# @author Oli's Programming
# @date 24/04/16
#
# Handles window instance and is run
# as a single instance when
# the program is started
class Main
begin
    initfunction
    begin
        write "Main init"
        make Window called window  # Calls Window's initfunction automatically
    end
end


mainfunction  # Runs at program start
begin
    make Main called main  # Calls Main's initfunction automatically
end

Window.pgs

import pygame  # Module for windows and apps

# Window class
#
# @author Oli's Programming
# @date 24/04/16
#
# Handles draw calls and
# PyGame events
# Is owned by the Main class
# @see Main
class Window
begin
    initfunction
    begin
        write "Window init"
        run pygame's init  # Initialise PyGame
        make list (640 480) called size  # Set window size to 640x480

        store pygame's display's set_mode(size) in my hwnd  # Store window in hwnd

        set my title to """ + '"' + proj_name + '"' + """
        run pygame's display's set_caption(my title)  # Set title to """ + '"' + proj_name + '"' + """

        make list (255 255 255) called my background_color  # Set background colour to white
        make pygame's time's Clock called my clock  # Make a clock to record FPS and time since last frame
        set my running to true  # Game is still running

        ########################################

        while my running  # Main Loop
        begin
            ##### EVENTS #####
            store pygame's event's get in eventlist
            for event in eventlist  # Get all events since last frame
            begin
                switch event's type
                case pygame's QUIT  # User pressed 'X' button
                begin
                    set my running to false
                end
                case pygame's KEYDOWN  # User pressed a key down
                begin
                    write "Key Down!"
                end
            end

            ##### DRAWING #####
            run my hwnd's fill (my background_color)  # Fill background with 'my background_color'
            run pygame's display's flip  # Flip sprites drawn onto screen
            run my clock's tick (60)  # Delay so that frames never exceed 60FPS
        end
    end
end