Rick

I agree with Aggror, and that's why LE 3 should be created in such a way that these kind of things can be separate purchasable plugins just like that lighting module was. That would be ideal. lol what agreement did you "make" with LE when you bought it? There was nothing about the creators listening to their customers to implement the features they want. No engine agreement would say something like this. You bought the product as is, and at the mercy of the creator.

Where is the link to the most recent C# library?

http://leadwerks.com/werkspace/index.php?/topic/1491-getting-terrain/page__p__13869__hl__%2Bfind+%2Bterrain__fromsearch__1#entry13869

The way this is setup, each behavior is only created once for the entire game and all game objects that are connected to that behavior use just the one instance. So when it's a certain game objects turn to use a certain behavior, the previous parameters are cleared and that game objects parameters are filled in. That would be why I don't use the constructor. But I like the idea of using an array of parameters. I'll just make that passed to the function call operator. In this design you can think of behaviors are just a normal function. Like if this was normal C you'd just have normal functions that work on all the different game objects in your game. The reason I didn't make it a normal function is with polymorphism you can store all the different behaviors in a container and assign them a name. Create 1 of each at the beginning of the game dynamically from dll's (in C# anyway), so people can add their own behaviors dynamically. Then when the actual flow of game logic is read from xml files you can refer to behaviors via their string name. I've been playing around with Kismat a little and it seems the theme is that Events fire and run Actions that work on Game Objects. One of the cool things I like about Kismat is that these events have parameters that get filled in by the even caller and one can save off those parameters to variables to be used later in the flowgraph. That's pretty handy.

Seems to just be this site. Netflix isn't doing that or any other site that I've been to. Yeah, it's kind of strange. The progress bar on the bottom right never seems to fully complete either. Must be one of those reboot things I was just wondering if others were seeing the same thing or not.

My youth was console (we are talking the Nintendo's and Sega Genesis, and up to PS2. Once they started to cost what a cheap PC costs I stopped), the adult is PC. Character dialog was big, but I couldn't care about lip syncing, then or now. It's a nice to have, but not required to make good games. What is said in these dialogs is what's important. I'm hardly even looking at the characters in most games anyway. Mafia 2 wouldn't have been any less fun if their lips weren't moving. It's the storyline that people like, not if that characters lips are moving. It does help add to the realism, but these are games. We don't hardly even expect things to be real in them.

Just recently I notice this site (in firefox anyway, haven't tested anything else) always stays loading. The icon for this tab always has the moving loading icon and the status bar continues to say "Transferring data from leadwerks.com...". What gives?

When did games becomes movies? This trend needs to stop. When lip sync technology becomes that important for a game then we are all doomed. Lip sync has no affect on gameplay. I don't think I'd ever call it essential. I would put many things above lip sync features.

Just something I'm working on to try and make UI driven game logic. Very similar to the component stuff I was doing. Almost for my own documentation #include <map> #include <string> using namespace std; class AttributeType { public: AttributeType(){} }; template <class T> class Attribute : public AttributeType { private: T _data; public: Attribute(T data) { _data = data; } T GetValue() { return _data; } void SetValue(T value) { _data = value; } }; class GameObject { private: map<string, AttributeType*> _attributes; public: void AddAttribute(string name, AttributeType* att) { _attributes[name] = att; } template <typename T> T GetAttributeValue(string name) { return reinterpret_cast<Attribute<T>*>(_attributes[name])->GetValue(); } template <typename T> void SetAttributeValue(string name, T value) { reinterpret_cast<Attribute<T>*>(_attributes[name])->SetValue(value); } }; // the base class for all behaviors class Behavior { private: map<string, AttributeType*> _parameters; public: void ClearParameters() { _parameters.clear(); } template<typename T> void PushParameter(string name, T data) { _parameters[name] = new Attribute<T>(data); } template<typename T> T GetParameter(string name) { return reinterpret_cast<Attribute<T>*>(_parameters[name])->GetValue(); } virtual void operator()()=0; }; // this specific behavior reduces health of a game object class DoDamage : public Behavior { public: virtual void operator()() { // get the parameters (the names would be linked via xml/editor) GameObject* obj = GetParameter<GameObject*>("game.object"); int dmgAmount = GetParameter<int>("damage.amount"); // do the logic int health = obj->GetAttributeValue<int>("health"); health -= dmgAmount; obj->SetAttributeValue<int>("health", health); } }; // input parameter: modelFilename <string> the name of the model to load // output parameter: model <TEntity> stores the actual model class LoadModel : public Behavior { public: virtual void operator()() { } }; class TEntity { }; int main() { // everything is a GameObject object GameObject human; // all logic is a Behavior. we would create 1 type of each behavior and that would be used // everywhere it's needed Behavior* damage = new DoDamage(); // we can create/set custom data for any game object // this can be explained in xml human.AddAttribute("health", new Attribute<int>(100)); human.AddAttribute("name", new Attribute<string>("Rick")); human.AddAttribute("attack.power", new Attribute<float>(50.5f)); human.AddAttribute("model", new Attribute<string>("abstract::model.gmf")); // we can get these attributes float ap = human.GetAttributeValue<float>("attack.power"); int health = human.GetAttributeValue<int>("health"); // add parameters and call the DoDamage behavior damage->ClearParameters(); damage->PushParameter<GameObject*>("game.object", &human); damage->PushParameter<int>("damage.amount", 5); (*damage)(); health = human.GetAttributeValue<int>("health"); return 0; }

Everyone learns from mistakes, but if you relied on learning from mistakes to making an MMO (with 1-3 people) it would take you a few decades given that it's not your only thing you do in life. We are saying there is a faster more efficient way to learning. By starting smaller and building on it. As I said, this is why we don't teach calculus to first graders (BLaBZ being the exception. I guess he special or something.). You have to learn to crawl before you run.

I was just going to say that too Laurens, but for some reason if I click off the reply textbox it clears everything I typed. The fastest most efficient way to learn would be to start small and build on it. That's why kids in first grade aren't learning calculus.

A flowchart to code converter. After looking more into flow graphs, they are nice and all, but as a programmer flow charts seem more logical to me personally, and would still allow non coders to write code visually.

It would stop him from making an MMO because at 17 you have many other things going on that tend to take priority. If you really want to make an MMO around that age, once you are done with high school, don't go to college. Instead, work on your MMO, because you won't have time for both. But of course about .01% of the population who wants to make an MMO at age 17 will ever do that because it's not logical. When someone does that and it works we call them great, but for all the people who do that and it doesn't work we call them stupid. It's amazing how fine the line really is between great and stupid.

Lum, you are insane sometimes. Raknet can handle as much as your bandwidth and hardware setup can support. Why are you on this SDL kick the last month or so? I want to quote this, btw! It's good to high an ultimate goal, but I suggest you meet some smaller goals first. You can even do a smaller online game to get the idea down.

I'm going to go ahead and say unless one is using an engine designed for MMO's, that a 3 man team wouldn't be able to make an MMO. My advise would be to look for an engine geared towards MMO's. There are a few out there, but I think they aren't cheap.

I have to agree. Your first 50 projects shouldn't be an MMO

This is great news! LE3 is looking to be very powerful. About script callbacks, all I can say is make lots of them for many different events. Just because you might not be able to see why a specific event shouldn't have a callback doesn't mean someone else won't have a reason for it.

What are the skills in your clan?

Thanks Lum. I actually found one and here it is. I'm using this for my A* pathfinding with waypoints. It's supposed to make the A* algorithm much faster for a larger number of waypoints when used for the open list because you remove the need to search for the lowest f score because it'll always be the first element in the heap. You take a slight hit with insertion but it's still supposed to be much faster than using a normal array. #pragma once #include <vector> using namespace std; template <class Comparable> class BinaryHeap { public: explicit BinaryHeap( int capacity = 100 ) : array( capacity + 1 ), currentSize( 0 ) { } bool isEmpty( ) const { return currentSize == 0; } bool isFull( ) const { return currentSize == array.size( ) - 1; } const Comparable & findMin( ) const { //if( isEmpty( ) ) // throw Underflow( ); return array[ 1 ]; } void insert( const Comparable & x ) { //if( isFull( ) ) // throw Overflow( ); // Percolate up int hole = ++currentSize; for( ; hole > 1 && x < array[ hole / 2 ]; hole /= 2 ) array[ hole ] = array[ hole / 2 ]; array[ hole ] = x; } void deleteMin( ) { //if( isEmpty( ) ) // throw Underflow( ); array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); } void deleteMin( Comparable & minItem ) { //if( isEmpty( ) ) // throw Underflow( ); minItem = array[ 1 ]; array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); } void makeEmpty( ) { currentSize = 0; } private: int currentSize;// Number of elements in heap vector<Comparable> array; // The heap array void buildHeap( ) { for( int i = currentSize / 2; i > 0; i-- ) percolateDown( i ); } void percolateDown( int hole ) { /* 1*/ int child; /* 2*/ Comparable tmp = array[ hole ]; /* 3*/ for( ; hole * 2 <= currentSize; hole = child ) { /* 4*/ child = hole * 2; /* 5*/ if( child != currentSize && array[ child + 1 ] < array[ child ] ) /* 6*/ child++; /* 7*/ if( array[ child ] < tmp ) /* 8*/ array[ hole ] = array[ child ]; else /* 9*/ break; } /*10*/ array[ hole ] = tmp; } }; Usage: #include "BinaryHeap.h" int main() { BinaryHeap<int> heap(100); heap.insert(5); heap.insert(8); heap.insert(15); heap.insert(3); int a = 0; // delete min and return it to parameter. this returns 3 heap.deleteMin(a); // find the min. this returns 5 now because 3 was removed int b = heap.findMin(); return 0; }

AFAIK there is. You have to make it yourself. You can use a boolean for each mouse button (left/right) to do that. It's a pain I know. It would just be easier if LE did this. Unity does

Does anyone have a binary heap class or know where one is? I can't seem to find a "good" one.

Yeah it can convert different model formats for leadwerks model format (gmf). It does other stuff too. It's cheap and I use it all the time since I buy models. It's priceless in my mind.

I don't really know what that means though? It doesn't mean anything to me because I don't get why you have to do it in the first place. Is there examples as to why you have to do that and the issues it causes if you don't? Remember I'm a programmer and not an artist at all.

Can someone explain to me why this guy is drawing lines in his model in the video on their site? What does that do and why is it needed and/or a big deal?

Why would it be slow? What did the code look like?