readmap.c

石器时代2.0完整版源代码.已经加入新功能. 在REDHAT9下GCC3.4编译成功.

    if( floorindex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return FALSE;
	}
    xsiz = MAP_map[floorindex].xsiz;
    if( fx < 0 || fx >= xsiz ) {
        return FALSE;
	}
    if( fy < 0 || fy >= MAP_map[floorindex].ysiz ) {
        return FALSE;
	}
    if( tile != -1 )
    	MAP_map[floorindex].tile[fy*xsiz+fx] = tile;
    if( obj != -1)
    	MAP_map[floorindex].obj[fy*xsiz+fx] = obj;
    return TRUE;
}

BOOL MAP_initReadMap( char* maptilefile , char* mapdir )
{
    print("\n");
    if( !MAP_readMapConfFile(maptilefile) )
        return FALSE;
    if( !MAP_readBattleMapConfFile( getBattleMapfile( ) ) )
        return FALSE;
    if( !MAP_readMapDir(mapdir) )
        return FALSE;
    return TRUE;
}

static int MAP_coKindAndInt[MAP_KINDNUM]=
{
    MAP_WALKABLE,
};

BOOL MAP_makeVariousMap(char* atile, char* aobj, int floor, int startx,
                        int starty, int xsiz, int ysiz, MAP_kind   kind )
{
    int     i,j;
    int     findex;
    int     fxsiz;
    int     startpoint;

    if( atile == NULL || aobj == NULL || kind < 0 || kind >= MAP_KINDNUM ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
        return FALSE;
	}
    findex = MAP_getfloorIndex( floor );
    if( findex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return FALSE;
	}
    fxsiz = MAP_map[findex].xsiz;
    startpoint = startx + starty * fxsiz ;

    for( i = 0 ; i < ysiz ; i ++ ){
        for( j = 0 ; j < xsiz ; j ++ ){
            atile[i*xsiz+j] = MAP_getImageInt( MAP_map[findex].tile[
                startpoint + i*xsiz + j],MAP_coKindAndInt[kind] )
                ? 1 : 0;

            aobj[i*xsiz+j] = MAP_getImageInt( MAP_map[findex].obj[
                startpoint + i*xsiz + j],MAP_coKindAndInt[kind] )
                ? 1 : 0;
        }
    }
    return TRUE;
}

BOOL MAP_makeWalkableMap( char* data,  int floor, int startx, int starty,
                          int xsiz, int ysiz )
{
    int     i,j;
    char*   obj;
    obj = allocateMemory(xsiz*ysiz*sizeof(char));
    if( obj == NULL )return FALSE;

    if( MAP_makeVariousMap( data, obj, floor, startx, starty, xsiz, ysiz,
                            MAP_KINDWALKABLE ) == FALSE ){
        freeMemory( obj );
        return FALSE;
    }

    for( i = 0 ; i < ysiz ; i ++ )
        for( j = 0 ; j < xsiz ; j ++ )
            data[j+i*ysiz] = data[j+i*ysiz] & obj[j+i*ysiz];

#ifdef DEBUG
    for( i = 0 ; i < ysiz ; i ++ ){
        for( j = 0 ; j < xsiz ; j ++ )
            if( data[j+i*ysiz] ){
                print(" ");
            }else
                print("O");
        print("\n");
    }
#endif  /*DEBUG*/

    return TRUE;
}

BOOL MAP_IsThereSpecificFloorid( int floorid )
{
    if( MAP_getfloorIndex(floorid)== -1)return FALSE;
    else                                return TRUE;
}

BOOL MAP_IsValidCoordinate( int floor, int x, int y )
{
    if( MAP_IsThereSpecificFloorid(floor)==FALSE )return FALSE;
    if( x < 0 || MAP_getfloorX(floor)<=x )return FALSE;
    if( y < 0 || MAP_getfloorY(floor)<=y )return FALSE;
    return TRUE;
}

int MAP_attackSpecificPoint( int floor, int x, int y, int damage ,
                             int charaindex )
{
#if 0
    int     mapindex;
    int     xsiz;
    int     objimagenumber;

    mapindex = MAP_getfloorIndex(floor);
    if( mapindex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return 5;
	}
    xsiz = MAP_map[mapindex].xsiz;
    if( 0 > x || x >= xsiz || 0 >y || y >= MAP_map[mapindex].ysiz ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
        return 5;
	}
    if( damage <= 0 )return 5;

    objimagenumber = MAP_map[mapindex].obj[x+y*xsiz];

    if( MAP_getImageInt( objimagenumber,MAP_DEFENCE ) > 0 ){
        MAP_map[mapindex].objhp[x+y*xsiz] -= damage;
        if( MAP_map[mapindex].objhp[x+y*xsiz] < 0 ){
            MAP_map[mapindex].obj[x+y*xsiz] = 0;
#if 1
            {
                char *stringdata;
                RECT seekr , retr;
                seekr.x = x;
                seekr.y = y;
                seekr.width = 1;
                seekr.height = 1;
                stringdata = MAP_getdataFromRECT(floor,&seekr,&retr);
                if( stringdata ){
                    print("RINGO: RETR: %d %d %d %d\n",
                          retr.x,retr.y,retr.width,retr.height);
                    if( CHAR_getInt( charaindex , CHAR_WHICHTYPE )
                        == CHAR_TYPEPLAYER ){
                        int fd = getfdFromCharaIndex( charaindex );
                        lssproto_M_send(fd,floor, retr.x, retr.y,
                                        retr.x + retr.width, retr.y + retr.height,
                                        stringdata );
                    }
                } else {
                    print("RINGO: bad stringdata. %d %d %d %d\n",
                          seekr.x,seekr.y,seekr.width,seekr.height);

                }

            }
#endif
            return 1;
        }
        return 2;
    }

    if( MAP_getImageInt(MAP_map[mapindex].obj[y*xsiz+x],MAP_HAVEHEIGHT )
        == 0 )
        return 4;
#endif
    return 3;
}
BOOL MAP_appendTailObj( int floor, int x, int y, int objindex )
{
    int     mapindex;
    int     xsiz;
    int     dataindex;
    MAP_Objlink*    c;
    MAP_Objlink*    top;

    mapindex = MAP_getfloorIndex( floor );
    if( mapindex == -1 ) {
    	//print( "%s:%d:err(fl=%d,x=%d,y=%d)\n", __FILE__, __LINE__, floor, x, y );
    	return FALSE;
	}
    xsiz = MAP_map[mapindex].xsiz;
    if( 0 > x || x >= xsiz || 0 >y || y >= MAP_map[mapindex].ysiz ) {
    	//print( "%s:%d:err(fl=%d,x=%d,y=%d)\n", __FILE__, __LINE__, floor, x, y);
        return FALSE;
	}
    dataindex = y*xsiz+x;
    top = MAP_map[mapindex].olink[dataindex];
    if( top == NULL ){
        top = allocateMemory( sizeof(MAP_Objlink) );
        if( top == NULL ) {
    		//print( "%s:%d:err(fl=%d,x=%d,y=%d)\n", __FILE__, __LINE__, floor, x, y);
        	return FALSE;
        }
        top->next      = NULL;
        top->objindex  = objindex;
        MAP_map[mapindex].olink[dataindex] = top;
        return TRUE;
    }
    for( c=top ; c->next ; c = c->next );
    c->next = allocateMemory(sizeof(MAP_Objlink));
    if( c->next == NULL )return FALSE;
    c->next->next = NULL;
    c->next->objindex = objindex;
    return TRUE;
}

BOOL MAP_removeObj( int floor, int x, int y, int objindex )
{
    int     mapindex;
    int     xsiz;
    int     dataindex;
    MAP_Objlink*    c;
    MAP_Objlink*    last=NULL;

    mapindex = MAP_getfloorIndex( floor );
    if( mapindex == -1 ) {
    	print( "%s:%d:错误\n", __FILE__, __LINE__);
    	return FALSE;
	}
    xsiz = MAP_map[mapindex].xsiz;
    if( 0 > x || x >= xsiz || 0 >y || y >= MAP_map[mapindex].ysiz ) {
    	print( "%s:%d:错误 地图号[%d] x:[%d] y:[%d]\n", __FILE__, __LINE__, floor, x, y);
        return FALSE;
	}
    dataindex = y*xsiz+x;
    c = MAP_map[mapindex].olink[dataindex];
    while( c ){
        if( c->objindex == objindex ){
            if( last )
                last->next = c->next;
            else
                MAP_map[mapindex].olink[dataindex] = c->next;
            freeMemory( c );
            return TRUE;
        }
        last = c;
        c = c->next;
    }
    print( "%s:%d:错误\n", __FILE__, __LINE__);
    return FALSE;
}

BOOL _MAP_objmove( char *file, int line, int objindex, int ofloor, int ox, int oy, int nfloor,
                  int nx, int ny )
{
#if 1

    int     oldmapindex;
    int     oldxsiz;

    int     dataindex;
    MAP_Objlink*    c;
    MAP_Objlink*    last=NULL;
    MAP_Objlink*    pointer=NULL;

    oldmapindex = MAP_getfloorIndex( ofloor );
    if( oldmapindex == -1 ) {
    	print( "%s:%d:错误 地图号[%d] x:[%d] y:[%d]\n", __FILE__, __LINE__,
		    				 ofloor, ox, oy);
    	return FALSE;
	}
    oldxsiz = MAP_map[oldmapindex].xsiz;
    if( 0 > ox || ox >= oldxsiz
        || 0 >oy || oy >= MAP_map[oldmapindex].ysiz )
	{
    	print( "%s:%d:错误 地图号[%d] x:[%d] y:[%d]\n", __FILE__, __LINE__,
		    				 ofloor, ox, oy);
        return FALSE;
	}
    dataindex = oy*oldxsiz+ox;
    c = MAP_map[oldmapindex].olink[dataindex];
    while( c ){
        if( c->objindex == objindex ){
            if( last )
                last->next = c->next;
            else
                MAP_map[oldmapindex].olink[dataindex] = c->next;

            pointer = c;
            pointer->next = NULL;
            break;
        }
        last = c;
        c = c->next;
    }
    if( !pointer ) {
    	print( "\n%s:%d:错误( %d,%d,%d )->(%d,%d,%d)\n", __FILE__, __LINE__,
			ofloor, ox, oy, nfloor, nx, ny );
    	return FALSE;
	}
    {
        int     newmapindex;
        int     newxsiz;
        MAP_Objlink*    top;

        if( ofloor == nfloor ){
            newmapindex = oldmapindex;
            newxsiz     = oldxsiz;
        }else{
            newmapindex = MAP_getfloorIndex( nfloor );
            if( newmapindex == -1 ) {
		    	print( "%s:%d:错误 地图号[%d] x:[%d] y:[%d]\n", __FILE__, __LINE__,
		    				 nfloor, nx, ny);
            	return FALSE;
			}
            newxsiz = MAP_map[newmapindex].xsiz;
        }
        if( 0 > nx || nx >= newxsiz
            || 0 >ny || ny >= MAP_map[newmapindex].ysiz )
		{
	    	print( "%s:%d:错误 地图号[%d] x:[%d] y:[%d]\n", __FILE__, __LINE__,
	    				 nfloor, nx, ny);
            return FALSE;
		}

        dataindex = ny*newxsiz+nx;
        top = MAP_map[newmapindex].olink[dataindex];
        if( top == NULL ){
            top = MAP_map[newmapindex].olink[dataindex] = pointer;
            top->next = NULL;
            return TRUE;
        }

        for( c=top ; c->next ; c = c->next );
        c->next = pointer;
        c->next->next = NULL;
        return TRUE;
    }
#else
    if( MAP_removeObj( ofloor,ox,oy,objindex)
        && MAP_appendTailObj( nfloor, nx ,ny, objindex ) )
        return TRUE;
#endif
    print( "%s:%d:错误\n", __FILE__, __LINE__);
    return FALSE;
}

MAP_Objlink* _MAP_getTopObj( char *file, int line,int floor, int x, int y )
{
    int     mapindex;
    int     xsiz;

    mapindex = MAP_getfloorIndex( floor );
    if( mapindex == -1 ) {
    	//print( "callfrom[%s:%d] %s:%d:err floor(%d,%d,%d)\n", file, line, __FILE__, __LINE__,
    	//	floor, x, y );
    	return NULL;
	}

    xsiz = MAP_map[mapindex].xsiz;

#if 1
	if(  x >= xsiz) return NULL;
	if( y >= MAP_map[mapindex].ysiz ) return NULL;
	if( x < 0 ) return NULL;
	if( y < 0 ) return NULL;
    return MAP_map[mapindex].olink[y*xsiz+x];
#else
    if( 0 <= x && x < xsiz && 0 <= y && y < MAP_map[mapindex].ysiz )
        return MAP_map[mapindex].olink[y*xsiz+x];
    else
        return NULL;
#endif
}

BOOL MAP_addNewObj( int floor, int x, int y, int objindex )
{
    OBJECT  map;
    BOOL    ret;

    for( map=MAP_getTopObj(floor,x,y) ; map ; map = NEXT_OBJECT(map)) {
        if( GET_OBJINDEX(map) == objindex ) {
	    	print( "%s:%d:err\n", __FILE__, __LINE__);
            return 0;
		}
	}
    ret = MAP_appendTailObj( floor, x, y, objindex );
    if( ret )return 1;
    else     return -1;
}

char *MAP_getFloorName( int floor)
{
    int     floorindex;
    floorindex = MAP_getfloorIndex( floor );
    if( floorindex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return NULL;
    }
    return MAP_map[floorindex].string;
}

#ifdef _MAKE_MAP
int MAP_getFloorXY( int floor, int *x, int *y)
{
    int     floorindex;
    floorindex = MAP_getfloorIndex( floor );
    if( floorindex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return FALSE;
    }
    *x=MAP_map[floorindex].xsiz;
    *y=MAP_map[floorindex].ysiz;
    return TRUE;
}
#endif

BOOL MAP_setObjData( int ff ,int fx, int fy, int obj, int objhp )
{
    int     floorindex,xsiz;

    floorindex = MAP_getfloorIndex( ff );
    if( floorindex == -1 ) {
    	print( "%s:%d:err\n", __FILE__, __LINE__);
    	return FALSE;
	}
    xsiz = MAP_map[floorindex].xsiz;
    if( fx < 0 || fx >= xsiz ) {
        return FALSE;
	}
    if( fy < 0 || fy >= MAP_map[floorindex].ysiz ) {
        return FALSE;
	}
    MAP_map[floorindex].obj[fy*xsiz+fx] = obj;
    return TRUE;
}

void MAP_sendAroundMapdata( int fl, int fromx, int fromy)
{
    char*   mapdata;
    RECT    seek,ret;
	int		i,j;
	seek.x = fromx;
	seek.y = fromy;
	seek.width = seek.height = 1;
    mapdata = MAP_getdataFromRECT(fl,&seek,&ret);
    if( mapdata != NULL ) {
		int x = fromx;
		int	y = fromy;

		for( i =x-MAP_CHAR_DEFAULTSEESIZ/2 ; i <= x+MAP_CHAR_DEFAULTSEESIZ/2 ; i++ ){
			for( j = y-MAP_CHAR_DEFAULTSEESIZ/2 ; j <= y+MAP_CHAR_DEFAULTSEESIZ/2 ;
				 j ++ ){
				OBJECT  object;
				for( object = MAP_getTopObj(fl,i,j) ;
					 object ;
					 object = NEXT_OBJECT(object ) ){
					int objindex = GET_OBJINDEX(object);
					if( OBJECT_getType(objindex) == OBJTYPE_NOUSE ) continue;
					if( OBJECT_getType(objindex) == OBJTYPE_CHARA ) {
						int index = OBJECT_getIndex( objindex);
						if( CHAR_getInt( index, CHAR_WHICHTYPE)	== CHAR_TYPEPLAYER)	{
							int fd = getfdFromCharaIndex( index );
							if( fd !=  -1 ) {
						        lssproto_M_send( fd, fl, ret.x,ret.y,
					                         ret.x+ret.width, ret.y+ret.height,
					                         mapdata );
							}
						}
					}
				}
			}
		}
	}else {
		print( "地图数据错误 %s:%d \n" , __FILE__, __LINE__);
	}
}