'Structured' programming in Lite-C

typedef struct {

  var itemNumber;
  BMAP *image; //pointer to bitmap
  String *name; //pointer to string

} Item;


typedef struct {
  
  Item item1; //no pointer, actual object!
  Item item2;

} Inventory;


void main() {
  Inventory *inv; //pointer to inventory
  inv = malloc( sizeof( Inventory ) ); //assign a new inventory
  
  //first you do after allocating a new structure, is fill all its parameters!
  //Otherwise you can end up with some nasty unpredictable errors

  //fill item1
  //arrow (->) means you call from pointer "inv" to its member "item1"
  //point (.) means you call from object "item1" to its member "itemNumber" (or "image", "name")
  inv->item1.itemNumber=0;
  inv->item1.image = bmap_create("bla");
  inv->item1.name = "bitmap of item 1";

  //same for item2
  [...]

  //for the sake of this example, let's remove this inventory again
  free( inventory ); //remove the inventory (and automatically the items!)
  
}

//Item.c
typedef struct {

  int itemNumber;
  BMAP *image;
  String *name;

} Item;


//a function to visualize an item on a panel
void item_visualize( Inventory *inventory, Panel *panel ) {
  panel->bmap = inventory->image;
}


//Item creation function, returns pointer to the newly created Item
Item *item_create( int number, String *imageName ) {
  
  Item *item = malloc( sizeof( Item ) );
  
  //always fill ALL the item's properties immediately after!
  item->itemNumber = number;
  item->image = bmap_create( imageName );
  item->name = imageName;
  
  return item; //return the new item back
}


//function to remove an item
void item_remove( Item *item ) {
  ptr_remove( item->image ); //remove bitmap first
  ptr_remove( item->name ); //remove name
  free( item ); //THEN remove item
}

//Inventory.c
typedef struct {
  
  bool alive;

  Panel *panel;

  Item *item1;
  Item *item2;
  
} Inventory


//function to keep the inventory running and catch input
void inventory_run( Inventory *inventory ) {
  
  //infinite loop
  //in order to check if the object still exists and prevent empty pointer errors,
  //you can best add an "alive" state, just add an "alive" boolean in the structure, and check it here
  //after the while, call the inventory_remove function to fully destroy
  //We simply make an inventory_kill() function, and set the boolean to false to kill the object
  while( inventory->alive ) { //as long as the inventory is alive, keep loopin'

    //when we press key_1, show item1
    if( key_1 ) {
      item_visualize( inventory->item1, inventory->panel ); //remember this function in the item code?
    }

    //when we press key_2, show item2
    if( key_2 ) {
      item_visualize( inventory->item2, inventory->panel );
    }

    wait( 1 );
  }

  inventory_remove( inventory ); //the object is dead, remove it!
}


//function kill
void inventory_kill( Inventory *inventory ) {
  inventory->alive = false;
}


//function to create a new inventory
Inventory *inventory_create() {

  //allocate new inventory structure
  Inventory *inventory = malloc( sizeof( Inventory ) );
 
  //once again, fill all its parameters immediately after
  inventory->alive = true; //we set this object to alive first!
  inventory->panel = pan_create("bla");
  inventory->item1 = item_create( 1, "item1.tga" ); //easily create an item
  inventory->item2 = item_create( 2, "item2.tga" );

  //in addition to the item code, the inventory code catches player input
  //this run function handles this input, and loops infinitely
  inventory_run( inventory );

  return inventory; //give back the inventory
}


void inventory_remove( Inventory *inventory ) {
  item_remove( inventory->item1 ); //remove item1 first
  item_remove( inventory->item2 ); //remove item2
  ptr_remove( inventory->panel ); //don't forget to remove the panel too
  free( inventory ); //THEN remove inventory safely
}

//main
#include "Item.c"
#include "Inventory.c"


void main() {

  //create a new inventory!
  Inventory *inventory = inventory_create();

  //main loop (a little dirty, but forgiveable for now :) )
  while( 1 ) {
    
    //when we press q, remove the inventory
    if( key_q ) {
      inventory_remove( inventory ); //this should go smooth without errors...
    }

    wait( 1 );
  }
}

typedef struct
{
	var    koor_x_abs;
	var    koor_y_abs;
	var    koor_x;
	var    koor_y;
	var    bombenreichweite;
	var    erzeuger_id;
	var    kicker_id;
	var    speed;
	PANEL* panel;
} BOMBE;



typedef struct
{
	var    koor_x_abs;
	var    koor_y_abs;
	var    koor_x;
	var    koor_y;
	var    start_koor_x;
	var    start_koor_y;
	var    anz_leben;
	var    unverwundbar;
	var    richtung;
	var    bombenanzahl;
	var    bombenanzahl_max;
	var    bombenreichweite;
	var    speed;
	var    speed_orginal;
	var    anz_schuhe;
	var    tod;
	var    id;
	var    ki;
	var    sp_status;
	var    negativ;
	
	var    r;
	var    l;
	var    u;
	var    o;
	
	var    t1;
	var    t2;
	
	var    joy1_aktiv;
	var    joy2_aktiv;
	
	var    t1_gedr;
	var    t2_gedr;
	
	PANEL* panel;
	
	BOMBE  Bombe[Anz_bomben];
} PLAYER;

PLAYER  Player[Anz_spieler];

PLAYER *player = malloc( sizeof( PLAYER ) * Anz_spieler );

PLAYER **player = malloc( sizeof( PLAYER* ) * players_y );

for( i=0; i<players_x; i++ ) {
  player[i] = malloc( sizeof( PLAYER ) );
}

PLAYER  Player[Anz_spieler];
// Not use the malloc here because Player is a array not pointer !
Player[1].r = 2;
Player[3].u = 3;
....

typedef struct
{
	var    koor_x_abs;
	var    koor_y_abs;
	var    koor_x;
	var    koor_y;
	var    btype;
	PANEL* pnl;
} BLOCK;


/////////////////////////////////////////Actions//////////////////////////////////////////
//noch nicht Benötigt
////////////////////////////////////////Functions/////////////////////////////////////////
function create_new_level(var height, var lenght)
{
	var i, j;
	BLOCK **block = malloc( sizeof( BLOCK* ) * height );

	for( i=0; i<lenght; i++ ) {
		block[i] = malloc( sizeof( BLOCK ) );
	}
	
	for(i = 0; i<=height; i++)
	{
		for(j = 0; j<=1; j++)
		{
			if((i/height)*random(100) > 60)
			{
				block[0]->pnl.pos_x = 1;
			}
		}
	}
}