• Advertisement

Execution: Backstory revelation

Recommended Posts

Hey guys. Need advice on a matter thats been baffling me.

I have a main story. Made in proper context and all. I have two characters who generally have an uneasy past that will be presented in the form of flashbacks and argumentative conversations in cutscenes. The story has many secrets behind the becoming of the second character because they play the villain, but in a sense where they are misunderstood  (Like Sylar on Heroes). I was wonder how I could incorporate this secondary characters life story after their separation with the first character.......should I make a interactive flashback where the player can see things through the secondary characters eyes so that his actions can be justified through what he went through  (i.e. Call of Duty Ghost. The fathers flashback to why Rorke is hunting ghosts) or should I got with the more subtle approach, presenting it as a prologue that shows the past, then works through present day.

Any other approaches would be highly appreciated:D

Share this post


Link to post
Share on other sites
Advertisement
Posted (edited)

I like both approaches. However, with the first one, by having the player see through said secondary character , then switching back to the actual player character, can be jarring and confusing. If you start with the main character, you establish who the game is mostly played by. Later on you can switch characters to show stuff. I'm thinking of that exact idea in my game story. Jotted it down to consider later.

Now your second idea seems as the more conventional route, which isn't necessarily bad. If you show a past tense cinematic, you establish the two characters and perhaps the beginnings of their differences. It makes the player understand that you have these two characters at odds early on. What I see problematic is that outside that conflict there isn't much else about these two. You can explore that later on through the first idea. 

What is your idea, or ideas, for the background lore? Will the player watch cinematics explaining it, or will they find in game stuff related to it? Also, do you want your villain established right off the bat, or do you want the player to learn about said villain as the story progresses and characters are introduced? You might do some foreshadowing first, showing a relationship between the characters, then gradually the other character turns bad? Or maybe that's nothing close to your plan. It might be better to focus on your protagonist first, show the player why we need to care about them and enjoy playing as them, before you bring up a bad guy. Of course not all game stories need to show certain characters this way.

This help any?

Edited by Matthew Birdzell

Share this post


Link to post
Share on other sites

Loads of helpxD. The thing is, my idea is based on the betrayal of one brother to the other. The other moves on with their lives thinking their sibling is dead, but in actual fact is just living off 6 years of his life as a small time theif at a distant county. I was thinking player starts the game playing as the protagonist detective trying to solve a string of well planned crimes, then when the antagonist is discovered, it turns out to be the brother. From there onwards the story continues with the detective as a captive in a disclosed location, and the theif becomes the detective, solving crimes and stuff. The twist to the story would be that the goody two shoes detective is actually the antagonist and the criminal is the protagonist, just wronged to many times to give a sh*# about morals. 

So with that I've been trying to find a never been attempted approach towards presenting backstories. The story already had antagonists for the undercover antagonist/protagonist, my problem was showing players where the rivalry come from.

Advice was helpful too....thanks alot

Share this post


Link to post
Share on other sites
On 1/8/2018 at 3:03 PM, Savidge said:

Loads of help. The thing is, my idea is based on the betrayal of one brother to the other. The other moves on with their lives thinking their sibling is dead, but in actual fact is just living off 6 years of his life as a small time theif at a distant county. I was thinking player starts the game playing as the protagonist detective trying to solve a string of well planned crimes, then when the antagonist is discovered, it turns out to be the brother. From there onwards the story continues with the detective as a captive in a disclosed location, and the theif becomes the detective, solving crimes and stuff. The twist to the story would be that the goody two shoes detective is actually the antagonist and the criminal is the protagonist, just wronged to many times to give a sh*# about morals. 

So with that I've been trying to find a never been attempted approach towards presenting backstories. The story already had antagonists for the undercover antagonist/protagonist, my problem was showing players where the rivalry come from.

Advice was helpful too....thanks alot

So the confusion by the player could work in your favor by being intentional for a time? Hmm...sounds like it might work. At least establish a character to start playing as that makes the player think they're the protagonist. 

Share this post


Link to post
Share on other sites

This reminds me of a Kevin Kostner movie called "No Way Out" about a Russian Spy named Yuri.  You might watch that movie for some inspiration/ideas.  I haven't seen it in many years, but it has aspects too it that are similar to your story.

Share this post


Link to post
Share on other sites

I personally like the second idea better, but, it's your story. If anything, block out how both would look/work in the game, and then see which you feel resonates more.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now


  • Advertisement
  • Advertisement
  • Popular Tags

  • Advertisement
  • Popular Now

  • Similar Content

    • By GameDev.net
      This is an extract from Practical Game AI Programming from Packt. Click here to download the book for free!
      When humans play games – like chess, for example – they play differently every time. For a game developer this would be impossible to replicate. So, if writing an almost infinite number of possibilities isn’t a viable solution game developers have needed to think differently. That’s where AI comes in. But while AI might like a very new phenomenon in the wider public consciousness, it’s actually been part of the games industry for decades.
      Enemy AI in the 1970s
      Single-player games with AI enemies started to appear as early as the 1970s. Very quickly, many games were redefining the standards of what constitutes game AI. Some of those examples were released for arcade machines, such as Speed Race from Taito (a racing video game), or Qwak (a duck hunting game using a light gun), and Pursuit (an aircraft fighter) both from Atari. Other notable examples are the text-based games released for the first personal computers, such as Hunt the Wumpus and Star Trek, which also had AI enemies.
      What made those games so enjoyable was precisely that the AI enemies that didn't react like any others before them. This was because they had random elements mixed with the traditional stored patterns, creating games that felt unpredictable to play. However, that was only possible due to the incorporation of microprocessors that expanded the capabilities of a programmer at that time. Space Invaders brought the movement patterns and Galaxian improved and added more variety, making the AI even more complex. Pac-Man later on brought movement patterns to the maze genre – the AI design in Pac-Man was arguably as influential as the game itself.
      After that, Karate Champ introduced the first AI fighting character and Dragon Quest introduced the tactical system for the RPG genre. Over the years, the list of games that has used artificial intelligence to create unique game concepts has expanded. All of that has essentially come from a single question, how can we make a computer capable of beating a human in a game?
      All of the games mentioned used the same method for the AI called finite-state machine (FSM). Here, the programmer inputs all the behaviors that are necessary for the computer to challenge the player. The programmer defined exactly how the computer should behave on different occasions in order to move, avoid, attack, or perform any other behavior to challenge the player, and that method is used even in the latest big budget games.
      From simple to smart and human-like AI
      One of the greatest challenges when it comes to building intelligence into games is adapting the AI movement and behavior in relation to what the player is currently doing, or will do. This can become very complex if the programmer wants to extend the possibilities of the AI decisions.
      It's a huge task for the programmer because it's necessary to determine what the player can do and how the AI will react to each action of the player. That takes a lot of CPU power. To overcome that problem, programmers began to mix possibility maps with probabilities and perform other techniques that let the AI decide for itself how it should react according to the player's actions. These factors are important to be considered while developing an AI that elevates a games’ quality.
      Games continued to evolve and players became even more demanding. To deliver games that met player expectations, programmers had to write more states for each character, creating new in-game and more engaging enemies.
      Metal Gear Solid and the evolution of game AI
      You can start to see now how technological developments are closely connected to the development of new game genres. A great example is Metal Gear Solid; by implementing stealth elements, it moved beyond the traditional shooting genre. Of course, those elements couldn't be fully explored as Hideo Kojima probably intended because of the hardware limitations at the time. However, jumping forward from the third to the fifth generation of consoles, Konami and Hideo Kojima presented the same title, only with much greater complexity. Once the necessary computing power was there, the stage was set for Metal Gear Solid to redefine modern gaming.
      Visual and audio awareness
      One of the most important but often underrated elements in the development of Metal Gear Solid was the use of visual and audio awareness for the enemy AI. It was ultimately this feature that established the genre we know today as a stealth game. Yes, the game uses Path Finding and a FSM, features already established in the industry, but to create something new the developers took advantage of some of the most cutting-edge technological innovations. Of course the influence of these features today expands into a range of genres from sports to racing.
      After that huge step for game design, developers still faced other problems. Or, more specifically, these new possibilities brought even more problems. The AI still didn't react as a real person, and many other elements were required, to make the game feel more realistic.
      Sports games
      This is particularly true when we talk about sports games. After all, interaction with the player is not the only thing that we need to care about; most sports involve multiple players, all of whom need to be ‘realistic’ for a sports game to work well.
      With this problem in mind, developers started to improve the individual behaviors of each character, not only for the AI that was playing against the player but also for the AI that was playing alongside them. Once again, Finite State Machines made up a crucial part of Artificial Intelligence, but the decisive element that helped to cultivate greater realism in the sports genre was anticipation and awareness. The computer needed to calculate, for example, what the player was doing, where the ball was going, all while making the ‘team’ work together with some semblance of tactical alignment. By combining the new features used in the stealth games with a vast number of characters on the same screen, it was possible to develop a significant level of realism in sports games. This is a good example of how the same technologies allow for development across very different types of games.
      How AI enables a more immersive gaming experience
      A final useful example of how game realism depends on great AI is F.E.A.R., developed by Monolith Productions. What made this game so special in terms of Artificial Intelligence was the dialog between enemy characters. While this wasn’t strictly a technological improvement, it was something that helped to showcase all of the development work that was built into the characters' AI. This is crucial because if the AI doesn't say it, it didn't happen.
      Ultimately, this is about taking a further step towards enhanced realism. In the case of F.E.A.R., the dialog transforms how you would see in-game characters. When the AI detects the player for the first time, it shouts that it found the player; when the AI loses sight of the player, it expresses just that. When a group of (AI generated) characters are trying to ambush the player, they talk about it. The game, then, almost seems to be plotting against the person playing it. This is essential because it brings a whole new dimension to gaming. Ultimately, it opens up possibilities for much richer storytelling and complex gameplay, which all of us – as gamers – have come to expect today.
       
    • By tgobbens
      Introduction 
      The architecture of software design is a much-debated subject. Every developer has his own opinion about what is good software design and what is not. Most developers agree on what is bad design, on what is good design there are a wide variety of opinions. Unfortunately, due to the nature of software development, there is no silver bullet; there is no one design strategy that always works.
      There are a couple of strategies that have proofed to be successful. These strategies have known strengths and weaknesses. The advantage of using such a strategy is allowing you to focus on building your game, instead of worrying if your codebase will implode after someone decided the game should function a bit different than how the code was originally written.
      Architecture
      In game development, the entity-component-system is an architectural pattern that is used successfully in small, medium and large games. The main strength of this strategy is the usage of the composition over inheritance pattern. This pattern prevents the build-up of complex object inheritance tree’s, that will make your code impossible to refactor without a lot of side-effects.
      So how does this pattern work, at its core, there are three elements; entity, components, and systems guess you didn’t see that coming. Let’s describe these one by one, I’m starting with the smallest and most simple one the “component”:
      Component
       The component represents a single attribute of an entity. Some examples of entities can be:
      Position Rotation Scale Physics body Texture Health Entity
       Entities are the “game-object” some examples:
      Ball Camera Player Enemy Bullet An entity can have multiple components, for example, a ball entity can have the following components: position, rotation, scale, texture and physics body. A camera entity might only have a position. Usually, all entities have a unique-id for fast access, but there can also be other ways of accessing entities.
      System
      The system is responsible for one aspect of the game, a simple game has can, for example, have the following systems:
      Rendering Physics GUI Sound AI What a system does is iterating over all entities that have components of the types defined by the system. For example, the physics system will act only on entities with a physics-component and a position-component. The rendering system will only act on entities that have a position and texture component. 
      For example, if a ball entity has a position and physics and texture component. The physics system will pick up the ball entity, as it has a physics and position component. The physics-system control a physics-engine, that will do its magic and calculate a new position for the ball. The physics system will set this new position on the position component.
      The rendering-system will also pick up the ball entity, as it acts on all entities that have a position and a texture component. The rendering system can render the ball using the texture and the position found with the ball entity (yes, the same component that was just updated by the physics-system).
      Now imagine you spend some time implementing the architecture described above, and you after, running it, realize the ball is not really moving very realistic. That might be because you forgot to take rotation into account.
      To fix it you now only have to create a rotation-component and add it to the ball entity. Now add in the physics system a check if the entity has a rotation component and if so just set the rotation on this component. In the rendering-system also add some code to check if there is a rotation component and if so render with this rotation.
      This is where the power of this architecture emerges, imagine you have not one ball entity but have a lot of entities like the ball, wall, player, ground, etc. and you forgot about the rotation. You only have to modify the rendering system and the physics system. Then by simple adding a rotation component to the entities you want to have rotation on, magically all those objects have a rotation. Now adding rotation seems like a trivial thing to do, but what does this architecture enforces is the separation of concerns (e.g. rendering and physics) while still allows adding new functionality. And important; It does this without the usage of inheritance but rather by composition.
      Possible features
      The architecture described above is in itself quite powerful. But there are some more interesting possibilities with this architecture. I will describe some of them below.
      Game-mechanic tweaking
      Creating a generic mechanic-tuning-utilities; as there are a limit number of component types, you can create a (developer) GUI-overlay that allows you to modify the values of a component. This will allow you to in real-time modify the values, e.g. the position, size, texture, acceleration, the weight of a certain entity his components. This will help you tremendously in fine-tuning game mechanics without the need to keep recompiling and reloading your game.
      Level-editor
      Taking this even a step further you could use the above system to load all entities and relevant components from a file, e.g. XML. This will also help you decrease compile and loading time, letting you focus more one tuning game mechanics. This could then be a very good start for creating a level-editor, letting a none technical team member (game-designers) tweak game mechanics.
      Dynamic loading
      Something else that can be managed using this system, is implementing an entity loading/unloading mechanism. You can define an interface with functions like initializing, loading, starting, stopping, unloading, destructing. Now you can implement a loading mechanism that guarantees the loading and initializing always happen asynchronously. This will allow you to load and unload entities in a uniform and controlled manner. You could also choose to run all the systems in a different thread you need to take some more care about modifying components, but this could allow you to do a lot of performance enhancements, as for example, the AI needs less frequent updates then a renderer.
      Real-world example
      Note this implementation is done in Java, as I’m using libGDX as the platform, but the architecture is certainly not limited to Java and can also be implemented in other languages like C++.
      Enough of the theory, now for a real implementation. As a hobby project, I have been creating a small iOS/Android game, my first implementation of this game was naïve, with one source file containing all logic. No need to explain this is a bad implementation, but this did allow me to check if my idea was fun and create a quick prototype and do some fast iterations from there.
      For reference, the “bad” implementation can still be found here:  https://github.com/tgobbens/fluffybalance/blob/master/core/src/com/balanceball/Balanceball.java  
      After I created this implementation I decided I wanted to implement the same game using a better manageable implementation.
      The “main” entry file can be found here: https://github.com/tgobbens/fluffybalance/blob/master/core/src/com/balanceball/BalanceBallSec.java.
      So, I’ve created my own entity-component-system. If you want to create your own game using an entity-component-system, and want the game to be ready as soon as possible then I wouldn’t recommend writing one yourself. However, if you want to learn about programming or just create something for fun, implementing such a system is easy, and you will learn a lot from doing this. Another reason to implement this yourself is you get a lot of freedom allowing you to add specific tricks and features that can help you improve your codebase.
      The entity component system can be found under https://github.com/tgobbens/fluffybalance/tree/master/core/src/com/sec and yes there are some optimisation and improvements opportunities in this code base. But it does show an easy to understand implementation. When trying to understand make sure you know what Java generic types are. It’s quite common you need to find a certain entity to update or get some info from. As there are a lot of components you know there will be only one instance from. I’ve added a method to get the first entity of a certain type. For example, give me the camera entity, or give me the first “game-world” entity. But there are also helper functions to get all entities of a certain type. The same trick is used for getting components of an entity.
      You will also find a basic type called “engine”, used for binding everything together. This will trigger the updates and holding references to all systems and entities. If you look for a “starting” point for the architecture this is where to start looking.
    • By 123iamking
      Let me explain why I call it: 3rd person camera-based movement (honestly, I don't know if that's the official name)
      In GTA Vice city, you can see, when you turn the camera, the main character turns with the camera. When you press Back, the character walks backward, press Left, the character walks left-ward. I call this 3rd person character-based movement.
      In GTA SanAndreas (also GTA IV, GTA V, Sleeping Dogs, Prince of Persia,... ), when you turn the camera, the character won't turn, but the camera rotate orbit around the character, when you press Back, the character walks toward the camera, when you press Left, the character walk toward the left of the camera. So I call this 3rd person camera-based movement.
      So I see that 3rd person camera-based movement is pretty popular, I wonder if there is a good implement of 3rd person camera-based movement (that's from open-source, books, forums,... I tried searching but I haven't found any) so that I can learn from.
    • By Gabriel Gonzalez
      Hi everyone, my name is Gabriel and this is my first post here. I graduated from college over three years ago with a degree in Physics and now I want to start a career as a gameplay programmer. Besides a single C++ programming class in college I have not had any prior experience programming. What I have done to learn until now is to use SFML to recreate Arkanoid and Space Invaders. My question is, am I on the right track if I just continue creating games from scratch using libraries such as SFML or would I benefit more if I move on to using an engine such as Unreal or Unity? Also, of how much help (if any) would my degree be when trying to join a team? I live in San Diego, CA if that matters at all.   I do appreciate in advance any guidance anyone could offer me.
    • By MidnightFoxGaming
      Hi, I’m starting out in game development as a whole and while I have some experience with programming in the past with small things like mods and a single byond game that I took over for a previous person I’m rather new to the start from the ground up thing.
      im looking to get some advice on where to start for tools/material/resources for such. I already have the core concept for the game hashed out, this has been a relitivly solo thing so far so any help is appreciated thank you.
  • Advertisement