Sharing enumerations

[pkooman]

Hi,

I was wondering whether I could use an enumeration which is defined in another class. I want to define an item to pickup and use an enumeration to specify it:

class ItemPickup extends Pickup;

// Possible Items
enum ItemType {
    ItemA,
    ItemB
};

// Editable from Properties Screen
var () ItemType itemType;

defaultproperties {
    itemType=ItemA
    InventoryType=Game.Item
    DrawType=DT_StaticMesh
}

Now I'd like to use this enum in my inventory class, and be able to say:

class Item extends Inventory;

// Item type from ItemPickup
// ** DOES NOT COMPILE, but I'd like to do something like this. **
var ItemPickup.ItemType itemType;

function bool HandlePickupQuery( pickup Item ) {
        if ( class == item.InventoryType ) {                
                // Copy the value here.
		itemType = (ItemPickup(item).itemType);
		return true;				
	}

	return Inventory.HandlePickupQuery(Item);
}

But I can't come up with a way to 'share' the enum type. Has it something todo with .int and .ucl files maybe?

Thanks in advance.

 

[[SAS]Solid Snake]

You may have to put a DependsOn syntax. I've seen this type of ENum sharing used for xUtil.PlayerRecord. Thus something like this may do the trick:

class Item extends Inventory
  DependsOn(ItemPickup);

 

[pkooman]

Yes that works exactly like I had in mind. Great Thanks!.

 

[Hunz]

Hey, thats an extremely useful command - I thought this wouldnt be possible in UScript!
Thx SolidSnake!

 

[Mychaeel]

If that fails (which it occasionally does), you can always access any enum through a reference to an object of that class:

if (foo == MyItemPickup.ItemType.ItemA)
  ...

 

[[SAS]Solid Snake]

Yes indeed, I think DependsOn() only just makes sure that the class syntax is compiled before the script it resides in, thus making declarations like this possible. I am sure it has other uses, and was just an observation I noted down a while ago.

 

[Bonehed316]

enums are just a set of bytes with a friendly name, so you can really just create the exact enum in a different class, and they will work together without a problem. that is how enums can also work with certain operators.

 

[Mychaeel]

Then again, the idea of giving constants friendly names is that you can define them once and then forget about their values. If you ever change one of those enums whose clones you've scattered across several classes, you'll have the hell of a time debugging this.

 

[Bonehed316]

yep, very true. but some people dont care about that, lol.

 

[[SAS]Solid Snake]

It depends how far you go in terms of designing your code layout. I used to be the type that just coded whatever that came to my head, but after a while it became annoying form e having to go through a lot of my old code to clean it up or to rewrite it due to changing methods. Usually now I plan a lot of the methods I want to do things in and then code from there. But that of course makes me difficult when it comes to working with other coders.

 

[Techno JF]

Excellent information here. I may find this thread of use to me later.

I have a question for you, Solid Snake. Do you know if this DependsOn syntax works in version 436? Or do I have to write an orphaned function in the second class with a command to spawn an instance of the first class, in order to force UCC to compile the classes in the proper order?

 

[[SAS]Solid Snake]

version 436

I doubt it. I believe this was added in UE2.x and not UE1.x. I'm not exactly sure why or how UCC decides to compile a script before/after a class... but hacks like that may/may not work.

 

[BinarySystem]

UCC seems to be able to access members, etc. of other classes regardless of the order in which they are compiled, so long as they are in the same package. I've never had any issue with that. Also, you can have two classes that use dependson for each other - so I think dependson does something other than just tweak the order in which the classes in a package are compiled.

I think what you are looking for is "qualifying" an enum, as described in the Unrealscript language reference by Tim Sweeney.
http://unreal.epicgames.com/UnrealScript.htm

I think this information is on the wiki too, but I couldn't find it, so maybe it isn't.

 

[Techno JF]

Ah yes, it makes sense. From Actor.uc:

00113	// Scriptable.
00114	var       const LevelInfo Level;         // Level this actor is on.
00115	var transient const Level XLevel;        // Level object.
00116	var(Events) name		  Tag;			 // Actor's tag name.
00117	var(Events) name          Event;         // The event this actor causes.
00118	var Actor                 Target;        // Actor we're aiming at (other uses as well).
00119	var Pawn                  Instigator;    // Pawn responsible for damage.
00120	var(Sound) sound        AmbientSound;    // Ambient sound effect.
00121	var Inventory             Inventory;     // Inventory chain.
00122	var const Actor           Base;          // Moving brush actor we're standing on.
00123	var const PointRegion     Region;        // Region this actor is in.
00124	var(Movement)	name	  AttachTag;

This block of code contains pointers to LevelInfo, Pawn, and Inventory actors. All of these classes are also defined in Engine.u along with Actor, but Actor has to be compiled first because it's a superclass to all of them. On the other hand, these pointers still don't cause any errors as long as the classes they refer to don't exist in other packages.

 

[dataangel]

Can you declare enumerations as static?

 

[Bonehed316]

no, only functions can be declared as static.

 

[[SAS]Solid Snake]

Can you declare enumerations as static?

What exactly would be the point of that?

 

[Bonehed316]

i imagine he was trying to do something where he either didnt want the variables to change, or wanted the default value, both of which are possible through other methods.

 

[dataangel]

I meant declare enum's static -- as in static enumerated types, not individual instances of them. Peppers vs. pepper grinders

This way you could share an enumeration between classes, like asked for in the post.

 

[Hunz]

Here something I found today while surfing code (just an example):

var hudbase.escalemode blabla;

This variable-definition can be placed in any class, although the enumeration 'escalemode' is only defined in the class 'hudbase' looking like that:

enum EScaleMode
{
    SM_None,
    SM_Up,
    SM_Down,
    SM_Left,
    SM_Right
};

...looks pretty much like sharing (or at least borrowing) enumerations