A Bear's Story

A Bear's Story is a 3D  platformer with a short quest and splash of action for PC. You play as Barry, a recently donated Teddy Bear. Feeling homesick, Barry sets his goal to escape and go back home. Armed with a Sticky Hand, you begin your escape plan. Along the way, you will meet friendly Teddy Bears while facing the forces of enemies who want you to stay. You will face the criminal forces of the Barbie Yakuza,  the thunderous storm of the Dust Bunnies, and the ludicrous speeds of the Dragsters. Think you can help Barry escape?

~ Controls ~

Move: WASD

Look Around: Mouse

Attack: Left Click

Grapple: E

Interact: F

Post Mortem

Major Changes:

- Setting Change: 1/3 of the way into the project we decided that our original environment of a bedroom was too limiting and switched off to a daycare, which we also later expanded to a greater scale for more exploration potential.

- Core Gameplay Loop: At first we planned to have multiple puzzles per area, which we later decided to cut due to it feeling overscoped. We decided to focus and fine tune the core gameplay loop into one main objective instead. Due to this we also scrapped items like a small inventory hotbar, a clues system, and condition-based interactions.

- Linear Course to Open: At first we imagined the progression would be from room to room, and you would unlock one zone after completing the first. We opted for free-to-choose exploration instead of a consecutive order of events.

- Tutorial Room: An area of our game was switched to be an introductory area so the player can get more accustomed to the controls, NPCs, enemies, and mechanics.  

What went poorly:

- 3rd Person Camera: Perfecting the camera was more difficult for 3rd person than anticipated, and we considered switching to first person at times because of this. Overall it felt better to do the platforming and combat in third person so we took the time to improve it instead.

- Slow Integration: Although we were making good headway progression-wise early on, it took us a while to integrate our work together from our multiple areas and get them working.

- Asset Issues: We had a couple of assets that weren't properly uv unwrapped, so they were a bit problematic when applying textures to them, so we had to work around it. This was mostly prevalent on the walls, and we ended up adding a bunch of posters and drawings on the walls to decorate the wall instead.

What went well:

- Communication: Despite having times where we were behind in integration, our team was always in communication with each other with what was going on.

- Adaptive: We had to cut some aspects that we were interested in implementing and had some major changes that altered the course of our development but were able to adapt to these events accordingly.

- Aesthetic/Theme: We had a strong idea of how we wanted the game atmosphere to feel for the player and had consistent art style between the animations, models, UI, and particles.

What we learned:

-Limiting scope: Throughout the development and design for this game, everybody on the team had tons of great ideas that would have been fun to implement. However, we knew that projects always turn out to be larger and more difficult than expected, so we were bound to cut ideas from the list eventually. Sometimes cutting ideas wouldn't sit well, but we all grew to accept it and understood that it was for the benefit of the game and the team.

-Learning diverse development skills: Everyone has their own unique skill set and development tasks they are most comfortable with. However, in order to grow as creators and developers, we all have to step out of our comfort zones and learn new skills. For instance some artists had to dabble with code while programmers had to work with 3d models and animations.

-Iterative design: Rather than building systems and mechanics and implementing them immediately, we found that it was much more efficient and convenient to go through multiple prototypes before integrating. With this method, any implementations we would make to the main project would be a lot smoother to debug and test with.