Extending the Script: Memorial Wall Design
Life is Strange: Reunion | Design-Driven Environmental Storytelling
TL;DR
The Memorial Wall is the final free-roam as Max in Life is Strange: Reunion — a space for players to sit with those they saved and who they lost.
Challenge: The scene arrived with one variable driving its outcome, despite eight character variables having been tracked across the game — the script's single variable couldn't represent the range of outcomes a player might actually arrive at.
Solution: Using data layers already proven in production, I designed a four-layer outcome system driven by a hybrid of dedicated variable checks and an aggregated student death count, giving the wall intentional, aesthetically distinct results for every possible combination of player choices. Impact: By working within existing systems, I extended what was already in the pipeline into something the player could actually feel — player choices had somewhere to land, without pulling resources from other teams.
Variation of the Memorial wall in the editor.
The Scene
The Memorial Wall scene is the last free-roam as Max in Life is Strange: Reunion. It takes place at the Snapping Turtle a couple of days after the fire, the primary climax of the game. Players are able to move through the space talking to surviving NPCs, and on the back patio, a free-look looks out at a memorial wall for those that may have been lost during the fire.
What I Was Working With
When the scene came to my desk, the script was using a single variable to determine its outcome: a fire success score of zero, one, or two. Depending on that value, there was some small cinematic branching during Yasmin's intro speech, while talking with Moses, and when interacting with the patio door.
With the Memorial Wall free-look, the script didn't cover the range of outcomes the player might actually have arrived at. It was simply each hotspot with a true or false, on or off, check. By that point in production, we had been tracking eight separate character variables. Some were straightforward, like whether you had saved Jeanette or Poet directly. Others were more conditional, such as accusing Ren as Chloe and suspecting Vinh as Max. These were intertwined conditions — both had to happen for the player to confront Vinh at the Abraxas House, and if either accusation was missed, Owen and Vinh were lost. The script's single variable wasn't able to represent those nuances within the memorial wall.
Throughout the rest of the scene, if a character was dead they simply weren't there. Absence can be a powerful piece of storytelling, especially when used deliberately. In the Memorial Wall free-look, though, absence was being used in reverse — if a character survived, their picture wasn't on the wall. This felt less deliberate; it was simply a hotspot and image being turned on or off.
As the scene came to my desk, it became my job to give rhyme and reason to that on and off logic. That gap was the core of what I was trying to solve: taking the script and all the possible mutations in the player's journey and crafting something that felt intentional, regardless of which choices they had made along the way. Given where we were in production, that needed to come from the design side.
The Goal
My goal wasn't to add complexity for its own sake. A memorial wall with eight individual on/off photo swaps sounds thorough on paper, but it creates an aesthetic problem immediately. If only one person died, their photo doesn't belong on the far left of a wide wall surrounded by empty easels and flowers. That doesn't read as a memorial — it reads as a mistake. A real memorial has intention to it. The placement of objects, the density of the space, the number of people in the room, all of it communicates something.
So the goal was an outcome that felt organic regardless of how the player had gotten there. It also needed to be manageable for environment and cinematics to build against, and was structured clearly enough that when an edge case came up, it could be diagnosed and corrected without unraveling everything else.
The wall was the primary focus, but that design instinct extended further into the scene. Some variable-driven elements were already in the script — newspapers reflecting who had died, environmental details indicating which buildings had burned. Others I added independently. One example is a garden gnome that recurs throughout the game. Whether it appears in the memorial scene at all tracks off a single variable, independent of the data layer, with no dialogue explaining it.
The same thinking applied to NPC placement. Where a character was standing, and who they were standing near, changed based on how the fire had gone — not because the script called for it, but because the space should reflect what the player had been through. Not every player would consciously register it, and that was okay. I was after the feeling, not the acknowledgment.
The Solution: Four Data Layers
Data layers were already part of our toolkit — how we primarily defined different scenes and which assets and actors were loaded. The system had been there from the beginning, eventually expanded for scenes like the Overlight and the Mabon party. For the Memorial Wall, I set up four distinct data layers, each representing a possible outcome the player might find themselves in: Good, Minor, Bad, and Ugly.
Rather than checking all eight variables independently, I created a scene-specific variable — student death count — that aggregated the individual student variables into a single trackable number. This gave me a hybrid system: definite factors like whether Ren or Vinh had been stopped could be checked directly, while the student death count handled the broader threshold without needing to check each student individually. The blueprint logic then used these checks in sequence, ruling first whether the player qualified for Ugly, then Bad, then Minor, and finally Good, activating the first layer they qualified for.
Logic checks determine the scene's outcome.
Good was the outcome where everyone survived. Rather than a memorial, the entrance displayed a Wall of Heroes poster and the billboard reflected it too. If no one died, the community isn't grieving — they're celebrating. 30-plus background characters fill the space.
Minor represented losing one or two people. The memorial is present but not overwhelming. Around 26 background characters.
Bad required specific combinations — stopping Ren but losing multiple students, or failing to stop Ren and losing Owen and Vinh along with additional deaths. This layer had the most conditional checks and took the most iteration to feel right — it was the outcome I expected more players to land in, which meant getting it wrong was the least forgivable. Around 21 background characters.
Ugly was the worst state. Primary checks were failing to stop Ren, losing Owen and Vinh, and losing Loretta — but I also built in a secondary path where losing five or more students pushed the player here even if Loretta had survived. The logic had to account for the feeling of the outcome, not just the variable checks. Sixteen background characters, significantly more flowers and wreaths throughout.
Because the environment team could build set dressing against a known outcome, they had clear direction for how the space should feel at each threshold. The layers also let me assign specific NPCs to specific outcomes — or to multiple situations — moving the same character to a different position between states, implying a shift in their situation without adding anything to the script.
There's a small example of this that I'm fond of. Two returning characters from Double Exposure, Claire and Tim, appear at the Snapping Turtle in the memorial scene. Where they're standing — and whether they're standing together — changes based on how the fire had gone. It's a detail the script never addresses.
Logic activates the desired Data Layer and NPC living world level sequence.
Issues Along the Way
The Loretta variable. Loretta's alive/dead variable was intended to be set during the memorial scene itself. Late in production, we started seeing instances where the scene loaded with that variable already sitting at 1. If the player had also saved Loretta in-game, the logic would push it to 2, because the original implementation used a +1 increment. That had downstream effects on how she was portrayed in the scene.
The fix was two-part: hard-set the variable instead of incrementing it, and add a baseline reset at begin-play for any variables unique to the memorial scene blueprint. That way, whatever state a player arrived in, the logic started clean.
Cinematics and the default layer. The intro cinematic for the scene pulled NPC actors from the default data layer, which was Ugly. That meant those NPCs had to be present for the cinematic regardless of which outcome the free-roam was going to load into. The solution was keying the cinematic NPCs to their own layer so they would be guaranteed present at the top of the scene before the free-roam data layer activated.
Reworking the layer logic. My original approach to slotting players into a data layer was based purely on death count — essentially an extension of what the script had given me, just with more gradations. The problem was the same one I'd identified in the script: a raw number couldn't reliably capture the right feeling for each outcome. So I went back and defined each layer by specific conditions — this is what Ugly means, this is what Bad means — and built the logic around that. That decision is what made edge case detection possible, because I now had a clear picture of what should be present in each outcome to check against.
Logic checks the variables used to determine whether a student was saved.
Two edge cases surfaced from there. The first was the Loretta scenario. I had defined Ugly as primarily requiring her death, but a player who saved Loretta while losing five students was now landing in Bad — and that didn't feel right. The fix was adding a student death count as a secondary check within the Ugly condition, so the threshold could catch that combination even when Loretta had survived.
The second was a placement issue with Poet's picture in a scenario where both Vinh and Noel had survived. With their easels holding wreaths rather than photos, Poet's picture ended up pushed to the far left of the wall — two wreaths between him and the next photo to the right. That's not how a memorial gets arranged. The fix was using our state manager sequencer to swap Poet's position with where Vinh's photo would have been, moving him closer to the center. It was a different system from the rest of the memorial wall logic, but I kept the call to it within the main blueprint, so the behavior stayed traceable.
That fix introduced a small error of its own. The logic for determining whether to trigger the swap used an equality check; if both values were equal, move the photo. The problem was that "equal" also meant both values were zero, which would trigger the swap even if both Vinh and Noel had died. I only wanted it to trigger when both had survived. The fix was straightforward: check that both values were equal to 1 and equal to each other. Small error, quick fix, and a reminder to be specific about what you're actually checking for.
Logic error when checking for equivalent - fix was making it an AND node.
After shipping, a playthrough surfaced another edge case. In the Minor outcome with only one casualty, Jeanette's picture ends up on the far left of the wall, wreaths in the middle, photo isolated in a way that doesn't read as intentional. It's the same placement problem as Poet's, and the fix would likely have been the same, or at least similar. I'm noting it here because it's a good example of how edge cases in a system this complex aren't always caught during production. They might only surface after launch, when a player makes a specific set of choices.
Image of a student's photo on the far side of the wall.
Reflection
The system I built didn't require the narrative team to write additional scenes or the animation team to create new content. It worked from what was already in the pipeline and extended it through design and implementation. The player's choices going into that final scene had somewhere to land. A lighting tone pass and broader set dressing changes didn't make the final cut — scheduling constraints at the tail end of production are a reality on every project, but the bones are there for both.
What the research shows is that a significant portion of players used the wall as a save point. They saw a picture on an easel, went back, and tried to change it. I understand why — making loss visible invites the impulse to undo it. Whether a more ambiguous reveal would have produced a different response is a question I find genuinely interesting. In the end, players read the wall correctly on the first try. Guides, walkthroughs, and community threads treat it as self-explanatory: if you see the Wall of Heroes, you pulled it off; if you see the memorial, you missed something.
The wall was never meant to be the emotional climax of the game. The heavier payoff lives downstream, in the conversation that follows between Max and Chloe and the choice that closes the game. The wall was a conclusion to Life is Strange: Reunion — not a conclusion to the relationship between Max and Chloe. What it needed to be was a space that remembered what the player had been through and reflected it back to them without ceremony.
