Inside the Game Development Process: A Streamer's Journey

The stream begins with a warm welcome from the host, who expresses excitement about returning to work on the game project. The host mentions having created a spawner that generates enemies randomly, currently limited to slimes, and acknowledges the need to develop additional enemy types.

The host discusses the current functionality of the game, indicating that while it is operational, there is still much to be done. They plan to introduce various enemy types, including a ranged enemy and a heavy enemy, alongside the existing slimes.

The host focuses on scripting the behavior of the slime enemy, noting that they have a document prepared for this purpose. They express a moment of uncertainty but quickly regain focus on the task at hand.

The host begins working on the game's environment, specifically the trees, and considers adding apple trees for variety. They express a desire to enhance the aesthetic appeal of the game by decorating stumps and grass later.

The host acknowledges a viewer who has joined the stream, expressing gratitude for their previous engagement. They share a light-hearted moment about a previous incident, reinforcing a friendly atmosphere.

The host reflects on the current state of the game, noting that it is not yet fully playable. They contemplate the number of levels to include, suggesting a target of ten levels, and emphasize the importance of making the game enjoyable.

The host takes a brief break, mentioning the need to use the bathroom. Upon returning, they humorously explain that they drank too much water, indicating a casual and relatable atmosphere during the stream.

The speaker discusses the need to modify a script to store more coordinates effectively. They contemplate changing the target position to an array format to enhance functionality.

The speaker experiments with camera transformations, considering duplicating the main camera's transform to create additional functionality. They note that pressing a key too often can disrupt the system, indicating a need for careful timing in interactions.

The speaker plans to create a slime enemy and outlines their intention to design multiple areas, aiming for a total of ten. They express a desire to return to a flat palette for drawing, focusing on adding more greenery to the environment.

The speaker describes a simple game mechanic where the king character will walk through a designated area, triggering a box collider that changes the main camera's transform. This system is intended to enhance gameplay dynamics.

The speaker commits to creating ten levels, ensuring that the main camera is positioned correctly to facilitate gameplay. They emphasize the importance of filling the game environment with appropriate decorations and elements.

In the final stages of development, the speaker focuses on adding decorative elements to the game, ensuring that there is enough space for gameplay mechanics. They perform checks on the transformations to ensure everything is functioning as intended.

The speaker discusses the design of monsters in a game, proposing an initial count of 20 slimes for the first area. They consider increasing the frequency of slimes in subsequent areas and introducing heavier enemies in later stages, indicating a flexible approach as they progress.

The speaker focuses on adding trees to the game environment, starting with orange trees due to their simplicity. They express concerns about visual clipping issues when layering different types of trees, such as apple trees overlapping with orange trees, and aim for a natural look without obvious overlaps.

The speaker randomly places elements in the game, indicating they are creating five distinct levels. They mention the need to ensure proper transformations and camera positioning for each level, reflecting a methodical approach to level design.

The speaker outlines the implementation of camera transition barriers in the game. They detail the process of setting up triggers for camera movement when colliding with specific game objects, such as the 'king,' and emphasize the importance of scripting to manage these transitions effectively.

The speaker delves into the scripting logic for camera movement, discussing the need for flags to manage triggers and movement states. They highlight the importance of ensuring that the camera responds correctly to player actions and game events, demonstrating a thorough understanding of game mechanics.

The speaker tests the functionality of the camera and enemy interactions, specifically checking the behavior of the camera when encountering the 'king' character. They express a need to refine the camera's response to ensure smooth gameplay, indicating an iterative approach to development.

The speaker discusses the functionality of a trigger related to a camera transition. Initially, there is confusion about whether the correct trigger is activated, but after some adjustments, it is confirmed that the trigger works, although it produces an undesired effect. The speaker contemplates the need for a rigid body component to resolve the issue.

After resolving the trigger issue, the speaker mentions the need to add more designs, specifically mentioning the integration of sprites and camera movement triggers. This indicates a focus on enhancing the visual and interactive elements of the project.

The speaker takes a brief break, indicating a need to step away for personal reasons. Upon returning, they refocus on programming tasks, particularly the completion of a transition effect.

The speaker explores the possibility of destroying a game object after it has fulfilled its function, which would streamline the gameplay experience. They test this functionality to ensure that the game behaves as expected without the now-unnecessary objects.

The speaker shifts focus to creating pixel art, specifically for a character. They express a desire to develop a four-directional male character and consider various references to guide their design process. The speaker also contemplates creating animations for a slime character, including attack and death animations.

The speaker works on refining the attack animation for the slime character, adjusting frame rates and ensuring the animation looks satisfactory. They discuss technical aspects such as frame speed and sprite dimensions, indicating a detailed approach to animation design.

The speaker sets up an animator for the slime character, mistakenly adding a new layer instead of a new time state. They express uncertainty about the process but continue to work on creating an idle animation for the slime, demonstrating a hands-on approach to character animation.

The speaker discusses the implementation of various animation states for a game character, specifically focusing on the 'Idle' state, which is represented by an integer value of zero. They also mention the 'Move' state as one and the 'Attack' state as two, indicating a structured approach to managing character animations.

The speaker contemplates how to manage enemy health within the game. They suggest setting a default health value of 10 for enemies and discuss the mechanics of taking damage, indicating a need for a straightforward damage system without a timer.

The speaker outlines the conditions under which the enemy will attack, emphasizing the importance of checking if the enemy is currently attacking. They mention the need to set the attacking state to false when certain conditions are met, ensuring that the enemy's behavior is responsive to game events.

The speaker introduces the concept of an attack delay, initially setting it to one second. They explain that this delay will be integrated into the attack state, allowing for a more realistic timing of attacks based on animations, which will trigger damage during specific moments in the animation.

The speaker discusses the current state of a game object, specifically a 'King' character, noting that the code is messy due to it being a game jam project. They acknowledge that the code is not tidy and may resemble 'spaghetti' code, but express a willingness to tidy it up later.

The speaker outlines the mechanics for the King character to take damage from enemies. They mention implementing a function for the King to take enemy damage, which involves setting health to zero to trigger a 'die' state. The mechanics are still in development, and the speaker is working on refining the damage system.

The speaker expresses uncertainty about how to implement animation events in Unity, indicating a need to search for tutorials. They discuss the importance of triggering damage through animations and the necessity of making certain functions public to ensure they work correctly within the game.

The speaker tests the animation transitions and notes that the speed of the animations is too fast. They contemplate ways to slow down the damage-taking animations to create a more realistic gameplay experience, indicating a desire for better pacing in the game.

The speaker continues to test the attack mechanics of the King character, noting that the character should attack instantly. They troubleshoot issues with the attack function, realizing that the attack was not being triggered correctly due to the absence of an exit condition in the code.

After several adjustments, the speaker concludes that the current state of the game mechanics is a success for now. They express satisfaction with the progress made, despite acknowledging that there are still areas for improvement, particularly in the attack mechanics and overall gameplay experience.

The speaker begins by testing a game feature, expressing curiosity about its functionality. They mention the need to implement a 'Rog' system and decide to create a cursor before proceeding to develop the king character.

The speaker focuses on designing the king character, starting with the crown and head. They experiment with colors, shading, and details, aiming for a visually appealing design. The process includes adjustments to skin color and adding shading to enhance the character's appearance.

After completing the king's design, the speaker shifts to animating the character. They express a desire to ensure the animation is executed properly, indicating a thoughtful approach to the character's movement and presentation.

The speaker acknowledges their audience, welcoming viewers to the stream and apologizing for not engaging with the chat earlier. They share their inspiration for the king's design, mentioning the need to create additional views for the character.

The speaker discusses managing the king's sprite within a spreadsheet, indicating a methodical approach to organizing game assets. They express uncertainty about certain tools but continue to work on refining the character's appearance and functionality.

The speaker adjusts the animation speed for the king character, aiming for a frame rate of one frame per second. This reflects their attention to detail in ensuring the animation aligns with their vision for the character's movement.

The speaker prepares to continue drawing, indicating a transition to further development of the game. They express enthusiasm for the creative process, suggesting a commitment to enhancing the game's visual elements.

The speaker discusses the need to adjust the animation for a character, focusing on the right side and top side of the design. They mention covering certain areas with red and making adjustments to the back part of the character, indicating a desire for a cohesive look.

The speaker contemplates copying a previous frame to maintain consistency in the animation. They express uncertainty about the movement of the body and decide to copy a frame from earlier to ensure the animation flows smoothly.

The speaker adjusts various settings for the animation, including bit depth and cell size. They express confusion about the animation tools, indicating a need to remember how everything works while trying to set the animation to a specific state.

The speaker realizes their microphone is positioned too far away, affecting the clarity of their voice. They adjust the microphone closer to ensure better audio quality during the session.

The speaker discusses the different states of the animation, indicating a sequence of states from zero to two. They express hope that the animation will work correctly after these adjustments.

The speaker observes that the slimes are not attacking as expected. They troubleshoot the issue, noting that only one slime is responding correctly. They consider the proximity of the slimes to the main character, the King, and how it affects the animation.

The speaker suggests modifying the collider settings to improve the interaction between the slimes and the King. They propose that the attack behavior should depend on the proximity of the enemies to the King, aiming for more consistent animations.

The speaker discusses the difficulties faced while coding, particularly with the movement of a character, indicating a lack of attention to detail in the initial setup. They express uncertainty about the effectiveness of their current approach and consider alternative methods, suggesting a trial-and-error process in their coding journey.

The speaker identifies issues with their code, specifically mentioning the need to call the Box collider to improve functionality. They test the code to see if it breaks anything, indicating a focus on debugging and refining their work to achieve more consistent results.

The speaker adjusts the attack delay in their game mechanics, experimenting with different timing settings to find the right balance. They express satisfaction with the improvements made, noting that the attack mechanics are becoming more effective and consistent.

The speaker reflects on the completion of the main mechanics of their game and shifts focus to sprite development. They plan to create additional sprites, particularly for the king character, and discuss the design elements they want to incorporate, emphasizing the importance of visual consistency in their game.

The speaker contemplates the animation of the king character, considering how to make it visually appealing without overcomplicating the design. They experiment with different movements and expressions, aiming for a playful and engaging character design while managing the complexity of the animation process.

The speaker prepares to integrate their sprite work into Unity, discussing the technical aspects of setting up the sprite editor and ensuring the correct parameters are applied. They demonstrate a methodical approach to programming, indicating a clear plan for how the character's actions will trigger specific game responses.

The speaker discusses the progress of their game development, indicating they have a clear idea of the mechanics they want to implement. They express confidence in completing most of the mechanics by the end of the day, with plans to assemble everything the following day. They also mention the possibility of staying up late to work on the project, hinting at a casual barbecue planned for Friday.

The speaker begins programming camera movement for the game, outlining the steps to grab the camera object and set up its movement. They detail the process of creating a public method to handle movement and update the camera's position based on player input. The speaker emphasizes the importance of ensuring the camera movement is smooth and responsive to player actions.

The speaker explores how to trigger the king's movement in the game using keyboard input. They write code to check for the 'E' key press and toggle the king's movement state. The speaker expresses uncertainty about whether the code will work as intended but remains optimistic about testing it.

As the speaker tests the camera movement, they encounter unexpected behavior, noting that the king's position is not as intended. They analyze the code to understand why the camera is moving too quickly and why the king appears in an unexpected location. The speaker contemplates creating a separate mechanism for the king's movement to improve extensibility, although they struggle to find a solution at that moment.

The speaker considers implementing a trigger variable to manage the king's target counter more effectively. They plan to create a private integer to track the target counter and increment it based on camera movement. This approach aims to streamline the logic behind the king's movement and ensure it aligns with the camera's actions.

The discussion begins with the implementation of a 'King Target' logic, described as foolproof. The speaker explains how the logic is triggered, indicating a sequence where the state changes from false to true, and then back to false, ensuring that the king cannot teleport to another area, which is a desired outcome.

The speaker encounters issues with the 'King Target' counter, which starts at zero and is supposed to trigger camera movement. They express confusion over the logic, contemplating whether to increment the target counter correctly. The speaker reflects on the need for the king's movement to be slower, indicating a desire for a more controlled pace.

The speaker struggles with adjusting the speed of the king's movement, experimenting with various parameters. They note that the current implementation feels like a brute force method, acknowledging that a more refined script could be developed. The speaker continues to tweak the speed, trying to find a balance that feels right.

Transitioning to animation, the speaker plans to measure the target's position to create a more dynamic movement for the king. They realize they need to implement a 'down walk' animation, expressing a sense of urgency to finalize the necessary sprites for both the king and the slime. The speaker meticulously details the process of copying frames and creating new animation clips.

The speaker confirms they have all the required sprites for the king and slime characters. They proceed to organize the assets, ensuring that the animations are correctly set up in the inspector, indicating a structured approach to managing the game's visual elements.

The speaker discusses the progress of their game development, mentioning the need to delete unnecessary elements and considering adding mechanics such as healing and damage. They express a desire to take a break before planning further game design elements.

Before taking a break, the speaker decides to create a mouse cursor, opting for a simple pixel art design. They plan to use a 64x64 pixel format and experiment with colors, including yellow and blue, to achieve a visually appealing cursor.

After designing the cursor, the speaker attempts to implement it in Unity. They navigate through project settings to set the custom cursor but encounter issues with its accuracy during gameplay, leading to confusion about its functionality.

The speaker faces challenges with the slime enemy in the game, initially believing it to be a cursor issue. After troubleshooting, they discover that the enemy prefab was not functioning correctly, but once fixed, the slime enemy operates as intended.

The speaker makes final adjustments to the pixel art for the sword, ensuring it is flipped correctly for better visual representation. They continue to refine the game elements, indicating a focus on achieving a polished final product.

The speaker expresses confusion and frustration as they encounter a verification failure, stating that all verification checks have failed and that the collider did not create any collision shapes. They note that only a small portion exists in the XY plane, indicating a potential issue with the setup.

After troubleshooting, the speaker identifies that the default cider size and offset were inadvertently deleted during a copy-paste operation. They successfully restore the settings, leading to a resolution of the previous issues, and express satisfaction with the progress made.

The speaker contemplates implementing a king walking animation, indicating a desire to enhance the character's movement. They plan to create a new animation state and address a bug related to the slime hitbox, which fails to spawn in specific areas.

Diving into the script for the king character, the speaker outlines the creation of various states for movement, including idle, up, right, down, and left. They detail the process of setting up an animator script and defining integer states for each movement direction, demonstrating a methodical approach to coding.

The speaker tests the animation changes based on the character's movement, confirming that the animations switch correctly according to the current position. They express a sense of accomplishment as the animations respond as intended, indicating progress in the development process.

The speaker discusses the logic behind an exit condition in their project, repeatedly emphasizing the need for 'no exit' to ensure the functionality works as intended. They express confidence that the adjustments made will lead to a successful outcome.

After several iterations of testing, the speaker successfully modifies the code to handle conditions involving values less than and greater than one. They articulate their thought process, indicating that they are refining the logic to ensure it accurately reflects the intended behavior of the program.

The speaker encounters a technical issue related to a 'stack overflow' error but reassures themselves that it should be manageable. They express relief when the program functions correctly after their adjustments.

The speaker accidentally closes a project window in Unity, leading to a moment of confusion as they search for the correct window. They quickly resolve the issue, demonstrating familiarity with the software's interface.

Before taking a break, the speaker commits their work on the 'King animations,' noting that they have fully implemented the animations with transitions to different areas. They reflect on their progress and express a desire to continue developing the game, mentioning plans for further design work and documentation.

The speaker concludes the stream by expressing hope to return for another session soon, possibly the next day. They mention their intention to focus on game design tasks in the interim, indicating a balance between streaming and development work.