This is the source repo for the book Game Programming Patterns

This phrase in the "A pallet for your CPU" section is not technically right. The main reason for the access speed improvement is the different memory type used for caches. Even every cache may have a different architecture that lower the cost but increase the access time. I apologize about my english.

Hello. It's clear that the book's source-code is made available gratis here on GitHub, but what is its license, exactly? What am I allowed to do with this source-code, besides read it? If I make modifications to it, am I allowed to publish on my own website? Am I allowed to publish a PDF of your book I prepared myself, or of modified copies?

Please specify a license on the project root. Free documentation licenses are contracts upon which communities can build, deprecating trust. Have you considered the GFDL or something else?

I could help you choose a license, if you want.

Hello, I apologize if it's a stupid question. I learned to code on my own, for years I have coded on my own and I never read about common solutions or patterns. Because of that, my brain works in strange ways to solve problems and usually I can't understand what to other people it's common knowledge or darn obvious.

For what I read, Command and Observer patterns serve the same propose: something happens -> inform/react Both act as a way of decoupling code that isn't directly related.

I don't understand when to use one or when to use the other. The best that I came up with, is that one is about what gets communicated and the other about how to communicate it.

To me the Command pattern looks like an Observer pattern where the subject has only one observer and a complex data.

Some light over the topic will be appreciated.

I don't pay for movies because I can't get them for free online, I pay for them because it's the right thing to do. Similarly, I very much appreciate you posting the complete text of your book online but feel like you should still have a "buy now" button or "become a registered supporter" button. And don't leave an empty box with a "donate what you feel like" option. Have some balls and pick a number of how much you think people should be paying you for being able to read your book. (I'm thinking $10 or $20) Still worth keeping it online but for those of us who can afford it we need to be giving you something.

Oh, and your book is awesome, but you (should) already know that.

In this chapter, methods that override virtual method don't use the virtual keyword. However, if I recall correctly, the code snippets from other chapters do.

Edit: Referring specifically to the Dragon and Troll classes.

Hi, Bob, everyone :] This book is very useful to me, and I wana say: Thank you! I have a plan now: I am going to translate this book into Chinese. By the way, has this book been finished? From the commit history, I see there are almost small fixes such as typo, spelling etc recently. Looking forward to your reply :+1:

In this section and the previous we have three examples:

For all of these examples we have a series of Comedians who are stored in an array and then updated in sequence. Additionally, each Comedian's behavior is dependent on what other Comedians have done within a single update.

With the first example we have no incorrect behavior because the scene is set up so that the Comedians are dependent on other Comedians whose update methods have already executed. You provide a demonstration of the propagation of the slaps as follows:

Harry -> Baldy -> Chump -> Harry

In the second example you reverse the dependencies of the Comedians. Comedians are now dependent on the Comedian's whose update methods execute after their own. As you state in the section, this causes an error. Your demonstration in this example is as follows:

Harry -- Baldy <- Chump -- Harry

Clearly the slap did not fully propagate and only Baldy was able to receive a slap.

In the next section, Buggered Slaps, you provide a third example which I believe does not work. All of the Comedians get two slapped_ which are swapped after states and, as you state in the section, "The end result of this is that an actor will only see a slap in the frame after it was actually slapped." I agree with your statement but the behavior is still incorrect.

Your statment leads the reader to believe that we would now see this:

Harry <- Baldy <- Chump <- Harry

But I believe that the execution of the code would actually cause this:

Harry -- Baldy <- Chump -- Harry

Within a single frame, the slap still won't propagate to Harry. This is because Baldy still has no knowledge that he was slapped until his Swap() is executed.

I can elaborate a little bit further if you wish.

This pull request includes:

• Proofreading edits to the Type Object chapter
• A few minor fixes to the Introduction and Double Buffer chapters to move punctuation that appeared inside quotation marks outside of the quotation marks (unless it was part of the quoted matter) in other chapters
• An update to the style guide to define the quote/punctuation convention

I see this in the discussion of singletons so often that I was surprised not to find the mention of it in the chapter. Unlike other proposed alternatives, it even makes writing tests and mocking up environments for them almost trivial.

I think this book is great, I'm enjoying reading it, congratulations both on writing it and all all the work you've done to get to the point where you could write it, it's good.

I've got no reason to think you're sexist, in fact quite the opposite, you come across in your writing as a thoughtful humble person - but the phrase 'giddy as a schoolgirl' is sexist. I guess it is one of those patterns, familiar, right there ready to be used like - singleton - but if I had somehow managed to write this great book, and I think I'd edit this phrase out.

I'm not certain if you would create a "mutex / lock / monitor" chapter (as that is more in vein with your current naming schema - one chapter per pattern) or if you would consider a chapter of common issues encountered by programmers, however I feel like race conditions are a common enough issue in normal code (and even more-so in video gaming) that it would be helpful to cover common solutions.

Examples:

• User enters a new location during auto-save
• User and enemy attempt to access the audio driver simultaneously
• User levels up while a spell is in flight

There's a number of different conditions where ensuring one bit of code executes before another can make a huge difference - and more importantly there are plenty of examples where one bit of code executing before another can completely crash or deadlock your program.

Consider the dining philosopher's problem

I just noticed some of the links to GoF patterns are now broken (the curse of the internet), e.g., the Interpreter pattern link here.

Not a big deal since one can now easily Google them, but probably quite easy to fix too.

Hi. This PR:

• adds a small button on top of every page. This small button is responsible for toggling between dark and light themes.
• persists the user's current choice in the local storage, so the latest selection is persistent across page refreshes and navigations.
• implements a (n almost) well-looking dark theme.
• fixes two minor bugs in script.js.
• reads changes from the user's preferences to enable dark or light themes based on the user's system preferences.

TODO:

• Improve the structure of the asset/dark-styles.scss file to use meaningful variables and better order of styles.
• Maybe better icons for light and dark themes.

ONLINE DEMO

https://aghardeshir.github.io/game-programming-patterns/html/command.html

VIDEO DEMO

dark-theme-for-game-programming-patterns.webm

VIDEO DEMO FOR READING THEME FROM SYSTEM SETTINGS

dark-theme-from-system.webm

I try to wrap my head around the final code example on the page on game loops:

double previous = getCurrentTime();
double lag = 0.0;
while (true)
{
  double current = getCurrentTime();
  double elapsed = current - previous;
  previous = current;
  lag += elapsed;

  processInput();

  while (lag >= MS_PER_UPDATE)
  {
    update();
    lag -= MS_PER_UPDATE;
  }

  render();
}

In the text it says:

We then have an inner loop to update the game, one fixed step at a time, until it’s caught up.

I fail to see any fixed time step here. How often update() is called is only limited by how fast the underlying machine is. So a faster machine will give more updates than a slower machine. This throws us back to non-deterministic behavior as described a chapter before.

It also doesn't match with the diagram, where there's a clock above the update() box:

According to this image I would expect a call to sleep() in the inner loop. Could it be missing?

This may be a newbie question but it is unclear to me how to save data when using a component pattern. For example say I have a Room class with max 5 random monsters that all inherit from the Monster class. If I don't use inheritance how can I save the data of these monsters without knowing the info at runtime? My room might spawn 5 Tree monsters, or 2 snakes and 3 blobs or something else.. What kind of pointer do I use (I can't use Monster * monster[ 5 ] in the Room class anymore... I also asked this on stack overflow https://stackoverflow.com/questions/71280409/how-to-save-c-class-data-from-a-template-when-using-component-pattern