• Implement keyboard inputs controlling player movement

• Implement collision detection for the player interacting with solid objects

• Debug issues related to the action spots

• Investigate rigidbody physics in unity

• Implement physics for objects in unity mockup

• Debug physics in unity mockup

• Debug issues with the camera in unity

• Debug the LOS (line of sight) issue

• Debug the clipping issue

• Read about how RNG is used to create seeds for one-time pads.

• Investigate secure ways of producing RNG

• Investigate CSPRNG specifically

Not sure if it's set up the right way, but all issues should be in the projects tab now.

• Get feedback from the two demos for Kivy and Unity

• Determine whether to use Kivy, Unity, or investigate another development engine

• Investigate blender as an option for creating models in unity

• Investigate how to import a Sketchup model into Unity

• Investigate how to import textures from Sketchup into Unity

• Determine if Sketchup is feasible to use for the project

• Implement UI for entering the seed for procedurally generated map

• Generate new scene using the input seed

• create reusable object type for action spots

• create index to keep list of action spots

• create dialogue windows for interacting with action spots

• create (or import) models for actionable objects

• create log to record player's actions, which includes area index, site index, object index, and action

• place action spots within sites on world map

• Fine-tune OTP generation using entropy shards from the player's action

• Final adjustments should be made after the game is nearing completion, and should address issues that arise when the game is more fully fleshed out.

• Investigate algorithm for XOR-ing ints together

• Create program to XOR entropy shards together.

• Generate seed phrase from combined entropy shards.

• implement a model for the player character

• implement a model building

• implement an area for the building to occupy

• Fine-tune the camera

• Implement a grid for the world map to occupy

• implement an index for each tile of the grid (256)

• program in coordinates for equally-sized tiles to occupy in order to not overlap with other tiles

• Deploy alpha version of the project

• Find and contact potential play testers

• Distribute executable to playtesters

• Gather feedback from playtesters

• Update Unity to the latest version

• This is a large update, and may take some time to install

• debug compatibility issues, and re-import assets if needed

• Investigate CSPRNG

• Create user interface / heads-up display

• Create graphics for menus and other UI elements

• Investigate how graphics are handled in Kivy

• Create basic graphics for the world map

• Create graphics for the player character

• Implement code to generate OTP from entropy seed

• This will require the entropy seeds to be created from the game first.

• Add information to the wiki

• Add in issues to the repository.

• Implement functionality for rehearse mode

• Implement game start code for rehearse mode

• Implement end-of-run script to end the game and generate seed phrase

• Implement auto-playing code to have the game show the route needed for the input seed phrase

Install and set up Kivy, Unity, and Sketchup, along with any other important or relevant programs needed.

• Construct sites (buildings) for each of the map areas

• Import building models from sketchup

• place models on map tiles

• create index for each site per tile

-moved to another issue

• Investigate Kivy as a potential development engine

• go through a tutorial for Kivy

• Test out the graphics generation engine for Kivy

• Implement entropic bit extraction from player actions in kivy demo

• Add landmarks

• Add visual quirks to locations to improve memorability for players

Investigate possible solutions for large file repos for the unity files and assets.
Github only allows files of 100MB or less, and many files used for unity will be much larger.
Currently, the project's files and assets can't be pushed to the github repo, because their file size is too large.

• Investigate Unity as a development engine

• Create simple 3D models in Unity

• Implement code to XOR entropy shards together

• Add visual effects

• Add animations

• Add improvements on existing graphics

• Investigate algorithms that could be used to generate OTP from seed

• Implement functionality for recall mode

• Implement game start code fro recall mode

• Implement end-of-run script to end the game and generate seed phrase

Add visualization for the procedural generation function to show at the next meeting.

• Debug issues relating to hit detection between the player and objects in the game

• Download and install Sketchup

• Investigate and learn how Sketchup works

• Fine tune the procedural generator function to generate a "ground" tile map instead of a "wall" tile map

• Look into object destruction for old tile maps

• Implement code to have the camera follow the player

• Implement code to prevent the camera from clipping into solid objects

• Investigate seed phrase generation

• Find out if there's a publicly available seed phrase word list for other ethereum account creation programs.

• Implement basic player movement for the mockup

• Program in keyboard input

• Program in simple movement based on keyboard input

• Program in hit detection for objects

• Create dev tools needed for Area creation, site creation, or action spot creation

• Create dev tools for in-engine debugging

• Make separate Dev branch in repo

Implement procedural generation function for randomizing world layout

Update the readme with other information from the project roadmap document.

• Rework SeedQuest based on alpha tester feedback

• fix any bugs reported by playtesters

Investigate if python can be run in Unity

• Implement camera movement for the demo

• Implement screen scrolling as an alternative option if the game is 2D