Universal Behavior Setting

long ExtObject::GetData(int id, void* param)
{
   int param1;
   string param2;

   switch (id)
   {
      case 1:
      {
         param1 = (int)param;
         return 0;
         break;
      }

      case 2:
      {
         param2 = (string)param;
         return 0;
         break;
      }
      case 3:
      {
         return param1 + param2;
         break;
      }
}[/code:1pl9i59i]

btw, if you're on right now, you should go to chat
we can be plugin code buddies

edit:: and if it's not top secret, may I ask what type of plugin you're developing?

long ExtObject::GetData(int id, void* param)
{
	switch (id)
	{
		case 1:
			return MASS;
	}
	return 0;
}[/code:vw3xcad2]
This is where I try and retrieve something:

[code:vw3xcad2]stuff += (*i)->GetData(1, (float)param);[/code:vw3xcad2]
Thing is, it throws a fit about how "param" is undeclared, and how it can't convert from "void *" to "float" and stuff.  I'm not exactly sure what you were getting out, so I'm getting kind of confused here.

The plugin I'm working on is a gravitation behavior.  You put it on objects and you can set weather objects are attractors and/or satellites.  Kind of like a much more advanced version of my orbiter behavior.

long ExtObject::GetData(int id, void* param)
{
	switch (id)
	{
		case 1:
			return MASS+(int*)param;// for instance, 
	}
	return 0;
}[/code:2tctjxno]
This is where you would retrieve something:

[code:2tctjxno]stuff += (*i)->GetData(1, *MyInt);[/code:2tctjxno]

I may have messed up the asterisks in the return MASS line in order for it to add correctly
I'm pretty new to pointer notation, but the basic idea is
that void* is a pointer to [i]something[/i]
you have to cast it so it knows what it is
this way, you can make param any type you want

long ExtObject::GetData(int id, void* param)
{
	//this would just return the second parameter as an integer....sorry no asterisk needed
	return (int)param;
}[/code:2x70bejr]

sorry, you don't need any asterisks there, I just compiled an example to make sure this works

[code:2x70bejr]int* MyIntPointer;  // a pointer to an integer

YourObject->CallFunction(1,MyIntPointer);[/code:2x70bejr]

not sure if it was my confusion that confused you, 
or if you're not clear on pointers themselves

but the way they work is like so:

int* MyIntPointer; // a pointer to an integer, holds the memory address of an integer
int MyInt; // I'm pretty sure you know what this is   

MyIntPointer = &MyInt   // Now MyIntPointer points to the Address of MyInt(& is the address of operator) 

[code:2x70bejr]MyInt = 3;[/code:2x70bejr]

now

*MyIntPointer  is equal to 3
if I say
[code:2x70bejr]*MyIntPointer = 5;[/code:2x70bejr]
then 
MyInt is now equal to 5

the asterisk before a pointer is called the dereference operator, and makes it so you're basically operating directly on the thing pointed to

MyIntPointer without the asterisk, is still equal to &MyInt

hope this made some sense
Edit:: if you read this before my last edit, read the first part again
it's (int)param, not int(param)

	int* MyIntPointer;
	int MyInt;
	MyIntPointer = &MyInt;
	MyInt = 5;
	stuff = (*i)->GetData(1, MyIntPointer);[/code:jwg63bgz]
The code I put in the GetData() function is the same as what you have.

Shouldn't what I have above return 5?  I'm using a Construct expression to access the value of stuff, but it always comes back as a random value between 20 million and 25 million.

long ExtObject::GetData(int id, void* param)
{
	int* myint =(int*)param;
	return *myint;
}[/code:1nhqf3aj]

sorry for all the wrong answers 

and to be clear, this also works:
[code:1nhqf3aj]long ExtObject::GetData(int id, void* param)
{
	
	return *(int*)param;
}[/code:1nhqf3aj]

you are type casting the void pointer to a int pointer (      (int*)      )
then you are dereferencing this pointer to get the value of what it's pointing to

please post back to make sure this worked for you