Back to Evolution Project page

---

                 

---

auxiliar.c

#include "auxiliar.h"
#include <string.h>
#include <gtk/gtk.h>

void toggle_view_grid(void) {
  view_grid = ! view_grid;
  draw_grid();
}

void hide_old(GdkDrawable *drawable) {
  int pixel_x, pixel_y;
  if ((old_x != -1) && (old_y != -1) && (sp_sel)) {
    pixel_x = (old_x)*UNIT_WIDTH;
    pixel_y = old_y*UNIT_HEIGHT + (sp_sel->sizey * UNIT_HEIGHT) - sp_sel->height_pixels;
    /*
    gdk_draw_pixmap(drawable, GcXOR, back_pixmap, pixel_x, pixel_y, 
            pixel_x, pixel_y, sp_sel->width_pixels, sp_sel->height_pixels);
            */
    draw_grid_local(old_x, old_y, old_x + sp_sel->sizex, old_y + sp_sel->sizey);
  }
  old_x = current_x; old_y = current_y;
}

void show_current(GdkDrawable *drawable) {
  int pixel_x, pixel_y;
  if (!sp_sel) return;
  pixel_x = current_x*UNIT_WIDTH;
  pixel_y = current_y*UNIT_HEIGHT + (sp_sel->sizey * UNIT_HEIGHT) - sp_sel->height_pixels;
  gdk_draw_pixmap(drawable, defgc, sp_sel->pixmap, 0, 0, 
          pixel_x, pixel_y, sp_sel->width_pixels, sp_sel->height_pixels);

}

void clear_pixmap(GdkPixmap *pixmap, GdkGC *gc) {
  int width, height;
  
  gdk_window_get_size( (GdkWindow *) pixmap, &width, &height);
  gdk_draw_rectangle (pixmap, gc, TRUE, 0, 0, width, height);
}

void draw_grid(void) {
  draw_grid_local(0, 0, level_width, level_height);
}

void create_new_level(void) {
  frmNew = create_frmNew();
  gtk_widget_show(frmNew);
}

void create_my_frmNew(void) {
  if (level_changed) {
    dlg_areyousure = create_dlgAreYouSure();
    gtk_widget_show(dlg_areyousure) ;
    return;
  }
  create_new_level();
}



void resize_map(void) {
  GtkWidget *drawing_area1;
  resize_array_of_units();
  //Set the drawing area' size
  drawing_area1 = lookup_widget(Main, "drawarea");
  gtk_widget_set_usize(drawing_area1, level_width * UNIT_WIDTH, level_height * UNIT_HEIGHT);
  gtk_widget_show(drawing_area1);
  
  //Initialize back_pixmap
  if (back_pixmap) g_free(back_pixmap);
  //    gdk_pixmap_destroy(back_pixmap);
  back_pixmap = gdk_pixmap_new (drawing_area1->window, level_width * UNIT_WIDTH, 
                level_height * UNIT_HEIGHT, -1);

  clear_pixmap(back_pixmap, drawing_area1->style->white_gc);
  old_x = old_y = -1;

  //(Re)initialize GCs
  if (GcXOR) gdk_gc_destroy(GcXOR);
  GcXOR = gdk_gc_new(back_pixmap);
  gdk_gc_set_function(GcXOR, GDK_XOR);
  if (defgc) gdk_gc_destroy(defgc);
  defgc = gdk_gc_new(back_pixmap);

}


void new_map(int sizex, int sizey) {
  level_width = sizex;
  level_height = sizey;
  resize_map();
  refresh_all();
}

void refresh_all(void) {
  refresh_local(0, 0, level_width, level_height);
}

void refresh_local(int x, int y, int x2, int y2) {
  int i, miny, minx;
  if (x<0) x=0;
  if (y<0) y=0;
  if (x2>level_width) x2=level_width;
  if (y2>level_height) y2=level_height;

  minx=x; miny=y;
  for (i=x; i<x2; i++)
    if (levelsp[(y*level_width)+i].sp_unit) 
      if (miny>levelsp[(y*level_width)+i].sp_unit->unity)
    miny=levelsp[(y*level_width)+i].sp_unit->unity;
    
  for (i=y; i<y2; i++)
    if (levelsp[(i*level_width)+x].sp_unit)
      if (minx>levelsp[(i*level_width)+x].sp_unit->unitx)
    minx=levelsp[(i*level_width)+x].sp_unit->unitx;
  x = minx; y = miny;

  draw_units_local(x, y, x2, y2); //First draw the units on the back_pixmap...
  
  draw_grid_local(x, y, x2, y2);  //And after this and the grid on the screen...
}

void draw_grid_local(int x, int y, int x2, int y2) {
  int i;
  GtkWidget *drawarea;

  if (x<0) x=0;
  if (y<0) y=0;
  if (x2>level_width) x2=level_width;
  if (y2>level_height) y2=level_height;


  drawarea = lookup_widget(Main, "drawarea");

  //Draw the back pixmap
  if (back_pixmap) {
    gdk_draw_pixmap (drawarea->window, drawarea->style->fg_gc[drawarea->state], back_pixmap, 
             x*UNIT_WIDTH, y*UNIT_HEIGHT, 
             x*UNIT_WIDTH, y*UNIT_HEIGHT, 
             (x2-x)*UNIT_WIDTH, (y2-y)*UNIT_HEIGHT);
  }

  //Draw the grid
  if (!level) return;
  if (view_grid) {
    for (i=y; i<=y2; i++){
      gdk_draw_line(drawarea->window, drawarea->style->fg_gc[drawarea->state],
            x*UNIT_WIDTH, i*UNIT_HEIGHT, x2*UNIT_WIDTH, i*UNIT_HEIGHT);
    }
    for (i=x; i<=x2; i++){
      gdk_draw_line(drawarea->window, drawarea->style->fg_gc[drawarea->state],
            i*UNIT_WIDTH, y*UNIT_WIDTH, i*UNIT_WIDTH, y2*UNIT_HEIGHT);
    }
  }

}


void draw_units_local(int x, int y, int x2, int y2) {
  //Draw the back pixmap from the unit map...
  int i, j;
  sprite *sp;

  //First, draw the grounds...
  for (i=x; i<x2; i++)
    for (j=y; j<y2; j++)
      if ((level[(j*level_height)+i].sp_unit) && (level[(j*level_height)+i].draw_here)) {
    sp = level[(j*level_height)+i].sp_unit->sprite;
    gdk_draw_pixmap (back_pixmap, defgc, 
             (GdkPixmap *) sp->pixmap,
             0, 0,
             i*UNIT_WIDTH, j*UNIT_HEIGHT,            
             sp->width_pixels, sp->height_pixels);
      }

  //...after, draw the sprites.
  if (view_sprites) {
    for (i=x; i<x2; i++)
      for (j=y; j<y2; j++)
    if ((levelsp[(j*level_height)+i].sp_unit) && (levelsp[(j*level_height)+i].draw_here)) {
      sp = levelsp[(j*level_height)+i].sp_unit->sprite;
      gdk_draw_pixmap (back_pixmap, defgc, 
               (GdkPixmap *) sp->pixmap,
               0, 0,
               i*UNIT_WIDTH, j*UNIT_HEIGHT,              
               sp->width_pixels, sp->height_pixels);
    }
  }
}



void draw_units_all(void) {
  draw_units_local(0, 0, level_width, level_height);
}


void event_on_unit(sprite *sp, int x, int y) {
  //  g_print("%d %d \n", sp->type, sp->id);
  if ((!view_sprites) && (sp->type==SPRITE_TYPE_SPRITE)) return;
  
  if ((sp->type==SPRITE_TYPE_SPRITE) && (sp->id==1)) 
    delete_sprite_on_unit_le(levelsp, x, y);
  else 
    add_sprite_on_unit_le(sp, x, y);
  
  level_changed = TRUE;
}


void toggle_view_sprites(void) {
  view_sprites = !view_sprites;
  refresh_all();
}

void exit_program(void) {
    gtk_main_quit();
}

void show_on_statusbar(gchar *text) {
  GtkWidget *statusbar;
  statusbar =  lookup_widget(Main, "statusbar1");
  gtk_statusbar_pop  (GTK_STATUSBAR(statusbar), 1);
  gtk_statusbar_push (GTK_STATUSBAR(statusbar), 1, text);
}

void set_pixmaps_from_filenames(GList *sp_lst) {
  GList *last, *current;
  GtkWidget *window;
  GtkStyle  *style;
  GdkBitmap *mask;
  sprite *sp;
  int width=0, height=0;

  window = lookup_widget(Main, "Main");
  style = gtk_widget_get_style(window);
  
  last = g_list_first(sp_lst);
  current = g_list_last(sp_lst);

  if (last) {
    do {
      sp = (sprite *)(current->data);
      sp->pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, 
                           &style->bg[GTK_STATE_NORMAL],
                           sp->filename);
      //      g_print(" %s %s %p\n", sp->description, sp->filename, sp->pixmap);
      sp->mask = mask;
      gdk_window_get_size( (GdkWindow *)sp->pixmap, &width, &height);  
      sp->width_pixels  = width;
      sp->height_pixels = height;
      
      if (current==last) break;
      current = current->prev;
    } while (1);    
  }
}

void delete_sprite_on_unit_le(unit *unitmap, int x, int y) {
  rect r;
  r = delete_sprite_on_unit(unitmap, x, y);
  refresh_local(r.x, r.y, r.sx, r.sy);
}

void add_sprite_on_unit_le(sprite *sp, int x, int y){
  rect r;
  r = add_sprite_on_unit(sp, x, y);
  refresh_local(r.x, r.y, r.sx, r.sy);
}


int open_level(gchar *fn) {
  FILE *f;
  file_header fh;

  g_print("Opening file '%s'\n", fn);
  f = fopen(fn, "rb");
  if (!f) return 0;

  //Read the reader first...
  fread(&fh, sizeof(fh), 1, f);
  level_width = fh.level_width;
  level_height = fh.level_height;
  resize_map();
  fseek(f, 0, SEEK_SET);

  if (!open_level_from_file(f)) {
    show_on_statusbar("Error loading file!!!");
    fclose(f);
    return 0;
  }
  fclose(f);
  refresh_all();
  strcpy(current_filename, fn);
  level_changed=FALSE;
  return 1;
}

int save_level(gchar *fn) {
  FILE *f;
  if (!g_strcasecmp(fn, ""))
    return 0;
  g_print("Saving file '%s'\n", fn);
  f = fopen(fn, "wb");
  if (!f) return 0;
  if (!save_level_to_file(f)) {
    fclose(f);
    show_on_statusbar("Error saving file!!!");
    return 0;
  }
  fclose(f);
  strcpy(current_filename, fn);
  level_changed=FALSE;
  return 1;
}

---