Cue introduction

Reading over the code, it occurs to me that this may come in handy for inspiration.

Some noteworthy bits:

• The command pattern will come in handy once we gear up for more advanced AI -- especially since we want to be able to assume control of organisms whenever we like.
  
• Flyweight might be useful once we're pushing hundreds of creatures to the GPU at a time -- though Ogre might handle instanced rendering, I'm not sure.
  
• Component is part of the Ogre way of doing things (or so I've heard :P), and I'm guessing we use it, but I'm not too sure how much.
  

If we've already discussed this sort of high-level architecture somewhere, does anyone have pointers to threads I can read?

Quote :

The command pattern

I'll have to read it thoroughly later, but it seems overly complicated for problems with seemingly trivial solutions. I'm not claiming that I know better than the author but I personally don't see the benefit in this specific pattern

Quote :

Flyweight

Sounds worthwhile to keep in mind, but I don't think its a good idea to mess with the rendering pipeline that ogre controls before we have a problem that we can't solve in other ways.

Quote :

Component

This is indeed what we are using, specifically the version called Artemis entity system framework. We use it for almost everything!

Quote :

does anyone have pointers to threads I can read?

We don't have a specialized architecture thread, but that might be a good idea!

crovea wrote:

I'll have to read it thoroughly later, but it seems overly complicated for problems with seemingly trivial solutions.

The trick is that the trivial solutions result in high coupling between commanders and commanded. As the link explains, the command pattern decouples the senders and receivers of orders. This decoupling is especially important for us, as we want to be able to plop the player in control of an organism that was until then taking its orders from something else. Until recently, actually, I didn't know this pattern had a name, and thought I'd independently invented it. From my experience, it's really useful.


Anyway, I was reading a paper at work today, and I thought it would be useful for fast, cheap microbe softness -- note though, that since we're storing position and orientation per-microbe, that there's no need to do the complicated shape-matching step; but just restitute each displaced point and apply corresponding forces to the center of the microbe.

crovea wrote:

We don't have a specialized architecture thread, but that might be a good idea!

As I have limited coding knowledge, this is a shot in the dark, but does this thread cover what you mean?

https://thrivegame.canadaboard.net/t1117-engine-architecture

Quote :

does this thread cover what you mean?

Yes it does Somehow forgot about it and missed it while looking for it

While I was at work I ran across some interesting papers. These won't be useful until much later, when we can afford to do interesting things with city development and infrastructure in Industrial Stage. Once we get there, however, I have big plans for making deep, beautiful cities.

And here's something cool talking about some state-of-the-art real-time raytracing, and hardware support that we could expect in a few years. If we ever need our own renderer that is

And here is a very comprehensive paper on position-based dynamics algorithms.

And another.

Changing it up a little, here we have a blog post detailing some great uses of github issues for project organization. Their tricks seem like they'll come in handy.


And here's a paper on the VDB, an amazingly-efficient datastructure for representing sparse volumetric data. It can store essentially infinitely large volumes, but the largest things I can see it being used for in Thrive are massive destructible asteroids and spaceships.

And here we have a good explanation of the Barnes-Hut algorithm, which could see lots of use in places like asteroid fields.

And then there's this book. It's pretty much the seminal book on the mathematics of plant structure, and should be a required read (for programmers at least) once we reach Organism Stage.

Here's a website that tracks libraries for API/ABI changes, listing backwards compatibility breaks. Very useful.

And changing it up a bunch, this thread is the home of a worldbuilding project, which, starting about 30 pages in, gets really detailed about placing tectonic plates, landforms, ocean currents, biomes, language groups, founder crops, civilization, and more.

In a few years we should probably sign up for GSoC. It'll be intense, certainly; but it would be a great step to take.

Here, some great stuff I've come across in a couple blogs today.

The GPU Gems series is full of great tidbits.

What every programmer should know about memory.

[url=http://nccastaff.bournemouth.ac.uk/jmacey/MastersProjects/MSc13/06/Jon Hudson Thesis.pdf]A pretty good paper on creature generation[/url].

Hofstede's cultural dimensions theory, a system for quantifying cultures along a bunch of different axes. Some parts will certainly need further generalization, but it's really eye-opening.

Someone must really remind me to reorganize this massive link mess.

OH look another link.