This is something I never learned, when I studied C, so be patient with me. I'd like to make a type called ENEMY to create an enemy easily. Now I know I should make the type like this:

typedef struct ENEMY{
     int x,y;
     int state;
}

I could then create a enemy by ENEMY *enemy1; But how do I read and change the variables? Also, please correct me, if I said something stupid...

Or you can make function to do it:

ENEMY *create_enemy(int new_x, int new_y, int new_state)
{
  ENEMY *tmp = malloc(sizeof(struct ENEMY));
  tmp->x = new_x;
  tmp->y = new_y;
  tmp->state = new_state;

  return tmp;
}

ENEMY *enemy1 = create_enemy(100, 100, ENEMY_ALIVE);

You create a new type with the keyword typedef. You declare a new variable of some time on the fly with only the keyword struct:

typedef struct node_st {
    int data;
    struct node_st *next;
} node_t;

struct list_st {
    node_t *first;
    node_t *last;
} list;

/*  list is a variable, node_t is a type  */

Just a precision aboout one item:

typedef struct ENEMY
{
     int x,y;
     int state;
} ENEMY;

Kauhiz may not see it clearly why the word ENEMY appears twice.. in this precise case, the top one is unneeded. It's a kind of 'temporary' identifier, which is valid only until the struct is defined (until the } ENEMY; )
ReyBrujo shows one case where it's needed:

typedef struct node_st {
    int data;
    struct node_st *next;
} node_t;

This is a classic node element for a linked list of ints.
"next" is meant to be a pointer to a node_t, but the word "node_t" is not yet defined while the compiler parses the struct (it's farther down in the code) So you give a temporary name (node_st) at the beginning, and define "next" as a pointer to node_st.

If it's clear....

edit:
no CAPS? While learning C, I usually saw typedef structs in uppercase from books and sample code, though I cant really remember the origin... Well, it's a matter of norma. If you never succumb to the evil macros demons, uppercase is free for this use, right?

Allegro is code he can't influence. He can influence the code he writes, though

And I think that BITMAP and SAMPLE started as macros, which are the other case where you's ude ALL_CAPS.

EDIT:

Constants != macros.
While you can use the preprocessor for macros, it's better to use enums.

enum {
   I_AM_A_CONSTANT = 120,
   I_AM_A_CONSTANT_AS_WELL = 300
};

Maybe, but this is not the right place to discuss that. But I guess you could suggest this on [AD] or the allegro-development board of this forum.

How about

struct Enemy
{
  int x,y;     
  int state;
};

or is this pure C++?

I think this discussion is quite idle. I myself use ALL_CAPS for all types I define, and all_lowercase for instances. Since I work in C++ most of the time, this means that a class is in caps, and a class instance in lower case. I don't consider this "wrong" or "not done", but rather a convention, just as valid as others as long as you stick to it.
And, by the way, allegro is not the only API using it; the win api does pretty much the same thing, except for that evil Hungarian stuff. Anyway, as far as I'm concerned, I say let people name their identifiers the way they want to.
And X-G, please be so good and read the part of the allegro doc about "hacking allegro" or something like that. Shawn (I think it was him) defined the allegro code style there in detail, and AFAIK all the allegro code follows these rules neatly. Which means there is actually nothing to be fixed, unless by "fix" you mean "rewrite the library to fit your own coding style" (no offence pal).

And that 90% of people use a nomenclature, doesn't mean it's the good one

As long as you are coherent with your nomenclature, use whatever you want. Like if you want to use MiXeD cAsE, but do it in all your code (then you'll find that mixed case is not very optimal;)).

In C I use usually use capitalization in my projects for structs, like Enemy. This leaves me the enemy word free for other usage

No, but it's self-consistent and consistent with how it was done, so there's really no good reason to use anything else for no added benefit. The style with UPPERCASE_MACROS_WITH_UNDERSCORES is universally recognizable.

Yes, Allegro uses it, but that's what we're discussing so you can't exactly use it as an example, heh. As for libc...

Yes, FILE is uppercase, and I don't know why. I can't find any other libc typedefs that are: time_t, size_t, sockaddr etc are all lowercase. Then again I'm not looking that closely. Feel free to prove me wrong.

Of course neither way is "wrong" in the strictest sense. I just believe, and so does many, many others (the majority, I wager), that sticking to conventions like UPPERCASE_MACROS is a good idea for code legibility. I think that should be encouraged.

And I'd write it as it is now, but with eight real spaces instead of one tab as Allegro's code uses.

Personally, I use uppercase names for defines and typedefs. I think that's how it was done in the book I read for the C programming course I followed. I like it.