Cinematic Introduction Scripts

The introduction sequence combines several scripts to create an immersive and cinematic opening. These scripts manage transitions, animations, text, and image fades to guide players through the lore, setting the tone before entering the main game hub. Notably, the ImageFader and TextCanvasFader scripts are reused to add atmospheric transitions in the game’s endings.

• LoreCutsceneEnd Script

  • This script helps transition between sequential cutscenes by activating the next cutscene once the current animation finishes.

  • It is initialized to keep the next cutscene deactivated, waiting until the current cutscene ends to reveal the next scene.

• IntroductionScene Script

  • Controls the opening cutscene with elements such as a sun rising animation and a “Skip Cutscene” button.

  • The SunRiseSequence coroutine moves and rotates the sun gradually, creating a visual effect of sunrise over the duration of the cutscene.

  • The “Skip” button appears at the start and allows players to skip directly to the fightershub, giving flexibility to players who prefer to bypass the introduction. The button visibility is managed by buttonVisibleTimer.

• TextCanvasFader Script

  • The TextCanvasFader script controls the fading in and out of text and associated images. It gradually displays each text in sequence.

  • The coroutine FadeCanvases manages each text/image pair’s visibility, fading them in and out over specified durations.

• ImageFader Script

  • The ImageFader script is specifically designed to manage image elements.

  • Similar to TextCanvasFader, it cycles through images, ensuring only one image is visible at a time and that each is displayed long enough to be impactful before transitioning to the next.

These scripts contribute to a dynamic introduction and memorable endings. This taught me the importance of:

• Cinematic Timing: Coordinating animations, fades, and transitions to enhance the storytelling.

• Player Control Options: Allowing players to skip the cutscene respects diverse playstyles.

• Reusable Code: Leveraging TextCanvasFader and ImageFader in both the introduction and endings, demonstrated the value of modular design.

• SpinningCamera

  • Controls the initial spinning of the camera around the main character, Bom, in the main menu. It gradually transitions to the intro scene through smooth position and rotation adjustments.

  • When StopSpinningAndReset() is called, the camera returns to its starting position while playing an audio cue. Once aligned, it initiates a scene transition to the "IntroScene," signaling the start of the story.

Fighters Hub

The InspectController script is a utility in the FighterHub that handles the display of UI elements when players inspect or interact with objects. Reusing and adapting this script from Murder in Osaka allowed me to streamline development, implementing tried-and-true inspection features in a new game context. This approach underscores the value of modular code that can be adapted across different projects, enhancing efficiency and continuity in development.

I developed the Fighters Hub as a compact, streamlined central hub where players can engage with the bosses and select who to challenge. This hub integrates seamlessly with the game’s core mechanics, creating a cohesive player experience and serving as a central point for progression.

Through developing this script, I learned to manage layered interactions within a central hub scene and developed a system for interaction gating based on progression. The dynamic UI feedback allowed me to refine my skills in using coroutines and managing user cues to enhance player experience. This script showcases practical approaches to integrating scene transitions, progression tracking, and layered interaction design.

Key Features of FighterhubScript:

• The script uses a raycasting system to detect objects the player can interact with. When a valid target within interactionRange is detected, the ObjectController associated with the target is accessed, triggering relevant information displays, such as boss names or extra details. Raycasting resets if no interactable object is hit, ensuring smooth, error-free interactions.

• At the start of the game, the script checks the GameManager for defeated bosses and removes their associated objects from the scene. This keeps the hub updated, showing only bosses yet to be fought.

• The script manages a flashing "Press E to Continue" text to indicate when an action can be taken. It uses a coroutine (FlashText()) to make the text blink, drawing the player’s attention. When interacting with a boss, the script dynamically displays the “Yes” and “No” options to confirm boss selection, enhancing user control.

• The PerformInteraction method handles the boss selection process. When the player presses a key while interacting, it checks if the player has unlocked that particular boss based on previous accomplishments. If eligible, it prompts a confirmation; pressing “Yes” loads the selected boss scene, using SceneManager.LoadScene() for a smooth transition to the battle. Special logic prevents interactions with the “Final Boss” unless earlier bosses are defeated, guiding the player through the proper progression.

• ResetRaycastedObject() resets interaction states, hiding extra information and options to prepare for the next interaction, enhancing gameplay fluidity.

In developing the grappling mechanic, I spent over 60 hours prototyping and integrating it within the game. Facing challenges due to limited assets and animations, I implemented a temporary non-realtime solution using video references. This workaround allowed us to move forward, test, and align the mechanic with other systems.

In post-production, we ultimately removed the grappling feature due to course restrictions on new assets. Instead, we focused on bug fixes and refinements based on playtesting. This experience reinforced the value of adaptability and effective communication in meeting project requirements within tight time constraints.

The GrabbingController script was designed to allow players to grab and damage the boss within specific proximity. The script manages the sequence of animations, sounds, and interactions that make the grappling mechanic immersive and responsive. The GrabbingController script interacts closely with the Boss script to manage the grappling mechanic and track the boss's health, damage states, and defeat sequences.

• GrabbingController: Manages the grappling action initiated by the player, including animations, sound effects, and temporarily disabling the boss's and player’s movements.

• Boss: Controls the boss’s health, damage states, defeat tracking, and manages transitions between rounds and scenes based on the boss’s health and defeat status.

• In the GrabbingController script, when the player successfully initiates a grapple, the boss.TakeDamage(grabDamage, this.transform.position) line calls the TakeDamage method within the Boss script.

• Both scripts manage animations and gameplay states in tandem.

• The GrabbingController’s GrapplingBool coroutine disables and re-enables the AI and player inputs to control the flow of the grapple animation, and the Boss script manages state changes during the boss’s defeat and round transitions.

• The shared management of animations and game states between these scripts ensures that grappling actions and boss health states align correctly within each round of gameplay.

• Using a coroutine, GrapplingBool(), the script temporarily restricts the player and boss controls and initiates a sequence of animations and sounds to simulate the grappling event. During this sequence: After the grappling sequence, the boss receives damage specified by grabDamage, and a final sound (BossScreaming) plays to mark the grapple’s impact. Afterward, all elements reset: The player regains control, the AI returns to its idle state, and grabbingAnimation is hidden. These resets ensure that the gameplay can seamlessly continue after each grapple.

• By structuring the grappling sequence with coroutines and condition-based checks, this script can easily be adjusted or expanded. New animations, sound effects, or other interactions can be added without disrupting the core functionality.

Key takeaways

Throughout Shura’s Gauntlet’s development, our team faced resource shortages, particularly a lack of assets, which impacted our timeline and required us to adapt frequently. Playtesting helped us identify bugs and control issues that affected gameplay quality, highlighting the importance of early prototyping and continuous testing for faster iterations. Moving forward, I plan to employ tools like PERT and Gantt charts for more realistic time management. We also addressed team morale challenges, as we all struggled with motivation. Regular meetings promoted open communication and mutual support, reinforcing our commitment to collaboration, flexibility, and clear communication—key elements for successful game development.

This project emphasized critical lessons for future work:

• Structured Time Management: Using PERT and Gantt charts for effective planning.

• Role Clarity and Accountability: Implementing RACI matrices to clarify responsibilities.

• User Experience as a Core Focus: Prioritizing consistent playtesting for better feedback integration.

Despite setbacks, we completed a functional prototype, showcasing our dedication, creativity, and teamwork. This experience taught me resilience and the importance of continuous learning, skills I’ll carry forward into future projects.