exploring speculative ideas, MICRO-INTeractions, user experience, and storytelling.

Project Overview
This exploratory design project was focused on how to implement and apply UI and UX in an interactive mobile experience. Numerous functioning prototypes were designed and built to explore different problems and to develop unique solutions.

The goal of the project was to build a fully functioning high fidelity demo prototype that could be played and fully experienced on an iPad. (The demo experience was developed and built for the first few minutes of the story.)
Games and interactive experiences encapsulate a large field of study and work that makes me excited. The project allowed me to work on research, art, 3D design, sound and music, storytelling, interaction, and experience design as well as coding and different areas of technology.

It required a multidisciplinary design approach that I am alywas excited and passhionate about. I enjoy building interactive game like  experiences and projects.
The project was build and developed in Unreal Engine 4 with the use of Blender, Sketch, Photoshop and Garage Band and other design tools.

Night Within is an Interactive Adventure Experience built for iPadOS. The project explores a short story where the player gets to experience an individual's internal world. The player is placed in a world that feels abandoned, desolate, and threatening.

Throughout the experience, the player must find a way out from this environment and see the truth behind this facade.

The first stage of the project was to understand and research current interactive projects and experiences, that explore ideas and questions about similar topics.

By having prior knowledge with developing similar experiences, I was able to dig deeper into more advanced development practices, and further expand my understanding on more complex interactive prototypes.
After the initial research, I spend a largest portion of my time on constantly building and testing interactive prototypes, mechanics, assets, and micro-interactions.

Most of these ideas were quick prototypes that allowed me to evaluate the experience and build on top of the feedbacks gathered from playtesting.
Almost all ideas were validated or completely disproved during the early stages of testing. All final designs, interactions, and details were results of quick building and and constant usability testing.

During the development of the project, several unanticipated problems surfaced that required constant debugging and creative problem solving.
fully interactive experience without a single line of code.
The entirety of the project was built using Unreal Engine 4's built-in Blueprint System. Visual scripting had it's on difficulties and challenges, but this system allowed me to create fully working prototypes without a single line of code.

Building prorotypes with UE4's blueprint system was often quite a bit faster process than writing native C++ code, however, this is not alwats the case.
Blueprint example from the project - includes a number of similar and complicated function and visual scripts.
Project progression and iterative prototyping.
There are a number of different versions were built of the project before the final design and ideas came to life. Every iteration of the project pushed the concept, ideas, and technical solution further with each version.
DEVELOPING prototypes with efficiency and modularity in mind.
One of the goals of the project was to develop prototypes with efficiency and scalability in mind. Almost all assets and blueprints were broken down into the smallest components to make assets as reusable as possible. Since I had to build several prototypes for testing and research, my goal was to make sure that small components are modular enough to be reused in other areas of the project. This allowed me to quickly test ideas by combining smaller components into something new.

Every function, event, actor, shader, texture, and assets were designed to make sure that the project is easily scalable. It was essential to the project that the blueprints (logic) running behind the front end interface and experience are just as elegant and thoughtful as the design and the art itself.
Overview of a Tower Actor with all it's individual and modular components.
Simple solutions and rapid-prototyping.
Ofter I had very litmited time and resources to work on the porject, so I had to come up with simle and cheap solutions. Assets and object were often first built in a "grey box" manner with little to no detail, and later on upgraded during the later development of the project.

One of many of simple solutions was recording some specific sound effects that I needed for the project. I recorded several foley sounds from myself (breathing, cloths, objects, ground and rocks, etc) and from Google Translate. I took these raw sound effects and transformed them within Garage Band. This was a fast process to achieve interesting sound effects that added an important layer of immersion and experience to the project. Sound was ofter crucial to the immersive ness of the project and to achive a higher, more believable fidelity.
Google Translate voice recorded and transformed within Garage Band. Several other sound effects where
recorded using very similar strategies.
how to tell a story and create narrative?
Storytelling was a crucial, but challenging part of the design process. The project went through several iterations and changes to the story, as well as how to deliver an experience that the user can think about.

I was interested to explore speculative storytelling ideas where I leave the person experiencing the project come up with their own story and theory based on the interactions and environment. There are no dialogues, textual storytelling or any form of explanation. The experience was built around visual storytelling, short animations, cutscenes, and world exploration. The player is faced with an experience that presents visual clues, but the definition of the story is left to the user to synthesize themselves.
ASset design and development.
Almost all assets present in the experience is custom designed and built in Blender.

One of the more difficult challenge was custom character and rig. It took some trial and error to get the pipeline work properly, but once I was able to figure out efficient ways to import rigs and assets it made the process fairly simple.
EXploring micro-interactions and small details.
The project was mainly built around interactions and small experiences. There are a number of micro-interaction in the project that are very small details, but if it was missing, it would break the immersion.

This part of the project was the longest and perhaps most time consuming. All micro-interactions required constant testing after every little change. A large portion of these test were often fine tuning the interaction to make sure that the experience feels high quality and enjoyable. It was important to make sure that whatever interaction happens in the project, the player feels like it meant to happen and feels natural.
Building the illusion of smart AI for in-game ENEMY.
During the creation of the "Drone" actor, I had explored several different avenues for building a seemingly intelligent enemy. Using UE4's AI Behavior Tree seemed to be a great place to start at first, but I figured out ways to simplify that system for the need of the project using only Events and simple functions within the Actor Blueprints.

Since I was designing a floating & flying drone, it made it easier to create an actor, that did not necessarily need collision avoidance due to the design of the environment. I was able to built a simple system that randomly "picks" locations in a dynamic area, where the drone would continuously move to the updated locations in a fluent, but naturally random pace.

This created the sense of "patrolling," and created thension in the experience. The player has no way of knowing where the drone would move next. Unpredictability became a key element of the entire project.
This demo shows the events after the player is detected by an enemy drone patrolling the area.
the Importance of none-visible details
There are several development practices as solution that are happening in the background.

For example, one is to eliminate refreshing functions and events every frame ("Event Tick").

This could be an expensive function and potentially lower the frame-rate of the experience. It was crucial to build the project where actors, assets, and functions only update when it is necessary.
testing every mechanic, interaction, event, and experience.
Considering that this project was a fairly complex interactive experience, every little change and idea needed to be carefully tested, ofter numerous times. Every change made to the experience was played both in the engine and editor and packaged to the iPad.

Although I was constantly building and testing the project on my own, I have worked and showed the experience to others to collect feedback and understand their experience with the project.
Playtesting the experience on iPad Pro.
designing simple menus and in-game interfaces.
It was important to make sure that every little detail within the project is thoughtful and fully considered. I designed several versions of in-game interfaces, loading screens, and other UI elements. Almost all menus and interfaces have parallax effect built in, that reacts to the orientation and tilting of the device. It was important to make the interface feel alive, responsive, and dynamic.
BUIlding tools and ways to debug on the fly.
It became a useful practice early on in the project to build some functions and tools that would allow me to test the game and debug the experience while playing. This proven to be extremely useful since I was able to test different scenarios and reset parts of the game, if needed to be, without needing to restart or recompile the app.

I built a simple developer platform and interface that allowed me to modify and change aspects of the in-game objects and actors, so I can evaluate and understand where the project breaks and fails. (Without these tools, I would had to restart the project every time I wanted to make a change or test a scenario)
what went wrong during the development of the project?
One of the best, but most challenging part of the project was constant problem solving. Every little change and addition to the project created problems and complexity that was often unpredictable. Layering complexity often resulted in lots of errors and unexpected bugs.

I had to develop ways in which I could build little by little and make sure everything works well, and efficiently together.

My expectations to approach a large project as such come to the realization that this is more work than one person can handle in a short amount of time. I had to sacrifice ideas, sections of the project, experiences, and mechanics due to complexity and time limit.