Example #1
0
SpaceSprite *load_sprite(const char *string, TW_DATAFILE *data, int *index)
{
	char buffy[512]; buffy[0] = 0;
	char *cp = buffy;
	char *tp;
	int argc, i;
	int rotations = 1;
	char **argv = get_config_argv("Objects", string, &argc);
	int count = 0;
	if (!argc) return NULL;
	count = atoi(argv[0]);
	if (!count) return NULL;
	tp = strchr(argv[0], 'r');
	for (i = 1; i < argc; i += 1) {
		if ((argv[i][0] == '-') || (argv[i][0] == '+')) {
			cp += sprintf(cp, "%s ", argv[i]);
		}
		else if (argv[i][0] == 'r') tp = argv[i];
		else {tw_error("load_sprite - unrecognized modifiers '%s'", argv[i]);}
	}
	if (tp) {
		rotations = atoi(tp+1);
		if (rotations == 0) rotations = 64;
	}
	SpaceSprite *sprite = NULL;
	int attrib = string_to_sprite_attributes(buffy);
	sprite = new SpaceSprite(&data[*index], count, attrib, rotations);
	for (i = 0; i < count; i += 1) {
		destroy_rle_sprite((RLE_SPRITE*)data[(*index)+i].dat);
		data[(*index)+i].dat = NULL;
		// brutal hack to free up the memory
	}
	*index += count;
	return sprite;
}
Example #2
0
int main(int argc, unsigned char **argv)
{
  /* Variables located at IR.config */
  int Resol_X, Resol_Y, count;
  char **screen;
  
  if (allegro_init() != 0)   /* you should always do this at the start of Allegro programs */
    return 1;
  
  set_config_file("config/Coco.config");  /* Read configuration file */
  
  install_keyboard();   /* set up the keyboard handler */
  install_timer();	/* set up the timer handler */
  
  set_color_depth(32);  
  /* Get screen resolution from Coco.config */
  screen = get_config_argv("content", "SCREEN_SIZE", &count);
  Resol_X = atoi(screen[0]);  Resol_Y = atoi(screen[1]);
  if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, Resol_X, Resol_Y, 0, 0) != 0)   /* for X */
    {
      if (set_gfx_mode(GFX_SAFE, Resol_X, Resol_Y, 0, 0) != 0)        /* for console */
	{
	  set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
	  allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
	  return 1;
	}
    }
  
  /* Check if all images exists before trying to blit'em */
  /* Add some protection */
  
  set_palette(desktop_palette);   /* set the color palette */
  
  /* Read desired sampling time in IR.config */
  Delay= (get_config_float("content", "Delay", 0));  
  
  iSP= (get_config_float("content", "iSP", 0));  
  SP= iSP*3.68;
  
  /* Go to Register the user and run the program after having hardware initialized */

  Register();
  return 0;  
}
Example #3
0
File: gui.c Project: cravo/damp
void gui_init(void)
{
   int x,y,n;                 /* Loop counters */
   char ini_colours[256];     /* For reading in colour values from the ini */
   char **ini_colvals;        /* The array of ini colour values */
   int argc;                  /* The number of ini colour values */

   /* We need the mouse, so we'll init that */

   install_mouse();

   /* Read the desired width & height from the ini file */

   GUI_SCREEN_W = get_config_int("[gui]","width",640);
   GUI_SCREEN_H = get_config_int("[gui]","height",480);

   /* Set the graphics mode */

   set_gfx_mode(GFX_AUTODETECT,GUI_SCREEN_W,GUI_SCREEN_H,0,0);
   clear(screen);

   /* Create the back-buffer */

   gui_buffer = create_bitmap(GUI_SCREEN_W, GUI_SCREEN_H);

   /* Create the mouse pointer bitmap */

   gui_mouse = create_bitmap(11,19);

   /* Read in the colours from the ini file */

   damp_gfx_palette[GUI_COLOUR_BACKGROUND].r = damp_gfx_palette[GUI_COLOUR_BACKGROUND].g = damp_gfx_palette[GUI_COLOUR_BACKGROUND].b = 32;
   damp_gfx_palette[GUI_COLOUR_SHADOW].r = damp_gfx_palette[GUI_COLOUR_SHADOW].g = damp_gfx_palette[GUI_COLOUR_SHADOW].b = 0;
   damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].r = damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].g = damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].b = 63;
   damp_gfx_palette[GUI_COLOUR_WINDOW].r = 63; damp_gfx_palette[GUI_COLOUR_WINDOW].g = damp_gfx_palette[GUI_COLOUR_WINDOW].b = 0;

   sprintf(ini_colours,get_config_string("[gui]","colours","gui_c_default"));

   ini_colvals = get_config_argv(ini_colours,"background",&argc);
   damp_gfx_palette[GUI_COLOUR_BACKGROUND].r = atoi(ini_colvals[0]) / 4;
   damp_gfx_palette[GUI_COLOUR_BACKGROUND].g = atoi(ini_colvals[1]) / 4;
   damp_gfx_palette[GUI_COLOUR_BACKGROUND].b = atoi(ini_colvals[2]) / 4;

   ini_colvals = get_config_argv(ini_colours,"titlebar",&argc);
   damp_gfx_palette[GUI_COLOUR_WINDOW].r = atoi(ini_colvals[0]) / 4;
   damp_gfx_palette[GUI_COLOUR_WINDOW].g = atoi(ini_colvals[1]) / 4;
   damp_gfx_palette[GUI_COLOUR_WINDOW].b = atoi(ini_colvals[2]) / 4;

   ini_colvals = get_config_argv(ini_colours,"highlight",&argc);
   damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].r = atoi(ini_colvals[0]) / 4;
   damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].g = atoi(ini_colvals[1]) / 4;
   damp_gfx_palette[GUI_COLOUR_HIGHLIGHT].b = atoi(ini_colvals[2]) / 4;

   ini_colvals = get_config_argv(ini_colours,"shadow",&argc);
   damp_gfx_palette[GUI_COLOUR_SHADOW].r = atoi(ini_colvals[0]) / 4;
   damp_gfx_palette[GUI_COLOUR_SHADOW].g = atoi(ini_colvals[1]) / 4;
   damp_gfx_palette[GUI_COLOUR_SHADOW].b = atoi(ini_colvals[2]) / 4;

   set_palette(damp_gfx_palette);

   /* Initialise the variables */

   gui_num_windows = 0;
   gui_window_dragging = -1;
   gui_titlebar_height = text_height(font)+4;
   gui_border_size = 4;

   /* Initialise the mouse pointer */

   clear(gui_mouse);
   n=0;
   for(y=0;y<19;y++)
      for(x=0;x<11;x++)
      {
         if(gui_mouse_data[n] == 0)
            putpixel(gui_mouse,x,y,0);
         else if(gui_mouse_data[n] == 1)
            putpixel(gui_mouse,x,y,GUI_COLOUR_SHADOW);
         else
            putpixel(gui_mouse,x,y,GUI_COLOUR_HIGHLIGHT);

         n++;
      }

}
Example #4
0
// called only from ReadINIFileInfo for reading in the information from the
// ini file and storing it globally
static BOOL ReadFromDriverIniFile(void)
{
   char * pBuffer = NULL;
   char Buffer[255];
   int i, k;
   int argc;
   char ** argv;

	pBuffer = get_config_string("General", "Description", "None");
	if (strcmp(pBuffer, "None") == 0)
	{ DisplayError("Can't load .ini driver!"); return FALSE; }


   strncpy(GameDescription, pBuffer, MAX_GAME_DESCRIPTION);
   GameDescription[MAX_GAME_DESCRIPTION -1] = 0;
   
   if ((NumGfxBanks = get_config_int("Layout", "GfxDecodes", 0)) == 0)
	{ DisplayError("INI file error 'GfxDecodes'"); return FALSE; }

   // if this fail the orientation will be 0 - which is OK.
   Orientation = get_config_int("Layout", "Orientation", 0);

   GfxBanks = malloc(NumGfxBanks * sizeof(SPRITE_PALETTE));
	if (GfxBanks == NULL)
	{ DisplayError("GfxBanks malloc failed"); return FALSE; }

   GfxBankExtraInfo = malloc(NumGfxBanks * sizeof(GFXBANKEXTRA));
   if (GfxBankExtraInfo == NULL)
   {
      free(GfxBanks);
      DisplayError("GfxBanksExtra malloc failed");
      return FALSE;
   }
   
	for (i = 0; i < NumGfxBanks; i++)
	{
		char GfxBank[10];

      sprintf(GfxBank, "Decode%d", i+1);

      // read staight forward stuff from INI file
		GfxBanks[i].sprite_w = get_config_int(GfxBank, "width", -1);
		GfxBanks[i].sprite_h = get_config_int(GfxBank, "height", -1);
		GfxBanks[i].n_total = get_config_int(GfxBank, "total", -1);
		GfxBanks[i].first_sprite = 0; // set the position to the default
		GfxBankExtraInfo[i].planes = get_config_int(GfxBank, "planes", -1);
		GfxBankExtraInfo[i].startaddress = get_config_int(GfxBank, "start", -1);
		GfxBankExtraInfo[i].charincrement = get_config_int(GfxBank, "charincrement", -1);

      // did any fail?
      if ((GfxBanks[i].sprite_w == -1) || (GfxBanks[i].sprite_h == -1) ||
          (GfxBanks[i].n_total == -1) || (GfxBankExtraInfo[i].planes == -1) ||
          (GfxBankExtraInfo[i].startaddress == -1) || (GfxBankExtraInfo[i].charincrement == -1))
      {
         free(GfxBanks);
         free(GfxBankExtraInfo);
         DisplayError("INI file corrupt");
         return FALSE;
      }

      // read plane offsets and store in array
		argv = get_config_argv(GfxBank, "planeoffsets", &argc);
      // sanity check
      if (argc != GfxBankExtraInfo[i].planes)
      {
         free(GfxBanks);
         free(GfxBankExtraInfo);
         DisplayError("INI file corrupt - planeoffsets");
         return FALSE;
      }

      // copy planeoffsets in to array
      for (k = 0; k < argc; k++)
         GfxBankExtraInfo[i].planeoffsets[k] = atol(argv[k]);


      // read xoffsets and store in array
		get_config_int_array(GfxBank, "xoffsets", GfxBankExtraInfo[i].xoffset, &argc);

      // sanity check
      if (argc != GfxBanks[i].sprite_w)
      {
         free(GfxBanks);
         free(GfxBankExtraInfo);
         DisplayError("INI file corrupt - xoffsets");
         return FALSE;
      }


      // read yoffsets and store in array
		get_config_int_array(GfxBank, "yoffsets", GfxBankExtraInfo[i].yoffset, &argc);

      // sanity check
      if (argc != GfxBanks[i].sprite_h)
      {
         free(GfxBanks);
         free(GfxBankExtraInfo);
         DisplayError("INI file corrupt - yoffsets");
         return FALSE;
      }
	}

   // calculate the number of graphics roms
   NumGfxRoms = 0;
   do
   {
      NumGfxRoms++;
      sprintf(Buffer, "Rom%d", NumGfxRoms);
      pBuffer = get_config_string("GraphicsRoms", Buffer, "None");
   } while (strcmp(pBuffer, "None") != 0);
   NumGfxRoms --;
   
   // is the ini file corrupt?
   if (NumGfxRoms == 0)
   {
      free(GfxBanks);
      free(GfxBankExtraInfo);
      DisplayError("INI file corrupt - graphicsroms");
      return FALSE;
   }
   
   // allocate memory for appropriate number of structures;
   GfxRoms = malloc(NumGfxRoms * sizeof(GFXROM));
   if (GfxRoms == NULL)
   {
      free(GfxBanks);
      free(GfxBankExtraInfo);
      DisplayError("GfxRoms malloc failed");
      return FALSE;
   }

   // read the information in to the array
   for (i = 0; i < NumGfxRoms; i ++)
   {
      // read rom info and store in array
      sprintf(Buffer, "Rom%d", i+1);
		argv = get_config_argv("GraphicsRoms", Buffer, &argc);
      // sanity check
      if (argc != 3) // loadaddress,size,name
      {
         free(GfxBanks);
         free(GfxBankExtraInfo);
         free(GfxRoms);
         DisplayError("INI file corrupt - %s", Buffer);
         return FALSE;
      }

      // copy info in to array
      GfxRoms[i].LoadAddress = atol(argv[0]);
      GfxRoms[i].Size = atol(argv[1]);
      GfxRoms[i].Alternate = FALSE;
      // detect for Alternate byte loading flag
      if ((GfxRoms[i].Size & ALTERNATE_ROMS_DETECT) == ALTERNATE_ROMS_DETECT)
      {
         GfxRoms[i].Size &= ALTERNATE_ROMS_SIZE;
         GfxRoms[i].Alternate = TRUE;         
      }
      
      strncpy(GfxRoms[i].ROMName, argv[2], MAX_ROM_NAME);
      GfxRoms[i].ROMName[MAX_ROM_NAME -1] = 0;
   }

   // finally read in the colour palettes or set defaults if none
   // exist
   if (ReadColourPalettes() == FALSE)
   {
      // free any allocated colour palettes
      for (i = 0; i < MAX_COL_PLANES; i++)
      {
         if (ColPalettes[i] != NULL)
         {
            free(ColPalettes[i]);
            ColPalettes[i] = NULL;
            NumColPalettes[i] = 0;
         }
      }
      free(GfxBanks);
      free(GfxBankExtraInfo);
      free(GfxRoms);
      return FALSE;
   }

   return TRUE;
}
Example #5
0
/* See README for details.
 */
void
abitmap_init (char const *path, DATAFILE *datafile)
{
	int i;
	int prev[10];
	int cv;
	char str[1024];
	DATAFILE *dat;

	cv = get_color_conversion ();
	set_color_conversion (COLORCONV_TOTAL | COLORCONV_KEEP_TRANS);

	used_bitmaps_cleanup ();

	push_config_state ();
	dat = set_theme_config (path, datafile);
	if (dat != datafile)
		used_dat = dat;

	theme->fg_color = get_color_string ("fg", "0x000000");
	theme->bg_color = get_color_string ("bg", "0xffffff");
	theme->mg_color = get_color_string ("mg", "0x808080");

	theme->textpushx = get_config_int ("agup.cfg", "px", 0);
	theme->textpushy = get_config_int ("agup.cfg", "py", 0);

	for (i = 0; bload[i].name; i++) {
		int j;
		int s;

		char const *suffix[] = { "", "_hl", "_dis" };

		for (s = 0; bload[i].name[s] == ' '; s++);

		for (j = 0; j < 3; j++) {
			char **argv = NULL;
			int argc = 0;
			BITMAP *bmp = NULL;
			int got_color = 0;

			theme->bitmaps[bload[i].elem][j].bmp = NULL;
			theme->bitmaps[bload[i].elem][j].flags = 0;
			theme->bitmaps[bload[i].elem][j].bl = 0;
			theme->bitmaps[bload[i].elem][j].br = 0;
			theme->bitmaps[bload[i].elem][j].bt = 0;
			theme->bitmaps[bload[i].elem][j].bb = 0;

			sprintf (str, "%s%s", bload[i].name + s, suffix[j]);
			argv = get_config_argv ("agup.cfg", str, &argc);

			TRACE ("%s: ", str);

			if (argc) {
				bmp = find_theme_bitmap (dat, argv[0]);
			}

			if (bmp) {
				int a;

				theme->bitmaps[bload[i].elem][j].bmp = bmp;

				for (a = 1; a < argc; a++) {
					if (!strcmp (argv[a], "stretch"))
						theme->bitmaps[bload[i].elem][j].flags |=
							ABMAP_STRETCH_H | ABMAP_STRETCH_V;
					else if (!strcmp (argv[a], "center"))
						theme->bitmaps[bload[i].elem][j].flags |=
								ABMAP_CENTER_H | ABMAP_CENTER_V;
					else if (!strcmp (argv[a], "stretchh"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_STRETCH_H;
					else if (!strcmp (argv[a], "centerh"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_CENTER_H;
					else if (!strcmp (argv[a], "alignh"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_ALIGN_H;
					else if (!strcmp (argv[a], "stretchv"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_STRETCH_V;
					else if (!strcmp (argv[a], "centerv"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_CENTER_V;
					else if (!strcmp (argv[a], "alignv"))
						theme->bitmaps[bload[i].elem][j].flags |= ABMAP_ALIGN_V;
					else if (!strcmp (argv[a], "cut")) {
						int cx, cy, cw, ch;
						a++;
						if (a < argc) {
							cx = strtol (argv[a], NULL, 10);
							a++;
							if (a < argc) {
								cy = strtol (argv[a], NULL, 10);
								a++;
								if (a < argc) {
									cw = strtol (argv[a], NULL, 10);
									a++;
									if (a < argc) {
										BITMAP *sub;
										ch = strtol (argv[a], NULL, 10);
										if (cw <= 0)
											cw += bmp->w;
										if (ch <= 0)
											ch += bmp->h;
										sub = create_sub_bitmap (bmp, cx, cy, cw, ch);
										used_bitmap (sub, NULL);
										theme->bitmaps[bload[i].elem][j].bmp = sub;
									}
								}
							}
						}
					}
					else if (!strcmp (argv[a], "border")) {
						a++;
						if (a < argc) {
							theme->bitmaps[bload[i].elem][j].bl = strtol (argv[a], NULL, 10);
							a++;
							if (a < argc) {
								theme->bitmaps[bload[i].elem][j].br =
									strtol (argv[a], NULL, 10);
								a++;
								if (a < argc) {
									theme->bitmaps[bload[i].elem][j].bt =
										strtol (argv[a], NULL, 10);
									a++;
									if (a < argc) {
										theme->bitmaps[bload[i].elem][j].bb =
											strtol (argv[a], NULL, 10);
									}
								}
							}
						}
					}
					else if (!strcmp (argv[a], "color")) {
						a++;
						if (a < argc) {
							int rgb32 = strtol (argv[a], NULL, 0);

							theme->bitmaps[bload[i].elem][j].color =
								makecol (rgb32 >> 16, (rgb32 >> 8) & 255,
								rgb32 & 255);
							got_color = 1;
							TRACE ("color %06x ", rgb32);
						}
					}
				}
				TRACE ("loaded successfully.\n");
			} else {
				/* If everything fails, try to inherit from another bitmap. */
				if (j) {
Example #6
0
int main(void)
{
   int w,h,bpp;
   int windowed;
   int count;
   char **data;

   char *title;
   char *filename;
   int  r,g,b;

   BITMAP *background;
   int     display;
   RGB     pal[256];

   int    x, y;

   /* you should always do this at the start of Allegro programs */
   if (allegro_init() != 0)
      return 1;
   /* set up the keyboard handler */
   install_keyboard(); 

   /* save the current ini file, then set the program specific one */
   push_config_state();
   set_config_file("exconfig.ini");

   /* the gfx mode is stored like this:
    *    640  480 16
    * the get_config_argv() function returns a pointer to a char
    * array, and stores the size of the char array in an int
    */
   data = get_config_argv("graphics", "mode", &count);
   if (count != 3) {
      /* We expect only 3 parameters */
      allegro_message("Found %i parameters in graphics.mode instead of "
		      "the 3 expected.\n", count);
      w = 320;
      h = 200;
      bpp = 8;
   }
   else {
      w = atoi(data[0]);
      h = atoi(data[1]);
      bpp = atoi(data[2]);       
   }

   /* Should we use a windowed mode? 
    * In the config file this is stored as either FALSE or TRUE.
    * So we need to read a string and see what it contains.
    * If the entry is not found, we use "FALSE" by default
    */
   if (ustricmp(get_config_string("graphics", "windowed", "FALSE"), "FALSE") == 0)
      windowed = GFX_AUTODETECT_FULLSCREEN;
   else
      windowed = GFX_AUTODETECT_WINDOWED;

   /* the title string 
    * The string returned is stored inside of the config system
    * and would be lost if we call pop_config_state(), so we create
    * a copy of it.
    */
   title = ustrdup(get_config_string("content", "headline", "<no headline>"));

   /* the title color 
    * once again this is stored as three ints in one line
    */
   data = get_config_argv("content", "headercolor", &count);
   if (count != 3) {
      /* We expect only 3 parameters */
      allegro_message("Found %i parameters in content.headercolor "
		      "instead of the 3 expected.\n", count);
      r = g = b = 255;
   }
   else {
      r = atoi(data[0]);
      g = atoi(data[1]);
      b = atoi(data[2]);       
   }

   /* The image file to read 
    * The string returned is stored inside of the config system
    * and would be lost if we call pop_config_state(), so we create
    * a copy of it.
    */   
   filename = ustrdup(get_config_string("content", "image", "mysha.pcx"));

   /* and it's tiling mode */
   display = get_config_int("content", "display", 0);
   if (display <0 || display > 2) {
      allegro_message("content.display must be within 0..2\n");
      display = 0; 
   } 

   /* restore the old config file */
   pop_config_state();


   /* set the graphics mode */
   set_color_depth(bpp);
   if (set_gfx_mode(windowed, w, h, 0, 0) != 0) {
      allegro_message("Unable to set mode %ix%i with %ibpp\n", w, h, bpp);
      free(filename);
      free(title);
      exit(-1);           
   }         

   /* Clear the screen */
   clear_bitmap(screen);   

   /* load the image */
   background = load_bitmap(filename, pal);
   if (background != NULL) {
      set_palette(pal);

      switch (display) {

	 case 0: /* stretch */
	    stretch_blit(background, screen, 0, 0, background->w,
			 background->h, 0, 0, SCREEN_W, SCREEN_H);
	 break;

	 case 1: /* center */
	    blit(background, screen, 0, 0, (SCREEN_W - background->w)/2,
		 (SCREEN_H - background->h)/2, background->w, background->h);
	 break;

	 case 2: /* tile */
	    for (y = 0; y < SCREEN_H; y += background->h)
	       for (x = 0; x < SCREEN_W; x += background->w)
		  blit(background, screen, 0, 0, x, y,
		       background->w, background->h);
         break; 
      }
   }
   else {
      textprintf_centre_ex(screen, font, SCREEN_W/2, SCREEN_H/2,
			   makecol(r,g,b), -1, "%s not found", filename);
   }

   textout_centre_ex(screen, font, title, SCREEN_W/2, 20, makecol(r,g,b), -1);

   readkey();

   free(filename);
   free(title);

   return 0;
}