It’s been a while since I did any form of game development, & in my attempts at game development last year I didn’t get very far. One of my main issues was that I didn’t have much of a plan or process for my projects. Really it was just do whatever I felt needed to be done, which just left me feeling aimless.
So I’m endeavouring to come up with something I can reliably follow for most of my projects. First, I’m going to look at existing frameworks, in this case a process from a book Game Design Workshop: Designing, Prototyping, & Playtesting Games, & the framework I followed back in Polytech to develop a sex ed game up to the “beta stage”.
Game Design Workshop
I tried to do what many designers do & create the game design document way too early when I was still just brainstorming everything. Thing is, in a professional setting, designing the game right at the start of production often leads to hardship, simply because it becomes increasingly difficult to change things the further down the production line you are.
The author’s way of getting around this is to never begin production, or even the software prototype, without a solid understanding of the game.
- Come up with as many concepts as possible
- Narrow down to the top few
- Draft a short, one-page outline describing the ideas
- Physical Prototyping
- Create a playable prototype using pen, paper, & other materials
- Playtest using the iterative cycle below
- Once perfected, write a 3-6 page gameplay treatment describing how the game functions
- Presentation (optional)
- Often needed to secure funds to hire a prototyping team. Going through the process of making a presentation can also be a good way of thinking through your game & introducing it to team members. Should include demo art & a solid gameplay treatment.
- If you do not secure funding you can return to step 1 or modify the game to fit their needs (I would also add the option of finding other ways to find funding).
- Software Prototype
- Create a rough program that models the core gameplay. Try to do this without graphics, or use cheap temp graphics.
- Playtest the software prototype using the iterative cycle below.
- Once perfected, move onto documentation.
- Design Document
- Use the knowledge & notes gained from prototyping to write the first draft of a game design document outlining every aspect of the game & how it functions.
- Work with all team members to make sure each aspect of the design is achievable & correctly described.
- Acquire your full staff & begin creation of the real game (art, programming, etc). Do the iterative cycle below for each aspect of the game. The problems encountered at this stage should get smaller as you go since all major problems should have been encountered during prototyping.
- Playtest with a focus on usability & accessibility. Gameplay should be solid at this point but problems can still arise.
For each of these steps it emphasizes an iterative approach centred on player testing. Something like this:
- Generate Ideas
- Formalize Ideas (write down or prototype)
- Evaluate Results
- If results are negative & there seems to be fundamental flaws, return to step 1
- If results lead to improvement, modify then return to step 3
- Else, next major step
The Agile Development Framework
The “Agile Development Framework” that I followed in Polytech can be thought of as a spiral consisting of three main loops, each focused on a different part of the project. It follows a similar iterative cycle to the process above:
- Understanding – communicating with the client to figure out what they want
- Functional Delivery – building a MVP (minimal viable product)
- Robust Delivery – building the final product
In all three loops are the following stages:
- Functional Requirements
- Interaction Design
- Design Specifications
- Implementation & Deployment
- Return to Evaluate for the next cycle
Now to breakdown what each stage of the three cycles contain:
- Evaluation – Management documents, establish group & relationship with client
- Functional Requirements – Interview client, initial project plan
- Interaction Design – Ethical design, risk management
- Design Specification – System Metaphor
- Implementation – Conceptual Prototype
- Evaluation – Proposal to client
- Functional Delivery
- Evaluation – Project estimates, client feedback, knowledge base
- Functional Requirements – List of requirements, user stories => requirements
- Interaction Design – Interface design, user/environment analysis, design theme, ERD (entity relationship diagram), interactivity testing
- Task analysis => dialogue diagrams => wireframes => interface designs
- Design Specification – Style guide, system architecture, background development
- Implementation – Stable development platform then MVP
- Evaluation – Analysis of MVP, mid-point reflection
- Robust Delivery
- Evaluation – Direction for iteration 3, scoping for final delivery
- Functional Requirements – Revisit requirements list
- Interaction Design – Update designs & concepts, content production
- Design Specification – Style guide, system specifications, implementation & deployment plan
- Implementation – Robust delivery
- Evaluation – Project evaluation & completion
In a team setting, though this can prove useful even if you’re working alone, you also have daily (well, every time you meet up) SCRUM meetings. These are only supposed to be about 10 minutes & consist of:
- What you did yesterday?
- What you will do today?
- What barriers, if any, are there to your progress?
Lastly, it’s important to keep the client in the loop as much as possible, typically in the form of weekly meetings.
Now with all of that laid out, I’ll be taking aspects from each of these to form a framework for my own projects. I haven’t gone through that yet, & this post is already quite long so I’ll have my results in part 2.