Attachment #102712 for bug #155617

Lines 10-15 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/visobj.hpp (+1 lines)
10	virtual void draw(image screen, int x, int y, window_manager wm, filter *f) = 0;	10	virtual void draw(image screen, int x, int y, window_manager wm, filter *f) = 0;
11	virtual int width(window_manager *wm) = 0;	11	virtual int width(window_manager *wm) = 0;
12	virtual int height(window_manager *wm) = 0;	12	virtual int height(window_manager *wm) = 0;
		13	virtual ~visual_object() {}
13	} ;	14	} ;
14		15
15		16

Lines 11-16 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/status.hpp (+1 lines)
11	virtual void update(int percentage) = 0;	11	virtual void update(int percentage) = 0;
12	virtual void pop() = 0;	12	virtual void pop() = 0;
13	virtual void force_display() { ; }	13	virtual void force_display() { ; }
		14	virtual ~status_manager() {}
14	} ;	15	} ;
15		16
16		17




#ifdef MANAGE_MEM
enum {ALLOC_SPACE_STATIC,ALLOC_SPACE_CACHE};
extern int alloc_space;
void *jmalloc(int32_t size, char *what_for);
void *jrealloc(void *ptr, int32_t size, char *what_for);
void jfree(void *ptr);
void mem_report(char *filename);
void jmalloc_init(int32_t min_size);
void jmalloc_uninit();
int32_t j_allocated();
int32_t j_available();
extern void free_up_memory();
#else
#define jmalloc(x,y) malloc(x)

Lines 27-33 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/palette.hpp (-1 / +1 lines)
27	palette(bFILE *fp);	27	palette(bFILE *fp);
28	void set(int x, unsigned char red, unsigned char green, unsigned char blue);	28	void set(int x, unsigned char red, unsigned char green, unsigned char blue);
29	void get(int x, unsigned char &red, unsigned char &green, unsigned char &blue);	29	void get(int x, unsigned char &red, unsigned char &green, unsigned char &blue);
30	long getquad(int x);	30	uint32_t getquad(int x);
31	unsigned int red(int x) { return pal[x].red; }	31	unsigned int red(int x) { return pal[x].red; }
32	unsigned int green(int x) { return pal[x].green; }	32	unsigned int green(int x) { return pal[x].green; }
33	unsigned int blue(int x) { return pal[x].blue; }	33	unsigned int blue(int x) { return pal[x].blue; }





  // if screen x & y offset already calculated save a mul
  // and no clipping, but fast use this
  void put_image_offseted(image *screen, uint8_t *s_off);   
  void put_image_filled(image *screen, int x, int y, 
			uint8_t fill_color);
  void put_fade(image *screen, int x, int y,
			   int frame_on, int total_frames, 
			   color_filter *f, palette *pal);
  void put_fade_tint(image *screen, int x, int y,
		     int frame_on, int total_frames, 
		     uint8_t *tint,
		     color_filter *f, palette *pal);
  void put_color(image *screen, int x, int y, int color);
  unsigned char *clip_y(image *screen, int x1, int y1, int x2, int y2, 




class packet
{
  public :
  uint8_t *buf;
  int32_t buf_size,ro,wo,rend;
  int pre_size;
  void make_bigger(int max);

  int get_read_position() { return ro; }
  void set_read_position(int x) { ro=x; }
  int read(uint8_t *buffer, int size);
  int write(uint8_t *buffer, int size);
  int eop() { return ro>=rend; }
  void reset();
  packet(int prefix_size=2);
  void get_string(char *st, int len);
  int advance(int32_t offset);

  void write_uint32(uint32_t x);      // writes can't fail...
  void write_uint16(uint16_t x);
  void write_uint8(uint8_t x);
  void insert_into(packet &pk);
  int size() { return rend-pre_size; }
  ~packet();

Lines 68-76 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/jwindow.hpp (-3 / +2 lines)
68		68
69	struct jwindow_properties	69	struct jwindow_properties
70	{	70	{
71	uchar moveable,	71	uint8_t moveable,
72	hidden;	72	hidden;
73
74	} ;	73	} ;
75		74
76		75




#define imWRITE_ERROR          7
#define imMAX_ERROR 	       7

int16_t current_error();
void clear_errors();
void set_error(int16_t x);
int16_t last_error();
void make_block(size_t size);
void image_init();
void image_uninit();


typedef struct image_color_t
{
	uint16_t r;
	uint16_t g;
	uint16_t b;
} image_color;

class filter;

class dirty_rect : public linked_node
{
public :
  int16_t dx1,dy1,dx2,dy2;
  dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
  { dx1=x1; dy1=y1; dx2=x2; dy2=y2; 
    if (x2<x1 || y2<y1) 
      printf("add inccorect dirty\n");
  }
  virtual int16_t compare(void *n1, int16_t field)
  { return ((dirty_rect *)n1)->dy1>dy1; }
} ;

class image_descriptor
{
  int16_t l,h;
  int16_t clipx1, clipy1, clipx2, clipy2;
public :  
  uint8_t keep_dirt,
	  static_mem;      // if this flag is set then don't free memory on exit
  
  linked_list dirties;
  void *extended_descriptor;              // type depends on current system

  image_descriptor(int16_t length, int16_t height,
		  int keep_dirties=1, int static_memory=0);
  int16_t bound_x1(int16_t x1)  { return x1<clipx1 ? clipx1 : x1; }
  int16_t bound_y1(int16_t y1)  { return y1<clipy1 ? clipy1 : y1; }
  int16_t bound_x2(int16_t x2)  { return x2>clipx2 ? clipx2 : x2; }
  int16_t bound_y2(int16_t y2)  { return y2>clipy2 ? clipy2 : y2; }
  int16_t x1_clip() { return clipx1; }
  int16_t y1_clip() { return clipy1; }
  int16_t x2_clip() { return clipx2; }
  int16_t y2_clip() { return clipy2; }
  void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ;}
  void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
  void clear_dirties();
  int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2) { return 0; }
  void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
    { x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }
  void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
    { if (x2<x1) x2=x1;
      if (y2<y1) y2=y1;
      if (x1<0) clipx1=0; else clipx1=x1;

  void reduce_dirties();
  void add_dirty(int x1, int y1, int x2, int y2);
  void delete_dirty(int x1, int y1, int x2, int y2);
  void resize(int16_t length, int16_t height)
   { l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }
} ;

class image : public linked_node
{ 
  uint8_t *data;
  int16_t w,h;
  void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
  void delete_page();
public :
  image_descriptor *special;
  image(spec_entry *e, bFILE *fp);
  image(bFILE *fp);
  image(int16_t width, int16_t height,                 // required
	uint8_t *page_buffer=NULL,
	int16_t create_descriptor=0);        // 0=no, 1=yes, 2=yes & keep dirties
  uint8_t  pixel              (int16_t x, int16_t y);
  void     putpixel           (int16_t x, int16_t y, char color);
  uint8_t *scan_line          (int16_t y) { return data+y*w; }
  uint8_t *next_line          (int16_t lasty, uint8_t *last_scan) 
                                    { return last_scan+w; }          
  int32_t  total_pixels       (uint8_t background=0);
  image    *copy               ();    // makes a copy of an image
  void     clear              (int16_t color=-1);  // -1 is background color
  void     to_24bit           (palette &pal);
  int16_t  width              () { return (int16_t)w; }
  int16_t  height             () { return (int16_t)h; }
  void     scroll             (int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd);
  void     fill_image         (image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
			      int16_t align=1);
  void     put_image          (image *screen, int16_t x, int16_t y, char transparent=0);
  void     put_part           (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
				     int16_t x2, int16_t y2, char transparent=0);
  void     put_part_xrev      (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
				     int16_t x2, int16_t y2, char transparent=0);
  void     put_part_masked    (image *screen, image *mask, int16_t x, int16_t y, 
				     int16_t maskx, int16_t masky, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
  image    *copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
  void     bar                (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
  void     xor_bar            (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
  void 	   wiget_bar          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
				     uint8_t light, uint8_t med, uint8_t dark);
  void     line               (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
  void     rectangle          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
  void     burn_led           (int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale=1);
  void     set_clip           (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
  void     get_clip           (int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
  void     in_clip            (int16_t x1, int16_t y1, int16_t x2, int16_t y2);

  void     dirt_off           () { if (special && special->keep_dirt) special->keep_dirt=0; }
  void     dirt_on            () { if (special) special->keep_dirt=1; }

  void     add_dirty          (int x1, int y1, int x2, int y2) 
                                    { if (special) special->add_dirty(x1,y1,x2,y2); }
  void     delete_dirty       (int x1, int y1, int x2, int y2) 
                                    { if (special) special->delete_dirty(x1,y1,x2,y2); }
  void     clear_dirties      () { if (special) special->clear_dirties(); }
  void     dither             (palette *pal); // use a b&w palette!
  void     resize             (int16_t new_width, int16_t new_height);
  void     change_size        (int16_t new_width, int16_t new_height, uint8_t *page=NULL);
  void     flood_fill         (int16_t x, int16_t y, uint8_t color);
  image    *create_smooth     (int16_t smoothness=1); // 0 no smoothness
  void     unpack_scanline    (int16_t line, char bitsperpixel=1);
  uint8_t  brightest_color    (palette *pal);
  void     flip_x	      ();
  void     flip_y             ();
  void     make_color         (uint8_t color);
  uint8_t  darkest_color      (palette *pal, int16_t noblack=0);

  ~image();
} ;




#define max(x,y) (x>y ? x:y)
#endif

//#define uchar  unsigned char
//#define schar  signed char
//#define ushort unsigned short
//typedef unsigned short int ushort;
//#define sshort signed short
//#define ulong  unsigned long
//typedef unsigned long int ulong;

#endif




#else
  // so apps can find unlink
  #include <unistd.h>
  #include <stdint.h>
#endif


#define uint16_swap(x) (((((uint16_t) (x)))<<8)|((((uint16_t) (x)))>>8))
#define uint32_swap(x) \
   ((( ((uint32_t)(x)) )>>24)|((( ((uint32_t)(x)) )&0x00ff0000)>>8)| \
   ((( ((uint32_t)(x)) )&0x0000ff00)<<8)|(( ((uint32_t)(x)) )<<24))

#if defined BIG_ENDIANS
#define LONG int32_t
#define uint16_to_intel(x) uint16_swap(x)
#define uint16_to_local(x) uint16_to_intel(x)
#define big_uint32_to_local(x) (x)
#define big_uint16_to_local(x) (x)
#define uint32_to_intel(x) uint32_swap(x)
#define uint32_to_local(x) uint32_to_intel(x)
#else
#define LONG int32_t
#define uint16_to_intel(x) (x)
#define uint16_to_local(x) (x)
#define uint32_to_local(x) (x)
#define uint32_to_intel(x) (x)
#define big_uint32_to_local(x) uint32_swap(x)
#define big_uint16_to_local(x) uint16_swap(x)
#endif

#define bltl(x) big_uint32_to_local(x)
#define bstl(x) big_uint16_to_local(x)
#define lltl(x) uint32_to_intel(x)
#define lstl(x) uint16_to_intel(x)

#endif


Lines 50-56 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/scroller.hpp (-1 / +1 lines)
50	{	50	{
51	protected :	51	protected :
52	int r,c,m,last_sel,cur_sel;	52	int r,c,m,last_sel,cur_sel;
53	uchar *select;	53	uint8_t *select;
54	public :	54	public :
55	spicker(int X, int Y, int ID, int Rows, int Cols, int Vert, int MultiSelect, ifield *Next);	55	spicker(int X, int Y, int ID, int Rows, int Cols, int Vert, int MultiSelect, ifield *Next);
56	int vis() { if (vert) return r; else return c; }	56	int vis() { if (vert) return r; else return c; }




#include "system.h"
#include <fcntl.h>
#include <stdlib.h>
#include <stdint.h>

extern char *spec_types[];




  // these read and writes, allways read/write Intel endian-ness
  uint16_t read_uint16();
  uint32_t read_uint32();
  uint8_t read_uint8();
  double read_double();
  void write_uint16(uint16_t x);
  void write_uint32(uint32_t x);
  void write_uint8(uint8_t x);
  void write_double(double x);
  void set_read_buffer_size(long size);
} ;

                         unsigned long data_size,
                         char *link_filename=NULL);*/

uint16_t read_uint16(FILE *fp);
uint32_t read_uint32(FILE *fp);
uint32_t read_other_uint32(FILE *fp);
uint16_t read_other_uint16(FILE *fp);
uint8_t read_uint8(FILE *fp);

void write_uint16(FILE *fp, uint16_t x);
void write_uint32(FILE *fp, uint32_t x);
void write_other_uint16(FILE *fp, uint16_t x);
void write_other_uint32(FILE *fp, uint32_t x);
void write_uint8(FILE *fp, uint8_t x);

void set_spec_main_file(char *filename, int Search_order);
void set_file_opener(bFILE *(*open_fun)(char *, char *));




    return 0;
  }
  
  uint8_t id,color_map,im_type;

  id=fp->read_uint8();
  color_map=fp->read_uint8();
  im_type=fp->read_uint8();

  if (color_map!=0)
  {

    return 0;
  }

  fp->read_uint16();
  fp->read_uint16();
  fp->read_uint8();

  fp->read_uint16();
  fp->read_uint16();


  int w=fp->read_uint16();
  int h=fp->read_uint16();
  uint8_t bpp=fp->read_uint8();
  uint8_t im_des=fp->read_uint8();

  if (bpp!=32)
  {

  image *im=new image(w,h);

  int x,y;
  uint8_t ctrl;
  uint8_t bgra[4],*sl,c,lr=0,lg=0,lb=0,ll=0,lc=0;
  
  
  


      for (x=0;x<w;)
      {
        ctrl=fp->read_uint8();
        if (ctrl&0x80)
        {
          fp->read(bgra,4);




    {
      case JK_LEFT : if (cur) { draw_cur(wm->dark_color(),screen,wm); cur--;
                           draw_cur(wm->bright_color(),screen,wm); } break; 
      case JK_RIGHT : if (cur<(int)strlen(format)-1) { draw_cur(wm->dark_color(),screen,wm); cur++;
                           draw_cur(wm->bright_color(),screen,wm); } break; 
      case JK_END : if (cur!=last_spot()) 
                          { draw_cur(wm->dark_color(),screen,wm); cur=last_spot(); 
                            if (cur==(int)strlen(format)-1) cur--; 
                           draw_cur(wm->bright_color(),screen,wm); } break; 
      case JK_HOME : if (cur) 
                          { draw_cur(wm->dark_color(),screen,wm); cur=0;
                           draw_cur(wm->bright_color(),screen,wm); } break; 
      case JK_BACKSPACE : if (cur)
         { draw_cur(wm->dark_color(),screen,wm); cur--;
           for (xx=cur;xx<(int)strlen(format)-1;xx++)
             data[xx]=data[xx+1];
           data[strlen(format)-1]=' ';
           draw_text(screen,wm);

           for (xx=strlen(format)-1;xx>cur && xx>0;xx--)
             data[xx]=data[xx-1];
           data[cur]=ev.key;
           if (cur<(int)strlen(format)-1)
             cur++;
	   data[strlen(format)]=0;
           draw_text(screen,wm);

                               double Data, ifield *Next)
{
  char num[20];
  sprintf(num,"%g",Data);  
  int slen=(strlen(Format)>strlen(num) ? strlen(Format) : strlen(num));
  x=X; y=Y; id=ID;
  prompt=strcpy((char *)jmalloc(strlen(Prompt)+1,"text_field::prompt"),Prompt);

Lines 20-27 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/dprint.cpp (-2 / +1 lines)
20	{	20	{
21	if (dprint_fun)	21	if (dprint_fun)
22	{	22	{
23	char st[1000],a,*sp;	23	char st[1000];
24	int y;
25	va_list ap;	24	va_list ap;
26		25
27	va_start(ap, format);	26	va_start(ap, format);






struct {
	uint16_t	Width;
	uint16_t	Height;
	uint8_t 	ColorMap[3][256];
	uint16_t	BitPixel;
	uint16_t	ColorResolution;
	uint16_t	Background;
	uint16_t	AspectRatio;
} GifScreen;

struct {
  uint16_t w,h;
  uint8_t color_info,background,reserved;
} gif_screen;

struct {
  uint16_t xoff,yoff,w,h;
  uint8_t color_info;
} gif_image;

image *read_gif(char *fn, palette *&pal)
{
  char buf[100],er;
  uint8_t sep;
  unsigned int ncolors;
  FILE *fp;
  image *im;
  clear_errors();

      buf[6]=0;
      if (!strcmp("GIF87a",buf))
      {
        fread((uint8_t *)&gif_screen.w,2,1,fp);
        gif_screen.w=uint16_to_local(gif_screen.w);
        fread((uint8_t *)&gif_screen.h,2,1,fp);
        gif_screen.h=uint16_to_local(gif_screen.h);
        fread((uint8_t *)&gif_screen.color_info,1,1,fp);
        fread((uint8_t *)&gif_screen.background,1,1,fp);
        if (fread((uint8_t *)&gif_screen.reserved,1,1,fp)==1)
	{
	  if (gif_screen.color_info&128)
	  {

	    pal=new palette(256);
	    if (pal)
	    {  
              if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
	    } else er=imMEMORY_ERROR;
	  }
	  if (!er)
	  { do
	    {
	      if (fread((uint8_t *)&sep,1,1,fp)!=1)
		er=imREAD_ERROR;
	    } while (!er && sep!=',');
            fread((uint8_t *)&gif_image.xoff,2,1,fp);
            gif_image.xoff=uint16_to_local(gif_image.xoff);
            fread((uint8_t *)&gif_image.yoff,2,1,fp);
            gif_image.yoff=uint16_to_local(gif_image.yoff);
            fread((uint8_t *)&gif_image.w,2,1,fp);
            gif_image.w=uint16_to_local(gif_image.w);
            fread((uint8_t *)&gif_image.h,2,1,fp);
            gif_image.h=uint16_to_local(gif_image.h);
	    if (!er && (fread((uint8_t *)&gif_image.color_info,1,1,fp)==1))
	    {
	      if (gif_image.color_info&128)
	      {

		make_block(sizeof(palette));
		pal = new palette(ncolors);
		if (pal)
		{ if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
		} else er=imMEMORY_ERROR;
	      }





#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>

#include <specs.hpp>
//#include <new.h>

#define MEM_CHECK
//#ifdef MEM_CHECK
//#define MEM_CLEAR
//#endif

#include "jmalloc.hpp"
#define uchar unsigned char
#define JM_SMALL_SIZE 128      // above 128 bytes is considered to be a big block and no hashing is done
int alloc_space=ALLOC_SPACE_STATIC;

extern void free_up_memory();

#ifdef MEM_CHECK
intptr_t break_mem_point=0;       // can be set in debugger, break mem fun will be called when this address is allocated
void break_mem_fun()
{
  printf("memory breakpoint\n");


struct memory_node
{
  int32_t size;
#ifdef MEM_CHECK
  char *name;                     // name is allocated on regular heap
#endif                            // because it is used for debugging purposes


struct small_block
{  
  uint32_t size;             // size of blocks...
  uint32_t alloc_list;            // bit field saying weither each block is allocated or not.
  small_block *next;              // next small block of same size
#ifdef MEM_CHECK
  char *name[32];
#endif 

{
  public :

  int32_t block_size;                             // size of this memory_block
  small_block *sblocks[JM_SMALL_SIZE];
  small_block *cblocks[JM_SMALL_SIZE];
  void *addr;

  memory_node *sfirst,*slast,
              *cfirst;
  uint8_t block_type;

  void init(void *block, int32_t Block_size, uint8_t type);
  void *static_alloc(int32_t size, char *name);
  void *cache_alloc(int32_t size, char *name);
  void static_free(void *ptr);
  void cache_free(void *ptr);
  int32_t available();
  int32_t allocated();
  int32_t pointer_size(void *ptr);
  void report(FILE *fp);
  void inspect();



int block_manager::valid_static_ptr(void *ptr)
{
  void *next=(void *)(*(((int32_t *)ptr)-1));
  if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
  {
    small_block *s=(small_block *)next;


int block_manager::valid_cache_ptr(void *ptr)
{
  void *next=(void *)(*(((int32_t *)ptr)-1));
  if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
  {
    small_block *s=(small_block *)next;

      small_block *s=bmanage[i].sblocks[size];
      while (s) 
      { 
	for (x=0;x<32;x++)
	  if (s->alloc_list&(1<<x))
	    static_list[size]++; 

	s=s->next; 
      }

      s=bmanage[i].cblocks[size];
      while (s) 
      { 
	for (x=0;x<32;x++)
	  if (s->alloc_list&(1<<x))
	    cache_list[size]++; 

	s=s->next; 
      }
    }
  }

  memory_node *f=sfirst;
  for (;f;f=f->next);               // scan through static big list

  int i,bit=1;
  for (i=0;i<JM_SMALL_SIZE;i++)
  {
    for (small_block *s=sblocks[i];s;s=s->next)

      char *addr=((char *)(s+1));
      for (int j=0;j<32;j++)
      {
	if (s->alloc_list&bit)
	{
	  void *next=(void *)(*(((intptr_t *)addr)));
	  if ((intptr_t)next!=(intptr_t)s)
	  {
	    fprintf(stderr,"inspect : bad pointer\n");
	    return ;	    
	  }
	}
	bit=bit<<1;
	addr+=s->size+4;
      }	
    }
  }

    for (small_block *s=sblocks[i];s;s=s->next)
    {      
      fprintf(fp,"*** Small Block size = %d ***\n",i);      
      uint32_t bit=1;
      char *addr=((char *)(s+1));
      for (int j=0;j<32;j++)
      {
	fprintf(fp,"%p   ",addr);
	if (s->alloc_list&bit)
	{
#ifdef MEM_CHECK
	  fprintf(fp,"%s\n",s->name[j]);
#else
	  fprintf(fp,"allocated\n");
#endif	  
	} else fprintf(fp,"FREE\n");
	bit=bit<<1;
	addr+=s->size+4;
      }
    }
  }

    for (small_block *s=cblocks[i];s;s=s->next)
    {      
      fprintf(fp,"*** Small Block size = %d ***\n",i);      
      uint32_t bit=1;
      char *addr=((char *)(s+1));
      for (int j=0;j<32;j++)
      {

  }
}

int32_t block_manager::pointer_size(void *ptr)
{
  void *next=(void *)(*(((intptr_t *)ptr)-1));
  if (next>ptr)
    return ((memory_node *)(((char *)ptr)-sizeof(memory_node)))->size;
  else return ((small_block *)next)->size;
}

int32_t block_manager::available()
{
  int32_t size=0;
  memory_node *f;
  for (f=sfirst;f;f=f->next)
    if (f->size<0) size-=f->size;

  return size;
}

int32_t block_manager::allocated()
{
  int32_t size=0;
  memory_node *f;
  for (f=sfirst;f;f=f->next)
    if (f->size>0) size+=f->size;

  return size;
}

void block_manager::init(void *block, int32_t Block_size, uint8_t type)
{
  block_size=Block_size;
  addr=block;

  block_type=type;
}

void *block_manager::static_alloc(int32_t size, char *name)
{
  if (size<JM_SMALL_SIZE)
  {

      s->size=size;
#ifdef MEM_CHECK
      s->name[0]=strcpy((char *)malloc(strlen(name)+1),name);
      if ((intptr_t)s==break_mem_point)
        break_mem_fun();
#endif      
      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
      *addr=(intptr_t)s;
      return (void *)(addr+1);  // return first block
    } else
    {
      int bit=1,i=0;
      char *addr=((char *)s)+sizeof(small_block);
      while (1)        // we already know there is a bit free
      {

#ifdef MEM_CHECK
	  s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
#endif      	 
	  *((intptr_t *)addr)=(intptr_t)s;

#ifdef MEM_CHECK
	  if ((intptr_t)addr==break_mem_point)
            break_mem_fun();
#endif


  if (!s) return NULL;
  s->size=-s->size;

  if (s->size-size>(int)sizeof(memory_node)+4)  // is there enough space to split the block?
  {    
    memory_node *p=(memory_node *)((char *)s+sizeof(memory_node)+size);
    if (s==slast)

#ifdef MEM_CHECK
  s->name=strcpy((char *)malloc(strlen(name)+1),name);

  if ((intptr_t)s==break_mem_point)
    break_mem_fun();

#endif

}


void *block_manager::cache_alloc(int32_t size, char *name)
{
  if (size<JM_SMALL_SIZE)
  {

      s->name[0]=strcpy((char *)malloc(strlen(name)+1),name);

#endif      
      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
      *addr=(intptr_t)s;
#ifdef MEM_CHECK
      if ((intptr_t)s==break_mem_point)
        break_mem_fun();
#endif
      return (void *)(addr+1);  // return first block
    } else
    {
      int bit=1,i=0;
      char *addr=((char *)s)+sizeof(small_block);
      while (1)        // we already know there is a bit free
      {

	  s->alloc_list|=bit;
#ifdef MEM_CHECK
	  s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
	  if ((intptr_t)s==break_mem_point)
	    break_mem_fun();
#endif      	 
	  *((intptr_t *)addr)=(intptr_t)s;
	  return (void *)(addr+4);
	}
	i++;

  for (;s && -s->size<size;s=s->next) clast=s;
  if (!s) // no current cache space for object, see if we can enlarge the cache space
  {
    int32_t size_avail=-slast->size;
    size_avail-=sizeof(memory_node);

    if (slast->size>0 || size_avail<size) // not enough space

      nc->size=size;
#ifdef MEM_CHECK
      nc->name=strcpy((char *)malloc(strlen(name)+1),name);      
      if ((intptr_t)nc==break_mem_point)
        break_mem_fun();
#endif      
      if (!clast)


  s->size=-s->size;

  if (s->size-size>(int)sizeof(memory_node)+4)  // is there enough space to split the block?
  {
    memory_node *p=s;    // store this position
    int32_t psize=s->size-size-sizeof(memory_node);
    s=(memory_node *)(((char *)s)+psize+sizeof(memory_node));
    p->size=-psize;
    s->next=p;

  }
#ifdef MEM_CHECK
  s->name=strcpy((char *)malloc(strlen(name)+1),name);
  if ((intptr_t)s==break_mem_point)
    break_mem_fun();
#endif
  return (void *)(((char *)s)+sizeof(memory_node));

void block_manager::cache_free(void *ptr)
{
  // see if this was a small_block allocation
  void *next=(void *)(*(((int32_t *)ptr)-1));
  if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
  {
    small_block *s=(small_block *)next;

void block_manager::static_free(void *ptr)
{
  // see if this was a small_block allocation
  void *next=(void *)(*(((int32_t *)ptr)-1));
  if (next && next<ptr)  // small allocation
  {
    small_block *s=(small_block *)next;

				   "    - remove TSR's  & drivers not needed by ABUSE\n"
				   "    - add memory to your system\n";

void jmalloc_init(int32_t min_size)
{
  fprintf(stderr,"Disabling memory manager, using libc instead\n");
  return;

  if (bmanage_total)
    fprintf(stderr,"warning : jmalloc_init called twice\n");
  else

    void *mem;

#ifdef __POWERPC__
    int32_t size=jmalloc_max_size-0x10000;
    for (mem=NULL;!mem && size>0x10000;)
    {
      mem=malloc(size+0x10000);

    free(mem);
    mem = malloc(size);
#else
    int32_t size=jmalloc_max_size;
    for (mem=NULL;!mem && size>0x4000;)
    {
      mem=malloc(size);

#endif
    if (mem)
    {
      bmanage[bmanage_total].init(mem,size,HI_BLOCK);
      bmanage_total++;      
      fprintf(stderr,"Added himem block (%d bytes)\n",size);
    }

/*    bmanage[bmanage_total].init(malloc(2039552),2039552,HI_BLOCK);

    bmanage[bmanage_total].init(malloc(150224),150224,HI_BLOCK);
    bmanage_total++;      */



#ifdef __WATCOMC__
    if (size!=jmalloc_max_size)
    {
      do
      {
	size=low_memory_available();
	if (size>jmalloc_min_low_size+0x1000)              // save 64K for misc low memory needs
	{
	  bmanage[bmanage_total].init(alloc_low_memory(size-jmalloc_min_low_size-0x1000),size-jmalloc_min_low_size-0x1000,LOW_BLOCK);
	  bmanage_total++; 
	  fprintf(stderr,"Added low memory block (%d bytes)\n",size);
	}
      } while (size>jmalloc_min_low_size+0x1000);
      if (size<jmalloc_min_low_size)
      {
	fprintf(stderr,not_enough_low_memory_message,size,jmalloc_min_low_size);
	exit(0);
      }
    }
#endif
 

    fprintf(stderr,"Memory available : %d\n",j_available());
    if (j_available()<min_size)
    {
      fprintf(stderr,not_enough_total_memory_message);
      exit(0);
    }

  }
}


int32_t j_available()
{
  int32_t size=0;
  for (int i=0;i<bmanage_total;i++) 
    size+=bmanage[i].available();
  return size;
}

int32_t j_allocated()
{
  int32_t size=0;
  for (int i=0;i<bmanage_total;i++) 
    size+=bmanage[i].allocated();
  return size;
}


void *jmalloc(int32_t size, char *name)
{  
  if (!bmanage_total)
    return malloc(size);

    {
      void *a;
      if (alloc_space==ALLOC_SPACE_STATIC)
      {
        a=bmanage[i].static_alloc(size,name);
      }
      else
      {
        a=bmanage[i].cache_alloc(size,name);
      }
      if (a) return a;
    }
    free_up_memory();

}


void *jrealloc(void *ptr, int32_t size, char *name)
{  
  if (!ptr) return jmalloc(size,name);
  if (!bmanage_total) { return realloc(ptr,size); }

  if (size==0) { jfree(ptr); return NULL; }

  int32_t old_size=0;
  for (int i=0;i<bmanage_total;i++)
    if (ptr>=(void *)bmanage[i].sfirst && 
	ptr<=(void *)(((char *)bmanage[i].sfirst)+bmanage[i].block_size))

void mem_report(char *filename)
{
	char *reportpath;
	reportpath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + strlen( filename ) + 1, "reportpath" );
	sprintf( reportpath, "%s%s", get_save_filename_prefix(), filename );

	FILE *fp = fopen( reportpath, "wb" );
	if( fp != NULL )	/* make sure we actually got a file */

}


int32_t small_ptr_size(void *ptr)
{
  return ((small_block *)(((int32_t *)ptr)[-1]))->size;
}



Lines 5-11 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include.cpp (-1 / +2 lines)
5	{	5	{
6	char tmp_name[200];	6	char tmp_name[200];
7	strcpy(tmp_name,name);	7	strcpy(tmp_name,name);
8	int j,append=0,i;	8	unsigned int j;
		9	int append=0,i;
9	for (j=0;j<strlen(name);j++)	10	for (j=0;j<strlen(name);j++)
10	if (toupper(tmp_name[j])<'A' \|\| toupper(tmp_name[j])>'Z')	11	if (toupper(tmp_name[j])<'A' \|\| toupper(tmp_name[j])>'Z')
11	tmp_name[j]='_';	12	tmp_name[j]='_';

Lines 3-9 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/scroller.cpp (-15 / +15 lines)
3	#define HS_ICON_H 8	3	#define HS_ICON_H 8
4		4
5		5
6	unsigned char hs_left_arrow[10*8]={	6	uint8_t hs_left_arrow[10*8]={
7	0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,	7	0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
8	0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,	8	0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
9	1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,	9	1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
Lines 12-18 Link Here
12	2, 0, 0, 0, 0};	12	2, 0, 0, 0, 0};
13		13
14		14
15	unsigned char hs_right_arrow[10*8]={	15	uint8_t hs_right_arrow[10*8]={
16	0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,	16	0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
17	0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,	17	0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
18	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1,	18	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1,
Lines 21-27 Link Here
21	1, 1, 0, 0, 0};	21	1, 1, 0, 0, 0};
22		22
23		23
24	unsigned char vs_up_arrow[8*10]={	24	uint8_t vs_up_arrow[8*10]={
25	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 0,	25	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 0,
26	0, 0, 0, 1, 1, 1, 1, 2, 0, 0, 1, 2, 1, 1, 2,	26	0, 0, 0, 1, 1, 1, 1, 2, 0, 0, 1, 2, 1, 1, 2,
27	1, 2, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1,	27	1, 2, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1,
Lines 30-36 Link Here
30	0, 2, 2, 0, 0};	30	0, 2, 2, 0, 0};
31		31
32		32
33	unsigned char vs_down_arrow[8*10]={	33	uint8_t vs_down_arrow[8*10]={
34	0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1, 1, 2, 0,	34	0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1, 1, 2, 0,
35	0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1, 2,	35	0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1, 2,
36	0, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1,	36	0, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1,
Lines 38-48 Link Here
38	1, 1, 2, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0,	38	1, 1, 2, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0,
39	0, 0, 0, 0, 0};	39	0, 0, 0, 0, 0};
40		40
41	void show_icon(image screen, window_manager wm, int x, int y, int icw, int ich, unsigned char *buf)	41	void show_icon(image screen, window_manager wm, int x, int y, int icw, int ich, uint8_t *buf)
42	{	42	{
43	short cx1,cy1,cx2,cy2;	43	short cx1,cy1,cx2,cy2;
44	screen->get_clip(cx1,cy1,cx2,cy2);	44	screen->get_clip(cx1,cy1,cx2,cy2);
45	unsigned char remap[3];	45	uint8_t remap[3];
46	remap[0]=wm->medium_color();	46	remap[0]=wm->medium_color();
47	remap[1]=wm->bright_color();	47	remap[1]=wm->bright_color();
48	remap[2]=wm->dark_color();	48	remap[2]=wm->dark_color();
Lines 51-57 Link Here
51	{	51	{
52	if (y>=cy1 && y<=cy2)	52	if (y>=cy1 && y<=cy2)
53	{	53	{
54	unsigned char *sl=screen->scan_line(y)+x;	54	uint8_t *sl=screen->scan_line(y)+x;
55	for (int xc=icw,xo=x;xc;xc--,xo++,sl++,buf++)	55	for (int xc=icw,xo=x;xc;xc--,xo++,sl++,buf++)
56	{	56	{
57	if (xo>=cx1 && xo<=cx2)	57	if (xo>=cx1 && xo<=cx2)
Lines 87-99 Link Here
87	int scroller::bh() { if (vert) return 15; else return 13; }	87	int scroller::bh() { if (vert) return 15; else return 13; }
88	int scroller::bw() { if (vert) return 12; else return 14; }	88	int scroller::bw() { if (vert) return 12; else return 14; }
89		89
90	unsigned char *scroller::b1()	90	uint8_t *scroller::b1()
91	{	91	{
92	if (vert) return vs_up_arrow;	92	if (vert) return vs_up_arrow;
93	else return hs_left_arrow;	93	else return hs_left_arrow;
94	}	94	}
95		95
96	unsigned char *scroller::b2()	96	uint8_t *scroller::b2()
97	{	97	{
98	if (vert) return vs_down_arrow;	98	if (vert) return vs_down_arrow;
99	else return hs_right_arrow;	99	else return hs_right_arrow;
Lines 347-353 Link Here
347	void scroller::scroll_event(int newx, image screen, window_manager wm)	347	void scroller::scroll_event(int newx, image screen, window_manager wm)
348	{	348	{
349	screen->bar(x,y,x+l-1,y+h-1,wm->black());	349	screen->bar(x,y,x+l-1,y+h-1,wm->black());
350	int xa,ya,xo,yo;	350	int xa,ya,xo=0,yo;
351	if (vert) { xa=0; ya=30; yo=x+5; yo=y+5; } else { xa=30; ya=0; xo=x+5; yo=y+5; }	351	if (vert) { xa=0; ya=30; yo=x+5; yo=y+5; } else { xa=30; ya=0; xo=x+5; yo=y+5; }
352	for (int i=newx,c=0;c<30 && i<100;i++,c++)	352	for (int i=newx,c=0;c<30 && i<100;i++,c++)
353	{	353	{
Lines 390-396 Link Here
390	qsort((void *)lis,num_entries,sizeof(pick_list_item),lis_sort);	390	qsort((void *)lis,num_entries,sizeof(pick_list_item),lis_sort);
391		391
392	for (i=0;i<t;i++)	392	for (i=0;i<t;i++)
393	if (strlen(List[i])>wid)	393	if ((int)strlen(List[i])>wid)
394	wid=strlen(List[i]);	394	wid=strlen(List[i]);
395	cur_sel=sx=start_yoffset;	395	cur_sel=sx=start_yoffset;
396	}	396	}
Lines 425-435 Link Here
425	{	425	{
426	int found=-1;	426	int found=-1;
427	if (key_hist_total<20)	427	if (key_hist_total<20)
428	key_hist[key_hist_total++]=ev.key;	428	key_hist[(int)(key_hist_total++)]=ev.key;
429		429
430	for (int i=0;i<t && found==-1;i++)	430	for (int i=0;i<t && found==-1;i++)
431	{	431	{
432	if (strlen(lis[i].name)>=key_hist_total && memcmp(lis[i].name,key_hist,key_hist_total)==0)	432	if ((int)strlen(lis[i].name)>=key_hist_total && memcmp(lis[i].name,key_hist,key_hist_total)==0)
433	found=i;	433	found=i;
434	}	434	}
435	if (found!=-1)	435	if (found!=-1)
Lines 479-485 Link Here
479	screen->set_clip(x,y,x+l-1,y+h-1);	479	screen->set_clip(x,y,x+l-1,y+h-1);
480	int tw=(l+tex->width()-1)/tex->width();	480	int tw=(l+tex->width()-1)/tex->width();
481	int th=(h+tex->height()-1)/tex->height();	481	int th=(h+tex->height()-1)/tex->height();
482	int dy=y,dx;	482	int dy=y;
483	for (int j=0;j<th;j++,dy+=tex->height())	483	for (int j=0;j<th;j++,dy+=tex->height())
484	for (int i=0,dx=x;i<tw;i++,dx+=tex->width())	484	for (int i=0,dx=x;i<tw;i++,dx+=tex->width())
485	tex->put_image(screen,dx,dy);	485	tex->put_image(screen,dx,dy);
Lines 552-558 Link Here
552	sx=t-1;	552	sx=t-1;
553	if (m)	553	if (m)
554	{	554	{
555	select=(uchar *)jmalloc((t+7)/8,"selection bit array");	555	select=(uint8_t *)jmalloc((t+7)/8,"selection bit array");
556	memset(select,0,(t+7)/8);	556	memset(select,0,(t+7)/8);
557	} else cur_sel=0;	557	} else cur_sel=0;
558	}	558	}




color_filter::color_filter(spec_entry *e, bFILE *fp)
{
  fp->seek(e->offset,0);
  fp->read_uint16();
  int colors=32;
  color_table=(unsigned char *)jmalloc(colors*colors*colors,"color_filter : loaded");
  fp->read(color_table,colors*colors*colors);

int color_filter::write(bFILE *fp)
{
  int colors=32;
  fp->write_uint16(colors);
  return fp->write(color_table,colors*colors*colors)==colors*colors*colors;
}



  screen->add_dirty(x,y,x+xl-1,y+yl-1);

  uint8_t *pg1=screen->scan_line(y),*source,*dest;
  uint8_t *pg2=im->scan_line(y1);
  int i;
  for (int j=0;j<yl;j++)        
  {




  if (!fread(&PCX_header.version,1,1,fp)) return 0;  
  if (!fread(&PCX_header.encoding,1,1,fp)) return 0;  
  if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0;  
  PCX_header.xmin=read_uint16(fp);
  PCX_header.ymin=read_uint16(fp);  
  PCX_header.xmax=read_uint16(fp);
  PCX_header.ymax=read_uint16(fp);
  PCX_header.hres=read_uint16(fp);
  PCX_header.vres=read_uint16(fp);
  if (!fread(PCX_header.palette,1,48,fp)) return 0;
  if (!fread(&PCX_header.reserved,1,1,fp)) return 0;
  if (!fread(&PCX_header.color_planes,1,1,fp)) return 0;
  PCX_header.bytes_per_line=read_uint16(fp); 
  PCX_header.palette_type=read_uint16(fp); 
  if (!fread(PCX_header.filter,1,58,fp)) return 0;
  return 1;
}

  if (!fwrite(&PCX_header.version,1,1,fp)) return 0;  
  if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0;  
  if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0;  
  write_uint16(fp,PCX_header.xmin);
  write_uint16(fp,PCX_header.ymin);  
  write_uint16(fp,PCX_header.xmax);
  write_uint16(fp,PCX_header.ymax);
  write_uint16(fp,PCX_header.hres);
  write_uint16(fp,PCX_header.vres);
  if (!fwrite(PCX_header.palette,1,48,fp)) return 0;
  if (!fwrite(&PCX_header.reserved,1,1,fp)) return 0;
  if (!fwrite(&PCX_header.color_planes,1,1,fp)) return 0;
  write_uint16(fp,PCX_header.bytes_per_line); 
  write_uint16(fp,PCX_header.palette_type); 
  if (!fwrite(PCX_header.filter,1,58,fp)) return 0;
  return 1;
}




void read_chunk(wav_chunk &chunk, bFILE *fp)
{
  fp->read(&chunk.id,4);
  chunk.size=fp->read_uint32();
  fp->read(&chunk.type,4);  
}

void read_tag(wav_tag &tag, bFILE *fp)
{
  fp->read(&tag.id,4);
  tag.size=fp->read_uint32();
}

void read_wav_format(wav_format &fmt, bFILE *fp)
{
  fmt.fmt_tag=fp->read_uint16();
  fmt.channels=fp->read_uint16(); 
  fmt.samplesps=fp->read_uint32();
  fmt.avg_bytesps=fp->read_uint32();  
  fmt.align=fp->read_uint16();  
}


void read_pcm(pcm_wave &pcm, bFILE *fp)
{
  read_wav_format(pcm.wf,fp);
  pcm.bitsps=fp->read_uint16();  
}




  /***************  Write the chunk ***************************/
  fp->write((void *)"RIFF",4);  
  fp->write_uint32(data_size+36);
  fp->write((void *)"WAVE",4);


  /************** Write the tag *******************************/
  fp->write((void *)"fmt ",4);
  fp->write_uint32(16);
  
  
  /************** Write PCM ***********************************/
  fp->write_uint16(1);          // format_tag
  fp->write_uint16(1);          // mono recording
  fp->write_uint32(sample_rate);
  fp->write_uint32(sample_rate);   // average bytes per sec
  fp->write_uint16(1);    // alignment? Don't know what this does?
  fp->write_uint16(8);    // 8 bits per sample
  
  /************* Write data tag ******************************/
  fp->write((void *)"data",4);
  fp->write_uint32(data_size);

  /************ Now write sample data ************************/
  fp->write(data,data_size);

  ERROR((unsigned int)fp->read(data,tag.size)==tag.size,"Premature end of file");
  ERROR(pcm.bitsps==8,"Only 8-bit samples supported");
  ERROR(pcm.wf.channels==1,"Only mono samples supported");  
  ERROR(pcm.wf.align==1,"Bad block alignment");   
  delete fp;
  return data;
}




int bits_per_item, bits_used, bit_shift, bits_per_pixel, pixel_mask;
int bit_order, byte_swap;
char buf[4];
uint8_t *byteP;
uint16_t *shortP;
uint32_t *longP;


uint32_t bs_uint32(uint32_t s);
uint16_t bs_uint16(uint16_t s );
short bs_short(short s );


image *getinit(FILE *file, palette *&pal, int *padrightP)
{
  /* Assume X11 headers are larger than X10 ones. */
  uint8_t header[sizeof(X11WDFileHeader)];
  image *im;
  X11WDFileHeader *h11P;
  char junk[800];
  unsigned int i;
  int dummy1, dummy2, dummy3;
  uint16_t minred, maxred;
  X11XColor x11col;

  h11P = (X11WDFileHeader *) header;

  bit_order = h11P->bitmap_bit_order;
  pixel_mask = ( 1 << bits_per_pixel ) - 1;

  byteP = (uint8_t *) buf;
  shortP = (uint16_t *) buf;
  longP = (uint32_t *) buf;
  return im;
}

void getimage(FILE *file,image *im,int pad)
{
  int i,j;
  uint8_t *sl;
#if BYTE_ORDER!=BIG_ENDIAN
  printf("little guys\n");
#endif

	  case 8:
	    break;

	  case 16: *shortP=uint16_swap(*shortP); break;

	  case 32: *longP=uint32_swap(*longP); break;

	  default:
	    fprintf(stderr, "can't happen" );

}


uint16_t bs_uint16(uint16_t s )
{
  uint16_t ss;
  uint8_t *bp, t;

  ss = s;
  bp = (uint8_t *) &ss;
  t = bp[0];
  bp[0] = bp[1];
  bp[1] = t;
  return ss;
}

uint32_t bs_uint32(uint32_t l )
{
  uint32_t ii;
  uint8_t *bp, t;

  ii = l;
  bp = (uint8_t *) &ii;
  t = bp[0];
  bp[0] = bp[3];
  bp[3] = t;

  return ii;
}

long bs_long(long l )
{
  return bs_int( l );
}

struct BMP_header
{
  char id[2];
  long filesize;
  int16_t reserved[2];
  long headersize,infosize,width,height;
  int16_t biplanes,bits;
  long bicompression, bisizeimage, bixpelspermeter, biypelspermeter,
       biclrused,biclrimportant;
} bmp;

int read_BMP_header(FILE *fp)
{
  if (!fread(&bmp.id,1,2,fp)) return 0;         // 2 0
  bmp.filesize=read_uint32(fp);                   // 4 4
  if (!fread(bmp.reserved,1,4,fp)) return 0;    // 4 8
  bmp.headersize=read_uint32(fp);                 // 4 12
  bmp.infosize=read_uint32(fp);                   // 4 16
  bmp.width=read_uint32(fp);                      // 4 20
  bmp.height=read_uint32(fp);                     // 4 24
  bmp.biplanes=read_uint16(fp);                  // 2 26
  bmp.bits=read_uint16(fp);                      // 2 28
  bmp.bicompression=read_uint32(fp);              // 4 32
  bmp.bisizeimage=read_uint32(fp);                // 4 36
  bmp.bixpelspermeter=read_uint32(fp);            // 4 40
  bmp.biypelspermeter=read_uint32(fp);            // 4 44
  bmp.biclrused=read_uint32(fp);                  // 4 48
  bmp.biclrimportant=read_uint32(fp);             // 4 52
  return 1;
  
}

  if (!im)
    return NULL;
  
  uint8_t *sl;
  int trailer=im->width()%4;
  if (trailer==1) trailer=3;
  else if (trailer==3) trailer=1;
  uint8_t buf[9];
  for (i=im->height();i;i--)
  {
    sl=im->scan_line(i-1);

{
  image *im;
  FILE *fp;
  uint8_t pal_quad[4];
  char *scrap;
  int bytes,i;
  fp=fopen(filename,"rb");

int write_BMP_header(FILE *fp)
{
  if (!fwrite(&bmp.id,1,2,fp)) return 0;  
  write_uint32(fp,bmp.filesize);  
  if (!fwrite(bmp.reserved,1,4,fp)) return 0;   
  write_uint32(fp,bmp.headersize);
  write_uint32(fp,bmp.infosize);  
  write_uint32(fp,bmp.width);
  write_uint32(fp,bmp.height);
  write_uint16(fp,bmp.biplanes);
  write_uint16(fp,bmp.bits);
  write_uint32(fp,bmp.bicompression);
  write_uint32(fp,bmp.bisizeimage);
  write_uint32(fp,bmp.bixpelspermeter);
  write_uint32(fp,bmp.biypelspermeter);
  write_uint32(fp,bmp.biclrused);
  write_uint32(fp,bmp.biclrimportant);   
  return 1;
  
}

{
  FILE *fp;
  int i,bytes;
  uint8_t pal_quad[4];
  fp=fopen(filename,"wb");
  if (!fp)
  { printf("Error : unable to open %s for writing!\n",filename);




long *longP;


int32_t bs_int32(int32_t s);
int16_t bs_int16(int16_t s );
short bs_short(short s );


HBITMAP getinit(FILE *file, palette *&pal, int *padrightP, int &xres, int &yres);)

}


short bs_int16(short s )
{
  short ss;
  unsigned char *bp, t;

  return ss;
}

int32_t bs_int32(int32_t l )
{
  int32_t ii;
  uint8_t *bp, t;

  ii = i;
  bp = (uint8_t *) &ii;
  t = bp[0];
  bp[0] = bp[3];
  bp[3] = t;

  return ii;
}

long bs_long(long l )
{
  return bs_int( l );
}

struct BMP_header
{
  char id[2];

{
  FILE *fp;
  int i,bytes;
  uint8_t pal_quad[4];
//  fp=fopen("d:\\windows\\256color.bmp","rb");
//  fread(&bmp,1,sizeof(bmp),fp);
//  fclose(fp);

image *image24(image *im, palette *pal, int rev)
{
  image *ni;
  uint8_t *sl1,*sl2;
  int i,x;
  uint8_t r,g,b;
  printf("Creating image size (%d, %d)\n",im->width()*3,im->height());
  ni=new image(im->width()*3,im->height());
  printf("Image created\n");

  return ni;
}

uint8_t addb(int n1, int n2)
{ int n3;
  n3=n1+n2;
  return n3>255 ? 255 : (n3<0 ? 0 : n3);

image *color_dither(image *im, palette *pal, int rev)
{
  image *i24;
  uint8_t min[3],max[3],mid[3],*ad,*sl,*sl2,crimp;
  int i,j,x,y,delta;
  (void *)ad=pal->addr();


      display=0,bad=0,bmp=0,land=0,ch,xo=0,yo=0;
  image *im,*i24;
  palette *pal;
  uint8_t *sl;
  FILE *fp;
  char def_name[10],*dev_name,*fname=NULL;
  uint8_t cp[500],mp[500],yp[500],kp[500];
  strcpy(def_name,"\\dev\\lp");  // set the default output device to /dev/lp
		// since we are in vpix, however we will use the backslash
  dev_name=def_name; rev=0;





palette::palette(bFILE *fp)
{
  ncolors=fp->read_uint16();
  pal=(color *)jmalloc(sizeof(color)*ncolors,"palette");
  usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
  set_all_unused();

palette::palette(spec_entry *e, bFILE *fp)
{
  fp->seek(e->offset,0);
  ncolors=fp->read_uint16();
  pal=(color *)jmalloc(sizeof(color)*ncolors,"palette");
  usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
  set_all_unused();


int palette::write(bFILE *fp)
{
  fp->write_uint16(ncolors);
  return fp->write(pal,sizeof(color)*ncolors)==ncolors;
}


  return find;
}

uint32_t palette::getquad(int x)
{ char entry[4];
  entry[3]=0;
  entry[2]=pal[x].red;
  entry[1]=pal[x].green;
  entry[0]=pal[x].blue;
  return *((uint32_t *)entry);
}



  long brv;
  brv=0; bri=0;

  for (i=0;i<(unsigned int)ncolors;i++)
  { if (all || used(i))
    {
      get(i,r,g,b);

  long brv,x;
  brv=(long)258*(long)258*(long)258; bri=0;

  for (i=0;i<(unsigned int)ncolors;i++)
  { if (all || used(i))
    {
      get(i,r,g,b);


void palette::fade_to(int total_fades, int fade_on, int dest_r, int dest_g, int dest_b)
{
  uint8_t *sl=(uint8_t *)addr();
  uint8_t x;
  int i;
  for (i=0;i<ncolors;i++)
  {
    x=(( dest_r-(int)*sl)*fade_on/total_fades+*sl);
    *(sl++)=x;
    x=(( dest_g-(int)*sl)*fade_on/total_fades+*sl);
    *(sl++)=x;
    x=(( dest_b-(int)*sl)*fade_on/total_fades+*sl);    
    *(sl++)=x;
  }  
}




image *read_glfont(char *fn)
{
  image *im,*sub;
  uint16_t length,y;
  uint8_t size,first,width,height,gsize,last;
  FILE *fp;
  fp=fopen(fn,"rb");
  if (!fp) return NULL;
  fread(&length,1,2,fp);  length=uint16_to_local(length);
  fread(&size,1,1,fp);
  fread(&first,1,1,fp);
  if (size+first>255) { set_error(imFILE_CORRUPTED); fclose(fp); return NULL; }

{
  image *im;
  char x[4],bpp;
  uint8_t *sl=NULL,esc,c,n,marker,vmode;
  uint16_t w,h,len,bufsize,blocks,sn,esize,edesc;
  int xx,yy;
  FILE *fp;
  im=NULL;

  fread(&x[0],1,2,fp);
  fread(&w,1,2,fp);
  fread(&h,1,2,fp);
  w=uint16_to_local(w);  h=uint16_to_local(h);
  fread(x,1,4,fp);
  fread(&bpp,1,1,fp);
  fread(&marker,1,1,fp);


  fread(&vmode,1,1,fp);
  fread(&edesc,1,2,fp);
  edesc=uint16_to_local(edesc);
  fread(&esize,1,2,fp);
  esize=uint16_to_local(esize);
  if (esize==768 && !pal)
  { pal=new palette(1<<bpp);
    fread(pal->addr(),1,(1<<bpp)*3,fp);

  else if (esize)
    fseek(fp,esize,SEEK_CUR);
  fread(&blocks,1,2,fp);
  blocks=uint16_to_local(blocks);

  yy=h; xx=w;

  while (blocks-- && w>=1 && yy>=0)
  {
    fread(&bufsize,1,2,fp);
    bufsize=uint16_to_local(bufsize);
    fread(&len,1,2,fp);
    len=uint16_to_local(len);
    fread(&esc,1,1,fp);
    while (yy>=0 && len)
    {

	else
	{
	  fread(&sn,1,2,fp);
	  sn=uint16_to_local(sn);
	  fread(&c,1,1,fp);
	  while (sn-- && yy>=0 && len)
	  {




  }
  else
  {
    int32_t size=read_other_uint32(fp);
    fread(type,1,4,fp);    
    if (memcmp(type,"PBM ",4))
    {

    }
    else
    {
      int32_t ssize;    
      char stype[4];
      int16_t w=0,h=0,x,y,tcolor,pagew,pageh;
      char planes,masking,compr=0,padl,xa,ya;
      
      while (ftell(fp)+4<size)
      {
	fread(stype,1,4,fp);
	ssize=read_other_uint32(fp);
        if (ssize &1) ssize++;            // specs say all chunks are padded by 2
	if (!memcmp(stype,"BMHD",4))
	{
	  w=read_other_uint16(fp);
	  h=read_other_uint16(fp);
	  x=read_other_uint16(fp);
	  y=read_other_uint16(fp);
	  planes=fgetc(fp);
	  masking=fgetc(fp);
	  compr=fgetc(fp);
	  padl=fgetc(fp);
	  tcolor=read_other_uint16(fp);
	  xa=fgetc(fp);
	  ya=fgetc(fp);
	  pagew=read_other_uint16(fp);
	  pageh=read_other_uint16(fp);
	} else if (!memcmp(stype,"CMAP",4))
	{
	  pal=new palette(256);

	{
	  if (im) delete im;  // shouldn't be two BODY's butjust in case...
	  im=new image(w,h);
	  int y;
	  if (!compr)
	  {
	    for (y=0;y<h;h++)





void trans_image::make_color(int c)
{
  uint8_t *dp=data;
  int y,x;
  for (y=0;y<h;y++)
  {

image *trans_image::make_image()
{
  image *im=new image(w,h);
  uint8_t *d=im->scan_line(0),*dp=data,*dline;
  int y,x;
  for (y=0;y<h;y++)
  {

trans_image::trans_image(image *im, char *name)
{
  int size=0,x,y;
  uint8_t *sl,*datap,*marker; 
  w=im->width();
  h=im->height();
  

#ifdef MEM_CHECK
  char st[80];
  sprintf(st,"trans_image::data (%s)",name);
  data=(uint8_t *)jmalloc(size,st);
#else
  data=(uint8_t *)jmalloc(size,"");
#endif
  int ww=im->width(),hh=im->height();
  datap=data;


void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent   
{
  int16_t x1,y1,x2,y2;
  screen->get_clip(x1,y1,x2,y2);
  if (y+line<y1 || y+line>y2 || x>x2 || x+w-1<x1)            // clipped off completely?
    return;

  uint8_t *datap=data;
  int ix;  
  while (line)            // skip scan line data until we get to the line of interest
  {

  
  
  // now slam this list of runs to the screen
  uint8_t *screen_line=screen->scan_line(y)+x;
    
  for (ix=0;ix<w;)             
  {      

}


inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2, 
				   int x, int &y, int &ysteps)
{
  // check to see if it is total clipped out first
  if (y+h<=y1 || y>y2 || x>x2 || x+w<=x1)
    return NULL;

  register uint8_t *datap=data;  


  ysteps=height();

} 

void trans_image::put_image_filled(image *screen, int x, int y, 
				   uint8_t fill_color)
{
 int16_t x1,y1,x2,y2;
  int chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
  if (!datap) return ;     // if clip_y says nothing to draw, return
  
  screen_line=screen->scan_line(y)+x;  

  }    
}

void trans_image::put_image_offseted(image *screen, uint8_t *s_off)   // if screen x & y offset already calculated save a mul
{
  int ix,ysteps=height();
  int screen_skip=screen->width()-w;
  uint8_t skip,*datap=data;
  for (;ysteps;ysteps--)
  {
    for (ix=0;ix<w;)


void trans_image::put_image(image *screen, int x, int y) 
{
  int16_t x1,y1,x2,y2;
  int chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
  if (!datap) return ;     // if clip_y says nothing to draw, return
  
  screen_line=screen->scan_line(y)+x;  

  }    
}

void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap) 
{
  int16_t x1,y1,x2,y2;
  int chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
  if (!datap) return ;     // if clip_y says nothing to draw, return
  
  screen_line=screen->scan_line(y)+x;  

	    else
	      counter=slam_length;

	    register uint8_t *sl=screen_line+ix,*sl2=datap;
	    ix+=slam_length;	    
	    datap+=slam_length;
	    while (counter)




void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2) 
{
  int16_t x1,y1,x2,y2;
  int chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
  if (!datap) return ;     // if clip_y says nothing to draw, return
  
  screen_line=screen->scan_line(y)+x;  

	    else
	      counter=slam_length;

	    register uint8_t *sl=screen_line+ix,*sl2=datap;
	    ix+=slam_length;	    
	    datap+=slam_length;
	    while (counter)

			   int frame_on, int total_frames, 
			   color_filter *f, palette *pal) 
{
  int16_t x1,y1,x2,y2;
  int ix,slam_length,chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                *screen_line;
  if (!datap) return ;

  uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
                *caddr1,*caddr2,r_dest,g_dest,b_dest;

  long fixmul=(frame_on<<16)/total_frames;


void trans_image::put_fade_tint(image *screen, int x, int y,
				int frame_on, int total_frames, 
				uint8_t *tint,
				color_filter *f, palette *pal) 
{
  int16_t x1,y1,x2,y2;
  int ix,slam_length,chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                *screen_line;
  if (!datap) return ;

  uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
                *caddr1,*caddr2,r_dest,g_dest,b_dest;

  long fixmul=(frame_on<<16)/total_frames;


void trans_image::put_color(image *screen, int x, int y, int color) 
{
  int16_t x1,y1,x2,y2;
  int ix,slam_length,chop_length,ysteps;
  
  screen->get_clip(x1,y1,x2,y2);
  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                *screen_line;
  if (!datap) return ;
  

   	           int blendx, int blendy, int blend_amount, color_filter *f, palette *pal)

{
  int16_t x1,y1,x2,y2;
  int ix,slam_length,chop_length,ysteps;
  uint8_t *paddr=(uint8_t *)pal->addr();  
  
  screen->get_clip(x1,y1,x2,y2);
  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                *blend_line,*screen_line;
  if (!datap) return ;
  CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");

	      chop_length=x2-x-ix;
	    else chop_length=slam_length;

	    uint8_t *screen_run=screen_line+x+ix,
	                  *blend_run=blend_line+x+ix-blendx,
	                  *caddr1,*caddr2,r_dest,g_dest,b_dest;      
              


void trans_image::put_predator(image *screen, int x, int y) 
{
  int16_t x1,y1,x2,y2;
  int chop_length,ysteps;

  screen->get_clip(x1,y1,x2,y2);
  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
  if (!datap) return ;     // if clip_y says nothing to draw, return

  // see if the last scanline is clipped off


int trans_image::size()
{
  uint8_t *d=data;
  int t=0;
  for (int y=0;y<h;y++)
  {




#include <string.h>


int packet::advance(int32_t offset)
{
  ro+=offset;
  return ro<=rend;
}

void packet::write_uint32(uint32_t x)
{
  x=lltl(x);
  write((uint8_t *)&x,4);
}

void packet::write_uint16(uint16_t x)
{
  x=lstl(x);
  write((uint8_t *)&x,2);
}

void packet::write_uint8(uint8_t x)
{
  write(&x,1);
}

#endif

  buf_size=1000;
  buf=(uint8_t *)jmalloc(buf_size,"packet buffer");
  reset(); 

#ifdef MANAGE_MEM

  if (buf_size<max)
  {
    buf_size=max;
    buf=(uint8_t *)jrealloc(buf,max,"packet buffer"); 
  }
}

int packet::read(uint8_t *buffer, int size)
{
  if (size>rend-ro)
    size=rend-ro;

}


int packet::write(uint8_t *buffer, int size)
{
  if (size>buf_size-wo)
    make_bigger(wo+size);




// images.  Note, only the mode 320x200x256 is sopprted here for saving
// images.  All images should be sized so they will fit on an mdl screen
// but no checking of that is done hhere.
void write_mdl(image **images, int16_t total_images, palette *pal,char *fn,
		int16_t firstpage, int16_t images_per_page)
{
  FILE *fp;
  char buf[18];
  uint16_t xy[2],x;
  char name[13],page;
  unsigned char *c;
  int16_t i;
  palette *np;
  clear_errors();
  CONDITION(images && pal && fn && total_images>0,"bad parms");

    {
      memset(buf,0,6);            // each image has 6 bytes of reserved 0
      fwrite(buf,6,1,fp);
      xy[0]=uint16_to_intel(i%100+20); xy[1]=uint16_to_intel(30);  // the x and y position on the screen
      fwrite(xy,4,1,fp);
      sprintf(name,"JC%-10d",i);  // set the name of the image
      fwrite(name,12,1,fp);

      page=firstpage+i/images_per_page;

      fwrite(&page,1,1,fp);         // put all of the image on the first page
      xy[0]=uint16_to_intel(images[i]->width()*images[i]->height()+4);  // calc the size of the image
    
      fwrite(xy,2,1,fp);
      xy[0]=uint16_to_intel(images[i]->width());
      fwrite(xy,2,1,fp);
      xy[0]=uint16_to_intel(images[i]->height());
      fwrite(xy,2,1,fp);
      for (x=0;x<(uint16_t)images[i]->height();x++)   // write all the scan_lines for the
      { c=images[i]->scan_line(x);            // image
	fwrite(c,images[i]->width(),1,fp);
      }

  }
}

int16_t mdl_total_images(char *fn)
{
  char buf[800];
  uint16_t xy[2],t;
  FILE *fp;
  fp=fopen(fn,"rb");
  if (!fp)

  { if (fread(buf,1,23,fp)==23)
    {
      fread(xy,2,1,fp);
      xy[0]=uint16_to_local(xy[0]);
      fseek(fp,xy[0],SEEK_CUR);
      t++;
    }

// read_mdl returns an array containing pointers to all the desired images
// and a palette that is read form the file
// to load image numbers 4 through 9 let start =4, end=9
image **read_mdl(char *fn, palette *&pal, int16_t startn, int16_t endn, int16_t &total)
{
  FILE *fp;
  image **im;
  char buf[50];
  uint16_t xy[2],i,j;
  clear_errors();
  make_block(sizeof(FILE));
  im=NULL;

      { if (fread(buf,1,23,fp)!=23)
	  set_error(imFILE_CORRUPTED);
	fread(xy,2,1,fp);
	xy[0]=uint16_to_local(xy[0]);
	fseek(fp,xy[0],SEEK_CUR);
	startn--; if (endn>0) endn--;
      }

  	  if (fread(&j,1,2,fp)!=2) set_error(imFILE_CORRUPTED);
	  else
	  {
	    j=uint16_to_local(j);
	    j-=4;
            xy[0]=5; xy[1]=5;
	    if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);
	    make_block(sizeof(image));
	    xy[0]=uint16_to_local(xy[0]);
	    xy[1]=uint16_to_local(xy[1]);
	    im[startn]=new image(xy[0],xy[1]);
	    total++;
	    for (i=0;i<xy[1];i++)




#include "specs.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <ctype.h>
#include <fcntl.h>
#include "system.h"

                    "Palette",                  // 2
                    "Invalid Type",             // 3
                    "Image",                    // 4
                    "Fore Tile",
                    "Back Tile",
                    "Character",
                    "8 Morph",
                    "16 Morph",
                    "Grue objs",
                    "Extern WAV",
                    "DMX MUS",
                    "Patched morph",
                    "Normal file",
                    "Compress1 file",
                    "Vector Image",
                    "Light list",
                    "Grue fgmap",
                    "Grue bgmap",
                    "Data array",
                    "Character2",
                    "Particle",
                    "Extern lcache"
};



{
  if (wbuf_end!=0)
  {
    unsigned long ret=unbuffered_write(wbuf,wbuf_end);
    if (ret!=wbuf_end && no_space_handle_fun)
      no_space_handle_fun();
      

  {
    if (rbuf_start<rbuf_end)
    {
      unsigned int avail_size=rbuf_end-rbuf_start;
      int copy_size=avail_size>count ? count : avail_size;
      memcpy(buf,rbuf+rbuf_start,copy_size);
      buf=(void *)(((unsigned char *)buf)+copy_size);

      count-=copy_size;
      buf=(void *)(((char *)buf)+copy_size);
      if (wbuf_end==wbuf_size)
        if ((unsigned int)flush_writes()!=wbuf_size)
	  return total_written;
      
      total_written+=copy_size;      

    return total_written;
  } else
  {
    unsigned long ret=unbuffered_write(buf,count);
    if (ret!=count && no_space_handle_fun)
      no_space_handle_fun();
  }

  if (whence==SEEK_CUR) offset+=curpos;
  else if (whence==SEEK_END) offset=file_size()-offset;

  if (offset<realpos-(long)rbuf_end || offset>=realpos)
  {
    rbuf_start=rbuf_end=0;
    unbuffered_seek(offset,SEEK_SET);

  
#if (defined(__APPLE__) && !defined(__MACH__))
  spec_main_jfile.open_external(filename,"rb",O_BINARY|O_RDONLY);
  spec_main_fd = spec_main_jfile.get_fd();
  spec_main_sd.startup(&spec_main_jfile);
#else
  spec_main_jfile.open_external(filename,"rb",O_RDONLY);
#endif
  spec_main_fd = spec_main_jfile.get_fd();
  if (spec_main_fd==-1)
    return;
  spec_main_sd.startup(&spec_main_jfile);
#endif
}

void fast_load_start_recording(char *filename)

    if ((flags&O_APPEND)==0) 
    {
      skip_size=1;
      //int errval = unlink(tmp_name);
    }

    flags-=O_WRONLY;

      spec_entry *se=spec_main_sd.find(filename);
      if (se)    
      {
	start_offset=se->offset;
	current_offset = 0;
	file_length=se->size;
	rbuf_start=rbuf_end=0;
      } else 
      {
	close(fd);
	fd=-1;
      }
    }  
  }


int jFILE::unbuffered_read(void *buf, size_t count)
{
	unsigned long len;

	if (fd == spec_main_fd)
	{

			
			len = ::read(fd,(char*)buf,count);
			::write(fast_load_fd,(char*)&len,sizeof(len));
			::write(fast_load_fd,(char*)buf,len);
			break;
		case 2:
			::read(fast_load_fd,(char*)&len,sizeof(len));

		case 1:
	  	len = ::read(fd,(char*)buf,count);
			::write(fast_load_fd,(char*)&len,sizeof(len));
			::write(fast_load_fd,(char*)buf,len);
	  	break;
		case 2:
			::read(fast_load_fd,(char*)&len,sizeof(len));


int jFILE::unbuffered_seek(long offset, int whence) // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success
{
  long ret;

  if (fast_load_mode == 2)
  {
    switch (whence)
    {
    case SEEK_SET : 
      current_offset = start_offset+offset;
      break;
    case SEEK_END : 
      current_offset = start_offset+file_length-offset;
      break;
    case SEEK_CUR : 
      current_offset += offset;
      break;
    default:
      ret = -1;
      break;
    }
    return current_offset;
  }

  switch (whence)
  {
    case SEEK_SET : 

  }
  if (ret>=0)
  {
    current_offset = ret - start_offset;
    if (spec_main_fd == fd)
      spec_main_offset = ret;
    return ret;
  }
  else
    return -1;  // if a bad whence, then failure
}


uint8_t bFILE::read_uint8()
{ uint8_t x;
  read(&x,1);
  return x;
}

uint16_t bFILE::read_uint16()
{ 
  uint16_t x;
  read(&x,2); 
  return uint16_to_local(x);
}


uint32_t bFILE::read_uint32()
{ 
  uint32_t x;
  read(&x,4); 
  return uint32_to_local(x);
}

void bFILE::write_uint8(uint8_t x)
{
  write(&x,1);
}

void bFILE::write_uint16(uint16_t x)
{ 
  x=uint16_to_local(x);
  write(&x,2);
}


void bFILE::write_uint32(uint32_t x)
{
  x=uint32_to_local(x);
  write(&x,4);
}

void bFILE::write_double(double x)
{
  double a;
  write_uint32((long)(modf(x,&a)*(double)(1<<32-1)));
  write_uint32((long)a);
}

double bFILE::read_double()
{
  long a,b;
  a=read_uint32();
  b=read_uint32();
  return (double)b+a/(double)(1<<32-1);
}


void spec_directory::startup(bFILE *fp)
{
  char buf[256];
  memset(buf,0,256);
  fp->read(buf,8);
  buf[9]=0;
  size=0;
  if (!strcmp(buf,SPEC_SIGNATURE))
  {    
    total=fp->read_uint16();   
    entries=(spec_entry **)jmalloc(sizeof(spec_entry *)*total,"spec_directory::entries");
    long start=fp->tell();


      fp->read(se->name,len);
      fp->read(&flags,1); 

      se->size=fp->read_uint32();
      se->offset=fp->read_uint32();
      dp+=((sizeof(spec_entry)+len)+3)&(~3);
    }
  }

  strcpy(sig,SPEC_SIGNATURE);

  if (fp->write(sig,sizeof(sig))!=sizeof(sig))    return 0;
  fp->write_uint16(total);


  int i;

    flags=0;
    if (fp->write(&flags,1)!=1)                     return 0; 

    data_size=uint32_to_intel((*e)->size); 
    if (fp->write((char *)&data_size,4)!=4)              return 0; 
    offset=uint32_to_intel((*e)->offset);
    if (fp->write((char *)&offset,4)!=4)                  return 0; 

  }


}

uint16_t read_uint16(FILE *fp)
{
  uint16_t x;
  fread(&x,1,2,fp); 
  return uint16_to_local(x);
}

uint32_t read_uint32(FILE *fp)
{
  uint32_t x;
  fread(&x,1,4,fp);
  return uint32_to_local(x);
}
void write_uint16(FILE *fp, uint16_t x)
{
  x=uint16_to_local(x);
  fwrite(&x,1,2,fp);
}

void write_uint32(FILE *fp, uint32_t x)
{
  x=uint32_to_local(x);
  fwrite(&x,1,4,fp);
}

uint8_t read_uint8(FILE *fp) { return fgetc(fp)&0xff; }
void write_uint8(FILE *fp, uint8_t x) { fputc((unsigned char)x,fp); }

uint32_t read_other_int32(FILE *fp)
{
  uint32_t x;
  fread(&x,1,4,fp);
  return big_uint32_to_local(x);
}

uint16_t read_other_uint16(FILE *fp)
{
  uint16_t x;
  fread(&x,1,2,fp);
  return big_uint16_to_local(x);
}


void write_other_uint16(FILE *fp, uint16_t x)
{
  x=big_uint16_to_local(x);
  fwrite(&x,1,2,fp);
}

void write_other_int32(FILE *fp, uint32_t x)
{
  x=big_uint32_to_local(x);
  fwrite(&x,1,4,fp);
}





#endif
#include <stdlib.h>

extern uint8_t current_background;
char *imerr_messages[]={"No error",
      		 	"Error occured while reading",
			"Incorrect file type",

			"Error occured while writing, (disk full?)"};
			
                         
int16_t imerror=0;
int16_t swpfile_num=0;

int16_t current_error()
{ return imerror; }

void clear_errors()

  }
}

void set_error(int16_t x)
{ imerror=x; }

int16_t last_error()
{
  int16_t ec;
  ec=imerror;
  imerror=0;
  return ec;

linked_list image_list;


image_descriptor::image_descriptor(int16_t length, int16_t height,
				   int keep_dirties, int static_memory)

{ clipx1=0; clipy1=0; 

  static_mem=static_memory;  
}

void image::change_size(int16_t new_width, int16_t new_height, uint8_t *page)
{
  delete_page();
  w=new_width;

  if (dat) jfree((char *)dat);
}

uint8_t image::pixel(int16_t x, int16_t y)
{
  CONDITION(x>=0 && x<width() && y>=0 && y<height(),
     "image::pixel Bad pixel xy");
  return (*(scan_line(y)+x));
}

void image::putpixel(int16_t x, int16_t y, char color)
{
  CONDITION(x>=0 && x<width() && y>=0 && y<height(),
     "image::putpixel Bad pixel xy");

}


image::image(int16_t width, int16_t height, uint8_t *page_buffer, int16_t create_descriptor)
{
  w=width;
  h=height;  


image::image(spec_entry *e, bFILE *fp)
{
  int16_t i; 
  fp->seek(e->offset,0);
  w=fp->read_uint16();
  h=fp->read_uint16();
  special=NULL;
  make_page(w,h,NULL);
  for (i=0;i<h;i++)


image::image(bFILE *fp)
{
  int16_t i; 
  w=fp->read_uint16();
  h=fp->read_uint16();
  special=NULL;
  make_page(w,h,NULL);
  for (i=0;i<h;i++)


void image_init()
{
  uint8_t bt[2];
  uint16_t wrd,*up;
  bt[0]=1;
  bt[1]=0;
  up=(uint16_t *)bt;
  wrd=uint16_to_intel(*up);
  if (wrd!=0x01)
  { printf("Compiled under wrong ENDING-nes, edit system.h and try again\n");
    printf("1 (intel) = %d\n",(int)wrd);

}


int32_t image::total_pixels(uint8_t background)
{
  int16_t i,j;
  int32_t co;
  uint8_t *c;
  for (co=0,i=height()-1;i>=0;i--)
  { c=scan_line(i);
    for (j=width()-1;j>=0;j--,c++)

  return co;
}

void image::clear(int16_t color)
{
  int16_t i;
  if (color==-1) color=current_background;
  if (special)
  { if (special->x1_clip()<=special->x2_clip())

image *image::copy()
{
  image *im;
  uint8_t *c,*dat;
  int i;
  dat=(uint8_t *)jmalloc(width(),"image copy");
  im=new image(width(),height());
  for (i=height()-1;i>=0;i--)
  { c=scan_line(i);




void image::line(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
{
  int16_t i,xc,yc,er,n,m,xi,yi,xcxi,ycyi,xcyi;
  unsigned dcy,dcx;
  // check to make sure that both endpoint are on the screen

  int16_t cx1,cy1,cx2,cy2;

  // check to see if the line is completly clipped off
  get_clip(cx1,cy1,cx2,cy2);  

}


void image::put_image(image *screen, int16_t x, int16_t y, char transparent)
{
  int16_t i,j,xl,yl;
  uint8_t *pg1,*pg2,*source,*dest;
  if (screen->special)  // the screen is clipped then we onl want to put
		    // part of the image
    put_part(screen,x,y,0,0,width()-1,height()-1,transparent);

  }
}

void image::fill_image(image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t align)
{
  int16_t i,j,w,xx,start,xl,starty;
  uint8_t *pg1,*pg2;
  CHECK(x1<=x2 && y1<=y2);  // we should have gotten this

  if (screen->special)

    return ;
  screen->add_dirty(x1,y1,x2,y2);
  w=width();
  if (align)
  {
    start=x1%w;
    starty=y1%height();

}


void image::put_part(image *screen, int16_t x, int16_t y,
		int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
{
  int16_t xl,yl,j,i;
  int16_t cx1,cy1,cx2,cy2;
  uint8_t *pg1,*pg2,*source,*dest;
  CHECK(x1<=x2 && y1<=y2);

  screen->get_clip(cx1,cy1,cx2,cy2);

  }    
}

void image::put_part_xrev(image *screen, int16_t x, int16_t y,
		int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
{
  int16_t xl,yl,j,i;
  int16_t cx1,cy1,cx2,cy2;
  uint8_t *pg1,*pg2,*source,*dest;
  CHECK(x1<=x2 && y1<=y2);

  i=x1; x1=width()-x2-1;  // reverse the x locations

}


void image::put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
		int16_t maskx, int16_t masky,
		int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
  int16_t xl,yl,j,i,ml,mh;
  int16_t cx1,cy1,cx2,cy2;
  uint8_t *pg1,*pg2,*pg3;
  CHECK(x1<=x2 && y1<=y2);

  if (screen->special)




uint8_t image::brightest_color(palette *pal)
{ uint8_t *p,r,g,b,bri;
  int16_t i,j;
  int32_t brv;
  brv=0; bri=0;
  for (j=0;j<h;j++)
  {
    p=scan_line(j);
    for (i=0;i<w;i++)
    { pal->get(p[i],r,g,b);
      if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
      { brv=(int32_t)r*(int32_t)g*(int32_t)b;
	bri=p[i];
      }
    }

  return bri;
}

uint8_t image::darkest_color(palette *pal, int16_t noblack)
{ uint8_t *p,r,g,b,bri;
  int16_t i,j;
  int32_t brv,x;
  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
  for (j=0;j<h;j++)
  {
    p=scan_line(j);
    for (i=0;i<w;i++)
    { pal->get(p[i],r,g,b);
      x=(int32_t)r*(int32_t)g*(int32_t)b;
      if (x<brv && (x || !noblack))
      { brv=x;
	bri=p[i];

  return bri;
}

void image::rectangle(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
{
  line(x1,y1,x2,y1,color);
  line(x2,y1,x2,y2,color);

  line(x1,y1,x1,y2,color);
}

void image::set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
  // If the image does not already have an Image descriptor, allocate one.


		       // should be it will adjust to fit wiothin the image.
}

void image::get_clip (int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
{
  if (special)
    special->get_clip(x1,y1,x2,y2);

  { x1=0; y1=0; x2=width()-1; y2=height()-1; }
}

void image::in_clip  (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
  if (special)
  {

void image_descriptor::reduce_dirties()
{
  dirty_rect *p,*q;
  int16_t x1,y1,x2,y2,nn;
  x1=6000; y1=6000;
  x2=0; y2=0;
  p=(dirty_rect *)dirties.first();


void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
{
  int16_t i,ax1,ay1,ax2,ay2;
  dirty_rect *p,*next;
  if (keep_dirt)
  {

// specifies that an area is a dirty
void image_descriptor::add_dirty(int x1, int y1, int x2, int y2)
{
  int16_t i;
  dirty_rect *p;
  if (keep_dirt)
  {

  }
}

void image::bar      (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
{
  int16_t y;
  if (x1>x2 || y1>y2) return ;
  if (special)
  { x1=special->bound_x1(x1);

  add_dirty(x1,y1,x2,y2);
}

void image::xor_bar  (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
{
  int16_t y,x;
  if (x1>x2 || y1>y2) return ;
  if (special)
  { x1=special->bound_x1(x1);

  if (x2<0 || y2<0 || x1>=width() || y1>=height() || x2<x1 || y2<y1)
    return ;

  uint8_t *sl=scan_line(y1)+x1; 
  for (y=y1;y<=y2;y++)
  {
    uint8_t *s=sl;
    for (x=x1;x<=x2;x++,s++)
      *s=(*s)^color;
    sl+=w;

}


void image::unpack_scanline(int16_t line, char bitsperpixel)
{
  int16_t x;
  uint8_t *sl,*ex,mask,bt,sh;
  ex=(uint8_t *)jmalloc(width(),"image::unpacked scanline");
  sl=scan_line(line);
  memcpy(ex,sl,width());



void image::dither(palette *pal)
{
  int16_t x,y,i,j;
  uint8_t dt_matrix[]={0,  136,24, 170,
		   68, 204,102,238,
		   51, 187, 17,153,
		   119,255, 85,221};

  uint8_t *sl;
  for (y=height()-1;y>=0;y--)
  {
    sl=scan_line(y);

  }
}

void image::resize(int16_t new_width, int16_t new_height)
{
  int old_width=width(),old_height=height();
  uint8_t *im=(uint8_t *)jmalloc(width()*height(),"image::resized");
  memcpy(im,scan_line(0),width()*height());

  delete_page();

  w=new_width;      // set the new hieght and width
  h=new_height;

  uint8_t *sl1,*sl2;
  int16_t y,y2,x2;
  double yc,xc,yd,xd;



  if (special) special->resize(new_width,new_height);
}

void image::scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd)
{
  int16_t cx1,cy1,cx2,cy2;
  CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
  if (special)
  {
    special->get_clip(cx1,cy1,cx2,cy2);
    x1=max(x1,cx1); y1=max(cy1,y1); x2=min(x2,cx2); y2=min(y2,cy2);
  }
  int16_t xsrc,ysrc,xdst,ydst,xtot=x2-x1-abs(xd)+1,ytot,xt;
  uint8_t *src,*dst;
  if (xd<0) { xsrc=x1-xd; xdst=x1; } else { xsrc=x2-xd; xdst=x2; }
  if (yd<0) { ysrc=y1-yd; ydst=y1; } else { ysrc=y2-yd; ydst=y2; }
  for (ytot=y2-y1-abs(yd)+1;ytot;ytot--)

}


image *image::create_smooth(int16_t smoothness)
{
  int16_t i,j,k,l,t,d;
  image *im;
  CHECK(smoothness>=0);
  if (!smoothness) return NULL;

  return im;
}

void image::wiget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
   	uint8_t light, uint8_t med, uint8_t dark)
{
  line(x1,y1,x2,y1,light);
  line(x1,y1,x1,y2,light);

class fill_rec
{
public :
  int16_t x,y;
  fill_rec *last;
  fill_rec(int16_t X, int16_t Y, fill_rec *Last)
  { x=X; y=Y; last=Last; }
} ;

void image::flood_fill(int16_t x, int16_t y, uint8_t color)
{
  uint8_t *sl,*above,*below;
  fill_rec *recs=NULL,*r;
  uint8_t fcolor;
  sl=scan_line(y);
  fcolor=sl[x];
  if (fcolor==color) return ;


#define LED_L 5
#define LED_H 5
void image::burn_led(int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale)
{
  char st[100];
  int16_t ledx[]={1,2,1,2,3,3,3,3,1,2,0,0,0,0};
  int16_t ledy[]={3,3,0,0,1,2,4,6,7,7,4,6,1,2};

  int16_t dig[]={2+4+8+16+32+64,4+8,2+4+1+32+16,2+4+1+8+16,64+1+4+8,
             2+64+1+8+16,64+32+1+8+16,2+4+8,1+2+4+8+16+32+64,64+2+4+1+8,1};
  int16_t xx,yy,zz;
  sprintf(st,"%8ld",(long int)num);
  for (xx=0;xx<8;xx++)
  {
    if (st[xx]!=' ')

  }
}

uint8_t dither_matrix[]={0,  136,24, 170,
		     68, 204,102,238,
		     51, 187, 17,153,
		     119,255, 85,221};

image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
  int16_t x,y,cx1,cy1,cx2,cy2,ry,rx,bo,dity,ditx;
  image *ret;
  uint8_t *sl1,*sl2;
  get_clip(cx1,cy1,cx2,cy2);
  if (y1<cy1) y1=cy1;
  if (x1<cx1) x1=cx1;


void image::flip_x()
{
  uint8_t *rev=(uint8_t *)jmalloc(width(),"image tmp::flipped_x"),*sl;
  CONDITION(rev,"memory allocation"); 
  int y,x,i;
  for (y=0;y<height();y++)


void image::flip_y()
{
  uint8_t *rev=(uint8_t *)jmalloc(width(),"image::flipped_y"),*sl;
  CONDITION(rev,"memory allocation"); 
  int y;
  for (y=0;y<height()/2;y++)

  }
}

void image::make_color(uint8_t color)
{
  uint8_t *sl;
  int y,x;
  for (y=0;y<height();y++)
  {

Lines 56-64 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/filesel.cpp (-4 / +4 lines)
56	wid=0;	56	wid=0;
57	int i=0;	57	int i=0;
58	for (;i<tf;i++)	58	for (;i<tf;i++)
59	if (strlen(f[i])>wid) wid=strlen(f[i]);	59	if ((int)strlen(f[i])>wid) wid=strlen(f[i]);
60	for (i=0;i<td;i++)	60	for (i=0;i<td;i++)
61	if (strlen(d[i])+2>wid) wid=strlen(d[i])+2;	61	if ((int)strlen(d[i])+2>wid) wid=strlen(d[i])+2;
62	sx=0;	62	sx=0;
63		63
64		64
Lines 102-110 Link Here
102	wid=0;	102	wid=0;
103	int i=0;	103	int i=0;
104	for (;i<tf;i++)	104	for (;i<tf;i++)
105	if (strlen(f[i])>wid) wid=strlen(f[i]);	105	if ((int)strlen(f[i])>wid) wid=strlen(f[i]);
106	for (i=0;i<td;i++)	106	for (i=0;i<td;i++)
107	if (strlen(d[i])+2>wid) wid=strlen(d[i])+2;	107	if ((int)strlen(d[i])+2>wid) wid=strlen(d[i])+2;
108	reconfigure();	108	reconfigure();
109	}	109	}
110		110

Lines 275-281 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/pmenu.cpp (-1 / +1 lines)
275	int w=bar->screen->width();	275	int w=bar->screen->width();
276		276
277		277
278	int total=0,tx,tw,i=0,x;	278	int total=0,tw,i=0,x=0;
279	for (pmenu_item *pp=top;pp;pp=pp->next,i++)	279	for (pmenu_item *pp=top;pp;pp=pp->next,i++)
280	{ if (pp==p) x=i;	280	{ if (pp==p) x=i;
281	total++;	281	total++;





    for (i=0;i<total;i++)
    { 
      ((morph_point16 *)p+i)->x1=fp->read_uint16();
      ((morph_point16 *)p+i)->y1=fp->read_uint16();
      ((morph_point16 *)p+i)->x2=fp->read_uint16();
      ((morph_point16 *)p+i)->y2=fp->read_uint16();
      fp->read( &((morph_point16 *)p+i)->start_color,1);
      fp->read( &((morph_point16 *)p+i)->end_color,1);
    }

    small=0;
  }
  w[0]=fp->read_uint16();
  h[0]=fp->read_uint16();  
  w[1]=fp->read_uint16();
  h[1]=fp->read_uint16();
}

void jmorph::show_frame(image *screen, int x, int y, 

  int i;

  
  fp->write_uint32(total);  
  if (small)
  {


  else
  {
    for (i=0;i<total;i++)
    { fp->write_uint16(((morph_point16 *)p+i)->x1);
      fp->write_uint16(((morph_point16 *)p+i)->y1);
      fp->write_uint16(((morph_point16 *)p+i)->x2);
      fp->write_uint16(((morph_point16 *)p+i)->y2);
      fp->write( &((morph_point16 *)p+i)->start_color,1);
      fp->write( &((morph_point16 *)p+i)->end_color,1);
    }
  }
  fp->write_uint16(w[0]);
  fp->write_uint16(h[0]);
  fp->write_uint16(w[1]);
  fp->write_uint16(h[1]);
  return 1;
}


{
  int i;
  
  patches=fp->read_uint16();
  pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"patched_morph::points");
  
  for (i=0;i<patches;i++)
  {
    pats[i].patches=fp->read_uint16();
    if (pats[i].patches)
    {      
      pats[i].patch_data=(unsigned char *)jmalloc(3*pats[i].patches,"patched_morph::patch_data");

Lines 36-46 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/fonts.cpp (-3 / +3 lines)
36		36
37	void JCFont::put_char(image *screen, int x, int y, char ch, int color)	37	void JCFont::put_char(image *screen, int x, int y, char ch, int color)
38	{	38	{
39	if (let[ch])	39	if (let[(int)ch])
40	{	40	{
41	if (color>=0)	41	if (color>=0)
42	let[ch]->put_color(screen,x,y,color);	42	let[(int)ch]->put_color(screen,x,y,color);
43	else let[ch]->put_image(screen,x,y);	43	else let[(int)ch]->put_image(screen,x,y);
44	}	44	}
45	}	45	}
46		46

Lines 1-7 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/compiled.hpp (-2 / +2 lines)
1	#ifndef __COMPILED_HPP_	1	#ifndef __COMPILED_HPP_
2	#define __COMPILED_HPP_	2	#define __COMPILED_HPP_
3	#include "macs.hpp"	3	#include "macs.hpp"
4	extern long S_fall_start,S_falling,S_landing,S_pounce_wait,	4	extern int32_t S_fall_start,S_falling,S_landing,S_pounce_wait,
5	S_turn_around,S_fire_wait,S_ceil_fire,S_top_walk,	5	S_turn_around,S_fire_wait,S_ceil_fire,S_top_walk,
6	S_blown_back_dead,S_jump_up,S_hiding,S_weapon_fire,	6	S_blown_back_dead,S_jump_up,S_hiding,S_weapon_fire,
7	S_hanging,S_blocking,S_rotate,S_climbing,S_climb_off,	7	S_hanging,S_blocking,S_rotate,S_climbing,S_climb_off,
Lines 24-30 Link Here
24	void compiled_init();	24	void compiled_init();
25	void compiled_uninit();	25	void compiled_uninit();
26		26
27	extern uchar *bad_guy_array; // list flaging each character saying they are a bad bug or not	27	extern uint8_t *bad_guy_array; // list flaging each character saying they are a bad bug or not
28	// mainly used by the rocket to find targets	28	// mainly used by the rocket to find targets
29		29
30	#endif	30	#endif





struct net_packet
{
  uint8_t data[PACKET_MAX_SIZE];
  int packet_prefix_size()                 { return 5; }    // 2 byte size, 2 byte check sum, 1 byte packet order
  uint16_t packet_size()             { uint16_t size=(*(uint16_t *)data); return lstl(size); }
  uint8_t tick_received()            { return data[4]; }  
  void set_tick_received(uint8_t x)  { data[4]=x; }
  uint8_t *packet_data()             { return data+packet_prefix_size(); }
  uint16_t get_checksum()            { uint16_t cs=*((uint16_t *)data+1); return lstl(cs); }
  uint16_t calc_checksum()
  {
    *((uint16_t *)data+1)=0;
    int i,size=packet_prefix_size()+packet_size();
    uint8_t c1=0,c2=0,*p=data;
    for (i=0;i<size;i++,p++)
    {
      c1+=*p;
      c2+=c1;
    }
    uint16_t cs=( (((uint16_t)c1)<<8) | c2);
    *((uint16_t *)data+1)=lstl(cs);
    return cs;
  }


      set_packet_size(packet_size()+size);
    }
  }
  void write_uint8(uint8_t x) { add_to_packet(&x,1); }
  void write_uint16(uint16_t x) { x=lstl(x); add_to_packet(&x,2); }
  void write_uint32(uint32_t x) { x=lltl(x); add_to_packet(&x,4); }

  void set_packet_size(uint16_t x) { *((uint16_t *)data)=lstl(x); }


} ;

  net_packet packet,                        // current tick data
             last_packet;                   // last tick data (in case a client misses input, we can resend)

  int16_t mem_lock;
  int16_t calc_crcs;
  int16_t get_lsf;
  int16_t wait_reload;
  int16_t need_reload;
  int16_t input_state;          // COLLECTING or PROCESSING
  int16_t current_tick;         // set by engine, used by driver to confirm packet is not left over
  
  join_struct *join_list;
} ;

Lines 2-7 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/transp.hpp (-1 / +1 lines)
2	#define __TRANSP_HPP_	2	#define __TRANSP_HPP_
3	#include "image.hpp"	3	#include "image.hpp"
4	#include "macs.hpp"	4	#include "macs.hpp"
5	void transp_put(image im, image screen, uchar *table, int x, int y);	5	void transp_put(image im, image screen, uint8_t *table, int x, int y);
6		6
7	#endif	7	#endif

Lines 1-6 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/lisp.hpp (-14 / +16 lines)
1	#ifndef __LISP_HPP_	1	#ifndef __LISP_HPP_
2	#define __LISP_HPP_	2	#define __LISP_HPP_
3		3
		4	#include <stdint.h>
		5
4	#include "lisp_opt.hpp"	6	#include "lisp_opt.hpp"
5		7
6	#ifdef L_PROFILE	8	#ifdef L_PROFILE
Lines 34-41 Link Here
34	L_OBJECT_VAR, L_1D_ARRAY,	36	L_OBJECT_VAR, L_1D_ARRAY,
35	L_FIXED_POINT, L_COLLECTED_OBJECT };	37	L_FIXED_POINT, L_COLLECTED_OBJECT };
36		38
37	typedef long ltype; // make sure structures aren't packed differently on various compiler	39	typedef uint64_t ltype; // make sure structures aren't packed differently on various compiler
38	// and sure that word, etc are word alligned	40	// and sure that word, etc are word aligned
39		41
40	struct lisp_object_var	42	struct lisp_object_var
41	{	43	{
Lines 82-88 Link Here
82	{	84	{
83	ltype type;	85	ltype type;
84	#ifndef NO_LIBS	86	#ifndef NO_LIBS
85	long alist,blist; // id for cached blocks	87	intptr_t alist,blist; // id for cached blocks
86	#else	88	#else
87	void arg_list,block_list;	89	void arg_list,block_list;
88	#endif	90	#endif
Lines 103-110 Link Here
103	struct lisp_character	105	struct lisp_character
104	{	106	{
105	ltype type;	107	ltype type;
106	short pad;	108	int16_t pad;
107	unsigned short ch;	109	uint16_t ch;
108	} ;	110	} ;
109		111
110	struct lisp_pointer	112	struct lisp_pointer
Lines 117-123 Link Here
117	struct lisp_fixed_point	119	struct lisp_fixed_point
118	{	120	{
119	ltype type;	121	ltype type;
120	long x;	122	int32_t x;
121	} ;	123	} ;
122		124
123		125
Lines 127-133 Link Here
127	#define item_type(c) ((c) ? ((ltype )c) : (ltype)L_CONS_CELL)	129	#define item_type(c) ((c) ? ((ltype )c) : (ltype)L_CONS_CELL)
128	void lget_array_element(void a, long x);	130	void lget_array_element(void a, long x);
129	void lpointer_value(void lpointer);	131	void lpointer_value(void lpointer);
130	long lnumber_value(void *lnumber);	132	int32_t lnumber_value(void *lnumber);
131	char lstring_value(void lstring);	133	char lstring_value(void lstring);
132	unsigned short lcharacter_value(void *c);	134	unsigned short lcharacter_value(void *c);
133	long lfixed_point_value(void *c);	135	long lfixed_point_value(void *c);
Lines 155-161 Link Here
155	lisp_symbol make_find_symbol(char name);	157	lisp_symbol make_find_symbol(char name);
156		158
157	void push_onto_list(void object, void &list);	159	void push_onto_list(void object, void &list);
158	lisp_symbol add_c_object(void symbol, short number);	160	lisp_symbol add_c_object(void symbol, int16_t number);
159	lisp_symbol add_c_function(char name, short min_args, short max_args, short number);	161	lisp_symbol add_c_function(char name, short min_args, short max_args, short number);
160	lisp_symbol add_c_bool_fun(char name, short min_args, short max_args, short number);	162	lisp_symbol add_c_bool_fun(char name, short min_args, short max_args, short number);
161	lisp_symbol add_lisp_function(char name, short min_args, short max_args, short number);	163	lisp_symbol add_lisp_function(char name, short min_args, short max_args, short number);
Lines 166-178 Link Here
166		168
167	lisp_number *new_lisp_number(long num);	169	lisp_number *new_lisp_number(long num);
168	lisp_pointer new_lisp_pointer(void addr);	170	lisp_pointer new_lisp_pointer(void addr);
169	lisp_character *new_lisp_character(unsigned short ch);	171	lisp_character *new_lisp_character(uint16_t ch);
170	lisp_string new_lisp_string(char string);	172	lisp_string new_lisp_string(char string);
171	lisp_string new_lisp_string(char string, int length);	173	lisp_string new_lisp_string(char string, int length);
172	lisp_string *new_lisp_string(long length);	174	lisp_string *new_lisp_string(int length);
173	lisp_fixed_point *new_lisp_fixed_point(long x);	175	lisp_fixed_point *new_lisp_fixed_point(int32_t x);
174	lisp_object_var *new_lisp_object_var(short number);	176	lisp_object_var *new_lisp_object_var(int16_t number);
175	lisp_1d_array new_lisp_1d_array(unsigned short size, void rest);	177	lisp_1d_array new_lisp_1d_array(int size, void rest);
176	lisp_sys_function *new_lisp_sys_function(int min_args, int max_args, int fun_number);	178	lisp_sys_function *new_lisp_sys_function(int min_args, int max_args, int fun_number);
177	lisp_sys_function *new_lisp_c_function(int min_args, int max_args, int fun_number);	179	lisp_sys_function *new_lisp_c_function(int min_args, int max_args, int fun_number);
178	lisp_sys_function *new_lisp_c_bool(int min_args, int max_args, int fun_number);	180	lisp_sys_function *new_lisp_c_bool(int min_args, int max_args, int fun_number);
Lines 180-186 Link Here
180	#ifdef NO_LIBS	182	#ifdef NO_LIBS
181	lisp_user_function new_lisp_user_function(void arg_list, void *block_list);	183	lisp_user_function new_lisp_user_function(void arg_list, void *block_list);
182	#else	184	#else
183	lisp_user_function *new_lisp_user_function(long arg_list, long block_list);	185	lisp_user_function *new_lisp_user_function(intptr_t arg_list, intptr_t block_list);
184	#endif	186	#endif
185		187
186	lisp_sys_function *new_user_lisp_function(int min_args, int max_args, int fun_number);	188	lisp_sys_function *new_user_lisp_function(int min_args, int max_args, int fun_number);





struct suggest_struct
{
  int32_t cx1,cy1,cx2,cy2,shift_down,shift_right,pan_x,pan_y;
  int32_t new_weapon;
  uint8_t send_view,send_weapon_change;
} ;




class view
{
  uint8_t keymap[512/8];
  char chat_buf[60];
  public : 
  int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }


  char name[100];
  struct suggest_struct suggest;
  int32_t cx1,cy1,cx2,cy2,                    // view area to show
      shift_down,shift_right;             // shift of view

  int god;                                // :) if you believe in such things

  
  int draw_solid;                         // -1 if don't draw solid

  int32_t *weapons;                          // [0..total_weapons-1]
  int32_t *last_weapons;                     // last history of above array (for updating statbar)
  int32_t current_weapon;


  game_object *focus;                     // object we are focusing on (player)



  short ambient;                        // ambient lighting setting, used by draw
  int32_t pan_x,pan_y,no_xleft,no_xright,no_ytop,no_ybottom,
       last_x,last_y,last_last_x,last_last_y,view_percent;

  int32_t last_left,last_right,last_up,last_down,   // how many frames ago were these pressed (<=0)
       last_b1,last_b2,last_b3,last_b4,last_hp,last_ammo,last_type;
  int32_t secrets,kills,tsecrets,tkills;

  view(game_object *Focus, view *Next, int number);
  void draw_character_damage();           // draws the characters 'status' on the viewer

  int32_t x_center();                        // center of attention
  int32_t y_center();
  int32_t xoff();                            // top left and right corner of the screen
  int32_t interpolated_xoff();
  int32_t yoff();
  int32_t interpolated_yoff();
  int drawable();                        // network viewables are not drawable
  int local_player();                    //  just in case I ever need non-viewable local players.

  view *next;                             // next viewable player (singly linked list)  
  void get_input();
  int process_input(char cmd, uint8_t *&pk);

  void add_ammo   (int weapon_type, int total);
  int has_weapon  (int weapon_type) { return god || (weapons[weapon_type]!=-1); }

  void draw_hp();
  void draw_ammo();
  void draw_logo();
  void resize_view(int32_t Cx1, int32_t Cy1, int32_t Cx2, int32_t Cy2);
  void set_input(int cx, int cy, int b1, int b2, int b3, int b4, int px, int py);
  int view_changed() { return suggest.send_view; }
  int weapon_changed() { return suggest.send_weapon_change; }


  void reset_player();
  int receive_failed() { return focus==NULL; }
  int32_t get_view_var_value(int num);
  int32_t set_view_var_value(int num, int32_t x);
  void configure_for_area(area_controller *a);
  ~view();
} ;

int total_local_players();
void recalc_local_view_space();

void process_packet_commands(uint8_t *pk, int size);

object_node *make_player_onodes(int player_num=-1);
int total_view_vars();

Lines 18-24 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/dev.hpp (-3 / +3 lines)
18		18
19	class pal_win	19	class pal_win
20	{	20	{
21	long scale,w,h,x,y,last_selected;	21	int32_t scale,w,h,x,y,last_selected;
22	unsigned short *pat;	22	unsigned short *pat;
23	void draw();	23	void draw();
24		24
Lines 100-107 Link Here
100	void close_ai_window();	100	void close_ai_window();
101	void make_ambient();	101	void make_ambient();
102	int ok_to_scroll();	102	int ok_to_scroll();
103	long snap_x(long x);	103	int32_t snap_x(int32_t x);
104	long snap_y(long y);	104	int32_t snap_y(int32_t y);
105	void area_handle_input(event &ev);	105	void area_handle_input(event &ev);
106	void pick_handle_input(event &ev);	106	void pick_handle_input(event &ev);
107	void close_area_win(int read_values);	107	void close_area_win(int read_values);




#define jmalloc(x,y) malloc(x)
#define jrealloc(x,y,z) realloc(x,y)
#define jfree(x) free(x)
#define uchar  unsigned char
#define schar  signed char
#define sshort signed short

#ifdef __sgi
#include <sys/bsd_types.h>
#else
#include <stdint.h>
#define ushort unsigned short
#endif

class bFILE

Lines 16-22 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/particle.hpp (-1 / +1 lines)
16	struct part	16	struct part
17	{	17	{
18	short x,y;	18	short x,y;
19	uchar color;	19	uint8_t color;
20	} ;	20	} ;
21		21
22	class part_frame	22	class part_frame




{
public :  
  boundary(bFILE *fp,char *er_name);
  uint8_t *inside;     // tells which side of the line is on the inside
  boundary(boundary *p);      // flips the *inside list
  ~boundary() { if (tot) jfree(inside); }
} ;

class backtile
{
public :
  uint16_t next;
  image *im;
  backtile(spec_entry *e, bFILE *fp);
  backtile(bFILE *fp);
  int32_t size() { return 2+4+im->width()*im->height(); }
  ~backtile() { delete im; }
} ;


{
public :
  trans_image *im;
  uint16_t next;
  uint8_t damage;
  uint8_t ylevel;            // for fast intersections, this is the y level offset for the ground
                           // if ground is not level this is 255
  boundary *points;

  image *micro_image;

  foretile(bFILE *fp);
  int32_t size() { return im->width()*im->height()+4+2+1+points->size(); }
  ~foretile() { delete im; delete points; delete micro_image; }
} ;


{
public :
  trans_image *forward,*backward;
  uint8_t hit_damage,xcfg;
  int8_t advance;
  point_list *hit;
  boundary *f_damage,*b_damage;
  int size();

  int width() { return forward->width(); }
  int height() { return forward->height(); }

/*  int32_t size(int type)         // taken from spaint items
  {
    if 
    return forward->width()*backward->height()+4+

class char_tint
{
  public :
  uint8_t data[256];
  ~char_tint() { ; }
  char_tint(bFILE *fp);               // should be a palette entry
} ;

Lines 33-39 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/demo.hpp (-1 / +1 lines)
33		33
34		34
35		35
36	extern int last_demo_mx,last_demo_my,last_demo_mbut;	36	extern int32_t last_demo_mx,last_demo_my,last_demo_mbut;
37	//extern ulong demo_tick_on;	37	//extern ulong demo_tick_on;
38	#endif	38	#endif
39		39







#define RC_8 0
#define RC_16 1
#define RC_32 2




  sequence *current_sequence() { return figures[otype]->get_sequence(state); }
public :
  game_object *next,*next_active;
  int32_t *lvars;

  int size();
  int decide();        // returns 0 if you want to be deleted


  void drawer();
  void draw_above(view *v);
  void do_damage(int amount, game_object *from, int32_t hitx, int32_t hity, int32_t push_xvel, int32_t push_yvel);
  void damage_fun(int amount, game_object *from, int32_t hitx, int32_t hity, int32_t push_xvel, int32_t push_yvel);


  void note_attack(game_object *whom);

  void set_state(character_state s, int frame_direction=1);
  int has_sequence(character_state s) { return figures[otype]->has_sequence(s); }

  game_object *try_move(int32_t x, int32_t y, int32_t &xv, int32_t &yv, int checks);  // 1=down,2=up,3=both
  game_object *bmove(int &whit, game_object *exclude);  // ballestic move, return hit object, 
                                                        // or NULL (whit is 1 if hit wall)
  trans_image *picture() { return current_sequence()->get_frame(current_frame,direction); }
												    
  int next_picture();
  int32_t x_center();  
  int32_t height();

  void stop_acel() { set_xacel(0);  set_yacel(0); set_fxacel(0); set_fyacel(0); }
  void stop_vel() {  set_xvel(0);   set_yvel(0); set_fxvel(0);  set_fyvel(0); }

  int mover(int cx, int cy, int button);
  figure *current_figure() { return current_sequence()->get_figure(current_frame); }
  int total_frames() { return current_sequence()->length(); }
  void picture_space(int32_t &x1, int32_t &y1,int32_t &x2, int32_t &y2);
  int tx(int x) { if (direction>0) return x-x_center(); else return x_center()-x; }
  int ty(int y) { return y-picture()->height()+1; }
  void defaults();

  void reload_notify();

  void change_type(int new_type);
  int set_var_by_name(char *name, int32_t value);
  int32_t get_var_by_name(char *name, int &error);
  game_object *copy();
  void change_aitype(int new_type);
  ~game_object();


extern game_object *current_object;
extern view *current_view;
game_object *create(int type, int32_t x, int32_t y, int skip_constructor=0, int aitype=0);
int base_size();

void delete_object_list(object_node *first);
int          object_to_number_in_list(game_object *who, object_node *list);
game_object *number_to_object_in_list(int32_t x, object_node *list);


#endif




struct cache_item
{
  void *data;
  int32_t last_access;   
  uint8_t type;
  int16_t file_number;
  int32_t offset;
} ;



{
  public :
  int crc_calculated;
  uint32_t crc;
  char *filename;
  crced_file(char *name);
  ~crced_file();

  public :
  crc_manager();
  int get_filenumber(char *filename);
  uint32_t get_crc(int32_t filenumber, int &failed);
  void set_crc(int32_t filenumber, uint32_t crc);
  char *get_filename(int32_t filenumber);
  void clean_up();
  int total_filenames() { return total_files; }
  int write_crc_file(char *filename);

class cache_list
{
  cache_item *list;
  int32_t total,last_registered,last_access,poll_start_access;
  int16_t last_file;           // for speed leave the last file accessed open

  bFILE *fp,*cache_file,*cache_read_file;
  spec_directory *last_dir;
  int32_t last_offset;          // store the last offset so we don't have to seek if
                             // we don't need to
  

  int16_t lcache_number;
  int32_t alloc_id();
  void locate(cache_item *i, int local_only=0);    // set up file and offset for this item
  void normalize();
  void unmalloc(cache_item *i);

  void free_oldest();
  int in_use() { if (used) { used=0; return 1; } else return 0; }
  int full() { if (ful) { ful=0; return 1; } else return 0; }
  int32_t reg_object(char *filename, void *object, int type, int rm_dups);      // lisp object
  int32_t reg(char *filename, char *name, int type=-1, int rm_dups=0);          // returns id to item
  int32_t reg_lisp_block(Cell *block);
  int loaded(int id);
  void unreg(int id);
  void note_need(int id);

  int offset_compare(int a, int b);

  void load_cache_prof_info(char *filename, level *lev);
  int search(int *sarray, uint16_t filenum, int32_t offset);  // sarray is a index table sorted by offset/filenum

  void show_accessed();
  void empty();




class area_controller
{
  public :
  int32_t x,y,w,h,active;
  int32_t ambient,view_xoff,view_yoff;
  int32_t ambient_speed, view_xoff_speed,view_yoff_speed;
  area_controller *next;
  area_controller(int32_t X, int32_t Y, int32_t W, int32_t H, area_controller *Next);
} ;

extern int32_t last_tile_hit_x,last_tile_hit_y;
extern int dev;
class level        // contain map info and objects
{
  uint16_t *map_fg,        // just big 2d arrays
           *map_bg,
	   bg_width,bg_height,
	   fg_width,fg_height;  
  char *Name,*first_name;
  int32_t total_objs;
  game_object *first,*first_active,*last;

  game_object **attack_list;                // list of characters for tick which can attack someone

  game_object **all_block_list;            // list of characters who can block a character or can be hurt
  int all_block_list_size,all_block_total;
  void add_all_block(game_object *who);
  uint32_t ctick;
  
public :
  char *original_name() { if (first_name) return first_name; else return Name; }
  uint32_t tick_counter() { return ctick; }
  void set_tick_counter(uint32_t x);
  area_controller *area_list;
 
  void clear_active_list() { first_active=NULL; }


  game_object *first_object() { return first; }
  game_object *first_active_object() { return first_active; }
  uint16_t foreground_width() { return fg_width; }
  uint16_t foreground_height() { return fg_height; }
  uint16_t background_width() { return bg_width; }
  uint16_t background_height() { return bg_height; }
  int load_failed() { return map_fg==NULL; } 
  level(spec_directory *sd, bFILE *fp, char *lev_name);
  void load_fail();             

  int fg_raised(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
				 return (*(map_fg+x+y*fg_width))&0x4000; }
  void fg_set_raised(int x, int y, int r) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
					    uint16_t v=(*(map_fg+x+y*fg_width))&(0xffff-0x4000);
					    if (r) (*(map_fg+x+y*fg_width))=v|0x4000;
					    else (*(map_fg+x+y*fg_width))=v;
					  }
  void mark_seen(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
					  (*(map_fg+x+y*fg_width))|=0x8000; }
  void clear_fg(int32_t x, int32_t y) { *(map_fg+x+y*fg_width)&=0x7fff; }

  uint16_t *get_fgline(int y) { CHECK(y>=0 && y<fg_height); return map_fg+y*fg_width; }
  uint16_t *get_bgline(int y) { CHECK(y>=0 && y<bg_height); return map_bg+y*bg_width; }
  uint16_t get_fg(int x, int y) { if (x>=0 && y>=0 && x<fg_width && y<fg_height)
        			          return fgvalue(*(map_fg+x+y*fg_width)); 
	                                else return 0;
				      }
  uint16_t get_bg(int x, int y) { if (x>=0 && y>=0 && x<bg_width && y<bg_height)
					  return *(map_bg+x+y*bg_width); 
	                                 else return 0;
					}
  void put_fg(int x, int y, uint16_t tile) { *(map_fg+x+y*fg_width)=tile; }   
  void put_bg(int x, int y, uint16_t tile) { *(map_bg+x+y*bg_width)=tile; }
  void draw_objects(view *v); 
  void interpolate_draw_objects(view *v);
  void draw_areas(view *v);


  void unactivate_all();
  // forms all the objects in processing range into a linked list
  int add_actives(int32_t x1, int32_t y1, int32_t x2, int32_t y2);  //returns total added
  void pull_actives(game_object *o, game_object *&last_active, int &t);
  int add_drawables(int32_t x1, int32_t y1, int32_t x2, int32_t y2);  //returns total added

  game_object *find_object(int32_t x, int32_t y);

  game_object *damage_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2, game_object *exclude);
  game_object *boundary_setback(game_object *subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
  game_object *all_boundary_setback(game_object *subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
  int crush(game_object *by_who, int xamount, int yamount);
  int push_characters(game_object *by_who, int xamount, int yamount);  // return 0 if fail on any.
  int platform_push(game_object *by_who, int xamount, int yamount);
  void foreground_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
  void vforeground_intersect(int32_t x1, int32_t y1, int32_t &y2);

  void hurt_radius(int32_t x, int32_t y,int32_t r, int32_t m, game_object *from, game_object *exclude,
		   int max_push);
  void send_signal(int32_t signal);
  void next_focus();
  void to_front(game_object *o);
  void to_back(game_object *o);

  bFILE *create_dir(char *filename, int save_all,
		    object_node *save_list, object_node *exclude_list);
  view *make_view_list(int nplayers);
  int32_t total_light_links(object_node *list);
  int32_t total_object_links(object_node *save_list);
  game_object *find_object_in_area(int32_t x, int32_t y, int32_t x1, int32_t y1, 
				   int32_t x2, int32_t y2, Cell *list, game_object *exclude);
  game_object *find_object_in_angle(int32_t x, int32_t y, int32_t start_angle, int32_t end_angle,
				    void *list, game_object *exclude);
  object_node *make_not_list(object_node *list);
  int load_player_info(bFILE *fp, spec_directory *sd, object_node *save_list);





extern char **start_argv;
extern int start_argc;
extern int32_t current_vxadd,current_vyadd;
extern int frame_panic,massive_frame_panic;
extern int demo_start,idle_ticks;


  int bright_color,med_color,dark_color,     // for boundaries and windows, etc
      morph_bright_color,morph_med_color,morph_dark_color;

  int32_t last_time,fps;
  char mapname[100],command[200],help_text[200];
  int refresh,mousex,mousey,help_text_frames;
  int has_joystick,no_delay;


  jwindow *top_menu,*joy_win,*last_input;
  JCFont *game_font;
  uint8_t keymap[512/8];

public : 
  int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }

                           return cash.foret(foretiles[BLACK]); else 
			   return cash.foret(foretiles[x]); }

  void ftile_on(int screenx, int screeny, int32_t &x, int32_t &y);
  void btile_on(int screenx, int screeny, int32_t &x, int32_t &y);
  void toggle_delay();
  void set_delay(int on) { no_delay=!on; }
  void pan(int xv, int yv);

  void mouse_to_game(int32_t x, int32_t y, int32_t &gamex, int32_t &gamey, view *v=NULL);
  void game_to_mouse(int32_t gamex, int32_t gamey, view *which, int32_t &x, int32_t &y);
  view *view_in(int mousex, int mousey);

  int calc_speed();

  void set_state(int new_state);
  int game_over();
  void grow_views(int amount);
  void play_sound(int id, int vol, int32_t x, int32_t y);
  void request_level_load(char *name);
  void request_end();
  ~game();




class simple_object
{
  public :
  int8_t Fade_dir;
  uint8_t Fade_count,Fade_max;
  uint8_t Flags,grav_on,targetable_on;
  int32_t Xvel,Yvel,Xacel,Yacel;
  uint8_t Fx,Fy,Fxvel,Fyvel,Fxacel,Fyacel;
  uint8_t Aitype;
  uint16_t Aistate,Aistate_time;
  uint16_t Hp,Mp,Fmp;
  int8_t Frame_dir;        


  uint8_t tobjs,tlights;
  game_object **objs,*link;
  light_source **lights;


  int total_vars();
  char *var_name(int x);
  int   var_type(int x);
  void set_var(int x, uint32_t v);
  int32_t get_var(int x);

  // leave these public, so I don't have monster code changes.
  simple_object();
  int32_t x,y,
       last_x,last_y;              // used for frame interpolation on fast machines
  int8_t direction,active;
  uint16_t otype;
  character_state state;
  short current_frame;


  int floating()             { return flags()&FLOATING_FLAG; }

  int keep_ai_info()         { return 1; }
  uint8_t flags()            { return Flags; }
  int32_t xvel()             { return Xvel; }
  int32_t yvel()             { return Yvel; }
  int32_t xacel()            { return Xacel; }
  int32_t yacel()            { return Yacel; }

  uint8_t fx()               { return Fx; }
  uint8_t fy()               { return Fy; }
  uint8_t fxvel()            { return Fxvel; }
  uint8_t fyvel()            { return Fyvel; }
  uint8_t fxacel()           { return Fxacel; }
  uint8_t fyacel()           { return Fyacel; }

  uint8_t sfx()              { return Fx; }  // x & y should always be positive
  uint8_t sfy()              { return Fy; }
  uint8_t sfxvel()           { if (Xvel>=0) return Fxvel; else return -Fxvel; }
  uint8_t sfyvel()           { if (Yvel>=0) return Fyvel; else return -Fyvel; }
  uint8_t sfxacel()          { if (Xacel>=0) return Fxacel; else return -Fxacel; }
  uint8_t sfyacel()          { if (Yacel>=0) return Fyacel; else return -Fyacel; }

  uint8_t aitype()           { return Aitype; }
  uint16_t aistate()         { return Aistate; }
  uint16_t aistate_time()    { return Aistate_time; }
  uint16_t hp()              { return Hp;         }
  uint16_t mp()              { return Mp;         }
  uint16_t fmp()             { return Fmp;        }
  int8_t fade_dir()          { return Fade_dir;   }
  int8_t frame_dir()         { return Frame_dir;  }
  uint8_t fade_count()       { return Fade_count; }
  uint8_t fade_max()         { return Fade_max;   }
  uint8_t total_objects()    { return tobjs;      }
  uint8_t total_lights()     { return tlights;    }

  morph_char *morph_status()     { return mc; }
  light_source *get_light(int x)     

  { if (x>=tobjs) { lbreak("bad x for object\n"); exit(0); } return objs[x]; }
  view *controller()             { return Controller; }

  void set_targetable(uint8_t x)  { targetable_on=x; }
  void set_flags(uint8_t f)       { Flags=f; }
  void set_xvel(int32_t xv)       { Xvel=xv; }
  void set_yvel(int32_t yv)       { Yvel=yv; }
  void set_xacel(int32_t xa)      { Xacel=xa; }
  void set_yacel(int32_t ya)      { Yacel=ya; }
  void set_fx(uint8_t x)          { Fx=x; }
  void set_fy(uint8_t y)          { Fy=y; }
  void set_fxvel(uint8_t xv)      { Fxvel=abs(xv); }
  void set_fyvel(uint8_t yv)      { Fyvel=abs(yv); }
  void set_fxacel(uint8_t xa)     { Fxacel=abs(xa); }
  void set_fyacel(uint8_t ya)     { Fyacel=abs(ya); }
  void set_aitype(uint8_t t)      { Aitype=t; }
  void set_aistate(uint16_t s)      { Aistate=s; }
  void set_aistate_time(uint16_t t) { Aistate_time=t; }
  void set_hp(uint16_t h)           { Hp=h; }
  void set_mp(uint16_t m)           { Mp=m; }
  void set_fmp(uint16_t m)          { Fmp=m; }



  void set_fade_count(uint8_t f)        { Fade_count=f; }
  void set_fade_max(uint8_t m)          { Fade_max=m;  }
  void set_fade_dir(int8_t d)            { Fade_dir=d; }

  void set_frame_dir(int8_t d)           { Frame_dir=d; }
  void add_light(light_source *ls);
  void add_object(game_object *o);





#include "crc.hpp"

#define TTINTS 9
extern uint8_t *tints[TTINTS];
extern uint8_t *white_light,*white_light_initial,*green_light,*trans_table;
extern int16_t ambient_ramp;
#define REVERSE_GREEN_TINT 8

extern int16_t shutdown_lighting_value,shutdown_lighting;

class light_source
{
  public :
  int32_t type,x,xshift,y,yshift;
  int32_t outer_radius,mul_div,inner_radius;

  int32_t x1,y1,x2,y2;
  char known;
  light_source *next;

  void calc_range();
  light_source(char Type, int32_t X, int32_t Y, int32_t Inner_radius, int32_t Outer_radius, 
	       int32_t Xshift, int32_t Yshift,
	       light_source *Next);
  light_source *copy();
} ;

class light_patch
{
  public :
  int32_t total,x1,y1,x2,y2;
  light_source **lights;  
  light_patch *next;
  light_patch(int32_t X1, int32_t Y1, int32_t X2, int32_t Y2, light_patch *Next)
  { 
    x1=X1; y1=Y1; x2=X2; y2=Y2;
    next=Next;
    total=0;
    lights=NULL;
  }
  void add_light(int32_t X1, int32_t Y1, int32_t X2, int32_t Y2, light_source *who);
  light_patch *copy(light_patch *Next);
  ~light_patch() { if (total) jfree(lights); }
} ;

void delete_all_lights();
void delete_light(light_source *which);
light_source *add_light_source(char type, int32_t x, int32_t y, 
			       int32_t inner, int32_t outer, int32_t xshift, int32_t yshift);

void add_light_spec(spec_directory *sd, char *level_name);
void write_lights(bFILE *fp);


void delete_patch_list(light_patch *first);
light_patch *find_patch(int screenx, int screeny, light_patch *list);
int calc_light_value(int32_t x, int32_t y, light_patch *which);			       
void light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient);
void double_light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient,
			 image *out, int32_t out_x, int32_t out_y);

void calc_light_table(palette *pal);
extern light_source *first_light_source;
extern int light_detail;

extern int32_t light_to_number(light_source *l);
extern light_source *number_to_light(int32_t x);

#endif

Lines 3-10 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/crc.hpp (-2 / +2 lines)
3	#include "specs.hpp"	3	#include "specs.hpp"
4	#include "macs.hpp"	4	#include "macs.hpp"
5		5
6	unsigned short calc_crc(unsigned char *buf, long len);	6	uint16_t calc_crc(uint8_t *buf, int len);
7	ulong crc_file(bFILE *fp);	7	uint32_t crc_file(bFILE *fp);
8		8
9		9
10	#endif	10	#endif

Lines 1-8 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/intsect.hpp (-2 / +2 lines)
1	#ifndef __INTSECT_HPP_	1	#ifndef __INTSECT_HPP_
2	#define __INTSECT_HPP_	2	#define __INTSECT_HPP_
3		3
4	int setback_intersect(long x1, long y1, long &x2, long &y2,	4	int setback_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2,
5	long xp1, long yp1, long xp2, long yp2, long inside);	5	int32_t xp1, int32_t yp1, int32_t xp2, int32_t yp2, int32_t inside);
6		6
7	#endif	7	#endif
8		8




	printf( "** Abuse Options **\n" );
	printf( "  -size <arg>       Set the size of the screen\n" );
	printf( "  -edit             Startup in editor mode\n" );
	printf( "  -a <arg>          Use addon named <arg>\n" );
	printf( "  -f <arg>          Load map file named <arg>\n" );
	printf( "  -lisp             Startup in lisp interpreter mode\n" );
	printf( "  -nodelay          Run at maximum speed\n" );

	if( (fd = fopen( rcfile, "w" )) != NULL )
	{
		fputs( "; Abuse-SDL Configuration file\n\n", fd );
		fputs( "; Location of the datafiles\ndatadir=/usr/share/games/abuse\n\n", fd );
		fputs( "; Startup fullscreen\nfullscreen=0\n\n", fd );
		fputs( "; Use DoubleBuffering\ndoublebuf=0\n\n", fd );
		fputs( "; Use mono audio only\nmono=0\n\n", fd );

	char *result;

	rcfile = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 9, "rcfile" );
	sprintf( rcfile, "%s/abuserc", get_save_filename_prefix() );
	if( (fd = fopen( rcfile, "r" )) != NULL )
	{
		while( fgets( buf, sizeof( buf ), fd ) != NULL )


	if( (homedir = getenv( "HOME" )) != NULL )
	{
		savedir = (char *)jmalloc( strlen( homedir ) + 9, "savedir" );
		sprintf( savedir, "%s/.abuse/", homedir );
		// Check if we already have a savegame directory
		if( (fd = fopen( savedir, "r" )) == NULL )
		{




			{
				case SDL_QUIT:
				{
					exit(0);
					{
						// We're in the actual game so just confirm the user
						// wishes to quit and exit the game.
						if( confirm_quit() )
						{
							the_game->end_session();
						}
					}
					else
					{
						// We're at the menu screen so simluate the user
						// pressing the ESC key.
						ev.type = EV_KEY;
						ev.key = JK_ESC;
					}
					break;
				}
				case SDL_MOUSEBUTTONUP:

											ev.key = SDLK_COLON; break;
										case SDLK_QUOTE:
											ev.key = SDLK_QUOTEDBL; break;
										default:
											break;
									}
								}
							}




//
void put_part_image( image *im, int x, int y, int x1, int y1, int x2, int y2 )
{
	int xe, ye;
	SDL_Rect srcrect, dstrect;
	int ii, jj;
	int srcx, srcy, xstep, ystep;
	Uint8 *dpixel;
	Uint16 dinset;
	int dest_addr, line_width;

	if( (unsigned)y > yres || (unsigned)x > xres )
	{

Lines 66-72 Link Here

(-)abuse-sdl-0.7.0.orig/src/sdlport/sound.cpp (-3 / +3 lines)
66	{	66	{
67	if( handle->length > 0 && handle->pos )	67	if( handle->length > 0 && handle->pos )
68	{	68	{
69	len = ( len > handle->length ? handle->length : len );	69	len = ( len > (int)handle->length ? handle->length : len );
70	SDL_MixAudio( stream, handle->pos, len, handle->volume );	70	SDL_MixAudio( stream, handle->pos, len, handle->volume );
71	handle->pos += len;	71	handle->pos += len;
72	handle->length -= len;	72	handle->length -= len;
Lines 111-118 Link Here
111		111
112	// Check for the sfx directory, disable sound if we can't find it.	112	// Check for the sfx directory, disable sound if we can't find it.
113	datadir = get_filename_prefix();	113	datadir = get_filename_prefix();
114	sfxdir = (char *)jmalloc( strlen( datadir ) + 6, "sfxdir" );	114	sfxdir = (char *)jmalloc( strlen( datadir ) + 5 + 1, "sfxdir" );
115	sprintf( sfxdir, "%s/sfx/\0", datadir );	115	sprintf( sfxdir, "%s/sfx/", datadir );
116	if( (fd = fopen( sfxdir,"r" )) == NULL )	116	if( (fd = fopen( sfxdir,"r" )) == NULL )
117	{	117	{
118	// Didn't find the directory, so disable sound.	118	// Didn't find the directory, so disable sound.




    net_socket *sock;
    int file_fd;

    long size_to_read;  
    long size;
    nfs_client *next;
    int32_t size_to_read;  
    int32_t size;
    nfs_client(net_socket *sock, int file_fd, nfs_client *next);
    int send_read();     // flushes as much of size_to_read as possible
    ~nfs_client();

    public :
    net_socket *sock;
    void r_close(char *reason);
    int32_t size;   // server tells us the size of the file when we open it
    int open_local;
    remote_file *next; 
    remote_file(net_socket *sock, char *filename, char *mode, remote_file *Next);

    int unbuffered_read(void *buffer, size_t count);
    int unbuffered_write(void *buf, size_t count) { return 0; } // not supported
    int32_t unbuffered_tell();
    int32_t unbuffered_seek(int32_t offset);
    int32_t file_size() { return size; }
    int open_failure() { return sock==NULL; }    
    ~remote_file();
    int fd() { if (sock) return sock->get_fd(); else return -1; }



  int rf_open_file(char *&filename, char *mode);
  int32_t rf_tell(int fd);
  int32_t rf_seek(int fd, int32_t offset);
  int rf_read(int fd, void *buffer, size_t count);
  int rf_close(int fd);
  int32_t rf_file_size(int fd);
  void set_default_fs(net_address *def) { default_fs=def->copy(); }
  ~file_manager() { if (default_fs) delete default_fs; }
} ;

Lines 35-42 Link Here

(-)abuse-sdl-0.7.0.orig/src/net/include/gserver.hpp (-1 / +1 lines)
35	int need_reload_start_ok() { return get_flag(Need_reload_start_ok); }	35	int need_reload_start_ok() { return get_flag(Need_reload_start_ok); }
36	void set_need_reload_start_ok(int x) { set_flag(Need_reload_start_ok,x); }	36	void set_need_reload_start_ok(int x) { set_flag(Need_reload_start_ok,x); }
37		37
38	net_socket *comm;
39	int client_id;	38	int client_id;
		39	net_socket *comm;
40	net_address *data_address;	40	net_address *data_address;
41	player_client *next;	41	player_client *next;
42	player_client(int client_id, net_socket comm, net_address data_address, player_client *next) :	42	player_client(int client_id, net_socket comm, net_address data_address, player_client *next) :




// across the net as the other computer might have a different endianess

#ifdef BIGUNS
#define swap_uint16(x) (((((uint16_t) (x)))<<8)|((((uint16_t) (x)))>>8))
#define swap_uint32(x) \
   ((( ((uint32_t)(x)) )>>24)|((( ((uint32_t)(x)) )&0x00ff0000)>>8)| \
   ((( ((uint32_t)(x)) )&0x0000ff00)<<8)|(( ((uint32_t)(x)) )<<24))
#else
#define swap_uint16(x) (x)
#define swap_uint32(x) (x)

#endif

#define uchar unsigned char

#endif



Lines 16-21 Link Here

(-)abuse-sdl-0.7.0.orig/src/net/include/sock.hpp (+1 lines)
16	virtual void print() { ; }	16	virtual void print() { ; }
17	virtual net_address *copy() = 0;	17	virtual net_address *copy() = 0;
18	virtual void store_string(char *st, int st_length) = 0; // this should be able to be used get_node_address()	18	virtual void store_string(char *st, int st_length) = 0; // this should be able to be used get_node_address()
		19	virtual ~net_address() {;}
19	} ;	20	} ;
20		21
21		22




  };
  typedef isllist<RequestItem *>::iterator p_request;
  isllist<RequestItem*> servers,returned;
  net_socket *responder;
  ip_address *bcast;

  // Notification Data
  net_socket *notifier;
  char notify_data[512];
  int notify_len;

  net_socket *responder;
  ip_address *bcast;

  int handle_notification();
  int handle_responder();
public :

Lines 140-148 Link Here

(-)abuse-sdl-0.7.0.orig/src/net/include/ipx.hpp (-3 / +3 lines)
140		140
141	void add_to_packet(void *buf, int size);	141	void add_to_packet(void *buf, int size);
142		142
143	void write_byte(unsigned char x) { add_to_packet(&x,1); }	143	void write_uint8(uint8_t x) { add_to_packet(&x,1); }
144	void write_short(unsigned short x) { x=lstl(x); add_to_packet(&x,2); }	144	void write_uint16(uint16_t x) { x=lstl(x); add_to_packet(&x,2); }
145	void write_long(unsigned long x) { x=lltl(x); add_to_packet(&x,4); }	145	void write_uint32(uint32_t x) { x=lltl(x); add_to_packet(&x,4); }
146		146
147		147
148	} *pk;	148	} *pk;




// across the net as the other computer might have a different endianess

#ifdef BIGUNS
#define lstl(x) (((((uint16_t) (x)))<<8)|((((uint16_t) (x)))>>8))
#define lltl(x) \
   ((( ((uint32_t)(x)) )>>24)|((( ((uint32_t)(x)) )&0x00ff0000)>>8)| \
   ((( ((uint32_t)(x)) )&0x0000ff00)<<8)|(( ((uint32_t)(x)) )<<24))
#else
#define lstl(x) (x)
#define lltl(x) (x)

#endif

#define uchar unsigned char

#endif






#else
  char my_name[100];						// check to see if this address is 'hostname'
  gethostname(my_name,100);
  //ip_address *ret = 0;
  
  if (my_name[0]<'0' || my_name[0]>'9')
  {

    {
			buf[len] = 0;
      if  (strcmp(buf, notify_signature)==0) {
				char s[256];
#ifdef TCPIP_DEBUG
				char s[256];
				addr->store_string(s,256);
				printf("responding to %s",s);
#endif

      		 	
      	if (!found)
      	{
#ifdef TCPIP_DEBUG
					char s[256];
#endif
					RequestItem *r = new RequestItem;
					r->addr = addr;
					strcpy(r->name,buf+5);					// ack hard coded numbers for now




#include <bstring.h>
#include <netdb.h>

#define real2shm(type,ptr) (ptr==NULL ? NULL : ((type *)((uint8_t *)(ptr)-(uint8_t *)base)))
#define shm2real(type,ptr) (ptr==NULL ? NULL : ((type *)((intptr_t)(ptr)+(intptr_t)(base))))

net_driver *driver=NULL;


    comm_failed();

  // wait for engine to ack it has attached
  uint8_t ack=0;
  if (in->read(&ack,1)!=1 || ack!=1)
    comm_failed();


  int ret=0;
  if (in->ready_to_read())       // commands from engine?
  {
    uint8_t cmd;
    if (in->read(&cmd,1)!=1) return 0;

    if (debug)


      case NFCMD_REQUEST_ENTRY :
      {
	uint8_t len;
	char name[256];
	if (in->read(&len,1)!=1) { mdie("could not read server name length"); }
	if (in->read(name,len)!=len) { mdie("could not read server name"); }
	uint16_t success=join_server(name);
	if (out->write(&success,2)!=2) mdie("cound not send lsf read failure");      
      } break;
      case NFCMD_BECOME_SERVER :

      } break;
      case NFCMD_REQUEST_LSF :
      {
	uint8_t len;
	char name[256];
	if (in->read(&len,1)!=1) { mdie("could not read lsf name length"); }
	if (in->read(name,len)!=len) { mdie("could not read lsf name"); }


      case NFCMD_PROCESS_LSF :
      {
	uint8_t len,name[256];
	if (in->read(&len,1)!=1) { mdie("could not read lsf name length"); }
	if (in->read(name,len)!=len) { mdie("could not read lsf name"); }


	{
	  lsf_waiter *c=lsf_wait_list;
	  lsf_wait_list=lsf_wait_list->next;
	  uint8_t status=1;
	  c->sock->write(&len,1);
	  c->sock->write(name,len);
	  delete c;

	{
	  crc_waiter *c=crc_wait_list;
	  crc_wait_list=crc_wait_list->next;
	  uint8_t status=1;
	  c->sock->write(&status,1);
	  delete c;
	}


      case NFCMD_SET_FS :
      {
	uint8_t size;
	char sn[256];
	if (in->read(&size,1)!=1) mdie("could not read filename length");
	if (in->read(sn,size)!=size) mdie("could not read server name");


      case NFCMD_OPEN :
      {
	uint8_t size[2];
	char filename[300],mode[20],*fn;
	fn=filename;
	if (in->read(size,2)!=2  ||

	int fd=fman->rf_open_file(fn,mode);
	if (fd==-2)
	{
	  uint8_t st[2];
	  st[0]=NF_OPEN_LOCAL_FILE;
	  st[1]=strlen(fn)+1;
	  if (out->write(st,2)!=2) comm_failed();
	  if (out->write(fn,st[1])!=st[1]) comm_failed();
	} else if (fd==-1)
	{
	  uint8_t st=NF_OPEN_FAILED;
	  if (out->write(&st,1)!=1) comm_failed(); 
	} else
	{
	  uint8_t st=NF_OPEN_REMOTE_FILE;
	  if (out->write(&st,1)!=1) comm_failed(); 	
	  if (out->write(&fd,sizeof(fd))!=sizeof(fd)) comm_failed(); 	
	}

	  case NFCMD_CLOSE : 
	  { 
	    fman->rf_close(fd);
	    uint8_t st=1;
	    if (out->write(&st,1)!=1) comm_failed(); 	
	  } break;
	  case NFCMD_SIZE  :
	  {
	    int32_t x=fman->rf_file_size(fd);
	    if (out->write(&x,sizeof(x))!=sizeof(x)) comm_failed(); 		  
	  } break;
	  case NFCMD_TELL :
	  {
	    int32_t offset=fman->rf_tell(fd);
	    if (out->write(&offset,sizeof(offset))!=sizeof(offset)) comm_failed();  
	  } break;
	  case NFCMD_SEEK :
	  {
	    int32_t offset;
	    if (in->read(&offset,sizeof(offset))!=sizeof(offset)) comm_failed();
	    offset=fman->rf_seek(fd,offset);
	    if (out->write(&offset,sizeof(offset))!=sizeof(offset)) comm_failed();  
	  } break;
	  case NFCMD_READ :
	  {
	    int32_t size;
	    if (in->read(&size,sizeof(size))!=sizeof(size)) comm_failed();
	    fman->rf_read(fd,out,size);
	  } break;

    return 0;
  }

  uint8_t ctype=CLIENT_ABUSE;
  uint16_t port=lstl(game_port),cnum;

  uint8_t reg;
  if (sock->write(&ctype,1)!=1 ||   // send server out game port
      sock->read(&reg,1)!=1)        // is remote engine registered?
  { delete sock; return 0; }

  if (getlogin())
    strcpy(uname,getlogin());
  else strcpy(uname,"unknown");
  uint8_t len=strlen(uname)+1;

  if (sock->write(&len,1)!=1 ||
      sock->write(uname,len)!=len || 

  net_socket *sock=connect_to_server(name);
  if (!sock) return 0;

  uint8_t ctype=CLIENT_LSF_WAITER;
  uint8_t len;

  if (sock->write(&ctype,1)!=1 ||
      sock->read(&len,1)!=1 || len==0 ||

{
  net_socket *sock=connect_to_server(server);
  if (!sock) return 0;
  uint8_t cmd=CLIENT_CRC_WAITER;
  if (sock->write(&cmd,1)!=1 ||
      sock->read(&cmd,1)!=1)  
  { delete sock; return 0; }




      comm_failed();

    // wait for engine to ack it has attached
    uint8_t ack=0;
    if (read(driver_in_fd,&ack,1)!=1 || ack!=1)
      comm_failed();
  }

  char *name_start=name;
  int fd=connect_to_server(name);
  if (fd<0) return 0;
  uint8_t ctype=CLIENT_LSF_WAITER;
  if (write(fd,&ctype,1)!=1) { close(fd); return 0; } 
  uint8_t len;
  if (read(fd,&len,1)!=1 || len==0) { close(fd); return 0; }
  if (read(fd,name_start,len)!=len) { close(fd); return 0; }
  close(fd);

  strcpy(sn_start,server_name);

  int fd=connect_to_server(server_name);
  uint8_t ctype=CLIENT_ABUSE;
  if (write(fd,&ctype,1)!=1) { close(fd); return 0; } 

  // send server out game port
  uint16_t port=lstl(packet_port);
  if (write(fd,&port,2)!=2) { close(fd); return 0; }

  // read server's game port
  if (read(fd,&port,2)!=2) { close(fd); return 0; }
  port=lstl(port);

  uint16_t cnum;
  if (read(fd,&cnum,2)!=2 || cnum==0) { close(fd); return 0; }
  cnum=lstl(cnum);


  {
    if (!c->has_joined)
    {
      uint16_t cnum=lstl(c->client_id);
      if (write(c->socket_fd,&cnum,2)!=2) { c->delete_me=1; }
      c->wait_reload=1;
      c->has_joined=1;
    } else if (!c->delete_me)
    {
      uint8_t reload=CLCMD_RELOAD;
      if (write(c->socket_fd,&reload,1)!=1) { c->delete_me=1; }
      c->wait_reload=1;
    }


void process_engine_command()
{
  uint8_t cmd;
  if (read(driver_in_fd,&cmd,1)!=1) { mdie("could not read command from engine"); }
  switch (cmd)
  {

    {
      if (game_server_fd>0)
      {
	uint8_t ok=CLCMD_RELOADED;
        if (!write(game_server_fd,&ok,1)) { mdie("could not send join_ok msg"); }	
	next_process();
      }


    case NFCMD_REQUEST_ENTRY :
    {
      uint8_t len;
      char name[256];
      if (read(driver_in_fd,&len,1)!=1) { mdie("could not read server name length"); }
      if (read(driver_in_fd,name,len)!=len) { mdie("could not read server name"); }
      strcpy(net_server,name);
      uint16_t success=join_game(name);
      if (write(driver_out_fd,&success,2)!=2) mdie("cound not send lsf read failure");      
      next_process();
    } break;

    case NFCMD_REQUEST_LSF :
    {
      uint8_t len;
      char name[256];
      if (read(driver_in_fd,&len,1)!=1) { mdie("could not read lsf name length"); }
      if (read(driver_in_fd,name,len)!=len) { mdie("could not read lsf name"); }


    case NFCMD_PROCESS_LSF :
    {
      uint8_t len,name[256];
      if (read(driver_in_fd,&len,1)!=1) { mdie("could not read lsf name length"); }
      if (read(driver_in_fd,name,len)!=len) { mdie("could not read lsf name"); }
      while (lsf_wait_list)
      {
	lsf_waiter *c=lsf_wait_list;
	lsf_wait_list=lsf_wait_list->next;
	uint8_t status=1;
	write(c->socket_fd,&len,1);
	write(c->socket_fd,name,len);
	delete c;

      {
	crc_waiter *c=crc_wait_list;
	crc_wait_list=crc_wait_list->next;
	uint8_t status=1;
	write(c->socket_fd,&status,1);
	delete c;
      }


    case NFCMD_SET_FS :
    {
      uint8_t size;
      char sn[256];
      if (read(driver_in_fd,&size,1)!=1) mdie("could not read filename length");
      if (read(driver_in_fd,sn,size)!=size) mdie("could not read server name");


    case NFCMD_OPEN :
    {
      uint8_t size[2];
      char filename[300],mode[20],*fn;
      fn=filename;
      if (read(driver_in_fd,size,2)!=2) mdie("could not read fd on open");

      int fd=open_file(fn,mode);
      if (fd==-2)
      {
	uint8_t st[2];
	st[0]=NF_OPEN_LOCAL_FILE;
	st[1]=strlen(fn)+1;
	if (write(driver_out_fd,st,2)!=2) comm_failed();

	if (size!=st[1]) comm_failed();
      } else if (fd==-1)
      {
	uint8_t st=NF_OPEN_FAILED;
	if (write(driver_out_fd,&st,1)!=1) comm_failed(); 
      } else
      {
	uint8_t st=NF_OPEN_REMOTE_FILE;
	if (write(driver_out_fd,&st,1)!=1) comm_failed(); 	
	if (write(driver_out_fd,&fd,sizeof(fd))!=sizeof(fd)) comm_failed(); 	
      }

	{ 
	  unlink_remote_file(rf);
	  delete rf; 
	  uint8_t st=1;
	  if (write(driver_out_fd,&st,1)!=1) comm_failed(); 	
	} break;
	case NFCMD_SIZE  :


int process_client_command(client *c)
{
  uint8_t cmd;
  if (read(c->socket_fd,&cmd,1)!=1) return 0;
  switch (cmd)
  {

    } break;
    case CLCMD_REQUEST_RESEND :
    {
      uint8_t tick;
      if (read(c->socket_fd,&tick,1)!=1) return 0;




int add_game_client(int fd, sockaddr *from)     // returns false if could not join client
{  
  uint16_t port;
  if (read(fd,&port,2)!=2) { close(fd);  return 0; }
  port=lstl(port);

  uint16_t pport=lstl(packet_port);
  if (write(fd,&pport,2)!=2) { close(fd);  return 0; }  




  if (f===-1) { close(fd); return 0; }

  uint16_t client_id=lstl(f);
  if (write(fd,&client_id,2)!=2) { close(fd);  return 0; }    



	}
      } else if (FD_ISSET(game_server_fd,&read_set))
      {
	uint8_t cmd;
	if (read(game_server_fd,&cmd,1)!=1) { mdie("unable to read command from server"); }
	switch (cmd)
	{

	  } break;
	  case CLCMD_REQUEST_RESEND :
	  {
	    uint8_t tick;
	    if (read(game_server_fd,&tick,1)!=1) { mdie("unable to read resend tick from server"); }

	    fprintf(stderr,"request for resend tick %d (game cur=%d, pack=%d, last=%d)\n",





int game_client::process_server_command()
{
  uint8_t cmd;
  if (client_sock->read(&cmd,1)!=1) return 0;
  switch (cmd)
  {
    case CLCMD_REQUEST_RESEND :
    {
      uint8_t tick;
      if (client_sock->read(&tick,1)!=1) return 0;

      fprintf(stderr,"request for resend tick %d (game cur=%d, pack=%d, last=%d)\n",


      if (tick==base->packet.tick_received() && !wait_local_input)    // asking for this tick?  make sure is collected
      {
	fprintf(stderr,"resending client packet %d to server\n",base->packet.tick_received());
	net_packet *pack=&base->packet;
	game_sock->write(pack->data,pack->packet_size()+pack->packet_prefix_size(),server_data_port); 


    int bytes_received=game_sock->read(tmp.data,PACKET_MAX_SIZE);
    if (bytes_received==tmp.packet_size()+tmp.packet_prefix_size())   // was the packet complete?
    {
      uint16_t rec_crc=tmp.get_checksum();
      if (rec_crc==tmp.calc_checksum())
      {
	if (base->current_tick==tmp.tick_received())  


int game_client::end_reload(int disconnect)  // notify evryone you've reloaded the level (at server request)
{
  uint8_t cmd=CLCMD_RELOAD_END;
  if (client_sock->write(&cmd,1)!=1) return 0;
  return 1;
}

int game_client::start_reload()
{
  uint8_t cmd=CLCMD_RELOAD_START;
  if (client_sock->write(&cmd,1)!=1) return 0;
  if (client_sock->read(&cmd,1)!=1) return 0;
  return 1;


int game_client::quit()
{
  uint8_t cmd=CLCMD_UNJOIN;
  if (client_sock->write(&cmd,1)!=1) return 0;
  if (client_sock->read(&cmd,1)!=1) return 0;
  return 1;




    if (FD_ISSET(socket_fd,&write_check))            // ready to write?
    {
      char buf[READ_PACKET_SIZE];   
      int16_t read_total;
      int16_t actual;

      do
      {      

  {
    case NFCMD_READ :
    {
      int32_t size;
      if (read(c->socket_fd,&size,sizeof(size))!=sizeof(size)) return 0;
      size=lltl(size);


    } break;
    case NFCMD_SEEK :
    {
      int32_t offset;
      if (read(c->socket_fd,&offset,sizeof(offset))!=sizeof(offset)) return 0;
      offset=lltl(offset);
      offset=lseek(c->file_fd,offset,0);

    } break;
    case NFCMD_TELL :
    {
      int32_t offset=lseek(c->file_fd,0,SEEK_CUR);
      offset=lltl(offset);
      if (write(c->socket_fd,&offset,sizeof(offset))!=sizeof(offset)) return 0;
      return 1;


void add_nfs_client(int fd)
{
  uint8_t size[2];
  char filename[300],mode[20],*mp;
  if (read(fd,size,2)!=2) { close(fd); return ; }
  if (read(fd,filename,size[0])!=size[0]) { close(fd); return ; }

    f=-1;  // make sure this is -1
  }

  int32_t ret=lltl(f);
  if (write(fd,&ret,sizeof(ret))!=sizeof(ret)) { close(fd); return ; }

  if (f<0)    // no file, sorry
    close(fd);
  else
  {
    int32_t cur_pos=lseek(f,0,SEEK_CUR);
    int32_t size=lseek(f,0,SEEK_END);
    lseek(f,cur_pos,SEEK_SET);
    size=lltl(size);
    if (write(fd,&size,sizeof(size))!=sizeof(size)) {  close(f); close(fd); return ; }

    fprintf(stderr,"remote_file : %s\n",reason);
  if (socket_fd>=0) 
  {
    uint8_t cmd=NFCMD_CLOSE;
    write(socket_fd,&cmd,1);
    close(socket_fd); 
  }

    return ;
  }

  uint8_t sizes[3]={CLIENT_NFS,strlen(filename)+1,strlen(mode)+1};
  if (write(socket_fd,sizes,3)!=3) { r_close("could not send open info"); return ; }
  if (write(socket_fd,filename,sizes[1])!=sizes[1]) { r_close("could not send filename"); return ; }
  if (write(socket_fd,mode,sizes[2])!=sizes[2]) { r_close("could not send mode"); return ; }

  int32_t remote_file_fd;
  if (read(socket_fd,&remote_file_fd,sizeof(remote_file_fd))!=sizeof(remote_file_fd)) 
  { r_close("could not read remote fd"); return ; }   
  remote_file_fd=lltl(remote_file_fd);
  if (remote_file_fd<0) { r_close("remote fd is bad"); return ; }

  if (read(socket_fd,&size,sizeof(size))!=sizeof(size)) { r_close("could not read remote filesize"); return ; } 
//  uint32_t remote_crc;
//  if (read(socket_fd,&remote_crc,sizeof(remote_crc))!=sizeof(remote_crc)) { r_close("could not read remote checksum"); return ; }
//  uint32_t local_crc=

  size=lltl(size);
}

{
  if (socket_fd>=0 && count)
  {
    uint8_t cmd=NFCMD_READ;
    if (write(socket_fd,&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("read : could not send command"); return 0; }

    int32_t rsize=lltl(count);
    if (write(socket_fd,&rsize,sizeof(rsize))!=sizeof(rsize)) { r_close("read : could not send size"); return 0; }

    int32_t total_read=0,total;
    char buf[READ_PACKET_SIZE];
    uint16_t size;

    uint16_t packet_size;    
    do
    {
      if (read(socket_fd,&packet_size,sizeof(packet_size))!=sizeof(packet_size)) 

      }
      packet_size=lstl(packet_size);

      uint16_t size_read=read(socket_fd,buf+2,packet_size);   

      if (size_read!=packet_size) 
      { 

	}
      }

      *((int16_t *)buf)=packet_size;
      if (write(out_fd,buf,packet_size+2)!=packet_size+2) comm_failed();

      total_read+=packet_size;

{
  if (socket_fd>=0)
  {
    uint8_t cmd=NFCMD_TELL;
    if (write(socket_fd,&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("tell : could not send command"); return 0; }

    int32_t offset;
    if (read(socket_fd,&offset,sizeof(offset))!=sizeof(offset)) { r_close("tell : could not read offset"); return 0; }    
    return lltl(offset);
  }    
  return 0;
}

int remote_file::unbuffered_seek(int32_t offset)  // tell server to seek to a spot in a file
{
  if (socket_fd>=0)
  {
    uint8_t cmd=NFCMD_SEEK;
    if (write(socket_fd,&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("seek : could not send command"); return 0; }

    int32_t off=lltl(offset);
    if (write(socket_fd,&off,sizeof(off))!=sizeof(off)) { r_close("seek : could not send offset"); return 0; }

    if (read(socket_fd,&offset,sizeof(offset))!=sizeof(offset)) { r_close("seek : could not read offset"); return 0; }    

    return 0;
  }

  uint8_t cmd=CLIENT_CRC_WAITER;
  if (write(socket_fd,&cmd,1)!=1)  { close(socket_fd); return 0; }
  if (read(socket_fd,&cmd,1)!=1)  { close(socket_fd); return 0; }
  close(socket_fd);




  {
    case NFCMD_READ :
    {
      int32_t size;
      if (c->sock->read(&size,sizeof(size))!=sizeof(size)) return 0;
      size=lltl(size);


    } break;
    case NFCMD_SEEK :
    {
      int32_t offset;
      if (c->sock->read(&offset,sizeof(offset))!=sizeof(offset)) return 0;
      offset=lltl(offset);
      offset=lseek(c->file_fd,offset,0);

    } break;
    case NFCMD_TELL :
    {
      int32_t offset=lseek(c->file_fd,0,SEEK_CUR);
      offset=lltl(offset);
      if (c->sock->write(&offset,sizeof(offset))!=sizeof(offset)) return 0;
      return 1;


void file_manager::add_nfs_client(net_socket *sock)
{
  uint8_t size[2];
  char filename[300],mode[20],*mp;
  if (sock->read(size,2)!=2) { delete sock; return ; }
  if (sock->read(filename,size[0])!=size[0]) { delete sock; return ; }

    f=-1;  // make sure this is -1


  int32_t ret=lltl(f);
  if (sock->write(&ret,sizeof(ret))!=sizeof(ret)) { delete sock; return ; }

  if (f<0)    // no file, sorry
    delete sock;
  else
  {
    int32_t cur_pos=lseek(f,0,SEEK_CUR);
    int32_t size=lseek(f,0,SEEK_END);
    lseek(f,cur_pos,SEEK_SET);
    size=lltl(size);
    if (sock->write(&size,sizeof(size))!=sizeof(size)) {  close(f); delete sock; sock=NULL; return ; }

  next=Next;
  open_local=0;

  uint8_t sizes[3]={CLIENT_NFS,strlen(filename)+1,strlen(mode)+1};
  if (sock->write(sizes,3)!=3) { r_close("could not send open info"); return ; }
  if (sock->write(filename,sizes[1])!=sizes[1]) { r_close("could not send filename"); return ; }
  if (sock->write(mode,sizes[2])!=sizes[2]) { r_close("could not send mode"); return ; }

  int32_t remote_file_fd;
  if (sock->read(&remote_file_fd,sizeof(remote_file_fd))!=sizeof(remote_file_fd)) 
  { r_close("could not read remote fd"); return ; }   
  remote_file_fd=lltl(remote_file_fd);

{
  if (sock && count)
  {
    uint8_t cmd=NFCMD_READ;
    if (sock->write(&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("read : could not send command"); return 0; }

    int32_t rsize=lltl(count);
    if (sock->write(&rsize,sizeof(rsize))!=sizeof(rsize)) { r_close("read : could not send size"); return 0; }

    int32_t total_read=0;
    char buf[READ_PACKET_SIZE];

    ushort packet_size;

  return 0;
}

int32_t file_manager::remote_file::unbuffered_tell()   // ask server where the offset of the file pointer is
{
  if (sock)
  {
    uint8_t cmd=NFCMD_TELL;
    if (sock->write(&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("tell : could not send command"); return 0; }

    int32_t offset;
    if (sock->read(&offset,sizeof(offset))!=sizeof(offset)) { r_close("tell : could not read offset"); return 0; }    
    return lltl(offset);
  }    
  return 0;
}

int32_t file_manager::remote_file::unbuffered_seek(int32_t offset)  // tell server to seek to a spot in a file
{
  if (sock)
  {
    uint8_t cmd=NFCMD_SEEK;
    if (sock->write(&cmd,sizeof(cmd))!=sizeof(cmd)) { r_close("seek : could not send command"); return 0; }

    int32_t off=lltl(offset);
    if (sock->write(&off,sizeof(off))!=sizeof(off)) { r_close("seek : could not send offset"); return 0; }

    if (sock->read(&offset,sizeof(offset))!=sizeof(offset)) { r_close("seek : could not read offset"); return 0; }    

}


int32_t file_manager::rf_tell(int fd)
{
  remote_file *rf=find_rf(fd);
  if (rf) return rf->unbuffered_tell();
  else return 0;
}

int32_t file_manager::rf_seek(int fd, int32_t offset)
{
  remote_file *rf=find_rf(fd);
  if (rf) return rf->unbuffered_seek(offset);

  }  
}

int32_t file_manager::rf_file_size(int fd)
{
  remote_file *rf=find_rf(fd);
  if (rf) return rf->file_size();




    {
      if (c->delete_me())
      {
	base->packet.write_uint8(SCMD_DELETE_CLIENT);
	base->packet.write_uint8(c->client_id);
	if (c->wait_reload())
	{
	  c->set_wait_reload(0);


int game_server::process_client_command(player_client *c)
{
  uint8_t cmd;
  if (c->comm->read(&cmd,1)!=1) return 0;
  switch (cmd)
  {
    case CLCMD_REQUEST_RESEND :
    {
      uint8_t tick;
      if (c->comm->read(&tick,1)!=1) return 0;

      fprintf(stderr,"request for resend tick %d (game cur=%d, pack=%d, last=%d)\n",

      // make sure we got a complete packet and the packet was not a previous game tick packet
      if (bytes_received==use->packet_size()+use->packet_prefix_size())
      {
	uint16_t rec_crc=use->get_checksum();
	if (rec_crc==use->calc_checksum())
	{
	  player_client *f=player_list,*found=NULL;

  {
    if (!c->delete_me() && c->need_reload_start_ok())    // if the client is already waiting for reload state to start, send ok
    {
      uint8_t cmd=CLCMD_RELOAD_START;
      if (c->comm->write(&cmd,1)!=1) { c->set_delete_me(1); }
      c->set_need_reload_start_ok(0);
    }

	{
		if( total_players() >= main_net_cfg->max_players )
		{
			uint8_t too_many = 2;
			sock->write( &too_many, 1 );
			return 0;
		}

		uint8_t reg = registered ? 1 : 0;
		if( sock->write( &reg, 1 ) != 1 )
			return 0;

		uint16_t our_port = lstl( main_net_cfg->port + 1 ), cport;
		char name[256];
		uint8_t len;
		int16_t nkills=lstl(main_net_cfg->kills);

		if( sock->read(&len,1)!=1 ||
			sock->read(name,len)!=len ||


		from->set_port( cport );

		uint16_t client_id = lstl( f );
		if( sock->write( &client_id, 2 ) != 2 )
		{
			return 0;

  {
    player_client *d=c;
    c=c->next;
    delete d;
  }
  player_list=NULL;
  return 1;




  if (f->connect)
  {
    packet pk;
    uint8_t cmd=SCMD_QUIT;    // send quit command to server
    pk.write(&cmd,1);
    send_pkt(f->connect,pk);
    delete f->connect;

  collect_inputs();
}

uint32_t make_sync_uint32()
{
  uint32_t x=0;
  for (view *v=player_list;v;v=v->next)
  {
    x^=v->focus->x;

  return x^rand_on;
}

int server::process_command(view *f, uint8_t command, packet &pk)
{
  switch (command)
  {


    case SCMD_VIEW_RESIZE :                          // change view area
    {
      uint32_t view_size[8];          
      if (pk.read((uint8_t *)view_size,8*4)!=8*4)
      return 0;
      else
      {

	f->suggest.send_view=0;
	if (is_server)                  // if we are a server, tell everybody about this.
	{
	  uint8_t cmd=SCMD_VIEW_RESIZE;
	  next_out.write((uint8_t *)&cmd,1);
	  uint16_t pn=lstl(f->player_number);
	  next_out.write((uint8_t *)&pn,2);
	  next_out.write((uint8_t *)view_size,8*4);
	}
      }	      
    } break;

    case SCMD_WEAPON_CHANGE :                          // change weapon
    {
      uint32_t new_weap;
      if (pk.read((uint8_t *)&new_weap,4)!=4)
        return 0;
      else
      {

	f->suggest.send_weapon_change=0;
	if (is_server)                      // if we are a server, tell everybody about this.
	{
	  uint8_t cmd=SCMD_WEAPON_CHANGE;
	  next_out.write((uint8_t *)&cmd,1);
	  uint16_t pn=lstl(f->player_number);
	  next_out.write((uint8_t *)&pn,2);
	  next_out.write((uint8_t *)&new_weap,4);
	}
      }	      
    } break;

    case SCMD_SET_INPUT :                        // set the input from this player
    {
      signed char inp[5];
      if (pk.read((uint8_t *)inp,5)!=5)
        return 0;
      else		
        f->set_input(inp[0],inp[1],inp[2],inp[3],inp[4]);		

    } break;
    case SCMD_SYNC :
    {
      uint32_t x;
      if (pk.read((uint8_t *)&x,4)!=4)
        return 0;
      else 
      {
	uint32_t s=make_sync_uint32();
	if (lltl(x)!=s)
	  printf("Out of sync, %x!=%x\n",lltl(x),s);
	return 1;

{
  if (f->view_changed())
  {
    uint8_t cmd=SCMD_VIEW_RESIZE;
    pk.write(&cmd,1);
    if (number)
    {
      uint16_t pn=lstl(f->player_number);
      pk.write((uint8_t *)&pn,2);
      dprintf("Server : %s resized view %d %d %d %d\n",f->name,
	      f->suggest.cx1,f->suggest.cy1,f->suggest.cx2,f->suggest.cy2);
      f->resize_view(f->suggest.cx1,f->suggest.cy1,f->suggest.cx2,f->suggest.cy2);
      f->suggest.send_view=0;
    } else dprintf("sending resize to server\n");
    uint32_t view_size[8];          	  
    view_size[0]=lltl(f->suggest.cx1);
    view_size[1]=lltl(f->suggest.cy1);
    view_size[2]=lltl(f->suggest.cx2);

    view_size[5]=lltl(f->suggest.pan_y);
    view_size[6]=lltl(f->suggest.shift_down);
    view_size[7]=lltl(f->suggest.shift_right);
    pk.write((uint8_t *)view_size,8*4);
  }

  if (f->weapon_changed())
  {
    uint8_t cmd=SCMD_WEAPON_CHANGE;
    pk.write(&cmd,1);
    if (number)
    {
      uint16_t pn=lstl(f->player_number);
      pk.write((uint8_t *)&pn,2);
      dprintf("Server : %s change weapon to %d\n",f->name,f->suggest.new_weapon);
      f->current_weapon=f->suggest.new_weapon;
      f->suggest.send_weapon_change=0;
    } else dprintf("sending resize to server\n");
    uint32_t nw=lltl(f->suggest.new_weapon);
    pk.write((uint8_t *)&nw,4);
  }
}


  inp[3]=f->b1_suggestion;
  inp[4]=f->b2_suggestion;
  inp[5]=f->b3_suggestion;
  if (pk.write((uint8_t *)inp,6)!=6)
    return 0;
  if (!send_pkt(f->connect,pk))
    return 0;

	{
	  while (!pk.eop())
	  {
	    uint8_t cmd;
	    if (pk.read((uint8_t *)&cmd,1)==1)
	      if (!process_command(f,cmd,pk))
	      { remove_player(f); f=NULL; }
	  }

  for (view *f=player_list;f;f=f->next)
  {   
    cmd=SCMD_SET_INPUT;
    next_out.write((uint8_t *)&cmd,1);
    uint16_t pn=lstl(f->player_number);
    next_out.write((uint8_t *)&pn,2);

    signed char inp[5];
    inp[0]=f->x_suggestion;

    inp[2]=f->b1_suggestion;
    inp[3]=f->b2_suggestion;
    inp[4]=f->b3_suggestion;
    next_out.write((uint8_t *)inp,5);
  }

  if (sync_check)
  {
    cmd=SCMD_SYNC;
    uint32_t x=lltl(make_sync_uint32());
    next_out.write((uint8_t *)&cmd,1);  
    next_out.write((uint8_t *)&x,4);  
  }

  for (f=player_list;f;)  

    if (nd)
    {
      packet pk;
//      pk.write_uint32(file_server->get_port());      
      if (!send_pkt(nd,pk))
      {
	printf("error writing to connection\n");

	pk.get_string(name,100);
	printf("Joined by player %s\n",name);
	pk.reset();
	uint8_t ok=1;
	pk.write((uint8_t *)&ok,1);      // write ok to join
	send_pkt(nd,pk);

	/**************** Read suggested view size from client ****/

	  printf("error reading view info from connection\n");
	  return ;	
	}	
	int32_t cx1,cy1,cx2,cy2;
	if (pk.read((uint8_t *)&cx1,4)!=4) return ;  cx1=lltl(cx1); 
	if (pk.read((uint8_t *)&cy1,4)!=4) return ;  cy1=lltl(cy1); 
	if (pk.read((uint8_t *)&cx2,4)!=4) return ;  cx2=lltl(cx2); 
	if (pk.read((uint8_t *)&cy2,4)!=4) return ;  cy2=lltl(cy2); 

	/**************** Create the player  *******************/
	for (view *f=player_list;f && f->next;f=f->next);      // find last player, add one for pn


	if (current_level->send(nd))
	{	
	  uint8_t cmd=SCMD_ADD_VIEW;
	  next_out.write((uint8_t *)&cmd,1);
	  v->write_packet(next_out);


	  /********** Send all of the views to the player **********/ 
	  pk.reset();
	  uint16_t tv=0;
	  for (f=player_list;f;f=f->next) tv++;
	  tv=lstl(tv);
	  pk.write((uint8_t *)&tv,2);
	  if (!send_pkt(nd,pk)) return ;

	  for (f=player_list;f;f=f->next)

	  }

	  pk.reset();
	  uint16_t r=lstl(rand_on);
	  pk.write((uint8_t *)&r,2);       // write current random seed
	  pk.write((uint8_t *)rtable,1024*2);
	  send_pkt(nd,pk);

	}


  if (!get_pkt(os,pk))                  // read join status packet, 0 means we can't join
  { fputs(re,stderr); exit(0); }
  int32_t nfs_port;
  if (pk.read((uint8_t *)&nfs_port,4)!=4)
  { fputs(re,stderr); exit(0); }

//  connect_to_nfs_server(server_name,lltl(nfs_port));




  pk.write((uint8_t *)name,strlen(name)+1);  // send or name and see if it's ok to join in
  if (!send_pkt(os,pk))
  {    
    printf("Unable to write to server\n");

  if (!get_pkt(os,pk))                  // read join status packet, 0 means we can't join
  { fputs(re,stderr); exit(0); }
  
  uint8_t stat;
  if (pk.read((uint8_t *)&stat,1)!=1)
  { fputs(re,stderr); exit(0); }

  if (stat==0)

  if (current_level)
    delete current_level;

  int32_t vs[4]={lltl(320/2-155),lltl(200/2-95),lltl(320/2+155),lltl(200/2+70)};
  pk.write((uint8_t *)vs,4*4);
  if (!send_pkt(os,pk))   { printf("Unable to write to server\n"); exit(0);  }
  


    printf("Unable to read views from server\n");
    exit(0);
  }
  uint16_t tv;
  if (pk.read((uint8_t *)&tv,2)!=2)
  { fputs(re,stderr); exit(0); }
  tv=lstl(tv);
  view *last=NULL;

  }   

  if (!get_pkt(os,pk)) { fputs(re,stderr); exit(0); }
  if (pk.read((uint8_t *)&rand_on,2)!=2)    // read the current random seed used by the server.
  { fputs(re,stderr); exit(0); }
  rand_on=lstl(rand_on);
  uint16_t *rtab=(uint16_t *)jmalloc(1024*2,"tmp rtab");
  if (!pk.read((uint8_t *)rtab,1024*2)) { fputs(re,stderr); exit(0); }  // read the rand table

  for (int j=0;j<1024*2;j++)
    if (((uint8_t *)rtab)[j]!=((uint8_t *)rtable)[j])
    { printf("rtables differ on byte %d\n",j); exit(0); }
    
  jfree(rtab);


void server::remove_player(view *f)
{
  uint8_t cmd=SCMD_REMOVE_VIEW;
  next_out.write((uint8_t *)&cmd,1);
  uint16_t pn=lstl(f->player_number);
  next_out.write((uint8_t *)&pn,2);
  if (f==player_list)
    player_list=player_list->next;
  else

{

	  cmd=SCMD_ADD_VIEW;
	  next_out.write((uint8_t *)&cmd,1);

    uint16_t pn=lstl(new_player->player_number);
    next_out.write((uint8_t *)&pn,2);
    uint16_t type=lstlli(new_player->focus->otype);
    next_out.write((uint8_t *)&type,2);
    uint32_t x=lltl(new_player->focus->x),y=lltl(new_player->focus->y);
    next_out.write((uint8_t *)&x,4);
    next_out.write((uint8_t *)&y,4);    
  }*/



#define TOT_VIEW_VARS 32
view *server::add_view(packet &pk)
{
  uint32_t x[TOT_VIEW_VARS];
  if (!pk.read((uint8_t *)x,TOT_VIEW_VARS*4)) return NULL;
  for (int i=0;i<TOT_VIEW_VARS;i++) x[i]=lltl(x[i]);
  int skip=0;
  for (view *f=player_list;f;f=f->next)

    v->last_ammo=x[22];  v->last_type=x[23]; v->visor_time=x[28]; v->current_weapon=x[29];
    v->secrets=x[30];    v->kills=x[31];

    pk.read((uint8_t *)v->weapons,total_objects*4);
    pk.get_string(v->name,100);



  int er=0;
  while (!pk.eop() && !er)
  {
    uint8_t cmd;
    if (pk.read(&cmd,1)!=1)
      er=1;
    else

      int fail=0;
      if (cmd!=SCMD_ADD_VIEW && cmd!=SCMD_SYNC)
      {	
	uint16_t player;
	if (pk.read((uint8_t *)&player,2)!=2)
	  er=1;
	player=lstl(player);
	for (f=player_list;f && f->player_number!=player;f=f->next);

Lines 412-418 Link Here

(-)abuse-sdl-0.7.0.orig/src/chars.cpp (-1 / +1 lines)
412	else	412	else
413	{	413	{
414	lprint(lcar(field));	414	lprint(lcar(field));
415	lbreak("Unknown field for character definiltion");	415	lbreak("Unknown field for character definition");
416	exit(0);	416	exit(0);
417	}	417	}
418	}	418	}




    return 0; 
  }

  fp->write_uint16(total);
  total=0;
  for (i=0;i<total_files;i++)
  {
    uint32_t crc;
    int failed=0;
    crc=get_crc(i,failed);
    if (!failed)
    {
      fp->write_uint32(crc);
      uint8_t len=strlen(get_filename(i))+1;
      fp->write_uint8(len);
      fp->write(get_filename(i),len);
      total++;
    }

    return 0;
  } else
  {
    short total=fp->read_uint16();
    int i;
    for (i=0;i<total;i++)
    {
      char name[256];
      uint32_t crc=fp->read_uint32();
      uint8_t len=fp->read_uint8();
      fp->read(name,len);
      set_crc(get_filenumber(name),crc);
    }

  return total_files-1;
}

char *crc_manager::get_filename(int32_t filenumber)
{
  CHECK(filenumber>=0 && filenumber<total_files);
  return files[filenumber]->filename;
}

uint32_t crc_manager::get_crc(int32_t filenumber, int &failed)
{    
  CHECK(filenumber>=0 && filenumber<total_files);
  if (files[filenumber]->crc_calculated) 

  return 0;
}

void crc_manager::set_crc(int32_t filenumber, uint32_t crc)
{
  CHECK(filenumber>=0 && filenumber<total_files);
  files[filenumber]->crc_calculated=1;


    if (fp)
    {
      fp->write_uint16(crc_man.total_filenames());
      for (i=0;i<crc_man.total_filenames();i++)
      {
	int l=strlen(crc_man.get_filename(i))+1;
        fp->write_uint8(l);
	fp->write(crc_man.get_filename(i),l);
      }

      int tsaved=0;
      for (i=0;i<total;i++)
        if (list[i].last_access>0) tsaved++;
      fp->write_uint32(tsaved);

      for (i=0;i<total;i++)
      {
	int id=ordered_ids[i];
        if (list[id].last_access>0)       // don't save unaccessed counts      
	{
	  fp->write_uint8(list[id].type);    // save type, if type changed on reload 
	                                    // don't cache in-> its a different refrence
	  fp->write_uint16(list[id].file_number);
	  fp->write_uint32(list[id].offset);
	}
      }      
    }

}


int cache_list::search(int *sarray, uint16_t filenum, int32_t offset)
{
  int x1=0,x2=total-1;
  int split;



  int j;
  uint16_t *fg_line;
  for (j=0;j<lev->foreground_height();j++)
  {
    fg_line=lev->get_fgline(j);

    }      
  }

  uint16_t *bg_line;
  for (j=0;j<lev->background_height();j++)
  {
    bg_line=lev->get_bgline(j);

      int tnames=0;
      int *fnum_remap;    // remaps old filenumbers into current ones
      
      tnames=fp->read_uint16();
      if (tnames)                     /// make sure there isn't bad info in the file
      {
	fnum_remap=(int *)jmalloc(sizeof(int)*tnames,"pfname remap");

	int i;
	for (i=0;i<tnames;i++)
	{
	  fp->read(name,fp->read_uint8());
	  fnum_remap[i]=-1;                    // initialize the map to no-map

	  int j;

	      fnum_remap[i]=j;
	}
	
	uint32_t tsaved=fp->read_uint32();


	int *priority=(int *)jmalloc(tsaved*sizeof(int),"priorities");


	for (i=0;i<tsaved;i++)
	{
	  uint8_t type=fp->read_uint8();
	  short file_num=fp->read_uint16();
	  if (file_num>=tnames)  // bad data?
	    file_num=-1;
	  else file_num=fnum_remap[file_num];

	  uint32_t offset=fp->read_uint32();

	  // search for a match 
	  j=search(sorted_id_list,file_num,offset);	 

  used=1;
}

int32_t cache_list::alloc_id()
{
  int id;
  if (prof_data)




int32_t cache_list::reg_lisp_block(Cell *block)
{ 
  uint32_t s;
  if (lcache_number==-1)
    lcache_number=crc_man.get_filenumber(lfname);


    {
      if (cache_read_file)
      {
	delete cache_read_file;
	cache_read_file=NULL;
			
				cache_file=new jFILE(lfname,"ab");	
      } else cache_file=new jFILE(lfname,"wb");	 // first time we opened

	cache_file=new jFILE(lfname,"ab");	
      } else cache_file=new jFILE(lfname,"wb");	 // first time we opened
    }
    if (cache_file->open_failure()) 
    { 

  ci->offset=cache_file->tell();

  s=block_size(block);
  cache_file->write_uint32(s);
  write_level(cache_file,block);
  return id;    
}

int32_t cache_list::reg_object(char *filename, void *object, int type, int rm_dups)
{ 
  char *name;
  if (item_type(object)==L_CONS_CELL)      // see if we got a object with a filename included


extern int total_files_open;

int32_t cache_list::reg(char *filename, char *name, int type, int rm_dups)
{
	int id=alloc_id(),i,fn=crc_man.get_filenumber(filename);
	cache_item *ci=list+id;

      
      int cache_size=80*1024;                   // 80K
      cache_read_file->set_read_buffer_size(cache_size); 
      uint8_t mini_buf;
      cache_read_file->read(&mini_buf,1);       // prime the buffer
    }



    int sp=alloc_space; alloc_space=ALLOC_SPACE_CACHE;

    uint32_t size=cache_read_file->read_uint32();
    void *space;

    if (size)


void cache_list::free_oldest()
{
  uint32_t i,old_time=last_access;
  cache_item *ci=list,*oldest=NULL;
  ful=1;


      old=ci->last_access;
      printf("type=(%20s) file=(%20s) access=(%6ld)\n",spec_types[ci->type],
	     crc_man.get_filename(ci->file_number),
	     (long int)ci->last_access);
    }
  } while (new_old);
}




int numsounds;			// number of sound effects
int longsound;			// longest sound effect
int lengths[NUMSFX];		// lengths of all sound effects
uint8_t mixbuffer[MIXBUFFERSIZE];	// mixing buffer
int sfxdevice;			// file descriptor of sfx device
int musdevice;			// file descriptor of music device
uint8_t *channels[8];	// the channel data pointers
uint8_t *channelsend[8];	// the channel data end pointers
int channelstart[8];		// time that the channel started playing
int channelhandles[8];		// the channel handles


    } while (j);
    if (d > 127) mixbuffer[i] = 255;
    else if (d < -128) mixbuffer[i] = 0;
    else mixbuffer[i] = (uint8_t) (d+128);
//    if (d > 127) mixbuffer[i] = 0;
//    else if (d < -128) mixbuffer[i] = 255;
//    else mixbuffer[i] = (uint8_t) (-d+127);
  }

  // check for freed channels


  int i;
  int rc = -1;
  static uint16_t handlenums = 0;
  int oldest = mytime;
  int oldestnum = 0;


    if (!channels[i])
    {
      channelsend[i] =
        (channels[i] = (uint8_t *) S_sfx[sfxid].data) + lengths[sfxid];
      if (!handlenums) handlenums = 100;
      channelhandles[i] = rc = handlenums++;
      channelstart[i] = mytime;

  if (i == 8)
  {
    channelsend[oldestnum] =
      (channels[oldestnum] = (uint8_t *) S_sfx[sfxid].data)
       + lengths[sfxid];
    if (!handlenums) handlenums = 100;
    channelhandles[oldestnum] = rc = handlenums++;


}

void output_uint16(int num)
{

  static uint8_t buff[5] = { 0, 0, 0, 0, '\n' };
  static char *badbuff = "xxxx\n";

  // outputs a 16-bit # in hex or "xxxx" if -1.

void initdata(void)
{
  int i;
  for (i=0 ; i<sizeof(channels)/sizeof(uint8_t *) ; i++) channels[i] = 0;
  gettimeofday(&last, &whocares);
  usleep(100000);
}


  int done = 0;
  int rc, nrc, sndnum, handle = 0;
  uint8_t commandbuf[10];
  fd_set fdset, scratchset;
  struct timeval zerowait = { 0, 0 };





#include <sys/stat.h>
#endif

#include <limits.h>
#include <time.h>

level *current_level;

game_object *level::attacker(game_object *who)
{ 
  int32_t d=0x7fffffff;
  game_object *c=NULL;
  view *f=the_game->first_view;
  for (;f;f=f->next)
  {
    if (f->focus)
    {
      int32_t tmp_d=abs(f->focus->x-who->x)+abs(f->focus->y-who->y);
      if (tmp_d<d)
      {
	d=tmp_d;

  }
}

int level::add_actives(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
{
  int t=0;
  game_object *last_active=NULL;

  {    
    if (!o->active)
    {
      int32_t xr=figures[o->otype]->rangex,
           yr=figures[o->otype]->rangey;

      if (o->x+xr>=x1 && o->x-xr<=x2 && o->y+yr>=y1 && o->y-yr<=y2)

}


int level::add_drawables(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
{
  int t=0,ft=0;
  game_object *last_active=NULL;

  {    
    if (ft || !o->active)
    {
      int32_t xr=figures[o->otype]->draw_rangex,
      yr=figures[o->otype]->draw_rangey;

      if (o->x+xr>=x1 && o->x-xr<=x2 && o->y+yr>=y1 && o->y-yr<=y2)


void level::wall_push()
{
  int32_t sx1,sy1,sx2,sy2,xv,yv;
  game_object *o=first_active;
  for (;o;o=o->next_active)
  {

    int b1=subject->push_range(),b2=target->push_range();
    if (abs(subject->x-target->x)<b1+b2)
    {
      int32_t tmove=b1+b2-abs(subject->x-target->x),xv,yv=0,xv2;
      if (subject->x>target->x)
        xv=tmove/2;
      else xv=-tmove/2;

void level::check_collisions()
{
  game_object *target,*reciever=NULL;
  int32_t sx1,sy1,sx2,sy2,tx1,ty1,tx2,ty2,hitx,hity,
      s_centerx,t_centerx;

  for (game_object *subject=first_active;subject;subject=subject->next_active)

	    {
	      for (t_dat=t_damage->data,j=(int)t_damage->tot-1;j>0 && !hit;j--)
	      {
		int32_t x1,y1,x2,y2,          // define the two line segments to check
		xp1,yp1,xp2,yp2;

		xp1=target->x+target->tx(*t_dat);  t_dat++;	      

}
*/

game_object *level::boundary_setback(game_object *subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2)
{
  game_object *l=NULL;
  int32_t tx1,ty1,tx2,ty2,t_centerx;
  game_object *target=first_active;
  game_object **blist=block_list;
  int t=block_total;

	int iter=t_damage->tot-1;
	while(iter-->0)
	{
	  int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;	      
	  int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
	  int32_t xp2=target->x+target->tx(*t_dat); 
	  int32_t yp2=target->y+target->ty(t_dat[1]); 

	  // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
	  if (*ins)

}


game_object *level::all_boundary_setback(game_object *subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2)
{
  game_object *l=NULL;
  int32_t tx1,ty1,tx2,ty2,t_centerx;
  game_object *target=first_active;
  game_object **blist=all_block_list;
  int t=all_block_total;

	int iter=t_damage->tot-1;
	while(iter-->0)
	{
	  int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;	      
	  int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
	  int32_t xp2=target->x+target->tx(*t_dat); 
	  int32_t yp2=target->y+target->ty(t_dat[1]); 

	  // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
	  if (*ins)


void level::interpolate_draw_objects(view *v)
{
  int32_t old_x,old_y;
  current_view=v;
  
  game_object *o=first_active;

  if (current_demo_mode()==DEMO_PLAY)
  {
    if (!rcheck) rcheck=open_file("rcheck","rb");
    int32_t x=rcheck->read_uint32();
    if (x!=rand_on)
      dprintf("off!\n");
  } else if (current_demo_mode()==DEMO_RECORD)

      rcheck=open_file("rcheck","wb");
      rcheck_lp=open_file("rcheck.lp","wb");
    }
    rcheck->write_uint32(rand_on);
  } else
  {
    if (rcheck)

      if (c)
      {      
	area_controller *a,*smallest=NULL;
	int32_t smallest_size=0xffffffff;
	for (a=area_list;a;a=a->next)
	  if (o->x>=a->x && o->y>=a->y && o->x<=a->x+a->w && o->y<=a->y+a->h)
	  {
	    int32_t size=a->w*a->h;
	    if (size<smallest_size)
	    {
	      smallest=a;


	if (o->otype!=current_start_type)
	{
	  int32_t fmp=o->fmp();      
	  int reduce=figures[o->otype]->morph_power;
	  if (reduce)
	  {

  return ret;
}

void level::set_tick_counter(uint32_t x) 
{ 
  ctick=x; 
}

void level::draw_areas(view *v)
{
  int32_t sx1,sy1,sx2,sy2;
  area_controller *a=area_list;
  for (;a;a=a->next)
  {

  clear_tmp();
}  

void calc_bgsize(uint16_t fgw, uint16_t  fgh, uint16_t  &bgw, uint16_t  &bgh)
{
  bgw=fgw/ASPECT+8;
  bgh=fgh/ASPECT+8;  

    return ; 
  }

  uint16_t *new_fg,*new_bg;
  new_fg=(uint16_t *)jmalloc(w*h*sizeof(int16_t),"Map fg : resized");
  memset(new_fg,0,w*h*sizeof(int16_t));

  int x,y,miny=(h<fg_height)? h : fg_height,minx=(w<fg_width)? w : fg_width;
  
  uint16_t nbw,nbh;
  calc_bgsize(w,h,nbw,nbh);
  
  new_bg=(uint16_t *)jmalloc((int)nbw*(int)nbh*sizeof(int16_t),"map bg : resized");
  memset(new_bg,0,(int)nbw*(int)nbh*sizeof(int16_t));

  for (y=0;y<miny;y++)
    for (x=0;x<minx;x++)

  if (se)
  {
    fp->seek(se->offset,0);
    if (RC_type_size(fp->read_uint8())!=size)
      return 0;
    else return 1;
  } 

  {
    fp->seek(se->offset,0);
    /******************************* Read debug info ******************************/
    int16_t old_tot=fp->read_uint16();  
    uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");    
    char old_name[150];      
    for (i=0;i<old_tot;i++)
    {
      fp->read(old_name,fp->read_uint8());    // read the name
      for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
      {
	if (!strcmp(old_name,object_names[j]))



    /***************************** Read state names *********************************/
    int old_stot=fp->read_uint16();
    unsigned char *s_remap=(unsigned char *)jmalloc(old_stot,"state remap array");
    for (i=0;i<old_stot;i++)
    {
      fp->read(old_name,fp->read_uint8());
      s_remap[i]=stopped;           // non exsitant states get mapped into stopped state
      for (j=0;j<MAX_STATE;j++)                  // see if old state exist now
	if (!strcmp(state_names[j],old_name))
         s_remap[i]=j;
    }
    total_objs=fp->read_uint32();    

    se=sd->find("type");
    if (se)
    {
      fp->seek(se->offset,0);
      last=NULL;
      if (fp->read_uint8()==RC_16)    //  read type array, this should be type RC_16
      {
	for (i=0;i<total_objs;i++)
	{
	  uint16_t t=fp->read_uint16();
	  game_object *p=new game_object(o_remap[t],1);
	  clear_tmp();
	  if (!first) first=p; else last->next=p;

	if (se)
	{
	  fp->seek(se->offset,0);
	  if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
	  {
	    game_object *l=first;
	    for (i=0;i<total_objs;i++,l=l->next)
	    {
	      character_state s=(character_state)s_remap[fp->read_uint16()];
	      if (l->otype!=0xffff)
	      {
		if (l->has_sequence((character_state)s))

	  {
	    fp->seek(se->offset,0);
	    int t=object_descriptions[j].type;
	    if (fp->read_uint8()!=t)
	      dprintf("Warning : load level -> var '%s' size changed\n");
	    else
	    {

	      {	       
		switch (t)
		{
		  case RC_8 : f->set_var(j,fp->read_uint8()); break;
		  case RC_16 : f->set_var(j,fp->read_uint16()); break;
		  case RC_32 : f->set_var(j,fp->read_uint32()); break;
		}

		// check to make sure the frame number is not out of bounds from the time

  else if (se)
  {
    fp->seek(se->offset,0);
    int16_t old_tot=fp->read_uint16();
    se=sd->find("describe_names");
    if (!se || !old_tot)
      return ;

    uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");    
    uint16_t *o_backmap=(uint16_t *)jmalloc(total_objects*2,"obj remap array");    
    memset(o_backmap,0xff,total_objects*2);
    char old_name[150];      
    for (i=0;i<old_tot;i++)
    {
      fp->read(old_name,fp->read_uint8());    // read the name
      for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
      {
	if (!strcmp(old_name,object_names[j]))


    se=sd->find("describe_states");
    if (!se) { jfree(o_remap); jfree(o_backmap); return ; }
    int16_t **s_remap=(int16_t **)jmalloc(old_tot*sizeof(int16_t *),"big state remap array");
    int16_t *s_remap_totals=(int16_t *)jmalloc(old_tot*sizeof(int16_t),"big state rmp totals");
    fp->seek(se->offset,0);
    int i=0;
    for (;i<old_tot;i++)
    {
      int16_t t=fp->read_uint16();
      s_remap_totals[i]=t;
      if (t)
      {
        s_remap[i]=(int16_t *)jmalloc(t*sizeof(int16_t),"state remap");
	int j=0;
	for (;j<t;j++)
	  *(s_remap[i]+j)=stopped;    // if no remap found, then go to stopped state

      int j=0;
      for (;j<t;j++)
      {
	fp->read(old_name,fp->read_uint8());
	int new_type=o_remap[i];	
	if (new_type<total_objects)     // make sure old object still exsist
	{

      }
    }

    int16_t **v_remap=NULL;
    int16_t *v_remap_totals=NULL;
    int load_vars=1;
    se=sd->find("describe_lvars");
    if (se)
    {
      v_remap=(int16_t **)jmalloc(old_tot*sizeof(int16_t *),"big var remap array");
      v_remap_totals=(int16_t *)jmalloc(old_tot*sizeof(int16_t),"big var rmp totals");

      fp->seek(se->offset,0);
      int i=0;
      for (;i<old_tot;i++)
      {
	int16_t t=fp->read_uint16();
	v_remap_totals[i]=t;
	if (t)
	{
	  v_remap[i]=(int16_t *)jmalloc(t*sizeof(int16_t),"var remap");
	  memset(v_remap[i],0xff,t*sizeof(int16_t));
	} else { v_remap[i]=NULL; }
	int j=0;
	for (;j<t;j++)
	{
	  fp->read(old_name,fp->read_uint8());
	  int new_type=o_remap[i];
	  if (new_type!=0xffff)        // make sure old object still exsist
	  {

    se=sd->find("object_list");
    if (se)
    {
      total_objs=fp->read_uint32();    

      se=sd->find("type");
      if (se)
      {
	fp->seek(se->offset,0);
	last=NULL;
	if (fp->read_uint8()==RC_16)    //  read type array, this should be type RC_16
	{
	  int i=0;
	  for (;i<total_objs;i++)
	  {
	    uint16_t t=fp->read_uint16();
	    game_object *p=new game_object(o_remap[t],1);
	    clear_tmp();
	    if (!first) first=p; else last->next=p;

	  if (se)
	  {
	    fp->seek(se->offset,0);
	    if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
	    {
	      game_object *l=first;
	      for (i=0;i<total_objs;i++,l=l->next)
	      {
		int st=fp->read_uint16();
		if (l->otype==0xffff)
		  l->state=stopped;
		else

	    game_object *o=first;
	    for (;o && !abort;o=o->next)
	    {
	      int16_t ot=fp->read_uint16();
	      int k=0;
	      for (;k<ot;k++)
	      {
		if (fp->read_uint8()!=RC_32) abort=1;
		else
		{
		  int32_t v=fp->read_uint32();
		  if (o->otype!=0xffff)     // non-exstant object
		  {
		    int remap=*(v_remap[o_backmap[o->otype]]+k);

	    {
	      fp->seek(se->offset,0);
	      int t=object_descriptions[j].type;
	      if (fp->read_uint8()!=t)
	        dprintf("Warning : load level -> var '%s' size changed\n");
	      else
	      {

		{	       
		  switch (t)
		  {
		    case RC_8 : 
		    { f->set_var(j,fp->read_uint8()); } break;
		    case RC_16 : 
		    { f->set_var(j,fp->read_uint16()); } break;
		    case RC_32 : 
		    { f->set_var(j,fp->read_uint32()); } break;
		  }
		  
		  // check to make sure the frame number is not out of bounds from the time

  if (e)
  {
    fp->seek(e->offset,0);
    int len=fp->read_uint8();   // read the length of the string
    first_name=(char *)jmalloc(len,"level first name");
    fp->read(first_name,len);    // read the string
  } else

  if (e)
  {    
    fp->seek(e->offset,0);
    fg_width=fp->read_uint32();
    fg_height=fp->read_uint32();
    map_fg=(uint16_t *)jmalloc(2*fg_width*fg_height,"Map fg : loaded");
    fp->read((char *)map_fg,2*fg_width*fg_height);
    int t=fg_width*fg_height;
    uint16_t *map=map_fg;
    while (t) { *map=lstl(*map); map++; t--; }
  } else
  {

  if (e)
  {
    fp->seek(e->offset,0);
    bg_width=fp->read_uint32();
    bg_height=fp->read_uint32();
    map_bg=(uint16_t *)jmalloc(2*bg_width*bg_height,"Map bg : loaded");
    fp->read((char *)map_bg,2*bg_width*bg_height);
    int t=bg_width*bg_height;
    uint16_t *map=map_bg;
    while (t) { *map=lstl(*map); map++; t--; } 
  } else
  {

  {
    fg_width=bg_width;
    fg_height=bg_height;
    map_fg=(uint16_t *)jmalloc(2*fg_width*fg_height,"Map fg : loaded");
    memset(map_fg,0,2*fg_width*fg_height);
  }


  {
    bg_width=fg_width/8+8;
    bg_height=fg_height/8+8;
    map_bg=(uint16_t *)jmalloc(2*bg_width*bg_height,"Map bg : loaded");
    memset(map_bg,0,2*bg_width*bg_height);
  }
  stat_man->update(10);

  /***************** Check map for non exsistant tiles **************************/
  int32_t i,w;
  uint16_t *m;  
  spec_entry *load_all=sd->find("player_info");
  for (i=0,w=fg_width*fg_height,m=map_fg;i<w;i++,m++)
  {


 

  // how many objects are we goint to save, use a int32_t to specify how many
  sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"object_list",NULL,4,0)); 
  
  int32_t t=0;
  object_node *o=save_list;
  for (;o;o=o->next)
    t++;

  strftime(buf,80,"%T %A %B %d",localtime(&t));  
  eh->font()->put_string(i,80-strlen(buf)*eh->font()->width()/2,100+eh->font()->height(),buf);

  fp->write_uint16(i->width());
  fp->write_uint16(i->height());
  int y=0;
  for (;y<i->height();y++)
    fp->write(i->scan_line(y),i->width());


void level::write_player_info(bFILE *fp, object_node *save_list)
{
  int32_t t=0;
  view *v=player_list;
  for (;v;v=v->next) t++; 
  fp->write_uint32(t);

  for (v=player_list;v;v=v->next)
    fp->write_uint32(object_to_number_in_list(v->focus,save_list));

  int tv=total_view_vars();
  int i=0;
  for (;i<tv;i++)
  {
    fp->write_uint8(RC_32);
    for (v=player_list;v;v=v->next)
      fp->write_uint32(v->get_view_var_value(i));
  }

  fp->write_uint8(RC_32);
  fp->write_uint32(rand_on);

  fp->write_uint8(RC_32);
  fp->write_uint32(total_weapons);
  for (v=player_list;v;v=v->next)
    for (i=0;i<total_weapons;i++)
      fp->write_uint32(v->weapons[i]);

  for (v=player_list;v;v=v->next)
  {
    int len=strlen(v->name)+1;
    fp->write_uint8(len);
    fp->write(v->name,len);
  }
}

      delete v;
    }

    int32_t total_players=fp->read_uint32();
    view *last=NULL;
    int i=0;
    for (;i<total_players;i++)    
    {
      game_object *o=number_to_object_in_list(fp->read_uint32(),save_list);
      v=new view(o,NULL,0);
      if (o) o->set_controller(v);
      if (player_list)

      if (se)
      {
	fp->seek(se->offset,0);
	if (fp->read_uint8()==RC_32)
	{
	  for (v=player_list;v;v=v->next)
            v->set_view_var_value(i,fp->read_uint32());
	}
      } else 
      {

    if (se)
    {
      fp->seek(se->offset,0);
      if (fp->read_uint8()==RC_32)
        rand_on=fp->read_uint32();
    } else rand_on=0;

    se=sd->find("weapon_array");
    if (se)
    {
      fp->seek(se->offset,0);
      if (fp->read_uint8()==RC_32)
      {
	int32_t m=fp->read_uint32();  // read how many weapons exsisted when last saved
	int i;
	for (v=player_list;v;v=v->next)	  
	{
	  for (i=0;i<m;i++)
	  {
	    int32_t x=fp->read_uint32();
	    if (i<total_weapons)
	    {
	      v->weapons[i]=x;

    { 
      for (v=player_list;v;v=v->next)	  
      {
	memset(v->last_weapons,0xff,total_weapons*sizeof(int32_t));
	memset(v->weapons,0xff,total_weapons*sizeof(int32_t));
      }
    }


      fp->seek(se->offset,0);
      for (v=player_list;v;v=v->next)	  
      {
	uint8_t len=fp->read_uint8();
	fp->read(v->name,len);
      }
    }

{
  // record information in the file about what the data structures look like
  // right now, so if they change later, they don't get get screwed up
  fp->write_uint16(total_objects);   // mark how many objects we know about right now  

  int i=0;
  for (;i<total_objects;i++)   // loop through all the object types we know of
  {    
    fp->write_uint8(strlen(object_names[i])+1);                    // sizeof name    
    fp->write(object_names[i],strlen(object_names[i])+1);      // write object name
  }
    

    int j=0;
    for (;j<figures[i]->ts;j++)
      if (figures[i]->seq[j]) total++;
    fp->write_uint16(total);

    for (j=0;j<figures[i]->ts;j++)
      if (figures[i]->seq[j])
      {
	char *state_name=lstring_value(symbol_name(figures[i]->seq_syms[j]));
	fp->write_uint8(strlen(state_name)+1);
	fp->write(state_name,strlen(state_name)+1);
      }
  }

  // write object lvar names
  for (i=0;i<total_objects;i++)
  {
    fp->write_uint16(figures[i]->tv);
    int j,x;
    
    for (x=0;x<figures[i]->tv;x++)

        if (figures[i]->vars[j] && figures[i]->var_index[j]==x)
	{
	  char *var_name=lstring_value(symbol_name(figures[i]->vars[j]));
	  fp->write_uint8(strlen(var_name)+1);
	  fp->write(var_name,strlen(var_name)+1);
	}
      }
    }
  }
  
  int32_t t=0;
  object_node *o=save_list;
  for (;o;o=o->next) t++;
  fp->write_uint32(t);


  fp->write_uint8(RC_16);                                    // save type info for each record
  for (o=save_list;o;o=o->next) fp->write_uint16(o->me->type());    

  fp->write_uint8(RC_16);                                    // save state info for each record
  for (o=save_list;o;o=o->next) fp->write_uint16(o->me->reduced_state());

  for (o=save_list;o;o=o->next)                            // save lvars
  {
    fp->write_uint16(figures[o->me->otype]->tv);
    for (i=0;i<figures[o->me->otype]->tv;i++) 
    {
      fp->write_uint8(RC_32);                           // for now the only type allowed is int32_t
      fp->write_uint32(o->me->lvars[i]);
    }
  }

  for (i=0;i<default_simple.total_vars();i++)
  {
    int t=object_descriptions[i].type;
    fp->write_uint8(t);
    for (o=save_list;o;o=o->next)
    {
      switch (t)
      { 	
	case RC_8 :
	{ fp->write_uint8(o->me->get_var(i)); } break;
	case RC_16 :
	{ fp->write_uint16(o->me->get_var(i)); } break;
	case RC_32 :
	{ fp->write_uint32(o->me->get_var(i)); } break;
      }
    }
  }
}


int32_t level::total_object_links(object_node *list)
{
  int32_t tl=0;
  for (object_node *o=list;o;o=o->next)
    tl+=o->me->total_objects();
  return tl;
}

int32_t level::total_light_links(object_node *list)
{
  int32_t tl=0;
  for (object_node *o=list;o;o=o->next)
    tl+=o->me->total_lights();
  return tl;


void level::write_links(bFILE *fp, object_node *save_list, object_node *exclude_list)
{
  fp->write_uint8(RC_32);  
  fp->write_uint32(total_object_links(save_list));

  int x=1;
  object_node *o=save_list;

    int i=0;
    for (;i<o->me->total_objects();i++)
    {
      fp->write_uint32(x);
      int32_t x=object_to_number_in_list(o->me->get_object(i),save_list); 
      if (x)
        fp->write_uint32(x);
      else                            // save links to excluded items as negative
        fp->write_uint32((int32_t)(-(object_to_number_in_list(o->me,exclude_list))));
    }
  }

  fp->write_uint8(RC_32);  
  fp->write_uint32(total_light_links(save_list));

  x=1;
  for (o=save_list;o;o=o->next,x++)

    int i=0;
    for (;i<o->me->total_lights();i++)
    {
      fp->write_uint32(x);
      fp->write_uint32(light_to_number(o->me->get_light(i)));
    }
  }


  if (se)
  {
    fp->seek(se->offset,0);
    if (fp->read_uint8()==RC_32)
    {
      int32_t t=fp->read_uint32();
      while (t)
      {
	int32_t x1=fp->read_uint32();
	CONDITION(x1>=0,"expected x1 for object link to be > 0\n");
	int32_t x2=fp->read_uint32();
	game_object *p,*q=number_to_object_in_list(x1,save_list);
	if (x2>0)
	  p=number_to_object_in_list(x2,save_list);

  if (se)
  {
    fp->seek(se->offset,0);
    if (fp->read_uint8()==RC_32)
    {
      int32_t t=fp->read_uint32();
      while (t)
      {
	int32_t x1=fp->read_uint32();
	int32_t x2=fp->read_uint32();
	game_object *p=number_to_object_in_list(x1,save_list);
	if (p)
	  p->add_light(number_to_light(x2));

void level::write_options(bFILE *fp)
{
  // save background scroll rate
  fp->write_uint8(RC_32);
  fp->write_uint32(bg_xmul);
  fp->write_uint32(bg_xdiv);
  fp->write_uint32(bg_ymul);
  fp->write_uint32(bg_ydiv);

  fp->write_uint8(RC_32);
  int ta=0;
  area_controller *a=area_list;
  for (;a;a=a->next) ta++;
  fp->write_uint32(ta);
  for (a=area_list;a;a=a->next)
  {
    fp->write_uint32(a->x);
    fp->write_uint32(a->y);
    fp->write_uint32(a->w);
    fp->write_uint32(a->h);
    fp->write_uint32(a->active);

    fp->write_uint32(a->ambient);
    fp->write_uint32(a->view_xoff);
    fp->write_uint32(a->view_yoff);
    fp->write_uint32(a->ambient_speed);
    fp->write_uint32(a->view_xoff_speed);
    fp->write_uint32(a->view_yoff_speed);
  }
  fp->write_uint8(RC_32);
  fp->write_uint32(tick_counter());
}

void level::load_options(spec_directory *sd, bFILE *fp)

  if (se)
  {
    fp->seek(se->offset,0);
    if (fp->read_uint8()!=RC_32)
    { bg_xmul=bg_ymul=1; bg_xdiv=bg_ydiv=8; }
    else
    {
      bg_xmul=fp->read_uint32();
      bg_xdiv=fp->read_uint32();
      bg_ymul=fp->read_uint32();
      bg_ydiv=fp->read_uint32();
    }
  } else { bg_xmul=bg_ymul=1; bg_xdiv=bg_ydiv=8; }


  if (se)
  {
    fp->seek(se->offset,0);
    if (fp->read_uint8()==RC_32)
    {
      area_controller *l=NULL,*p;
      int32_t ta=fp->read_uint32();
      int i=0;
      for (;i<ta;i++)
      {
	int32_t x,y,w,h;
	x=fp->read_uint32();
	y=fp->read_uint32();
	w=fp->read_uint32();
	h=fp->read_uint32();	
	p=new area_controller(x,y,w,h,NULL);
	if (l) l->next=p;
	else area_list=p;
	l=p;
	p->active=fp->read_uint32();
	p->ambient=fp->read_uint32();
	p->view_xoff=fp->read_uint32();
	p->view_yoff=fp->read_uint32();
	p->ambient_speed=fp->read_uint32();
	p->view_xoff_speed=fp->read_uint32();
	p->view_yoff_speed=fp->read_uint32();
      }
    }
  }

  if (se)
  {
    fp->seek(se->offset,0);
    if (fp->read_uint8()==RC_32)    
      set_tick_counter(fp->read_uint32());
    else set_tick_counter(0);
  } else set_tick_counter(0);
}

				dprintf("unable to open backup file %s\n", bkname );
			else
			{
				int32_t size = fp->file_size();
				uint8_t *buf = (uint8_t *)jmalloc(0x1000,"copy buf");
				int tr = 1;
				while( size && tr )
				{

		{
			if( first_name )
			{
				fp->write_uint8( strlen( first_name ) + 1 );
				fp->write( first_name, strlen( first_name ) + 1 );
			}
			else
			{
				fp->write_uint8( 1 );
				fp->write_uint8( 0 );
			}

			fp->write_uint32( fg_width );
			fp->write_uint32( fg_height );

			int t  = fg_width * fg_height;
			uint16_t *rm = map_fg;
			for (;t;t--,rm++)
			{
				uint16_t x = *rm;
				x = lstl(x);            // convert to intel endianess
				*rm = x;
			}

			rm = map_fg;
			for (;t;t--,rm++)
			{
				uint16_t x = *rm;
				x = lstl( x );            // convert to intel endianess
				*rm = x;
			}

			fp->write_uint32( bg_width );
			fp->write_uint32( bg_height );
			t = bg_width * bg_height;
			rm = map_bg;

			for (;t;t--,rm++)
			{
				uint16_t x=*rm;
				x = lstl( x );		// convert to intel endianess
				*rm = x;
			}


			for (;t;t--,rm++)
			{
				uint16_t x = *rm;
				x = lstl( x );		// convert to intel endianess
				*rm = x;
			}

  fg_height=height;
  calc_bgsize(fg_width,fg_height,bg_width,bg_height);
  
  map_bg=(uint16_t *)jmalloc(sizeof(int16_t)*bg_width*bg_height,"map bg");
  map_fg=(uint16_t *)jmalloc(sizeof(int16_t)*fg_width*fg_height,"map fg");



  memset(map_bg,0,sizeof(int16_t)*bg_width*bg_height);
  memset(map_fg,0,sizeof(int16_t)*fg_width*fg_height);

  int i;  
  for (i=0;i<fg_width;i++)

  return me;
}

game_object *level::find_object(int32_t x, int32_t y)
{
  int32_t x1,y1,x2,y2;  
  game_object *o=first;
  for (;o;o=o->next)
  {

  return NULL; 
}

int32_t last_tile_hit_x,last_tile_hit_y;

#define remapx(x) (x==0 ? -1 : x==tl-1 ? tl+1 : x)
#define remapy(y) (y==0 ? -1 : y==th-1 ? th+1 : y)

void level::foreground_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2)
{
/*  if (x1==x2)
  { vforeground_intersect(x1,y1,y2);
    return ;
  }  */

  int32_t tl=the_game->ftile_width(),th=the_game->ftile_height(),
    j,
    xp1,yp1,xp2,yp2,    // starting and ending points of block line segment 
    swap;               // temp var
  int32_t blockx1,blocky1,blockx2,blocky2,block,bx,by;
  point_list *block_list;
  unsigned char *bdat;


        unsigned char total=block_list->tot;
        bdat=block_list->data;
        unsigned char *ins=f->points->inside;
	int32_t xo=bx*tl,yo=by*th;
        for (j=0;j<total-1;j++,ins++)
        {
          // find the starting and ending points for this segment

	  yp2=yo+remapy(bdat[1]);


	  int32_t ox2=x2,oy2=y2;
          if (*ins)	  
            setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1); 
          else

}


void level::vforeground_intersect(int32_t x1, int32_t y1, int32_t &y2)
{
  int32_t tl=f_wid,th=f_hi,
    j,
    xp1,yp1,xp2,yp2;    // starting and ending points of block line segment temp var
  int32_t blocky1,blocky2,block,bx,by,checkx;
  point_list *block_list;
  unsigned char *bdat;


    bdat=block_list->data;
    unsigned char *ins=f->points->inside;

//    int32_t xo=bx*tl,yo=by*th;
    for (j=0;j<total-1;j++,ins++)
    {
      // find the starting and ending points for this segment

      yp2=remapy(bdat[1]);


      int32_t oy2=y2;
      if (*ins)	  
        setback_intersect(checkx,y1,checkx,y2,xp1,yp1,xp2,yp2,1); 
      else




void level::send_signal(int32_t signal)
{
  if (signal)   // signal 0 is never sent!
  {


int level::crush(game_object *by_who, int xamount, int yamount)
{
  int32_t xv,yv,crushed=0;  
  game_object *o=first_active;
  for (;o;o=o->next_active)
  {

int level::platform_push(game_object *by_who, int xamount, int yamount)
{
  int failed=0;
  int32_t xv,yv;
  game_object *o=first_active;
  for (;o;o=o->next_active)  
  {
    if (o->is_playable() && o->state!=dieing && o->state!=dead)  
    {      
      // check to see if the platform is going up and will run into us.      
      int32_t tvx,tvy;
      if (yamount<0)
      {
	tvx=-xamount;


int level::push_characters(game_object *by_who, int xamount, int yamount)
{
  int32_t xv,yv;
  int failed=0;
  game_object *o=first_active;
  for (;o;o=o->next_active)  

    {      
      xv=-xamount;    
      yv=-yamount;
      int32_t tvx,tvy;
      if (xv>0) tvx=xv+1; else if (xv<0) tvx=xv-1; else tvx=0;
      if (yv>0) tvy=yv+1; else if (yv<0) tvx=yv-1; else tvy=0;
      if (o->try_move(o->x+xamount,o->y+yamount,tvx,tvy,3)==by_who)


game_object *level::find_xrange(int x, int y, int type, int xd)
{
  int32_t find_ydist=100000;
  game_object *find=NULL;
  game_object *o=first_active;
  for (;o;o=o->next_active)  


game_object *level::find_xclosest(int x, int y, int type, game_object *who)
{
  int32_t find_ydist=100000,find_xdist=0xffffff;
  game_object *find=NULL;
  game_object *o=first_active;
  for (;o;o=o->next_active)  


game_object *level::find_closest(int x, int y, int type, game_object *who)
{
  int32_t find_dist=100000;
  game_object *find=NULL;
  game_object *o=first_active;
  for (;o;o=o->next_active)  

  return l;
}

void level::hurt_radius(int32_t x, int32_t y,int32_t r, int32_t m, game_object *from, game_object *exclude, 
			int max_push)
{
  if (r<1) return ;   // avoid dev vy zero

  {
    if (o!=exclude && o->hurtable())
    {
      int32_t y1=o->y,y2=o->y-o->picture()->height();
      int32_t cx=abs(o->x-x),cy1=abs(y1-y),d1,d2,cy2=abs(y2-y);
      if (cx<cy1)
        d1=cx+cy1-(cx>>1);
      else d1=cx+cy1-(cy1>>1);

    { 
      if (v!=exclude)
      {
	int32_t cx=abs(v->x_center()-o->x),cy=abs(v->y_center()-o->y),d;
	if (cx<cy)
          d=cx+cy-(cx>>1);
	else d=cx+cy-(cy>>1);

}


game_object *level::find_object_in_area(int32_t x, int32_t y, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
				     Cell *list, game_object *exclude)
{
  game_object *closest=NULL;
  int32_t closest_distance=0xfffffff,distance,xo,yo;
  game_object *o=first_active;
  for (;o;o=o->next_active)
  {
    int32_t xp1,yp1,xp2,yp2;
    o->picture_space(xp1,yp1,xp2,yp2);






game_object *level::find_object_in_angle(int32_t x, int32_t y, int32_t start_angle, int32_t end_angle,
				    void *list, game_object *exclude)
{
  game_object *closest=NULL;
  int32_t closest_distance=0xfffffff,distance,xo,yo;
  game_object *o=first_active;
  for (;o;o=o->next_active)
  {
    int32_t angle=lisp_atan2(o->y-y,o->x-x);
    if (((start_angle<=end_angle && (angle>=start_angle && angle<=end_angle))
	|| (start_angle>end_angle && (angle>=start_angle || angle<=end_angle)))
	&& o!=exclude)

    game_object *o=first;
    for (;o;o=o->next)
    {
      fprintf(fp,"%3d %s %4ld %4ld %4ld %4ld %04d\n",i++,object_names[o->otype],(long)o->x,(long)o->y,
	      (long)o->xvel(),(long)o->yvel(),o->current_frame);
    }
    fclose(fp);
  }
}


area_controller::area_controller(int32_t X, int32_t Y, int32_t W, int32_t H, area_controller *Next)
{ 
  x=X; y=Y; w=W; h=H; 
  next=Next; active=0; 




int dev,shift_down=SHIFT_DOWN_DEFAULT,shift_right=SHIFT_RIGHT_DEFAULT;
double sum_diffs=1,total_diffs=12;
int total_active=0;
int32_t map_xoff=0,map_yoff=0;
int32_t current_vxadd,current_vyadd;
int frame_panic=0,massive_frame_panic=0;
int demo_start=0,idle_ticks=0;
int req_end=0;

char req_name[100];

int registered=0;
extern uint8_t chatting_enabled;

extern int confirm_quit();


  }
}

void game::play_sound(int id, int vol, int32_t x, int32_t y)
{
	if( sound_avail & SFX_INITIALIZED )
	{

		if( !player_list )
			return;

		uint32_t mdist = 0xffffffff;
		view *cd = NULL;
		for( view *f = player_list; f ; f = f->next )
		{
			if( f->local_player() )
			{
				int32_t cx = abs(f->x_center()-x),cy = abs(f->y_center()-y), d;
				if( cx < cy )
					d = cx + cy - ( cx >> 1 );
				else

  else return 0;
}

void game::ftile_on(int screenx, int screeny, int32_t &x, int32_t &y)
{
  mouse_to_game(screenx,screeny,x,y);
  x/=ftile_width();

/*  view *f=view_in(screenx,screeny);
  if (f)
  {
    x=((int32_t)(screenx)-(int32_t)f->cx1+f->xoff())/(int32_t)f_wid;
    y=((int32_t)(screeny)-(int32_t)f->cy1+f->yoff())/(int32_t)f_hi;
  }
  else
  {

  }*/
}

void game::btile_on(int screenx, int screeny, int32_t &x, int32_t &y)
{
  view *f=view_in(screenx,screeny);
  if (f)
  {
    x=((int32_t)(screenx)-(int32_t)f->cx1+f->xoff()*bg_xmul/bg_xdiv)/(int32_t)b_wid; 
    y=((int32_t)(screeny)-(int32_t)f->cy1+f->yoff()*bg_ymul/bg_ydiv)/(int32_t)b_hi;
  }
  else
  {

}


void game::mouse_to_game(int32_t x, int32_t y, int32_t &gamex, int32_t &gamey, view *f)
{
  if (!f)
  {


      if (dev&MAP_MODE)
      {
	gamex=((x-(int32_t)f->cx1)*ftile_width()/AUTOTILE_WIDTH+map_xoff*ftile_width());
	gamey=((y-(int32_t)f->cy1)*ftile_height()/AUTOTILE_HEIGHT+map_yoff*ftile_height());
      } else
      {
	gamex=(x-(int32_t)f->cx1+f->xoff());
	gamey=(y-(int32_t)f->cy1+f->yoff());
      }

  }

}

void game::game_to_mouse(int32_t gamex, int32_t gamey, view *which, int32_t &x, int32_t &y)
{
  if (dev&MAP_MODE)
  {
    int32_t x1,y1;
    if (dev&EDIT_MODE)
    {
      x1=map_xoff;

  {			      
    spec_directory sd(fp);  

#if 0
    spec_entry *e=sd.find("Copyright 1995 Crack dot Com, All Rights reserved"); 
    if (!e)
    { 

      the_game->need_refresh();
    }
    else 
#endif
      current_level=new level(&sd,fp,name);
    delete fp;
  }

  }
}

void remap_area(image *screen, int x1, int y1, int x2, int y2, uint8_t *remap)
{
  uint8_t *sl=(uint8_t *)screen->scan_line(y1)+x1;
  int x,y,a=screen->width()-(x2-x1+1);
  uint8_t c;
  for (y=y1;y<=y2;y++)
  {
    for (x=x1;x<=x2;x++)

    return ;
  }

  int32_t old_cx1=0,old_cy1=0,old_cx2=0,old_cy2=0;   // if we do a small render, we need to restore these
  image *old_screen=NULL;
  if (small_render && (dev&DRAW_LIGHTS))  // cannot do this if we skip lighting
  {




//  int32_t max_xoff=(current_level->foreground_width()-1)*ftile_width()-(v->cx2-v->cx1+1);
//  int32_t max_yoff=(current_level->foreground_height()-1)*ftile_height()-(v->cy2-v->cy1+1); 

  int32_t xoff,yoff;
  if (interpolate)
  {
    xoff=v->interpolated_xoff();

  nxoff=xoff*bg_xmul/bg_xdiv;
  nyoff=yoff*bg_ymul/bg_ydiv;

//  int32_t max_bg_xoff=(current_level->background_width())*btile_width()-(v->cx2-v->cx1+1);
//  int32_t max_bg_yoff=(current_level->background_height())*btile_height()-(v->cy2-v->cy1+1);
//  if (nxoff>max_bg_xoff) nxoff=max_xoff;
//  if (nyoff>max_bg_yoff) nyoff=max_yoff;  
  

    yinc=btile_height();  
    
    int bh=current_level->background_height(),bw=current_level->background_width();
    uint16_t *bl;
    for (draw_y=yo,y=y1;y<=y2;y++,draw_y+=yinc)
    {
      if (y>=bh)

//  if (!(dev&EDIT_MODE))
//    server_check();

  uint8_t rescan=0;  

    int fw,fh;


      {
	if (!(draw_y<ncy1 ||draw_y+yinc>=ncy2))
	{
	  uint16_t *cl=current_level->get_fgline(y)+x1;
	  uint8_t *sl1=screen->scan_line(draw_y)+xo;
	  for (x=x1,draw_x=xo;x<=x2;x++,cl++,sl1+=xinc,draw_x+=xinc)
	  {
	    if (!(draw_x<ncx1 || draw_x+xinc>=ncx2))

	        fort_num=fgvalue(*cl);
//	      else fort_num=0;

	      uint8_t *sl2=get_fg(fort_num)->micro_image->scan_line(0);
	      uint8_t *sl3=sl1;
	      memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
	      memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
	      memcpy(sl3,sl2,AUTOTILE_WIDTH);

      for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
      {
	
	uint16_t *cl;
	if (y<fg_h)
	  cl=current_level->get_fgline(y)+x1;
	else cl=NULL;
	uint8_t *sl1=draw_y<ncy1 ? 0 : screen->scan_line(draw_y)+xo;

	for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++,sl1+=xinc)
	{

//  if (!(dev&EDIT_MODE))
//    server_check();

  int32_t ro=rand_on;
  if (dev & DRAW_PEOPLE_LAYER)
  {
    if (interpolate)

    {
      for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
      {
	uint16_t *cl=current_level->get_fgline(y)+x1;
	for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++)
	{
	  if (above_tile(*cl))


      for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
      {
	uint16_t *cl;
	if (y<fg_h)
	  cl=current_level->get_fgline(y)+x1;
	else cl=NULL;

	    if (fort_num!=BLACK)
	    {
	      point_list *p=get_fg(fort_num)->points;
	      uint8_t *d=p->data;	
	      if (p->tot)
	      {
		for (int i=1;i<p->tot;i++)


  for (i=0;i<steps;i++)
  {
    uint8_t *sl1=(uint8_t *)pal->addr();    
    uint8_t *sl2=(uint8_t *)old_pal->addr();    
    int j;
    int v=(i+1)*256/steps;
    for (j=0;j<256;j++)

  int i;
  for (i=0;i<steps;i++)
  {
    uint8_t *sl1=(uint8_t *)pal->addr();    
    uint8_t *sl2=(uint8_t *)old_pal->addr();    
    int j;
    int v=(steps-i)*256/steps;
    for (j=0;j<256;j++)

  pal->load();
}

int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uint8_t *cmap, char color);

void do_title()
{

			smoke[0]->put_image( screen, dx + 24, dy + 5 );

			fade_in( NULL, 16 );
			uint8_t cmap[32];
			for( i = 0; i < 32; i++ )
			cmap[i] = pal->find_closest( i * 256 / 32, i * 256 / 32, i * 256 / 32 );



//	ProfilerInit(collectDetailed, bestTimeBase, 2000, 200); //prof
	char *fastpath;
	fastpath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 12 + 1, "fastpath" );
	sprintf( fastpath, "%sfastload.dat", get_save_filename_prefix() );
	fast_load_start_recording( fastpath );
	load_data(argc,argv);  
	fast_load_stop_recording();

		if (avg_fps>15 && ((dev&EDIT_MODE)==0 || need_delay))
		{
			frame_panic = 0;
			int32_t stime=(int32_t)((1/15.0-1.0/possible_fps)*1000.0); 
			if (stime>0 && !no_delay)
			{
				milli_wait(stime);

					if(ev.key < 256 )
					{
						if( chat && chat->chat_event( ev ) )
							base->packet.write_uint8( SCMD_CHAT_KEYPRESS );
						else
							base->packet.write_uint8( SCMD_KEYPRESS );
					}
					else
						base->packet.write_uint8( SCMD_EXT_KEYPRESS );
					base->packet.write_uint8( client_number() );
					if( ev.key > 256 )
						base->packet.write_uint8( ev.key - 256 );
					else
						base->packet.write_uint8( ev.key );
				}
			}
			else if(ev.type == EV_KEYRELEASE )

				if( playing_state( state ) )
				{
					if( ev.key < 256 )
						base->packet.write_uint8( SCMD_KEYRELEASE );
					else
						base->packet.write_uint8( SCMD_EXT_KEYRELEASE );
					base->packet.write_uint8( client_number() );
					if( ev.key > 255 )
						base->packet.write_uint8( ev.key - 256 );
					else
						base->packet.write_uint8( ev.key );
				}
			}


	  p->get_input();


      base->packet.write_uint8(SCMD_SYNC);
      base->packet.write_uint16(make_sync());

      if (base->join_list)
      base->packet.write_uint8(SCMD_RELOAD);

      //      printf("save tick %d, pk size=%d, rand_on=%d, sync=%d\n",current_level->tick_counter(),
      //	     base->packet.packet_size(),rand_on,make_sync());

{
  if (!(dev&EDIT_MODE) && current_level)
  {
    uint8_t buf[PACKET_MAX_SIZE+1];
    int size;

    if (demo_man.state==demo_manager::PLAYING)


	fprintf(stderr,"Mac Options: ");
	xres = 320; yres = 200;
	GetKeys((uint32_t*)&km);
	if ((km[ 0x3a >>3] >> (0x3a & 7)) &1 != 0)
	{
		dev|=EDIT_MODE;    

Lines 191-198 Link Here

(-)abuse-sdl-0.7.0.orig/src/loadgame.cpp (-2 / +3 lines)
191	if (total_saved>MAX_SAVE_GAMES)	191	if (total_saved>MAX_SAVE_GAMES)
192	total_saved=MAX_SAVE_GAMES;	192	total_saved=MAX_SAVE_GAMES;
193		193
194	int i,ih=cash.img(save_buts[0])->height();	194	int i;
195	/* ico_button *buts[MAX_SAVE_GAMES];	195	/* int ih=cash.img(save_buts[0])->height();
		196	ico_button *buts[MAX_SAVE_GAMES];
196	int y=WINDOW_FRAME_TOP;	197	int y=WINDOW_FRAME_TOP;
197		198
198		199

Lines 4-10 Link Here

(-)abuse-sdl-0.7.0.orig/src/specache.cpp (-2 / +2 lines)
4		4
5	void spec_directory_cache::load(bFILE *fp)	5	void spec_directory_cache::load(bFILE *fp)
6	{	6	{
7	short tfn=fp->read_short();	7	short tfn=fp->read_uint16();
8	int i;	8	int i;
9	unsigned char len;	9	unsigned char len;
10	char fn[256];	10	char fn[256];
Lines 23-29 Link Here
23	filename_node *f=fn_list;	23	filename_node *f=fn_list;
24	for (;f;f=f->next)	24	for (;f;f=f->next)
25	total++;	25	total++;
26	fp->write_short(total);	26	fp->write_uint16(total);
27	for (f=fn_list;f;f=f->next)	27	for (f=fn_list;f;f=f->next)
28	{	28	{
29	unsigned char len=strlen(f->filename())+1;	29	unsigned char len=strlen(f->filename())+1;




  return a;
}

static uint8_t *cstart,*cend,*collected_start,*collected_end;

inline void *collect_cons_cell(void *x)
{
  cons_cell *last=NULL,*first=NULL;
  if (!x) return x;
  for (;x && item_type(x)==L_CONS_CELL;)
  {

{
  void *ret=x;

  if (((uint8_t *)x)>=cstart && ((uint8_t *)x)<cend)
  {
    switch (item_type(x))
    {

    }
    ((lisp_collected_object *)x)->type=L_COLLECTED_OBJECT;
    ((lisp_collected_object *)x)->new_reference=ret;
  } else if ((uint8_t *)x<collected_start || (uint8_t *)x>=collected_end)  
  {
    if (item_type(x)==L_CONS_CELL) // still need to remap cons_cells outside of space
    {


void collect_space(int which_space) // should be tmp or permenant
{
  return; /* XXX */

  int old_space=current_space;
  cstart=(uint8_t *)space[which_space];
  cend=(uint8_t *)free_space[which_space];

  space_size[GC_SPACE]=space_size[which_space];
  void *new_space=jmalloc(space_size[GC_SPACE],"collect lisp space");
  current_space=GC_SPACE;
  free_space[GC_SPACE]=space[GC_SPACE]=(char *)new_space;

  collected_start=(uint8_t *)new_space;
  collected_end=(((uint8_t *)new_space)+space_size[GC_SPACE]);

  collect_symbols(lsym_root);
  collect_stacks();


  space[which_space]=(char *)new_space;
  free_space[which_space]=((char *)new_space)+
         (((uint8_t *)free_space[GC_SPACE])-((uint8_t *)space[GC_SPACE]));
  current_space=old_space;
}







  Simple object             (power ups, non-moving objects)
    int32_t x,y;
    int8_t direction;
    uint16_t otype,state
    uint16_t current_frame;
    extension *


  Moving object             (simple lisp controlled characters)
     uint8_t flags;
     int32_t xvel,yvel,xacel,yacel;
     uint8_t fx,fy,fxvel,fyvel,fxacel,fyacel,aitype;
     uint16_t aistate,aistate_time;
     uint16_t hp,mp,
     extension *


  Complex objects          (can controll lights, other characters, and have a neural net ai)
    uint8_t tobjs,tlights;
    object_list *                       
    light_list *
    nnet_info *
    int8_t fade_dir, frame_dir;        
    uint8_t fade_count,fade_max;
    morph_char *morph_status;







  for (y=y1;y<=y2;y++)
  {
    uint8_t *sl=screen->scan_line(y)+x1;
    for (x=x1;x<=x2;x++,sl++)
    {
      uint8_t *paddr=(uint8_t *)pal->addr()+(*sl)*3;
      uint8_t r=((*(paddr++))-r_to)*percent/256+r_to;
      uint8_t g=((*(paddr++))-g_to)*percent/256+g_to;
      uint8_t b=((*(paddr++))-b_to)*percent/256+b_to;
      *sl=color_table->lookup_color((r)>>3,(g)>>3,(b)>>3);
    }
  }


  for (y=y1;y<=y2;y++)
  {
    uint8_t *sl=screen->scan_line(y)+x1;
    for (x=x1;x<=x2;x++,sl++)
    {
      uint8_t *paddr=(uint8_t *)pal->addr()+(*sl)*3;
      uint8_t r=(*(paddr++))*amount/256;
      uint8_t g=(*(paddr++))*amount/256;
      uint8_t b=(*(paddr++))*amount/256;
      *sl=color_table->lookup_color((r)>>3,(g)>>3,(b)>>3);
    }
  }

struct mask_line
{
  int x,size;
  uint16_t *remap;
} ;



{  
  int x1=10000,x2=0;
  int iw=im->width();  
  uint16_t r,co,off,cc;
  int y=0;
  for (;y<mask_height;y++)
  {
    mask_line *n=p+y;
    uint8_t *sl=screen->scan_line(y+sy)+sx+n->x;
    uint8_t *sl2=im->scan_line(y);
//    uint8_t *sl3=clouds->scan_line(y);
    uint16_t *rem=n->remap;
    if (sx+n->x<x1) x1=sx+n->x;    
    int x=0;
    for (;x<n->size;x++,sl++,rem++)   

  for (int y=0;y<mask->height();y++)
  {
    // find the start of the run..
    uint8_t *sl=mask->scan_line(y);    
    int x=0;
    while (*sl==0) { sl++; x++; }
    p[y].x=x;

    p[y].size=size;

    // now calculate remap for line
    p[y].remap=(uint16_t *)jmalloc(size*2,"mask remap");
    uint16_t *rem=p[y].remap;
    for (x=0;x<size;x++,rem++)
    {
      if (x<=size/2)

  char name[20];
  ico_button *buts[MENU_TICONS];

  int32_t maxx=0,maxy=0;
  int i=0;
  for (;i<MENU_TICONS;i++)
  {

    sprintf(name,"icon%04d.pcx",i*3+2);
    menu_icons[i*3+2]=cash.reg("art/icons.spe",name,SPEC_IMAGE,1);

    int32_t x=WINDOW_FRAME_LEFT+(i%9)*cash.img(menu_icons[0])->width();
    int32_t y=WINDOW_FRAME_TOP+(i/9)*cash.img(menu_icons[0])->height();
    if (x>maxx) maxx=x;
    if (y>maxy) maxy=y;
    buts[i]=new ico_button(x,y,menu_icons_ids[i],

  int eoff=0,coff=0;
  event ev;
//  main_pm->draw(screen,eh,1);
  int32_t x=84,y=60;
  Cell *v=find_symbol("earth_x");
  if (v && DEFINEDP(v)) x=lnumber_value(symbol_value(v));


Lines 11-17 Link Here

(-)abuse-sdl-0.7.0.orig/src/profile.cpp (-1 / +1 lines)
11		11
12	struct prof_info	12	struct prof_info
13	{	13	{
14	ushort otype;	14	uint16_t otype;
15	float total_time;	15	float total_time;
16	};	16	};
17		17




elcontrol::elcontrol(FILE *fp, unsigned char *state_remap)
{
  load(fp,state_remap);
  allow_dir=read_uint16(fp);
}



elevator::elevator(FILE *fp, unsigned char *state_remap)
{
  load(fp,state_remap);  
  dir=read_uint16(fp);  
  speed=read_uint16(fp);  
}

void elevator::save(FILE *fp) 
{ 
  game_object::save(fp); 
  write_uint16(fp,dir);    
  write_uint16(fp,speed);    
}




void sensor::save(FILE *fp) 
{ game_object::save(fp); 
  write_uint16(fp,xrange);
  write_uint16(fp,yrange);
  write_uint16(fp,signal);  

  write_uint8(fp,strlen(aname())+1);
  fwrite(aname(),strlen(aname())+1,1,fp);  
}

sensor::sensor(FILE *fp, unsigned char *state_remap)
{
  load(fp,state_remap);
  xrange=read_uint16(fp);
  yrange=read_uint16(fp);
  signal=read_uint16(fp);  

  char name[200];
  fread(name,read_uint8(fp),1,fp);
  get_activate(name);
}


Lines 58-63 Link Here

(-)abuse-sdl-0.7.0.orig/src/netcfg.cpp (-2 / +5 lines)
58	case RESTART_CLIENT :	58	case RESTART_CLIENT :
59	case RESTART_SINGLE :	59	case RESTART_SINGLE :
60	return 1;	60	return 1;
		61	default:
		62	break;
61	}	63	}
62	return 0;	64	return 0;
63	}	65	}
Lines 69-74 Link Here
69	case RESTART_SERVER : { state=SERVER; } break;	71	case RESTART_SERVER : { state=SERVER; } break;
70	case RESTART_CLIENT : { state=CLIENT; } break;	72	case RESTART_CLIENT : { state=CLIENT; } break;
71	case RESTART_SINGLE : { state=SINGLE_PLAYER; } break;	73	case RESTART_SINGLE : { state=SINGLE_PLAYER; } break;
		74	default: break;
72	}	75	}
73		76
74		77
Lines 249-257 Link Here
249	ns->put_image(screen,x,y);	252	ns->put_image(screen,x,y);
250	JCFont *fnt=eh->font();	253	JCFont *fnt=eh->font();
251		254
252	uchar remap=white_light+30256;	255	uint8_t remap=white_light+30256;
253		256
254	uchar *sl=screen->scan_line(0);	257	uint8_t *sl=screen->scan_line(0);
255	int xx=screen->width()*screen->height();	258	int xx=screen->width()*screen->height();
256	for (;xx;xx--,sl++) sl=remap[sl];	259	for (;xx;xx--,sl++) sl=remap[sl];
257		260




#include "dev.hpp"

light_source *first_light_source=NULL;
uint8_t *white_light,*white_light_initial,*green_light,*trans_table;
short ambient_ramp=0;
short shutdown_lighting_value,shutdown_lighting=0;
extern char disable_autolight;   // defined in dev.hpp

int light_detail=MEDIUM_DETAIL;

int32_t light_to_number(light_source *l)
{
  
  if (!l) return 0;

}


light_source *number_to_light(int32_t x)
{
  if (x==0) return NULL;
  x--;

  mul_div=(1<<16)/(outer_radius-inner_radius)*64;
}

light_source::light_source(char Type, int32_t X, int32_t Y, int32_t Inner_radius, 
			   int32_t Outer_radius, int32_t Xshift,  int32_t Yshift, light_source *Next)
{ 
  type=Type; 
  x=X; y=Y; 

  return t;
}

light_source *add_light_source(char type, int32_t x, int32_t y, 
			       int32_t inner, int32_t outer, int32_t xshift, int32_t yshift)
{
  first_light_source=new light_source(type,x,y,inner,outer,xshift,yshift,first_light_source);
  return first_light_source;



#define TTINTS 9
uint8_t *tints[TTINTS];
uint8_t bright_tint[256];

void calc_tint(uint8_t *tint, int rs, int gs, int bs, int ra, int ga, int ba, palette *pal)
{
  palette npal;
  memset(npal.addr(),0,256);


void calc_light_table(palette *pal)
{
	white_light_initial=(uint8_t *)jmalloc(256*64,"light table");
	white_light=white_light_initial;

//	green_light=(uint8_t *)jmalloc(256*64,"green light");
	int i = 0;
	for( ; i < TTINTS; i++ )
	{
		tints[i] = (uint8_t *)jmalloc( 256, "color tint" );
	}

	char *lightpath;
	lightpath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 9 + 1, "lightpath" );
	sprintf( lightpath, "%slight.tbl", get_save_filename_prefix() );

	bFILE *fp=open_file( lightpath, "rb" );
	int recalc = 0;

	}
	else
	{
		if (fp->read_uint16()!=calc_crc((uint8_t *)pal->addr(),768))
			recalc=1;
		else
		{

			for (i=0;i<TTINTS;i++)
				fp->read(tints[i],256);
			fp->read(bright_tint,256);
//			trans_table=(uint8_t *)jmalloc(256*256,"transparency table");
//			fp.read(trans_table,256*256);
		}
		delete fp;

		int color=0;
		for (;color<256;color++)
		{
			uint8_t r,g,b;
			pal->get(color,r,g,b);
			stat_man->update(color*100/256);
			for (int intensity=63;intensity>=0;intensity--)

    for (color=0;color<256;color++)
    {
      stat_man->update(color*100/256);
      uint8_t r,g,b;
      pal->get(color,b,r,g);
      r=r*3/5; b=b*3/5; g+=7; if (g>255) g=255;


    stat_man->pop(); */

    stat_man->push("tints",NULL);
    uint8_t t[TTINTS*6]={0,0,0,0,0,0, // normal
                   0,0,0,1,0,0,     // red
		   0,0,0,1,1,0,     // yellow
		   0,0,0,1,0,1,     // purple


		   0,0,0,0,0,0   // reverse green  (night vision effect)
		 } ;
    uint8_t *ti=t+6;
    uint8_t *c;
    for (i=0,c=tints[0];i<256;i++,c++) *c=i;  // make the normal tint (maps everthing to itself)
    for (i=0,c=tints[TTINTS-1];i<256;i++,c++)  // reverse green
    {

    }
    stat_man->pop();
/*    fprintf(stderr,"calculating transparency tables (256 total)\n");
    trans_table=(uint8_t *)jmalloc(256*256,"transparency table");

    uint8_t *tp=trans_table;
    for (i=0;i<256;i++)
    {      
      uint8_t r1,g1,b1,r2,g2,b2;
      pal->get(i,r1,g1,b1);
      if ((i%16)==0)
        fprintf(stderr,"%d ",i);

			dprintf( "Unable to open file light.tbl for writing\n" );
		else
		{
			f->write_uint16(calc_crc((uint8_t *)pal->addr(),768));
			f->write(white_light,256*64);
//      f->write(green_light,256*64);
			for (int i=0;i<TTINTS;i++)

  }
}

void add_light(light_patch *&first, int32_t x1, int32_t y1, int32_t x2, int32_t y2, 
			    light_source *who)
{  
  light_patch *next;

}

/* shit
int calc_light_value(light_patch *which, int32_t x, int32_t y)
{
  int lv=0;
  int t=which->total;

    }
    else
    {
      int32_t dx=abs(fn->x-x)<<fn->xshift;
      int32_t dy=abs(fn->y-y)<<fn->yshift;
      int32_t  r2;
      if (dx<dy)
        r2=dx+dy-(dx>>1);
      else r2=dx+dy-(dy>>1);

  
}

light_patch *make_patch_list(int width, int height, int32_t screenx, int32_t screeny)
{
  light_patch *first=new light_patch(0,0,width-1,height-1,NULL);

  for (light_source *f=first_light_source;f;f=f->next)   // determine which lights will have effect
  {
    int32_t x1=f->x1-screenx,y1=f->y1-screeny,
        x2=f->x2-screenx,y2=f->y2-screeny;
    if (x1<0) x1=0;
    if (y1<0) y1=0;

/*
#ifdef __WATCOMC__
extern "C" {
extern int32_t MAP_PUT(int32_t pad, int32_t screen_addr, int32_t remap, int32_t w);
} ;
#else*/

inline void MAP_PUT(uint8_t * screen_addr, uint8_t * remap, int w)
{ 
  register int cx=w;
  register uint8_t * di=screen_addr;
  register uint8_t * si=remap;
  while (cx--) 
  {
    uint8_t x=*((uint8_t *)si+*((uint8_t *)di));
    *((uint8_t *)(di++))=x;
  }
}

inline void MAP_2PUT(uint8_t * in_addr, uint8_t * out_addr, uint8_t * remap, int w)
{ 
  while (w--) 
  {
    uint8_t x=*(((uint8_t *)remap)+(*(uint8_t *)(in_addr++)));
    *((uint8_t *)(out_addr++))=x;
    *((uint8_t *)(out_addr++))=x;
  }
}

/*
#endif

inline void PUT8(int32_t *addr, uint8_t *remap)
{
  register uint32_t in_pixels;
  register uint32_t pixel;
  register uint32_t out_pixels;
  in_pixels=*addr;
  pixel=in_pixels;
  out_pixels=remap[(uint8_t)pixel];
  
  pixel=in_pixels;
  pixel>>=8;
  pixel=remap[(uint8_t)pixel];
  pixel<<=8;
  out_pixels|=pixel;

  pixel=in_pixels;
  pixel>>=16;
  pixel=remap[(uint8_t)pixel];
  pixel<<=16;
  out_pixels|=pixel;

  pixel=in_pixels;
  pixel>>=24;
  pixel=remap[(uint8_t)pixel];
  pixel<<=24;
  out_pixels|=pixel;


  
  pixel=in_pixels;
  pixel>>=8;
  pixel=remap[(uint8_t)pixel];
  pixel<<=8;
  out_pixels|=pixel;

  pixel=in_pixels;
  pixel>>=16;
  pixel=remap[(uint8_t)pixel];
  pixel<<=16;
  out_pixels|=pixel;

  pixel=in_pixels;
  pixel>>=24;
  pixel=remap[(uint8_t)pixel];
  pixel<<=24;
  out_pixels|=pixel;  
  addr[1]=out_pixels;        // send out bus
  
}

inline int32_t MAP_PUT2(int32_t dest_addr, int32_t screen_addr, int32_t remap, int32_t w)
{ while (w--) 
  { 
    *((uint8_t *)(dest_addr))=*((uint8_t *)remap+*((uint8_t *)screen_addr)); 
    screen_addr++; 
    dest_addr++;
  } 


*/

uint16_t min_light_level;
// calculate the light value for this block.  sum up all contritors
inline int calc_light_value(light_patch *lp,   // light patch to look at
			    int32_t sx,           // screen x & y
			    int32_t sy)
{
  int lv=min_light_level,r2,light_count;
  register int dx,dy;           // x and y distances

  for (light_count=lp->total;light_count>0;light_count--)
  {
    light_source *fn=*lon_p;
    register int32_t *dt=&(*lon_p)->type; 
                                     // note we are accessing structure members by bypassing the compiler
                                     // for speed, this may not work on all compilers, but don't
                                     // see why it shouldn't..  all members are int32_t
    
    if (*dt==9)                      // (dt==type),  if light is a Solid rectangle, return it value
      return fn->inner_radius;


/*#ifdef __WATCOMC__

extern "C" void remap_line_asm(uint8_t *screen_line,uint8_t *light_lookup,uint8_t *remap_line,int count);

#else */

void remap_line_asm2(uint8_t *addr,uint8_t *light_lookup,uint8_t *remap_line,int count)
//inline void remap_line_asm2(uint8_t *addr,uint8_t *light_lookup,uint8_t *remap_line,int count)
{
  while (count--)
  {
    uint8_t *off=light_lookup+(((int32_t)*remap_line)<<8); 
    remap_line++;

    *addr=off[*addr]; 

//#endif


inline void put_8line(uint8_t *in_line, uint8_t *out_line, uint8_t *remap, uint8_t *light_lookup, int count)
{
  uint8_t v;
  int x;
  for (x=0;x<count;x++)                        
  {                                            
    uint8_t *off=light_lookup+(((int32_t)*remap)<<8);

    v=off[*(in_line++)];
    *(out_line++)=v;

}


void light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient)
{
  int lx_run=0,ly_run;                     // light block x & y run size in pixels ==  (1<<lx_run)



  int suffix=(cx2-cx1-prefix+1)&7;

  int32_t remap_size=((cx2-cx1+1-prefix-suffix)>>lx_run);

  uint8_t *remap_line=(uint8_t *)jmalloc(remap_size,"light remap line");

  light_patch *f=first;
  uint8_t *screen_line=screen->scan_line(cy1)+cx1;

  for (int y=cy1;y<=cy2;)
  {
    int x,count;
//    while (f->next && f->y2<y) 
//      f=f->next;
    uint8_t *rem=remap_line;

    int todoy=4-((screeny+y)&3);
    if (y+todoy>cy2)

      light_patch *lp=f;
      for (;(lp->y1>y-cy1 || lp->y2<y-cy1 || 
			      lp->x1>suffix_x || lp->x2<suffix_x);lp=lp->next);
      uint8_t * caddr=(uint8_t *)screen_line+cx2-cx1+1-suffix;
      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,suffix_x+screenx,calcy)<<8));
      switch (todoy)
      {
	case 4 :
	{ 
	  MAP_PUT(caddr,r,suffix); caddr+=scr_w;
	}
	case 3 :
	{ MAP_PUT(caddr,r,suffix); caddr+=scr_w;}
	case 2 :
	{ MAP_PUT(caddr,r,suffix); caddr+=scr_w;}
	case 1 :
	{ 
	  MAP_PUT(caddr,r,suffix);
	}
      }
    }

      for (;(lp->y1>y-cy1 || lp->y2<y-cy1 || 
			      lp->x1>prefix_x || lp->x2<prefix_x);lp=lp->next);

      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,prefix_x+screenx,calcy)<<8));
      uint8_t * caddr=(uint8_t *)screen_line;
      switch (todoy)
      {
	case 4 :
	{ 
	  MAP_PUT(caddr,r,prefix); 
	  caddr+=scr_w; 
	}
	case 3 :
	{ MAP_PUT(caddr,r,prefix); caddr+=scr_w; }
	case 2 :
	{ MAP_PUT(caddr,r,prefix); caddr+=scr_w; }
	case 1 :
	{ MAP_PUT(caddr,r,prefix); }
      }
      screen_line+=prefix;
    }

}


void double_light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient,
			 image *out, int32_t out_x, int32_t out_y)
{
  if (sc->width()*2+out_x>out->width() ||
      sc->height()*2+out_y>out->height()) 


  if (ambient==63)      // lights off, just double the pixels
  {
    uint8_t *src=sc->scan_line(0);
    uint8_t *dst=out->scan_line(out_y+cy1*2)+cx1*2+out_x;
    int d_skip=out->width()-sc->width()*2;
    int x,y;
    uint16_t v;
    for (y=sc->height();y;y--)
    {
      for (x=sc->width();x;x--)


  int suffix=(cx2-cx1-prefix+1)&7;

  int32_t remap_size=((cx2-cx1+1-prefix-suffix)>>lx_run);

  uint8_t *remap_line=(uint8_t *)jmalloc(remap_size,"light remap line");

  light_patch *f=first;
  uint8_t *in_line=sc->scan_line(cy1)+cx1;
  uint8_t *out_line=out->scan_line(cy1*2+out_y)+cx1*2+out_x;


  for (int y=cy1;y<=cy2;)

    int x,count;
//    while (f->next && f->y2<y) 
//      f=f->next;
    uint8_t *rem=remap_line;

    int todoy=4-((screeny+y)&3);
    if (y+todoy>cy2)

      light_patch *lp=f;
      for (;(lp->y1>y-cy1 || lp->y2<y-cy1 || 
			      lp->x1>suffix_x || lp->x2<suffix_x);lp=lp->next);
      uint8_t * caddr=(uint8_t *)in_line+cx2-cx1+1-suffix;
      uint8_t * daddr=(uint8_t *)out_line+(cx2-cx1+1-suffix)*2;

      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,suffix_x+screenx,calcy)<<8));
      switch (todoy)
      {
	case 4 : 
	{ 
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 3 :
	{ 
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 2 :
	{ 
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 1 :
	{ 
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,suffix); daddr+=dscr_w; caddr+=scr_w;
	} break;
      }
    }

      for (;(lp->y1>y-cy1 || lp->y2<y-cy1 || 
			      lp->x1>prefix_x || lp->x2<prefix_x);lp=lp->next);

      uint8_t *r=light_lookup+(((int32_t)calc_light_value(lp,prefix_x+screenx,calcy)<<8));
      uint8_t * caddr=(uint8_t *)in_line;
      uint8_t * daddr=(uint8_t *)out_line;
      switch (todoy)
      {
	case 4 :
	{ 
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 3 :
	{ 
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 2 :
	{ 
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w; caddr+=scr_w;
	}
	case 1 :
	{ 
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w;
	  MAP_2PUT(caddr,daddr,r,prefix); daddr+=dscr_w; caddr+=scr_w;
	} break;
      }
      in_line+=prefix;


void add_light_spec(spec_directory *sd, char *level_name)
{
  int32_t size=4+4;  // number of lights and minimum light levels
  for (light_source *f=first_light_source;f;f=f->next)
    size+=6*4+1;
  sd->add_by_hand(new spec_entry(SPEC_LIGHT_LIST,"lights",NULL,size,0));  

  int t=0;
  light_source *f=first_light_source;
  for (;f;f=f->next) t++;
  fp->write_uint32(t);
  fp->write_uint32(min_light_level);
  for (f=first_light_source;f;f=f->next)
  {
    fp->write_uint32(f->x);
    fp->write_uint32(f->y);
    fp->write_uint32(f->xshift);
    fp->write_uint32(f->yshift);
    fp->write_uint32(f->inner_radius);
    fp->write_uint32(f->outer_radius);
    fp->write_uint8(f->type);
  }
}


  if (se)
  {
    fp->seek(se->offset,SEEK_SET);
    int32_t t=fp->read_uint32();
    min_light_level=fp->read_uint32();
    light_source *last=NULL;
    while (t)
    {
      t--;
      int32_t x=fp->read_uint32();
      int32_t y=fp->read_uint32();
      int32_t xshift=fp->read_uint32();
      int32_t yshift=fp->read_uint32();
      int32_t ir=fp->read_uint32();
      int32_t ora=fp->read_uint32();
      int32_t ty=fp->read_uint8();

      light_source *p=new light_source(ty,x,y,ir,ora,xshift,yshift,NULL);
      




#include "crc.hpp"

uint16_t calc_crc(uint8_t *buf, int len)
{
  uint8_t c1=0,c2=0;
  while (len)
  {
    len--;



 
uint32_t crc_file(bFILE *fp)
{
  uint8_t crc1=0,crc2=0,crc3=0,crc4=0;

  int size=0x1000;
  uint8_t *buffer=(uint8_t *)jmalloc(size,"crc_buffer"),*c;
  long l=fp->file_size();
  long cur_pos=fp->tell();
  fp->seek(0,0);




#include "macs.hpp"
#include <stdlib.h>

void pushback(int32_t x1,int32_t y1,int32_t &x2,int32_t &y2,
		     int32_t xp1, int32_t yp1, int32_t xp2, int32_t yp2, int xdir, int ydir, int inside)
{

   // determine if the lines are intersecting before we set back

}


/* int setback_intersect(int32_t x1,int32_t y1,int32_t &x2,int32_t &y2,
		     int32_t xp1, int32_t yp1, int32_t xp2, int32_t yp2)
{
  int32_t mx1,my1,b1,mx2,my2,b2,side1,side2,tx2,ty2;
  my1=(y2-y1);
  if (!my1)                  // is the first line strait across?
  {

        {
          if (abs(mx1)>abs(my1))
          {
            int32_t ae_bd=my1*mx2-mx1*my2;
            CONDITION(ae_bd,"line intersect fuck up");
            tx2=(mx1*mx2*(b2-b1))/ae_bd+xadd;
            ty2=my1*tx2/mx1+b1;
          }
          else
          {
            int32_t db_ea=(my2*mx1-mx2*my1);
            CONDITION(db_ea,"line intersect fuck up");
            ty2=(mx1*b1*my2-my1*mx2*b2)/db_ea+yadd;
            tx2=mx1*(ty2-b1)/my1;

} */


int setback_intersect(int32_t x1,int32_t y1,int32_t &x2,int32_t &y2,
		      int32_t xp1, int32_t yp1, int32_t xp2, int32_t yp2, 
                     int32_t inside)  // which side is inside the polygon? (0 always setback)
{
  // the line equations will be put in the form
  // x(y2-y1)+y(x1-x2)-x1*y2+x2*y1=0
  //     A        B        C  

  int32_t a1,b1,c1,a2,b2,c2,r1,r2;              

  a1=y2-y1;        
  b1=x1-x2;        

    r1=xp1; xp1=xp2; xp2=r1;
  } 

  int32_t xdiff,ydiff;
/*  int32_t xdiff=abs(xp1-xp2),ydiff=yp1-yp2;  
  if (xdiff>=ydiff)                              // increment the endpoints 
    if (xp2<xp1) { xp2--; xp1++; }  				 
    else { xp2++; xp1--; } 

           (xp1>=xp2 && ((r2^inside)<0)) ||
	   inside==0 || r2==0) 
      { 
	int32_t ae=a1*b2,bd=b1*a2;	
	if (ae!=bd)         // co-linear returns 0
	{
	  x2=(b1*c2-b2*c1)/(ae-bd);




#define DIN_NAME "/tmp/.abuse_ndrv_out"   // opposite of driver's in/out
#define DOUT_NAME "/tmp/.abuse_ndrv_in"

#define real2shm(type,ptr) (ptr==NULL ? NULL : ((type *)((uint8_t *)(ptr)-(uint8_t *)base)))
#define shm2real(type,ptr) (ptr==NULL ? NULL : ((type *)((intptr_t)(ptr)+(intptr_t)(base))))

#define real2shm(type,ptr) (ptr==NULL ? NULL : ((type *)((char *)(ptr)-(char *)base)))
#define shm2real(type,ptr) (ptr==NULL ? NULL : ((type *)((long)(ptr)+(long)(base))))

#ifdef __sgi
#define next_process() sginap(0)

    if (write(net_out_fd,filename,cm[1])!=cm[1])  { kill_net(); return -1; }
    if (write(net_out_fd,mode,cm[2])!=cm[2])  { kill_net(); return -1; }

    uint8_t file_type;
    if (read(net_in_fd,&file_type,1)!=1)  { kill_net(); return -1; }    
    if (file_type==NF_OPEN_LOCAL_FILE) 
    {
      uint8_t name_size;
      if (read(net_in_fd,&name_size,1)!=1)  { kill_net(); return -1; }          
      int size=read(net_in_fd,filename,name_size);
      if (size!=name_size)  { kill_net(); return -1; }    

  } else return -2;          // return open local
}

int32_t NF_close(int fd)
{
  if (net_installed)
  {

}


int32_t NF_read(int fd, void *buf, int32_t size)
{
  if (net_installed && size)
  {

    if (write(net_out_fd,&fd,sizeof(fd))!=sizeof(fd)) { kill_net(); return 0; }
    if (write(net_out_fd,&size,sizeof(size))!=sizeof(size)) { kill_net(); return 0; }

    int32_t total_read=0;
    uint16_t t=0xffff;
    while (size && t>=READ_PACKET_SIZE-2)
    {
      if (read(net_in_fd,&t,sizeof(t))!=sizeof(t))  { kill_net(); return 0; }      

}


int32_t NF_filelength(int fd)
{
  if (net_installed)
  {
    char cm=NFCMD_SIZE;
    if (write(net_out_fd,&cm,1)!=1) { kill_net(); return 0; }
    if (write(net_out_fd,&fd,sizeof(fd))!=sizeof(fd)) { kill_net(); return 0; }
    int32_t size;
    if (read(net_in_fd,&size,sizeof(size))!=sizeof(size))  { kill_net(); return 0; }
    return size;
  } else return 0;  
}

int32_t NF_tell(int fd)
{
  if (net_installed)
  {
    char cm=NFCMD_TELL;
    if (write(net_out_fd,&cm,1)!=1) { kill_net(); return 0; }
    if (write(net_out_fd,&fd,sizeof(fd))!=sizeof(fd)) { kill_net(); return 0; }
    int32_t offset;
    if (read(net_in_fd,&offset,sizeof(offset))!=sizeof(offset))  { kill_net(); return 0; }
    return offset;
  } else return 0;  
}

int32_t NF_seek(int fd, int32_t offset)
{
  if (net_installed)
  {

    if (write(net_out_fd,&fd,sizeof(fd))!=sizeof(fd)) { kill_net(); return 0; }
    if (write(net_out_fd,&offset,sizeof(offset))!=sizeof(offset)) { kill_net(); return 0; }

    int32_t offset;
    if (read(net_in_fd,&offset,sizeof(offset))!=sizeof(offset))  { kill_net(); return 0; }
    return offset;
  } else return 0;  

	  base->calc_crcs=0;
	  base->mem_lock=0;

	  uint8_t cmd=NFCMD_CRCS_CALCED;
	  if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return ; }
	} else base->mem_lock=0;
      }

	{
	  base->get_lsf=0;
	  base->mem_lock=0;
	  uint8_t c[2]={NFCMD_PROCESS_LSF,strlen(lsf)+1};
	  if (write(net_out_fd,&c,2)!=2) { kill_net(); return ; }
	  if (write(net_out_fd,lsf,c[1])!=c[1]) { kill_net(); return ; }
	} else base->mem_lock=0;

{
  if (net_installed)
  {
    uint8_t cm[2]={NFCMD_REQUEST_LSF,strlen(name)+1};
    if (write(net_out_fd,cm,2)!=2) { kill_net(); return 0; }
    if (write(net_out_fd,name,cm[1])!=cm[1]) { kill_net(); return 0; }
    uint8_t size;
    if (read(net_in_fd,&size,1)!=1) { kill_net(); return 0; }
    if (size==0) return 0;
    if (read(net_in_fd,filename,size)!=size) { kill_net(); return 0; }

  if (net_installed)
  {
    if (!net_server) return 0;
    uint8_t cm[2]={NFCMD_REQUEST_ENTRY,strlen(net_server)+1};
    if (write(net_out_fd,cm,2)!=2) { kill_net(); return 0; }
    if (write(net_out_fd,net_server,cm[1])!=cm[1]) { kill_net(); return 0; }
    uint16_t cnum;  // client number
    if (read(net_in_fd,&cnum,2)!=2) { kill_net(); return 0; } 
    if (cnum==0) return 0;
    local_client_number=cnum;

{
  if (net_installed)
  {
    uint8_t cmd=NFCMD_RELOAD_START;
    if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return 0; } 
    if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return 0; } 
    return cmd;

{
  if (net_installed)
  {
    uint8_t cmd=NFCMD_RELOAD_END;
    if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return 0; } 
    if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return 0; } 
    return cmd;


      spec_directory sd(fp);  

#if 0
      spec_entry *e=sd.find("Copyright 1995 Crack dot Com, All Rights reserved"); 
      if (!e)
      { 

	the_game->need_refresh();
      }
      else 
#endif
        current_level=new level(&sd,fp,NET_STARTFILE);

      delete fp;     

  if (net_installed)
  {
    if (base->join_list)
      base->packet.write_uint8(SCMD_RELOAD);

    uint8_t cmd=NFCMD_SEND_INPUT;

    if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return ; }    
    if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return ; }    

{
  if (net_installed)
  {
    uint8_t cmd=NFCMD_KILL_SLACKERS;
    if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return ; }    
    if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return ; }        
  }

      if ((((now.tv_sec-start.tv_sec)*100)+(now.tv_usec-start.tv_usec)/10000)>20)
      {
//	fprintf(stderr,"receive timeout %d\n",(((now.tv_sec-start.tv_sec)*100)+(now.tv_usec-start.tv_usec)/10000));
	uint8_t cmd=NFCMD_INPUT_MISSING;
	if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return  0; }    
	if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return 0; }     // block, so net driver can request input
	gettimeofday(&start,NULL);

    { close(net_out_fd); close(net_in_fd); net_installed=0; kill_net(); }
    else
    {
      uint8_t cmd=NFCMD_BLOCK;
      if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return ; }    
      if (base->input_state==INPUT_NET_DEAD)
      { close(net_out_fd); close(net_in_fd); net_installed=0; kill_net(); }

{
  if (net_installed)
  {
    uint8_t cmd=NFCMD_BECOME_SERVER;
    if (write(net_out_fd,&cmd,1)!=1) { kill_net(); return 0; } 
    if (read(net_in_fd,&cmd,1)!=1) { kill_net(); return 0; }     
    




#include "jdir.hpp"
#include "netcfg.hpp"

extern uint8_t major_version;
extern uint8_t minor_version;
extern int has_joystick;

// the following are references to lisp symbols

	    *l_statbar_health_bg_color,

	    *l_statbar_logo_x,*l_statbar_logo_y;
uint8_t chatting_enabled=0; 

extern void scatter_line(int x1, int y1, int x2, int y2, int c, int s);
extern void ascatter_line(int x1, int y1, int x2, int y2, int c1, int c2, int s);

    } break;
    case 24 :
    {
      int32_t x1=lnumber_value(eval(CAR(args)));  args=CDR(args);
      int32_t y1=lnumber_value(eval(CAR(args)));  args=CDR(args);
      int32_t x2=lnumber_value(eval(CAR(args)));  args=CDR(args);
      int32_t y2=lnumber_value(eval(CAR(args)));
      current_level->foreground_intersect(x1,y1,x2,y2);
      void *ret=NULL;
      push_onto_list(new_lisp_number(y2),ret);

    case 36 :
    {
      
      int32_t xm,ym,but;
      xm=lnumber_value(CAR(args)); args=CDR(args);
      ym=lnumber_value(CAR(args)); args=CDR(args);
      but=lnumber_value(CAR(args));

    } break;
    case 49 :
    {
      int32_t x=lnumber_value(eval(CAR(args))); args=CDR(args);
      int32_t y=lnumber_value(eval(CAR(args))); args=CDR(args);

      int32_t rx,ry;
      the_game->mouse_to_game(x,y,rx,ry);
      void *ret=NULL;
      {

    } break;
    case 50 :
    {
      int32_t x=lnumber_value(eval(CAR(args))); args=CDR(args);
      int32_t y=lnumber_value(eval(CAR(args))); args=CDR(args);

      int32_t rx,ry;
      the_game->game_to_mouse(x,y,current_view,rx,ry);
      void *ret=NULL;
      {

    {
    	long x;
    	sscanf(lstring_value(eval(CAR(args))),"%lx",&x);
    	return new_lisp_pointer((void *)(intptr_t)x);
    } break;
    case 64 :
    {

    case 21 : return current_object->fade_dir(); break;
    case 22 :
    {
      int32_t x1,y1,x2,y2,xp1,yp1,xp2,yp2;
      current_level->attacker(current_object)->picture_space(x1,y1,x2,y2);
      current_object->picture_space(xp1,yp1,xp2,yp2);
      if (xp1>x2 || xp2<x1 || yp1>y2 || yp2<y1) return 0;

    case 30 : return current_object->x; break;
    case 31 : return current_object->y; break;
    case 32 : 
    { int32_t v=lnumber_value(CAR(args));
      current_object->x=v;
//      current_object->last_x=v;
      return 1; 
    } break;
    case 33 : 
    { int32_t v=lnumber_value(CAR(args));
      current_object->y=v;
//      current_object->last_y=v;
      return 1; 


    case 37 : 
    {
      int32_t s=lnumber_value(CAR(args));
      current_object->set_state((character_state)s); 
      return (s==current_object->state);
    } break;

    case 91 : current_object->add_object((game_object *)lpointer_value(CAR(args))); return 1; break;
    case 92 : 
    {
      int32_t cx1,x1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy1,y1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cx2,x2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy2,y2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t c=lnumber_value(CAR(args));
      the_game->game_to_mouse(x1,y1,current_view,cx1,cy1);
      the_game->game_to_mouse(x2,y2,current_view,cx2,cy2);
      screen->line(cx1,cy1,cx2,cy2,c);


    case 104 :  
    { light_source *l=(light_source *)lpointer_value(CAR(args));
      int32_t x=lnumber_value(CAR(CDR(args)));
      if (x>=1)
        l->inner_radius=x;
      l->calc_range();

    } break;
    case 105 :  
    { light_source *l=(light_source *)lpointer_value(CAR(args));
      int32_t x=lnumber_value(CAR(CDR(args)));
      if (x>l->inner_radius)
        l->outer_radius=x;
      l->calc_range();

	int vol=lnumber_value(lcar(a)); a=CDR(a);
	if (a)
	{
	  int32_t x=lnumber_value(lcar(a)); a=CDR(a);
	  if (!a)
	  {
	    lprint(args);
	    lbreak("expecting y after x in play_sound\n");
	    exit(1);
	  }
	  int32_t y=lnumber_value(lcar(a));
	  the_game->play_sound(id,vol,x,y);
	} else cash.sfx(id)->play(vol);        
      }

    case 137 : return defun_pseq(args); break;
    case 138 :
    { int id=lnumber_value(CAR(args)); args=CDR(args);
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args)); args=CDR(args);
      int32_t dir=lnumber_value(CAR(args));
      add_panim(id,x,y,dir);
    } break;
    case 142 :
    {
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      if (x<0 || x>=total_weapons)
      { 
	lbreak("weapon out of range (%d)\n",x);

    } break;
    case 143 :
    {
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args)); args=CDR(args);
      int32_t r=lnumber_value(CAR(args)); args=CDR(args);
      int32_t m=lnumber_value(CAR(args)); args=CDR(args);
      game_object *o=(game_object *)lpointer_value(CAR(args)); args=CDR(args);
      int32_t mp=lnumber_value(CAR(args));
      current_level->hurt_radius(x,y,r,m,current_object,o,mp);
    } break;


      if (!v) dprintf("Can't add weapons for non-players\n");
      else
      {
	int32_t x=lnumber_value(CAR(args)); args=CDR(args);
	int32_t y=lnumber_value(CAR(args)); args=CDR(args);
	if (x<0 || x>=total_weapons)
	{ lbreak("weapon out of range (%d)\n",x); exit(0); }
	v->add_ammo(x,y);

    case 153 :
    {
      game_object *o=(game_object *)lpointer_value(CAR(args));
      int32_t x=o->x-current_object->x,
        y=-(o->y-o->picture()->height()/2-(current_object->y-(current_object->picture()->height()/2)));
      return lisp_atan2(y,x);
    } break;
    case 154 :
    {
      int32_t ang=lnumber_value(CAR(args)); args=CDR(args);
      int32_t mag=lfixed_point_value(CAR(args));
      int32_t xvel=(lisp_cos(ang)>>8)*(mag>>8);
      current_object->set_xvel(xvel>>16);
      current_object->set_fxvel((xvel&0xffff)>>8);
      int32_t yvel=-(lisp_sin(ang)>>8)*(mag>>8);
      current_object->set_yvel(yvel>>16);
      current_object->set_fyvel((yvel&0xffff)>>8);      
    } break;

    {
      int tframes=current_object->total_frames(),f;

      int32_t ang1=lnumber_value(CAR(args)); args=CDR(args);      
      if (ang1<0) ang1=(ang1%360)+360; 
      else if (ang1>=360) ang1=ang1%360;
      int32_t ang2=lnumber_value(CAR(args)); args=CDR(args);      
      if (ang2<0) ang2=(ang2%360)+360; 
      else if (ang2>=360) ang2=ang2%360;

      int32_t ang=(lnumber_value(CAR(args))+90/tframes)%360;
      if (ang1>ang2)
      {
        if (ang<ang1 && ang>ang2) 	

    case 168 : if (current_object->morph_status()) return 1; else return 0; break;
    case 169 :
    {
      int32_t am=lnumber_value(CAR(args)); args=CDR(args);
      game_object *from=(game_object *)lpointer_value(CAR(args)); args=CDR(args);
      int32_t hitx=lnumber_value(CAR(args)); args=CDR(args);      
      int32_t hity=lnumber_value(CAR(args)); args=CDR(args);      
      int32_t px=lnumber_value(CAR(args)); args=CDR(args);      
      int32_t py=lnumber_value(CAR(args)); args=CDR(args);
      current_object->damage_fun(am,from,hitx,hity,px,py);
    } break;
    case 170 : return current_object->gravity(); break;

    case 179 : 
    {
      view *v=lget_view(CAR(args),"set_ambient_light");       args=CDR(args);
      int32_t x=lnumber_value(CAR(args));
      if (x>=0 && x<64) v->ambient=x;
    } break;
    case 180 : return lget_view(CAR(args),"ambient_light")->ambient; break;

    } break;
    case 192 : 
    {     
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args)); args=CDR(args);
      int32_t type=lnumber_value(CAR(args));
      if (x<0 || y<0 || x>=current_level->foreground_width() || y>=current_level->foreground_width())
        lbreak("%d %d is out of range of fg map",x,y);
      else	

    } break;
    case 193 :
    { 
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args));
      if (x<0 || y<0 || x>=current_level->foreground_width() || y>=current_level->foreground_width())
        lbreak("%d %d is out of range of fg map",x,y);
      else return current_level->get_fg(x,y);
    } break;
    case 194 : 
    {     
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args)); args=CDR(args);
      int32_t type=lnumber_value(CAR(args));
      if (x<0 || y<0 || x>=current_level->background_width() || y>=current_level->background_width())
        lbreak("%d %d is out of range of fg map",x,y);
      else	

    } break;
    case 195 :
    { 
      int32_t x=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y=lnumber_value(CAR(args));
      if (x<0 || y<0 || x>=current_level->background_width() || y>=current_level->background_width())
        lbreak("%d %d is out of range of fg map",x,y);
      else return current_level->get_bg(x,y);

    } break;
    case 200 :
    {
      int32_t xv=lnumber_value(CAR(args));  args=CDR(args);
      int32_t yv=lnumber_value(CAR(args));  args=CDR(args);
      int top=2;
      if (args)
        if (!CAR(args)) top=0;
        
      int32_t oxv=xv,oyv=yv;
      current_object->try_move(current_object->x,current_object->y,xv,yv,1|top);
      current_object->x+=xv;
      current_object->y+=yv;

    } break;
    case 201 :
    {
      int32_t x=lnumber_value(CAR(args));
      return figures[current_object->otype]->get_sequence((character_state)x)->length();
    } break;
    case 202 :
    { 
      int32_t x1=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y1=lnumber_value(CAR(args)); args=CDR(args);
      int32_t x2=lnumber_value(CAR(args)); args=CDR(args);
      int32_t y2=lnumber_value(CAR(args)); args=CDR(args);
      void *block_all=CAR(args);
      int32_t nx2=x2,ny2=y2;
      current_level->foreground_intersect(x1,y1,x2,y2);
      if (x2!=nx2 || y2!=ny2) return 0;
      

    } break;
    case 206 :
    {
      int32_t x=lnumber_value(CAR(args));
      if (x<current_object->total_frames())
        current_object->current_frame=x;
      else      

    } break;
    case 216 :
    {
      int32_t x1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t y1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t id=lnumber_value(CAR(args));
      cash.img(id)->put_image(screen,x1,y1,1);
    } break;
    case 217 :

    case 228 :
    {
      palette *p=pal->copy();
      uint8_t *addr=(uint8_t *)p->addr();
      int r,g,b;
      int ra=lnumber_value(CAR(args)); args=CDR(args);
      int ga=lnumber_value(CAR(args)); args=CDR(args);
      int ba=lnumber_value(CAR(args));
      for (int i=0;i<256;i++)
      {
	r=(int)*addr+ra; if (r>255) r=255; else if (r<0) r=0; *addr=(uint8_t)r; addr++;
	g=(int)*addr+ga; if (g>255) g=255; else if (g<0) g=0; *addr=(uint8_t)g; addr++;
	b=(int)*addr+ba; if (b>255) b=255; else if (b<0) b=0; *addr=(uint8_t)b; addr++;
      }
      p->load();
      delete p;

      if (!v) lbreak("object has no view : local_player");
      else 
      {
	int32_t x=lnumber_value(CAR(args));
	if (x<0 || x>=total_weapons)
	{ lbreak("weapon out of range (%d)\n",x); exit(0); }
	v->current_weapon=x;	


    case 234 :
    {
      int32_t cx1,x1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy1,y1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cx2,x2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy2,y2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t c=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t s=lnumber_value(CAR(args));
      the_game->game_to_mouse(x1,y1,current_view,cx1,cy1);
      the_game->game_to_mouse(x2,y2,current_view,cx2,cy2);
      scatter_line(cx1,cy1,cx2,cy2,c,s);

    } break;
    case 244 :
    {
      int32_t cx1,x1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy1,y1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cx2,x2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy2,y2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t c1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t c2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t s=lnumber_value(CAR(args));
      the_game->game_to_mouse(x1,y1,current_view,cx1,cy1);
      the_game->game_to_mouse(x2,y2,current_view,cx2,cy2);
      ascatter_line(cx1,cy1,cx2,cy2,c1,c2,s);

    } break;
    case 247 :
    {
      int32_t cx1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy1=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cx2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t cy2=lnumber_value(CAR(args)); args=lcdr(args);
      int32_t c1=lnumber_value(CAR(args)); args=lcdr(args);      
      screen->bar(cx1,cy1,cx2,cy2,c1);
    } break;
    case 248 :

    case 277 :
    {
      JCFont *fnt=(JCFont *)lpointer_value(CAR(args)); args=CDR(args);
      int32_t x=lnumber_value(CAR(args));       args=CDR(args);
      int32_t y=lnumber_value(CAR(args));       args=CDR(args);
      char *st=lstring_value(CAR(args));     args=CDR(args);
      int color=-1;
      if (args)

    } break;
    case 282 :
    {
      int32_t x1=lnumber_value(CAR(args));   args=CDR(args);
      int32_t y1=lnumber_value(CAR(args));   args=CDR(args);
      int32_t x2=lnumber_value(CAR(args));   args=CDR(args);
      int32_t y2=lnumber_value(CAR(args));   args=CDR(args);
      int32_t c=lnumber_value(CAR(args));
      screen->bar(x1,y1,x2,y2,c);
    } break;
    case 283 :
    {
      int32_t x1=lnumber_value(CAR(args));   args=CDR(args);
      int32_t y1=lnumber_value(CAR(args));   args=CDR(args);
      int32_t x2=lnumber_value(CAR(args));   args=CDR(args);
      int32_t y2=lnumber_value(CAR(args));   args=CDR(args);
      int32_t c=lnumber_value(CAR(args));
      screen->rectangle(x1,y1,x2,y2,c);
    } break;
    case 284 :




class collide_patch
{
  public :
  int32_t total,x1,y1,x2,y2;
  game_object **touch;  
  collide_patch *next;
  collide_patch(int32_t X1, int32_t Y1, int32_t X2, int32_t Y2, collide_patch *Next)
  { 
    x1=X1; y1=Y1; x2=X2; y2=Y2;
    next=Next;
    total=0;
    touch=NULL;
  }
  void add_collide(int32_t X1, int32_t Y1, int32_t X2, int32_t Y2, game_object *who);
  collide_patch *copy(collide_patch *Next);
  ~collide_patch() { if (total) jfree(touch); }
} ;

}


void add_collide(collide_patch *&first, int32_t x1, int32_t y1, int32_t x2, int32_t y2, 
			    game_object *who)
{
  collide_patch *next;

void level::check_collisions()
{
  game_object *target,*rec,*subject;
  int32_t sx1,sy1,sx2,sy2,tx1,ty1,tx2,ty2,hitx=0,hity=0,t_centerx;

  for (int l=0;l<attack_total;l++)
  {

	  {
	    for (t_dat=t_damage->data,j=(int)t_damage->tot-1;j>0 && !rec;j--)
	    {
	      int32_t x1,y1,x2,y2,          // define the two line segments to check
	      xp1,yp1,xp2,yp2;

	      xp1=target->x+target->tx(*t_dat);  t_dat++;	      


	      // ok, now we know which line segemnts to check for intersection
	      // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
	      int32_t _x2=x2,_y2=y2;	      
	      setback_intersect(x1, y1, x2, y2, xp1, yp1, xp2, yp2,0);



Lines 7-13 Link Here

(-)abuse-sdl-0.7.0.orig/src/morpher.cpp (-1 / +1 lines)
7	{	7	{
8	if (fleft)	8	if (fleft)
9	{	9	{
10	long rx,ry;	10	int32_t rx,ry;
11	the_game->game_to_mouse(who->x-(cx>>16),who->y-(cy>>16),v,rx,ry);	11	the_game->game_to_mouse(who->x-(cx>>16),who->y-(cy>>16),v,rx,ry);
12	mor->show(screen,rx,ry,color_table,pal,1000);	12	mor->show(screen,rx,ry,color_table,pal,1000);
13	cx+=dcx;	13	cx+=dcx;

Lines 179-185 Link Here

(-)abuse-sdl-0.7.0.orig/src/gamma.cpp (-2 / +2 lines)
179	FILE *fp;	179	FILE *fp;
180		180
181	gammapath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 10, "gammapath" );	181	gammapath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 10, "gammapath" );
182	sprintf( gammapath, "%sgamma.lsp\0", get_save_filename_prefix() );	182	sprintf( gammapath, "%sgamma.lsp", get_save_filename_prefix() );
183	fp = open_FILE( gammapath, "wb" );	183	fp = open_FILE( gammapath, "wb" );
184	if( fp )	184	if( fp )
185	{	185	{
Lines 219-225 Link Here
219	pal = new palette;	219	pal = new palette;
220	for( int i = 0; i < 256; i++ )	220	for( int i = 0; i < 256; i++ )
221	{	221	{
222	uchar oldr, oldg, oldb;	222	uint8_t oldr, oldg, oldb;
223	old_pal->get( i, oldr, oldg, oldb );	223	old_pal->get( i, oldr, oldg, oldb );
224	pal->set( i, (int)( pow( oldr / 255.0, gamma ) * 255 ),	224	pal->set( i, (int)( pow( oldr / 255.0, gamma ) * 255 ),
225	(int)( pow( oldg / 255.0, gamma ) * 255 ),	225	(int)( pow( oldg / 255.0, gamma ) * 255 ),





void *ant_ai();

int can_see(game_object *o, int32_t x1, int32_t y1, int32_t x2, int32_t y2)
{
  int32_t nx2=x2,ny2=y2;
  current_level->foreground_intersect(x1,y1,x2,y2);
  if (x2!=nx2 || y2!=ny2) return 0;



static void fire_at_player(game_object *o, game_object *b)
{
  int32_t firex=o->x+(o->direction>0?15:-15),firey=o->y-15,
          playerx=b->x+b->xvel()*8,playery=b->y-15+b->yvel()*2;
  if (can_see(o,o->x,o->y,firex,firey) && can_see(o,firex,firey,playerx,playery))
  {
    int angle=lisp_atan2(firey-playery,playerx-firex);

    {
      if (!o->next_picture())
      {
	int32_t xv=0,yv=2;
	o->try_move(o->x,o->y,xv,yv,1);
	if (yv!=0)
	{

	    o->set_aistate(ANT_JUMP);
	  else 
	  {
	    int32_t xm=o->direction>0 ? get_ability(o->otype,run_top_speed) : -get_ability(o->otype,run_top_speed);
	    int32_t ym=0,new_xm=xm;
	    if (o->state!=running) o->set_state(running);

	    o->try_move(o->x,o->y,new_xm,ym,3);

      o->set_state((character_state)S_jump_up);
//      o->set_yvel(o->yvel()+1);
      o->set_xacel(0);
      int32_t xv=0,yv=o->yvel();
      o->y-=31;
      o->try_move(o->x,o->y,xv,yv,1);
      o->y+=31+yv;





extern int total_objects;

uint8_t *bad_guy_array=NULL;  // list flaging each character saying they are a bad bug or not
                              // mainly used by the rocket to find targets

int32_t S_fall_start,S_falling,S_landing,S_pounce_wait,
     S_turn_around,S_fire_wait,S_ceil_fire,S_top_walk,
     S_blown_back_dead,S_jump_up,S_hiding,S_weapon_fire,
     S_hanging,S_blocking,S_rotate,S_climbing,S_climb_off,


int compile_error=0;

int32_t c_state(char *name)
{
  void *sym=find_symbol(name);
  if (sym)

  if (b && DEFINEDP(symbol_value(b)))
  {
    b=symbol_value(b);
    bad_guy_array=(uint8_t *)jmalloc(total_objects,"bad_guy_array");
    memset(bad_guy_array,0,total_objects);
    while (b)
    {
      int32_t x=lnumber_value(CAR(b));
      if (x>=0 && x<total_objects)
        bad_guy_array[x]=1;
      else { lbreak("objetc number out of range %d\n",x); }




struct mask_line
{
  int x,size;
  uint16_t *remap;
  uint8_t *light;
} ;


int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uint8_t *cmap, char color);

mask_line *make_mask_lines(image *mask, int map_width)
{

  for (int y=0;y<mask->height();y++)
  {
    // find the start of the run..
    uint8_t *sl=mask->scan_line(y);    
    int x=0;
    while (*sl==0) { sl++; x++; }
    p[y].x=x;

   
    // find the length of the run
    int size=0; 
    uint8_t *sl_start=sl;
    while (*sl!=0 && x<mask->width()) { sl++; x++; size++; }
    p[y].size=size;

    // now calculate remap for line
    p[y].remap=(uint16_t *)jmalloc(size*2,"mask remap");
    p[y].light=(uint8_t *)jmalloc(size,"mask light");
    uint16_t *rem=p[y].remap;
    uint8_t *lrem=p[y].light;
    for (x=0;x<size;x++,rem++)
    {
      *(lrem++)=*(sl_start++);

}


void scan_map(image *screen, int sx, int sy, image *im1, image *im2, int fade256, int32_t *paddr, mask_line *p, int mask_height, 
	      int xoff, int coff)
{  
  int x1=10000,x2=0;
  int iw=im1->width();  
  uint16_t r,off;
  int y=0;
  uint8_t *l;

  for (;y<mask_height;y++)
  {
    mask_line *n=p+y;
    uint8_t *sl=screen->scan_line(y+sy)+sx+n->x;
    uint8_t *sl2=im1->scan_line(y);
    uint8_t *sl3=im2->scan_line(y);
    l=n->light;
    uint16_t *rem=n->remap;
    if (sx+n->x<x1) x1=sx+n->x;    
    int x=0;
    for (;x<n->size;x++,sl++,rem++,l++)   

      off=(r+xoff);
      if (off>=iw) off-=iw;

      int32_t p1=*(paddr+sl2[off]);
      int32_t p2=*(paddr+sl3[off]);

      int r1=p1>>16,g1=(p1>>8)&0xff,b1=p1&0xff;
      int r2=p2>>16,g2=(p2>>8)&0xff,b2=p2&0xff;

          g3=g1+(g2-g1)*fade256/256,
          b3=b1+(b2-b1)*fade256/256;

      uint8_t c=color_table->lookup_color(r3>>3,g3>>3,b3>>3);
				
      *sl=*(white_light+((*l)/2+28+jrand()%4)*256+c); 
      


class ex_char { 
  public :
  uint8_t frame,char_num;
  int x,y;
  ex_char *next; 
  ex_char (int X, int Y, int Frame, int Char_num, ex_char *Next) { x=X; y=Y; frame=Frame; char_num=Char_num; next=Next; }

	    pal->find_closest(200,200,200),
	    pal->find_closest(100,100,100),
	    pal->find_closest(64,64,64)};
  uint16_t sinfo[800*3],*si;

  for (si=sinfo,i=0;i<800;i++)
  {

    *(si++)=c[jrand()%4];     
    screen->putpixel(si[-3],si[-2],si[-1]);
  }
  int32_t paddr[256];
  if (old_pal)
  {
    for (i=0;i<256;i++) 

  } while (ev.type!=EV_KEY && ev.type!=EV_MOUSE_BUTTON);


  uint8_t cmap[32];
  for (i=0;i<32;i++)
    cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);


			   lstring_value(to_be));
  fade_in(NULL,32);

  uint8_t cmap[32];
  int i;
  for (i=0;i<32;i++)
    cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);


  fade_in(im,32);

  uint8_t cmap[32];
  int i;
  for (i=0;i<32;i++)
    cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);




    }

    int remote_file_num=net_crcs->get_filenumber(local_filename);
    uint32_t remote_crc=net_crcs->get_crc(remote_file_num,fail2);
    if (!fail2)
    {   
      int local_file_num=crc_man.get_filenumber(local_filename);
      uint32_t local_crc=crc_man.get_crc(local_file_num,fail1);
      if (fail1)
      {
	bFILE *fp=new jFILE(local_filename,"rb");      

  else if (nfs_fd>=0)
  {
    long a=NF_read(nfs_fd,buf,count);
    if (a>(long)count)
    { 
      fprintf(stderr,"ooch read too much\n");
    }




#include "transp.hpp"


void transp_put(image *im, image *screen, uint8_t *table, int x, int y)
{
  short cx1,cy1,cx2,cy2;
  screen->get_clip(cx1,cy1,cx2,cy2);

  int ye=ys+yl;
  int xe=xs+xl;

  uint8_t *isl=im->scan_line(ys)+xs;
  uint8_t *ssl=screen->scan_line(y)+x;
  int iw=im->width(),sw=screen->width();

  for (int iy=ys;iy<ye;iy++,y++,isl+=iw,ssl+=sw)
  {
    uint8_t *s=ssl,*i=isl;
    for (int ix=xs;ix<xe;ix++,s++,i++)
    {
      if (*i)



/*
void transp_put(image *im, image *screen, uint8_t *table, int x, int y)
{
  short cx1,cy1,cx2,cy2;
  screen->get_clip(cx1,cy1,cx2,cy2);

  int ye=ys+yl;
  int xe=xs+xl;

  uint8_t *isl=im->scan_line(ys)+xs;
  uint8_t *ssl=screen->scan_line(y)+x;
  int iw=im->width(),sw=screen->width();

  for (int iy=ys;iy<ye;iy++,y++,isl+=iw,ssl+=sw)
  {
    uint8_t *s=ssl,*i=isl;
    for (int ix=xs;ix<xe;ix++,s++,i++)
      *s=table[((*i)<<8)|(*s)];
  }        




  return ret;
}

lisp_1d_array *new_lisp_1d_array(int size, void *rest)
{
  p_ref r11(rest);
  long s=sizeof(lisp_1d_array)+size*sizeof(void *);

  return ((lisp_1d_array *)p);
}

lisp_fixed_point *new_lisp_fixed_point(int32_t x)
{
  lisp_fixed_point *p=(lisp_fixed_point *)lmalloc(sizeof(lisp_fixed_point),current_space);
  p->type=L_FIXED_POINT;

}


lisp_object_var *new_lisp_object_var(int16_t number)
{
  lisp_object_var *p=(lisp_object_var *)lmalloc(sizeof(lisp_object_var),current_space);
  p->type=L_OBJECT_VAR;

  return p;
}

struct lisp_character *new_lisp_character(uint16_t ch)
{
  lisp_character *c=(lisp_character *)lmalloc(sizeof(lisp_character),current_space);
  c->type=L_CHARACTER;


struct lisp_string *new_lisp_string(char *string)
{
  int size=sizeof(lisp_string)+strlen(string)+1;
  if (size<8) size=8;

  lisp_string *s=(lisp_string *)lmalloc(size,current_space);


struct lisp_string *new_lisp_string(char *string, int length)
{
  int size=sizeof(lisp_string)+length+1;
  if (size<8) size=8;
  lisp_string *s=(lisp_string *)lmalloc(size,current_space);
  s->type=L_STRING;

  return s;
}

struct lisp_string *new_lisp_string(int length)
{
  int size=sizeof(lisp_string)+length;
  if (size<8) size=8;
  lisp_string *s=(lisp_string *)lmalloc(size,current_space);
  s->type=L_STRING;

  return lu;
}
#else
lisp_user_function *new_lisp_user_function(intptr_t arg_list, intptr_t block_list)
{
  int sp=current_space;
  if (current_space!=GC_SPACE)

  return ((lisp_pointer *)lpointer)->addr;  
}

int32_t lnumber_value(void *lnumber)
{
  switch (item_type(lnumber))
  {

    case L_FIXED_POINT :
      return (((lisp_fixed_point *)lnumber)->x)>>16;
    case L_STRING :
      return (uint8_t)*lstring_value(lnumber);
    case L_CHARACTER :
      return lcharacter_value(lnumber);
    default :

  else return NULL;
}

uint16_t lcharacter_value(void *c)
{
#ifdef TYPE_CHECKING
  if (item_type(c)!=L_CHARACTER)

  }
  if (l1!=0)
  {
    void *first=NULL,*last=NULL,*cur=NULL,*tmp;
    p_ref r1(first),r2(last),r3(cur);
    while (list1)
    {

      last=cur;
	      
      cons_cell *cell=new_cons_cell();	      
      tmp=lcar(list1);
      ((cons_cell *)cell)->car=tmp;
      tmp=lcar(list2);
      ((cons_cell *)cell)->cdr=tmp;
      ((cons_cell *)cur)->car=cell;

      list1=((cons_cell *)list1)->cdr;

  return s;
}

lisp_symbol *add_c_object(void *symbol, int16_t number)
{
  need_perm_space("add_c_object");
  lisp_symbol *s=(lisp_symbol *)symbol;

    return true_symbol;
  else if (n[0]=='\'')                    // short hand for quote function
  {
    void *cs=new_cons_cell(),*c2=NULL,*tmp;
    p_ref r1(cs),r2(c2);

    ((cons_cell *)cs)->car=quote_symbol;
    c2=new_cons_cell();
    tmp=compile(s);
    ((cons_cell *)c2)->car=tmp;
    ((cons_cell *)c2)->cdr=NULL;
    ((cons_cell *)cs)->cdr=c2;
    ret=cs;
  }
  else if (n[0]=='`')                    // short hand for backquote function
  {
    void *cs=new_cons_cell(),*c2=NULL,*tmp;
    p_ref r1(cs),r2(c2);

    ((cons_cell *)cs)->car=backquote_symbol;
    c2=new_cons_cell();
    tmp=compile(s);
    ((cons_cell *)c2)->car=tmp;
    ((cons_cell *)c2)->cdr=NULL;
    ((cons_cell *)cs)->cdr=c2;
    ret=cs;
  }  else if (n[0]==',')              // short hand for comma function
  {
    void *cs=new_cons_cell(),*c2=NULL,*tmp;
    p_ref r1(cs),r2(c2);

    ((cons_cell *)cs)->car=comma_symbol;
    c2=new_cons_cell();
    tmp=compile(s);
    ((cons_cell *)c2)->car=tmp;
    ((cons_cell *)c2)->cdr=NULL;
    ((cons_cell *)cs)->cdr=c2;
    ret=cs;

				    lerror(s,"token '.' not allowed here\n");	      
				  else 
				  {
				    void *tmp;
				    read_ltoken(s,n);              // skip the '.'
				    tmp=compile(s);
				    ((cons_cell *)last)->cdr=tmp;          // link the last cdr to 
				    last=NULL;
				  }
				} else if (!last && first)
				  lerror(s,"illegal end of dotted list\n");
				else
				{		 
				  void *tmp;
				  cur=new_cons_cell();
				  p_ref r1(cur);
				  if (!first) first=cur;
				  tmp=compile(s);	
				  ((cons_cell *)cur)->car=tmp;
				  if (last)
				    ((cons_cell *)last)->cdr=cur;
				  last=cur;

    }
    else if (n[1]==0)                           // short hand for function
    {
      void *cs=new_cons_cell(),*c2=NULL,*tmp;
      p_ref r4(cs),r5(c2);
      tmp=make_find_symbol("function");
      ((cons_cell *)cs)->car=tmp;
      c2=new_cons_cell();
      tmp=compile(s);
      ((cons_cell *)c2)->car=tmp;
      ((cons_cell *)cs)->cdr=c2;
      ret=cs;
    }

      lbreak("Unknown #\\ notation : %s\n",n);
      exit(0);
    }
  } else {
    ret = make_find_symbol(n);
  } 
  return ret;
}


      {
	s++;
	if (*s=='n')
	  current_print_file->write_uint8('\n');
	else if (*s=='r')
	  current_print_file->write_uint8('\r');
	else if (*s=='t')
	  current_print_file->write_uint8('\t');
	else if (*s=='\\')
	  current_print_file->write_uint8('\\');
      }
      else*/
        current_print_file->write_uint8(*s);
    }
  }
  else

      {
				if (current_print_file)
				{
				  uint8_t ch=((lisp_character *)i)->ch;
				  current_print_file->write(&ch,1);
				} else
				{
				  uint16_t ch=((lisp_character *)i)->ch;
				  dprintf("#\\");
				  switch (ch)
				  {

    } break;
    case L_C_FUNCTION :
    {
      void *first=NULL,*cur=NULL,*tmp;
      p_ref r1(first),r2(cur);
      while (arg_list)
      {
				if (first) {
				  tmp=new_cons_cell();
				  ((cons_cell *)cur)->cdr=tmp;
				  cur=tmp;
				} else
				  cur=first=new_cons_cell();
			
				void *val=eval(CAR(arg_list));

    } break;
    case L_C_BOOL :
    {
      void *first=NULL,*cur=NULL,*tmp;
      p_ref r1(first),r2(cur);
      while (arg_list)
      {
				if (first) {
				  tmp=new_cons_cell();
				  ((cons_cell *)cur)->cdr=tmp;
				  cur=tmp;
				} else
				  cur=first=new_cons_cell();
			
				void *val=eval(CAR(arg_list));

      else ret=NULL;
    } break;
    default :
      fprintf(stderr,"not a fun, shouldn't happen\n");
  }

#ifdef L_PROFILE

    return eval(CAR(CDR(args)));
  else
  {
    void *first=NULL,*last=NULL,*cur=NULL,*tmp;
    p_ref ref1(first),ref2(last),ref3(cur),ref4(args);
    while (args)
    {

      {
	if (CAR(args)==comma_symbol)               // dot list with a comma?
	{
	  tmp=eval(CAR(CDR(args)));
	  ((cons_cell *)last)->cdr=tmp;
	  args=NULL;
	}
	else

	  else 
            first=cur;
	  last=cur;
          tmp=backquote_eval(CAR(args));
          ((cons_cell *)cur)->car=tmp;
 	  args=CDR(args);
	}
      } else
      {
	tmp=backquote_eval(args);
	((cons_cell *)last)->cdr=tmp;
	args=NULL;
      }



      while (var_list)
      {
	void *var_name=CAR(CAR(var_list)),*tmp;
#ifdef TYPE_CHECKING
	if (item_type(var_name)!=L_SYMBOL)
	{

#endif

	l_user_stack.push(((lisp_symbol *)var_name)->value);
	tmp=eval(CAR(CDR(CAR(var_list))));	
	((lisp_symbol *)var_name)->value=tmp;
	var_list=CDR(var_list);
      }


      void *block_list=CDR(CDR(arg_list));

#ifndef NO_LIBS
      intptr_t a=cash.reg_lisp_block(lcar(lcdr(arg_list)));
      intptr_t b=cash.reg_lisp_block(block_list);
      lisp_user_function *ufun=new_lisp_user_function(a,b);
#else
      lisp_user_function *ufun=new_lisp_user_function(lcar(lcdr(arg_list)),block_list);

				if( strcmp( st, "gamma.lsp" ) == 0 )
				{
					char *gammapath;
					gammapath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 9 + 1, "gammapath" );
					sprintf( gammapath, "%sgamma.lsp", get_save_filename_prefix() );
					fp = new jFILE( gammapath, "rb" );
					jfree( gammapath );
				}

      else return NULL; } break;
    case 85 :  // num2str
    {
      char str[20];
      sprintf(str,"%ld",(long int)lnumber_value(eval(CAR(arg_list))));
      ret=new_lisp_string(str);
    } break;
    case 86 : // nconc

  p_ref r19(arg_list);
  for (;f_arg;f_arg=CDR(f_arg))
  {
    lisp_symbol *s = (lisp_symbol *)CAR(f_arg);
    l_user_stack.push(s->value);
  }

  // open block so that local vars aren't saved on the stack




}


extern uint8_t bright_tint[256];

void view::add_ammo(int weapon_type, int total)
{  

}


int32_t view::xoff()
{
  if (focus)
  {

  } else return pan_x;
}

int32_t view::interpolated_xoff()
{
  if (focus)
  {

}


int32_t view::yoff()
{
  if (focus)
  {

}


int32_t view::interpolated_yoff()
{
  if (focus)
  {


  if (total_weapons)
  {
    weapons=(int32_t *)jmalloc(total_weapons*sizeof(int32_t),"weapon array");
    last_weapons=(int32_t *)jmalloc(total_weapons*sizeof(int32_t),"last weapon array");
    memset(weapons,0xff,total_weapons*sizeof(int32_t));   // set all to -1
    memset(last_weapons,0xff,total_weapons*sizeof(int32_t));   // set all to -1  
  }

  if (total_weapons)

  sbar.need_refresh();
}

int32_t view::x_center() 
{
  if (!focus)
    return (cx1+cx2)/2;

    return focus->x; 
}   

int32_t view::y_center() 
{ 
  if (!focus)
    return (cy1+cy2)/2;




uint16_t make_sync()
{
  uint16_t x=0;
  if (!current_level) return 0;
  if (current_level)
  {

void view::get_input()
{
	int sug_x,sug_y,sug_b1,sug_b2,sug_b3,sug_b4;
	int32_t sug_px,sug_py;

// NOTE:(AK) I have commented this out so we don't use the lisp
//		file "input.lsp" to get our key mappings.

			sug_b4 = 1;
		else sug_b4 = 0;

		int32_t bx = lnumber_value( CAR( ret ) );
		ret = CDR( ret );
		int32_t by = lnumber_value( CAR( ret ) );
		ret = CDR( ret );
		the_game->mouse_to_game( bx, by, sug_px, sug_py, this );



	if( view_changed() )
	{
		base->packet.write_uint8( SCMD_VIEW_RESIZE );
		base->packet.write_uint8( player_number );
		base->packet.write_uint32( suggest.cx1 );
		base->packet.write_uint32( suggest.cy1 );
		base->packet.write_uint32( suggest.cx2 );
		base->packet.write_uint32( suggest.cy2 );

		base->packet.write_uint32( suggest.pan_x );
		base->packet.write_uint32( suggest.pan_y );
		base->packet.write_uint32( suggest.shift_down );
		base->packet.write_uint32( suggest.shift_right );
	}

	if( weapon_changed() )
	{
		base->packet.write_uint8( SCMD_WEAPON_CHANGE );
		base->packet.write_uint8( player_number );
		base->packet.write_uint32( suggest.new_weapon );
	}

	base->packet.write_uint8( SCMD_SET_INPUT );
	base->packet.write_uint8( player_number );

	uint8_t mflags = 0;
	if( sug_x > 0 )
		mflags |= 1;
	else if ( sug_x < 0 )

	if( sug_b4 )
		mflags |= 128;

	base->packet.write_uint8( mflags );
	base->packet.write_uint16((uint16_t)((int16_t)sug_px));
	base->packet.write_uint16((uint16_t)((int16_t)sug_py));
}



  }
}

int view::process_input(char cmd, uint8_t *&pk)   // return 0 if something went wrong
{
  switch (cmd)
  {

    } break;
    case SCMD_VIEW_RESIZE :
    { 
      int32_t x[8];
      memcpy(x,pk,8*4);  pk+=8*4;
      cx1=lltl(x[0]);
      cy1=lltl(x[1]);

    }
    case SCMD_WEAPON_CHANGE :
    {
      int32_t x;
      memcpy(&x,pk,4);  pk+=4;
      current_weapon=lltl(x);



    case SCMD_SET_INPUT :
    {
      uint8_t x=*(pk++);

      if (x&1) x_suggestion=1;
      else if (x&2) x_suggestion=-1;

      if (x&64) b3_suggestion=1; else b3_suggestion=0;
      if (x&128) b4_suggestion=1; else b4_suggestion=0;

      uint16_t p[2];
      memcpy(p,pk,2*2);  pk+=2*2;
      
      pointer_x=(int16_t)(lstl(p[0]));
      pointer_y=(int16_t)(lstl(p[1]));
	
      return 1;
    } break;

}


void view::resize_view(int32_t Cx1, int32_t Cy1, int32_t Cx2, int32_t Cy2)
{
  if (cx1!=Cx1 || cx2!=Cx2 || cy1!=Cy1 || cy2!=Cy2)
  {

      dprintf("reset position to %d %d\n",start->x,start->y);
    } 
    focus->set_state(stopped);
    memset(weapons,0xff,total_weapons*sizeof(int32_t));   
    memset(last_weapons,0xff,total_weapons*sizeof(int32_t));   

    shift_down=SHIFT_DOWN_DEFAULT;
    shift_right=SHIFT_RIGHT_DEFAULT;

char *get_view_var_name(int num)
{ return vv_names[num]; }

int32_t view::get_view_var_value(int num)
{
  switch (num)
  {




int32_t view::set_view_var_value(int num, int32_t x)
{
  switch (num)
  {

}


void process_packet_commands(uint8_t *pk, int size)
{
  int32_t sync_uint16=-1;

  if (!size) return ;
  pk[size]=SCMD_END_OF_PACKET;

  uint8_t cmd;
  int already_reloaded=0;



      case SCMD_EXT_KEYRELEASE :
      case SCMD_CHAT_KEYPRESS :
      {
	uint8_t player_num=*(pk++);

	view *v=player_list;
	for (;v && v->player_number!=player_num;v=v->next);


      case SCMD_SYNC :
      {
	uint16_t x;
	memcpy(&x,pk,2);  pk+=2;
	x=lstl(x);
	if (demo_man.current_state()==demo_manager::PLAYING)
	sync_uint16=make_sync();

	if (sync_uint16==-1)
	sync_uint16=x;
	else if (x!=sync_uint16 && !already_reloaded)
	{
	  dprintf("out of sync %d (packet=%d, calced=%d)\n",current_level->tick_counter(),x,sync_uint16);
	  if (demo_man.current_state()==demo_manager::NORMAL)
	    net_reload();
	  already_reloaded=1;

      } break;
      case SCMD_DELETE_CLIENT :
      {
	uint8_t player_num=*(pk++);
	view *v=player_list,*last=NULL;
	for (;v && v->player_number!=player_num;v=v->next)
	last=v;




  virtual int unbuffered_read(void *buf, size_t count);       // returns number of bytes read
  int new_read(void *buf, size_t count);       // returns number of bytes read
  virtual int unbuffered_write(void *buf, size_t count);      // returns number of bytes written
  virtual int unbuffered_seek(int32_t offset, int whence);  // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success
  virtual int unbuffered_tell();
  virtual int file_size();
  virtual ~nfs_file();

      {
	delete local_test;
	local_test=NULL;
	pk.write_uint8(NFS_OPEN);
      }
      else
      {
	pk.write_uint8(NFS_CRC_OPEN);
	int fail;
	uint32_t crc=crc_man.get_crc(crc_man.get_filenumber(filename),fail); // skip crc calc if we can
	if (fail) crc=crc_file(local_test);
	pk.write_uint32(crc);
      }

      pk.write_uint8(strlen(filename)+1);
      pk.write((uint8_t *)filename,strlen(filename)+1);
      pk.write_uint8(strlen(mode)+1);
      pk.write((uint8_t *)mode,strlen(mode)+1);
      dprintf("try open %s,%s\n",filename,mode);
      offset=0;
      if (!nfs_server->send(pk))

	if (!nfs_server->get(pk)) nfs_disconnect();
	else
	{
	  int32_t fd;
	  if (pk.read((uint8_t *)&fd,4)!=4)
	    nfs_disconnect();
	  else
	  {

  else
  { 
    packet pk;
    pk.write_uint8(NFS_READ);
    pk.write_uint32(nfs_fd);
    pk.write_uint32(count);
    dprintf("try read %d,%d\n",nfs_fd,count);
    if (!nfs_server->send(pk))
    {


      int fail=0;
      int rtotal=0;
      uint16_t size=1;
      while (count>0 && !fail && size)
      {
	if (!nfs_server->get(pk)) fail=1;
	else
	{	  
	  if (pk.read((uint8_t *)&size,2)!=2) fail=1;
	  else
	  {
	    size=lstl(size);

	    {
	      int need_size=size>count ? count : size;

	      if (pk.read((uint8_t *)buf,need_size)!=need_size) fail=1;
	      else
	      {
		count-=need_size;	    

}


int nfs_file::unbuffered_seek(int32_t off, int whence) // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success
{
  if (local)
    return local->seek(off,whence);
  else
  { 
    packet pk;
    pk.write_uint8(NFS_SEEK);
    pk.write_uint32(nfs_fd);

    pk.write_uint32(off);
    pk.write_uint32(whence);
    dprintf("seek %d %d %d\n",nfs_fd,off,whence);
    if (!nfs_server->send(pk))
    {

  else if (nfs_server)
  { 
    packet pk;
    pk.write_uint8(NFS_TELL);
    pk.write_uint32(nfs_fd);
    if (!nfs_server->send(pk))
    {
      nfs_disconnect();    

	return 0;
      } else
      {
	int32_t off;
	if (pk.read((uint8_t *)&off,4)!=4) 
	{
	  dprintf("Disconnected on tell()\n");
	  nfs_disconnect();

  else if (nfs_server)
  { 
    packet pk;
    pk.write_uint8(NFS_FILESIZE);
    pk.write_uint32(nfs_fd);
    if (!nfs_server->send(pk))
    {
      nfs_disconnect();    

	return 0;
      } else
      {
	int32_t size;
	if (pk.read((uint8_t *)&size,4)!=4) 
	{
	  dprintf("disconnected on filesize\n");
	  nfs_disconnect();

  else if (nfs_server && !open_failure())
  {    
    packet pk;
    pk.write_uint8(NFS_CLOSE);
    pk.write_uint32(nfs_fd);
    dprintf("close %d\n",nfs_fd);
    if (!nfs_server->send(pk))
    {

Lines 24-30 Link Here

(-)abuse-sdl-0.7.0.orig/src/director.cpp (-1 / +1 lines)
24		24
25		25
26		26
27	int text_draw(int y, int x1, int y1, int x2, int y2, char buf, JCFont font, uchar *cmap, char color)	27	int text_draw(int y, int x1, int y1, int x2, int y2, char buf, JCFont font, uint8_t *cmap, char color)
28	{	28	{
29	short cx1,cy1,cx2,cy2,word_size,word_len;	29	short cx1,cy1,cx2,cy2,word_size,word_len;
30	screen->get_clip(cx1,cy1,cx2,cy2);	30	screen->get_clip(cx1,cy1,cx2,cy2);




}


int32_t dev_controll::snap_x(int32_t x)
{
  if (eh->key_pressed(JK_CTRL_L) || eh->key_pressed(JK_CTRL_R))
    return x-(x%the_game->ftile_width());

  else return x;  
}

int32_t dev_controll::snap_y(int32_t y)
{
  if (eh->key_pressed(JK_CTRL_L) || eh->key_pressed(JK_CTRL_R))
    return y-(y%the_game->ftile_height())-1;

void scale_put(image *im, image *screen, int x, int y, short new_width, short new_height)
{
  unsigned char *sl1,*sl2;
  int32_t xstep=(im->width()<<16)/new_width,
       ystep=(im->height()<<16)/new_height,iy,ix,sx,ix_start,iy_start;
  screen->add_dirty(x,y,x+new_width-1,y+new_height-1);


void scale_put_trans(image *im, image *screen, int x, int y, short new_width, short new_height)
{
  unsigned char *sl1,*sl2;
  int32_t xstep=(im->width()<<16)/new_width,
       ystep=(im->height()<<16)/new_height,iy,ix,sx,ix_start,iy_start;
  screen->add_dirty(x,y,x+new_width-1,y+new_height-1);


  if (y+new_height>cy2)
    new_height-=y+new_height-cy2;
  
  uint8_t d;
  for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
  {
    sl1=im->scan_line(iy>>16);


void dev_controll::dev_draw(view *v)
{
  int32_t x1,y1,x2,y2;
  if (dev&EDIT_MODE)
  {
    int32_t vx=v->xoff(),vy=v->yoff();
  
    if (dev&DRAW_LINKS)
    {


    if (link_object)
    {
      int32_t rx1,ry1;
      the_game->game_to_mouse(link_object->x,link_object->y,v,rx1,ry1);      
      screen->line(rx1,ry1,dlastx,dlasty,yellow);            
    }

    {
      image *i=cash.img(light_buttons[0]);
      int l=i->width()/2,h=i->height()/2;
      int32_t rx1,ry1;
      the_game->game_to_mouse(selected_light->x,selected_light->y,v,rx1,ry1);      
      screen->rectangle(rx1-l,ry1-h,rx1+l,ry1+h,eh->bright_color());
    }

    if (selected_object)
    {    
      selected_object->picture_space(x1,y1,x2,y2);    
      int32_t rx1,ry1,rx2,ry2;
      the_game->game_to_mouse(x1,y1,v,rx1,ry1);
      the_game->game_to_mouse(x2,y2,v,rx2,ry2);
      screen->rectangle(rx1,ry1,rx2,ry2,eh->bright_color());

  update_memprof();
}

light_source *find_light(int32_t x, int32_t y)
{
  image *i=cash.img(light_buttons[0]);
  int l=i->width()/2,h=i->height()/2;

    jfree(st);
    jfree(ch);
    char buf[100];
    sprintf(buf,"%8ld %8ld",(long int)j_allocated(),(long int)j_available());
    eh->font()->put_string(memprof->screen,memprof->x1(),memprof->y2()-eh->font()->height(),buf);

  }

    if (current_level && player_list && player_list->focus)
    {
      edit_object=selected_object=NULL;
      int32_t cx=player_list->focus->x,cy=player_list->focus->y;

      // save the old weapon array
      int32_t *w=(int32_t *)jmalloc(total_weapons*sizeof(int32_t),"tmp weapon array");
      memcpy(w,player_list->weapons,total_weapons*sizeof(int32_t));
      
      char tmp[100];
      strcpy(tmp,current_level->name());

      player_list->focus->x=cx;
      player_list->focus->y=cy;

      memcpy(player_list->weapons,w,total_weapons*sizeof(int32_t));     
      jfree(w);

      the_game->need_refresh();


  if (!strcmp(fword,"unchop"))
  {
    int32_t rx,ry;
    the_game->btile_on(dlastx,dlasty,rx,ry);
    if (rx>=0 && ry>=0)
    {


    if (t>=0)                                 // did we find it?
    {
      int32_t rx,ry;
      the_game->mouse_to_game(dlastx,dlasty,rx,ry);
      edit_object=create(t,rx,ry);
      current_level->add_object(edit_object);

  
  if (!strcmp(fword,"clear_auto"))
  {
    int32_t i,j;
    for (i=0;i<current_level->foreground_width();i++)
      for (j=0;j<current_level->foreground_height();j++)
        current_level->clear_fg(i,j);


  if (!strcmp(fword,"fg_select"))
  {
    int32_t x,y;
    the_game->ftile_on(dlastx,dlasty,x,y);
    if (x>=0 && y>=0 && x<current_level->foreground_width() &&
	y<current_level->foreground_height())


  if (!strcmp(fword,"toggle_fg_raise"))
  {
    int32_t x,y;
    the_game->ftile_on(dlastx,dlasty,x,y);
    if (x>=0 && y>=0 && x<current_level->foreground_width() &&
	y<current_level->foreground_height())    

  if (aiw)
  {    
    game_object *o=ai_object;
    int32_t x;
    if (o)
    {
      if (figures[o->otype]->total_fields)


  if (ev.type==EV_MOUSE_BUTTON && ev.mouse_button)
  {
    int32_t gx,gy;
    the_game->mouse_to_game(last_demo_mx,last_demo_my,gx,gy);
    if (!current_level) return ;
    current_area=current_level->area_list=new area_controller(gx,gy,

  if (!current_level) return;
  if (ev.type==EV_MOUSE_BUTTON && ev.mouse_button)
  {
    int32_t mx=last_demo_mx,my=last_demo_my;
    view *v=the_game->view_in(mx,my);
    for (area_controller *a=current_level->area_list;a;a=a->next)
    {
      int32_t x1,y1,x2,y2;
      the_game->game_to_mouse(a->x,a->y,v,x1,y1);
      the_game->game_to_mouse(a->x+a->w,a->y+a->h,v,x2,y2);
      if (abs(x1-mx)<2 && abs(y1-my)<2)


void dev_controll::handle_event(event &ev)
{
  int32_t x,y;
  if (link_object && (dlastx!=last_link_x || dlasty!=last_link_y))
  {
    last_link_x=dlastx;

	}
	if (ev.window==NULL && ev.type==EV_KEY && ev.key=='d')
	{
	  int32_t xv=0,yv=100;
	  edit_object->try_move(edit_object->x,edit_object->y,xv,yv,1);
	  edit_object->y+=yv;
	  state=DEV_SELECT;

    {
      if (current_area)
      {
	int32_t gx,gy;
	the_game->mouse_to_game(last_demo_mx,last_demo_my,gx,gy);
	if (gx>current_area->x && gy>current_area->y)
	{       

    {
      if (current_area)
      {
	int32_t gx,gy;
	the_game->mouse_to_game(last_demo_mx,last_demo_my,gx,gy);
	if (gx<current_area->x+current_area->w && gy<current_area->y+current_area->h)
	{       

	selected_object=NULL;
	if (ev.window==NULL)
	{	
	  int32_t rx,ry;
	  the_game->mouse_to_game(last_demo_mx,last_demo_my,rx,ry);

	  if (!(dev & MAP_MODE))

	  {
	    if (ev.mouse_button==1 && !selected_object && !selected_light)
	    {
	      int32_t xs,ys;
	      the_game->ftile_on(last_demo_mx,last_demo_my,xs,ys);
	      if (xs>=0 && ys>=0 && xs<current_level->foreground_width() && 
		  ys<current_level->foreground_height())	      

	      the_game->need_refresh();
	    } else if (ev.mouse_button==1 && !selected_object && !selected_light)
	    {
	      int32_t xs,ys;
	      the_game->btile_on(last_demo_mx,last_demo_my,xs,ys);
	      if (xs>=0 && ys>=0 && xs<current_level->background_width() && 
		  ys<current_level->background_height())

	}
      }
    }
    default:
      break;
  }

  switch (ev.type)

	case DEV_LIGHT8 :
	case DEV_LIGHT9 :
	{
	  int32_t lx,ly;
	  the_game->mouse_to_game(last_demo_mx,last_demo_my,lx,ly);
	  lx=snap_x(lx);
	  ly=snap_y(ly);

	  case 'R' : do_command("reload",ev); break;
	  case 'w' : 
	  {       
	    int32_t rx,ry;
	    the_game->mouse_to_game(dlastx,dlasty,rx,ry);
	    char msg[100]; sprintf(msg,symbol_str("mouse_at"),rx,ry);
	    the_game->show_help(msg);

	  {
	    if (current_level && player_list && player_list->focus)
	    {
	      int32_t rx,ry;
	      the_game->mouse_to_game(dlastx,dlasty,rx,ry);
	      player_list->focus->x=rx;
	      player_list->focus->y=ry;

	  case JK_ESC : close_window();	 break;
	  case ' ' : 
	  {
	    int32_t xs,ys,xx,yy;
	    the_game->ftile_on(me->x,me->y,xs,ys);

	    for (xx=xs;xx<xs+w;xx++)

	  } break;
	  case 't' :
	  {
	    int32_t xs,ys;
	    the_game->ftile_on(me->x,me->y,xs,ys);
	    dev_cont->fg_fill(-1,xs,ys,this);
	  } break;

    y=me->y;
  }

  fprintf(fp,"(add_palette \"%s\" %ld %ld %ld %ld %ld ",name,(long)w,(long)h,(long)x,(long)y,(long)scale);
  int i;
  for (i=0;i<w*h;i++)
    fprintf(fp,"%d ",pat[i]&0x7fff);




  if (fp.open_failure()) recalc=1;
  else
  {
    if (fp.read_uint16()!=calc_crc((unsigned char *)pal->addr(),768))
      recalc=1;
    else
    {

   

    jFILE f("light.tbl","wb");
    f.write_uint16(calc_crc((unsigned char *)pal->addr(),768));
    f.write(white_light,256*64);
    f.write(green_light,256*64);
    for (int i=0;i<TTINTS;i++)

{
  int t=0;
  for (light_source *f=first_light_source;f;f=f->next) t++;
  fp->write_uint32(t);
  fp->write_uint32(min_light_level);
  for (f=first_light_source;f;f=f->next)
  {
    fp->write_uint32(f->x);
    fp->write_uint32(f->y);
    fp->write_uint32(f->xshift);
    fp->write_uint32(f->yshift);
    fp->write_uint32(f->inner_radius);
    fp->write_uint32(f->outer_radius);
    fp->write_uint8(f->type);
  }
}


  packet pk;
  int t=0;
  for (light_source *f=first_light_source;f;f=f->next) t++;
  pk.write_uint32(t);
  pk.write_uint16(min_light_level);
  if (!os->send(pk)) return 0;
  for (f=first_light_source;f;f=f->next)
  {
    pk.reset();
    pk.write_uint32(f->x);
    pk.write_uint32(f->y);
    pk.write_uint32(f->xshift);
    pk.write_uint32(f->yshift);
    pk.write_uint32(f->inner_radius);
    pk.write_uint32(f->outer_radius);
    pk.write_uint32(f->type);
    if (!os->send(pk)) return 0;   
  }
  return 1;

  if (se)
  {
    fp->seek(se->offset,SEEK_SET);
    long t=fp->read_uint32();
    min_light_level=fp->read_uint32();
    light_source *last;
    while (t)
    {
      t--;
      long x=fp->read_uint32();
      long y=fp->read_uint32();
      long xshift=fp->read_uint32();
      long yshift=fp->read_uint32();
      long ir=fp->read_uint32();
      long ora=fp->read_uint32();
      long ty=fp->read_uint8();

      light_source *p=new light_source(ty,x,y,ir,ora,xshift,yshift,NULL);
      




	signed char *fire_off=o->otype==S_DFRIS_TOP ? large_fire_off :
	                                (o->otype==S_ROCKET_TOP ? large_fire_off :
					 (o->otype==S_BFG_TOP ? large_fire_off : small_fire_off));
	signed char *f=fire_off,*fb=NULL;
	int best_diff=200,best_num=0;
	int iy=f[1],ix=f[6*2];
	
	int best_angle=lisp_atan2(q->y-iy-v->pointer_y,v->pointer_x-q->x-ix);

 
  // fire try to move up to gun level

  int32_t x2=o->x,y2=firey;
//  current_level->foreground_intersect(other->x,other->y,x2,y2);      // find first location we can actuall "see"
//  current_level->all_boundary_setback(o,other->x,other->y,x2,y2);       // to make we don't fire through walls
  other->y=y2;

  {
    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    {
      int32_t value=lnumber_value(eval(CAR(args)));
      if (value)                                   // do we have ammo ?
      {
	o->lvars[fire_delay1]=3;

  {
    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    {
      int32_t value=lnumber_value(eval(CAR(args)));
      if (value)                                   // do we have ammo ?
      {
	o->lvars[fire_delay1]=6;

  {
    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    {
      int32_t value=lnumber_value(eval(CAR(args)));
      if (value)                                   // do we have ammo ?
      {
	o->lvars[fire_delay1]=2;

  {
    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    {
      int32_t value=lnumber_value(eval(CAR(args)));
      if (value)                                   // do we have ammo ?
      {
	o->lvars[fire_delay1]=1;

  {
    if (!o->lvars[fire_delay1])                   // make sur we are not waiting of previous fire
    {
      int32_t value=lnumber_value(eval(CAR(args)));
      if (value)                                   // do we have ammo ?
      {
	o->lvars[fire_delay1]=6;

      o->lvars[used_special_power]=1;
      o->lvars[last1_x]=o->x;
      o->lvars[last1_y]=o->y;
      int32_t oyvel=o->yvel();
      int in=o->lvars[in_climbing_area];

      player_move(o,xm,ym,but);


/*	if (o->lvars[special_power]==FAST_POWER)
	{
	  int32_t xv=0,yv=4;
	  o->try_move(o->x,o->y,xv,yv,1);
	  if (yv==4)
	    o->y+=3;

      }
      if (xm)                     // trying to get off the ladder, check to see if that's ok
      {
	int32_t x2=0,y2=-20;
	o->try_move(o->x,o->y,x2,y2,3);
	if (y2==-20)
	{

    o->lvars[b_ramp]=b;

    palette *p=pal->copy();
    uint8_t *addr=(uint8_t *)p->addr();
    int ra,ga,ba;
    
    for (int i=0;i<256;i++)
    {
      ra=(int)*addr+r; if (ra>255) ra=255; else if (ra<0) r=0; *addr=(uint8_t)ra; addr++;
      ga=(int)*addr+g; if (ga>255) ga=255; else if (ga<0) g=0; *addr=(uint8_t)ga; addr++;
      ba=(int)*addr+b; if (ba>255) ba=255; else if (ba<0) b=0; *addr=(uint8_t)ba; addr++;
    }
    p->load();
    delete p;

	  case run_jump : o->state=(character_state)S_fast_run_jump; break;
	  case run_jump_fall : o->state=(character_state)S_fast_run_jump_fall; break;
	  case end_run_jump : o->state=(character_state)S_fast_end_run_jump; break;
	  default: break;
	}

	player_draw(just_fired,o->controller()->player_number);

	  case run_jump : o->state=(character_state)S_fly_run_jump; break;
	  case run_jump_fall : o->state=(character_state)S_fly_run_jump_fall; break;
	  case end_run_jump : o->state=(character_state)S_fly_end_run_jump; break;
	  default: break;
	}

	player_draw(just_fired,o->controller()->player_number);

  o->lvars[sgb_lasty]=o->y;
  o->lvars[sgb_speed]=o->lvars[sgb_speed]*6/5;
  
  int32_t ang=o->lvars[sgb_angle];
  int32_t mag=o->lvars[sgb_speed];

  int32_t xvel=(lisp_cos(ang))*(mag);
  current_object->set_xvel(xvel>>16);
  current_object->set_fxvel((xvel&0xffff)>>8);
  int32_t yvel=-(lisp_sin(ang))*(mag);
  current_object->set_yvel(yvel>>16);
  current_object->set_fyvel((yvel&0xffff)>>8);      


    for (i=0;i<tp;i++)
    {
      int color=lnumber_value(lget_array_element(symbol_value(l_player_text_color),sorted_players[i]->player_number));  
      sprintf(msg,"%3ld %s",(long)sorted_players[i]->kills,sorted_players[i]->name);
      if (sorted_players[i]==local)
        strcat(msg," <<");


    char msg[100];


    sprintf(msg,"%-17s %3ld  %3ld",max_name,(long)v->kills,(long)(v->tkills+v->kills));
    fnt->put_string(screen,x,y,msg,color);

    y+=fnt->height();





int nfs_server::process_packet(packet &pk, nfs_server_client_node *c)
{
  uint8_t cmd;
  if (pk.read(&cmd,1)!=1) 
  {
    dprintf("Could not read command from nfs packet\n");

    { return 0; } break;
    case NFS_CRC_OPEN :
    {
      uint8_t fn_len;
      char fn[255],newfn[255],perm[255];
      uint32_t crc;
      if (pk.read((uint8_t *)&crc,4)!=4) return 0; crc=lltl(crc);
      if (pk.read(&fn_len,1)!=1) return 0;
      if (pk.read((uint8_t *)fn,fn_len)!=fn_len) return 0;      
      if (pk.read((uint8_t *)&fn_len,1)!=1) return 0;
      if (pk.read((uint8_t *)perm,fn_len)!=fn_len) return 0;      // read permission string
      dprintf("nfs open %s,%s\n",fn,perm);
      packet opk;
      int fail;
      uint32_t my_crc=crc_man.get_crc(crc_man.get_filenumber(fn),fail);
      if (fail)
      {
	jFILE *fp=new jFILE(squash_path(fn,newfn),perm);
	if (fp->open_failure())
	{
	  delete fp;
	  opk.write_uint32((int32_t)-1);
	  if (!c->nd->send(opk)) return 0;
	  return 1;
	} else      


      if (my_crc==crc)
      {
	opk.write_uint32((int32_t)-2);
	if (!c->nd->send(opk)) return 0;
	return 1;
      }

      if (fp->open_failure())
      {
	delete fp;
	opk.write_uint32((int32_t)-1);
      } else      
	opk.write_uint32(c->add_file(fp));      
      if (!c->nd->send(opk)) return 0;
      return 1;
    } break;
    case NFS_OPEN :
    { 
      uint8_t fn_len;
      char fn[255],newfn[255],perm[255];
      if (pk.read(&fn_len,1)!=1) return 0;
      if (pk.read((uint8_t *)fn,fn_len)!=fn_len) return 0;      
      if (pk.read((uint8_t *)&fn_len,1)!=1) return 0;
      if (pk.read((uint8_t *)perm,fn_len)!=fn_len) return 0;      // read permission string
      dprintf("nfs open %s,%s\n",fn,perm);
      packet opk;
      jFILE *fp=new jFILE(squash_path(fn,newfn),perm);
      if (fp->open_failure())
      {
	delete fp;
	opk.write_uint32((int32_t)-1);
      } else      
	opk.write_uint32(c->add_file(fp));      
      if (!c->nd->send(opk)) return 0;
      return 1;
    } break;
    case NFS_CLOSE :
    {
      int32_t fd;
      if (pk.read((uint8_t *)&fd,4)!=4) return 0;  fd=lltl(fd);
      dprintf("nfs close %d\n",fd);
      if (!c->delete_file(fd)) 
      {

    } break;
    case NFS_READ :
    {
      int32_t fd,size;
      if (pk.read((uint8_t *)&fd,4)!=4) return 0;    fd=lltl(fd);
      if (pk.read((uint8_t *)&size,4)!=4) return 0;  size=lltl(size);
      dprintf("nfs read %d,%d\n",fd,size);
      bFILE *fp=c->get_file(fd);
      uint8_t buf[NFSFILE_BUFFER_SIZE];
      packet opk;
      if (!fp) return 0;
      int total;

	opk.reset();
	int to_read=NFSFILE_BUFFER_SIZE < size ? NFSFILE_BUFFER_SIZE : size;
	total=fp->read(buf,to_read);
	opk.write_uint16(total);
	opk.write(buf,total);
	printf("sending %d bytes\n",total);
	if (!c->nd->send(opk)) 

    } break;
    case NFS_SEEK :
    {
      int32_t fd,off,type;
      if (pk.read((uint8_t *)&fd,4)!=4) return 0;   fd=lltl(fd);
      if (pk.read((uint8_t *)&off,4)!=4) return 0;  off=lltl(off);    
      if (pk.read((uint8_t *)&type,4)!=4) return 0; type=lltl(type);
      dprintf("seek %d %d %d\n",fd,off,type);
      bFILE *fp=c->get_file(fd);
      if (!fp) { dprintf("bad fd for seek\n"); return 0; }

    } break;
    case NFS_FILESIZE :
    {
      int32_t fd,off,type;
      if (pk.read((uint8_t *)&fd,4)!=4) return 0;   fd=lltl(fd);
      bFILE *fp=c->get_file(fd);
      if (!fp) return 0;      
      packet opk;
      opk.write_uint32(fp->file_size());
      if (!c->nd->send(opk)) return 0;
      return 1;
    } break;
    case NFS_TELL :
    {
      int32_t fd,off,type;
      if (pk.read((uint8_t *)&fd,4)!=4) return 0;   fd=lltl(fd);
      bFILE *fp=c->get_file(fd);
      if (!fp) return 0;      
      packet opk;
      opk.write_uint32(fp->tell());
      if (!c->nd->send(opk)) return 0;
      return 1;
    } break;

Lines 3-10 Link Here

(-)abuse-sdl-0.7.0.orig/src/version.cpp (-3 / +3 lines)
3	#include "macs.hpp"	3	#include "macs.hpp"
4	#include <string.h>	4	#include <string.h>
5		5
6	uchar major_version=2;	6	uint8_t major_version=2;
7	uchar minor_version=00;	7	uint8_t minor_version=00;
8		8
9	extern int get_option(char *name);	9	extern int get_option(char *name);
10		10
Lines 28-34 Link Here
28	dprintf(msg2);	28	dprintf(msg2);
29		29
30	for (i=0;i<80;i++)	30	for (i=0;i<80;i++)
31	((unsigned char )(0xb8000+i*2+1))=0x17;	31	((uint8_t )(0xb8000+i*2+1))=0x17;
32	}	32	}
33	#else	33	#else
34	static void setup()	34	static void setup()




/*  client_descriptor *last=NULL;
  if (sync_check)
  {
    next_out.write_uint8(SCMD_SYNC);
    next_out.write_uint32(make_sync_uint32());
  }
    
  next_out.write_uint8(SCMD_END_OF_PACKET);        // so clients knows when to stop reading

  for (client_descriptor *p=client_list;p;)
  {

  {
    packet pk;
    current_level->save("netstart.spe",1);
    printf("%d sync for save\n",make_sync_uint32());

    client_descriptor *last=NULL;
    for (p=client_list;p;p=p->next)
    {
      if (p->player)
      {
	pk.write_uint8(SCMD_JOIN_START);
	int error=!p->connection->send(pk);
	if (!error)
	{





part_frame::part_frame(bFILE *fp)
{
  t=fp->read_uint32();
  data=(part *)jmalloc(sizeof(part)*t,"particle frame");
  x1=y1=100000; x2=y2=-100000;
  for (int i=0;i<t;i++)
  {
    int16_t x=fp->read_uint16();
    int16_t y=fp->read_uint16();
    if (x<x1) x1=x;
    if (y<y1) y1=y;
    if (x>x2) x2=x;
    if (y>y2) y2=x;
    data[i].x=x;
    data[i].y=y;   
    data[i].color=fp->read_uint8(); 
  }
}



void part_frame::draw(image *screen, int x, int y, int dir)
{
  int16_t cx1,cy1,cx2,cy2;
  screen->get_clip(cx1,cy1,cx2,cy2);
  if (x+x1>cx2 || x+x2<cx1 || y+y1>cy2 || y+y2<cy1) return ;



void scatter_line(int x1, int y1, int x2, int y2, int c, int s)
{
	int16_t cx1, cy1, cx2, cy2;
	screen->get_clip( cx1, cy1, cx2, cy2 );

	int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;


void ascatter_line(int x1, int y1, int x2, int y2, int c1, int c2, int s)
{
	int16_t cx1, cy1, cx2, cy2;
	screen->get_clip( cx1, cy1, cx2, cy2 );

	int t = abs( x2 - x1 ) > abs( y2 - y1 ) ? abs( x2 - x1 ) + 1 : abs( y2 - y1 ) + 1;

	s = ( 15 - s );

	int w = screen->width();
	uint8_t *addr;

	while( t-- )
	{




    net_socket *sock=prot->connect_to_server(addr,net_socket::SOCKET_SECURE);

    if (!sock) { printf("set_file_server::connect failed\n"); return 0; }
    uint8_t cmd=CLIENT_CRC_WAITER;
    if ( (sock->write(&cmd,1)!=1 && printf("set_file_server::writefailed\n")) ||
	 (sock->read(&cmd,1)!=1  && printf("set_file_server::read failed\n")))        // wait for confirmation that crc's are written
    { delete sock; return 0; }

				net_socket *new_sock=comm_sock->accept(addr);	
				if (new_sock)
				{
				  uint8_t client_type;
				  if (new_sock->read(&client_type,1)!=1)
				  {
				    delete addr;	

				      } break;
				      case CLIENT_LSF_WAITER :          // wants to know which .lsp file to start with
				      {
								uint8_t len=strlen(lsf);
								new_sock->write(&len,1);
								new_sock->write(lsf,len);
								delete new_sock;

    net_socket *sock=prot->connect_to_server(addr,net_socket::SOCKET_SECURE);
    if (!sock) return 0;

    uint8_t ctype=CLIENT_LSF_WAITER;
    uint8_t len;

    if (sock->write(&ctype,1)!=1 ||
				sock->read(&len,1)!=1 || len==0 ||

      return 0;
    }

    uint8_t ctype=CLIENT_ABUSE;
    uint16_t port=lstl(main_net_cfg->port+1),cnum;

    uint8_t reg;
    if (sock->write(&ctype,1)!=1 ||   // send server out game port
				sock->read(&reg,1)!=1)        // is remote engine registered?
    { delete sock; return 0; }

    if (get_login())
      strcpy(uname,get_login());
    else strcpy(uname,"unknown");
    uint8_t len=strlen(uname)+1;
    short nkills;

    if (sock->write(&len,1)!=1 ||


      spec_directory sd(fp);  

#if 0
      spec_entry *e=sd.find("Copyright 1995 Crack dot Com, All Rights reserved"); 
      if (!e)
      { 

				the_game->need_refresh();
      }
      else 
#endif
        current_level=new level(&sd,fp,NET_STARTFILE);

      delete fp;     




void write_level(bFILE *fp, Cell *level)
{
  int type=item_type(level);
  fp->write_uint8(type);


  switch (type)
  {
    case L_NUMBER :
    { fp->write_uint32(lnumber_value(level)); } break;
    case L_CHARACTER :
    { fp->write_uint16(lcharacter_value(level)); } break;
    case L_STRING :
    { long l=strlen(lstring_value(level))+1;
      fp->write_uint32(l);
      fp->write(lstring_value(level),l); 
    } break;
    case L_SYMBOL :
    { fp->write_uint32((long)level); } break;
    case L_CONS_CELL :
    {
      if (!level) fp->write_uint32(0);
      else
      {
	long t=0;

	for (;b && item_type(b)==L_CONS_CELL;b=CDR(b)) t++;
	if (b) 
	{
	  fp->write_uint32(-t);      // negative number means dotted list
	  write_level(fp,b);       // save end of dotted list     
	}
	else fp->write_uint32(t);

	for (b=level;b && item_type(b)==L_CONS_CELL;b=CDR(b))    
	  write_level(fp,CAR(b));


Cell *load_block(bFILE *fp)
{
  int type=fp->read_uint8();
  switch (type)
  {   
    case L_NUMBER :
    { return new_lisp_number(fp->read_uint32()); } break;
    case L_CHARACTER :
    { return new_lisp_character(fp->read_uint16()); } break;
    case L_STRING :
    { long l=fp->read_uint32();
      lisp_string *s=new_lisp_string(l);
      fp->read(lstring_value(s),l);
      return s;
    } break;
    case L_SYMBOL :
    { return (void *)fp->read_uint32(); } break;
    case L_CONS_CELL :
    {
      long t=fp->read_uint32();
      if (!t) return NULL;
      else
      {
	long x=abs(t);
	cons_cell *last=NULL,*first=NULL;
	while (x)
	{
	  cons_cell *c=new_cons_cell();




      exit(0);      
    }

    inside=(uint8_t *)jmalloc(tot,"Boundary point list");  
  }

  uint8_t *point_on;
  
  for (i=0,point_on=data;i<tot-1;i++)
  {

    checky=(y1+y2)/2;

    int j,xp1,yp1,xp2,yp2,maxx,maxy,minx,miny;    
    uint8_t *point2,segs_left=0,segs_right=0,segs_down=0;    
    int skip_next=0;    
    int check_left=0,check_right=0,check_down=0;


boundary::boundary(boundary *p) : point_list(p->tot,p->data)
{
  int x1,y1,x2,y2,checkx,checky,i;  
  uint8_t *point_on;  
  if (tot)
  {
    inside=(uint8_t *)jmalloc(tot,"Boundary point list");  
  } else inside=NULL;
  for (i=0,point_on=data;i<tot-1;i++)
  {

    checky=(y1+y2)/2;

    int j,xp1,yp1,xp2,yp2,maxx,maxy,minx,miny;    
    uint8_t *point2,segs_left=0,segs_right=0,segs_down=0;    
    int skip_next=0;    
    int check_left=0,check_right=0,check_down=0;


backtile::backtile(bFILE *fp)
{
  im=load_image(fp);
  next=fp->read_uint16();
}

backtile::backtile(spec_entry *e, bFILE *fp)
{
  im=load_image(e,fp);
  next=fp->read_uint16();
}

foretile::foretile(bFILE *fp)
{
  uint8_t *sl; 
  image *img=load_image(fp);


  // create the micro image of the fore tile by aveginging the color values in 2 x 2 space
  // and storeing teh closest match
//  uint8_t *buffer=(uint8_t *)&micro_image;
  int x,y,w=img->width(),h=img->height(),l;
  int r[AUTOTILE_WIDTH*AUTOTILE_HEIGHT],
      g[AUTOTILE_WIDTH*AUTOTILE_HEIGHT],

  im=new trans_image(img,"foretile");
  delete img; 

  next=fp->read_uint16();
  fp->read(&damage,1);



  {
    point_list p(fp); 
    advance=0;
  } else advance=fp->read_uint8();
  
  f_damage=new boundary(fp,"fig bound"); 
  b_damage=new boundary(f_damage);

char_tint::char_tint(bFILE *fp)  // se should be a palette entry
{
  palette *p=new palette(fp);
  uint8_t *t=data,*p_addr=(uint8_t *)p->addr();
  for (int i=0;i<256;i++,t++,p_addr+=3)  
    *t=pal->find_closest(*p_addr,p_addr[1],p_addr[2]);
   





  the_game->load_level(name);
  record_file->write((void *)"DEMO,VERSION:2",14);
  record_file->write_uint8(strlen(name)+1);
  record_file->write(name,strlen(name)+1);
  
  
  if (DEFINEDP(symbol_value(l_difficulty)))
  {
    if (symbol_value(l_difficulty)==l_easy) record_file->write_uint8(0);
    else if (symbol_value(l_difficulty)==l_medium) record_file->write_uint8(1);
    else if (symbol_value(l_difficulty)==l_hard) record_file->write_uint8(2);
    else record_file->write_uint8(3);
  } else record_file->write_uint8(3);
  

  state=RECORDING;

        if (p->local_player())
          p->get_input();

      base->packet.write_uint8(SCMD_SYNC);
      base->packet.write_uint16(make_sync());
      demo_man.save_packet(base->packet.packet_data(),base->packet.packet_size());
      process_packet_commands(base->packet.packet_data(),base->packet.packet_size());

    } break;
    case PLAYING :
    {
      uint8_t buf[1500];
      int size;
      if (get_packet(buf,size))              // get starting inputs
      {
        process_packet_commands(buf,size);      
	int32_t mx,my;
	the_game->game_to_mouse(player_list->pointer_x,player_list->pointer_y,player_list,mx,my);
	eh->set_mouse_position(small_render ? mx*2 : mx, small_render ? my*2 : my);
      }

	return ;
      }
    } break;
    default :
      break;
  }
}



int demo_manager::start_playing(char *filename)
{
  uint8_t sig[15];
  record_file=open_file(filename,"rb");
  if (record_file->open_failure()) { delete record_file; return 0; }  
  char name[100],nsize,diff;



    } break;
    default :
      break;
  }

  switch (new_state)

{
  if (state==RECORDING)
  {
    uint16_t ps=lstl(packet_size);
    if (record_file->write(&ps,2)!=2 ||
	record_file->write(packet,packet_size)!=packet_size)
    {

{
  if (state==PLAYING)
  {
    uint16_t ps;
    if (record_file->read(&ps,2)!=2)
    {
      set_state(NORMAL);




int nforetiles,nbacktiles,f_wid,f_hi,b_wid,b_hi,total_songs=0,sfx_volume,music_volume,sound_avail=0;
song *current_song=NULL;

uint16_t current_start_type,start_position_type,last_start_number;
int light_buttons[13];
int joy_picts[2*9];
palette *pal;


	int should_save_sd_cache = 0;

# if 0
	char *cachepath;
	cachepath = (char *)jmalloc( strlen( get_save_filename_prefix() ) + 12 + 1, "cachepath" );
	sprintf( cachepath, "%ssd_cache.tmp", get_save_filename_prefix() );

	bFILE *load = open_file( cachepath, "rb" );
	if( !load->open_failure() )

		should_save_sd_cache = 1;
	}
	delete load;
#endif

  if (!net_start())              // don't let them specify a startup file we are connect elsewhere
  {

  b_wid=cash.backt(backtiles[0])->im->width();
  b_hi=cash.backt(backtiles[0])->im->height();

#if 0
	if( should_save_sd_cache )
	{
		bFILE *save = open_file( cachepath, "wb" );

		}
		delete save;
	}
#endif

	sd_cache.clear();
	past_startup = 1;
#if 0
	jfree( cachepath );
#endif
}








obj_desc object_descriptions[TOTAL_OBJECT_VARS]={
				{"fade_dir",      RC_8 },
				{"frame_dir",     RC_8 },
				{"direction",     RC_8 },
				{"gravity_on",    RC_8 },
				{"fade_count",    RC_8 },

				{"fade_max",      RC_8 },
				{"active",        RC_8 },
				{"flags",         RC_8 },
				{"aitype",        RC_8 },
				{"xvel",          RC_32 },

				{"fxvel",         RC_8 },
				{"yvel",          RC_32 },
				{"fyvel",         RC_8 },
				{"xacel",         RC_32 },
				{"fxacel",        RC_8 },

				{"yacel",         RC_32 },
				{"fyacel",        RC_8 },
				{"x",             RC_32 },
				{"fx",            RC_8 },
				{"y",             RC_32 },

				{"fy",            RC_8 },
				{"hp",            RC_16 },
				{"mp",            RC_16 },
				{"fmp",           RC_16 },
				{"cur_frame",     RC_16 },

				{"aistate",       RC_16 },
				{"aistate_time",  RC_16 },
				{"targetable",    RC_8 }

			      };
  
int32_t game_object::get_var_by_name(char *name, int &error)
{
  error=0;
  int i=0;

  return 0;
}

int game_object::set_var_by_name(char *name, int32_t value)
{
  int i=0;
  for (;i<TOTAL_OBJECT_VARS;i++)

}


void simple_object::set_var(int xx, uint32_t v)
{
  switch (xx)
  {

  }
}

int32_t simple_object::get_var(int xx)
{
  switch (xx)
  {

{
  switch (type)
  {
    case RC_8 : 
    { return 1; } break;
    case RC_16 : 
    { return 2; } break;
    case RC_32 : 
    { return 4; } break;
  }		
  CHECK(0);


void game_object::draw_above(view *v)
{
  int32_t x1,y1,x2,y2,sy1,sy2,sx,i;
  picture_space(x1,y1,x2,y2);    

  the_game->game_to_mouse(x1,y1,v,sx,sy2);
  if (sy2>=v->cy1)
  {
    int32_t draw_to=y1-(sy2-v->cy1),tmp=x;
    current_level->foreground_intersect(x,y1,tmp,draw_to);     
    the_game->game_to_mouse(x1,draw_to,v,i,sy1);     // calculate sy1


    current_object=this;
    void *m=mark_heap(TMP_SPACE);

    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


}

   
void game_object::do_damage(int amount, game_object *from, int32_t hitx, int32_t hity, 
			    int32_t push_xvel, int32_t push_yvel) 
{

  void *d=figures[otype]->get_fun(OFUN_DAMAGE);  

    ((cons_cell *)hy)->cdr=px;
    ((cons_cell *)px)->cdr=py;

    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


#endif
}

void game_object::damage_fun(int amount, game_object *from, int32_t hitx, int32_t hity, 
			    int32_t push_xvel, int32_t push_yvel) 
{ 
  if (!hurtable() || !alive()) return ;


}


void game_object::picture_space(int32_t &x1, int32_t &y1,int32_t &x2, int32_t &y2)
{
  int xc=x_center(),w=picture()->width(),h=picture()->height();  
  if (direction>0)

}


int32_t game_object::x_center()
{
  return current_sequence()->x_center(current_frame);   
}

    current_object=this;

    void *m=mark_heap(TMP_SPACE);
    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


    current_object=this;

    void *m=mark_heap(TMP_SPACE);
    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


  }
}

game_object *game_object::try_move(int32_t x, int32_t y, int32_t &xv, int32_t &yv, int checks)
{
  if (xv || yv)  // make sure they are suggesting movement
  {    
    game_object *who1=NULL,*who2=NULL;      // who did we intersect?  
    int32_t x2,y2,h;  

    if (checks&1)
    {      


void *game_object::float_tick()  // returns 1 if you hit something, 0 otherwise
{
  int32_t ret=0;
  if (hp()<=0)
  {
    if (state!=dead)

    } 
  }

  int32_t fxv=sfxvel()+sfxacel(),fyv=sfyvel()+sfyacel();
  int32_t xv=xvel()+xacel()+(fxv>>8),yv=yvel()+yacel()+(fyv>>8);

  if (xv!=xvel() || yv!=yvel())   // only store vel's if changed so we don't increase object size
  {

 
  if (fxv || fyv || xv || yv)   // don't even try if there is no velocity
  {
    int32_t ffx=fx()+sfxvel(),ffy=fy()+sfyvel();
    int32_t nxv=xvel()+(ffx>>8);
    int32_t nyv=yvel()+(ffy>>8);
    set_fx(ffx&0xff);
    set_fy(ffy&0xff);
    
    int32_t old_nxv=nxv,old_nyv=nyv;
    game_object *hit_object=try_move(x,y,nxv,nyv,3);   // now find out what velocity is safe to use
    
/*    if (get_cflag(CFLAG_STOPPABLE))

    y+=nyv;
    if (old_nxv!=nxv || old_nyv!=nyv)
    {
      int32_t lx=last_tile_hit_x,ly=last_tile_hit_y;
      stop();
      if (old_nxv==0)
      {

	else if (old_nxv<0) ret|=BLOCKED_LEFT;
      } else
      {
	int32_t tx=(old_nxv>0 ? 1 : -1),ty=0;
	try_move(x,y,tx,ty,3);
	if (!tx) 	
	  ret|=(old_nxv>0 ? BLOCKED_RIGHT : BLOCKED_LEFT);	

{
  int blocked=0;

  int32_t xt=0,yt=2;
  try_move(x,y-2,xt,yt,1);    // make sure we are not falling through the floor
  y=y-2+yt;
  

  }
  
  // first let's move the guy acording to his physics
  int32_t xa=xacel(),ya=yacel(),fxa=sfxacel(),fya=sfyacel();
  if (xa || ya || fxa || fya)
  {
    int fxv=sfxvel(),fyv=sfyvel();
    fxv+=fxa;  fyv+=fya;    
    int32_t xv=xvel()+xa+(fxv>>8); 
    set_xvel(xvel()+xa+(fxv>>8));
    set_yvel(yvel()+ya+(fyv>>8));
    set_fxvel(fxv&0xff);

  }
  
  // check to see if this advancement causes him to collide with objects
  int32_t old_vy=yvel(),old_vx=xvel();  // save the correct veloicties

  if (old_vx || old_vy)
  {
    int up=0;
    if (yvel()<=0)  // if we are going up or a strait across check up and down
    up=2;
    int32_t xv=xvel(),yv=yvel();
    game_object *h=try_move(x,y,xv,yv,1|up);       // now find out what velocity is safe to use
    set_xvel(xv);
    set_yvel(yv);

    {          
      if (gravity())                         // was he going up or down?
      {	                       
	int32_t fall_xv=0,old_fall_vy,fall_vy;
	old_fall_vy=fall_vy=old_vy-yvel();             // make sure he gets all of his yvel
	try_move(x,y,fall_xv,fall_vy,1|up);
	if (old_vy>0 && fall_vy<old_fall_vy)       // he was trying to fall, but he hit the ground

	{
	  if (old_vy!=0)
	  {
	    int32_t testx=old_vx<0 ? -1 : 1,testy=0;    // see if we were stopped left/right
                                                     // or just up down
	    try_move(x,y,testx,testy,1|up);
	    if (testx==0)                           // blocked left/right, set flag

      }    
      else                  // see if we can make him 'climb' the hill
      {
	int32_t ox=x,oy=y;       // rember orginal position in case climb doesn't work

	int32_t climb_xvel=0,climb_yvel=-5;	    // try to move up one pixel to step over the 
	try_move(x,y,climb_xvel,climb_yvel,3);  // jutting polygon line
	y+=climb_yvel;


     
  if (yacel()==0 && !gravity())       // he is not falling, make sure he can't
  {
    int32_t nvx=0,nvy=yvel()+12;  // check three pixels below for ground
    try_move(x,y,nvx,nvy,1); 
    if (nvy>11)                    // if he falls more than 2 pixels, then he falls
    {

  int ad=current_sequence()->get_advance(current_frame);
  if (ad && current_level)
  {
    int32_t xv;
    if (direction>0) xv=ad; else xv=-ad;
    int32_t yv=0;
    try_move(x,y,xv,yv,3);
    x+=xv;
  }   

}


game_object *create(int type, int32_t x, int32_t y, int skip_constructor, int aitype)
{
  game_object *g=new game_object(type,skip_constructor);
  g->x=x; g->y=y; g->last_x=x; g->last_y=y;


    void *m=mark_heap(TMP_SPACE);

    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;



    void *m=mark_heap(TMP_SPACE);

    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


  }         // not pressing left or right, so slow down or stop
  else if (!gravity() && state!=start_run_jump)
  {    
    int32_t stop_acel;
    if (xvel()<0)                                    // he was going left
    {
      stop_acel=get_ability(type(),stop_accel);    // find out how fast he can slow down

{

  // first let's move the guy acording to his physics
  int32_t xa=xacel(),ya=yacel(),fxa=sfxacel(),fya=sfyacel();
  if (xa || ya || fxa || fya)
  {
    int fxv=sfxvel(),fyv=sfyvel();
    fxv+=fxa;  fyv+=fya;    
    int32_t xv=xvel()+xa+(fxv>>8); 
    set_xvel(xvel()+xa+(fxv>>8));
    set_yvel(yvel()+ya+(fyv>>8));
    set_fxvel(fxv&0xff);
    set_fyvel(fyv&0xff);
  }
  
  int32_t ox2,oy2;

  int32_t nx=x+xvel(),nfx=fx()+fxvel(),ny=y+yvel(),nfy=fy()+fyvel();
  nx+=nfx>>8;
  ny+=nfy>>8;
 

  return 0;
}

game_object *number_to_object_in_list(int32_t x, object_node *list)
{
  if (!x) return NULL; x--;
  while (x && list) { list=list->next; x--; }

}


int32_t object_list_length(object_node *list)
{
  int32_t x=0;
  while (list) { list=list->next; x++; }
  return x;
  

    int t=figures[Type]->tv;
    if (t)
    {
      lvars=(int32_t *)jmalloc(t*4,"object vars");
      memset(lvars,0,t*4);
    }
    else lvars=NULL;


int game_object::reduced_state()
{
  int32_t x=0;
  for (int i=0;i<figures[otype]->ts;i++)
  {
    if (i==state) return x;

      game_object *o=current_object;
      current_object=(game_object *)this;

      time_marker *prof1=NULL;
      if (profiling())
        prof1=new time_marker;


    int t=figures[new_type]->tv;
    if (t)
    {
      lvars=(int32_t *)jmalloc(t*4,"object vars");
      memset(lvars,0,t*4);
    }
    else lvars=NULL;


    void *m=mark_heap(TMP_SPACE);

    time_marker *prof1=NULL;
    if (profiling())
      prof1=new time_marker;


Lines 5-11 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/lcache.hpp (-1 / +1 lines)
5	#ifdef SCADALISP	5	#ifdef SCADALISP
6	#define can_cache_lisp() 0	6	#define can_cache_lisp() 0
7	#else	7	#else
8	#define can_cache_lisp() 1	8	#define can_cache_lisp() 0 /* XXX */
9	#endif	9	#endif
10		10
11	long block_size(Cell *level); // return number of bytes to save this block of code	11	long block_size(Cell *level); // return number of bytes to save this block of code




#define BUS_TYPE_HPP

#ifdef __sgi
#define WORD_ALIGN 1
#endif

#ifdef sun
#define WORD_ALIGN 1
#endif

#ifdef SUN3
#define WORD_ALIGN 1
#endif

#ifdef SUN4
#define WORD_ALIGN 1
#endif

#ifdef __sgi
#define WORD_ALIGN 1
#endif

#ifdef _AIX
#define WORD_ALIGN 1
#endif

#ifdef __sparc__
#define WORD_ALIGN 1
#endif

#ifdef __arm__
#define WORD_ALIGN 1
#endif

#endif // BUS_TYPE_HPP

Lines 171-177 Link Here

(-)abuse-sdl-0.7.0.orig/src/lisp.cpp (-1 / +3 lines)
171		171
172	void *lmalloc(int size, int which_space)	172	void *lmalloc(int size, int which_space)
173	{	173	{
174	#ifdef WORD_ALLIGN	174	return malloc(size); /* XXX */
		175
		176	#ifdef WORD_ALIGN
175	size=(size+3)&(~3);	177	size=(size+3)&(~3);
176	#endif	178	#endif
177		179

Lines 35-41 Link Here

(-)abuse-sdl-0.7.0.orig/src/lcache.cpp (-1 / +1 lines)
35	{ ret=sizeof(lisp_pointer); }	35	{ ret=sizeof(lisp_pointer); }
36	else ret=0;	36	else ret=0;
37	}	37	}
38	#ifdef WORD_ALLIGN	38	#ifdef WORD_ALIGN
39	return (ret+3)&(~3);	39	return (ret+3)&(~3);
40	#else	40	#else
41	return ret;	41	return ret;

Lines 11-17 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/keys.cpp (-1 / +1 lines)
11		11
12	void key_name(int key, char *buffer)	12	void key_name(int key, char *buffer)
13	{	13	{
14	static char sing[2];	14	//static char sing[2];
15	if( key > 255 && key <= JK_MAX_KEY )	15	if( key > 255 && key <= JK_MAX_KEY )
16	strcpy(buffer,jk_key_names[key-256]);	16	strcpy(buffer,jk_key_names[key-256]);
17	else if( key == JK_BACKSPACE )	17	else if( key == JK_BACKSPACE )




	ev.window->next=NULL;
	if (red)
	{
	  jwindow *j=ev.window;
/*	  screen->add_dirty(j->x,j->y,j->x+j->l-1,j->y+j->h-1);
	  for (p=first;p!=j;p=p->next)
	    p->screen->add_dirty(j->x-p->x,j->y-p->y,j->x+j->l-1-p->x,j->y+j->h-1-p->y);*/

{
  jwindow *p,*q;

  int mx=0,my=0;
  image *mouse_pic=NULL,*mouse_save=NULL;
  
  if (has_mouse())
  {    


ifield *input_manager::unlink(int id)     // unlinks ID from fields list and return the pointer to it
{ 
  for (ifield *i=first,*last=NULL;i;i=i->next)
  {
    if (i->id==id) 
    {

Return to bug 155617

Lines 354-373 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/morph.cpp (-19 / +19 lines)
354		354
355	for (i=0;i<total;i++)	355	for (i=0;i<total;i++)
356	{	356	{
357	((morph_point16 *)p+i)->x1=fp->read_short();	357	((morph_point16 *)p+i)->x1=fp->read_uint16();
358	((morph_point16 *)p+i)->y1=fp->read_short();	358	((morph_point16 *)p+i)->y1=fp->read_uint16();
359	((morph_point16 *)p+i)->x2=fp->read_short();	359	((morph_point16 *)p+i)->x2=fp->read_uint16();
360	((morph_point16 *)p+i)->y2=fp->read_short();	360	((morph_point16 *)p+i)->y2=fp->read_uint16();
361	fp->read( &((morph_point16 *)p+i)->start_color,1);	361	fp->read( &((morph_point16 *)p+i)->start_color,1);
362	fp->read( &((morph_point16 *)p+i)->end_color,1);	362	fp->read( &((morph_point16 *)p+i)->end_color,1);
363	}	363	}
364		364
365	small=0;	365	small=0;
366	}	366	}
367	w[0]=fp->read_short();	367	w[0]=fp->read_uint16();
368	h[0]=fp->read_short();	368	h[0]=fp->read_uint16();
369	w[1]=fp->read_short();	369	w[1]=fp->read_uint16();
370	h[1]=fp->read_short();	370	h[1]=fp->read_uint16();
371	}	371	}
372		372
373	void jmorph::show_frame(image *screen, int x, int y,	373	void jmorph::show_frame(image *screen, int x, int y,
Lines 677-683 Link Here
677	int i;	677	int i;
678		678
679		679
680	fp->write_long(total);	680	fp->write_uint32(total);
681	if (small)	681	if (small)
682	{	682	{
683		683
Lines 690-707 Link Here
690	else	690	else
691	{	691	{
692	for (i=0;i<total;i++)	692	for (i=0;i<total;i++)
693	{ fp->write_short(((morph_point16 *)p+i)->x1);	693	{ fp->write_uint16(((morph_point16 *)p+i)->x1);
694	fp->write_short(((morph_point16 *)p+i)->y1);	694	fp->write_uint16(((morph_point16 *)p+i)->y1);
695	fp->write_short(((morph_point16 *)p+i)->x2);	695	fp->write_uint16(((morph_point16 *)p+i)->x2);
696	fp->write_short(((morph_point16 *)p+i)->y2);	696	fp->write_uint16(((morph_point16 *)p+i)->y2);
697	fp->write( &((morph_point16 *)p+i)->start_color,1);	697	fp->write( &((morph_point16 *)p+i)->start_color,1);
698	fp->write( &((morph_point16 *)p+i)->end_color,1);	698	fp->write( &((morph_point16 *)p+i)->end_color,1);
699	}	699	}
700	}	700	}
701	fp->write_short(w[0]);	701	fp->write_uint16(w[0]);
702	fp->write_short(h[0]);	702	fp->write_uint16(h[0]);
703	fp->write_short(w[1]);	703	fp->write_uint16(w[1]);
704	fp->write_short(h[1]);	704	fp->write_uint16(h[1]);
705	return 1;	705	return 1;
706	}	706	}
707		707
Lines 876-887 Link Here
876	{	876	{
877	int i;	877	int i;
878		878
879	patches=fp->read_short();	879	patches=fp->read_uint16();
880	pats=(morph_patch )jmalloc(sizeof(morph_patch)patches,"patched_morph::points");	880	pats=(morph_patch )jmalloc(sizeof(morph_patch)patches,"patched_morph::points");
881		881
882	for (i=0;i<patches;i++)	882	for (i=0;i<patches;i++)
883	{	883	{
884	pats[i].patches=fp->read_short();	884	pats[i].patches=fp->read_uint16();
885	if (pats[i].patches)	885	if (pats[i].patches)
886	{	886	{
887	pats[i].patch_data=(unsigned char )jmalloc(3pats[i].patches,"patched_morph::patch_data");	887	pats[i].patch_data=(unsigned char )jmalloc(3pats[i].patches,"patched_morph::patch_data");

Lines 7-20 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/jmalloc.hpp (-5 / +5 lines)
7	#ifdef MANAGE_MEM	7	#ifdef MANAGE_MEM
8	enum {ALLOC_SPACE_STATIC,ALLOC_SPACE_CACHE};	8	enum {ALLOC_SPACE_STATIC,ALLOC_SPACE_CACHE};
9	extern int alloc_space;	9	extern int alloc_space;
10	void jmalloc(long size, char what_for);	10	void jmalloc(int32_t size, char what_for);
11	void jrealloc(void ptr, long size, char *what_for);	11	void jrealloc(void ptr, int32_t size, char *what_for);
12	void jfree(void *ptr);	12	void jfree(void *ptr);
13	void mem_report(char *filename);	13	void mem_report(char *filename);
14	void jmalloc_init(long min_size);	14	void jmalloc_init(int32_t min_size);
15	void jmalloc_uninit();	15	void jmalloc_uninit();
16	long j_allocated();	16	int32_t j_allocated();
17	long j_available();	17	int32_t j_available();
18	extern void free_up_memory();	18	extern void free_up_memory();
19	#else	19	#else
20	#define jmalloc(x,y) malloc(x)	20	#define jmalloc(x,y) malloc(x)

Lines 27-41 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/timage.hpp (-3 / +3 lines)
27		27
28	// if screen x & y offset already calculated save a mul	28	// if screen x & y offset already calculated save a mul
29	// and no clipping, but fast use this	29	// and no clipping, but fast use this
30	void put_image_offseted(image screen, uchar s_off);	30	void put_image_offseted(image screen, uint8_t s_off);
31	void put_image_filled(image *screen, int x, int y,	31	void put_image_filled(image *screen, int x, int y,
32	uchar fill_color);	32	uint8_t fill_color);
33	void put_fade(image *screen, int x, int y,	33	void put_fade(image *screen, int x, int y,
34	int frame_on, int total_frames,	34	int frame_on, int total_frames,
35	color_filter f, palette pal);	35	color_filter f, palette pal);
36	void put_fade_tint(image *screen, int x, int y,	36	void put_fade_tint(image *screen, int x, int y,
37	int frame_on, int total_frames,	37	int frame_on, int total_frames,
38	uchar *tint,	38	uint8_t *tint,
39	color_filter f, palette pal);	39	color_filter f, palette pal);
40	void put_color(image *screen, int x, int y, int color);	40	void put_color(image *screen, int x, int y, int color);
41	unsigned char clip_y(image screen, int x1, int y1, int x2, int y2,	41	unsigned char clip_y(image screen, int x1, int y1, int x2, int y2,

Lines 4-27 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/packet.hpp (-8 / +8 lines)
4	class packet	4	class packet
5	{	5	{
6	public :	6	public :
7	uchar *buf;	7	uint8_t *buf;
8	long buf_size,ro,wo,rend;	8	int32_t buf_size,ro,wo,rend;
9	int pre_size;	9	int pre_size;
10	void make_bigger(int max);	10	void make_bigger(int max);
11		11
12	int get_read_position() { return ro; }	12	int get_read_position() { return ro; }
13	void set_read_position(int x) { ro=x; }	13	void set_read_position(int x) { ro=x; }
14	int read(uchar *buffer, int size);	14	int read(uint8_t *buffer, int size);
15	int write(uchar *buffer, int size);	15	int write(uint8_t *buffer, int size);
16	int eop() { return ro>=rend; }	16	int eop() { return ro>=rend; }
17	void reset();	17	void reset();
18	packet(int prefix_size=2);	18	packet(int prefix_size=2);
19	void get_string(char *st, int len);	19	void get_string(char *st, int len);
20	int advance(long offset);	20	int advance(int32_t offset);
21		21
22	void write_long(ulong x); // writes can't fail...	22	void write_uint32(uint32_t x); // writes can't fail...
23	void write_short(ushort x);	23	void write_uint16(uint16_t x);
24	void write_byte(uchar x);	24	void write_uint8(uint8_t x);
25	void insert_into(packet &pk);	25	void insert_into(packet &pk);
26	int size() { return rend-pre_size; }	26	int size() { return rend-pre_size; }
27	~packet();	27	~packet();

Lines 18-27 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/image.hpp (-81 / +81 lines)
18	#define imWRITE_ERROR 7	18	#define imWRITE_ERROR 7
19	#define imMAX_ERROR 7	19	#define imMAX_ERROR 7
20		20
21	short current_error();	21	int16_t current_error();
22	void clear_errors();	22	void clear_errors();
23	void set_error(short x);	23	void set_error(int16_t x);
24	short last_error();	24	int16_t last_error();
25	void make_block(size_t size);	25	void make_block(size_t size);
26	void image_init();	26	void image_init();
27	void image_uninit();	27	void image_uninit();
Lines 29-37 Link Here
29		29
30	typedef struct image_color_t	30	typedef struct image_color_t
31	{	31	{
32	unsigned short r;	32	uint16_t r;
33	unsigned short g;	33	uint16_t g;
34	unsigned short b;	34	uint16_t b;
35	} image_color;	35	} image_color;
36		36
37	class filter;	37	class filter;
Lines 40-83 Link Here
40	class dirty_rect : public linked_node	40	class dirty_rect : public linked_node
41	{	41	{
42	public :	42	public :
43	short dx1,dy1,dx2,dy2;	43	int16_t dx1,dy1,dx2,dy2;
44	dirty_rect(short x1, short y1, short x2, short y2)	44	dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
45	{ dx1=x1; dy1=y1; dx2=x2; dy2=y2;	45	{ dx1=x1; dy1=y1; dx2=x2; dy2=y2;
46	if (x2<x1 \|\| y2<y1)	46	if (x2<x1 \|\| y2<y1)
47	printf("add inccorect dirty\n");	47	printf("add inccorect dirty\n");
48	}	48	}
49	virtual short compare(void *n1, short field)	49	virtual int16_t compare(void *n1, int16_t field)
50	{ return ((dirty_rect *)n1)->dy1>dy1; }	50	{ return ((dirty_rect *)n1)->dy1>dy1; }
51	} ;	51	} ;
52		52
53	class image_descriptor	53	class image_descriptor
54	{	54	{
55	short l,h;	55	int16_t l,h;
56	short clipx1, clipy1, clipx2, clipy2;	56	int16_t clipx1, clipy1, clipx2, clipy2;
57	public :	57	public :
58	unsigned char keep_dirt,	58	uint8_t keep_dirt,
59	static_mem; // if this flag is set then don't free memory on exit	59	static_mem; // if this flag is set then don't free memory on exit
60		60
61	linked_list dirties;	61	linked_list dirties;
62	void *extended_descriptor; // type depends on current system	62	void *extended_descriptor; // type depends on current system
63		63
64	image_descriptor(short length, short height,	64	image_descriptor(int16_t length, int16_t height,
65	int keep_dirties=1, int static_memory=0);	65	int keep_dirties=1, int static_memory=0);
66	short bound_x1(short x1) { return x1<clipx1 ? clipx1 : x1; }	66	int16_t bound_x1(int16_t x1) { return x1<clipx1 ? clipx1 : x1; }
67	short bound_y1(short y1) { return y1<clipy1 ? clipy1 : y1; }	67	int16_t bound_y1(int16_t y1) { return y1<clipy1 ? clipy1 : y1; }
68	short bound_x2(short x2) { return x2>clipx2 ? clipx2 : x2; }	68	int16_t bound_x2(int16_t x2) { return x2>clipx2 ? clipx2 : x2; }
69	short bound_y2(short y2) { return y2>clipy2 ? clipy2 : y2; }	69	int16_t bound_y2(int16_t y2) { return y2>clipy2 ? clipy2 : y2; }
70	short x1_clip() { return clipx1; }	70	int16_t x1_clip() { return clipx1; }
71	short y1_clip() { return clipy1; }	71	int16_t y1_clip() { return clipy1; }
72	short x2_clip() { return clipx2; }	72	int16_t x2_clip() { return clipx2; }
73	short y2_clip() { return clipy2; }	73	int16_t y2_clip() { return clipy2; }
74	void dirty_area(short x1, short y1, short x2, short y2) { ;}	74	void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ;}
75	void clean_area(short x1, short y1, short x2, short y2) { ; }	75	void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
76	void clear_dirties();	76	void clear_dirties();
77	short get_dirty_area(short &x1, short &y1, short &x2, short &y2) { return 0; }	77	int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2) { return 0; }
78	void get_clip(short &x1, short &y1, short &x2, short &y2)	78	void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
79	{ x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }	79	{ x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }
80	void set_clip(short x1, short y1, short x2, short y2)	80	void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
81	{ if (x2<x1) x2=x1;	81	{ if (x2<x1) x2=x1;
82	if (y2<y1) y2=y1;	82	if (y2<y1) y2=y1;
83	if (x1<0) clipx1=0; else clipx1=x1;	83	if (x1<0) clipx1=0; else clipx1=x1;
Lines 88-162 Link Here
88	void reduce_dirties();	88	void reduce_dirties();
89	void add_dirty(int x1, int y1, int x2, int y2);	89	void add_dirty(int x1, int y1, int x2, int y2);
90	void delete_dirty(int x1, int y1, int x2, int y2);	90	void delete_dirty(int x1, int y1, int x2, int y2);
91	void resize(short length, short height)	91	void resize(int16_t length, int16_t height)
92	{ l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }	92	{ l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }
93	} ;	93	} ;
94		94
95	class image : public linked_node	95	class image : public linked_node
96	{	96	{
97	unsigned char *data;	97	uint8_t *data;
98	short w,h;	98	int16_t w,h;
99	void make_page(short width, short height, unsigned char *page_buffer);	99	void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
100	void delete_page();	100	void delete_page();
101	public :	101	public :
102	image_descriptor *special;	102	image_descriptor *special;
103	image(spec_entry e, bFILE fp);	103	image(spec_entry e, bFILE fp);
104	image(bFILE *fp);	104	image(bFILE *fp);
105	image(short width, short height, // required	105	image(int16_t width, int16_t height, // required
106	unsigned char *page_buffer=NULL,	106	uint8_t *page_buffer=NULL,
107	short create_descriptor=0); // 0=no, 1=yes, 2=yes & keep dirties	107	int16_t create_descriptor=0); // 0=no, 1=yes, 2=yes & keep dirties
108	unsigned char pixel (short x, short y);	108	uint8_t pixel (int16_t x, int16_t y);
109	void putpixel (short x, short y, char color);	109	void putpixel (int16_t x, int16_t y, char color);
110	unsigned char scan_line (short y) { return data+yw; }	110	uint8_t scan_line (int16_t y) { return data+yw; }
111	unsigned char next_line (short lasty, unsigned char last_scan)	111	uint8_t next_line (int16_t lasty, uint8_t last_scan)
112	{ return last_scan+w; }	112	{ return last_scan+w; }
113	long total_pixels (unsigned char background=0);	113	int32_t total_pixels (uint8_t background=0);
114	image *copy (); // makes a copy of an image	114	image *copy (); // makes a copy of an image
115	void clear (short color=-1); // -1 is background color	115	void clear (int16_t color=-1); // -1 is background color
116	void to_24bit (palette &pal);	116	void to_24bit (palette &pal);
117	short width () { return (short)w; }	117	int16_t width () { return (int16_t)w; }
118	short height () { return (short)h; }	118	int16_t height () { return (int16_t)h; }
119	void scroll (short x1, short y1, short x2, short y2, short xd, short yd);	119	void scroll (int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd);
120	void fill_image (image *screen, short x1, short y1, short x2, short y2,	120	void fill_image (image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
121	short allign=1);	121	int16_t align=1);
122	void put_image (image *screen, short x, short y, char transparent=0);	122	void put_image (image *screen, int16_t x, int16_t y, char transparent=0);
123	void put_part (image *screen, short x, short y, short x1, short y1,	123	void put_part (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
124	short x2, short y2, char transparent=0);	124	int16_t x2, int16_t y2, char transparent=0);
125	void put_part_xrev (image *screen, short x, short y, short x1, short y1,	125	void put_part_xrev (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1,
126	short x2, short y2, char transparent=0);	126	int16_t x2, int16_t y2, char transparent=0);
127	void put_part_masked (image screen, image mask, short x, short y,	127	void put_part_masked (image screen, image mask, int16_t x, int16_t y,
128	short maskx, short masky, short x1, short y1, short x2, short y2);	128	int16_t maskx, int16_t masky, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
129	image *copy_part_dithered (short x1, short y1, short x2, short y2);	129	image *copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
130	void bar (short x1, short y1, short x2, short y2, unsigned char color);	130	void bar (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
131	void xor_bar (short x1, short y1, short x2, short y2, unsigned char color);	131	void xor_bar (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
132	void wiget_bar (short x1, short y1, short x2, short y2,	132	void wiget_bar (int16_t x1, int16_t y1, int16_t x2, int16_t y2,
133	unsigned char light, unsigned char med, unsigned char dark);	133	uint8_t light, uint8_t med, uint8_t dark);
134	void line (short x1, short y1, short x2, short y2, unsigned char color);	134	void line (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
135	void rectangle (short x1, short y1, short x2, short y2, unsigned char color);	135	void rectangle (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
136	void burn_led (short x, short y, long num, short color, short scale=1);	136	void burn_led (int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale=1);
137	void set_clip (short x1, short y1, short x2, short y2);	137	void set_clip (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
138	void get_clip (short &x1,short &y1,short &x2,short &y2);	138	void get_clip (int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
139	void in_clip (short x1, short y1, short x2, short y2);	139	void in_clip (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
140		140
141	void dirt_off () { if (special && special->keep_dirt) special->keep_dirt=0; }	141	void dirt_off () { if (special && special->keep_dirt) special->keep_dirt=0; }
142	void dirt_on () { if (special) special->keep_dirt=1; }	142	void dirt_on () { if (special) special->keep_dirt=1; }
143		143
144	void add_dirty (int x1, int y1, int x2, int y2)	144	void add_dirty (int x1, int y1, int x2, int y2)
145	{ if (special) special->add_dirty(x1,y1,x2,y2); }	145	{ if (special) special->add_dirty(x1,y1,x2,y2); }
146	void delete_dirty (int x1, int y1, int x2, int y2)	146	void delete_dirty (int x1, int y1, int x2, int y2)
147	{ if (special) special->delete_dirty(x1,y1,x2,y2); }	147	{ if (special) special->delete_dirty(x1,y1,x2,y2); }
148	void clear_dirties () { if (special) special->clear_dirties(); }	148	void clear_dirties () { if (special) special->clear_dirties(); }
149	void dither (palette *pal); // use a b&w palette!	149	void dither (palette *pal); // use a b&w palette!
150	void resize (short new_width, short new_height);	150	void resize (int16_t new_width, int16_t new_height);
151	void change_size (short new_width, short new_height, unsigned char *page=NULL);	151	void change_size (int16_t new_width, int16_t new_height, uint8_t *page=NULL);
152	void flood_fill (short x, short y, unsigned char color);	152	void flood_fill (int16_t x, int16_t y, uint8_t color);
153	image *create_smooth (short smoothness=1); // 0 no smoothness	153	image *create_smooth (int16_t smoothness=1); // 0 no smoothness
154	void unpack_scanline (short line, char bitsperpixel=1);	154	void unpack_scanline (int16_t line, char bitsperpixel=1);
155	unsigned char brightest_color (palette *pal);	155	uint8_t brightest_color (palette *pal);
156	void flip_x ();	156	void flip_x ();
157	void flip_y ();	157	void flip_y ();
158	void make_color (unsigned char color);	158	void make_color (uint8_t color);
159	unsigned char darkest_color (palette *pal, short noblack=0);	159	uint8_t darkest_color (palette *pal, int16_t noblack=0);
160		160
161	~image();	161	~image();
162	} ;	162	} ;

Lines 23-34 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/macs.hpp (-5 / +5 lines)
23	#define max(x,y) (x>y ? x:y)	23	#define max(x,y) (x>y ? x:y)
24	#endif	24	#endif
25		25
26	#define uchar unsigned char	26	//#define uchar unsigned char
27	#define schar signed char	27	//#define schar signed char
28	//#define ushort unsigned short	28	//#define ushort unsigned short
29	typedef unsigned short int ushort;	29	//typedef unsigned short int ushort;
30	#define sshort signed short	30	//#define sshort signed short
31	//#define ulong unsigned long	31	//#define ulong unsigned long
32	typedef unsigned long int ulong;	32	//typedef unsigned long int ulong;
33		33
34	#endif	34	#endif

Lines 6-11 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/include/specs.hpp (-17 / +18 lines)
6	#include "system.h"	6	#include "system.h"
7	#include <fcntl.h>	7	#include <fcntl.h>
8	#include <stdlib.h>	8	#include <stdlib.h>
		9	#include <stdint.h>
9		10
10	extern char *spec_types[];	11	extern char *spec_types[];
11		12
Lines 95-107 Link Here
95		96
96		97
97	// these read and writes, allways read/write Intel endian-ness	98	// these read and writes, allways read/write Intel endian-ness
98	unsigned short read_short();	99	uint16_t read_uint16();
99	unsigned long read_long();	100	uint32_t read_uint32();
100	unsigned char read_byte();	101	uint8_t read_uint8();
101	double read_double();	102	double read_double();
102	void write_short(unsigned short x);	103	void write_uint16(uint16_t x);
103	void write_long(unsigned long x);	104	void write_uint32(uint32_t x);
104	void write_byte(unsigned char x);	105	void write_uint8(uint8_t x);
105	void write_double(double x);	106	void write_double(double x);
106	void set_read_buffer_size(long size);	107	void set_read_buffer_size(long size);
107	} ;	108	} ;
Lines 192-208 Link Here
192	unsigned long data_size,	193	unsigned long data_size,
193	char link_filename=NULL);/	194	char link_filename=NULL);/
194		195
195	unsigned short read_short(FILE *fp);	196	uint16_t read_uint16(FILE *fp);
196	unsigned long read_long(FILE *fp);	197	uint32_t read_uint32(FILE *fp);
197	unsigned short read_other_long(FILE *fp);	198	uint32_t read_other_uint32(FILE *fp);
198	unsigned long read_other_short(FILE *fp);	199	uint16_t read_other_uint16(FILE *fp);
199	unsigned char read_byte(FILE *fp);	200	uint8_t read_uint8(FILE *fp);
200		201
201	void write_short(FILE *fp, unsigned short x);	202	void write_uint16(FILE *fp, uint16_t x);
202	void write_long(FILE *fp, unsigned long x);	203	void write_uint32(FILE *fp, uint32_t x);
203	void write_other_short(FILE *fp, unsigned short x);	204	void write_other_uint16(FILE *fp, uint16_t x);
204	void write_other_long(FILE *fp, unsigned long x);	205	void write_other_uint32(FILE *fp, uint32_t x);
205	void write_byte(FILE *fp, unsigned char x);	206	void write_uint8(FILE *fp, uint8_t x);
206		207
207	void set_spec_main_file(char *filename, int Search_order);	208	void set_spec_main_file(char *filename, int Search_order);
208	void set_file_opener(bFILE (open_fun)(char , char ));	209	void set_file_opener(bFILE (open_fun)(char , char ));

Lines 13-23 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/targa.cpp (-17 / +17 lines)
13	return 0;	13	return 0;
14	}	14	}
15		15
16	unsigned char id,color_map,im_type;	16	uint8_t id,color_map,im_type;
17		17
18	id=fp->read_byte();	18	id=fp->read_uint8();
19	color_map=fp->read_byte();	19	color_map=fp->read_uint8();
20	im_type=fp->read_byte();	20	im_type=fp->read_uint8();
21		21
22	if (color_map!=0)	22	if (color_map!=0)
23	{	23	{
Lines 31-48 Link Here
31	return 0;	31	return 0;
32	}	32	}
33		33
34	fp->read_short();	34	fp->read_uint16();
35	fp->read_short();	35	fp->read_uint16();
36	fp->read_byte();	36	fp->read_uint8();
37		37
38	fp->read_short();	38	fp->read_uint16();
39	fp->read_short();	39	fp->read_uint16();
40		40
41		41
42	int w=fp->read_short();	42	int w=fp->read_uint16();
43	int h=fp->read_short();	43	int h=fp->read_uint16();
44	unsigned char bpp=fp->read_byte();	44	uint8_t bpp=fp->read_uint8();
45	unsigned char im_des=fp->read_byte();	45	uint8_t im_des=fp->read_uint8();
46		46
47	if (bpp!=32)	47	if (bpp!=32)
48	{	48	{
Lines 53-60 Link Here
53	image *im=new image(w,h);	53	image *im=new image(w,h);
54		54
55	int x,y;	55	int x,y;
56	unsigned char ctrl;	56	uint8_t ctrl;
57	unsigned char bgra[4],*sl,c,lr,lg,lb,ll=0,lc;	57	uint8_t bgra[4],*sl,c,lr=0,lg=0,lb=0,ll=0,lc=0;
58		58
59		59
60		60
Lines 67-73 Link Here
67		67
68	for (x=0;x<w;)	68	for (x=0;x<w;)
69	{	69	{
70	ctrl=fp->read_byte();	70	ctrl=fp->read_uint8();
71	if (ctrl&0x80)	71	if (ctrl&0x80)
72	{	72	{
73	fp->read(bgra,4);	73	fp->read(bgra,4);

Lines 256-273 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/input.cpp (-5 / +5 lines)
256	{	256	{
257	case JK_LEFT : if (cur) { draw_cur(wm->dark_color(),screen,wm); cur--;	257	case JK_LEFT : if (cur) { draw_cur(wm->dark_color(),screen,wm); cur--;
258	draw_cur(wm->bright_color(),screen,wm); } break;	258	draw_cur(wm->bright_color(),screen,wm); } break;
259	case JK_RIGHT : if (cur<strlen(format)-1) { draw_cur(wm->dark_color(),screen,wm); cur++;	259	case JK_RIGHT : if (cur<(int)strlen(format)-1) { draw_cur(wm->dark_color(),screen,wm); cur++;
260	draw_cur(wm->bright_color(),screen,wm); } break;	260	draw_cur(wm->bright_color(),screen,wm); } break;
261	case JK_END : if (cur!=last_spot())	261	case JK_END : if (cur!=last_spot())
262	{ draw_cur(wm->dark_color(),screen,wm); cur=last_spot();	262	{ draw_cur(wm->dark_color(),screen,wm); cur=last_spot();
263	if (cur==strlen(format)-1) cur--;	263	if (cur==(int)strlen(format)-1) cur--;
264	draw_cur(wm->bright_color(),screen,wm); } break;	264	draw_cur(wm->bright_color(),screen,wm); } break;
265	case JK_HOME : if (cur)	265	case JK_HOME : if (cur)
266	{ draw_cur(wm->dark_color(),screen,wm); cur=0;	266	{ draw_cur(wm->dark_color(),screen,wm); cur=0;
267	draw_cur(wm->bright_color(),screen,wm); } break;	267	draw_cur(wm->bright_color(),screen,wm); } break;
268	case JK_BACKSPACE : if (cur)	268	case JK_BACKSPACE : if (cur)
269	{ draw_cur(wm->dark_color(),screen,wm); cur--;	269	{ draw_cur(wm->dark_color(),screen,wm); cur--;
270	for (xx=cur;xx<strlen(format)-1;xx++)	270	for (xx=cur;xx<(int)strlen(format)-1;xx++)
271	data[xx]=data[xx+1];	271	data[xx]=data[xx+1];
272	data[strlen(format)-1]=' ';	272	data[strlen(format)-1]=' ';
273	draw_text(screen,wm);	273	draw_text(screen,wm);
Lines 280-286 Link Here
280	for (xx=strlen(format)-1;xx>cur && xx>0;xx--)	280	for (xx=strlen(format)-1;xx>cur && xx>0;xx--)
281	data[xx]=data[xx-1];	281	data[xx]=data[xx-1];
282	data[cur]=ev.key;	282	data[cur]=ev.key;
283	if (cur<strlen(format)-1)	283	if (cur<(int)strlen(format)-1)
284	cur++;	284	cur++;
285	data[strlen(format)]=0;	285	data[strlen(format)]=0;
286	draw_text(screen,wm);	286	draw_text(screen,wm);
Lines 334-340 Link Here
334	double Data, ifield *Next)	334	double Data, ifield *Next)
335	{	335	{
336	char num[20];	336	char num[20];
337	sprintf(num,"%Lg",Data);	337	sprintf(num,"%g",Data);
338	int slen=(strlen(Format)>strlen(num) ? strlen(Format) : strlen(num));	338	int slen=(strlen(Format)>strlen(num) ? strlen(Format) : strlen(num));
339	x=X; y=Y; id=ID;	339	x=X; y=Y; id=ID;
340	prompt=strcpy((char *)jmalloc(strlen(Prompt)+1,"text_field::prompt"),Prompt);	340	prompt=strcpy((char *)jmalloc(strlen(Prompt)+1,"text_field::prompt"),Prompt);

Lines 14-43 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/gifread.cpp (-32 / +32 lines)
14		14
15		15
16	struct {	16	struct {
17	unsigned short int Width;	17	uint16_t Width;
18	unsigned short int Height;	18	uint16_t Height;
19	unsigned char ColorMap[3][256];	19	uint8_t ColorMap[3][256];
20	unsigned short int BitPixel;	20	uint16_t BitPixel;
21	unsigned short int ColorResolution;	21	uint16_t ColorResolution;
22	unsigned short int Background;	22	uint16_t Background;
23	unsigned short int AspectRatio;	23	uint16_t AspectRatio;
24	} GifScreen;	24	} GifScreen;
25		25
26	struct {	26	struct {
27	unsigned short int w,h;	27	uint16_t w,h;
28	unsigned char color_info,background,reserved;	28	uint8_t color_info,background,reserved;
29	} gif_screen;	29	} gif_screen;
30		30
31	struct {	31	struct {
32	unsigned short int xoff,yoff,w,h;	32	uint16_t xoff,yoff,w,h;
33	unsigned char color_info;	33	uint8_t color_info;
34	} gif_image;	34	} gif_image;
35		35
36	image read_gif(char fn, palette *&pal)	36	image read_gif(char fn, palette *&pal)
37	{	37	{
38	char buf[100],er;	38	char buf[100],er;
39	unsigned char sep;	39	uint8_t sep;
40	int ncolors;	40	unsigned int ncolors;
41	FILE *fp;	41	FILE *fp;
42	image *im;	42	image *im;
43	clear_errors();	43	clear_errors();
Lines 52-64 Link Here
52	buf[6]=0;	52	buf[6]=0;
53	if (!strcmp("GIF87a",buf))	53	if (!strcmp("GIF87a",buf))
54	{	54	{
55	fread((char *)&gif_screen.w,2,1,fp);	55	fread((uint8_t *)&gif_screen.w,2,1,fp);
56	gif_screen.w=int_to_local(gif_screen.w);	56	gif_screen.w=uint16_to_local(gif_screen.w);
57	fread((char *)&gif_screen.h,2,1,fp);	57	fread((uint8_t *)&gif_screen.h,2,1,fp);
58	gif_screen.h=int_to_local(gif_screen.h);	58	gif_screen.h=uint16_to_local(gif_screen.h);
59	fread((char *)&gif_screen.color_info,1,1,fp);	59	fread((uint8_t *)&gif_screen.color_info,1,1,fp);
60	fread((char *)&gif_screen.background,1,1,fp);	60	fread((uint8_t *)&gif_screen.background,1,1,fp);
61	if (fread((char *)&gif_screen.reserved,1,1,fp)==1)	61	if (fread((uint8_t *)&gif_screen.reserved,1,1,fp)==1)
62	{	62	{
63	if (gif_screen.color_info&128)	63	if (gif_screen.color_info&128)
64	{	64	{
Lines 68-91 Link Here
68	pal=new palette(256);	68	pal=new palette(256);
69	if (pal)	69	if (pal)
70	{	70	{
71	if (fread((char )pal->addr(),1,ncolors3,fp)!=ncolors*3) er=imREAD_ERROR;	71	if (fread((uint8_t )pal->addr(),1,ncolors3,fp)!=ncolors*3) er=imREAD_ERROR;
72	} else er=imMEMORY_ERROR;	72	} else er=imMEMORY_ERROR;
73	}	73	}
74	if (!er)	74	if (!er)
75	{ do	75	{ do
76	{	76	{
77	if (fread((char *)&sep,1,1,fp)!=1)	77	if (fread((uint8_t *)&sep,1,1,fp)!=1)
78	er=imREAD_ERROR;	78	er=imREAD_ERROR;
79	} while (!er && sep!=',');	79	} while (!er && sep!=',');
80	fread((char *)&gif_image.xoff,2,1,fp);	80	fread((uint8_t *)&gif_image.xoff,2,1,fp);
81	gif_image.xoff=int_to_local(gif_image.xoff);	81	gif_image.xoff=uint16_to_local(gif_image.xoff);
82	fread((char *)&gif_image.yoff,2,1,fp);	82	fread((uint8_t *)&gif_image.yoff,2,1,fp);
83	gif_image.yoff=int_to_local(gif_image.yoff);	83	gif_image.yoff=uint16_to_local(gif_image.yoff);
84	fread((char *)&gif_image.w,2,1,fp);	84	fread((uint8_t *)&gif_image.w,2,1,fp);
85	gif_image.w=int_to_local(gif_image.w);	85	gif_image.w=uint16_to_local(gif_image.w);
86	fread((char *)&gif_image.h,2,1,fp);	86	fread((uint8_t *)&gif_image.h,2,1,fp);
87	gif_image.h=int_to_local(gif_image.h);	87	gif_image.h=uint16_to_local(gif_image.h);
88	if (!er && (fread((char *)&gif_image.color_info,1,1,fp)==1))	88	if (!er && (fread((uint8_t *)&gif_image.color_info,1,1,fp)==1))
89	{	89	{
90	if (gif_image.color_info&128)	90	if (gif_image.color_info&128)
91	{	91	{
Lines 94-100 Link Here
94	make_block(sizeof(palette));	94	make_block(sizeof(palette));
95	pal = new palette(ncolors);	95	pal = new palette(ncolors);
96	if (pal)	96	if (pal)
97	{ if (fread((char )pal->addr(),1,ncolors3,fp)!=ncolors*3) er=imREAD_ERROR;	97	{ if (fread((uint8_t )pal->addr(),1,ncolors3,fp)!=ncolors*3) er=imREAD_ERROR;
98	} else er=imMEMORY_ERROR;	98	} else er=imMEMORY_ERROR;
99	}	99	}
100		100

Lines 171-177 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/filter.cpp (-4 / +4 lines)
171	color_filter::color_filter(spec_entry e, bFILE fp)	171	color_filter::color_filter(spec_entry e, bFILE fp)
172	{	172	{
173	fp->seek(e->offset,0);	173	fp->seek(e->offset,0);
174	fp->read_short();	174	fp->read_uint16();
175	int colors=32;	175	int colors=32;
176	color_table=(unsigned char )jmalloc(colorscolors*colors,"color_filter : loaded");	176	color_table=(unsigned char )jmalloc(colorscolors*colors,"color_filter : loaded");
177	fp->read(color_table,colorscolorscolors);	177	fp->read(color_table,colorscolorscolors);
Lines 186-192 Link Here
186	int color_filter::write(bFILE *fp)	186	int color_filter::write(bFILE *fp)
187	{	187	{
188	int colors=32;	188	int colors=32;
189	fp->write_short(colors);	189	fp->write_uint16(colors);
190	return fp->write(color_table,colorscolorscolors)==colorscolorscolors;	190	return fp->write(color_table,colorscolorscolors)==colorscolorscolors;
191	}	191	}
192		192
Lines 219-226 Link Here
219		219
220	screen->add_dirty(x,y,x+xl-1,y+yl-1);	220	screen->add_dirty(x,y,x+xl-1,y+yl-1);
221		221
222	uchar pg1=screen->scan_line(y),source,*dest;	222	uint8_t pg1=screen->scan_line(y),source,*dest;
223	uchar *pg2=im->scan_line(y1);	223	uint8_t *pg2=im->scan_line(y1);
224	int i;	224	int i;
225	for (int j=0;j<yl;j++)	225	for (int j=0;j<yl;j++)
226	{	226	{

Lines 17-33 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/pcxread.cpp (-16 / +16 lines)
17	if (!fread(&PCX_header.version,1,1,fp)) return 0;	17	if (!fread(&PCX_header.version,1,1,fp)) return 0;
18	if (!fread(&PCX_header.encoding,1,1,fp)) return 0;	18	if (!fread(&PCX_header.encoding,1,1,fp)) return 0;
19	if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0;	19	if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0;
20	PCX_header.xmin=read_short(fp);	20	PCX_header.xmin=read_uint16(fp);
21	PCX_header.ymin=read_short(fp);	21	PCX_header.ymin=read_uint16(fp);
22	PCX_header.xmax=read_short(fp);	22	PCX_header.xmax=read_uint16(fp);
23	PCX_header.ymax=read_short(fp);	23	PCX_header.ymax=read_uint16(fp);
24	PCX_header.hres=read_short(fp);	24	PCX_header.hres=read_uint16(fp);
25	PCX_header.vres=read_short(fp);	25	PCX_header.vres=read_uint16(fp);
26	if (!fread(PCX_header.palette,1,48,fp)) return 0;	26	if (!fread(PCX_header.palette,1,48,fp)) return 0;
27	if (!fread(&PCX_header.reserved,1,1,fp)) return 0;	27	if (!fread(&PCX_header.reserved,1,1,fp)) return 0;
28	if (!fread(&PCX_header.color_planes,1,1,fp)) return 0;	28	if (!fread(&PCX_header.color_planes,1,1,fp)) return 0;
29	PCX_header.bytes_per_line=read_short(fp);	29	PCX_header.bytes_per_line=read_uint16(fp);
30	PCX_header.palette_type=read_short(fp);	30	PCX_header.palette_type=read_uint16(fp);
31	if (!fread(PCX_header.filter,1,58,fp)) return 0;	31	if (!fread(PCX_header.filter,1,58,fp)) return 0;
32	return 1;	32	return 1;
33	}	33	}
Lines 38-54 Link Here
38	if (!fwrite(&PCX_header.version,1,1,fp)) return 0;	38	if (!fwrite(&PCX_header.version,1,1,fp)) return 0;
39	if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0;	39	if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0;
40	if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0;	40	if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0;
41	write_short(fp,PCX_header.xmin);	41	write_uint16(fp,PCX_header.xmin);
42	write_short(fp,PCX_header.ymin);	42	write_uint16(fp,PCX_header.ymin);
43	write_short(fp,PCX_header.xmax);	43	write_uint16(fp,PCX_header.xmax);
44	write_short(fp,PCX_header.ymax);	44	write_uint16(fp,PCX_header.ymax);
45	write_short(fp,PCX_header.hres);	45	write_uint16(fp,PCX_header.hres);
46	write_short(fp,PCX_header.vres);	46	write_uint16(fp,PCX_header.vres);
47	if (!fwrite(PCX_header.palette,1,48,fp)) return 0;	47	if (!fwrite(PCX_header.palette,1,48,fp)) return 0;
48	if (!fwrite(&PCX_header.reserved,1,1,fp)) return 0;	48	if (!fwrite(&PCX_header.reserved,1,1,fp)) return 0;
49	if (!fwrite(&PCX_header.color_planes,1,1,fp)) return 0;	49	if (!fwrite(&PCX_header.color_planes,1,1,fp)) return 0;
50	write_short(fp,PCX_header.bytes_per_line);	50	write_uint16(fp,PCX_header.bytes_per_line);
51	write_short(fp,PCX_header.palette_type);	51	write_uint16(fp,PCX_header.palette_type);
52	if (!fwrite(PCX_header.filter,1,58,fp)) return 0;	52	if (!fwrite(PCX_header.filter,1,58,fp)) return 0;
53	return 1;	53	return 1;
54	}	54	}

Lines 37-66 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/readwav.cpp (-18 / +18 lines)
37	void read_chunk(wav_chunk &chunk, bFILE *fp)	37	void read_chunk(wav_chunk &chunk, bFILE *fp)
38	{	38	{
39	fp->read(&chunk.id,4);	39	fp->read(&chunk.id,4);
40	chunk.size=fp->read_long();	40	chunk.size=fp->read_uint32();
41	fp->read(&chunk.type,4);	41	fp->read(&chunk.type,4);
42	}	42	}
43		43
44	void read_tag(wav_tag &tag, bFILE *fp)	44	void read_tag(wav_tag &tag, bFILE *fp)
45	{	45	{
46	fp->read(&tag.id,4);	46	fp->read(&tag.id,4);
47	tag.size=fp->read_long();	47	tag.size=fp->read_uint32();
48	}	48	}
49		49
50	void read_wav_format(wav_format &fmt, bFILE *fp)	50	void read_wav_format(wav_format &fmt, bFILE *fp)
51	{	51	{
52	fmt.fmt_tag=fp->read_short();	52	fmt.fmt_tag=fp->read_uint16();
53	fmt.channels=fp->read_short();	53	fmt.channels=fp->read_uint16();
54	fmt.samplesps=fp->read_long();	54	fmt.samplesps=fp->read_uint32();
55	fmt.avg_bytesps=fp->read_long();	55	fmt.avg_bytesps=fp->read_uint32();
56	fmt.align=fp->read_short();	56	fmt.align=fp->read_uint16();
57	}	57	}
58		58
59		59
60	void read_pcm(pcm_wave &pcm, bFILE *fp)	60	void read_pcm(pcm_wave &pcm, bFILE *fp)
61	{	61	{
62	read_wav_format(pcm.wf,fp);	62	read_wav_format(pcm.wf,fp);
63	pcm.bitsps=fp->read_short();	63	pcm.bitsps=fp->read_uint16();
64	}	64	}
65		65
66		66
Lines 77-102 Link Here
77		77
78	/************* Write the chunk *************************/	78	/************* Write the chunk *************************/
79	fp->write((void *)"RIFF",4);	79	fp->write((void *)"RIFF",4);
80	fp->write_long(data_size+36);	80	fp->write_uint32(data_size+36);
81	fp->write((void *)"WAVE",4);	81	fp->write((void *)"WAVE",4);
82		82
83		83
84	/************ Write the tag *****************************/	84	/************ Write the tag *****************************/
85	fp->write((void *)"fmt ",4);	85	fp->write((void *)"fmt ",4);
86	fp->write_long(16);	86	fp->write_uint32(16);
87		87
88		88
89	/************ Write PCM *********************************/	89	/************ Write PCM *********************************/
90	fp->write_short(1); // format_tag	90	fp->write_uint16(1); // format_tag
91	fp->write_short(1); // mono recording	91	fp->write_uint16(1); // mono recording
92	fp->write_long(sample_rate);	92	fp->write_uint32(sample_rate);
93	fp->write_long(sample_rate); // average bytes per sec	93	fp->write_uint32(sample_rate); // average bytes per sec
94	fp->write_short(1); // allignment? Don't know what this does?	94	fp->write_uint16(1); // alignment? Don't know what this does?
95	fp->write_short(8); // 8 bits per sample	95	fp->write_uint16(8); // 8 bits per sample
96		96
97	/*********** Write data tag ****************************/	97	/*********** Write data tag ****************************/
98	fp->write((void *)"data",4);	98	fp->write((void *)"data",4);
99	fp->write_long(data_size);	99	fp->write_uint32(data_size);
100		100
101	/********** Now write sample data **********************/	101	/********** Now write sample data **********************/
102	fp->write(data,data_size);	102	fp->write(data,data_size);
Lines 154-160 Link Here
154	ERROR((unsigned int)fp->read(data,tag.size)==tag.size,"Premature end of file");	154	ERROR((unsigned int)fp->read(data,tag.size)==tag.size,"Premature end of file");
155	ERROR(pcm.bitsps==8,"Only 8-bit samples supported");	155	ERROR(pcm.bitsps==8,"Only 8-bit samples supported");
156	ERROR(pcm.wf.channels==1,"Only mono samples supported");	156	ERROR(pcm.wf.channels==1,"Only mono samples supported");
157	ERROR(pcm.wf.align==1,"Bad block allignment");	157	ERROR(pcm.wf.align==1,"Bad block alignment");
158	delete fp;	158	delete fp;
159	return data;	159	return data;
160	}	160	}

Lines 122-146 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/xwdread.cpp (-61 / +56 lines)
122	int bits_per_item, bits_used, bit_shift, bits_per_pixel, pixel_mask;	122	int bits_per_item, bits_used, bit_shift, bits_per_pixel, pixel_mask;
123	int bit_order, byte_swap;	123	int bit_order, byte_swap;
124	char buf[4];	124	char buf[4];
125	unsigned char *byteP;	125	uint8_t *byteP;
126	unsigned short *shortP;	126	uint16_t *shortP;
127	unsigned long *longP;	127	uint32_t *longP;
128		128
129		129
130	int bs_int(int s);	130	uint32_t bs_uint32(uint32_t s);
131	long bs_long(long s);	131	uint16_t bs_uint16(uint16_t s );
132	short bs_short(short s );
133		132
134		133
135	image getinit(FILE file, palette &pal, int padrightP)	134	image getinit(FILE file, palette &pal, int padrightP)
136	{	135	{
137	/* Assume X11 headers are larger than X10 ones. */	136	/* Assume X11 headers are larger than X10 ones. */
138	unsigned char header[sizeof(X11WDFileHeader)];	137	uint8_t header[sizeof(X11WDFileHeader)];
139	image *im;	138	image *im;
140	X11WDFileHeader *h11P;	139	X11WDFileHeader *h11P;
141	char junk[800];	140	char junk[800];
142	int i, dummy1, dummy2, dummy3;	141	unsigned int i;
143	unsigned short minred, maxred;	142	int dummy1, dummy2, dummy3;
		143	uint16_t minred, maxred;
144	X11XColor x11col;	144	X11XColor x11col;
145		145
146	h11P = (X11WDFileHeader *) header;	146	h11P = (X11WDFileHeader *) header;
Lines 273-288 Link Here
273	bit_order = h11P->bitmap_bit_order;	273	bit_order = h11P->bitmap_bit_order;
274	pixel_mask = ( 1 << bits_per_pixel ) - 1;	274	pixel_mask = ( 1 << bits_per_pixel ) - 1;
275		275
276	byteP = (unsigned char *) buf;	276	byteP = (uint8_t *) buf;
277	shortP = (unsigned short *) buf;	277	shortP = (uint16_t *) buf;
278	longP = (unsigned long *) buf;	278	longP = (uint32_t *) buf;
279	return im;	279	return im;
280	}	280	}
281		281
282	void getimage(FILE file,image im,int pad)	282	void getimage(FILE file,image im,int pad)
283	{	283	{
284	int i,j;	284	int i,j;
285	unsigned char *sl;	285	uint8_t *sl;
286	#if BYTE_ORDER!=BIG_ENDIAN	286	#if BYTE_ORDER!=BIG_ENDIAN
287	printf("little guys\n");	287	printf("little guys\n");
288	#endif	288	#endif
Lines 312-320 Link Here
312	case 8:	312	case 8:
313	break;	313	break;
314		314
315	case 16: shortP=short_swap(shortP); break;	315	case 16: shortP=uint16_swap(shortP); break;
316		316
317	case 32: longP=long_swap(longP); break;	317	case 32: longP=uint32_swap(longP); break;
318		318
319	default:	319	default:
320	fprintf(stderr, "can't happen" );	320	fprintf(stderr, "can't happen" );
Lines 355-380 Link Here
355	}	355	}
356		356
357		357
358	short bs_short(short s )	358	uint16_t bs_uint16(uint16_t s )
359	{	359	{
360	short ss;	360	uint16_t ss;
361	unsigned char *bp, t;	361	uint8_t *bp, t;
362		362
363	ss = s;	363	ss = s;
364	bp = (unsigned char *) &ss;	364	bp = (uint8_t *) &ss;
365	t = bp[0];	365	t = bp[0];
366	bp[0] = bp[1];	366	bp[0] = bp[1];
367	bp[1] = t;	367	bp[1] = t;
368	return ss;	368	return ss;
369	}	369	}
370		370
371	int bs_int(int i )	371	uint32_t bs_uint32(uint32_t l )
372	{	372	{
373	int ii;	373	uint32_t ii;
374	unsigned char *bp, t;	374	uint8_t *bp, t;
375		375
376	ii = i;	376	ii = l;
377	bp = (unsigned char *) &ii;	377	bp = (uint8_t *) &ii;
378	t = bp[0];	378	t = bp[0];
379	bp[0] = bp[3];	379	bp[0] = bp[3];
380	bp[3] = t;	380	bp[3] = t;
Lines 384-401 Link Here
384	return ii;	384	return ii;
385	}	385	}
386		386
387	long bs_long(long l )
388	{
389	return bs_int( l );
390	}
391
392	struct BMP_header	387	struct BMP_header
393	{	388	{
394	char id[2];	389	char id[2];
395	long filesize;	390	long filesize;
396	short reserved[2];	391	int16_t reserved[2];
397	long headersize,infosize,width,height;	392	long headersize,infosize,width,height;
398	short biplanes,bits;	393	int16_t biplanes,bits;
399	long bicompression, bisizeimage, bixpelspermeter, biypelspermeter,	394	long bicompression, bisizeimage, bixpelspermeter, biypelspermeter,
400	biclrused,biclrimportant;	395	biclrused,biclrimportant;
401	} bmp;	396	} bmp;
Lines 403-422 Link Here
403	int read_BMP_header(FILE *fp)	398	int read_BMP_header(FILE *fp)
404	{	399	{
405	if (!fread(&bmp.id,1,2,fp)) return 0; // 2 0	400	if (!fread(&bmp.id,1,2,fp)) return 0; // 2 0
406	bmp.filesize=read_long(fp); // 4 4	401	bmp.filesize=read_uint32(fp); // 4 4
407	if (!fread(bmp.reserved,1,4,fp)) return 0; // 4 8	402	if (!fread(bmp.reserved,1,4,fp)) return 0; // 4 8
408	bmp.headersize=read_long(fp); // 4 12	403	bmp.headersize=read_uint32(fp); // 4 12
409	bmp.infosize=read_long(fp); // 4 16	404	bmp.infosize=read_uint32(fp); // 4 16
410	bmp.width=read_long(fp); // 4 20	405	bmp.width=read_uint32(fp); // 4 20
411	bmp.height=read_long(fp); // 4 24	406	bmp.height=read_uint32(fp); // 4 24
412	bmp.biplanes=read_short(fp); // 2 26	407	bmp.biplanes=read_uint16(fp); // 2 26
413	bmp.bits=read_short(fp); // 2 28	408	bmp.bits=read_uint16(fp); // 2 28
414	bmp.bicompression=read_long(fp); // 4 32	409	bmp.bicompression=read_uint32(fp); // 4 32
415	bmp.bisizeimage=read_long(fp); // 4 36	410	bmp.bisizeimage=read_uint32(fp); // 4 36
416	bmp.bixpelspermeter=read_long(fp); // 4 40	411	bmp.bixpelspermeter=read_uint32(fp); // 4 40
417	bmp.biypelspermeter=read_long(fp); // 4 44	412	bmp.biypelspermeter=read_uint32(fp); // 4 44
418	bmp.biclrused=read_long(fp); // 4 48	413	bmp.biclrused=read_uint32(fp); // 4 48
419	bmp.biclrimportant=read_long(fp); // 4 52	414	bmp.biclrimportant=read_uint32(fp); // 4 52
420	return 1;	415	return 1;
421		416
422	}	417	}
Lines 458-468 Link Here
458	if (!im)	453	if (!im)
459	return NULL;	454	return NULL;
460		455
461	unsigned char *sl;	456	uint8_t *sl;
462	int trailer=im->width()%4;	457	int trailer=im->width()%4;
463	if (trailer==1) trailer=3;	458	if (trailer==1) trailer=3;
464	else if (trailer==3) trailer=1;	459	else if (trailer==3) trailer=1;
465	uchar buf[9];	460	uint8_t buf[9];
466	for (i=im->height();i;i--)	461	for (i=im->height();i;i--)
467	{	462	{
468	sl=im->scan_line(i-1);	463	sl=im->scan_line(i-1);
Lines 485-491 Link Here
485	{	480	{
486	image *im;	481	image *im;
487	FILE *fp;	482	FILE *fp;
488	unsigned char pal_quad[4];	483	uint8_t pal_quad[4];
489	char *scrap;	484	char *scrap;
490	int bytes,i;	485	int bytes,i;
491	fp=fopen(filename,"rb");	486	fp=fopen(filename,"rb");
Lines 528-547 Link Here
528	int write_BMP_header(FILE *fp)	523	int write_BMP_header(FILE *fp)
529	{	524	{
530	if (!fwrite(&bmp.id,1,2,fp)) return 0;	525	if (!fwrite(&bmp.id,1,2,fp)) return 0;
531	write_long(fp,bmp.filesize);	526	write_uint32(fp,bmp.filesize);
532	if (!fwrite(bmp.reserved,1,4,fp)) return 0;	527	if (!fwrite(bmp.reserved,1,4,fp)) return 0;
533	write_long(fp,bmp.headersize);	528	write_uint32(fp,bmp.headersize);
534	write_long(fp,bmp.infosize);	529	write_uint32(fp,bmp.infosize);
535	write_long(fp,bmp.width);	530	write_uint32(fp,bmp.width);
536	write_long(fp,bmp.height);	531	write_uint32(fp,bmp.height);
537	write_short(fp,bmp.biplanes);	532	write_uint16(fp,bmp.biplanes);
538	write_short(fp,bmp.bits);	533	write_uint16(fp,bmp.bits);
539	write_long(fp,bmp.bicompression);	534	write_uint32(fp,bmp.bicompression);
540	write_long(fp,bmp.bisizeimage);	535	write_uint32(fp,bmp.bisizeimage);
541	write_long(fp,bmp.bixpelspermeter);	536	write_uint32(fp,bmp.bixpelspermeter);
542	write_long(fp,bmp.biypelspermeter);	537	write_uint32(fp,bmp.biypelspermeter);
543	write_long(fp,bmp.biclrused);	538	write_uint32(fp,bmp.biclrused);
544	write_long(fp,bmp.biclrimportant);	539	write_uint32(fp,bmp.biclrimportant);
545	return 1;	540	return 1;
546		541
547	}	542	}
Lines 550-556 Link Here
550	{	545	{
551	FILE *fp;	546	FILE *fp;
552	int i,bytes;	547	int i,bytes;
553	unsigned char pal_quad[4];	548	uint8_t pal_quad[4];
554	fp=fopen(filename,"wb");	549	fp=fopen(filename,"wb");
555	if (!fp)	550	if (!fp)
556	{ printf("Error : unable to open %s for writing!\n",filename);	551	{ printf("Error : unable to open %s for writing!\n",filename);

Lines 105-113 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/readxwd.cpp (-20 / +14 lines)
105	long *longP;	105	long *longP;
106		106
107		107
108	int bs_int(int s);	108	int32_t bs_int32(int32_t s);
109	long bs_long(long s);	109	int16_t bs_int16(int16_t s );
110	short bs_short(short s );
111		110
112		111
113	HBITMAP getinit(FILE file, palette &pal, int *padrightP, int &xres, int &yres);)	112	HBITMAP getinit(FILE file, palette &pal, int *padrightP, int &xres, int &yres);)
Lines 324-330 Link Here
324	}	323	}
325		324
326		325
327	short bs_short(short s )	326	short bs_int16(short s )
328	{	327	{
329	short ss;	328	short ss;
330	unsigned char *bp, t;	329	unsigned char *bp, t;
Lines 337-349 Link Here
337	return ss;	336	return ss;
338	}	337	}
339		338
340	int bs_int(int i )	339	int32_t bs_int32(int32_t l )
341	{	340	{
342	int ii;	341	int32_t ii;
343	unsigned char *bp, t;	342	uint8_t *bp, t;
344		343
345	ii = i;	344	ii = i;
346	bp = (unsigned char *) &ii;	345	bp = (uint8_t *) &ii;
347	t = bp[0];	346	t = bp[0];
348	bp[0] = bp[3];	347	bp[0] = bp[3];
349	bp[3] = t;	348	bp[3] = t;
Lines 353-363 Link Here
353	return ii;	352	return ii;
354	}	353	}
355		354
356	long bs_long(long l )
357	{
358	return bs_int( l );
359	}
360
361	struct BMP_header	355	struct BMP_header
362	{	356	{
363	char id[2];	357	char id[2];
Lines 373-379 Link Here
373	{	367	{
374	FILE *fp;	368	FILE *fp;
375	int i,bytes;	369	int i,bytes;
376	unsigned char pal_quad[4];	370	uint8_t pal_quad[4];
377	// fp=fopen("d:\\windows\\256color.bmp","rb");	371	// fp=fopen("d:\\windows\\256color.bmp","rb");
378	// fread(&bmp,1,sizeof(bmp),fp);	372	// fread(&bmp,1,sizeof(bmp),fp);
379	// fclose(fp);	373	// fclose(fp);
Lines 410-418 Link Here
410	image image24(image im, palette *pal, int rev)	404	image image24(image im, palette *pal, int rev)
411	{	405	{
412	image *ni;	406	image *ni;
413	unsigned char sl1,sl2;	407	uint8_t sl1,sl2;
414	int i,x;	408	int i,x;
415	unsigned char r,g,b;	409	uint8_t r,g,b;
416	printf("Creating image size (%d, %d)\n",im->width()*3,im->height());	410	printf("Creating image size (%d, %d)\n",im->width()*3,im->height());
417	ni=new image(im->width()*3,im->height());	411	ni=new image(im->width()*3,im->height());
418	printf("Image created\n");	412	printf("Image created\n");
Lines 428-434 Link Here
428	return ni;	422	return ni;
429	}	423	}
430		424
431	unsigned char addb(int n1, int n2)	425	uint8_t addb(int n1, int n2)
432	{ int n3;	426	{ int n3;
433	n3=n1+n2;	427	n3=n1+n2;
434	return n3>255 ? 255 : (n3<0 ? 0 : n3);	428	return n3>255 ? 255 : (n3<0 ? 0 : n3);
Lines 440-446 Link Here
440	image color_dither(image im, palette *pal, int rev)	434	image color_dither(image im, palette *pal, int rev)
441	{	435	{
442	image *i24;	436	image *i24;
443	unsigned char min[3],max[3],mid[3],ad,sl,*sl2,crimp;	437	uint8_t min[3],max[3],mid[3],ad,sl,*sl2,crimp;
444	int i,j,x,y,delta;	438	int i,j,x,y,delta;
445	(void *)ad=pal->addr();	439	(void *)ad=pal->addr();
446		440
Lines 522-531 Link Here
522	display=0,bad=0,bmp=0,land=0,ch,xo=0,yo=0;	516	display=0,bad=0,bmp=0,land=0,ch,xo=0,yo=0;
523	image im,i24;	517	image im,i24;
524	palette *pal;	518	palette *pal;
525	unsigned char *sl;	519	uint8_t *sl;
526	FILE *fp;	520	FILE *fp;
527	char def_name[10],dev_name,fname=NULL;	521	char def_name[10],dev_name,fname=NULL;
528	unsigned char cp[500],mp[500],yp[500],kp[500];	522	uint8_t cp[500],mp[500],yp[500],kp[500];
529	strcpy(def_name,"\\dev\\lp"); // set the default output device to /dev/lp	523	strcpy(def_name,"\\dev\\lp"); // set the default output device to /dev/lp
530	// since we are in vpix, however we will use the backslash	524	// since we are in vpix, however we will use the backslash
531	dev_name=def_name; rev=0;	525	dev_name=def_name; rev=0;

Lines 11-17 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/palette.cpp (-12 / +16 lines)
11		11
12	palette::palette(bFILE *fp)	12	palette::palette(bFILE *fp)
13	{	13	{
14	ncolors=fp->read_short();	14	ncolors=fp->read_uint16();
15	pal=(color )jmalloc(sizeof(color)ncolors,"palette");	15	pal=(color )jmalloc(sizeof(color)ncolors,"palette");
16	usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");	16	usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
17	set_all_unused();	17	set_all_unused();
Lines 22-28 Link Here
22	palette::palette(spec_entry e, bFILE fp)	22	palette::palette(spec_entry e, bFILE fp)
23	{	23	{
24	fp->seek(e->offset,0);	24	fp->seek(e->offset,0);
25	ncolors=fp->read_short();	25	ncolors=fp->read_uint16();
26	pal=(color )jmalloc(sizeof(color)ncolors,"palette");	26	pal=(color )jmalloc(sizeof(color)ncolors,"palette");
27	usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");	27	usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
28	set_all_unused();	28	set_all_unused();
Lines 37-43 Link Here
37		37
38	int palette::write(bFILE *fp)	38	int palette::write(bFILE *fp)
39	{	39	{
40	fp->write_short(ncolors);	40	fp->write_uint16(ncolors);
41	return fp->write(pal,sizeof(color)*ncolors)==ncolors;	41	return fp->write(pal,sizeof(color)*ncolors)==ncolors;
42	}	42	}
43		43
Lines 88-100 Link Here
88	return find;	88	return find;
89	}	89	}
90		90
91	long palette::getquad(int x)	91	uint32_t palette::getquad(int x)
92	{ char entry[4];	92	{ char entry[4];
93	entry[3]=0;	93	entry[3]=0;
94	entry[2]=pal[x].red;	94	entry[2]=pal[x].red;
95	entry[1]=pal[x].green;	95	entry[1]=pal[x].green;
96	entry[0]=pal[x].blue;	96	entry[0]=pal[x].blue;
97	return ((long )entry);	97	return ((uint32_t )entry);
98	}	98	}
99		99
100		100
Lines 481-487 Link Here
481	long brv;	481	long brv;
482	brv=0; bri=0;	482	brv=0; bri=0;
483		483
484	for (i=0;i<ncolors;i++)	484	for (i=0;i<(unsigned int)ncolors;i++)
485	{ if (all \|\| used(i))	485	{ if (all \|\| used(i))
486	{	486	{
487	get(i,r,g,b);	487	get(i,r,g,b);
Lines 501-507 Link Here
501	long brv,x;	501	long brv,x;
502	brv=(long)258(long)258(long)258; bri=0;	502	brv=(long)258(long)258(long)258; bri=0;
503		503
504	for (i=0;i<ncolors;i++)	504	for (i=0;i<(unsigned int)ncolors;i++)
505	{ if (all \|\| used(i))	505	{ if (all \|\| used(i))
506	{	506	{
507	get(i,r,g,b);	507	get(i,r,g,b);
Lines 522-533 Link Here
522		522
523	void palette::fade_to(int total_fades, int fade_on, int dest_r, int dest_g, int dest_b)	523	void palette::fade_to(int total_fades, int fade_on, int dest_r, int dest_g, int dest_b)
524	{	524	{
525	unsigned char sl=(unsigned char )addr();	525	uint8_t sl=(uint8_t )addr();
526	int i;	526	uint8_t x;
		527	int i;
527	for (i=0;i<ncolors;i++)	528	for (i=0;i<ncolors;i++)
528	{	529	{
529	(sl++)=(( dest_r-(int)sl)fade_on/total_fades+sl);	530	x=(( dest_r-(int)sl)fade_on/total_fades+*sl);
530	(sl++)=(( dest_g-(int)sl)fade_on/total_fades+sl);	531	*(sl++)=x;
531	(sl++)=(( dest_b-(int)sl)fade_on/total_fades+sl);	532	x=(( dest_g-(int)sl)fade_on/total_fades+*sl);
		533	*(sl++)=x;
		534	x=(( dest_b-(int)sl)fade_on/total_fades+*sl);
		535	*(sl++)=x;
532	}	536	}
533	}	537	}

Lines 8-19 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/glread.cpp (-12 / +12 lines)
8	image read_glfont(char fn)	8	image read_glfont(char fn)
9	{	9	{
10	image im,sub;	10	image im,sub;
11	unsigned short length,y;	11	uint16_t length,y;
12	unsigned char size,first,width,height,gsize,last;	12	uint8_t size,first,width,height,gsize,last;
13	FILE *fp;	13	FILE *fp;
14	fp=fopen(fn,"rb");	14	fp=fopen(fn,"rb");
15	if (!fp) return NULL;	15	if (!fp) return NULL;
16	fread(&length,1,2,fp); length=int_to_local(length);	16	fread(&length,1,2,fp); length=uint16_to_local(length);
17	fread(&size,1,1,fp);	17	fread(&size,1,1,fp);
18	fread(&first,1,1,fp);	18	fread(&first,1,1,fp);
19	if (size+first>255) { set_error(imFILE_CORRUPTED); fclose(fp); return NULL; }	19	if (size+first>255) { set_error(imFILE_CORRUPTED); fclose(fp); return NULL; }
Lines 44-51 Link Here
44	{	44	{
45	image *im;	45	image *im;
46	char x[4],bpp;	46	char x[4],bpp;
47	unsigned char *sl=NULL,esc,c,n,marker,vmode;	47	uint8_t *sl=NULL,esc,c,n,marker,vmode;
48	unsigned short w,h,len,bufsize,blocks,sn,esize,edesc;	48	uint16_t w,h,len,bufsize,blocks,sn,esize,edesc;
49	int xx,yy;	49	int xx,yy;
50	FILE *fp;	50	FILE *fp;
51	im=NULL;	51	im=NULL;
Lines 54-60 Link Here
54	fread(&x[0],1,2,fp);	54	fread(&x[0],1,2,fp);
55	fread(&w,1,2,fp);	55	fread(&w,1,2,fp);
56	fread(&h,1,2,fp);	56	fread(&h,1,2,fp);
57	w=int_to_local(w); h=int_to_local(h);	57	w=uint16_to_local(w); h=uint16_to_local(h);
58	fread(x,1,4,fp);	58	fread(x,1,4,fp);
59	fread(&bpp,1,1,fp);	59	fread(&bpp,1,1,fp);
60	fread(&marker,1,1,fp);	60	fread(&marker,1,1,fp);
Lines 65-73 Link Here
65		65
66	fread(&vmode,1,1,fp);	66	fread(&vmode,1,1,fp);
67	fread(&edesc,1,2,fp);	67	fread(&edesc,1,2,fp);
68	edesc=int_to_local(edesc);	68	edesc=uint16_to_local(edesc);
69	fread(&esize,1,2,fp);	69	fread(&esize,1,2,fp);
70	esize=int_to_local(esize);	70	esize=uint16_to_local(esize);
71	if (esize==768 && !pal)	71	if (esize==768 && !pal)
72	{ pal=new palette(1<<bpp);	72	{ pal=new palette(1<<bpp);
73	fread(pal->addr(),1,(1<<bpp)*3,fp);	73	fread(pal->addr(),1,(1<<bpp)*3,fp);
Lines 76-91 Link Here
76	else if (esize)	76	else if (esize)
77	fseek(fp,esize,SEEK_CUR);	77	fseek(fp,esize,SEEK_CUR);
78	fread(&blocks,1,2,fp);	78	fread(&blocks,1,2,fp);
79	blocks=int_to_local(blocks);	79	blocks=uint16_to_local(blocks);
80		80
81	yy=h; xx=w;	81	yy=h; xx=w;
82		82
83	while (blocks-- && w>=1 && yy>=0)	83	while (blocks-- && w>=1 && yy>=0)
84	{	84	{
85	fread(&bufsize,1,2,fp);	85	fread(&bufsize,1,2,fp);
86	bufsize=int_to_local(bufsize);	86	bufsize=uint16_to_local(bufsize);
87	fread(&len,1,2,fp);	87	fread(&len,1,2,fp);
88	len=int_to_local(len);	88	len=uint16_to_local(len);
89	fread(&esc,1,1,fp);	89	fread(&esc,1,1,fp);
90	while (yy>=0 && len)	90	while (yy>=0 && len)
91	{	91	{
Lines 112-118 Link Here
112	else	112	else
113	{	113	{
114	fread(&sn,1,2,fp);	114	fread(&sn,1,2,fp);
115	sn=int_to_local(sn);	115	sn=uint16_to_local(sn);
116	fread(&c,1,1,fp);	116	fread(&c,1,1,fp);
117	while (sn-- && yy>=0 && len)	117	while (sn-- && yy>=0 && len)
118	{	118	{

Lines 19-25 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/lbmread.cpp (-13 / +13 lines)
19	}	19	}
20	else	20	else
21	{	21	{
22	long size=read_other_long(fp);	22	int32_t size=read_other_uint32(fp);
23	fread(type,1,4,fp);	23	fread(type,1,4,fp);
24	if (memcmp(type,"PBM ",4))	24	if (memcmp(type,"PBM ",4))
25	{	25	{
Lines 29-59 Link Here
29	}	29	}
30	else	30	else
31	{	31	{
32	long offset=12,ssize;	32	int32_t ssize;
33	char stype[4];	33	char stype[4];
34	short w=0,h=0,x,y,tcolor,pagew,pageh;	34	int16_t w=0,h=0,x,y,tcolor,pagew,pageh;
35	char planes,masking,compr,padl,xa,ya;	35	char planes,masking,compr=0,padl,xa,ya;
36		36
37	while (ftell(fp)+4<size)	37	while (ftell(fp)+4<size)
38	{	38	{
39	fread(stype,1,4,fp);	39	fread(stype,1,4,fp);
40	ssize=read_other_long(fp);	40	ssize=read_other_uint32(fp);
41	if (ssize &1) ssize++; // specs say all chunks are padded by 2	41	if (ssize &1) ssize++; // specs say all chunks are padded by 2
42	if (!memcmp(stype,"BMHD",4))	42	if (!memcmp(stype,"BMHD",4))
43	{	43	{
44	w=read_other_short(fp);	44	w=read_other_uint16(fp);
45	h=read_other_short(fp);	45	h=read_other_uint16(fp);
46	x=read_other_short(fp);	46	x=read_other_uint16(fp);
47	y=read_other_short(fp);	47	y=read_other_uint16(fp);
48	planes=fgetc(fp);	48	planes=fgetc(fp);
49	masking=fgetc(fp);	49	masking=fgetc(fp);
50	compr=fgetc(fp);	50	compr=fgetc(fp);
51	padl=fgetc(fp);	51	padl=fgetc(fp);
52	tcolor=read_other_short(fp);	52	tcolor=read_other_uint16(fp);
53	xa=fgetc(fp);	53	xa=fgetc(fp);
54	ya=fgetc(fp);	54	ya=fgetc(fp);
55	pagew=read_other_short(fp);	55	pagew=read_other_uint16(fp);
56	pageh=read_other_short(fp);	56	pageh=read_other_uint16(fp);
57	} else if (!memcmp(stype,"CMAP",4))	57	} else if (!memcmp(stype,"CMAP",4))
58	{	58	{
59	pal=new palette(256);	59	pal=new palette(256);
Lines 62-68 Link Here
62	{	62	{
63	if (im) delete im; // shouldn't be two BODY's butjust in case...	63	if (im) delete im; // shouldn't be two BODY's butjust in case...
64	im=new image(w,h);	64	im=new image(w,h);
65	int x,y;	65	int y;
66	if (!compr)	66	if (!compr)
67	{	67	{
68	for (y=0;y<h;h++)	68	for (y=0;y<h;h++)

Lines 2-8 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/timage.cpp (-41 / +41 lines)
2		2
3	void trans_image::make_color(int c)	3	void trans_image::make_color(int c)
4	{	4	{
5	unsigned char *dp=data;	5	uint8_t *dp=data;
6	int y,x;	6	int y,x;
7	for (y=0;y<h;y++)	7	for (y=0;y<h;y++)
8	{	8	{
Lines 24-30 Link Here
24	image *trans_image::make_image()	24	image *trans_image::make_image()
25	{	25	{
26	image *im=new image(w,h);	26	image *im=new image(w,h);
27	unsigned char d=im->scan_line(0),dp=data,*dline;	27	uint8_t d=im->scan_line(0),dp=data,*dline;
28	int y,x;	28	int y,x;
29	for (y=0;y<h;y++)	29	for (y=0;y<h;y++)
30	{	30	{
Lines 53-59 Link Here
53	trans_image::trans_image(image im, char name)	53	trans_image::trans_image(image im, char name)
54	{	54	{
55	int size=0,x,y;	55	int size=0,x,y;
56	unsigned char sl,datap,*marker;	56	uint8_t sl,datap,*marker;
57	w=im->width();	57	w=im->width();
58	h=im->height();	58	h=im->height();
59		59
Lines 83-91 Link Here
83	#ifdef MEM_CHECK	83	#ifdef MEM_CHECK
84	char st[80];	84	char st[80];
85	sprintf(st,"trans_image::data (%s)",name);	85	sprintf(st,"trans_image::data (%s)",name);
86	data=(unsigned char *)jmalloc(size,st);	86	data=(uint8_t *)jmalloc(size,st);
87	#else	87	#else
88	data=(unsigned char *)jmalloc(size,"");	88	data=(uint8_t *)jmalloc(size,"");
89	#endif	89	#endif
90	int ww=im->width(),hh=im->height();	90	int ww=im->width(),hh=im->height();
91	datap=data;	91	datap=data;
Lines 124-135 Link Here
124		124
125	void trans_image::put_scan_line(image *screen, int x, int y, int line) // always transparent	125	void trans_image::put_scan_line(image *screen, int x, int y, int line) // always transparent
126	{	126	{
127	short x1,y1,x2,y2;	127	int16_t x1,y1,x2,y2;
128	screen->get_clip(x1,y1,x2,y2);	128	screen->get_clip(x1,y1,x2,y2);
129	if (y+line<y1 \|\| y+line>y2 \|\| x>x2 \|\| x+w-1<x1) // clipped off completely?	129	if (y+line<y1 \|\| y+line>y2 \|\| x>x2 \|\| x+w-1<x1) // clipped off completely?
130	return;	130	return;
131		131
132	unsigned char *datap=data;	132	uint8_t *datap=data;
133	int ix;	133	int ix;
134	while (line) // skip scan line data until we get to the line of interest	134	while (line) // skip scan line data until we get to the line of interest
135	{	135	{
Lines 150-156 Link Here
150		150
151		151
152	// now slam this list of runs to the screen	152	// now slam this list of runs to the screen
153	unsigned char *screen_line=screen->scan_line(y)+x;	153	uint8_t *screen_line=screen->scan_line(y)+x;
154		154
155	for (ix=0;ix<w;)	155	for (ix=0;ix<w;)
156	{	156	{
Lines 201-214 Link Here
201	}	201	}
202		202
203		203
204	inline unsigned char trans_image::clip_y(image screen, int x1, int y1, int x2, int y2,	204	inline uint8_t trans_image::clip_y(image screen, int x1, int y1, int x2, int y2,
205	int x, int &y, int &ysteps)	205	int x, int &y, int &ysteps)
206	{	206	{
207	// check to see if it is total clipped out first	207	// check to see if it is total clipped out first
208	if (y+h<=y1 \|\| y>y2 \|\| x>x2 \|\| x+w<=x1)	208	if (y+h<=y1 \|\| y>y2 \|\| x>x2 \|\| x+w<=x1)
209	return NULL;	209	return NULL;
210		210
211	register unsigned char *datap=data;	211	register uint8_t *datap=data;
212		212
213		213
214	ysteps=height();	214	ysteps=height();
Lines 244-256 Link Here
244	}	244	}
245		245
246	void trans_image::put_image_filled(image *screen, int x, int y,	246	void trans_image::put_image_filled(image *screen, int x, int y,
247	uchar fill_color)	247	uint8_t fill_color)
248	{	248	{
249	short x1,y1,x2,y2;	249	int16_t x1,y1,x2,y2;
250	int chop_length,ysteps;	250	int chop_length,ysteps;
251		251
252	screen->get_clip(x1,y1,x2,y2);	252	screen->get_clip(x1,y1,x2,y2);
253	register unsigned char datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;	253	register uint8_t datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;
254	if (!datap) return ; // if clip_y says nothing to draw, return	254	if (!datap) return ; // if clip_y says nothing to draw, return
255		255
256	screen_line=screen->scan_line(y)+x;	256	screen_line=screen->scan_line(y)+x;
Lines 315-325 Link Here
315	}	315	}
316	}	316	}
317		317
318	void trans_image::put_image_offseted(image screen, uchar s_off) // if screen x & y offset already calculated save a mul	318	void trans_image::put_image_offseted(image screen, uint8_t s_off) // if screen x & y offset already calculated save a mul
319	{	319	{
320	int ix,ysteps=height();	320	int ix,ysteps=height();
321	int screen_skip=screen->width()-w;	321	int screen_skip=screen->width()-w;
322	uchar skip,*datap=data;	322	uint8_t skip,*datap=data;
323	for (;ysteps;ysteps--)	323	for (;ysteps;ysteps--)
324	{	324	{
325	for (ix=0;ix<w;)	325	for (ix=0;ix<w;)
Lines 352-362 Link Here
352		352
353	void trans_image::put_image(image *screen, int x, int y)	353	void trans_image::put_image(image *screen, int x, int y)
354	{	354	{
355	short x1,y1,x2,y2;	355	int16_t x1,y1,x2,y2;
356	int chop_length,ysteps;	356	int chop_length,ysteps;
357		357
358	screen->get_clip(x1,y1,x2,y2);	358	screen->get_clip(x1,y1,x2,y2);
359	register unsigned char datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;	359	register uint8_t datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;
360	if (!datap) return ; // if clip_y says nothing to draw, return	360	if (!datap) return ; // if clip_y says nothing to draw, return
361		361
362	screen_line=screen->scan_line(y)+x;	362	screen_line=screen->scan_line(y)+x;
Lines 413-425 Link Here
413	}	413	}
414	}	414	}
415		415
416	void trans_image::put_remaped(image screen, int x, int y, unsigned char remap)	416	void trans_image::put_remaped(image screen, int x, int y, uint8_t remap)
417	{	417	{
418	short x1,y1,x2,y2;	418	int16_t x1,y1,x2,y2;
419	int chop_length,ysteps;	419	int chop_length,ysteps;
420		420
421	screen->get_clip(x1,y1,x2,y2);	421	screen->get_clip(x1,y1,x2,y2);
422	register unsigned char datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;	422	register uint8_t datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;
423	if (!datap) return ; // if clip_y says nothing to draw, return	423	if (!datap) return ; // if clip_y says nothing to draw, return
424		424
425	screen_line=screen->scan_line(y)+x;	425	screen_line=screen->scan_line(y)+x;
Lines 469-475 Link Here
469	else	469	else
470	counter=slam_length;	470	counter=slam_length;
471		471
472	register unsigned char sl=screen_line+ix,sl2=datap;	472	register uint8_t sl=screen_line+ix,sl2=datap;
473	ix+=slam_length;	473	ix+=slam_length;
474	datap+=slam_length;	474	datap+=slam_length;
475	while (counter)	475	while (counter)
Lines 489-501 Link Here
489		489
490		490
491		491
492	void trans_image::put_double_remaped(image screen, int x, int y, unsigned char remap, unsigned char *remap2)	492	void trans_image::put_double_remaped(image screen, int x, int y, uint8_t remap, uint8_t *remap2)
493	{	493	{
494	short x1,y1,x2,y2;	494	int16_t x1,y1,x2,y2;
495	int chop_length,ysteps;	495	int chop_length,ysteps;
496		496
497	screen->get_clip(x1,y1,x2,y2);	497	screen->get_clip(x1,y1,x2,y2);
498	register unsigned char datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;	498	register uint8_t datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;
499	if (!datap) return ; // if clip_y says nothing to draw, return	499	if (!datap) return ; // if clip_y says nothing to draw, return
500		500
501	screen_line=screen->scan_line(y)+x;	501	screen_line=screen->scan_line(y)+x;
Lines 545-551 Link Here
545	else	545	else
546	counter=slam_length;	546	counter=slam_length;
547		547
548	register unsigned char sl=screen_line+ix,sl2=datap;	548	register uint8_t sl=screen_line+ix,sl2=datap;
549	ix+=slam_length;	549	ix+=slam_length;
550	datap+=slam_length;	550	datap+=slam_length;
551	while (counter)	551	while (counter)
Lines 569-583 Link Here
569	int frame_on, int total_frames,	569	int frame_on, int total_frames,
570	color_filter f, palette pal)	570	color_filter f, palette pal)
571	{	571	{
572	short x1,y1,x2,y2;	572	int16_t x1,y1,x2,y2;
573	int ix,slam_length,chop_length,ysteps;	573	int ix,slam_length,chop_length,ysteps;
574		574
575	screen->get_clip(x1,y1,x2,y2);	575	screen->get_clip(x1,y1,x2,y2);
576	unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),	576	uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
577	*screen_line;	577	*screen_line;
578	if (!datap) return ;	578	if (!datap) return ;
579		579
580	unsigned char screen_run,paddr=(unsigned char *)pal->addr(),	580	uint8_t screen_run,paddr=(uint8_t *)pal->addr(),
581	caddr1,caddr2,r_dest,g_dest,b_dest;	581	caddr1,caddr2,r_dest,g_dest,b_dest;
582		582
583	long fixmul=(frame_on<<16)/total_frames;	583	long fixmul=(frame_on<<16)/total_frames;
Lines 658-675 Link Here
658		658
659	void trans_image::put_fade_tint(image *screen, int x, int y,	659	void trans_image::put_fade_tint(image *screen, int x, int y,
660	int frame_on, int total_frames,	660	int frame_on, int total_frames,
661	uchar *tint,	661	uint8_t *tint,
662	color_filter f, palette pal)	662	color_filter f, palette pal)
663	{	663	{
664	short x1,y1,x2,y2;	664	int16_t x1,y1,x2,y2;
665	int ix,slam_length,chop_length,ysteps;	665	int ix,slam_length,chop_length,ysteps;
666		666
667	screen->get_clip(x1,y1,x2,y2);	667	screen->get_clip(x1,y1,x2,y2);
668	unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),	668	uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
669	*screen_line;	669	*screen_line;
670	if (!datap) return ;	670	if (!datap) return ;
671		671
672	unsigned char screen_run,paddr=(unsigned char *)pal->addr(),	672	uint8_t screen_run,paddr=(uint8_t *)pal->addr(),
673	caddr1,caddr2,r_dest,g_dest,b_dest;	673	caddr1,caddr2,r_dest,g_dest,b_dest;
674		674
675	long fixmul=(frame_on<<16)/total_frames;	675	long fixmul=(frame_on<<16)/total_frames;
Lines 752-762 Link Here
752		752
753	void trans_image::put_color(image *screen, int x, int y, int color)	753	void trans_image::put_color(image *screen, int x, int y, int color)
754	{	754	{
755	short x1,y1,x2,y2;	755	int16_t x1,y1,x2,y2;
756	int ix,slam_length,chop_length,ysteps;	756	int ix,slam_length,chop_length,ysteps;
757		757
758	screen->get_clip(x1,y1,x2,y2);	758	screen->get_clip(x1,y1,x2,y2);
759	unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),	759	uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
760	*screen_line;	760	*screen_line;
761	if (!datap) return ;	761	if (!datap) return ;
762		762
Lines 818-829 Link Here
818	int blendx, int blendy, int blend_amount, color_filter f, palette pal)	818	int blendx, int blendy, int blend_amount, color_filter f, palette pal)
819		819
820	{	820	{
821	short x1,y1,x2,y2;	821	int16_t x1,y1,x2,y2;
822	int ix,slam_length,chop_length,ysteps;	822	int ix,slam_length,chop_length,ysteps;
823	unsigned char paddr=(unsigned char )pal->addr();	823	uint8_t paddr=(uint8_t )pal->addr();
824		824
825	screen->get_clip(x1,y1,x2,y2);	825	screen->get_clip(x1,y1,x2,y2);
826	unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),	826	uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
827	blend_line,screen_line;	827	blend_line,screen_line;
828	if (!datap) return ;	828	if (!datap) return ;
829	CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");	829	CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");
Lines 875-881 Link Here
875	chop_length=x2-x-ix;	875	chop_length=x2-x-ix;
876	else chop_length=slam_length;	876	else chop_length=slam_length;
877		877
878	unsigned char *screen_run=screen_line+x+ix,	878	uint8_t *screen_run=screen_line+x+ix,
879	*blend_run=blend_line+x+ix-blendx,	879	*blend_run=blend_line+x+ix-blendx,
880	caddr1,caddr2,r_dest,g_dest,b_dest;	880	caddr1,caddr2,r_dest,g_dest,b_dest;
881		881
Lines 917-927 Link Here
917		917
918	void trans_image::put_predator(image *screen, int x, int y)	918	void trans_image::put_predator(image *screen, int x, int y)
919	{	919	{
920	short x1,y1,x2,y2;	920	int16_t x1,y1,x2,y2;
921	int chop_length,ysteps;	921	int chop_length,ysteps;
922		922
923	screen->get_clip(x1,y1,x2,y2);	923	screen->get_clip(x1,y1,x2,y2);
924	register unsigned char datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;	924	register uint8_t datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),screen_line;
925	if (!datap) return ; // if clip_y says nothing to draw, return	925	if (!datap) return ; // if clip_y says nothing to draw, return
926		926
927	// see if the last scanline is clipped off	927	// see if the last scanline is clipped off
Lines 1001-1007 Link Here
1001		1001
1002	int trans_image::size()	1002	int trans_image::size()
1003	{	1003	{
1004	uchar *d=data;	1004	uint8_t *d=data;
1005	int t=0;	1005	int t=0;
1006	for (int y=0;y<h;y++)	1006	for (int y=0;y<h;y++)
1007	{	1007	{

Lines 4-28 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/packet.cpp (-10 / +10 lines)
4	#include <string.h>	4	#include <string.h>
5		5
6		6
7	int packet::advance(long offset)	7	int packet::advance(int32_t offset)
8	{	8	{
9	ro+=offset;	9	ro+=offset;
10	return ro<=rend;	10	return ro<=rend;
11	}	11	}
12		12
13	void packet::write_long(ulong x)	13	void packet::write_uint32(uint32_t x)
14	{	14	{
15	x=lltl(x);	15	x=lltl(x);
16	write((uchar *)&x,4);	16	write((uint8_t *)&x,4);
17	}	17	}
18		18
19	void packet::write_short(ushort x)	19	void packet::write_uint16(uint16_t x)
20	{	20	{
21	x=lstl(x);	21	x=lstl(x);
22	write((uchar *)&x,2);	22	write((uint8_t *)&x,2);
23	}	23	}
24		24
25	void packet::write_byte(uchar x)	25	void packet::write_uint8(uint8_t x)
26	{	26	{
27	write(&x,1);	27	write(&x,1);
28	}	28	}
Lines 40-46 Link Here
40	#endif	40	#endif
41		41
42	buf_size=1000;	42	buf_size=1000;
43	buf=(uchar *)jmalloc(buf_size,"packet buffer");	43	buf=(uint8_t *)jmalloc(buf_size,"packet buffer");
44	reset();	44	reset();
45		45
46	#ifdef MANAGE_MEM	46	#ifdef MANAGE_MEM
Lines 71-81 Link Here
71	if (buf_size<max)	71	if (buf_size<max)
72	{	72	{
73	buf_size=max;	73	buf_size=max;
74	buf=(uchar *)jrealloc(buf,max,"packet buffer");	74	buf=(uint8_t *)jrealloc(buf,max,"packet buffer");
75	}	75	}
76	}	76	}
77		77
78	int packet::read(uchar *buffer, int size)	78	int packet::read(uint8_t *buffer, int size)
79	{	79	{
80	if (size>rend-ro)	80	if (size>rend-ro)
81	size=rend-ro;	81	size=rend-ro;
Lines 89-95 Link Here
89	}	89	}
90		90
91		91
92	int packet::write(uchar *buffer, int size)	92	int packet::write(uint8_t *buffer, int size)
93	{	93	{
94	if (size>buf_size-wo)	94	if (size>buf_size-wo)
95	make_bigger(wo+size);	95	make_bigger(wo+size);

Lines 10-24 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/mdlread.cpp (-18 / +18 lines)
10	// images. Note, only the mode 320x200x256 is sopprted here for saving	10	// images. Note, only the mode 320x200x256 is sopprted here for saving
11	// images. All images should be sized so they will fit on an mdl screen	11	// images. All images should be sized so they will fit on an mdl screen
12	// but no checking of that is done hhere.	12	// but no checking of that is done hhere.
13	void write_mdl(image *images, short total_images, palette pal,char *fn,	13	void write_mdl(image *images, int16_t total_images, palette pal,char *fn,
14	short firstpage, short images_per_page)	14	int16_t firstpage, int16_t images_per_page)
15	{	15	{
16	FILE *fp;	16	FILE *fp;
17	char buf[18];	17	char buf[18];
18	unsigned short xy[2],x;	18	uint16_t xy[2],x;
19	char name[13],page;	19	char name[13],page;
20	unsigned char *c;	20	unsigned char *c;
21	short i;	21	int16_t i;
22	palette *np;	22	palette *np;
23	clear_errors();	23	clear_errors();
24	CONDITION(images && pal && fn && total_images>0,"bad parms");	24	CONDITION(images && pal && fn && total_images>0,"bad parms");
Lines 42-48 Link Here
42	{	42	{
43	memset(buf,0,6); // each image has 6 bytes of reserved 0	43	memset(buf,0,6); // each image has 6 bytes of reserved 0
44	fwrite(buf,6,1,fp);	44	fwrite(buf,6,1,fp);
45	xy[0]=int_to_intel(i%100+20); xy[1]=int_to_intel(30); // the x and y position on the screen	45	xy[0]=uint16_to_intel(i%100+20); xy[1]=uint16_to_intel(30); // the x and y position on the screen
46	fwrite(xy,4,1,fp);	46	fwrite(xy,4,1,fp);
47	sprintf(name,"JC%-10d",i); // set the name of the image	47	sprintf(name,"JC%-10d",i); // set the name of the image
48	fwrite(name,12,1,fp);	48	fwrite(name,12,1,fp);
Lines 50-63 Link Here
50	page=firstpage+i/images_per_page;	50	page=firstpage+i/images_per_page;
51		51
52	fwrite(&page,1,1,fp); // put all of the image on the first page	52	fwrite(&page,1,1,fp); // put all of the image on the first page
53	xy[0]=int_to_intel(images[i]->width()*images[i]->height()+4); // calc the size of the image	53	xy[0]=uint16_to_intel(images[i]->width()*images[i]->height()+4); // calc the size of the image
54		54
55	fwrite(xy,2,1,fp);	55	fwrite(xy,2,1,fp);
56	xy[0]=int_to_intel(images[i]->width());	56	xy[0]=uint16_to_intel(images[i]->width());
57	fwrite(xy,2,1,fp);	57	fwrite(xy,2,1,fp);
58	xy[0]=int_to_intel(images[i]->height());	58	xy[0]=uint16_to_intel(images[i]->height());
59	fwrite(xy,2,1,fp);	59	fwrite(xy,2,1,fp);
60	for (x=0;x<(unsigned short)images[i]->height();x++) // write all the scan_lines for the	60	for (x=0;x<(uint16_t)images[i]->height();x++) // write all the scan_lines for the
61	{ c=images[i]->scan_line(x); // image	61	{ c=images[i]->scan_line(x); // image
62	fwrite(c,images[i]->width(),1,fp);	62	fwrite(c,images[i]->width(),1,fp);
63	}	63	}
Lines 66-75 Link Here
66	}	66	}
67	}	67	}
68		68
69	short mdl_total_images(char *fn)	69	int16_t mdl_total_images(char *fn)
70	{	70	{
71	char buf[800];	71	char buf[800];
72	unsigned short xy[2],t;	72	uint16_t xy[2],t;
73	FILE *fp;	73	FILE *fp;
74	fp=fopen(fn,"rb");	74	fp=fopen(fn,"rb");
75	if (!fp)	75	if (!fp)
Lines 91-97 Link Here
91	{ if (fread(buf,1,23,fp)==23)	91	{ if (fread(buf,1,23,fp)==23)
92	{	92	{
93	fread(xy,2,1,fp);	93	fread(xy,2,1,fp);
94	xy[0]=int_to_local(xy[0]);	94	xy[0]=uint16_to_local(xy[0]);
95	fseek(fp,xy[0],SEEK_CUR);	95	fseek(fp,xy[0],SEEK_CUR);
96	t++;	96	t++;
97	}	97	}
Lines 103-114 Link Here
103	// read_mdl returns an array containing pointers to all the desired images	103	// read_mdl returns an array containing pointers to all the desired images
104	// and a palette that is read form the file	104	// and a palette that is read form the file
105	// to load image numbers 4 through 9 let start =4, end=9	105	// to load image numbers 4 through 9 let start =4, end=9
106	image *read_mdl(char fn, palette *&pal, short startn, short endn, short &total)	106	image *read_mdl(char fn, palette *&pal, int16_t startn, int16_t endn, int16_t &total)
107	{	107	{
108	FILE *fp;	108	FILE *fp;
109	image **im;	109	image **im;
110	char buf[50];	110	char buf[50];
111	unsigned short xy[2],i,j;	111	uint16_t xy[2],i,j;
112	clear_errors();	112	clear_errors();
113	make_block(sizeof(FILE));	113	make_block(sizeof(FILE));
114	im=NULL;	114	im=NULL;
Lines 146-152 Link Here
146	{ if (fread(buf,1,23,fp)!=23)	146	{ if (fread(buf,1,23,fp)!=23)
147	set_error(imFILE_CORRUPTED);	147	set_error(imFILE_CORRUPTED);
148	fread(xy,2,1,fp);	148	fread(xy,2,1,fp);
149	xy[0]=int_to_local(xy[0]);	149	xy[0]=uint16_to_local(xy[0]);
150	fseek(fp,xy[0],SEEK_CUR);	150	fseek(fp,xy[0],SEEK_CUR);
151	startn--; if (endn>0) endn--;	151	startn--; if (endn>0) endn--;
152	}	152	}
Lines 160-172 Link Here
160	if (fread(&j,1,2,fp)!=2) set_error(imFILE_CORRUPTED);	160	if (fread(&j,1,2,fp)!=2) set_error(imFILE_CORRUPTED);
161	else	161	else
162	{	162	{
163	j=int_to_local(j);	163	j=uint16_to_local(j);
164	j-=4;	164	j-=4;
165	xy[0]=5; xy[1]=5;	165	xy[0]=5; xy[1]=5;
166	if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);	166	if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);
167	make_block(sizeof(image));	167	make_block(sizeof(image));
168	xy[0]=int_to_local(xy[0]);	168	xy[0]=uint16_to_local(xy[0]);
169	xy[1]=int_to_local(xy[1]);	169	xy[1]=uint16_to_local(xy[1]);
170	im[startn]=new image(xy[0],xy[1]);	170	im[startn]=new image(xy[0],xy[1]);
171	total++;	171	total++;
172	for (i=0;i<xy[1];i++)	172	for (i=0;i<xy[1];i++)

Lines 3-8 Link Here

(-)abuse-sdl-0.7.0.orig/src/imlib/specs.cpp (-100 / +102 lines)
3	#include "specs.hpp"	3	#include "specs.hpp"
4	#include <stdio.h>	4	#include <stdio.h>
5	#include <stdlib.h>	5	#include <stdlib.h>
		6	#include <stdint.h>
6	#include <ctype.h>	7	#include <ctype.h>
7	#include <fcntl.h>	8	#include <fcntl.h>
8	#include "system.h"	9	#include "system.h"
Lines 23-47 Link Here
23	"Palette", // 2	24	"Palette", // 2
24	"Invalid Type", // 3	25	"Invalid Type", // 3
25	"Image", // 4	26	"Image", // 4
26	"Fore Tile",	27	"Fore Tile",
27	"Back Tile",	28	"Back Tile",
28	"Character",	29	"Character",
29	"8 Morph",	30	"8 Morph",
30	"16 Morph",	31	"16 Morph",
31	"Grue objs",	32	"Grue objs",
32	"Extern WAV",	33	"Extern WAV",
33	"DMX MUS",	34	"DMX MUS",
34	"Patched morph",	35	"Patched morph",
35	"Normal file",	36	"Normal file",
36	"Compress1 file",	37	"Compress1 file",
37	"Vector Image",	38	"Vector Image",
38	"Light list",	39	"Light list",
39	"Grue fgmap",	40	"Grue fgmap",
40	"Grue bgmap",	41	"Grue bgmap",
41	"Data array",	42	"Data array",
42	"Character2",	43	"Character2",
43	"Particle",	44	"Particle",
44	"Extern lcache"	45	"Extern lcache"
45	};	46	};
46		47
47		48
Lines 150-156 Link Here
150	{	151	{
151	if (wbuf_end!=0)	152	if (wbuf_end!=0)
152	{	153	{
153	long ret=unbuffered_write(wbuf,wbuf_end);	154	unsigned long ret=unbuffered_write(wbuf,wbuf_end);
154	if (ret!=wbuf_end && no_space_handle_fun)	155	if (ret!=wbuf_end && no_space_handle_fun)
155	no_space_handle_fun();	156	no_space_handle_fun();
156		157
Lines 171-177 Link Here
171	{	172	{
172	if (rbuf_start<rbuf_end)	173	if (rbuf_start<rbuf_end)
173	{	174	{
174	int avail_size=rbuf_end-rbuf_start;	175	unsigned int avail_size=rbuf_end-rbuf_start;
175	int copy_size=avail_size>count ? count : avail_size;	176	int copy_size=avail_size>count ? count : avail_size;
176	memcpy(buf,rbuf+rbuf_start,copy_size);	177	memcpy(buf,rbuf+rbuf_start,copy_size);
177	buf=(void )(((unsigned char )buf)+copy_size);	178	buf=(void )(((unsigned char )buf)+copy_size);
Lines 208-214 Link Here
208	count-=copy_size;	209	count-=copy_size;
209	buf=(void )(((char )buf)+copy_size);	210	buf=(void )(((char )buf)+copy_size);
210	if (wbuf_end==wbuf_size)	211	if (wbuf_end==wbuf_size)
211	if (flush_writes()!=wbuf_size)	212	if ((unsigned int)flush_writes()!=wbuf_size)
212	return total_written;	213	return total_written;
213		214
214	total_written+=copy_size;	215	total_written+=copy_size;
Lines 216-222 Link Here
216	return total_written;	217	return total_written;
217	} else	218	} else
218	{	219	{
219	long ret=unbuffered_write(buf,count);	220	unsigned long ret=unbuffered_write(buf,count);
220	if (ret!=count && no_space_handle_fun)	221	if (ret!=count && no_space_handle_fun)
221	no_space_handle_fun();	222	no_space_handle_fun();
222	}	223	}
Lines 233-239 Link Here
233	if (whence==SEEK_CUR) offset+=curpos;	234	if (whence==SEEK_CUR) offset+=curpos;
234	else if (whence==SEEK_END) offset=file_size()-offset;	235	else if (whence==SEEK_END) offset=file_size()-offset;
235		236
236	if (offset<realpos-rbuf_end \|\| offset>=realpos)	237	if (offset<realpos-(long)rbuf_end \|\| offset>=realpos)
237	{	238	{
238	rbuf_start=rbuf_end=0;	239	rbuf_start=rbuf_end=0;
239	unbuffered_seek(offset,SEEK_SET);	240	unbuffered_seek(offset,SEEK_SET);
Lines 269-281 Link Here
269		270
270	#if (defined(__APPLE__) && !defined(__MACH__))	271	#if (defined(__APPLE__) && !defined(__MACH__))
271	spec_main_jfile.open_external(filename,"rb",O_BINARY\|O_RDONLY);	272	spec_main_jfile.open_external(filename,"rb",O_BINARY\|O_RDONLY);
272	spec_main_fd = spec_main_jfile.get_fd();
273	spec_main_sd.startup(&spec_main_jfile);
274	#else	273	#else
275	spec_main_jfile.open_external(filename,"rb",O_RDONLY);	274	spec_main_jfile.open_external(filename,"rb",O_RDONLY);
		275	#endif
276	spec_main_fd = spec_main_jfile.get_fd();	276	spec_main_fd = spec_main_jfile.get_fd();
		277	if (spec_main_fd==-1)
		278	return;
277	spec_main_sd.startup(&spec_main_jfile);	279	spec_main_sd.startup(&spec_main_jfile);
278	#endif
279	}	280	}
280		281
281	void fast_load_start_recording(char *filename)	282	void fast_load_start_recording(char *filename)
Lines 334-340 Link Here
334	if ((flags&O_APPEND)==0)	335	if ((flags&O_APPEND)==0)
335	{	336	{
336	skip_size=1;	337	skip_size=1;
337	int errval = unlink(tmp_name);	338	//int errval = unlink(tmp_name);
338	}	339	}
339		340
340	flags-=O_WRONLY;	341	flags-=O_WRONLY;
Lines 419-432 Link Here
419	spec_entry *se=spec_main_sd.find(filename);	420	spec_entry *se=spec_main_sd.find(filename);
420	if (se)	421	if (se)
421	{	422	{
422	start_offset=se->offset;	423	start_offset=se->offset;
423	current_offset = 0;	424	current_offset = 0;
424	file_length=se->size;	425	file_length=se->size;
425	rbuf_start=rbuf_end=0;	426	rbuf_start=rbuf_end=0;
426	} else	427	} else
427	{	428	{
428	close(fd);	429	close(fd);
429	fd=-1;	430	fd=-1;
430	}	431	}
431	}	432	}
432	}	433	}
Lines 486-492 Link Here
486		487
487	int jFILE::unbuffered_read(void *buf, size_t count)	488	int jFILE::unbuffered_read(void *buf, size_t count)
488	{	489	{
489	long len;	490	unsigned long len;
490		491
491	if (fd == spec_main_fd)	492	if (fd == spec_main_fd)
492	{	493	{
Lines 504-510 Link Here
504		505
505	len = ::read(fd,(char*)buf,count);	506	len = ::read(fd,(char*)buf,count);
506	::write(fast_load_fd,(char*)&len,sizeof(len));	507	::write(fast_load_fd,(char*)&len,sizeof(len));
507	::write(fast_load_fd,(char*)buf,count);	508	::write(fast_load_fd,(char*)buf,len);
508	break;	509	break;
509	case 2:	510	case 2:
510	::read(fast_load_fd,(char*)&len,sizeof(len));	511	::read(fast_load_fd,(char*)&len,sizeof(len));
Lines 524-530 Link Here
524	case 1:	525	case 1:
525	len = ::read(fd,(char*)buf,count);	526	len = ::read(fd,(char*)buf,count);
526	::write(fast_load_fd,(char*)&len,sizeof(len));	527	::write(fast_load_fd,(char*)&len,sizeof(len));
527	::write(fast_load_fd,(char*)buf,count);	528	::write(fast_load_fd,(char*)buf,len);
528	break;	529	break;
529	case 2:	530	case 2:
530	::read(fast_load_fd,(char*)&len,sizeof(len));	531	::read(fast_load_fd,(char*)&len,sizeof(len));
Lines 547-574 Link Here
547		548
548	int jFILE::unbuffered_seek(long offset, int whence) // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success	549	int jFILE::unbuffered_seek(long offset, int whence) // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success
549	{	550	{
550	long ret;	551	long ret;
551		552
552	if (fast_load_mode == 2)	553	if (fast_load_mode == 2)
553	{	554	{
554	switch (whence)	555	switch (whence)
555	{	556	{
556	case SEEK_SET :	557	case SEEK_SET :
557	current_offset = start_offset+offset;	558	current_offset = start_offset+offset;
558	break;	559	break;
559	case SEEK_END :	560	case SEEK_END :
560	current_offset = start_offset+file_length-offset;	561	current_offset = start_offset+file_length-offset;
561	break;	562	break;
562	case SEEK_CUR :	563	case SEEK_CUR :
563	current_offset += offset;	564	current_offset += offset;
564	break;	565	break;
565	default:	566	default:
566	ret = -1;	567	ret = -1;
567	break;	568	break;
568	}	569	}
569	return current_offset;	570	return current_offset;
570	}	571	}
571		572
572	switch (whence)	573	switch (whence)
573	{	574	{
574	case SEEK_SET :	575	case SEEK_SET :
Lines 583-649 Link Here
583	}	584	}
584	if (ret>=0)	585	if (ret>=0)
585	{	586	{
586	current_offset = ret - start_offset;	587	current_offset = ret - start_offset;
587	if (spec_main_fd == fd)	588	if (spec_main_fd == fd)
588	spec_main_offset = ret;	589	spec_main_offset = ret;
589	return ret;	590	return ret;
590	}	591	}
591	else	592	else
592	return -1; // if a bad whence, then failure	593	return -1; // if a bad whence, then failure
593	}	594	}
594		595
595		596
596	unsigned char bFILE::read_byte()	597	uint8_t bFILE::read_uint8()
597	{ unsigned char x;	598	{ uint8_t x;
598	read(&x,1);	599	read(&x,1);
599	return x;	600	return x;
600	}	601	}
601		602
602	unsigned short bFILE::read_short()	603	uint16_t bFILE::read_uint16()
603	{	604	{
604	unsigned short x;	605	uint16_t x;
605	read(&x,2);	606	read(&x,2);
606	return int_to_local(x);	607	return uint16_to_local(x);
607	}	608	}
608		609
609		610
610	unsigned long bFILE::read_long()	611	uint32_t bFILE::read_uint32()
611	{	612	{
612	unsigned long x;	613	uint32_t x;
613	read(&x,4);	614	read(&x,4);
614	return long_to_local(x);	615	return uint32_to_local(x);
615	}	616	}
616		617
617	void bFILE::write_byte(unsigned char x)	618	void bFILE::write_uint8(uint8_t x)
618	{	619	{
619	write(&x,1);	620	write(&x,1);
620	}	621	}
621		622
622	void bFILE::write_short(unsigned short x)	623	void bFILE::write_uint16(uint16_t x)
623	{	624	{
624	x=int_to_local(x);	625	x=uint16_to_local(x);
625	write(&x,2);	626	write(&x,2);
626	}	627	}
627		628
628		629
629	void bFILE::write_long(unsigned long x)	630	void bFILE::write_uint32(uint32_t x)
630	{	631	{
631	x=long_to_local(x);	632	x=uint32_to_local(x);
632	write(&x,4);	633	write(&x,4);
633	}	634	}
634		635
635	void bFILE::write_double(double x)	636	void bFILE::write_double(double x)
636	{	637	{
637	double a;	638	double a;
638	write_long((long)(modf(x,&a)*(double)(1<<32-1)));	639	write_uint32((long)(modf(x,&a)*(double)(1<<32-1)));
639	write_long((long)a);	640	write_uint32((long)a);
640	}	641	}
641		642
642	double bFILE::read_double()	643	double bFILE::read_double()
643	{	644	{
644	long a,b;	645	long a,b;
645	a=read_long();	646	a=read_uint32();
646	b=read_long();	647	b=read_uint32();
647	return (double)b+a/(double)(1<<32-1);	648	return (double)b+a/(double)(1<<32-1);
648	}	649	}
649		650
Lines 754-765 Link Here
754	void spec_directory::startup(bFILE *fp)	755	void spec_directory::startup(bFILE *fp)
755	{	756	{
756	char buf[256];	757	char buf[256];
		758	memset(buf,0,256);
757	fp->read(buf,8);	759	fp->read(buf,8);
758	buf[9]=0;	760	buf[9]=0;
759	size=0;	761	size=0;
760	if (!strcmp(buf,SPEC_SIGNATURE))	762	if (!strcmp(buf,SPEC_SIGNATURE))
761	{	763	{
762	total=fp->read_short();	764	total=fp->read_uint16();
763	entries=(spec_entry *)jmalloc(sizeof(spec_entry )*total,"spec_directory::entries");	765	entries=(spec_entry *)jmalloc(sizeof(spec_entry )*total,"spec_directory::entries");
764	long start=fp->tell();	766	long start=fp->tell();
765		767
Lines 790-797 Link Here
790	fp->read(se->name,len);	792	fp->read(se->name,len);
791	fp->read(&flags,1);	793	fp->read(&flags,1);
792		794
793	se->size=fp->read_long();	795	se->size=fp->read_uint32();
794	se->offset=fp->read_long();	796	se->offset=fp->read_uint32();
795	dp+=((sizeof(spec_entry)+len)+3)&(~3);	797	dp+=((sizeof(spec_entry)+len)+3)&(~3);
796	}	798	}
797	}	799	}
Lines 877-883 Link Here
877	strcpy(sig,SPEC_SIGNATURE);	879	strcpy(sig,SPEC_SIGNATURE);
878		880
879	if (fp->write(sig,sizeof(sig))!=sizeof(sig)) return 0;	881	if (fp->write(sig,sizeof(sig))!=sizeof(sig)) return 0;
880	fp->write_short(total);	882	fp->write_uint16(total);
881		883
882		884
883	int i;	885	int i;
Lines 888-896 Link Here
888	flags=0;	890	flags=0;
889	if (fp->write(&flags,1)!=1) return 0;	891	if (fp->write(&flags,1)!=1) return 0;
890		892
891	data_size=long_to_intel((*e)->size);	893	data_size=uint32_to_intel((*e)->size);
892	if (fp->write((char *)&data_size,4)!=4) return 0;	894	if (fp->write((char *)&data_size,4)!=4) return 0;
893	offset=long_to_intel((*e)->offset);	895	offset=uint32_to_intel((*e)->offset);
894	if (fp->write((char *)&offset,4)!=4) return 0;	896	if (fp->write((char *)&offset,4)!=4) return 0;
895		897
896	}	898	}
Lines 910-967 Link Here
910		912
911	}	913	}
912		914
913	unsigned short read_short(FILE *fp)	915	uint16_t read_uint16(FILE *fp)
914	{	916	{
915	unsigned short x;	917	uint16_t x;
916	fread(&x,1,2,fp);	918	fread(&x,1,2,fp);
917	return int_to_local(x);	919	return uint16_to_local(x);
918	}	920	}
919		921
920	unsigned long read_long(FILE *fp)	922	uint32_t read_uint32(FILE *fp)
921	{	923	{
922	unsigned long x;	924	uint32_t x;
923	fread(&x,1,4,fp);	925	fread(&x,1,4,fp);
924	return (long)long_to_local(x);	926	return uint32_to_local(x);
925	}	927	}
926	void write_short(FILE *fp, unsigned short x)	928	void write_uint16(FILE *fp, uint16_t x)
927	{	929	{
928	x=int_to_local(x);	930	x=uint16_to_local(x);
929	fwrite(&x,1,2,fp);	931	fwrite(&x,1,2,fp);
930	}	932	}
931		933
932	void write_long(FILE *fp, unsigned long x)	934	void write_uint32(FILE *fp, uint32_t x)
933	{	935	{
934	x=long_to_local(x);	936	x=uint32_to_local(x);
935	fwrite(&x,1,4,fp);	937	fwrite(&x,1,4,fp);
936	}	938	}
937		939
938	unsigned char read_byte(FILE *fp) { return fgetc(fp)&0xff; }	940	uint8_t read_uint8(FILE *fp) { return fgetc(fp)&0xff; }
939	void write_byte(FILE *fp, unsigned char x) { fputc(x,fp); }	941	void write_uint8(FILE *fp, uint8_t x) { fputc((unsigned char)x,fp); }
940		942
941	unsigned short read_other_long(FILE *fp)	943	uint32_t read_other_int32(FILE *fp)
942	{	944	{
943	unsigned long x;	945	uint32_t x;
944	fread(&x,1,4,fp);	946	fread(&x,1,4,fp);
945	return big_long_to_local(x);	947	return big_uint32_to_local(x);
946	}	948	}
947		949
948	unsigned long read_other_short(FILE *fp)	950	uint16_t read_other_uint16(FILE *fp)
949	{	951	{
950	unsigned short x;	952	uint16_t x;
951	fread(&x,1,2,fp);	953	fread(&x,1,2,fp);
952	return big_short_to_local(x);	954	return big_uint16_to_local(x);
953	}	955	}
954		956
955		957
956	void write_other_short(FILE *fp, unsigned short x)	958	void write_other_uint16(FILE *fp, uint16_t x)
957	{	959	{
958	x=big_short_to_local(x);	960	x=big_uint16_to_local(x);
959	fwrite(&x,1,2,fp);	961	fwrite(&x,1,2,fp);
960	}	962	}
961		963
962	void write_other_long(FILE *fp, unsigned long x)	964	void write_other_int32(FILE *fp, uint32_t x)
963	{	965	{
964	x=big_long_to_local(x);	966	x=big_uint32_to_local(x);
965	fwrite(&x,1,4,fp);	967	fwrite(&x,1,4,fp);
966	}	968	}
967		969

Lines 95-119 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/netface.hpp (-22 / +22 lines)
95		95
96	struct net_packet	96	struct net_packet
97	{	97	{
98	unsigned char data[PACKET_MAX_SIZE];	98	uint8_t data[PACKET_MAX_SIZE];
99	int packet_prefix_size() { return 5; } // 2 byte size, 2 byte check sum, 1 byte packet order	99	int packet_prefix_size() { return 5; } // 2 byte size, 2 byte check sum, 1 byte packet order
100	unsigned short packet_size() { unsigned short size=((unsigned short )data); return lstl(size); }	100	uint16_t packet_size() { uint16_t size=((uint16_t )data); return lstl(size); }
101	unsigned char tick_received() { return data[4]; }	101	uint8_t tick_received() { return data[4]; }
102	void set_tick_received(unsigned char x) { data[4]=x; }	102	void set_tick_received(uint8_t x) { data[4]=x; }
103	unsigned char *packet_data() { return data+packet_prefix_size(); }	103	uint8_t *packet_data() { return data+packet_prefix_size(); }
104	unsigned short get_checksum() { unsigned short cs=((unsigned short )data+1); return lstl(cs); }	104	uint16_t get_checksum() { uint16_t cs=((uint16_t )data+1); return lstl(cs); }
105	unsigned short calc_checksum()	105	uint16_t calc_checksum()
106	{	106	{
107	((unsigned short )data+1)=0;	107	((uint16_t )data+1)=0;
108	int i,size=packet_prefix_size()+packet_size();	108	int i,size=packet_prefix_size()+packet_size();
109	unsigned char c1=0,c2=0,*p=data;	109	uint8_t c1=0,c2=0,*p=data;
110	for (i=0;i<size;i++,p++)	110	for (i=0;i<size;i++,p++)
111	{	111	{
112	c1+=*p;	112	c1+=*p;
113	c2+=c1;	113	c2+=c1;
114	}	114	}
115	unsigned short cs=( (((unsigned short)c1)<<8) \| c2);	115	uint16_t cs=( (((uint16_t)c1)<<8) \| c2);
116	((unsigned short )data+1)=lstl(cs);	116	((uint16_t )data+1)=lstl(cs);
117	return cs;	117	return cs;
118	}	118	}
119		119
Lines 128-138 Link Here
128	set_packet_size(packet_size()+size);	128	set_packet_size(packet_size()+size);
129	}	129	}
130	}	130	}
131	void write_byte(unsigned char x) { add_to_packet(&x,1); }	131	void write_uint8(uint8_t x) { add_to_packet(&x,1); }
132	void write_short(unsigned short x) { x=lstl(x); add_to_packet(&x,2); }	132	void write_uint16(uint16_t x) { x=lstl(x); add_to_packet(&x,2); }
133	void write_long(unsigned long x) { x=lltl(x); add_to_packet(&x,4); }	133	void write_uint32(uint32_t x) { x=lltl(x); add_to_packet(&x,4); }
134		134
135	void set_packet_size(unsigned short x) { ((unsigned short )data)=lstl(x); }	135	void set_packet_size(uint16_t x) { ((uint16_t )data)=lstl(x); }
136		136
137		137
138	} ;	138	} ;
Lines 142-154 Link Here
142	net_packet packet, // current tick data	142	net_packet packet, // current tick data
143	last_packet; // last tick data (in case a client misses input, we can resend)	143	last_packet; // last tick data (in case a client misses input, we can resend)
144		144
145	short mem_lock;	145	int16_t mem_lock;
146	short calc_crcs;	146	int16_t calc_crcs;
147	short get_lsf;	147	int16_t get_lsf;
148	short wait_reload;	148	int16_t wait_reload;
149	short need_reload;	149	int16_t need_reload;
150	short input_state; // COLLECTING or PROCESSING	150	int16_t input_state; // COLLECTING or PROCESSING
151	short current_tick; // set by engine, used by driver to confirm packet is not left over	151	int16_t current_tick; // set by engine, used by driver to confirm packet is not left over
152		152
153	join_struct *join_list;	153	join_struct *join_list;
154	} ;	154	} ;

Lines 11-19 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/view.hpp (-22 / +22 lines)
11		11
12	struct suggest_struct	12	struct suggest_struct
13	{	13	{
14	long cx1,cy1,cx2,cy2,shift_down,shift_right,pan_x,pan_y;	14	int32_t cx1,cy1,cx2,cy2,shift_down,shift_right,pan_x,pan_y;
15	long new_weapon;	15	int32_t new_weapon;
16	uchar send_view,send_weapon_change;	16	uint8_t send_view,send_weapon_change;
17	} ;	17	} ;
18		18
19		19
Lines 22-28 Link Here
22		22
23	class view	23	class view
24	{	24	{
25	uchar keymap[512/8];	25	uint8_t keymap[512/8];
26	char chat_buf[60];	26	char chat_buf[60];
27	public :	27	public :
28	int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }	28	int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }
Lines 32-38 Link Here
32		32
33	char name[100];	33	char name[100];
34	struct suggest_struct suggest;	34	struct suggest_struct suggest;
35	long cx1,cy1,cx2,cy2, // view area to show	35	int32_t cx1,cy1,cx2,cy2, // view area to show
36	shift_down,shift_right; // shift of view	36	shift_down,shift_right; // shift of view
37		37
38	int god; // :) if you believe in such things	38	int god; // :) if you believe in such things
Lines 40-48 Link Here
40		40
41	int draw_solid; // -1 if don't draw solid	41	int draw_solid; // -1 if don't draw solid
42		42
43	long *weapons; // [0..total_weapons-1]	43	int32_t *weapons; // [0..total_weapons-1]
44	long *last_weapons; // last history of above array (for updating statbar)	44	int32_t *last_weapons; // last history of above array (for updating statbar)
45	long current_weapon;	45	int32_t current_weapon;
46		46
47		47
48	game_object *focus; // object we are focusing on (player)	48	game_object *focus; // object we are focusing on (player)
Lines 58-85 Link Here
58		58
59		59
60	short ambient; // ambient lighting setting, used by draw	60	short ambient; // ambient lighting setting, used by draw
61	long pan_x,pan_y,no_xleft,no_xright,no_ytop,no_ybottom,	61	int32_t pan_x,pan_y,no_xleft,no_xright,no_ytop,no_ybottom,
62	last_x,last_y,last_last_x,last_last_y,view_percent;	62	last_x,last_y,last_last_x,last_last_y,view_percent;
63		63
64	long last_left,last_right,last_up,last_down, // how many frames ago were these pressed (<=0)	64	int32_t last_left,last_right,last_up,last_down, // how many frames ago were these pressed (<=0)
65	last_b1,last_b2,last_b3,last_b4,last_hp,last_ammo,last_type;	65	last_b1,last_b2,last_b3,last_b4,last_hp,last_ammo,last_type;
66	long secrets,kills,tsecrets,tkills;	66	int32_t secrets,kills,tsecrets,tkills;
67		67
68	view(game_object Focus, view Next, int number);	68	view(game_object Focus, view Next, int number);
69	void draw_character_damage(); // draws the characters 'status' on the viewer	69	void draw_character_damage(); // draws the characters 'status' on the viewer
70		70
71	long x_center(); // center of attention	71	int32_t x_center(); // center of attention
72	long y_center();	72	int32_t y_center();
73	long xoff(); // top left and right corner of the screen	73	int32_t xoff(); // top left and right corner of the screen
74	long interpolated_xoff();	74	int32_t interpolated_xoff();
75	long yoff();	75	int32_t yoff();
76	long interpolated_yoff();	76	int32_t interpolated_yoff();
77	int drawable(); // network viewables are not drawable	77	int drawable(); // network viewables are not drawable
78	int local_player(); // just in case I ever need non-viewable local players.	78	int local_player(); // just in case I ever need non-viewable local players.
79		79
80	view *next; // next viewable player (singly linked list)	80	view *next; // next viewable player (singly linked list)
81	void get_input();	81	void get_input();
82	int process_input(char cmd, uchar *&pk);	82	int process_input(char cmd, uint8_t *&pk);
83		83
84	void add_ammo (int weapon_type, int total);	84	void add_ammo (int weapon_type, int total);
85	int has_weapon (int weapon_type) { return god \|\| (weapons[weapon_type]!=-1); }	85	int has_weapon (int weapon_type) { return god \|\| (weapons[weapon_type]!=-1); }
Lines 93-99 Link Here
93	void draw_hp();	93	void draw_hp();
94	void draw_ammo();	94	void draw_ammo();
95	void draw_logo();	95	void draw_logo();
96	void resize_view(long Cx1, long Cy1, long Cx2, long Cy2);	96	void resize_view(int32_t Cx1, int32_t Cy1, int32_t Cx2, int32_t Cy2);
97	void set_input(int cx, int cy, int b1, int b2, int b3, int b4, int px, int py);	97	void set_input(int cx, int cy, int b1, int b2, int b3, int b4, int px, int py);
98	int view_changed() { return suggest.send_view; }	98	int view_changed() { return suggest.send_view; }
99	int weapon_changed() { return suggest.send_weapon_change; }	99	int weapon_changed() { return suggest.send_weapon_change; }
Lines 103-110 Link Here
103		103
104	void reset_player();	104	void reset_player();
105	int receive_failed() { return focus==NULL; }	105	int receive_failed() { return focus==NULL; }
106	long get_view_var_value(int num);	106	int32_t get_view_var_value(int num);
107	long set_view_var_value(int num, long x);	107	int32_t set_view_var_value(int num, int32_t x);
108	void configure_for_area(area_controller *a);	108	void configure_for_area(area_controller *a);
109	~view();	109	~view();
110	} ;	110	} ;
Lines 114-120 Link Here
114	int total_local_players();	114	int total_local_players();
115	void recalc_local_view_space();	115	void recalc_local_view_space();
116		116
117	void process_packet_commands(uchar *pk, int size);	117	void process_packet_commands(uint8_t *pk, int size);
118		118
119	object_node *make_player_onodes(int player_num=-1);	119	object_node *make_player_onodes(int player_num=-1);
120	int total_view_vars();	120	int total_view_vars();

Lines 4-18 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/fakelib.hpp (-5 / +1 lines)
4	#define jmalloc(x,y) malloc(x)	4	#define jmalloc(x,y) malloc(x)
5	#define jrealloc(x,y,z) realloc(x,y)	5	#define jrealloc(x,y,z) realloc(x,y)
6	#define jfree(x) free(x)	6	#define jfree(x) free(x)
7	#define uchar unsigned char
8	#define schar signed char
9	#define sshort signed short
10		7
11	#ifdef __sgi	8	#ifdef __sgi
12	#include <sys/bsd_types.h>	9	#include <sys/bsd_types.h>
13	#else	10	#else
14	#define ulong unsigned long	11	#include <stdint.h>
15	#define ushort unsigned short
16	#endif	12	#endif
17		13
18	class bFILE	14	class bFILE

Lines 14-20 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/items.hpp (-11 / +11 lines)
14	{	14	{
15	public :	15	public :
16	boundary(bFILE fp,char er_name);	16	boundary(bFILE fp,char er_name);
17	unsigned char *inside; // tells which side of the line is on the inside	17	uint8_t *inside; // tells which side of the line is on the inside
18	boundary(boundary p); // flips the inside list	18	boundary(boundary p); // flips the inside list
19	~boundary() { if (tot) jfree(inside); }	19	~boundary() { if (tot) jfree(inside); }
20	} ;	20	} ;
Lines 22-32 Link Here
22	class backtile	22	class backtile
23	{	23	{
24	public :	24	public :
25	unsigned short next;	25	uint16_t next;
26	image *im;	26	image *im;
27	backtile(spec_entry e, bFILE fp);	27	backtile(spec_entry e, bFILE fp);
28	backtile(bFILE *fp);	28	backtile(bFILE *fp);
29	long size() { return 2+4+im->width()*im->height(); }	29	int32_t size() { return 2+4+im->width()*im->height(); }
30	~backtile() { delete im; }	30	~backtile() { delete im; }
31	} ;	31	} ;
32		32
Lines 34-49 Link Here
34	{	34	{
35	public :	35	public :
36	trans_image *im;	36	trans_image *im;
37	unsigned short next;	37	uint16_t next;
38	unsigned char damage;	38	uint8_t damage;
39	uchar ylevel; // for fast intersections, this is the y level offset for the ground	39	uint8_t ylevel; // for fast intersections, this is the y level offset for the ground
40	// if ground is not level this is 255	40	// if ground is not level this is 255
41	boundary *points;	41	boundary *points;
42		42
43	image *micro_image;	43	image *micro_image;
44		44
45	foretile(bFILE *fp);	45	foretile(bFILE *fp);
46	long size() { return im->width()*im->height()+4+2+1+points->size(); }	46	int32_t size() { return im->width()*im->height()+4+2+1+points->size(); }
47	~foretile() { delete im; delete points; delete micro_image; }	47	~foretile() { delete im; delete points; delete micro_image; }
48	} ;	48	} ;
49		49
Lines 51-58 Link Here
51	{	51	{
52	public :	52	public :
53	trans_image forward,backward;	53	trans_image forward,backward;
54	unsigned char hit_damage,xcfg;	54	uint8_t hit_damage,xcfg;
55	signed char advance;	55	int8_t advance;
56	point_list *hit;	56	point_list *hit;
57	boundary f_damage,b_damage;	57	boundary f_damage,b_damage;
58	int size();	58	int size();
Lines 61-67 Link Here
61	int width() { return forward->width(); }	61	int width() { return forward->width(); }
62	int height() { return forward->height(); }	62	int height() { return forward->height(); }
63		63
64	/* long size(int type) // taken from spaint items	64	/* int32_t size(int type) // taken from spaint items
65	{	65	{
66	if	66	if
67	return forward->width()*backward->height()+4+	67	return forward->width()*backward->height()+4+
Lines 79-85 Link Here
79	class char_tint	79	class char_tint
80	{	80	{
81	public :	81	public :
82	uchar data[256];	82	uint8_t data[256];
83	~char_tint() { ; }	83	~char_tint() { ; }
84	char_tint(bFILE *fp); // should be a palette entry	84	char_tint(bFILE *fp); // should be a palette entry
85	} ;	85	} ;

Lines 27-35 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/objects.hpp (-14 / +14 lines)
27		27
28		28
29		29
30	#define RC_C 0	30	#define RC_8 0
31	#define RC_S 1	31	#define RC_16 1
32	#define RC_L 2	32	#define RC_32 2
33		33
34		34
35		35
Lines 47-53 Link Here
47	sequence *current_sequence() { return figures[otype]->get_sequence(state); }	47	sequence *current_sequence() { return figures[otype]->get_sequence(state); }
48	public :	48	public :
49	game_object next,next_active;	49	game_object next,next_active;
50	long *lvars;	50	int32_t *lvars;
51		51
52	int size();	52	int size();
53	int decide(); // returns 0 if you want to be deleted	53	int decide(); // returns 0 if you want to be deleted
Lines 71-78 Link Here
71		71
72	void drawer();	72	void drawer();
73	void draw_above(view *v);	73	void draw_above(view *v);
74	void do_damage(int amount, game_object *from, long hitx, long hity, long push_xvel, long push_yvel);	74	void do_damage(int amount, game_object *from, int32_t hitx, int32_t hity, int32_t push_xvel, int32_t push_yvel);
75	void damage_fun(int amount, game_object *from, long hitx, long hity, long push_xvel, long push_yvel);	75	void damage_fun(int amount, game_object *from, int32_t hitx, int32_t hity, int32_t push_xvel, int32_t push_yvel);
76		76
77		77
78	void note_attack(game_object *whom);	78	void note_attack(game_object *whom);
Lines 93-106 Link Here
93	void set_state(character_state s, int frame_direction=1);	93	void set_state(character_state s, int frame_direction=1);
94	int has_sequence(character_state s) { return figures[otype]->has_sequence(s); }	94	int has_sequence(character_state s) { return figures[otype]->has_sequence(s); }
95		95
96	game_object *try_move(long x, long y, long &xv, long &yv, int checks); // 1=down,2=up,3=both	96	game_object *try_move(int32_t x, int32_t y, int32_t &xv, int32_t &yv, int checks); // 1=down,2=up,3=both
97	game_object bmove(int &whit, game_object exclude); // ballestic move, return hit object,	97	game_object bmove(int &whit, game_object exclude); // ballestic move, return hit object,
98	// or NULL (whit is 1 if hit wall)	98	// or NULL (whit is 1 if hit wall)
99	trans_image *picture() { return current_sequence()->get_frame(current_frame,direction); }	99	trans_image *picture() { return current_sequence()->get_frame(current_frame,direction); }
100		100
101	int next_picture();	101	int next_picture();
102	long x_center();	102	int32_t x_center();
103	long height();	103	int32_t height();
104		104
105	void stop_acel() { set_xacel(0); set_yacel(0); set_fxacel(0); set_fyacel(0); }	105	void stop_acel() { set_xacel(0); set_yacel(0); set_fxacel(0); set_fyacel(0); }
106	void stop_vel() { set_xvel(0); set_yvel(0); set_fxvel(0); set_fyvel(0); }	106	void stop_vel() { set_xvel(0); set_yvel(0); set_fxvel(0); set_fyvel(0); }
Lines 114-120 Link Here
114	int mover(int cx, int cy, int button);	114	int mover(int cx, int cy, int button);
115	figure *current_figure() { return current_sequence()->get_figure(current_frame); }	115	figure *current_figure() { return current_sequence()->get_figure(current_frame); }
116	int total_frames() { return current_sequence()->length(); }	116	int total_frames() { return current_sequence()->length(); }
117	void picture_space(long &x1, long &y1,long &x2, long &y2);	117	void picture_space(int32_t &x1, int32_t &y1,int32_t &x2, int32_t &y2);
118	int tx(int x) { if (direction>0) return x-x_center(); else return x_center()-x; }	118	int tx(int x) { if (direction>0) return x-x_center(); else return x_center()-x; }
119	int ty(int y) { return y-picture()->height()+1; }	119	int ty(int y) { return y-picture()->height()+1; }
120	void defaults();	120	void defaults();
Lines 133-140 Link Here
133	void reload_notify();	133	void reload_notify();
134		134
135	void change_type(int new_type);	135	void change_type(int new_type);
136	int set_var_by_name(char *name, long value);	136	int set_var_by_name(char *name, int32_t value);
137	long get_var_by_name(char *name, int &error);	137	int32_t get_var_by_name(char *name, int &error);
138	game_object *copy();	138	game_object *copy();
139	void change_aitype(int new_type);	139	void change_aitype(int new_type);
140	~game_object();	140	~game_object();
Lines 150-161 Link Here
150		150
151	extern game_object *current_object;	151	extern game_object *current_object;
152	extern view *current_view;	152	extern view *current_view;
153	game_object *create(int type, long x, long y, int skip_constructor=0, int aitype=0);	153	game_object *create(int type, int32_t x, int32_t y, int skip_constructor=0, int aitype=0);
154	int base_size();	154	int base_size();
155		155
156	void delete_object_list(object_node *first);	156	void delete_object_list(object_node *first);
157	int object_to_number_in_list(game_object who, object_node list);	157	int object_to_number_in_list(game_object who, object_node list);
158	game_object number_to_object_in_list(long x, object_node list);	158	game_object number_to_object_in_list(int32_t x, object_node list);
159		159
160		160
161	#endif	161	#endif

Lines 22-31 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/cache.hpp (-17 / +17 lines)
22	struct cache_item	22	struct cache_item
23	{	23	{
24	void *data;	24	void *data;
25	long last_access;	25	int32_t last_access;
26	unsigned char type;	26	uint8_t type;
27	short file_number;	27	int16_t file_number;
28	long offset;	28	int32_t offset;
29	} ;	29	} ;
30		30
31		31
Lines 34-40 Link Here
34	{	34	{
35	public :	35	public :
36	int crc_calculated;	36	int crc_calculated;
37	ulong crc;	37	uint32_t crc;
38	char *filename;	38	char *filename;
39	crced_file(char *name);	39	crced_file(char *name);
40	~crced_file();	40	~crced_file();
Lines 47-55 Link Here
47	public :	47	public :
48	crc_manager();	48	crc_manager();
49	int get_filenumber(char *filename);	49	int get_filenumber(char *filename);
50	ulong get_crc(long filenumber, int &failed);	50	uint32_t get_crc(int32_t filenumber, int &failed);
51	void set_crc(long filenumber, ulong crc);	51	void set_crc(int32_t filenumber, uint32_t crc);
52	char *get_filename(long filenumber);	52	char *get_filename(int32_t filenumber);
53	void clean_up();	53	void clean_up();
54	int total_filenames() { return total_files; }	54	int total_filenames() { return total_files; }
55	int write_crc_file(char *filename);	55	int write_crc_file(char *filename);
Lines 61-77 Link Here
61	class cache_list	61	class cache_list
62	{	62	{
63	cache_item *list;	63	cache_item *list;
64	long total,last_registered,last_access,poll_start_access;	64	int32_t total,last_registered,last_access,poll_start_access;
65	short last_file; // for speed leave the last file accessed open	65	int16_t last_file; // for speed leave the last file accessed open
66		66
67	bFILE fp,cache_file,*cache_read_file;	67	bFILE fp,cache_file,*cache_read_file;
68	spec_directory *last_dir;	68	spec_directory *last_dir;
69	long last_offset; // store the last offset so we don't have to seek if	69	int32_t last_offset; // store the last offset so we don't have to seek if
70	// we don't need to	70	// we don't need to
71		71
72		72
73	short lcache_number;	73	int16_t lcache_number;
74	long alloc_id();	74	int32_t alloc_id();
75	void locate(cache_item *i, int local_only=0); // set up file and offset for this item	75	void locate(cache_item *i, int local_only=0); // set up file and offset for this item
76	void normalize();	76	void normalize();
77	void unmalloc(cache_item *i);	77	void unmalloc(cache_item *i);
Lines 86-94 Link Here
86	void free_oldest();	86	void free_oldest();
87	int in_use() { if (used) { used=0; return 1; } else return 0; }	87	int in_use() { if (used) { used=0; return 1; } else return 0; }
88	int full() { if (ful) { ful=0; return 1; } else return 0; }	88	int full() { if (ful) { ful=0; return 1; } else return 0; }
89	long reg_object(char filename, void object, int type, int rm_dups); // lisp object	89	int32_t reg_object(char filename, void object, int type, int rm_dups); // lisp object
90	long reg(char filename, char name, int type=-1, int rm_dups=0); // returns id to item	90	int32_t reg(char filename, char name, int type=-1, int rm_dups=0); // returns id to item
91	long reg_lisp_block(Cell *block);	91	int32_t reg_lisp_block(Cell *block);
92	int loaded(int id);	92	int loaded(int id);
93	void unreg(int id);	93	void unreg(int id);
94	void note_need(int id);	94	void note_need(int id);
Lines 113-119 Link Here
113	int offset_compare(int a, int b);	113	int offset_compare(int a, int b);
114		114
115	void load_cache_prof_info(char filename, level lev);	115	void load_cache_prof_info(char filename, level lev);
116	int search(int *sarray, ushort filenum, long offset); // sarray is a index table sorted by offset/filenum	116	int search(int *sarray, uint16_t filenum, int32_t offset); // sarray is a index table sorted by offset/filenum
117		117
118	void show_accessed();	118	void show_accessed();
119	void empty();	119	void empty();

Lines 26-48 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/level.hpp (-40 / +40 lines)
26	class area_controller	26	class area_controller
27	{	27	{
28	public :	28	public :
29	long x,y,w,h,active;	29	int32_t x,y,w,h,active;
30	long ambient,view_xoff,view_yoff;	30	int32_t ambient,view_xoff,view_yoff;
31	long ambient_speed, view_xoff_speed,view_yoff_speed;	31	int32_t ambient_speed, view_xoff_speed,view_yoff_speed;
32	area_controller *next;	32	area_controller *next;
33	area_controller(long X, long Y, long W, long H, area_controller *Next);	33	area_controller(int32_t X, int32_t Y, int32_t W, int32_t H, area_controller *Next);
34	} ;	34	} ;
35		35
36	extern long last_tile_hit_x,last_tile_hit_y;	36	extern int32_t last_tile_hit_x,last_tile_hit_y;
37	extern int dev;	37	extern int dev;
38	class level // contain map info and objects	38	class level // contain map info and objects
39	{	39	{
40	unsigned short *map_fg, // just big 2d arrays	40	uint16_t *map_fg, // just big 2d arrays
41	*map_bg,	41	*map_bg,
42	bg_width,bg_height,	42	bg_width,bg_height,
43	fg_width,fg_height;	43	fg_width,fg_height;
44	char Name,first_name;	44	char Name,first_name;
45	long total_objs;	45	int32_t total_objs;
46	game_object first,first_active,*last;	46	game_object first,first_active,*last;
47		47
48	game_object **attack_list; // list of characters for tick which can attack someone	48	game_object **attack_list; // list of characters for tick which can attack someone
Lines 63-74 Link Here
63	game_object **all_block_list; // list of characters who can block a character or can be hurt	63	game_object **all_block_list; // list of characters who can block a character or can be hurt
64	int all_block_list_size,all_block_total;	64	int all_block_list_size,all_block_total;
65	void add_all_block(game_object *who);	65	void add_all_block(game_object *who);
66	ulong ctick;	66	uint32_t ctick;
67		67
68	public :	68	public :
69	char *original_name() { if (first_name) return first_name; else return Name; }	69	char *original_name() { if (first_name) return first_name; else return Name; }
70	ulong tick_counter() { return ctick; }	70	uint32_t tick_counter() { return ctick; }
71	void set_tick_counter(ulong x);	71	void set_tick_counter(uint32_t x);
72	area_controller *area_list;	72	area_controller *area_list;
73		73
74	void clear_active_list() { first_active=NULL; }	74	void clear_active_list() { first_active=NULL; }
Lines 79-88 Link Here
79		79
80	game_object *first_object() { return first; }	80	game_object *first_object() { return first; }
81	game_object *first_active_object() { return first_active; }	81	game_object *first_active_object() { return first_active; }
82	unsigned short foreground_width() { return fg_width; }	82	uint16_t foreground_width() { return fg_width; }
83	unsigned short foreground_height() { return fg_height; }	83	uint16_t foreground_height() { return fg_height; }
84	unsigned short background_width() { return bg_width; }	84	uint16_t background_width() { return bg_width; }
85	unsigned short background_height() { return bg_height; }	85	uint16_t background_height() { return bg_height; }
86	int load_failed() { return map_fg==NULL; }	86	int load_failed() { return map_fg==NULL; }
87	level(spec_directory sd, bFILE fp, char *lev_name);	87	level(spec_directory sd, bFILE fp, char *lev_name);
88	void load_fail();	88	void load_fail();
Lines 97-122 Link Here
97	int fg_raised(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);	97	int fg_raised(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
98	return ((map_fg+x+yfg_width))&0x4000; }	98	return ((map_fg+x+yfg_width))&0x4000; }
99	void fg_set_raised(int x, int y, int r) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);	99	void fg_set_raised(int x, int y, int r) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
100	ushort v=((map_fg+x+yfg_width))&(0xffff-0x4000);	100	uint16_t v=((map_fg+x+yfg_width))&(0xffff-0x4000);
101	if (r) ((map_fg+x+yfg_width))=v\|0x4000;	101	if (r) ((map_fg+x+yfg_width))=v\|0x4000;
102	else ((map_fg+x+yfg_width))=v;	102	else ((map_fg+x+yfg_width))=v;
103	}	103	}
104	void mark_seen(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);	104	void mark_seen(int x, int y) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
105	((map_fg+x+yfg_width))\|=0x8000; }	105	((map_fg+x+yfg_width))\|=0x8000; }
106	void clear_fg(long x, long y) { (map_fg+x+yfg_width)&=0x7fff; }	106	void clear_fg(int32_t x, int32_t y) { (map_fg+x+yfg_width)&=0x7fff; }
107		107
108	unsigned short get_fgline(int y) { CHECK(y>=0 && y<fg_height); return map_fg+yfg_width; }	108	uint16_t get_fgline(int y) { CHECK(y>=0 && y<fg_height); return map_fg+yfg_width; }
109	unsigned short get_bgline(int y) { CHECK(y>=0 && y<bg_height); return map_bg+ybg_width; }	109	uint16_t get_bgline(int y) { CHECK(y>=0 && y<bg_height); return map_bg+ybg_width; }
110	unsigned short get_fg(int x, int y) { if (x>=0 && y>=0 && x<fg_width && y<fg_height)	110	uint16_t get_fg(int x, int y) { if (x>=0 && y>=0 && x<fg_width && y<fg_height)
111	return fgvalue((map_fg+x+yfg_width));	111	return fgvalue((map_fg+x+yfg_width));
112	else return 0;	112	else return 0;
113	}	113	}
114	unsigned short get_bg(int x, int y) { if (x>=0 && y>=0 && x<bg_width && y<bg_height)	114	uint16_t get_bg(int x, int y) { if (x>=0 && y>=0 && x<bg_width && y<bg_height)
115	return (map_bg+x+ybg_width);	115	return (map_bg+x+ybg_width);
116	else return 0;	116	else return 0;
117	}	117	}
118	void put_fg(int x, int y, unsigned short tile) { (map_fg+x+yfg_width)=tile; }	118	void put_fg(int x, int y, uint16_t tile) { (map_fg+x+yfg_width)=tile; }
119	void put_bg(int x, int y, unsigned short tile) { (map_bg+x+ybg_width)=tile; }	119	void put_bg(int x, int y, uint16_t tile) { (map_bg+x+ybg_width)=tile; }
120	void draw_objects(view *v);	120	void draw_objects(view *v);
121	void interpolate_draw_objects(view *v);	121	void interpolate_draw_objects(view *v);
122	void draw_areas(view *v);	122	void draw_areas(view *v);
Lines 140-163 Link Here
140		140
141	void unactivate_all();	141	void unactivate_all();
142	// forms all the objects in processing range into a linked list	142	// forms all the objects in processing range into a linked list
143	int add_actives(long x1, long y1, long x2, long y2); //returns total added	143	int add_actives(int32_t x1, int32_t y1, int32_t x2, int32_t y2); //returns total added
144	void pull_actives(game_object o, game_object &last_active, int &t);	144	void pull_actives(game_object o, game_object &last_active, int &t);
145	int add_drawables(long x1, long y1, long x2, long y2); //returns total added	145	int add_drawables(int32_t x1, int32_t y1, int32_t x2, int32_t y2); //returns total added
146		146
147	game_object *find_object(long x, long y);	147	game_object *find_object(int32_t x, int32_t y);
148		148
149	game_object damage_intersect(long x1, long y1, long &x2, long &y2, game_object exclude);	149	game_object damage_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2, game_object exclude);
150	game_object boundary_setback(game_object subject, long x1, long y1, long &x2, long &y2);	150	game_object boundary_setback(game_object subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
151	game_object all_boundary_setback(game_object subject, long x1, long y1, long &x2, long &y2);	151	game_object all_boundary_setback(game_object subject, int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
152	int crush(game_object *by_who, int xamount, int yamount);	152	int crush(game_object *by_who, int xamount, int yamount);
153	int push_characters(game_object *by_who, int xamount, int yamount); // return 0 if fail on any.	153	int push_characters(game_object *by_who, int xamount, int yamount); // return 0 if fail on any.
154	int platform_push(game_object *by_who, int xamount, int yamount);	154	int platform_push(game_object *by_who, int xamount, int yamount);
155	void foreground_intersect(long x1, long y1, long &x2, long &y2);	155	void foreground_intersect(int32_t x1, int32_t y1, int32_t &x2, int32_t &y2);
156	void vforeground_intersect(long x1, long y1, long &y2);	156	void vforeground_intersect(int32_t x1, int32_t y1, int32_t &y2);
157		157
158	void hurt_radius(long x, long y,long r, long m, game_object from, game_object exclude,	158	void hurt_radius(int32_t x, int32_t y,int32_t r, int32_t m, game_object from, game_object exclude,
159	int max_push);	159	int max_push);
160	void send_signal(long signal);	160	void send_signal(int32_t signal);
161	void next_focus();	161	void next_focus();
162	void to_front(game_object *o);	162	void to_front(game_object *o);
163	void to_back(game_object *o);	163	void to_back(game_object *o);
Lines 181-191 Link Here
181	bFILE create_dir(char filename, int save_all,	181	bFILE create_dir(char filename, int save_all,
182	object_node save_list, object_node exclude_list);	182	object_node save_list, object_node exclude_list);
183	view *make_view_list(int nplayers);	183	view *make_view_list(int nplayers);
184	long total_light_links(object_node *list);	184	int32_t total_light_links(object_node *list);
185	long total_object_links(object_node *save_list);	185	int32_t total_object_links(object_node *save_list);
186	game_object *find_object_in_area(long x, long y, long x1, long y1,	186	game_object *find_object_in_area(int32_t x, int32_t y, int32_t x1, int32_t y1,
187	long x2, long y2, Cell list, game_object exclude);	187	int32_t x2, int32_t y2, Cell list, game_object exclude);
188	game_object *find_object_in_angle(long x, long y, long start_angle, long end_angle,	188	game_object *find_object_in_angle(int32_t x, int32_t y, int32_t start_angle, int32_t end_angle,
189	void list, game_object exclude);	189	void list, game_object exclude);
190	object_node make_not_list(object_node list);	190	object_node make_not_list(object_node list);
191	int load_player_info(bFILE fp, spec_directory sd, object_node *save_list);	191	int load_player_info(bFILE fp, spec_directory sd, object_node *save_list);

Lines 45-51 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/game.hpp (-8 / +8 lines)
45		45
46	extern char **start_argv;	46	extern char **start_argv;
47	extern int start_argc;	47	extern int start_argc;
48	extern long current_vxadd,current_vyadd;	48	extern int32_t current_vxadd,current_vyadd;
49	extern int frame_panic,massive_frame_panic;	49	extern int frame_panic,massive_frame_panic;
50	extern int demo_start,idle_ticks;	50	extern int demo_start,idle_ticks;
51		51
Lines 57-63 Link Here
57	int bright_color,med_color,dark_color, // for boundaries and windows, etc	57	int bright_color,med_color,dark_color, // for boundaries and windows, etc
58	morph_bright_color,morph_med_color,morph_dark_color;	58	morph_bright_color,morph_med_color,morph_dark_color;
59		59
60	long last_time,fps;	60	int32_t last_time,fps;
61	char mapname[100],command[200],help_text[200];	61	char mapname[100],command[200],help_text[200];
62	int refresh,mousex,mousey,help_text_frames;	62	int refresh,mousex,mousey,help_text_frames;
63	int has_joystick,no_delay;	63	int has_joystick,no_delay;
Lines 65-71 Link Here
65		65
66	jwindow top_menu,joy_win,*last_input;	66	jwindow top_menu,joy_win,*last_input;
67	JCFont *game_font;	67	JCFont *game_font;
68	uchar keymap[512/8];	68	uint8_t keymap[512/8];
69		69
70	public :	70	public :
71	int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }	71	int key_down(int key) { return keymap[key/8]&(1<<(key%8)); }
Lines 92-105 Link Here
92	return cash.foret(foretiles[BLACK]); else	92	return cash.foret(foretiles[BLACK]); else
93	return cash.foret(foretiles[x]); }	93	return cash.foret(foretiles[x]); }
94		94
95	void ftile_on(int screenx, int screeny, long &x, long &y);	95	void ftile_on(int screenx, int screeny, int32_t &x, int32_t &y);
96	void btile_on(int screenx, int screeny, long &x, long &y);	96	void btile_on(int screenx, int screeny, int32_t &x, int32_t &y);
97	void toggle_delay();	97	void toggle_delay();
98	void set_delay(int on) { no_delay=!on; }	98	void set_delay(int on) { no_delay=!on; }
99	void pan(int xv, int yv);	99	void pan(int xv, int yv);
100		100
101	void mouse_to_game(long x, long y, long &gamex, long &gamey, view *v=NULL);	101	void mouse_to_game(int32_t x, int32_t y, int32_t &gamex, int32_t &gamey, view *v=NULL);
102	void game_to_mouse(long gamex, long gamey, view *which, long &x, long &y);	102	void game_to_mouse(int32_t gamex, int32_t gamey, view *which, int32_t &x, int32_t &y);
103	view *view_in(int mousex, int mousey);	103	view *view_in(int mousex, int mousey);
104		104
105	int calc_speed();	105	int calc_speed();
Lines 138-144 Link Here
138	void set_state(int new_state);	138	void set_state(int new_state);
139	int game_over();	139	int game_over();
140	void grow_views(int amount);	140	void grow_views(int amount);
141	void play_sound(int id, int vol, long x, long y);	141	void play_sound(int id, int vol, int32_t x, int32_t y);
142	void request_level_load(char *name);	142	void request_level_load(char *name);
143	void request_end();	143	void request_end();
144	~game();	144	~game();

Lines 22-39 Link Here

(-)abuse-sdl-0.7.0.orig/src/include/extend.hpp (-69 / +69 lines)
22	class simple_object	22	class simple_object
23	{	23	{
24	public :	24	public :
25	schar Fade_dir;	25	int8_t Fade_dir;
26	uchar Fade_count,Fade_max;	26	uint8_t Fade_count,Fade_max;
27	uchar Flags,grav_on,targetable_on;	27	uint8_t Flags,grav_on,targetable_on;
28	long Xvel,Yvel,Xacel,Yacel;	28	int32_t Xvel,Yvel,Xacel,Yacel;
29	uchar Fx,Fy,Fxvel,Fyvel,Fxacel,Fyacel;	29	uint8_t Fx,Fy,Fxvel,Fyvel,Fxacel,Fyacel;
30	uchar Aitype;	30	uint8_t Aitype;
31	ushort Aistate,Aistate_time;	31	uint16_t Aistate,Aistate_time;
32	unsigned short Hp,Mp,Fmp;	32	uint16_t Hp,Mp,Fmp;
33	schar Frame_dir;	33	int8_t Frame_dir;
34		34
35		35
36	uchar tobjs,tlights;	36	uint8_t tobjs,tlights;
37	game_object *objs,link;	37	game_object *objs,link;
38	light_source **lights;	38	light_source **lights;
39		39
Lines 42-56 Link Here
42	int total_vars();	42	int total_vars();
43	char *var_name(int x);	43	char *var_name(int x);
44	int var_type(int x);	44	int var_type(int x);
45	void set_var(int x, ulong v);	45	void set_var(int x, uint32_t v);
46	long get_var(int x);	46	int32_t get_var(int x);
47		47
48	// leave these public, so I don't have monster code changes.	48	// leave these public, so I don't have monster code changes.
49	simple_object();	49	simple_object();
50	long x,y,	50	int32_t x,y,
51	last_x,last_y; // used for frame interpolation on fast machines	51	last_x,last_y; // used for frame interpolation on fast machines
52	schar direction,active;	52	int8_t direction,active;
53	ushort otype;	53	uint16_t otype;
54	character_state state;	54	character_state state;
55	short current_frame;	55	short current_frame;
56		56
Lines 59-96 Link Here
59	int floating() { return flags()&FLOATING_FLAG; }	59	int floating() { return flags()&FLOATING_FLAG; }
60		60
61	int keep_ai_info() { return 1; }	61	int keep_ai_info() { return 1; }
62	uchar flags() { return Flags; }	62	uint8_t flags() { return Flags; }
63	long xvel() { return Xvel; }	63	int32_t xvel() { return Xvel; }
64	long yvel() { return Yvel; }	64	int32_t yvel() { return Yvel; }
65	long xacel() { return Xacel; }	65	int32_t xacel() { return Xacel; }
66	long yacel() { return Yacel; }	66	int32_t yacel() { return Yacel; }
67		67
68	uchar fx() { return Fx; }	68	uint8_t fx() { return Fx; }
69	uchar fy() { return Fy; }	69	uint8_t fy() { return Fy; }
70	uchar fxvel() { return Fxvel; }	70	uint8_t fxvel() { return Fxvel; }
71	uchar fyvel() { return Fyvel; }	71	uint8_t fyvel() { return Fyvel; }
72	uchar fxacel() { return Fxacel; }	72	uint8_t fxacel() { return Fxacel; }
73	uchar fyacel() { return Fyacel; }	73	uint8_t fyacel() { return Fyacel; }
74		74
75	uchar sfx() { return Fx; } // x & y should always be positive	75	uint8_t sfx() { return Fx; } // x & y should always be positive
76	uchar sfy() { return Fy; }	76	uint8_t sfy() { return Fy; }
77	uchar sfxvel() { if (Xvel>=0) return Fxvel; else return -Fxvel; }	77	uint8_t sfxvel() { if (Xvel>=0) return Fxvel; else return -Fxvel; }
78	uchar sfyvel() { if (Yvel>=0) return Fyvel; else return -Fyvel; }	78	uint8_t sfyvel() { if (Yvel>=0) return Fyvel; else return -Fyvel; }
79	uchar sfxacel() { if (Xacel>=0) return Fxacel; else return -Fxacel; }	79	uint8_t sfxacel() { if (Xacel>=0) return Fxacel; else return -Fxacel; }
80	uchar sfyacel() { if (Yacel>=0) return Fyacel; else return -Fyacel; }	80	uint8_t sfyacel() { if (Yacel>=0) return Fyacel; else return -Fyacel; }
81		81
82	uchar aitype() { return Aitype; }	82	uint8_t aitype() { return Aitype; }
83	ushort aistate() { return Aistate; }	83	uint16_t aistate() { return Aistate; }
84	ushort aistate_time() { return Aistate_time; }	84	uint16_t aistate_time() { return Aistate_time; }
85	ushort hp() { return Hp; }	85	uint16_t hp() { return Hp; }
86	ushort mp() { return Mp; }	86	uint16_t mp() { return Mp; }
87	ushort fmp() { return Fmp; }	87	uint16_t fmp() { return Fmp; }
88	schar fade_dir() { return Fade_dir; }	88	int8_t fade_dir() { return Fade_dir; }
89	schar frame_dir() { return Frame_dir; }	89	int8_t frame_dir() { return Frame_dir; }
90	uchar fade_count() { return Fade_count; }	90	uint8_t fade_count() { return Fade_count; }
91	uchar fade_max() { return Fade_max; }	91	uint8_t fade_max() { return Fade_max; }
92	uchar total_objects() { return tobjs; }	92	uint8_t total_objects() { return tobjs; }
93	uchar total_lights() { return tlights; }	93	uint8_t total_lights() { return tlights; }
94		94
95	morph_char *morph_status() { return mc; }	95	morph_char *morph_status() { return mc; }
96	light_source *get_light(int x)	96	light_source *get_light(int x)
Lines 99-130 Link Here
99	{ if (x>=tobjs) { lbreak("bad x for object\n"); exit(0); } return objs[x]; }	99	{ if (x>=tobjs) { lbreak("bad x for object\n"); exit(0); } return objs[x]; }
100	view *controller() { return Controller; }	100	view *controller() { return Controller; }
101		101
102	void set_targetable(uchar x) { targetable_on=x; }	102	void set_targetable(uint8_t x) { targetable_on=x; }
103	void set_flags(uchar f) { Flags=f; }	103	void set_flags(uint8_t f) { Flags=f; }
104	void set_xvel(long xv) { Xvel=xv; }	104	void set_xvel(int32_t xv) { Xvel=xv; }
105	void set_yvel(long yv) { Yvel=yv; }	105	void set_yvel(int32_t yv) { Yvel=yv; }
106	void set_xacel(long xa) { Xacel=xa; }	106	void set_xacel(int32_t xa) { Xacel=xa; }
107	void set_yacel(long ya) { Yacel=ya; }	107	void set_yacel(int32_t ya) { Yacel=ya; }
108	void set_fx(uchar x) { Fx=x; }	108	void set_fx(uint8_t x) { Fx=x; }
109	void set_fy(uchar y) { Fy=y; }	109	void set_fy(uint8_t y) { Fy=y; }
110	void set_fxvel(uchar xv) { Fxvel=abs(xv); }	110	void set_fxvel(uint8_t xv) { Fxvel=abs(xv); }
111	void set_fyvel(uchar yv) { Fyvel=abs(yv); }	111	void set_fyvel(uint8_t yv) { Fyvel=abs(yv); }
112	void set_fxacel(uchar xa) { Fxacel=abs(xa); }	112	void set_fxacel(uint8_t xa) { Fxacel=abs(xa); }
113	void set_fyacel(uchar ya) { Fyacel=abs(ya); }	113	void set_fyacel(uint8_t ya) { Fyacel=abs(ya); }
114	void set_aitype(uchar t) { Aitype=t; }	114	void set_aitype(uint8_t t) { Aitype=t; }
115	void set_aistate(ushort s) { Aistate=s; }	115	void set_aistate(uint16_t s) { Aistate=s; }
116	void set_aistate_time(ushort t) { Aistate_time=t; }	116	void set_aistate_time(uint16_t t) { Aistate_time=t; }
117	void set_hp(ushort h) { Hp=h; }	117	void set_hp(uint16_t h) { Hp=h; }
118	void set_mp(ushort m) { Mp=m; }	118	void set_mp(uint16_t m) { Mp=m; }
119	void set_fmp(ushort m) { Fmp=m; }	119	void set_fmp(uint16_t m) { Fmp=m; }
120		120
121		121
122		122
123	void set_fade_count(uchar f) { Fade_count=f; }	123	void set_fade_count(uint8_t f) { Fade_count=f; }
124	void set_fade_max(uchar m) { Fade_max=m; }	124	void set_fade_max(uint8_t m) { Fade_max=m; }
125	void set_fade_dir(schar d) { Fade_dir=d; }	125	void set_fade_dir(int8_t d) { Fade_dir=d; }
126		126
127	void set_frame_dir(schar d) { Frame_dir=d; }	127	void set_frame_dir(int8_t d) { Frame_dir=d; }
128	void add_light(light_source *ls);	128	void add_light(light_source *ls);
129	void add_object(game_object *o);	129	void add_object(game_object *o);
130		130