Dan Dan Dan Dan Developing: January 2012

If you haven't read them yet check out the prolog and Part 1

I think it's been ~~a sufficient~~ ahem an excessive time since I've posted last...

During my Christmas vacation I managed to bash out the majority of the features I've wanted to support in my arcade frontend. I had a couple false starts before then. Frustrated, I went with the tried and true "just make the damn thing work" development methodology (aka hacking.)

Well, I didn't build it quite as haphazardly as that. The idea is to translate the project requirements into some minimal functionality that must be created for the project to be considered "working." For a small project like this it only takes about 10-30 minutes of effort. For larger projects it takes longer. Most of the time you'll find some features that are independent of each-other. To get the most bang for your buck your best bet is to start working on some feature that a lot of requirements depend on.

Huh? What?

I'll give an example. This is taken from the requirements list in Part 1 under each requirement is a number of functions that need to be implemented

Hide the regular Windows front-end.

Using pygame run in full screen mode
Leave full screen mode before starting a game, re-enter once the game exits

Allow the user to shut down the computer without exiting to Windows

Method for responding to user input
Method for confirming user action
Method for invoking windows shutdown

Allow an administrator to exit to windows

Method for responding to user input (key-mapped arcade controls)
Clean program shutdown

Allow rapid selection and launching of games using arcade controls (not keyboard and mouse)

Method for responding to user input (key-mapped arcade controls)

Support launching any game/program, not just MAME

Scan (something) to create a list of programs that are launchable
When prompted launch a program using information from the list

Display a preview of the selected game

Scan (something) to create a list of images associated with games
Method to load images as needed

Display a list of games that can be played

Scan (something) to create the list of playable games
Method for distinguishing selected game from others
Method for displaying available games

Display a marquee for the game... somewhere near the screenshot

Scan (something) to create a list of images associated with games
Method to load images as needed

Everything must have an animation

This means needing an endless update/draw loop for objects
Need a state machine to indicate whether some transition is occurring and what kind

Alter control-key mappings to support games without configurable controls

Method to invoke IPAC-2 programmer with some known configuration
Scan (something) to create a list of control configs associated with games

There are a couple things that pop out:

Method to load images as needed
Scan (something) to create a list of games and things associated with them

Of those scanning comes up the most and, more importantly, relates most directly to the purpose of the program which is starting games.

For my first crack at this I've decided that (something) will be a directory tree containing files called (game)-launcher.cfg which describe playable games. For the sake of organization, since there will likely be well over 100 files, the config files can be in any directory in the tree.

What do I want to put in the file:

The program to start
Extra information to pass to the program
Controller settings for the game
Where to find game's marquee, screenshot and other image files

Now, how do I format the file? I don't want to spend an undue amount of time writing a parser so I could use one of Python's built in parsers. But that still means I need code to convert that to an easily usable datastructure (let's just ignore JSON for now since it slipped my mind at the time) So... how about just making it a Python module. That reduces parsing to one line of code. The file itself simply contains a Python dict with a standardized name and standardized keys.

First the code to scan for config files:

def FindAllLaunchables( startDir ):
    outList = []
    dirList = os.listdir( startDir )
    for dir in dirList:
        checkDir = os.path.join( startDir, dir )
        try:
            if os.path.isdir( checkDir ):
                outList.extend( FindAllLaunchables( checkDir ) )
            elif os.path.isfile( checkDir ) and dir.lower().endswith("-launcher.cfg"):
                outList.append( checkDir )
        except WindowsError:
            pass
    
    return outList

That's it. The function recursively scans all directories under startDir and, if it finds a configuration file adds its location to an output list which the function returns.

This bit of code handles reading the configuration file.

def CreateLaunchers( configFiles ):
    launchers = []
    for launcherConfig in configFiles:
        moduleName = os.path.splitext( launcherConfig )[0].replace( os.path.sep, "_" ).replace( ".", "" ).replace( " ", "_" )
        
        moduleFile = open( launcherConfig )
        try:
            modulePath = os.path.split( launcherConfig )
            module = imp.load_module( moduleName, moduleFile, launcherConfig, ["cfg","rt",imp.PY_SOURCE] )
            launchers.append( config.Launcher( module.LauncherConfig ) )
        finally:
            moduleFile.close()
            del moduleFile
    return launchers

The meat here is the call to imp.load_module. The imp module exposes some of the guts of Python's import statement and is useful for importing arbitrary files as modules. Notice the config.Launcher object instantiation. The Launcher class will be used to carry out the work of starting up a game based on its configuration along with some other stuff.

And that's everything! To finish this initial step I stubbed in some code to start up fullscreen mode and to pick up keyboard input. That code is below and makes up the skeleton which the rest of the program will be built around.

pygame.init()

# load configuration
configFiles = FindAllLaunchables( search, skip )
launchers = CreateLaunchers( configFiles )

# startup sequence
screen = SetScreenMode()
pygame.key.set_repeat( 1000, 200 )
pygame.mixer.init()
things = []

# the main loop!
frameStart = time.clock()
time.sleep( 0.01 ) # XXX: don't want a frame time of 0 when starting
while True:
    frameTime = time.clock() - frameStart
    frameStart = time.clock()
        
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (event.type == KEYDOWN and event.key == pygame.K_F12):
            sys.exit()
        
    for thing in things:
        thing.Update( frameTime )
        thing.Draw( screen )
    pygame.display.flip()
    screen.fill( (0,0,0) )

Whelp, that's all for part 2. I'll have more for you next time! (and since the project is working, next time should be sooner, not later) SetScreenMode isn't all that exciting so I've spared you its details. Notice that with this code we now have the following done.

Using pygame run in full screen mode
An endless loop to update/draw objects
Method for responding to user input (stub)
Scan (something) to create a list of games and things associated with them

Not bad for one blog-entry worth of work eh?

Dan Dan Dan Dan Developing

Thursday, January 12, 2012

PONIES! And random shite

Tuesday, January 10, 2012

Making of an Arcade Frontend - Part 2

Followers

Blog Archive

About Me