Main Page | Class List | Directories | File List | Class Members | File Members

mappyal.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  BLKSTR
struct  ANISTR

Defines

#define MER_NONE   0
#define MER_OUTOFMEM   1
#define MER_MAPLOADERROR   2
#define MER_NOOPEN   3
#define MER_NOSCREEN   4
#define MER_NOACCELERATION   5
#define MER_CVBFAILED   6
#define AN_END   -1
#define AN_NONE   0
#define AN_LOOPF   1
#define AN_LOOPR   2
#define AN_ONCE   3
#define AN_ONCEH   4
#define AN_PPFF   5
#define AN_PPRR   6
#define AN_PPRF   7
#define AN_PPFR   8
#define AN_ONCES   9
#define MapDraw8BG   MapDrawBG
#define MapDraw8BGT   MapDrawBGT
#define MapDraw8FG   MapDrawFG
#define MapDraw15BG   MapDrawBG
#define MapDraw15BGT   MapDrawBGT
#define MapDraw15FG   MapDrawFG
#define MapDraw16BG   MapDrawBG
#define MapDraw16BGT   MapDrawBGT
#define MapDraw16FG   MapDrawFG
#define MapDraw32BG   MapDrawBG
#define MapDraw32BGT   MapDrawBGT
#define MapDraw32FG   MapDrawFG

Functions

void Mapconv8to6pal (unsigned char *)
void MapFreeMem (void)
void MapSetPal8 (void)
void MapCorrectColours (void)
int MapRelocate (void)
int MapLoad (char *)
int MapLoadVRAM (char *)
int MapLoadABM (char *)
int MapDecode (unsigned char *)
int MapDecodeVRAM (unsigned char *)
int MapDecodeABM (unsigned char *)
int MapLoadMAR (char *, int)
int MapDecodeMAR (unsigned char *, int)
int MapGetBlockID (int, int)
int MapGenerateYLookup (void)
int MapChangeLayer (int)
int MapGetXOffset (int, int)
int MapGetYOffset (int, int)
BLKSTRMapGetBlockInPixels (int, int)
BLKSTRMapGetBlock (int, int)
void MapSetBlockInPixels (int, int, int)
void MapSetBlock (int, int, int)
void MapRestore (void)
void MapInitAnims (void)
void MapUpdateAnims (void)
void MapDrawBG (BITMAP *, int, int, int, int, int, int)
void MapDrawBGT (BITMAP *, int, int, int, int, int, int)
void MapDrawFG (BITMAP *, int, int, int, int, int, int, int)
void MapDrawRow (BITMAP *, int, int, int, int, int, int, int, void(*cellcall)(int cx, int cy, int dx, int dy))
BITMAP * MapMakeParallaxBitmap (BITMAP *, int)
void MapDrawParallax (BITMAP *, BITMAP *, int, int, int, int, int, int)

Variables

int maperror
short int mapwidth
short int mapheight
short int mapblockwidth
short int mapblockheight
short int mapdepth
short int mapblockstrsize
short int mapnumblockstr
short int mapnumblockgfx
short int * mappt
short int ** maparraypt
char * mapcmappt
char * mapblockgfxpt
char * mapblockstrpt
ANISTRmapanimstrpt
ANISTRmapanimstrendpt
RGB * mapcmap6bit
short int ** mapmappt
short int *** mapmaparraypt
BITMAP ** abmTiles
int mapblocksinvidmem
int mapblocksinsysmem
int mapblockgapx
int mapblockgapy
int mapblockstaggerx
int mapblockstaggery


Define Documentation

#define AN_END   -1
 

Definition at line 16 of file mappyal.h.

#define AN_LOOPF   1
 

Definition at line 18 of file mappyal.h.

Referenced by MapUpdateAnims().

#define AN_LOOPR   2
 

Definition at line 19 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_NONE   0
 

Definition at line 17 of file mappyal.h.

Referenced by MapUpdateAnims().

#define AN_ONCE   3
 

Definition at line 20 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_ONCEH   4
 

Definition at line 21 of file mappyal.h.

Referenced by MapUpdateAnims().

#define AN_ONCES   9
 

Definition at line 26 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_PPFF   5
 

Definition at line 22 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_PPFR   8
 

Definition at line 25 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_PPRF   7
 

Definition at line 24 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define AN_PPRR   6
 

Definition at line 23 of file mappyal.h.

Referenced by MapInitAnims(), and MapUpdateAnims().

#define MapDraw15BG   MapDrawBG
 

Definition at line 32 of file mappyal.h.

#define MapDraw15BGT   MapDrawBGT
 

Definition at line 33 of file mappyal.h.

#define MapDraw15FG   MapDrawFG
 

Definition at line 34 of file mappyal.h.

#define MapDraw16BG   MapDrawBG
 

Definition at line 35 of file mappyal.h.

#define MapDraw16BGT   MapDrawBGT
 

Definition at line 36 of file mappyal.h.

#define MapDraw16FG   MapDrawFG
 

Definition at line 37 of file mappyal.h.

#define MapDraw32BG   MapDrawBG
 

Definition at line 38 of file mappyal.h.

#define MapDraw32BGT   MapDrawBGT
 

Definition at line 39 of file mappyal.h.

#define MapDraw32FG   MapDrawFG
 

Definition at line 40 of file mappyal.h.

#define MapDraw8BG   MapDrawBG
 

Definition at line 29 of file mappyal.h.

#define MapDraw8BGT   MapDrawBGT
 

Definition at line 30 of file mappyal.h.

#define MapDraw8FG   MapDrawFG
 

Definition at line 31 of file mappyal.h.

#define MER_CVBFAILED   6
 

Definition at line 14 of file mappyal.h.

Referenced by MapRelocate2().

#define MER_MAPLOADERROR   2
 

Definition at line 10 of file mappyal.h.

Referenced by MapPreRealDecode(), MapRealDecode(), and MapRealLoad().

#define MER_NOACCELERATION   5
 

Definition at line 13 of file mappyal.h.

Referenced by MapRelocate().

#define MER_NONE   0
 

Definition at line 8 of file mappyal.h.

Referenced by MapRealDecode(), and MapRealLoad().

#define MER_NOOPEN   3
 

Definition at line 11 of file mappyal.h.

Referenced by MapRealLoad().

#define MER_NOSCREEN   4
 

Definition at line 12 of file mappyal.h.

Referenced by MapRelocate().

#define MER_OUTOFMEM   1
 

Definition at line 9 of file mappyal.h.

Referenced by MapDecodeAGFX(), MapDecodeANDT(), MapDecodeBGFX(), MapDecodeBKDT(), MapDecodeCMAP(), MapDecodeLayer(), MapRealDecode(), and MapRelocate().


Function Documentation

int MapChangeLayer int   ) 
 

Definition at line 258 of file mappyal.c.

References maparraypt, mapmaparraypt, mapmappt, and mappt.

00259 {
00260   if (newlyr<0 || newlyr>7 || mapmappt[newlyr] == NULL) return -1;
00261   mappt = mapmappt[newlyr]; maparraypt = mapmaparraypt[newlyr];
00262   return newlyr;
00263 }

void Mapconv8to6pal unsigned char *   ) 
 

Definition at line 443 of file mappyal.c.

References mapcmap6bit.

Referenced by MapDecodeCMAP().

00444 {
00445   int i;
00446   for (i=0;i<256;i++)
00447     {
00448       mapcmap6bit[i].r=(*(palpt)>>2);
00449       mapcmap6bit[i].g=(*(palpt+1)>>2);
00450       mapcmap6bit[i].b=(*(palpt+2)>>2);
00451       palpt+=3;
00452     }
00453 }

void MapCorrectColours void   ) 
 

Definition at line 480 of file mappyal.c.

00481 {
00482   /* Remember, Intel stores shorts and longs the wrong way round!
00483    * ie. 0x12345678 will be 0x78563412
00484    */
00485   return;
00486 }

int MapDecode unsigned char *   ) 
 

Definition at line 1260 of file mappyal.c.

References mapgfxinbitmaps, and MapPreRealDecode().

01261 {
01262   mapgfxinbitmaps = 2;
01263   return MapPreRealDecode (mapmempt);
01264 }

Here is the call graph for this function:

int MapDecodeABM unsigned char *   ) 
 

Definition at line 1272 of file mappyal.c.

References mapgfxinbitmaps, and MapPreRealDecode().

01273 {
01274   mapgfxinbitmaps = 2;
01275   return MapPreRealDecode (mapmempt);
01276 }

Here is the call graph for this function:

int MapDecodeMAR unsigned char *  ,
int 
 

Definition at line 302 of file mappyal.c.

References mapheight, mapmappt, and mapwidth.

00303 {
00304   int i, j;
00305   short int * mymarpt;
00306 
00307   if (marlyr < 0 || marlyr > 7) return -1;
00308 
00309   if (mapmappt[marlyr] == NULL)
00310     mapmappt[marlyr] = malloc (mapwidth*mapheight*sizeof(short int));
00311 
00312   memcpy (mapmappt[marlyr], mrpt, (mapwidth*mapheight*sizeof(short int)));
00313 
00314   mymarpt = mapmappt[marlyr];
00315   j = 0; for (i=0;i<(mapwidth*mapheight);i++) { if (mymarpt[i]&0xF) j = 1; }
00316   if (j == 0) {
00317     for (i=0;i<(mapwidth*mapheight);i++) {
00318       if (mymarpt[i] >= 0) mymarpt[i] /= 32;
00319       else mymarpt[i] /= 16;
00320     }
00321   }
00322 
00323   return 0;
00324 }

int MapDecodeVRAM unsigned char *   ) 
 

Definition at line 1266 of file mappyal.c.

References mapgfxinbitmaps, and MapPreRealDecode().

01267 {
01268   mapgfxinbitmaps = 1;
01269   return MapPreRealDecode (mapmempt);
01270 }

Here is the call graph for this function:

void MapDrawBG BITMAP *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int 
 

Definition at line 1352 of file mappyal.c.

References abmTiles, ANISTR::ancuroff, BLKSTR::bgoff, mapanimseqpt, mapblockgapx, mapblockgapy, mapblockheight, mapblockstaggerx, mapblockstaggery, mapblockstrpt, mapblockwidth, mapgfxinbitmaps, mappt, and mapwidth.

Referenced by MapDrawBGT(), updatemap(), and updateplayer().

01354 {
01355   int i, j, mycl, mycr, myct, mycb, mapvclip, maphclip;
01356   int mbgx, mbgy;
01357   short int *mymappt;
01358   short int *mymap2pt;
01359   BLKSTR *blkdatapt;
01360   ANISTR *myanpt;
01361 
01362   if (!mapgfxinbitmaps) {
01363     return;
01364   } else {
01365     mycl = mapdestpt->cl;
01366     mycr = mapdestpt->cr;
01367     myct = mapdestpt->ct;
01368     mycb = mapdestpt->cb;
01369     set_clip_rect(mapdestpt, mapx, mapy, mapx+mapw-1, mapy+maph-1);
01370     mapxo -= mapblockstaggerx;
01371     mapyo -= mapblockstaggery;
01372     mymappt = (short int *) mappt;
01373     if (mapblockstaggerx || mapblockstaggery) {
01374       mymappt += (mapxo/mapblockgapx)+((mapyo/mapblockgapy)*mapwidth*2);
01375       mbgx = mapblockgapx;
01376       mbgy = mapblockgapy;
01377     } else {
01378       mymappt += (mapxo/mapblockgapx)+((mapyo/mapblockgapy)*mapwidth);
01379       mbgx = 0;
01380       mbgy = 0;
01381     }
01382     mapvclip = mapyo%mapblockgapy;
01383     maphclip = mapxo%mapblockgapx;
01384 
01385     mymap2pt = mymappt;
01386     for (j=((mapy-mapvclip)-mbgy);j<((mapy+maph));j+=mapblockgapy) {
01387       for (i=((mapx-maphclip)-mbgx);i<((mapx+mapw));i+=mapblockgapx) {
01388         if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01389         else { myanpt = mapanimstrendpt + *mymappt;
01390         blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01391         if (mapblockstaggerx || mapblockstaggery) {
01392           if (abmTiles[0] != (BITMAP *) blkdatapt->bgoff)
01393             masked_blit ((BITMAP *) blkdatapt->bgoff, mapdestpt, 0, 0, i, j, mapblockwidth, mapblockheight);
01394         } else {
01395           blit ((BITMAP *) blkdatapt->bgoff, mapdestpt, 0, 0, i, j, mapblockwidth, mapblockheight);
01396         }
01397         mymappt++;
01398       }
01399       if (mapblockstaggerx || mapblockstaggery) {
01400         mymap2pt += mapwidth;
01401         mymappt = mymap2pt;
01402         for (i=(((mapx-maphclip)-mbgx)+mapblockstaggerx);i<((mapx+mapw));i+=mapblockgapx) {
01403           if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01404           else { myanpt = mapanimstrendpt + *mymappt;
01405           blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01406           if (abmTiles[0] != (BITMAP *) blkdatapt->bgoff)
01407             masked_blit ((BITMAP *) blkdatapt->bgoff, mapdestpt, 0, 0, i, j+mapblockstaggery, mapblockwidth, mapblockheight);
01408           mymappt++;
01409         }
01410       }
01411       mymap2pt += mapwidth;
01412       mymappt = mymap2pt;
01413     }
01414 
01415     set_clip_rect(mapdestpt, mycl, myct, mycr+1, mycb+1);
01416   }
01417 }

void MapDrawBGT BITMAP *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int 
 

Definition at line 1419 of file mappyal.c.

References abmTiles, ANISTR::ancuroff, BLKSTR::bgoff, mapanimseqpt, mapblockgapx, mapblockgapy, mapblockheight, mapblockstaggerx, mapblockstaggery, mapblockstrpt, mapblockwidth, MapDrawBG(), mapgfxinbitmaps, mappt, mapwidth, and BLKSTR::trigger.

01421 {
01422   int i, j, mycl, mycr, myct, mycb, mapvclip, maphclip;
01423   short int *mymappt;
01424   short int *mymap2pt;
01425   BLKSTR *blkdatapt;
01426   ANISTR *myanpt;
01427 
01428   if (mapblockstaggerx || mapblockstaggery) {
01429     MapDrawBG (mapdestpt, mapxo, mapyo, mapx, mapy, mapw, maph);
01430     return;
01431   }
01432   if (!mapgfxinbitmaps) {
01433     return;
01434   } else {
01435     mycl = mapdestpt->cl;
01436     mycr = mapdestpt->cr;
01437     myct = mapdestpt->ct;
01438     mycb = mapdestpt->cb;
01439     set_clip_rect(mapdestpt, mapx, mapy, mapx+mapw-1, mapy+maph-1);
01440     mymappt = (short int *) mappt;
01441     mymappt += (mapxo/mapblockgapx)+((mapyo/mapblockgapy)*mapwidth);
01442     mapvclip = mapyo%mapblockgapy;
01443     maphclip = mapxo%mapblockgapx;
01444 
01445     mymap2pt = mymappt;
01446     for (j=(mapy-mapvclip);j<((mapy+maph));j+=mapblockgapy) {
01447       for (i=(mapx-maphclip);i<((mapx+mapw));i+=mapblockgapx) {
01448         if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01449         else { myanpt = mapanimstrendpt + *mymappt;
01450         blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01451         if (blkdatapt->trigger) {
01452           if (abmTiles[0] != (BITMAP *) blkdatapt->bgoff)
01453             masked_blit ((BITMAP *) blkdatapt->bgoff, mapdestpt, 0, 0, i, j, mapblockwidth, mapblockheight);
01454         } else {
01455           blit ((BITMAP *) blkdatapt->bgoff, mapdestpt, 0, 0, i, j, mapblockwidth, mapblockheight);
01456         }
01457         mymappt++;
01458       }
01459       mymap2pt += mapwidth;
01460       mymappt = mymap2pt;
01461     }
01462 
01463     set_clip_rect(mapdestpt, mycl, myct, mycr+1, mycb+1);
01464   }
01465 }

Here is the call graph for this function:

void MapDrawFG BITMAP *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int 
 

Definition at line 1467 of file mappyal.c.

References ANISTR::ancuroff, BLKSTR::fgoff, BLKSTR::fgoff2, BLKSTR::fgoff3, mapanimseqpt, mapblockgapx, mapblockgapy, mapblockheight, mapblockstaggerx, mapblockstaggery, mapblockstrpt, mapblockwidth, mapgfxinbitmaps, mappt, and mapwidth.

Referenced by updatemap(), and updateplayer().

01469 {
01470   int i, j, mycl, mycr, myct, mycb, mapvclip, maphclip;
01471   int mbgx, mbgy;
01472   short int *mymappt;
01473   short int *mymap2pt;
01474   BLKSTR *blkdatapt;
01475   ANISTR *myanpt;
01476   BITMAP *mapgfxpt;
01477 
01478   if (!mapgfxinbitmaps) {
01479     return;
01480   } else {
01481     mycl = mapdestpt->cl;
01482     mycr = mapdestpt->cr;
01483     myct = mapdestpt->ct;
01484     mycb = mapdestpt->cb;
01485     set_clip_rect(mapdestpt, mapx, mapy, mapx+mapw-1, mapy+maph-1);
01486     mapxo -= mapblockstaggerx;
01487     mapyo -= mapblockstaggery;
01488     mymappt = (short int *) mappt;
01489     if (mapblockstaggerx || mapblockstaggery) {
01490       mymappt += (mapxo/mapblockgapx)+((mapyo/mapblockgapy)*mapwidth*2);
01491       mbgx = mapblockgapx;
01492       mbgy = mapblockgapy;
01493     } else {
01494       mymappt += (mapxo/mapblockgapx)+((mapyo/mapblockgapy)*mapwidth);
01495       mbgx = 0;
01496       mbgy = 0;
01497     }
01498     mapvclip = mapyo%mapblockgapy;
01499     maphclip = mapxo%mapblockgapx;
01500 
01501     mymap2pt = mymappt;
01502     for (j=((mapy-mapvclip)-mbgy);j<((mapy+maph));j+=mapblockgapy) {
01503       for (i=((mapx-maphclip)-mbgx);i<((mapx+mapw));i+=mapblockgapx) {
01504         if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01505         else { myanpt = mapanimstrendpt + *mymappt;
01506         blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01507         if (!mapfg) mapgfxpt = (BITMAP *) blkdatapt->fgoff;
01508         else if (mapfg == 1) mapgfxpt = (BITMAP *) blkdatapt->fgoff2;
01509         else mapgfxpt = (BITMAP *) blkdatapt->fgoff3;
01510         if (((int)mapgfxpt) != 0)
01511           masked_blit (mapgfxpt, mapdestpt, 0, 0, i, j, mapblockwidth, mapblockheight);
01512         mymappt++;
01513       }
01514       if (mapblockstaggerx || mapblockstaggery) {
01515         mymap2pt += mapwidth;
01516         mymappt = mymap2pt;
01517         for (i=(((mapx-maphclip)-mbgx)+mapblockstaggerx);i<((mapx+mapw));i+=mapblockgapx) {
01518           if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01519           else { myanpt = mapanimstrendpt + *mymappt;
01520           blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01521           if (!mapfg) mapgfxpt = (BITMAP *) blkdatapt->fgoff;
01522           else if (mapfg == 1) mapgfxpt = (BITMAP *) blkdatapt->fgoff2;
01523           else mapgfxpt = (BITMAP *) blkdatapt->fgoff3;
01524           if (((int)mapgfxpt) != 0)
01525             masked_blit (mapgfxpt, mapdestpt, 0, 0, i, j+mapblockstaggery, mapblockwidth, mapblockheight);
01526           mymappt++;
01527         }
01528       }
01529       mymap2pt += mapwidth;
01530       mymappt = mymap2pt;
01531     }
01532 
01533     set_clip_rect(mapdestpt, mycl, myct, mycr+1, mycb+1);
01534   }
01535 }

void MapDrawParallax BITMAP *  ,
BITMAP *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int 
 

Definition at line 1295 of file mappyal.c.

References ANISTR::ancuroff, mapanimseqpt, mapblockheight, mapblockstaggerx, mapblockstaggery, mapblockstrpt, mapblockwidth, mappt, mapwidth, and BLKSTR::trigger.

01306 {
01307   int mycl, mycr, myct, mycb;
01308   int i, i2, j;
01309   int paraxo, paraxo2, parayo;
01310   short int * mymappt, * mymappt2;
01311   BLKSTR * blkdatapt;
01312   ANISTR * myanpt;
01313 
01314   if (mapblockstaggerx || mapblockstaggery) return;
01315   mycl = mapdestpt->cl;
01316   mycr = mapdestpt->cr;
01317   myct = mapdestpt->ct;
01318   mycb = mapdestpt->cb;
01319   set_clip_rect (mapdestpt, mapx, mapy, mapx+mapw-1, mapy+maph-1);
01320 
01321   mymappt = (short int *) mappt;
01322   mymappt += (mapxo/mapblockwidth)+((mapyo/mapblockheight)*mapwidth);
01323 
01324   paraxo = ((mapxo-(mapxo%mapblockwidth))%(parbm->w-mapblockwidth))-((mapxo/2)%(parbm->w-mapblockwidth));
01325   parayo = ((mapyo-(mapyo%mapblockheight))%(parbm->h-mapblockheight))-((mapyo/2)%(parbm->h-mapblockheight));
01326   while (paraxo < 0) paraxo += (parbm->w-mapblockwidth);
01327   while (parayo < 0) parayo += (parbm->h-mapblockheight);
01328 
01329   i = mapx-(mapxo%mapblockwidth);
01330   j = mapy-(mapyo%mapblockheight);
01331 
01332   i2 = i; paraxo2 = paraxo; mymappt2 = mymappt;
01333   while (j < (mapy+maph)) {
01334     while (i < (mapx+mapw)) {
01335       if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01336       else { myanpt = mapanimstrendpt + *mymappt;
01337       blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01338       if (blkdatapt->trigger)
01339         blit (parbm, mapdestpt, paraxo, parayo, i, j, mapblockwidth, mapblockheight);
01340       paraxo += mapblockwidth;
01341       if (paraxo >= (parbm->w-mapblockwidth)) paraxo -= (parbm->w-mapblockwidth);
01342       i += mapblockwidth; mymappt++;
01343     }
01344     parayo += mapblockheight;
01345     if (parayo >= (parbm->h-mapblockheight)) parayo -= (parbm->h-mapblockheight);
01346     i = i2; paraxo = paraxo2; mymappt2 += mapwidth; mymappt = mymappt2;
01347     j += mapblockheight;
01348   }
01349   set_clip_rect(mapdestpt, mycl, myct, mycr+1, mycb+1);
01350 }

void MapDrawRow BITMAP *  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
void(*)(int cx, int cy, int dx, int dy)  cellcall
 

Definition at line 1537 of file mappyal.c.

References ANISTR::ancuroff, BLKSTR::bgoff, BLKSTR::fgoff, BLKSTR::fgoff2, BLKSTR::fgoff3, mapanimseqpt, mapblockgapx, mapblockgapy, mapblockheight, mapblockstaggerx, mapblockstaggery, mapblockstrpt, mapblockwidth, mapgfxinbitmaps, mapheight, mappt, mapwidth, BLKSTR::unused1, BLKSTR::unused2, and BLKSTR::unused3.

01539 {
01540   int i, j, mycl, mycr, myct, mycb, mapvclip, maphclip;
01541   int mbgx, mbgy, bfield, bysub;
01542   int cx, cy;
01543   short int *mymappt;
01544   short int *mymap2pt;
01545   BLKSTR *blkdatapt;
01546   ANISTR *myanpt;
01547   BITMAP *mapgfxpt;
01548 
01549   if (((mapyo/mapblockgapy)+maprw) >= mapheight) return;
01550   if (mapblockstaggerx || mapblockstaggery) {
01551     mapxo -= mapblockstaggerx;
01552     mapyo -= mapblockstaggery;
01553     if ((((mapyo/mapblockgapy)*2)+maprw) >= (mapheight-1)) return;
01554   }
01555   if (!mapgfxinbitmaps) {
01556     return;
01557   } else {
01558     mycl = mapdestpt->cl;
01559     mycr = mapdestpt->cr;
01560     myct = mapdestpt->ct;
01561     mycb = mapdestpt->cb;
01562     set_clip_rect(mapdestpt, mapx, mapy, mapx+mapw-1, mapy+maph-1);
01563     mymappt = (short int *) mappt;
01564     mapvclip = mapyo%mapblockgapy;
01565     maphclip = mapxo%mapblockgapx;
01566     j = (mapy-mapvclip); i = 0;
01567     if (mapblockstaggerx || mapblockstaggery) {
01568       cx = mapxo/mapblockgapx;
01569       cy = (((mapyo/mapblockgapy)*2)+maprw);
01570       mymappt += (cx)+(cy*mapwidth);
01571       mbgx = mapblockgapx;
01572       mbgy = mapblockgapy;
01573       j -= mbgy;
01574       j += ((maprw/2)*mapblockgapy);
01575       if (maprw&1) { j += mapblockstaggery; i = mapblockstaggerx; }
01576     } else {
01577       cx = mapxo/mapblockgapx;
01578       cy = ((mapyo/mapblockgapy)+maprw);
01579       mymappt += (cx)+(cy*mapwidth);
01580       mbgx = 0;
01581       mbgy = 0;
01582       j += (maprw*mapblockgapy);
01583     }
01584 
01585     mymap2pt = mymappt;
01586     for (i+=((mapx-maphclip)-mbgx);i<((mapx+mapw));i+=mapblockgapx) {
01587       if (cellcall != NULL) cellcall (cx, cy, i, j);
01588       if (*mymappt>=0) blkdatapt = ((BLKSTR*) mapblockstrpt) + *mymappt;
01589       else { myanpt = mapanimstrendpt + *mymappt;
01590       blkdatapt = ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
01591       bfield = 1; bysub = 0;
01592       do {
01593         if (!bfield) blkdatapt++;
01594         for (;bfield<4;bfield++) {
01595           switch (bfield) {
01596           case 0: mapgfxpt = (BITMAP *) blkdatapt->bgoff; break;
01597           case 1: mapgfxpt = (BITMAP *) blkdatapt->fgoff; break;
01598           case 2: mapgfxpt = (BITMAP *) blkdatapt->fgoff2; break;
01599           default:
01600           case 3: mapgfxpt = (BITMAP *) blkdatapt->fgoff3; break;
01601           }
01602           if (((int)mapgfxpt) != 0) {
01603             if (blkdatapt->unused2 && !blkdatapt->unused3) {
01604               masked_blit (mapgfxpt, mapdestpt, 0, 0, i, j-bysub, mapblockwidth/2, mapblockheight);
01605             } else {
01606               if (!blkdatapt->unused2 && blkdatapt->unused3) {
01607                 masked_blit (mapgfxpt, mapdestpt, mapblockwidth/2, 0, i, j-bysub, mapblockwidth/2, mapblockheight);
01608               } else {
01609                 masked_blit (mapgfxpt, mapdestpt, 0, 0, i, j-bysub, mapblockwidth, mapblockheight);
01610               }
01611             }
01612           }
01613           bysub += mapblockheight;
01614         }
01615         bfield = 0;
01616       } while (blkdatapt->unused1);
01617       mymappt++; cx++;
01618     }
01619 
01620     set_clip_rect(mapdestpt, mycl, myct, mycr+1, mycb+1);
01621   }
01622 }

void MapFreeMem void   ) 
 

Definition at line 455 of file mappyal.c.

References abmTiles, mapanimseqpt, maparraypt, mapblockgfxpt, mapblocksinsysmem, mapblocksinvidmem, mapblockstrpt, mapcmappt, mapmaparraypt, mapmappt, mapnovctext, and mappt.

Referenced by main(), MapPreRealDecode(), MapRealDecode(), MapRelocate(), and MapRelocate2().

00456 {
00457   int i;
00458   for (i=0;i<8;i++) { if (mapmappt[i]!=NULL) { free (mapmappt[i]); mapmappt[i] = NULL; } }
00459   mappt = NULL;
00460   for (i=0;i<8;i++) { if (mapmaparraypt[i]!=NULL) { free (mapmaparraypt[i]); mapmaparraypt[i] = NULL; } }
00461   maparraypt = NULL;
00462   if (mapcmappt!=NULL) { free (mapcmappt); mapcmappt = NULL; }
00463   if (mapblockgfxpt!=NULL) { free (mapblockgfxpt); mapblockgfxpt = NULL; }
00464   if (mapblockstrpt!=NULL) { free (mapblockstrpt); mapblockstrpt = NULL; }
00465   if (mapanimseqpt!=NULL) { free (mapanimseqpt); mapanimseqpt = NULL; }
00466   if (mapanimstrpt!=NULL) { free (mapanimstrpt); mapanimstrpt = NULL; }
00467   if (abmTiles != NULL) {
00468     i = 0; while (abmTiles[i]!=NULL) { destroy_bitmap (abmTiles[i]); i++; }
00469     free (abmTiles); abmTiles = NULL;
00470   }
00471   mapnovctext[0] = 0;
00472   mapblocksinvidmem = 0; mapblocksinsysmem = 0;
00473 }

int MapGenerateYLookup void   ) 
 

Definition at line 92 of file mappyal.c.

References maparraypt, mapheight, mapmaparraypt, mapmappt, mappt, and mapwidth.

00093 {
00094 int i, j;
00095 
00096         for (i=0;i<8;i++) {
00097                 if (mapmaparraypt[i]!=NULL) { free (mapmaparraypt[i]); mapmaparraypt[i] = NULL; }
00098                 if (mapmappt[i]!=NULL) {
00099                         mapmaparraypt[i] = malloc (mapheight*sizeof(short int *));
00100                         if (mapmaparraypt[i] == NULL) return -1;
00101                         for (j=0;j<mapheight;j++) mapmaparraypt[i][j] = (mapmappt[i]+(j*mapwidth));
00102                         if (mapmappt[i] == mappt) maparraypt = mapmaparraypt[i];
00103                 }
00104         }
00105         return 0;
00106 }

BLKSTR* MapGetBlock int  ,
int 
 

Definition at line 207 of file mappyal.c.

References ANISTR::ancuroff, mapanimseqpt, maparraypt, mapblockstrpt, mappt, and mapwidth.

Referenced by collided().

00208 {
00209   short int * mymappt;
00210   ANISTR * myanpt;
00211 
00212   if (maparraypt!= NULL) {
00213     mymappt = maparraypt[y]+x;
00214   } else {
00215     mymappt = mappt;
00216     mymappt += x;
00217     mymappt += y*mapwidth;
00218   }
00219   if (*mymappt>=0) return ((BLKSTR*) mapblockstrpt) + *mymappt;
00220   else { myanpt = mapanimstrendpt + *mymappt;
00221   return ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
00222 }

int MapGetBlockID int  ,
int 
 

Definition at line 265 of file mappyal.c.

References mapblockstrpt, and mapnumblockstr.

00266 {
00267   int i;
00268   BLKSTR * myblkpt;
00269 
00270   myblkpt = (BLKSTR *) mapblockstrpt;
00271   if (myblkpt == NULL) return -1;
00272 
00273   for (i=0;i<mapnumblockstr;i++) {
00274     switch (usernum) {
00275     case 1:
00276       if (myblkpt[i].user1 == blid) return i;
00277       break;
00278     case 2:
00279       if (myblkpt[i].user2 == blid) return i;
00280       break;
00281     case 3:
00282       if (myblkpt[i].user3 == blid) return i;
00283       break;
00284     case 4:
00285       if (myblkpt[i].user4 == blid) return i;
00286       break;
00287     case 5:
00288       if (myblkpt[i].user5 == blid) return i;
00289       break;
00290     case 6:
00291       if (myblkpt[i].user6 == blid) return i;
00292       break;
00293     case 7:
00294       if (myblkpt[i].user7 == blid) return i;
00295       break;
00296     }
00297   }
00298 
00299   return -1;
00300 }

BLKSTR* MapGetBlockInPixels int  ,
int 
 

Definition at line 183 of file mappyal.c.

References ANISTR::ancuroff, mapanimseqpt, maparraypt, mapblockheight, mapblockstrpt, mapblockwidth, MapGetXOffset(), MapGetYOffset(), mapheight, mappt, and mapwidth.

00184 {
00185   int xp, yp;
00186   short int * mymappt;
00187   ANISTR * myanpt;
00188 
00189   if (x < 0 || y < 0 || x >= (mapwidth*mapblockwidth) || y >= (mapheight*mapblockheight)) return NULL;
00190 
00191   xp = x; yp = y;
00192   x = MapGetXOffset (xp, yp);
00193   y = MapGetYOffset (xp, yp);
00194 
00195   if (maparraypt!= NULL) {
00196     mymappt = maparraypt[y]+x;
00197   } else {
00198     mymappt = mappt;
00199     mymappt += x;
00200     mymappt += y*mapwidth;
00201   }
00202   if (*mymappt>=0) return ((BLKSTR*) mapblockstrpt) + *mymappt;
00203   else { myanpt = mapanimstrendpt + *mymappt;
00204   return ((BLKSTR *) mapblockstrpt) + mapanimseqpt[myanpt->ancuroff]; }
00205 }

Here is the call graph for this function:

int MapGetXOffset int  ,
int 
 

Definition at line 146 of file mappyal.c.

References mapblockgapx, mapblockstaggerx, mapblockstaggery, and mapwidth.

Referenced by MapGetBlockInPixels(), and MapSetBlockInPixels().

00147 {
00148   int xb;
00149 
00150   if (mapblockstaggerx || mapblockstaggery) {
00151     xpix += (mapblockstaggerx);
00152     ypix += (mapblockstaggery);
00153   }
00154   xb = xpix/mapblockgapx;
00155 
00156   if ((mapblockstaggerx || mapblockstaggery) && mapclickmask) xb += MEClickmask (xpix, ypix, 0);
00157 
00158   if (xb < 0) xb = 0;
00159   if (xb >= mapwidth) xb = mapwidth-1;
00160   return xb;
00161 }

int MapGetYOffset int  ,
int 
 

Definition at line 163 of file mappyal.c.

References mapblockgapy, mapblockstaggerx, mapblockstaggery, and mapheight.

Referenced by MapGetBlockInPixels(), and MapSetBlockInPixels().

00164 {
00165   int yb;
00166 
00167   if (mapblockstaggerx || mapblockstaggery) {
00168     xpix += (mapblockstaggerx);
00169     ypix += (mapblockstaggery);
00170   }
00171   yb = ypix/mapblockgapy;
00172 
00173   if ((mapblockstaggerx || mapblockstaggery) && mapclickmask) {
00174     yb *= 2;
00175     yb += MEClickmask (xpix, ypix, 1);
00176   }
00177 
00178   if (yb < 0) yb = 0;
00179   if (yb >= mapheight) yb = mapheight-1;
00180   return yb;
00181 }

void MapInitAnims void   ) 
 

Definition at line 358 of file mappyal.c.

References AN_LOOPR, AN_ONCE, AN_ONCES, AN_PPFF, AN_PPFR, AN_PPRF, AN_PPRR, ANISTR::ancount, ANISTR::ancuroff, ANISTR::andelay, ANISTR::anendoff, ANISTR::anstartoff, and ANISTR::antype.

Referenced by MapDecodeANDT().

00359 {
00360   ANISTR * myanpt;
00361   if (mapanimstrpt==NULL) return;
00362   myanpt = (ANISTR *) mapanimstrendpt; myanpt--;
00363   while (myanpt->antype!=-1)
00364     {
00365       if (myanpt->antype==AN_PPFR) myanpt->antype = AN_PPFF;
00366       if (myanpt->antype==AN_PPRF) myanpt->antype = AN_PPRR;
00367       if (myanpt->antype==AN_ONCES) myanpt->antype = AN_ONCE;
00368       if ((myanpt->antype==AN_LOOPR) || (myanpt->antype==AN_PPRR))
00369         {
00370           myanpt->ancuroff = myanpt->anstartoff;
00371           if ((myanpt->anstartoff)!=(myanpt->anendoff)) myanpt->ancuroff=(myanpt->anendoff)-1;
00372         } else {
00373           myanpt->ancuroff = myanpt->anstartoff;
00374         }
00375       myanpt->ancount = myanpt->andelay;
00376       myanpt--;
00377     }
00378 }

int MapLoad char *   ) 
 

Definition at line 1215 of file mappyal.c.

References mapgfxinbitmaps, and MapRealLoad().

Referenced by initialize().

01216 {
01217   mapgfxinbitmaps = 2;
01218   return MapRealLoad (mapname);
01219 }

Here is the call graph for this function:

int MapLoadABM char *   ) 
 

Definition at line 1227 of file mappyal.c.

References mapgfxinbitmaps, and MapRealLoad().

01228 {
01229   mapgfxinbitmaps = 2;
01230   return MapRealLoad (mapname);
01231 }

Here is the call graph for this function:

int MapLoadMAR char *  ,
int 
 

Definition at line 326 of file mappyal.c.

References mapheight, mapmappt, and mapwidth.

00327 {
00328   int i, j;
00329   short int * mymarpt;
00330   PACKFILE * marfpt;
00331 
00332   if (marlyr < 0 || marlyr > 7) return -1;
00333 
00334   marfpt = pack_fopen (mname, "rp");
00335   if (marfpt==NULL) { marfpt = pack_fopen (mname, "r");
00336   if (marfpt==NULL) { return -1; } }
00337 
00338   if (mapmappt[marlyr] == NULL)
00339     mapmappt[marlyr] = malloc (mapwidth*mapheight*sizeof(short int));
00340 
00341   if (pack_fread (mapmappt[marlyr], (mapwidth*mapheight*sizeof(short int)), marfpt) !=
00342       (mapwidth*mapheight*sizeof(short int))) { pack_fclose (marfpt); return -1; }
00343 
00344   pack_fclose (marfpt);
00345 
00346   mymarpt = mapmappt[marlyr];
00347   j = 0; for (i=0;i<(mapwidth*mapheight);i++) { if (mymarpt[i]&0xF) j = 1; }
00348   if (j == 0) {
00349     for (i=0;i<(mapwidth*mapheight);i++) {
00350       if (mymarpt[i] >= 0) mymarpt[i] /= 32;
00351       else mymarpt[i] /= 16;
00352     }
00353   }
00354 
00355   return 0;
00356 }

int MapLoadVRAM char *   ) 
 

Definition at line 1221 of file mappyal.c.

References mapgfxinbitmaps, and MapRealLoad().

01222 {
01223   mapgfxinbitmaps = 1;
01224   return MapRealLoad (mapname);
01225 }

Here is the call graph for this function:

BITMAP* MapMakeParallaxBitmap BITMAP *  ,
int 
 

Definition at line 1278 of file mappyal.c.

References mapblockheight, mapblockwidth, and mappt.

01279 {
01280   BITMAP * newbm;
01281 
01282   if (mappt == NULL) return NULL;
01283   if (style < 0 || style > 1) return NULL;
01284 
01285   if (style) newbm = create_video_bitmap (sourcebm->w+mapblockwidth, sourcebm->h+mapblockheight);
01286   else newbm = create_bitmap (sourcebm->w+mapblockwidth, sourcebm->h+mapblockheight);
01287 
01288   if (newbm == NULL) return NULL;
01289   blit (sourcebm, newbm, 0, 0, 0, 0, sourcebm->w, sourcebm->h);
01290   blit (sourcebm, newbm, 0, 0, 0, sourcebm->h, sourcebm->w, mapblockheight);
01291   blit (newbm, newbm, 0, 0, sourcebm->w, 0, mapblockwidth, sourcebm->h+mapblockheight);
01292   return newbm;
01293 }

int MapRelocate void   ) 
 

Definition at line 622 of file mappyal.c.

References mapblockgfxpt, mapblockheight, mapblockwidth, mapcmappt, mapdepth, maperror, MapFreeMem(), mapgfxinbitmaps, mapnumblockgfx, MapRelocate2(), MER_NOACCELERATION, MER_NOSCREEN, and MER_OUTOFMEM.

Referenced by MapRealDecode().

00623 {
00624   int i, j, cdepth, pixcol, ccr, ccg, ccb;
00625   //BLKSTR * myblkstrpt;
00626   unsigned char * oldgfxpt;
00627   unsigned char * mycmappt;
00628   unsigned char * newgfxpt;
00629   unsigned char * newgfx2pt;
00630 
00631   if (screen == NULL) { MapFreeMem (); maperror = MER_NOSCREEN; return -1; }
00632   if (!gfx_capabilities&GFX_HW_VRAM_BLIT && mapgfxinbitmaps==1)
00633     { MapFreeMem (); maperror = MER_NOACCELERATION; return -1; }
00634   cdepth = bitmap_color_depth (screen);
00635   oldgfxpt = (unsigned char *) mapblockgfxpt;
00636   newgfxpt = (unsigned char *)
00637     malloc (mapblockwidth*mapblockheight*((mapdepth+1)/8)*mapnumblockgfx*((cdepth+1)/8));
00638   if (newgfxpt==NULL) { MapFreeMem (); maperror = MER_OUTOFMEM; return -1; }
00639   newgfx2pt = newgfxpt;
00640   mycmappt = (unsigned char *) mapcmappt; pixcol = 0;
00641   for (i=0;i<(mapblockwidth*mapblockheight*mapnumblockgfx);i++)
00642     {
00643       switch (mapdepth) {
00644       case 8:
00645         if (cdepth==8) pixcol = (int) *oldgfxpt; else {
00646           j = (*oldgfxpt)*3;
00647           pixcol = makecol (mycmappt[j], mycmappt[j+1], mycmappt[j+2]);
00648 #ifdef RB8BITTOPINK
00649           if (j == 0 && cdepth!=8) pixcol = makecol (255, 0, 255); }
00650 #endif
00651         oldgfxpt++;
00652         break;
00653       case 15:
00654         ccr = ((((int) *oldgfxpt)&0x7C)<<1);
00655         ccg = ((((((int) *oldgfxpt)&0x3)<<3)|(((int) *(oldgfxpt+1))>>5))<<3);
00656         ccb = (((int) *(oldgfxpt+1)&0x1F)<<3);
00657         ccr |= ((ccr>>5)&0x07);
00658         ccg |= ((ccg>>5)&0x07);
00659         ccb |= ((ccb>>5)&0x07);
00660         pixcol = makecol (ccr, ccg, ccb);
00661         if (cdepth==8) { if (ccr == 0xFF && ccg == 0 && ccb == 0xFF) pixcol = 0; }
00662         oldgfxpt += 2;
00663         break;
00664       case 16:
00665         ccr = (((int) *oldgfxpt)&0xF8);
00666         ccg = ((((((int) *oldgfxpt)&0x7)<<3)|(((int) *(oldgfxpt+1))>>5))<<2);
00667         ccb = (((int) *(oldgfxpt+1)&0x1F)<<3);
00668         ccr |= ((ccr>>5)&0x07);
00669         ccg |= ((ccg>>6)&0x03);
00670         ccb |= ((ccb>>5)&0x07);
00671         pixcol = makecol (ccr, ccg, ccb);
00672         if (cdepth==8) { if (ccr == 0xFF && ccg == 0 && ccb == 0xFF) pixcol = 0; }
00673         oldgfxpt += 2;
00674         break;
00675       case 24:
00676         pixcol = makecol (*oldgfxpt, *(oldgfxpt+1), *(oldgfxpt+2));
00677         if (cdepth==8) { if (*oldgfxpt == 0xFF && *(oldgfxpt+1) == 0 &&
00678                              *(oldgfxpt+2) == 0xFF) pixcol = 0; }
00679         oldgfxpt += 3;
00680         break;
00681       case 32:
00682         pixcol = makecol (*(oldgfxpt+1), *(oldgfxpt+2), *(oldgfxpt+3));
00683         if (cdepth==8) { if (*(oldgfxpt+1) == 0xFF && *(oldgfxpt+2) == 0 &&
00684                              *(oldgfxpt+3) == 0xFF) pixcol = 0; }
00685         oldgfxpt += 4;
00686         break;
00687       }
00688       switch (cdepth) {
00689       case 8:
00690         *newgfxpt = (unsigned char) pixcol;
00691         newgfxpt++;
00692         break;
00693       case 15:
00694       case 16:
00695         *((unsigned short int *) newgfxpt) = (unsigned short int) pixcol;
00696         newgfxpt+=2;
00697         break;
00698       case 24:
00699         *newgfxpt = (unsigned char) (pixcol>>16)&0xFF;
00700         *(newgfxpt+1) = (unsigned char) (pixcol>>8)&0xFF;
00701         *(newgfxpt+2) = (unsigned char) pixcol&0xFF;
00702         newgfxpt+=3;
00703         break;
00704       case 32:
00705         *newgfxpt = 0;
00706         *(newgfxpt+1) = (unsigned char) (pixcol>>16)&0xFF;
00707         *(newgfxpt+2) = (unsigned char) (pixcol>>8)&0xFF;
00708         *(newgfxpt+3) = (unsigned char) pixcol&0xFF;
00709         newgfxpt+=4;
00710         break;
00711       }
00712     }
00713   free (mapblockgfxpt); mapblockgfxpt = (char *) newgfx2pt;
00714 
00715   mapdepth = cdepth;
00716 
00717   return MapRelocate2 ();
00718 }

Here is the call graph for this function:

void MapRestore void   ) 
 

Definition at line 488 of file mappyal.c.

References abmTiles, mapblockgfxpt, mapblockheight, mapblockwidth, mapdepth, and mapgfxinbitmaps.

00489 {
00490   int i, j, k;
00491   unsigned char * newgfxpt;
00492 
00493   if (mapgfxinbitmaps!=1 || abmTiles == NULL) return;
00494   i = 0; newgfxpt = mapblockgfxpt; while (abmTiles[i]!=NULL) {
00495     acquire_bitmap (abmTiles[i]);
00496     for (k=0;k<mapblockheight;k++) {
00497       for (j=0;j<mapblockwidth;j++) {
00498         switch (mapdepth) {
00499         case 8:
00500           putpixel (abmTiles[i], j, k, *((unsigned char *) newgfxpt));
00501           newgfxpt++;
00502           break;
00503         case 15:
00504         case 16:
00505           putpixel (abmTiles[i], j, k, *((unsigned short int *) newgfxpt));
00506           newgfxpt+=2;
00507           break;
00508         case 24:
00509           putpixel (abmTiles[i], j, k, makecol (newgfxpt[0], newgfxpt[1], newgfxpt[2]));
00510           newgfxpt+=3;
00511           break;
00512         case 32:
00513           putpixel (abmTiles[i], j, k, makecol (newgfxpt[1], newgfxpt[2], newgfxpt[3]));
00514           newgfxpt+=4;
00515           break;
00516         } } }
00517     release_bitmap (abmTiles[i]);
00518     i++;
00519   }
00520 }

void MapSetBlock int  ,
int  ,
int 
 

Definition at line 244 of file mappyal.c.

References maparraypt, mappt, and mapwidth.

00245 {
00246   short int * mymappt;
00247 
00248   if (maparraypt!= NULL) {
00249     mymappt = maparraypt[y]+x;
00250   } else {
00251     mymappt = mappt;
00252     mymappt += x;
00253     mymappt += y*mapwidth;
00254   }
00255   *mymappt = strvalue;
00256 }

void MapSetBlockInPixels int  ,
int  ,
int 
 

Definition at line 224 of file mappyal.c.

References maparraypt, mapblockheight, mapblockwidth, MapGetXOffset(), MapGetYOffset(), mapheight, mappt, and mapwidth.

00225 {
00226   int xp, yp;
00227   short int * mymappt;
00228 
00229   if (x < 0 || y < 0 || x >= (mapwidth*mapblockwidth) || y >= (mapheight*mapblockheight)) return;
00230   xp = x; yp = y;
00231   x = MapGetXOffset (xp, yp);
00232   y = MapGetYOffset (xp, yp);
00233 
00234   if (maparraypt!= NULL) {
00235     mymappt = maparraypt[y]+x;
00236   } else {
00237     mymappt = mappt;
00238     mymappt += x;
00239     mymappt += y*mapwidth;
00240   }
00241   *mymappt = strvalue;
00242 }

Here is the call graph for this function:

void MapSetPal8 void   ) 
 

Definition at line 475 of file mappyal.c.

References mapcmap6bit, and mapdepth.

00476 {
00477   if (screen!=NULL) { if ((bitmap_color_depth (screen)==8) && mapdepth == 8) set_palette (mapcmap6bit); }
00478 }

void MapUpdateAnims void   ) 
 

Definition at line 380 of file mappyal.c.

References AN_LOOPF, AN_LOOPR, AN_NONE, AN_ONCE, AN_ONCEH, AN_ONCES, AN_PPFF, AN_PPFR, AN_PPRF, AN_PPRR, ANISTR::ancount, ANISTR::ancuroff, ANISTR::andelay, ANISTR::anendoff, ANISTR::anstartoff, and ANISTR::antype.

00381 {
00382   ANISTR * myanpt;
00383 
00384   if (mapanimstrpt==NULL) return;
00385   myanpt = (ANISTR *) mapanimstrendpt; myanpt--;
00386   while (myanpt->antype!=-1)
00387     {
00388       if (myanpt->antype!=AN_NONE) { myanpt->ancount--; if (myanpt->ancount<0) {
00389         myanpt->ancount = myanpt->andelay;
00390         if (myanpt->antype==AN_LOOPF)
00391           {
00392             if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff++;
00393             if (myanpt->ancuroff==myanpt->anendoff) myanpt->ancuroff = myanpt->anstartoff;
00394             } }
00395         if (myanpt->antype==AN_LOOPR)
00396           {
00397             if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff--;
00398             if (myanpt->ancuroff==((myanpt->anstartoff)-1))
00399               myanpt->ancuroff = (myanpt->anendoff)-1;
00400             } }
00401         if (myanpt->antype==AN_ONCE)
00402           {
00403             if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff++;
00404             if (myanpt->ancuroff==myanpt->anendoff) { myanpt->antype = AN_ONCES;
00405             myanpt->ancuroff = myanpt->anstartoff; }
00406             } }
00407         if (myanpt->antype==AN_ONCEH)
00408           {
00409             if (myanpt->anstartoff!=myanpt->anendoff) {
00410               if (myanpt->ancuroff!=((myanpt->anendoff)-1)) myanpt->ancuroff++;
00411             } }
00412         if (myanpt->antype==AN_PPFF)
00413           {
00414             if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff++;
00415             if (myanpt->ancuroff==myanpt->anendoff) { myanpt->ancuroff -= 2;
00416             myanpt->antype = AN_PPFR;
00417             if (myanpt->ancuroff<myanpt->anstartoff) myanpt->ancuroff++; }
00418             } } else {
00419               if (myanpt->antype==AN_PPFR)
00420                 {
00421                   if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff--;
00422                   if (myanpt->ancuroff==((myanpt->anstartoff)-1)) { myanpt->ancuroff += 2;
00423                   myanpt->antype = AN_PPFF;
00424                   if (myanpt->ancuroff>myanpt->anendoff) myanpt->ancuroff --; }
00425                   } } }
00426         if (myanpt->antype==AN_PPRR)
00427           {
00428             if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff--;
00429             if (myanpt->ancuroff==((myanpt->anstartoff)-1)) { myanpt->ancuroff += 2;
00430             myanpt->antype = AN_PPRF;
00431             if (myanpt->ancuroff>myanpt->anendoff) myanpt->ancuroff--; }
00432             } } else {
00433               if (myanpt->antype==AN_PPRF)
00434                 {
00435                   if (myanpt->anstartoff!=myanpt->anendoff) { myanpt->ancuroff++;
00436                   if (myanpt->ancuroff==myanpt->anendoff) { myanpt->ancuroff -= 2;
00437                   myanpt->antype = AN_PPRR;
00438                   if (myanpt->ancuroff<myanpt->anstartoff) myanpt->ancuroff++; }
00439                   } } }
00440       } } myanpt--; }
00441 }


Variable Documentation

BITMAP** abmTiles
 

Definition at line 83 of file mappyal.c.

Referenced by MapDrawBG(), MapDrawBGT(), MapFreeMem(), MapRelocate2(), and MapRestore().

ANISTR* mapanimstrendpt
 

Definition at line 79 of file mappyal.c.

ANISTR* mapanimstrpt
 

Definition at line 77 of file mappyal.c.

short int** maparraypt
 

Definition at line 73 of file mappyal.c.

Referenced by MapChangeLayer(), MapFreeMem(), MapGenerateYLookup(), MapGetBlock(), MapGetBlockInPixels(), MapSetBlock(), and MapSetBlockInPixels().

int mapblockgapx
 

Definition at line 87 of file mappyal.c.

Referenced by MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawRow(), and MapGetXOffset().

int mapblockgapy
 

Definition at line 87 of file mappyal.c.

Referenced by MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawRow(), and MapGetYOffset().

char* mapblockgfxpt
 

Definition at line 75 of file mappyal.c.

Referenced by MapDecodeAGFX(), MapDecodeBGFX(), MapFreeMem(), MapRelocate(), MapRelocate2(), and MapRestore().

short int mapblockheight
 

Definition at line 69 of file mappyal.c.

Referenced by collided(), MapDecodeBKDT(), MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapGetBlockInPixels(), MapMakeParallaxBitmap(), MapRelocate(), MapRelocate2(), MapRestore(), MapSetBlockInPixels(), updatemap(), and updateplayer().

int mapblocksinsysmem
 

Definition at line 88 of file mappyal.c.

Referenced by MapFreeMem(), and MapRelocate2().

int mapblocksinvidmem
 

Definition at line 88 of file mappyal.c.

Referenced by MapFreeMem(), and MapRelocate2().

int mapblockstaggerx
 

Definition at line 87 of file mappyal.c.

Referenced by MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapGetXOffset(), and MapGetYOffset().

int mapblockstaggery
 

Definition at line 87 of file mappyal.c.

Referenced by MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapGetXOffset(), and MapGetYOffset().

char* mapblockstrpt
 

Definition at line 76 of file mappyal.c.

Referenced by MapDecodeBKDT(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapFreeMem(), MapGetBlock(), MapGetBlockID(), MapGetBlockInPixels(), and MapRelocate2().

short int mapblockstrsize
 

Definition at line 70 of file mappyal.c.

Referenced by MapDecodeANDT(), MapDecodeBKDT(), MapDecodeLayer(), and MapDecodeMPHD().

short int mapblockwidth
 

Definition at line 69 of file mappyal.c.

Referenced by collided(), MapDecodeBKDT(), MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapGetBlockInPixels(), MapMakeParallaxBitmap(), MapRelocate(), MapRelocate2(), MapRestore(), MapSetBlockInPixels(), updatemap(), and updateplayer().

RGB* mapcmap6bit
 

Definition at line 80 of file mappyal.c.

Referenced by Mapconv8to6pal(), and MapSetPal8().

char* mapcmappt
 

Definition at line 74 of file mappyal.c.

Referenced by MapDecodeCMAP(), MapFreeMem(), and MapRelocate().

short int mapdepth
 

Definition at line 69 of file mappyal.c.

Referenced by MapDecodeBKDT(), MapDecodeMPHD(), MapRealDecode(), MapRelocate(), MapRelocate2(), MapRestore(), and MapSetPal8().

int maperror
 

Definition at line 68 of file mappyal.c.

Referenced by MapDecodeAGFX(), MapDecodeANDT(), MapDecodeBGFX(), MapDecodeBKDT(), MapDecodeCMAP(), MapDecodeLayer(), MapDecodeMPHD(), MapPreRealDecode(), MapRealDecode(), MapRealLoad(), MapRelocate(), and MapRelocate2().

short int mapheight
 

Definition at line 69 of file mappyal.c.

Referenced by MapDecodeLayer(), MapDecodeMAR(), MapDecodeMPHD(), MapDrawRow(), MapGenerateYLookup(), MapGetBlockInPixels(), MapGetYOffset(), MapLoadMAR(), MapSetBlockInPixels(), updatemap(), and updateplayer().

short int*** mapmaparraypt
 

Definition at line 82 of file mappyal.c.

Referenced by MapChangeLayer(), MapFreeMem(), and MapGenerateYLookup().

short int** mapmappt
 

Definition at line 81 of file mappyal.c.

Referenced by MapChangeLayer(), MapDecodeLayer(), MapDecodeMAR(), MapFreeMem(), MapGenerateYLookup(), and MapLoadMAR().

short int mapnumblockgfx
 

Definition at line 70 of file mappyal.c.

Referenced by MapDecodeMPHD(), MapRelocate(), and MapRelocate2().

short int mapnumblockstr
 

Definition at line 70 of file mappyal.c.

Referenced by MapDecodeBKDT(), MapDecodeMPHD(), MapGetBlockID(), and MapRelocate2().

short int* mappt
 

Definition at line 72 of file mappyal.c.

Referenced by MapChangeLayer(), MapDecodeLayer(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapFreeMem(), MapGenerateYLookup(), MapGetBlock(), MapGetBlockInPixels(), MapMakeParallaxBitmap(), MapSetBlock(), and MapSetBlockInPixels().

short int mapwidth
 

Definition at line 69 of file mappyal.c.

Referenced by MapDecodeLayer(), MapDecodeMAR(), MapDecodeMPHD(), MapDrawBG(), MapDrawBGT(), MapDrawFG(), MapDrawParallax(), MapDrawRow(), MapGenerateYLookup(), MapGetBlock(), MapGetBlockInPixels(), MapGetXOffset(), MapLoadMAR(), MapSetBlock(), MapSetBlockInPixels(), updatemap(), and updateplayer().


Generated on Wed Jul 5 09:05:28 2006 for Super CS Brothers by  doxygen 1.4.4