Hi

Basically I don't understand enumerations at all, and I want to make an array of key press enums.

Firstly, how would I declare this array?

Secondly, any recommended reading for enumerations for newbies?

Thanks

I havent got to learning those yet but I was given this link and it looks strait forward. I just dont need them atm to learn it.

http://enel.ucalgary.ca/People/Norman/enel315_winter1997/enum_types/

Can you describe what you want them for? Making a set of enumeration instead of just using Allegro's predefined KEY_ macros my not be necessary.

I want to add a layer between the keyboard presses and the key[KEY_BLAH] stuff so that I can very quickly change controls in 1 header rather than mess around with various classes.

This is what I'm attempting:

Well in that case, you don't need an array:

typedef enum { IN_UP = KEY_W, IN_DOWN = KEY_S, IN_LEFT = KEY_D, IN_RIGHT = KEY_D } KeyDefs;

bool inKey(KeyDefs keyPressed) {
  if(key[keyPressed]) return true;
  return false;
}

You do want the array if you want to change the mapping at runtime though.

As Tom said, I want to be able to change it at runtime.

That contradicts what you said earlier.

Doing it at runtime, I wouldn't use an enumeration at all. Just read in the value the user wants to use for each, and store that in the applicable array offset.

That's what I'm trying to do. The only reason I mentioned enums at all is because I looked at keyboard.h and found the KEY_ stuff stored as enums.

My problem is that

int inkeys[x] = {KEY_W, KEY_A,. . .};

Is not correct as the keys are not integers. How should I declare this array?

Use the scancode value.

They are integers though. It'll be fine. Just use an int array.

I thought C++ didn't allow you to use them interchangeably, or is it just that you're not allowed to use ints where it's expecting an enum?

I can't ever remember the exact rules. Most of the time I never actually use the enum type itself, and just use ints where I'm going to use the enum values.

I looked it up^[1]. You can use the enum value in place of an int, but not the other way around. So in this case, an int array with enum values will be fine.

The array offset is what you would enumerate.

(Note: the above is for demonstration purposes only. I would discourage a global.)

And for the record, an int can be cast to an enum type. Then again, you might be just as well declaring the game keys as separate ints since there doesn't seem to be any advantage to the array... At least none that springs to mind right now. I would certainly store them in a struct or class though.

C++ distinguishes 3 kinds of casts:
- widening casts, where a value is cast to a more general type (e.g. a char to an int, or an object to one of its superclasses, like std::cin to a std::istream). If the new type can represent every value that the old type can represent, then it's a widening cast. Widening casts may be performed implicitly.
- narrowing casts, the opposite of a widening cast. Because there is a possible loss of precision, or an incorrect pointer may be generated, C++ mandates that narrowing casts be explicit.
- invalid casts, where you try to cast to a completely incompatible type

Casting from an enum to int is widening, and thus allowed to be done implicitly. Casting from int to enum is narrowing, and must be done explicitly (keeping in mind that the cast may fail).