Hazel Wong

Software Engineer, Entrepreneur, Game Developer

Summary

About Me

Hi! My name is Hazel and I am a Software Engineer currently working at Amazon Robotics. I hold a Master’s degree in Computational Science and Engineering from Harvard University and a Bachelor’s degree in Computer Science from the University of Michigan.

Throughout my professional career, I have gained experience in software engineering, project coordination, frontend web development, game development, program management, and project management.

Furthermore, I co-founded HardBoiled Studios, a video game development team, and successfully secured a funded publishing deal with Hitcents. Our game, YOLKED, was released on Steam in April 2023.

As a stationery enthusiast, I ran a small enamel pin shop called Tiny Pocket Studio on Etsy, where I sold original enamel pin designs and occasionally marketed them on Instagram and Reddit.

In addition to my software engineering skills, I have interests in music composition, singing, and graphic design. I have composed various music pieces and designed graphics for YOLKED and other projects at work.

  • Emailhazelltwong@gmail.com

  • EducationHarvard University

  • University of Michigan

  • LanguageEnglish

  • Cantonese

  • Mandarin

  • Japanese (N3)

Resume

Experience

  • Software Development Engineer at Amazon
    September 2022 - Present

    • Delivered high-quality software components and improvements to team's software, including new code, refactoring, and deprecation work, using Java and TypeScript
    • Collaborated with team members on the full software development lifecycle, including scoping, design, code, testing, documentation, deployment, and maintenance, while ensuring adherence to Amazon's coding standards
    • Utilized AWS technologies such as API Gateway, DynamoDB, and CloudWatch Dashboards to design, implement, and maintain highly scalable, reliable, and secure systems
    • Worked independently to develop and execute sprint plans every week, while also participating in weekly checkpoints in code reviews and daily stand-ups, ensuring timely completion of assigned tasks
    • Solicited and incorporated feedback from peers and stakeholders to improve code quality, usability, and performance, and conducted code reviews to ensure alignment with architectural and design principles
    Now
  • Co-Founder and Game Developer at HardBoiled Studios
    March 2020 - Present

    • Co-founded and led a game development studio, developing the video game "YOLKED" and releasing it on Early Access on Steam in Oct 2021, with the full version released in Apr 2023
    • Successfully negotiated contracts with external vendors, protecting the studio's intellectual property, and securing a funded publishing deal with Hitcents, an indie game publisher
    • Conceptualized and implemented innovative game mechanics and levels, conducting user testing and gathering feedback to improve the game's graphics and user experience
    • Effectively managed a team of 5-8 people, overseeing project development, conducting stakeholder meetings, and monitoring progress and performance, resulting in receiving the Commercialization/Entrepreneurship Award
  • Project Coordinator at ABC Pathways Group
    January 2021 - August 2021

    • Successfully launched two online courses for ABC Pathways School, organizing and executing all aspects of the project within budget and on time
    • Utilized video production skills to create captivating, informative content for a Phonics workshop and an aviation course for students in Grades 2-5
    • Designed and animated engaging characters using Adobe Illustrator, Animate and Character Animator to enhance the visual appeal of the courses
    2021
  • Software Engineering Intern at Animoca Brands
    June 2020 - August 2020

    • Contributed to the development of F1DeltaTime and other video games by implementing and testing frontend features using technologies such as HTML, CSS, and JavaScript
    • Transformed XD files into high-quality webpages, ensuring the mobile and desktop compatibility of the games' websites
    • Collaborated with the software development team and integrated a key part of the API flow between the game client and website, enhancing the user experience of the game
    2020
  • Undergraduate Student Researcher at the University of Michigan – Explore CS Research Program
    December 2019 - June 2020

    • Collaborated with Professor Sindhu Kutty at the University of Michigan to conduct research on machine learning prediction biases of COMPAS, a recidivism prediction instrument
    • Employed advanced statistical techniques to evaluate different definitions of fairness and proposed innovative solutions to achieve racial fairness in predictive models while minimizing the impact on accuracy
    • Presented our groundbreaking findings at the prestigious Grace Hopper Conference
    2019
  • Software Engineering Intern at Datatech Global HK
    June 2019 - August 2019

    • Integrated animations on an interactive website to enhance user experience and promote Friso Gold, resulting in increased engagement and customer satisfaction
    • Developed a mini-game with team members using HTML5, providing an interactive experience for users
    • Designed and built a functional content management system with Javascript, React and MySQL for a mobile application with functions such as adding, deleting, editing, and keyword searching
    • Devised a new enrollment system flow for an English learning centre, including the specifications of the backend and frontend systems in a functional requirement document
  • Undergraduate Student Researcher at the University of Michigan – The Frank Research Group
    October 2018 - December 2019

    • Utilized quantum mechanical computational methods to predict substrate ligand binding in biological systems and calculate energy differences of different molecular structures
    • Automated quantum mechanical computations with shell scripts to read in RNA molecules, break molecules into fragments and compute the chemical properties of each fragment
    2018
Projects

Portfolio

Devblog

Project Randomizer:

A Look into Procedural Generation in Video Games


In 2020, I undertook an Undergraduate Research class project that delved into the reasons behind the widespread use of procedural generation in video games. Through my research, I aimed to shed light on the various ways that procedural generation is integrated into video games.


It has been estimated that the video game industry will be a $159.3 billion dollar industry in 2020, with estimations that it will exceed $200 billion by 2023 (Newzoo 2020) and $300 billion by 2025 (Forbes 2020). In addition, the world currently has 2.7 billion gamers, which is more than a third of the world’s population (Newzoo 2020). As the industry grows exponentially and is changing rapidly, it is important that we continue finding ways to improve and polish video games.


Video game developers may often feel stuck when creating levels during development as there may be limited time, cost and memory. Procedural generation is a way for data in video games, such as levels, characters and the environment, to be created algorithmically. This method could have multiple advantages, including creating dynamic content, saving memory usage, saving development time and saving money (Packt 2016). This project attempts to explore that concept by creating an algorithm that will procedurally generate levels for a novel puzzle game, allowing more dynamic content to be created for people to enjoy while saving time, cost and memory usage.

  • This week I looked at some random dungeon generation videos and tried implementing one of the algorithms on Unity. This algorithm is based on the room generation algorithm from Binding of Isaac and I picked it as I feel like it could be used for roguelike or puzzle games. I closely followed the video series this week on Unity, which included spawning rooms of the same dimension randomly. I also started brainstorming some mechanics that could be added into the game, which I will try to do next week.



    The Algorithm

    Criteria:

    In this algorithm, there are three criteria:

    • There must be a clear path between start and exit room
    • The path must be closed (no openings leading to nowhere)
    • There must be a start and exit room

    Making a clear path:

    Each room is made of 10x10 pixels, with different room openings. For each opening, we put a “spawn point” 10 pixels away from the center, which will be the center point of the adjacent room.



    I made a spawn function that uses randomization to create adjacent rooms. Rooms spawn depending on which door is open in the adjacent room, which is indicated by the spawn points. The algorithm puts all the different types of rooms into lists. For example, all rooms in the bottomRooms list would include rooms that have a top door. Then using Random.Range, the algorithm randomly selects a room to spawn adjacent to a room. Using a rigid body and a 2D collider, we also prevent rooms from spawning on top of each other.

    Picking the Start and Last Room:

    The start room is the entry room, the only room that has 4 doors. The rooms are spawned in order using Invoke, which calls the spawning function every 0.1f. One by one, the algorithm adds the room onto the list and the last room added would be selected as the last room.



    Brainstorming New Mechanics

    I think by picking an interesting hero, we can introduce some interesting mechanics that the puzzles can be based around. A possible hero I thought about this week is an ice cube. With an ice cube we can introduce these mechanics:

    • The ice cube has to navigate its way across a level
    • The ice cube melts a little each move
    • The levels are timed – it has to get to the end of the level before it melts
    • The end goal could be a fridge, so that the ice cube can get back to its original shape








    Next Week's Objectives

    • Make tweaks to the algorithm
    • Begin implementing some of the mechanics above
    • Contact few more stakeholders for interviews


    Sources

    https://www.youtube.com/watch?v=qAf9axsyijY&ab_channel=Blackthornprod


  • This week, I had a one-hour interview with Adam Saltsman, a video game developer, from FINJI, where I got to learn a bit more about procedural generation. I also did some research on Brogue, a procedurally generated roguelike game, that he had recommended to look into during the interview. Finally, I began looking at the types of puzzle games there are to begin deciding what kind of puzzle game I could make for my final deliverable.


    Interview with Adam Saltsman

    The interview was very informative and really helped me understand what I was getting into. Here are some of the key things I took away from the interview:

    1. A lot of the times, developers use proc gen not to save time or costs, but to have access to something you cannot get access to through hand-authored levels. These random generated levels could give developers more complexity or an unpredictable element.
    2. In addition to creating a procedural generation algorithm, you will also need to write an algorithm to test and check your generated level. This could be to check whether it is even possible to solve the level or how many steps it is required to solve the level.
    3. For puzzle games, there are generally two forms of proc gen
      • The level design is procedurally generated
      • The ingredients (i.e. enemies, goals) are procedurally generated
    4. There’s a big gap between hand-authored and randomly generated levels. The cost of using a proc gen algorithm when generating levels is that it is more difficult to incorporate style/design (e.g. if you want the level obstacles to make a certain shsape)

    He also gave me a few games that use proc gen that he thinks I could look into, one of which was Brogue, a roguelike game by Brian Walker, where players must try to descend down to the 26th level in a dungeon to retrieve an amulet before heading back up to the surface. I spent a few hours this week trying to understand the procedurally generated algorithm used in Brogue. A step-by-step description of the algorithm can be found from an interview with the developer of the game.



    The Procedurally Generated Algorithm in Brogue



    Placing Rooms:

    First, the algorithm places rooms in an empty grid at random. A single room is placed randomly on the grid, then the next room slides around the grid until it touches the edge of an existing room and has no overlaps with other rooms. Once the new room has been placed, a door is punched out. The algorithm repeats until there is no more space for new rooms. The rooms are randomly drawn as well. They could be a donut shape, a circle or a rectangle etc.

    Once the rooms are placed, the algorithm runs five rounds of smoothing on the rooms to ensure that the rooms have space in them and there aren’t any walls that are randomly connected. Every floor tile that has fewer than four adjacent floor tiles becomes a wall, and every wall tile with 6+ adjacent floor tiles becomes a floor tile. After the five rounds of smoothing, the biggest room is selected as the first room.

    Finally, the algorithm checks for wall tiles that have floor tiles on either sides and are a certain distance apart. For these tiles, the algorithm would punch a door to connect the two rooms.



    Placing Lakes:

    Randomly shaped lakes are generated and placed around the map, on top of the existing rooms. Using the same technique of sliding the lake across the map, the algorithm tries to find a place for the lake such that it does not block any paths. If a lake cannot be placed anywhere on the map, the algorithm tries again with a smaller lake.



    Placing Local Features:

    Local features such as grass, crystals, mud pits, traps etc.are also placed at random. A random location is selected on the map and a local feature is spawned. The feature then randomly expands outwards based on probability. The further a tile is from the initial position, the lower the probability of the feature spawning on that tile.

    Placing Machines:

    Brian Walker describes machines as “clusters of terrain features that relate to one another”. There are 71 hand-authored machines that determines where a machine should spawn in the level. This is the most complex part of the algorithm. I did not do too much research into this part of the algorithm, as I don’t believe my puzzle game will get to this complexity.

    Placing Items:

    The algorithm for placing items is like a raffle. Each tile is assigned a particular number depending on where they are on the map. Every tile starts with a ticket. For each door that the player has to go through to get to the tile, the tile gets 3000 more tickets. For areas that the developers do not want items, such as hallways, the tile would discard all its tickets. When placing items, some tickets on the tiles around a specific tile with an item would be removed to discourage clumps of items.

    Placing Monster Hordes:

    Monster Hordes are randomly and uniformly placed in lowest floor of a level.

    Takeaways:

    • Similar to what Adam Saltsman had said to me, Brian also agrees that procedurally generated levels cannot come close to hand-crafted levels designed by experts
    • The procedural generation algorithm used in Brogue uses both forms of proc gen that Adam mentioned. Both the levels and the ingredients within the level are procedurally generated.


    Types of Puzzle Games

    Finally, I did some research on the types of puzzle games there are currently out in the market. A puzzle game is a game that requires solving a puzzle using problem-solving skills such as logic and pattern recognition. According to the Puzzle video game Wikipedia page, there are 6 different types of puzzle games.

    1. Logical (e.g. Portal, Cut the Rope)
    2. Trial-and-Error / Exploration (e.g. Monument Valley)
    3. Hidden Object Game (e.g. Mystery Trackers)
    4. Reveal the picture game
    5. Tile-matching (e.g. Candy Crush Saga
    6. Traditional puzzle (e.g. Solitaire)

    The proc gen games I've looked at so far seem to fall under the logical and trial-and-error/exploration categories. So far, I've been most interested in creating simple games like Adrena Line and Streamline from my previous blog post, which I believe would fall under the logical category of puzzle games.



    Plans for Next Week

    Next week, I would like to begin coming up with mechanics for my puzzle game.



    Sources

    https://www.rockpapershotgun.com/2015/07/28/how-do-roguelikes-generate-levels/#more-303483

    https://lutris.net/games/brogue/

    https://en.wikipedia.org/wiki/Puzzle_video_game

  • This week, I looked into the procedural generation algorithm for levels in Spelunky and four other puzzle games that also use procedural generation to create levels.


    Spelunky

    Spelunky is a platformer, action-adventure game, where the goal of the game is to collect as much treasure as possible. The game uses a procedural generation to create each cave level.

    Part 1: Generating a Solution Path

    The algorithm to generate cave levels is split into two parts. The first is to generate the solution path. Each cave level is split into 16 rooms and each room is categorized into one of four types.

    • A type 0 room is a side room that is not on the solution path
    • A type 1 room is guaranteed to have left and right exits
    • A type 2 room is guaranteed to have left, right, bottom exits (If there is another 2 room above, then it also has a top exit)
    • A type 3 room is guaranteed to have left, right and top exits

    The algorithm starts by placing a type 1 room on the top row. Then a random number generator picks a number from 1-5 whether the solution goes left, right or bottom. A 1 or 2 means the solution moves left, 3 or 4 means right, and 5 means bottom. If a 5 is chosen, then the room type of the starting room changes to a type 2. In the next room, the algorithm determines whether the previous room was a type 2. If it is then the current room is either a type 2 or 3, as the current room has to have a top exit. The algorithm then starts over until the solution path reaches the bottom row. If the solution path wants to drop down at the bottom row, then the final room is simply placed instead. Finally, type 0 rooms are placed on the cells that are not part of the solution path.




    Part 2: Creating Individual Rooms

    After a solution path has been found, the individual rooms are created using room templates, which are manually created. Each type of room has a specific room template. A template looks like a 2D 10x8 array with a number or letter in each cell. Each number or letter represents different things. The algorithm places obstacles, blocks and empty spaces based on the label of each cell.



    Types of Tiles:

    • Static Tiles
      • 0 means an empty space
      • 1 means that there’s a 100% chance that there is a wall
      • L means ladder
      • P is top of ladder platform

    • Probabilistic Tiles
      • 4 means there is a 25% chance of a pushblock at the top of the ladder
      • 7 means there’s a 33% chance of a spike tile
      • 2 means 50/50 empty or solid block

    • Obstacle Blocks
      • 5x3 tile that has a structure that the player would have to maneuver around



    Puzzle Game Inspiration

    These are four other games that use procedural generation to generate levels. This is to help brainstorm ideas for possible puzzle games and also look into what type of puzzle games are currently using procedural generation algorithms.

    Adrena Line by Daniel Linssen


    A simple puzzle game where you control a cube to get to the end goal within a time limit. There is an endless number of procedurally generated levels. Although I was unable to find specific details on the procedural generation algorithm, the developer had posted a gif that visualizes the algorithm step-by-step.

    Steps include:

    1. Placing a goal somewhere in the middle of the map
    2. Adding random empty spaces around the goal
    3. Adding large, medium, small empty rectangular areas
    4. Removing dead ends
    5. Finding step distance of each cell from the goal
    6. Placing the starting position

    Streamline by Francoisvn


    Streamline is a similar puzzle game, but with a fixed map size. It has a similar mechanic to Adrena Line but with a twist: the trail created by the player also acts as a wall. There is no time limit. The levels are also procedurally generated.

    Satie Cells by Contrebasse


    Satie Cells is a game where try to obtain the highest score possible by deleting cells from a grid of white and black cells. Your score corresponds to the percentage of black cells. A selection of cells can only be deleted if it follows a set of rules

    1. It is a straight line
    2. It has at least 1 black cell
    3. It doesn’t have more black cells than white cells
    4. The colors within the selection are symmetrical

    Fruit Dating by Tomas Rychnovsky


    In Fruit Dating, your goal is to match pairs of fruit of the same color. Swipe to move objects. All movable objects move in the same direction at once. A brief overview of the procedural generation algorithm can be found here. Similar to a lot of the procedural generation algorithms for puzzle games, first the walls are created, then the obstacles.



    Thoughts on This Week

    As there are a variety of different puzzle games, it is understandable that there isn't one specific procedural generation algorithm that can be used to create levels for each puzzle game. However, there seems to be a pattern emerging. It seems to be the case that levels are created using a broad-to-narrow approach. For example, starting with the outer walls, then adding start/goal positions for mazes, or starting finding the solution path first, before creating individual rooms for Spelunky.



    Sources

    http://warpdoor.com/2020/04/20/adrena-line/

    https://www.youtube.com/watch?v=R8PLv8rAyIY&ab_channel=SahilPlaysGames

    https://twitter.com/managore/status/1253195642878349312

    http://tinysubversions.com/spelunkyGen/

    https://francoisvn.itch.io/streamline

    https://contrebasse.itch.io/satie-cells

    https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/procedural-generation-of-puzzle-game-levels-r3862/

  • This week, I contacted five stakeholders to ask whether it would be possible to conduct interviews to learn more about procedural generation in video games. In addition, I started experimenting with my research idea by simplifying my research problem. I looked at procedural generating levels for the simplest puzzle game I could think of, mazes. I followed a tutorial that procedurally generated maze levels algorithmically and used the generated data to create meshes for the level. Through this tutorial, I was able to learn how to implement a simple procedural generation algorithm and represent it visually on Unity.

    Tutorial: https://www.raywenderlich.com/82-procedural-generation-of-mazes-with-unity

    Final Game: http://www-personal.umich.edu/~hazwong/Maze_Tutorial/



    The Tutorial

    The tutorial starts off by providing a Unity starter package that includes:

    • two C# scripts, a simple player movement script and a trigger handler script
    • a scene with a player, a spotlight, a camera and UI for score and time
    • a graphics folder with materials for the maze wall, ceiling and floor

    The tutorial walked me through how to write a GameController script that handles the overall game, a MazeConstructor script that manages the generation of mazes, a MazeDataGenerator script that initializes the maze, and a MazeMeshGenerator script that creates meshes for the maze from the maze data.

    Essentially, the flow of the program is as follows: the developer specifies dimensions for the maze in MazeDataGenerator. Then using a maze generation algorithm, MazeDataGenerator generates a random maze in the form of a 2D array. The MazeConstructor then iterates through the 2D array, adding start and goal positions algorithmically. Then MazeMeshGenerator is called in MazeConstructor to add meshes to the maze based on the 2D array. Finally, the GameController creates the maze on Unity.



    The Maze Generation Algorithm

    Maze Paths:

    The maze generation algorithm is written in MazeDataGenerator and is given the size of the 2D array as inputs. It is a simple algorithm that has two nested for loops to iterate through the cells in the array. A “0” or “1” is assigned to a cell to represent whether a cell is open or blocked, respectively.

    The algorithm starts at the first cell of the array at (0,0). First, the algorithm checks whether a cell is on the edge of the maze. If the cell is on the edge, then it is assigned a 1. Then the algorithm iterates through every other cell, by checking whether the cell is even or odd. If the cell is odd, then it is assigned a 0. If the cell is even, the algorithm randomly generates a value. If the value is above a certain threshold, then the cell is assigned a 0, otherwise it’s assigned a 1. Rather than just simply adding a wall to every other cell, the generation of a random value is to encourage open spaces in the maze rather than having it filled with tight corridors. Finally, once a cell is assigned a 1, the algorithm randomly selects an adjacent cell and assigns a 1 to that cell as well.

    Adding Start and Goal Positions:

    Once the maze has been generated, the algorithm goes through the 2D array again to add start and goal positions. To add a start position, the algorithm starts at (0,0) and iterates through each cell in the array until it finds an empty cell. Similarly, to add a finish position, the algorithm starts at the max value and iterates through each cell in the array backwards until it finds an empty cell.

    Finishing Touches:

    The final steps of the tutorial involves creating meshes for wall, ceiling, floor, the start position and the goal position based on the 2D array, incrementing the score once a goal has been found and starting a new maze once the timer runs out. Once I completed the tutorial, I built the game as a WebGL and uploaded it online.



    How to Play

    Find the game here!

    Objective:

    Find the goal in the maze before the timer runs out! Once you’ve found the goal, travel back to the starting position to start a new level. If the timer runs out, the game is reset and a new maze is generated.

    Controls:

    • Mouse: control camera
    • Arrow keys: control player movement
    • Spacebar: debug mode to show map of maze


    Final Thoughts

    This tutorial was able to show me how to create simple mazes using a basic procedural generation algorithm and how to incorporate them into a video game by representing them visually on Unity. This tutorial had boosted my confidence in my research idea as it gave me an idea of how to possibly structure my code for my own puzzle game. It also made me less overwhelmed by my research idea as I now realize that procedural generation algorithms could be relatively simple depending on the scope of the game.



    Next Steps

    As this tutorial was rather simple, my next steps would be to look at more complex procedural generation algorithms and begin brainstorming ideas for a novel puzzle game.



    Sources

    https://www.raywenderlich.com/82-procedural-generation-of-mazes-with-unity

    https://freesvg.org/the-maze

  • This week, I compiled stakeholders that I believe would benefit most from my research.



    Stakeholder Archetypes/Audience Information

    Game developers, especially those who are developing puzzle games, would benefit the most from my results. Generally, game developers work in game development studios, where they code the base engine of video games, generate levels for video games and translate ideas discussed in meetings into code. Oftentimes, they may be faced with optimization, time, cost or memory issues which could be fixed with procedurally generating levels. Being able to efficiently generate solvable levels could be important to game developers as it could save development time. money and memory usage. Resources that developers tend to have at their disposal are a decently sized team of developers and game development technology.



    Sources

    https://www.awesometuts.com/how-to-get-a-job-in-the-game-development-industry

  • This week, I compiled market research by identifying relevant market sectors, companies and products.



    Relevant Market Sectors

    1. Video game

    • Market size (measured by revenue) is $60.4 billion in 2020 (source)

    2. Professional, scientific, & technical services

    • Market size (measured by revenue) is $2.0 trillion in 2020 (source)

    3. Arts, entertainment & recreation

    • Market size (measured by revenue) is $243.7 billion in 2020 (source)


    Relevant Companies

    1. Sony Computer Entertainment

    • Market Sector: Video game
    • Revenue: 8.259 trillion JPY = 77.9 billion USD (2020)
    • Primary Business: Video game and digital entertainment

    2. Nintendo

    • Market Sector: Video game
    • Revenue: 1.309 trillion JPY = 12.3 billion USD (2020)
    • Primary Business: Video game and consumer electronics

    3. IBM

    • Market Sector: Professional, scientific, & technical services
    • Revenue: 77.14 billion revenue (2019)
    • Primary Business: Software, global business, hardware, information technology services

    4. Accenture PLC

    • Market Sector: Professional, scientific, & technical services
    • Revenue: 43.2 billion revenue (2019)
    • Primary Business: Professional services

    5. The Walt Disney Company

    • Market Sector: Arts, entertainment & recreation
    • Revenue: 69.57 billion (2019)
    • Primary Business: Media and entertainment, including movies, tv programs, theme parks, resorts and games


    Relevant Products

    Products that are using procedural generation

    1. Stardew Valley

    2. Don't Starve

    3. Binding of Isaac


    Products that could use procedural generation

    4. Angry Birds

    5. Snakebird



    Sources

    https://www.hotjar.com/blog/market-research/

  • This week, I found 20 academic papers that I thought were relevant to Project Randomizer. Within the set of relevant papers, I picked three that I believed would help me most with my research and summarized them.



    Relevant Articles

    1. The Gold Standard: Automatically Generating Puzzle Game Levels

    This paper introduces an automatic level generation system called Goldspinner for a non-scrolling puzzle platform game, KGoldrunner. Goldspinner is able to create interesting solvable levels that are both statically good and dynamically good by running (1) a genetic algorithm to generate and evaluate candidate levels and (2) simulations of these good candidate levels to test its dynamic aspects.

    To create a new level, the genetic algorithm starts with an initial base level, then overlays features, such as walls, on it. Once a level has been created, an evaluation function is used to determine whether a hero can travel through the level. A level is separated into different nodes. Each time the hero can travel between a pair of nodes, an edge is added to a graph called a “group graph”, which shows the possible movements of the hero in the level. If a level passes the static tests, Goldspinner then performs simulations to determine whether a level is actually solvable. A plan to complete the level is generated and an AI attempts to follow the plan. If the AI player is able to reach the exit, then the level is considered solvable and also encompasses desirable static and dynamic properties.

    Although Goldspinner is applied solely to KGoldrunner, it is possible that the technique can be used for other puzzle games.

    2. Procedural Generation of Sokoban Levels

    In this paper, an algorithm is used to procedurally generate levels for the Japanese puzzle game, Sokoban. Sokoban is a simple puzzle game, where the player has to push boxes onto specific squares specified in the level. However, the player is restricted by the placement of walls, different boxes, as well as its ability to only push one box at a time. The method used to procedurally generate levels for Sokoban is by working backwards. The algorithm itself consists of three steps: (1) Build an empty room; (2) Place goals in the room; (3) Find the state farthest from the goal state.

    First, an empty room is built by randomly selecting the height and width of the level, then walls and floors are added, while making sure that none of the rules are violated. Next, the goal is placed using brute force. Then, the algorithm finds the farthest state from the goal state and returns the set of levels that are furthest from the goal state. Finally, it filters these levels to find the best candidate levels that are not too easy or too similar to previous levels.

    3. Generating Sokoban Puzzle Game Levels with Monte Carlo Tree Search

    This is another paper that attempts to procedurally generate levels for the Japanese puzzle game, Sokoban. The approach it uses is a Monte Carlo Tree Search (MCTS) based approach that guarantees solvability, efficiency and speed by simulating gameplay. The algorithm is not require any human designed input and is able to generate levels of various sizes.

    MCTS is a search algorithm that consists of four distinct phases: selection, expansion, rollout and backpropagation. The reason why MCTS is used is because of its anytime property and its ability to succeed in problem that have large branching factors. The approach used in the article separates the puzzle program into two: puzzle initialization (where to place the starting locations of boxes, empty tiles and obstacle tiles) and puzzle shuffling (where to place goal locations). MCTS is then used to optimize the solutions. An evaluation function is used to filter out levels that are too easy or uninteresting, leaving a set of challenging and solvable puzzles.

    4. Search-Based Procedural Generation of Maze-Like Levels
    5. Procedural Generation of Narrative Puzzles in Adventure Games: The Puzzle-Dice System
    6. Procedural level generation with answer set programming for general Video Game playing
    7. Procedural Content Generation in Games
    8. A Generic Approach to Challenge Modeling for the Procedural Creation of Video Game Levels
    9. Procedural Generation of Dungeons
    10. Procedural content generation for games: A survey
    11. A case study of expressively constrainable level design automation tools for a puzzle game
    12. A multi-population genetic algorithm for procedural generation of levels for platform games
    13. Patterns and procedural content generation: revisiting Mario in world 1 level 1
    14. Mixed-initiative procedural generation of dungeons using game design patterns
    15. Procedural Level Design for Platform Games


    Less Relevant Articles

    16. A Logical Approach to Building Dungeons
    17. A games first approach to teaching introductory programming
    18. Procedural Generation in Game Design
    19. An approach to level design using procedural content generation and difficulty curves
    20. Integrating procedural generation and manual editing of virtual worlds


    Sources

    https://games.kde.org/game.php?game=kgoldrunner

  • By Hazel Wong September 7, 2020

    First Post

    Overview

    Procedural generation is a way for data in video games, such as levels, characters and the environment, to be created algorithmically. This method could have multiple advantages, including creating dynamic content, saving memory usage, saving development time and saving money (Packt 2016). This project will attempt to explore that concept by creating an algorithm that will procedurally generate levels for a novel puzzle game, allowing more dynamic content to be created for people to enjoy while saving time, cost and memory usage.



    Sources

    https://subscription.packtpub.com/book/game_development/9781785886713/1/ch01lvl1sec13/benefits-of-procedural-generation

    https://subscription.packtpub.com/book/game_development/9781785886713/11/ch11lvl1sec99/the-pros-and-cons-of-procedural-generation

    https://docs.racket-lang.org/planning/Sokoban.html

Contact

Get in Touch