"The Side Project" Planning Notes

I’m cleaning up my Kronos coda doc which currently has a “IGJ 2021” page where I planned what I was going to do for that jam. For reference, this is what ended up being The Side Project.

Figured I don’t need to keep it there anymore, since the project changed quite a bit over the length of the jam, and my notes would probably be more easily just started from scratch if/when I return to the project. But I figured some may be interested in seeing a bit of the pre-production that goes into a game, so I decided to post it here before deleting. Unfortunately Coda doesn’t support me sharing single pages with the public, so I’ve just copy/pasted/redacted the page here.

Some notes: I had the initial idea for wanting to use this new board component a few days before the jam. At some point the theme got announced and I started thinking of ideas to tie in the theme. Fortunately for me “running out of” fit pretty well with a resource management game like I’d been designing - I just added the idea of wanting unique penalties for each resource when it depletes, which ended up being simplified into the forced actions in the final game.

After I started working on the board component, I kinda stopped updating this document. For a real project I’d recommend keeping a “living document”, but for a game jam I tend to do all my pre-pro up front and eventually the ideas just keep building off each other, and I don’t even reference the original document. In that sense its purpose is less of a guide to what I want to make, and more of a piece of scratch paper I used to make sure the core idea could be sufficiently expanded upon. Indeed, its a bit “Stream of consciousness”-y, where I just keep appending new ideas. So the final game looks very different from the game described in this document, although given more time I imagine they would’ve converged slightly. The biggest difference is the feature itself, which became a lot more generalized in the end, and I ended up using a dynamic svg instead of a pixi.js canvas because it integrates with Vue a lot better.

Anyways, here’s the full (but minorly redacted) page:


Modify TMT-X to support cultist simulator-type mechanics.

In layers, call this feature a “board”.

...,
boards: {
  [id]: {
    startNodes: () => Node[],
    style?: () => CSS,
    height: () => number,
    width?: () => number, // default is null = width of container
    nodes: {
      [type]: {
        tooltip: (thisNode: Node) => string,
        display: (thisNode: Node) => string, // text or image URL
        mark?: (thisNode: Node) => string,
        width: (thisNode: Node) => number = 50,
        height: (thisNode: Node) => number = 50,
        draggable: (thisNode: Node) => boolean = false,
        canAccept: (thisNode: Node, otherNode: Node) => boolean = false,
        progress?: (thisNode: Node) => number,
        progressDisplay?: (thisNode: Node) => enum { Outline, Fill },
        progressColor?: (thisNode: Node) => string = theme.accentColor,
        borderRadius?: (thisNode: Node) => number = theme.borderRadius,
        fillColor?: (thisNode: Node) => string = theme.secondaryColor,
        outlineColor?: (thisNode: Node) => string = theme.secondaryColor,

        // default behavior is opening the card if it exists
        onClick: (thisNode: Node) => void,
        card?: (thisNode: Node) => {
          title: (thisNode: Node) => string,
          description: (thisNode: Node) => string,
          options?: (thisNode: Node) => CardOption[],
          width: (thisNode: Node) => number = 100,
          height: (thisNode: Node) => number = 100
        }
      }
    }
  }
},
...
interface Node {
  position: { x, y },
  type: string,
  data?: any
}

interface CardOption {
  text: string,
  selected: (thisNode: Node) => void
}

In player, save data will look like this:

...,
boards: {
  [id]: Node[]
},

Since it’s a new feature, make sure to (also write this in docs):

  • Add it to ComponentStyles

Start with a pixi.js canvas.
Support overlapping elements? Make them expand horizontally on hover, allowing you to drag any of them? How to support that on mobile?
Mobile might need some intermediary state for selecting cards once just counting as hovering. That could help for skill tree in Kronos as well
give players “connections” as they progress that allow nodes to auto send stuff to each other
different requirements to unlock new connections to encourage different “builds”
additionally have different milestones with vastly different required resources all apply some factor multiplicatively
different ways to make “fuel”, with visible ratios, so they might do different things to generate said fuel. Fuel fuels connections? or at least certain actions. Maybe make early connections cheap.
Basically, encourage them to make MC-style tree farm → coal generator setup (or thematic equivalent) as a bit of a tutorial into how to use the game
Have discrete containers instead of just making some bigger, as appropriate. e.g. more health as more (equally sized) health containers
Have eat and think actions to show the “you don’t always know what something will do until you try it”. Eating wood takes away some health
Have short death minigame when you die? or maybe just empty each container
Maybe then make something in the story of the game require you to die, e.g. a curse container that consumes other resources, but dying gets rid of it

Look into tree shaking for components so pixi.js isn’t included if the player never uses it?

Use transitions for cards being destroyed? Animations for things happening? How to handle that when the board isn’t always visible?

Use https://github.com/maitrungduc1410/vue-pixi-wrapper for vue integration, and ofc add a viewport for panning/zooming

For implementing Kronos’ <redacted>, Board will need to include these additions:

  • Give every node a unique ID
  • Every node type describes potential inputs and outputs
  • Nodes store links to their outputs
    • Use computed to get array of input and output Nodes
  • When removed, nodes remove any links they have with other nodes
  • Add “undoable” property to boards
  • when a node has inputs or outputs it appears like a blueprint node

It’s spring break and you have this amazing idea for a video game, so you get to work. Your time capsule starts with 17 hours and a clock at the top says 7 am. There are square action nodes for eating breakfast, making your bed, getting dressed, browsing the internet, hang with friends, and working on the game. There are also an energy container, a hunger container, a mental health container, money container, and a boredom container.

There’s a go to bed action that resets the clock, restores energy based on how late it is (time can go negative to wake up poorly), etc.

Once the game reaches a certain amount of progress (do it in steps so it’s ambiguous when it’ll be complete)

Stories/events are all logged in their respective actions, and any entries from earlier days are greyed out. Explain in the containers that they can influence events happening randomly, plus affect speeds various actions run at.

You can start an action no matter what, but it will have resource costs per tick that will stop the action (but maintain it’s progress) if the resources run out. Over night all action progress is reset, except for game development.

Some actions have a static cost, like buying a game.

Some events can create actions with decisions. For example, browsing the internet may discover a game, which will now be an action to buy and then play (requires lots of time but restores focus a ton, and gives game knowledge resource which improves game development speed)

Mental health improves is affected by the chores actions and boredom, which is affected by diversity of your actions

Low boredom will be called “burning out". If it fully fills up the action gets locked out for a few days

Running out of each resource can trigger a whole mini game or something, causing issues

First section ends with the game growing in scope (this should’ve been an rpg in space! Let me just change that real quick), and spring break ending so now school gets involved. Add going to school action that can only be done twice per day and takes a specific class, and gives resource that increase other skills based on the class. Missing class severely impacts mental health. New classes can be discovered from browsing the internet now.

Also add action to build hype about the game, which increases mental health, focus, and energy, but also fan expectations which cause adverse effects to mental health for not working on the game.

Next story beat is being told you need to start paying rent. You now have a job that takes a lot of time but gives money, but sleeping and eating have a cost now. You’ve expanded the scope of the game again, to add either modding support or multiplayer, asking the player which to do, before deciding to just do both at once.

That’ll probably be the final stage, which ends with the game being complete.

Extra time can be spent writing new events, like new things you find browsing the internet. Buy a bird feeder or adopt a pet, etc.

1 Like

BTW my Kronos notes are a bit more organized, but still a bit stream of conciousness-y (just loosely separated by chapter). I do collect the thoughts and organize them a bit better so my wife can make art for it, though. Still nowhere near something like a game design doc. If you’d like an example of a “real”/professional GDD/interesting piece of history, you should check out the DOOM bible

1 Like