Tapped

This is one of the biggest problem with component systems, how the components communicate when they don't know about each other.

This problem is often resolved with an internal message system. Unfortunately it does not work well for all cases.

 

A solution for the health problem, can be that all objects that wants collision information sends a reference to a collision data structure, which is part of the entity, to the physic system.
Then the physic system, fill collision data for entities with collision data.

Now you can just check this collision information in each update, and call the sound and health system.
The problem with this solution, is that some entities may want more information about the collision than others, so unused information may be stored.
Hence, this breaks the idea of component based design. 

 

Another solution is to make a query based physic system. Where entities can query for collision information. You can then solve the problem with unused information by creating different types of queries. The query system can also be used for ray tracing etc.

 

Both solutions require update functions, so if you want a very strict implementation of ECS these solutions is not appropriate.

There are two approaches you can choose between. Both of them needs to be done in the design phase of your project.

 

The first one is to make a plugin based system, using DLL's(dynamic link library) on Windows, or shared libraries on UNIX platform.
You start of creating an executable core, with the engine and other things you don't want a modder to have access to.

However keep in mind what you want the modder to have access to, and export these functions.
Now you can choose to make the game as a mod, or create the game explicit in the executable.
The first approach is the easiest way, and used by Valve for example.

 

The second approach is to give the modder a scripting language, which is linked with some of the functions in your game.

This can easily be done with Python, or Lua. Most games made to day have scripting support, used during the development cycle.
Unreal Tournament uses this approach for example.

When it comes to assets, you need to have a copyright license. The copyright license must be there even if you don't make the game moddable.
However most games use compiled assets, which often are hard to edit or use. This way the modders can only use your assets in your game, but can't edit them.
You should also ship the tools used for compiling assets, so that the modders can create their own assets.

I will show you how i do it.

• First create a project, where "Create directory for solution" is ticked. 
• Then remove the project from the solution, by right clicking in the Solution Explorer on the project.(It will not delete the project, only lose reference to it)
• Now create a new directory for the project file, and call it what you want.
• Copy the project files from the directory storing the project into your new folder.
• Back in Visual Studio, add the existing project to the solution file, by File->Add->Existing Project.
• Now you probably want to define the binary output folder.
• This is done in the project properties. General tab->Output Directory. Remember to set both Debug and Release.
• Also, set the path for your source folder, when you create new source files. This is done with the Location property in the add file window.
• Git got a handy setting file called .gitignore. Use this file to ignore binaries, objects, and other temporary data generated by visual studio.
• I often use the following ignore file, with some customization for Visual Studio: https://github.com/github/gitignore/blob/master/VisualStudio.gitignore

 

That's it, customize as much as you want

Why not make an event structure like following:

public struct Event_t
{
char eventType;//Byte alignment error, for more memory efficient storage, should this byte be the last element of the struct!
int eventDuration;
short eventSize;
}

Event duration is the time from this event to next event. The event duration can be zero, which means that the event would be processed simultaneously with the next event. The event size are the number of bytes of the event(can be discarded if the size of the types of events are static). From here you can make different Event types. For example:

public struct EventMessage_t
{
int nMessageLength;
string szMessage;
}

After you have loaded the level. You can derive the event structs from a base event struct. Then you can make an array of base event structs, which you can easily process, by casting the base struct to the right event type structure.

Now i have implemented the information i got from: http://gamedev.stack...le-perlin-noise
Even if i did that, i still had cracks, but then after a lot of testing of different sample types, i finally got it work. It worked when i used this sampler:

__constant sampler_t randomVolumeSampler = CLK_NORMALIZED_COORDS_TRUE | CLK_ADDRESS_MIRRORED_REPEAT | CLK_FILTER_LINEAR;


float4 realGridPos;
realGridPos.x = gridPos.x * voxelSize;
realGridPos.y = gridPos.y * voxelSize;
realGridPos.z = gridPos.z * voxelSize;

density.x += read_imagef(randomVolume, randomVolumeSampler, realGridPos).x * 0.8f;

realGridPos is the same as the local position in terms of a block, which in this case range from [0.0, 2.0] for each block.
Here is the result:

http://imageshack.us...383/itworks.png
Thanks for the help!

Problem with a sphere is that it only haves 1 degree of freedom. You can only xhoose one size for every axe. So if one bounding box axe is slightly bigger the sphere would have more free space because the biggest axe would make the sphere. But on the picture is looks like the box is not in centre of sphere, that's maybe the problem.
And also you are generatimg the sphere wrong. The radius is the biggest axe extent.