コード例 #1
0
ファイル: polyobj.c プロジェクト: Garog/d1x-rebirth-ovr
short pof_read_short(ubyte *bufp)
{
	short s;

	s = *((short *) &bufp[Pof_addr]);
	Pof_addr += 2;
	return INTEL_SHORT(s);
//	if (PHYSFS_read(f,&s,sizeof(s),1) != 1)
//		Error("Unexpected end-of-file while reading object");
//
//	return s;
}
コード例 #2
0
ファイル: pcxutils.cpp プロジェクト: lubomyr/freespace2
// reads header information from the PCX file into the bitmap pointer
int pcx_read_header(char *real_filename, int *w, int *h, ubyte *pal )
{
	PCXHeader header;
	CFILE * PCXfile;
	char filename[MAX_FILENAME_LEN];
		
	strcpy( filename, real_filename );
	char *p = strchr( filename, '.' );
	if ( p ) *p = 0;
	strcat( filename, ".pcx" );

	PCXfile = cfopen( filename , "rb" );
	if ( !PCXfile )
		return PCX_ERROR_OPENING;

	// read 128 char PCX header
	if (cfread( &header, sizeof(PCXHeader), 1, PCXfile )!=1)	{
		cfclose( PCXfile );
		return PCX_ERROR_NO_HEADER;
	}
        header.Xmin = INTEL_SHORT( header.Xmin );
        header.Ymin = INTEL_SHORT( header.Ymin );
        header.Xmax = INTEL_SHORT( header.Xmax );
        header.Ymax = INTEL_SHORT( header.Ymax );
        header.Hdpi = INTEL_SHORT( header.Hdpi );
        header.Vdpi = INTEL_SHORT( header.Vdpi );
        for ( int i=0; i<16; i++ ){
            for ( int j=0; j<3; j++){
                header.ColorMap[i][j] = INTEL_INT( header.ColorMap[i][j] );
            }
        }
        header.BytesPerLine = INTEL_SHORT( header.BytesPerLine );
        for ( int i=0; i<60; i++ ){
            header.filler[i] = INTEL_INT( header.filler[i] );
        }

	// Is it a 256 color PCX file?
	if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))	{
		cfclose( PCXfile );
		return PCX_ERROR_WRONG_VERSION;
	}

	if (w) *w = header.Xmax - header.Xmin + 1;
	if (h) *h = header.Ymax - header.Ymin + 1;
	
	if ( pal ) {
		cfseek( PCXfile, -768, CF_SEEK_END );
		cfread( pal, 3, 256, PCXfile );
	}

	cfclose(PCXfile);
	return PCX_ERROR_NONE;
}
コード例 #3
0
ファイル: netmisc-new.cpp プロジェクト: paud/d2x-xl
void BESendMissingObjFrames(ubyte *server, ubyte *node, ubyte *netAddress)
{
	int	i;

memcpy (nmDataBuf, &networkData.sync [0].objs.missingFrames, sizeof (networkData.sync [0].objs.missingFrames));
((tMissingObjFrames *) &nmDataBuf [0])->nFrame = INTEL_SHORT (networkData.sync [0].objs.missingFrames.nFrame);
i = 2 * sizeof (ubyte) + sizeof (ushort);
if (netAddress != NULL)
	IPXSendPacketData(nmDataBuf, i, server, node, netAddress);
else if ((server == NULL) && (node == NULL))
	IPXSendBroadcastData(nmDataBuf, i);
else
	IPXSendInternetPacketData(nmDataBuf, i, server, node);
}
コード例 #4
0
ファイル: bitblt.c プロジェクト: Mako88/DXX-Retro
void gr_bm_ubitblt0x_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src,
						 grs_bitmap * dest, int masked )
{
	int i, data_offset;
	register int y1;
	unsigned char * sbits;

	data_offset = 1;
	if (src->bm_flags & BM_FLAG_RLE_BIG)
		data_offset = 2;

	sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
	for (i=0; i<sy; i++ )
		sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));

	for (y1=0; y1 < h; y1++ )    {
		gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1);
		if ( src->bm_flags & BM_FLAG_RLE_BIG )
			sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
		else
			sbits += (int)src->bm_data[4+y1+sy];
	}
}
コード例 #5
0
ファイル: network_send.cpp プロジェクト: paud/d2x-xl
void NetworkSendEndLevelSub (int nPlayer)
{
	tEndLevelInfo end;
	int i, j = 0;

	// Send an endlevel packet for a tPlayer
end.nType       = PID_ENDLEVEL;
end.nPlayer = nPlayer;
end.connected  = gameData.multiplayer.players [nPlayer].connected;
end.kills      = INTEL_SHORT (gameData.multiplayer.players [nPlayer].netKillsTotal);
end.killed     = INTEL_SHORT (gameData.multiplayer.players [nPlayer].netKilledTotal);
memcpy (end.killMatrix, gameData.multigame.kills.matrix [nPlayer], MAX_PLAYERS*sizeof (short));
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
for (i = 0; i < MAX_PLAYERS; i++)
	for (j = 0; j < MAX_PLAYERS; j++)
		end.killMatrix [i][j] = INTEL_SHORT (end.killMatrix [i][j]);
#else
j = j;          // to satisfy compiler
#endif
if (gameData.multiplayer.players [nPlayer].connected == 1) {// Still playing
	Assert (gameData.reactor.bDestroyed);
	end.seconds_left = gameData.reactor.countdown.nSecsLeft;
	}
for (i = 0; i < gameData.multiplayer.nPlayers; i++) {       
	if ((i != gameData.multiplayer.nLocalPlayer) && 
		 (i != nPlayer) && 
		 (gameData.multiplayer.players [i].connected)) {
		if (gameData.multiplayer.players [i].connected == 1)
			NetworkSendEndLevelShortSub (nPlayer, i);
		else if (gameStates.multi.nGameType >= IPX_GAME)
			IPXSendPacketData (
				(ubyte *)&end, sizeof (tEndLevelInfo), 
			netPlayers.players [i].network.ipx.server, 
			netPlayers.players [i].network.ipx.node, gameData.multiplayer.players [i].netAddress);
		}
	}
}
コード例 #6
0
ファイル: netmisc-old.c プロジェクト: paud/d2x-xl
void BESendSequencePacket(sequence_packet seq, ubyte *server, ubyte *node, ubyte *net_address)
{
	short tmps;
	int loc, tmpi;

	loc = 0;
	memset(out_buffer, 0, sizeof(out_buffer));
	out_buffer[0] = seq.type;                                       
	loc++;
	tmpi = INTEL_INT(seq.Security);
	memcpy(out_buffer + loc, &tmpi, 4);                           
	loc += 4;       
	loc += 3;
	memcpy(out_buffer + loc, seq.player.callsign, CALLSIGN_LEN+1);
	loc += CALLSIGN_LEN+1;
	memcpy(out_buffer + loc, seq.player.network.ipx.server, 4);   
	loc += 4;
	memcpy(out_buffer + loc, seq.player.network.ipx.node, 6);     
	loc += 6;
	out_buffer[loc] = seq.player.version_major;                     
	loc++;
	out_buffer[loc] = seq.player.version_minor;                     
	loc++;
	out_buffer[loc] = seq.player.computer_type;                     
	loc++;
	out_buffer[loc] = seq.player.connected;                         
	loc++;
	tmps = INTEL_SHORT(seq.player.socket);
	memcpy(out_buffer + loc, &tmps, 2);                           
	loc += 2;
	out_buffer[loc]=seq.player.rank;                                
	loc++;      // for pad byte
	if (net_address != NULL)
		IPXSendPacketData(out_buffer, loc, server, node, net_address);
	else if (!server && !node)
		IPXSendBroadcastData(out_buffer, loc);
	else
		IPXSendInternetPacketData(out_buffer, loc, server, node);
}
コード例 #7
0
ファイル: interp.cpp プロジェクト: Foran/dxx-rebirth
/*
 * finds what chunks the data points to, adds them to the chunk_list, 
 * and returns the length of the current chunk
 */
int get_chunks(ubyte *data, ubyte *new_data, chunk *list, int *no)
{
	short n;
	ubyte *p = data;

	while (INTEL_SHORT(w(p)) != OP_EOF) {
		switch (INTEL_SHORT(w(p))) {
		case OP_DEFPOINTS:
			n = INTEL_SHORT(w(p+2));
			p += n*sizeof(struct vms_vector) + 4;
			break;
		case OP_DEFP_START:
			n = INTEL_SHORT(w(p+2));
			p += n*sizeof(struct vms_vector) + 8;
			break;
		case OP_FLATPOLY:
			n = INTEL_SHORT(w(p+2));
			p += 30 + ((n&~1)+1)*2;
			break;
		case OP_TMAPPOLY:
			n = INTEL_SHORT(w(p+2));
			p += 30 + ((n&~1)+1)*2 + n*12;
			break;
		case OP_SORTNORM:
			add_chunk(p, p - data + new_data, 28, list, no);
			add_chunk(p, p - data + new_data, 30, list, no);
			p += 32;
			break;
		case OP_RODBM:
			p+=36;
			break;
		case OP_SUBCALL:
			add_chunk(p, p - data + new_data, 16, list, no);
			p+=20;
			break;
		case OP_GLOW:
			p += 4;
			break;
		default:
			Error("invalid polygon model\n");
		}
	}
	return p + 2 - data;
}
コード例 #8
0
ファイル: polyobj.c プロジェクト: CDarrow/DXX-Retro
ubyte * new_dest(chunk o) // return where chunk is (in aligned struct)
{
	return o.new_base + INTEL_SHORT(*((short *)(o.old_base + o.offset))) + o.correction;
}
コード例 #9
0
void receive_d1x_netgame_packet(ubyte *data, netgame_info *netgame) {
	int i, j;
	int loc = 0;
	
	netgame->type = data[loc];	loc++;
	if (netgame->type == PID_D1X_GAME_LITE) {
		memset(netgame, 0, sizeof(netgame_info));
		netgame->type = PID_D1X_GAME_LITE;
	}
	netgame->protocol_version = data[loc]; loc++;
	netgame->subprotocol = data[loc]; loc++;
	netgame->required_subprotocol = data[loc]; loc++;
	memcpy(netgame->game_name, &(data[loc]), NETGAME_NAME_LEN); loc += NETGAME_NAME_LEN;
	netgame->game_name[NETGAME_NAME_LEN] = 0;
	memcpy(netgame->mission_name, &(data[loc]), 8); loc += 8;
	netgame->mission_name[8] = 0;
	memcpy(netgame->mission_title, &(data[loc]), MISSION_NAME_LEN); loc += MISSION_NAME_LEN;
	netgame->mission_title[MISSION_NAME_LEN] = 0;
        netgame->levelnum = ((signed char *)data)[loc]; loc++;
	netgame->gamemode = data[loc]; loc++;
	netgame->difficulty = data[loc]; loc++;
	netgame->game_status = data[loc]; loc++;
	netgame->game_flags = data[loc]; loc++;
	netgame->max_numplayers = data[loc]; loc++;
	netgame->team_vector = data[loc]; loc++;
	if (netgame->type == PID_D1X_GAME_LITE) {
		j = netgame->numplayers = data[loc]; loc++;
		for (i = 0; i < j; i++)
			netgame->players[i].connected = 1;
		get_netplayer_info(&(data[loc]), &(netgame->players[0]), 1);loc += NETPLAYER_D1X_SIZE;
		//added 4/18/99 Matt Mueller - send .flags as well, so 'I' can show them
		if (netgame->subprotocol>=1){
			memcpy(&netgame->flags, &data[loc], 4); loc += 4;
			netgame->flags = INTEL_INT(netgame->flags);
		}
		//end addition -MM
	} else {
		netgame->numplayers = data[loc]; loc++;
		j = data[loc]; loc++; // sizeof netplayer struct
		if (j > 29) { /* sanity: 304+29*8=536, just below IPX_MAX=542 */
		    netgame->protocol_version = 0; return;
		}
		for (i = 0; i < MAX_PLAYERS; i++) {
			get_netplayer_info(&(data[loc]), &(netgame->players[i]), 1);
			loc += j;
		}
		memcpy(netgame->team_name[0], &(data[loc]), CALLSIGN_LEN); loc += CALLSIGN_LEN;
		netgame->team_name[0][CALLSIGN_LEN] = 0;
		memcpy(netgame->team_name[1], &(data[loc]), CALLSIGN_LEN); loc += CALLSIGN_LEN;
		netgame->team_name[1][CALLSIGN_LEN] = 0;
                for (i = 0; i < MAX_PLAYERS; i++) {
			netgame->locations[i] = data[loc]; loc++;
		}
		for (i = 0; i < MAX_PLAYERS; i++) {
			for (j = 0; j < MAX_PLAYERS; j++) {
				memcpy(&(netgame->kills[i][j]), &(data[loc]), 2); loc += 2;			// SWAP HERE!!!
				netgame->kills[i][j] = INTEL_SHORT(netgame->kills[i][j]);
			}
		}
		memcpy(&(netgame->segments_checksum), &(data[loc]), 2); loc += 2;				// SWAP_HERE
		netgame->segments_checksum = INTEL_SHORT(netgame->segments_checksum);
		memcpy(&(netgame->team_kills[0]), &(data[loc]), 2); loc += 2;				// SWAP_HERE
		netgame->team_kills[0] = INTEL_SHORT(netgame->team_kills[0]);
		memcpy(&(netgame->team_kills[1]), &(data[loc]), 2); loc += 2;				// SWAP_HERE
		netgame->team_kills[1] = INTEL_SHORT(netgame->team_kills[1]);
		for (i = 0; i < MAX_PLAYERS; i++) {
			memcpy(&(netgame->killed[i]), &(data[loc]), 2); loc += 2;			// SWAP HERE!!!
			netgame->killed[i] = INTEL_SHORT(netgame->killed[i]);
		}
		for (i = 0; i < MAX_PLAYERS; i++) {
			memcpy(&(netgame->player_kills[i]), &(data[loc]), 2); loc += 2; 		// SWAP HERE!!!
			netgame->player_kills[i] = INTEL_SHORT(netgame->player_kills[i]);
		}
		memcpy(&(netgame->level_time), &(data[loc]), 4); loc += 4;				// SWAP_HERE
		netgame->level_time = INTEL_INT(netgame->level_time);
		memcpy(&(netgame->control_invul_time), &(data[loc]), 4); loc += 4;				// SWAP_HERE
		netgame->control_invul_time = INTEL_INT(netgame->control_invul_time);
		memcpy(&(netgame->monitor_vector), &(data[loc]), 4); loc += 4;				// SWAP_HERE
		netgame->monitor_vector = INTEL_INT(netgame->monitor_vector);
		for (i = 0; i < 8; i++) {
			memcpy(&(netgame->player_score[i]), &(data[loc]), 4); loc += 4; 			// SWAP_HERE
			netgame->player_score[i] = INTEL_INT(netgame->player_score[i]);
		}
		memcpy(netgame->player_flags, &(data[loc]), 8); loc += 8;
		netgame->packets_per_sec = data[loc]; loc++;
		memcpy(&netgame->flags, &data[loc], 4); loc += 4;
		netgame->flags = INTEL_INT(netgame->flags);
	}
}
コード例 #10
0
ファイル: rle.c プロジェクト: paud/d2x-xl
int rle_expand (grsBitmap *bmP, ubyte *colorMap, int bSwap0255)
{
	ubyte				*expandBuf, *pSrc, *pDest;
	ubyte				c, h;
	int				i, j, l, bBigRLE;
	unsigned short nLineSize;

if (!(bmP->bm_props.flags & BM_FLAG_RLE))
	return bmP->bm_props.h * bmP->bm_props.rowsize;
if (!(expandBuf = D2_ALLOC (bmP->bm_props.h * bmP->bm_props.rowsize)))
	return -1;

bBigRLE = (bmP->bm_props.flags & BM_FLAG_RLE_BIG) != 0;
if (bBigRLE)
	pSrc = bmP->bm_texBuf + 4 + 2 * bmP->bm_props.h;
else
	pSrc = bmP->bm_texBuf + 4 + bmP->bm_props.h;
pDest = expandBuf;
for (i = 0; i < bmP->bm_props.h; i++, pSrc += nLineSize) {
	if (bBigRLE)
		nLineSize = INTEL_SHORT (*((unsigned short *) (bmP->bm_texBuf + 4 + 2 * i)));
	else
		nLineSize = bmP->bm_texBuf [4 + i];
	for (j = 0; j < nLineSize; j++) {
		h = pSrc [j];
		if (!IS_RLE_CODE (h)) {
			c = colorMap ? colorMap [h] : h; // translate
			if (bSwap0255) {
				if (c == 0)
					c = 255;
				else if (c == 255)
					c = 0;
				}
			if (pDest - expandBuf > bmP->bm_props.h * bmP->bm_props.rowsize) {
				D2_FREE (expandBuf);
				return -1;
				}	
			*pDest++ = c;
			}
		else if ((l = (h & NOT_RLE_CODE))) {
			c = pSrc [++j];
			if (colorMap)
				c = colorMap [c];
			if (bSwap0255) {
				if (c == 0)
					c = 255;
				else if (c == 255)
					c = 0;
				}
			if (pDest - expandBuf + l > bmP->bm_props.h * bmP->bm_props.rowsize) {
				D2_FREE (expandBuf);
				return -1;
				}	
			memset (pDest, c, l);
			pDest += l;
			}
		}
	}
l = (int) (pDest - expandBuf);
Assert (l <= bmP->bm_props.h * bmP->bm_props.rowsize);
memcpy (bmP->bm_texBuf, expandBuf, l);
bmP->bm_props.flags &= ~(BM_FLAG_RLE | BM_FLAG_RLE_BIG);
D2_FREE (expandBuf);
return l;
}
コード例 #11
0
void receive_netgame_packet(ubyte *data, netgame_info *netgame, int d1x)
{
	int i, j;
	int loc = 0;
	if (d1x) {
		receive_d1x_netgame_packet(data, netgame);
		return;
	}

	netgame->type = data[loc];	loc++;
	memcpy(netgame->game_name, &(data[loc]), NETGAME_NAME_LEN+1); loc += (NETGAME_NAME_LEN+1);
	memcpy(netgame->team_name, &(data[loc]), 2*(CALLSIGN_LEN+1)); loc += 2*(CALLSIGN_LEN+1);
	netgame->gamemode = data[loc]; loc++;
	netgame->difficulty = data[loc]; loc++;
	netgame->game_status = data[loc]; loc++;
	netgame->numplayers = data[loc]; loc++;
	netgame->max_numplayers = data[loc]; loc++;
	netgame->game_flags = data[loc]; loc++;
	for (i = 0; i < MAX_PLAYERS; i++) {
		get_netplayer_info(&(data[loc]), &(netgame->players[i]), 0);
		loc += NETPLAYER_ORIG_SIZE;
	}
#if 0
	if (d1x) {
		for (i = 0; i < MAX_PLAYERS; i++) {
			netgame->locations[i] = data[loc]; loc++;
		}
	} else
#endif
	{
		for (i = 0; i < MAX_PLAYERS; i++) {
			memcpy(&(netgame->locations[i]), &(data[loc]), 4); loc += 4;			// SWAP HERE!!!
			netgame->locations[i] = INTEL_INT(netgame->locations[i]);
		}
	}

	for (i = 0; i < MAX_PLAYERS; i++) {
		for (j = 0; j < MAX_PLAYERS; j++) {
			memcpy(&(netgame->kills[i][j]), &(data[loc]), 2); loc += 2;			// SWAP HERE!!!
			netgame->kills[i][j] = INTEL_SHORT(netgame->kills[i][j]);
		}
	}

	memcpy(&(netgame->levelnum), &(data[loc]), 4); loc += 4;				// SWAP_HERE
	netgame->levelnum = INTEL_INT(netgame->levelnum);
	netgame->protocol_version = data[loc]; loc++;
	netgame->team_vector = data[loc]; loc++;
	memcpy(&(netgame->segments_checksum), &(data[loc]), 2); loc += 2;				// SWAP_HERE
	netgame->segments_checksum = INTEL_SHORT(netgame->segments_checksum);
	memcpy(&(netgame->team_kills[0]), &(data[loc]), 2); loc += 2;				// SWAP_HERE
	netgame->team_kills[0] = INTEL_SHORT(netgame->team_kills[0]);
	memcpy(&(netgame->team_kills[1]), &(data[loc]), 2); loc += 2;				// SWAP_HERE
	netgame->team_kills[1] = INTEL_SHORT(netgame->team_kills[1]);
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->killed[i]), &(data[loc]), 2); loc += 2;			// SWAP HERE!!!
		netgame->killed[i] = INTEL_SHORT(netgame->killed[i]);
	}
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->player_kills[i]), &(data[loc]), 2); loc += 2;			// SWAP HERE!!!
		netgame->player_kills[i] = INTEL_SHORT(netgame->player_kills[i]);
	}

	memcpy(&(netgame->level_time), &(data[loc]), 4); loc += 4;				// SWAP_HERE
	netgame->level_time = INTEL_INT(netgame->level_time);
	memcpy(&(netgame->control_invul_time), &(data[loc]), 4); loc += 4;				// SWAP_HERE
	netgame->control_invul_time = INTEL_INT(netgame->control_invul_time);
	memcpy(&(netgame->monitor_vector), &(data[loc]), 4); loc += 4;				// SWAP_HERE
	netgame->monitor_vector = INTEL_INT(netgame->monitor_vector);
	for (i = 0; i < 8; i++) {
		memcpy(&(netgame->player_score[i]), &(data[loc]), 4); loc += 4;				// SWAP_HERE
		netgame->player_score[i] = INTEL_INT(netgame->player_score[i]);
	}
	memcpy(netgame->player_flags, &(data[loc]), 8); loc += 8;
#if 0
	for (i = 0; i < 8; i++) {
		memcpy(&(netgame->player_flags[i]), &(data[loc]), 1); loc++;
	}
#endif

	memcpy(netgame->mission_name, &(data[loc]), 9); loc += 9;
	memcpy(netgame->mission_title, &(data[loc]), MISSION_NAME_LEN+1); loc += (MISSION_NAME_LEN+1);
#if 0
	if (d1x && netgame->protocol_version == MULTI_PROTO_D1X_VER) {
	    netgame->packets_per_sec = data[loc]; loc++;
	    memcpy(&netgame->flags, &data[loc], 4); loc += 4;
	    netgame->flags = INTEL_INT(netgame->flags);
	}
#endif
}
コード例 #12
0
void send_d1x_netgame_packet(ubyte *server, ubyte *node)
{
	uint tmpi;
	ushort tmps;
	int i, j;
	int loc = 0;
	
	memset(out_buffer, 0, MAX_DATA_SIZE);
	out_buffer[loc] = Netgame.type; loc++;
	out_buffer[loc] = MULTI_PROTO_D1X_VER; loc++;
	out_buffer[loc] = Netgame.subprotocol; loc++;
	out_buffer[loc] = Netgame.required_subprotocol; loc++;
	memcpy(&(out_buffer[loc]), Netgame.game_name, NETGAME_NAME_LEN); loc += NETGAME_NAME_LEN;
	memcpy(&(out_buffer[loc]), Netgame.mission_name, 8); loc += 8;
	memcpy(&(out_buffer[loc]), Netgame.mission_title, MISSION_NAME_LEN); loc += MISSION_NAME_LEN;
	out_buffer[loc] = Netgame.levelnum; loc++;
	out_buffer[loc] = Netgame.gamemode; loc++;
	out_buffer[loc] = Netgame.difficulty; loc++;
	out_buffer[loc] = Netgame.game_status; loc++;
	out_buffer[loc] = Netgame.game_flags; loc++;
	out_buffer[loc] = Netgame.max_numplayers; loc++;
	out_buffer[loc] = Netgame.team_vector; loc++;
	if (Netgame.type == PID_D1X_GAME_LITE) {
		int master = -1;
		j = 0;
		for (i = 0; i < Netgame.numplayers; i++)
			if (Players[i].connected) {
				if (master == -1)
					master = i;
				j++;
			}
		out_buffer[loc] = j; loc++; /* numconnected */
		if (master == -1)   /* should not happen, but... */
			master = Player_num; 
		put_netplayer_info(&(out_buffer[loc]), &Netgame.players[master], 1); loc += NETPLAYER_D1X_SIZE;
		//added 4/18/99 Matt Mueller - send .flags as well, so 'I' can show them
		tmpi = INTEL_INT(Netgame.flags);
		memcpy(&out_buffer[loc], &tmpi, 4); loc += 4;
		//end addition -MM
	} else {
		out_buffer[loc] = Netgame.numplayers; loc++;
		out_buffer[loc] = NETPLAYER_D1X_SIZE; loc++; // sizeof netplayer struct
		for (i = 0; i < MAX_PLAYERS; i++) {
			put_netplayer_info(&(out_buffer[loc]), &Netgame.players[i], 1);
			loc += NETPLAYER_D1X_SIZE;
		}
		memcpy(&(out_buffer[loc]), Netgame.team_name[0], CALLSIGN_LEN); loc += CALLSIGN_LEN;
		memcpy(&(out_buffer[loc]), Netgame.team_name[1], CALLSIGN_LEN); loc += CALLSIGN_LEN;
		for (i = 0; i < MAX_PLAYERS; i++) {
			out_buffer[loc] = Netgame.locations[i]; loc++;
		}
		for (i = 0; i < MAX_PLAYERS; i++) {
			for (j = 0; j < MAX_PLAYERS; j++) {
				tmps = INTEL_SHORT(Netgame.kills[i][j]);
				memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 	// SWAP HERE!!!
			}
		}
		tmps = INTEL_SHORT(Netgame.segments_checksum);
		memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 			// SWAP_HERE
		tmps = INTEL_SHORT(Netgame.team_kills[0]);
		memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 			// SWAP_HERE
		tmps = INTEL_SHORT(Netgame.team_kills[1]);
		memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 			// SWAP_HERE
		for (i = 0; i < MAX_PLAYERS; i++) {
			tmps = INTEL_SHORT(Netgame.killed[i]);
			memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 		// SWAP HERE!!!
		}
		for (i = 0; i < MAX_PLAYERS; i++) {
			tmps = INTEL_SHORT(Netgame.player_kills[i]);
			memcpy(&(out_buffer[loc]), &tmps, 2); loc += 2; 		// SWAP HERE!!!
		}
		tmpi = INTEL_INT(Netgame.level_time);
		memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4; 			// SWAP_HERE
		tmpi = INTEL_INT(Netgame.control_invul_time);
		memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4; 			// SWAP_HERE
		tmpi = INTEL_INT(Netgame.monitor_vector);
		memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4; 			// SWAP_HERE
		for (i = 0; i < 8; i++) {
			tmpi = INTEL_INT(Netgame.player_score[i]);
			memcpy(&(out_buffer[loc]), &tmpi, 4); loc += 4; 			// SWAP_HERE
		}
		memcpy(&(out_buffer[loc]), Netgame.player_flags, MAX_PLAYERS); loc += MAX_PLAYERS;
		out_buffer[loc] = Netgame.packets_per_sec; loc++;
		tmpi = INTEL_INT(Netgame.flags);
		memcpy(&out_buffer[loc], &tmpi, 4); loc += 4;
	}

	if (server == NULL)
		NetDrvSendBroadcastPacketData(out_buffer, loc);
	else
		NetDrvSendInternetworkPacketData(out_buffer, loc, server, node);
}
コード例 #13
0
ファイル: network.cpp プロジェクト: paud/d2x-xl
void NetworkDoFrame (int bForce, int bListen)
{
	tFrameInfoShort shortSyncPack;
	static fix xLastEndlevel = 0;
	int i;

if (!(gameData.app.nGameMode & GM_NETWORK)) 
	return;
if ((networkData.nStatus == NETSTAT_PLAYING) && !gameStates.app.bEndLevelSequence) { // Don't send postion during escape sequence...
	if (nakedData.nLength) {
		Assert (nakedData.nDestPlayer >- 1);
		if (gameStates.multi.nGameType >= IPX_GAME) 
			IPXSendPacketData (reinterpret_cast<ubyte*> (nakedData.buf), nakedData.nLength, 
									netPlayers.players [nakedData.nDestPlayer].network.ipx.server, 
									netPlayers.players [nakedData.nDestPlayer].network.ipx.node, 
									gameData.multiplayer.players [nakedData.nDestPlayer].netAddress);
		nakedData.nLength = 0;
		nakedData.nDestPlayer = -1;
		}
	if (networkData.refuse.bWaitForAnswer && TimerGetApproxSeconds ()> (networkData.refuse.xTimeLimit+ (I2X (12))))
		networkData.refuse.bWaitForAnswer=0;
	networkData.xLastSendTime += gameData.time.xFrame;
	networkData.xLastTimeoutCheck += gameData.time.xFrame;

	// Send out packet PacksPerSec times per second maximum... unless they fire, then send more often...
	if ((networkData.xLastSendTime > I2X (1) / PacketsPerSec ()) || 
		(gameData.multigame.laser.bFired) || bForce || networkData.bPacketUrgent) {        
		if (LOCALPLAYER.connected) {
			int nObject = LOCALPLAYER.nObject;
			networkData.bPacketUrgent = 0;
			if (bListen) {
				MultiSendRobotFrame (0);
				MultiSendFire ();              // Do firing if needed..
				}
			networkData.xLastSendTime = 0;
			if (netGame.bShortPackets) {
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
				ubyte send_data [MAX_PACKETSIZE];
#endif
				memset (&shortSyncPack, 0, sizeof (shortSyncPack));
				CreateShortPos (&shortSyncPack.objPos, OBJECTS+nObject, 0);
				shortSyncPack.nType = PID_PDATA;
				shortSyncPack.nPlayer = gameData.multiplayer.nLocalPlayer;
				shortSyncPack.objRenderType = OBJECTS [nObject].info.renderType;
				shortSyncPack.nLevel = gameData.missions.nCurrentLevel;
				shortSyncPack.dataSize = networkData.syncPack.dataSize;
				memcpy (shortSyncPack.data, networkData.syncPack.data, networkData.syncPack.dataSize);
				networkData.syncPack.nPackets = INTEL_INT (gameData.multiplayer.players [0].nPacketsSent++);
				shortSyncPack.nPackets = networkData.syncPack.nPackets;
#if !(defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__))
				IpxSendGamePacket (
					reinterpret_cast<ubyte*> (&shortSyncPack), 
					sizeof (tFrameInfoShort) - networkData.nMaxXDataSize + networkData.syncPack.dataSize);
#else
				SquishShortFrameInfo (shortSyncPack, send_data);
				IpxSendGamePacket (
					reinterpret_cast<ubyte*> (send_data), 
					IPX_SHORT_INFO_SIZE-networkData.nMaxXDataSize+networkData.syncPack.dataSize);
#endif
				}
			else {// If long packets
					int send_dataSize;

				networkData.syncPack.nType = PID_PDATA;
				networkData.syncPack.nPlayer = gameData.multiplayer.nLocalPlayer;
				networkData.syncPack.objRenderType = OBJECTS [nObject].info.renderType;
				networkData.syncPack.nLevel = gameData.missions.nCurrentLevel;
				networkData.syncPack.nObjSeg = OBJECTS [nObject].info.nSegment;
				networkData.syncPack.objPos = OBJECTS [nObject].info.position.vPos;
				networkData.syncPack.objOrient = OBJECTS [nObject].info.position.mOrient;
				networkData.syncPack.physVelocity = OBJECTS [nObject].mType.physInfo.velocity;
				networkData.syncPack.physRotVel = OBJECTS [nObject].mType.physInfo.rotVel;
				send_dataSize = networkData.syncPack.dataSize;                  // do this so correct size data is sent
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)                        // do the swap stuff
				if (gameStates.multi.nGameType >= IPX_GAME) {
					networkData.syncPack.nObjSeg = INTEL_SHORT (networkData.syncPack.nObjSeg);
					INTEL_VECTOR (networkData.syncPack.objPos);
					INTEL_MATRIX (networkData.syncPack.objOrient);
					INTEL_VECTOR (networkData.syncPack.physVelocity);
					INTEL_VECTOR (networkData.syncPack.physRotVel);
					networkData.syncPack.dataSize = INTEL_SHORT (networkData.syncPack.dataSize);
					}
#endif
				networkData.syncPack.nPackets = INTEL_INT (gameData.multiplayer.players [0].nPacketsSent++);
				IpxSendGamePacket (
					reinterpret_cast<ubyte*> (&networkData.syncPack), 
					sizeof (tFrameInfo) - networkData.nMaxXDataSize + send_dataSize);
				}
			networkData.syncPack.dataSize = 0;               // Start data over at 0 length.
			networkData.bD2XData = 0;
			if (gameData.reactor.bDestroyed) {
				if (gameStates.app.bPlayerIsDead)
					LOCALPLAYER.connected=3;
				if (TimerGetApproxSeconds () > (xLastEndlevel+ (I2X (1)/2))) {
					NetworkSendEndLevelPacket ();
					xLastEndlevel = TimerGetApproxSeconds ();
					}
				}
			}
		}

	if (!bListen)
		return;

	if ((networkData.xLastTimeoutCheck > I2X (1)) && !gameData.reactor.bDestroyed) {
		fix t = (fix) SDL_GetTicks ();
	// Check for CPlayerData timeouts
		for (i = 0; i < gameData.multiplayer.nPlayers; i++) {
			if ((i != gameData.multiplayer.nLocalPlayer) && 
				((gameData.multiplayer.players [i].connected == 1) || downloadManager.Downloading (i))) {
				if ((networkData.nLastPacketTime [i] == 0) || (networkData.nLastPacketTime [i] + downloadManager.GetTimeoutSecs () * 1000 > t)) {
					ResetPlayerTimeout (i, t);
					continue;
					}
#if 1//!DBG
				if (gameOpts->multi.bTimeoutPlayers && (t - networkData.nLastPacketTime [i] > 15000))
					NetworkTimeoutPlayer (i);
#endif
				}
			}
		networkData.xLastTimeoutCheck = 0;
		}
	}

if (!bListen) {
	networkData.syncPack.dataSize = 0;
	return;
	}
NetworkListen ();
#if 0
if ((networkData.sync.nPlayer != -1) && !(gameData.app.nFrameCount & 63))
	ResendSyncDueToPacketLoss (); // This will resend to network_player_rejoining
#endif
NetworkDoSyncFrame ();
if (NetworkIAmMaster ())
	tracker.AddServer ();
}
コード例 #14
0
ファイル: network_sync.cpp プロジェクト: paud/d2x-xl
void NetworkSyncObjects (tNetworkSyncData *syncP)
{
	tObject	*objP;
	sbyte		owner;
	short		nRemoteObj;
	int		bufI, i, h;
	int		nObjFrames = 0;
	int		nPlayer = syncP->player [1].player.connected;

// Send clear OBJECTS array tTrigger and send tPlayer num
objFilter [OBJ_MARKER] = !gameStates.app.bHaveExtraGameInfo [1];
for (h = 0; h < OBJ_PACKETS_PER_FRAME; h++) {	// Do more than 1 per frame, try to speed it up without
																// over-stressing the receiver.
	nObjFrames = 0;
	memset (objBuf, 0, DATALIMIT);
	objBuf [0] = PID_OBJECT_DATA;
	bufI = (gameStates.multi.nGameType == UDP_GAME) ? 4 : 3;

	if (syncP->objs.nCurrent == -1) {	// first packet tells the receiver to reset it's object data
		syncP->objs.nSent = 0;
		syncP->objs.nMode = 0;
		syncP->objs.nFrame = 0;
		NW_SET_SHORT (objBuf, bufI, syncP->objs.missingFrames.nFrame ? -3 : -1);		// object number -1          
		NW_SET_BYTE (objBuf, bufI, nPlayer);                            
		bufI += 2;									// Placeholder for nRemoteObj, not used here
		syncP->objs.nCurrent = 0;
		syncP->objs.nFrame = 0;
		nObjFrames = 1;		// first frame contains "reset object data" info
		}

	for (i = syncP->objs.nCurrent, objP = OBJECTS + i; i <= gameData.objs.nLastObject [0]; i++, objP++) {
		if (NetworkFilterObject (objP))
			continue;
		if (syncP->objs.nMode) { 
			 if ((gameData.multigame.nObjOwner [i] != -1) && (gameData.multigame.nObjOwner [i] != nPlayer))
				continue;
			}
		else {
			if ((gameData.multigame.nObjOwner [i] == -1) || (gameData.multigame.nObjOwner [i] == nPlayer))
				continue;
			}
		if ((DATALIMIT - bufI - 1) < (int) sizeof (tObject) + 5)
			break; // Not enough room for another tObject
		nObjFrames++;
		syncP->objs.nSent++;
		nRemoteObj = ObjnumLocalToRemote ((short) i, &owner);
		Assert (owner == gameData.multigame.nObjOwner [i]);
		NW_SET_SHORT (objBuf, bufI, i);      
		NW_SET_BYTE (objBuf, bufI, owner);                                 
		NW_SET_SHORT (objBuf, bufI, nRemoteObj); 
		NW_SET_BYTES (objBuf, bufI, objP, sizeof (tObject));
		if (gameStates.multi.nGameType >= IPX_GAME)
			SwapObject ((tObject *) (objBuf + bufI - sizeof (tBaseObject)));
		}
	if (nObjFrames) {	// Send any objects we've buffered
		syncP->objs.nCurrent = i;	
		if (NetworkObjFrameFilter (syncP)) {
			objBuf [1] = nObjFrames;  
			if (gameStates.multi.nGameType == UDP_GAME)
				*((short *) (objBuf + 2)) = INTEL_SHORT (syncP->objs.nFrame);
			else
				objBuf [2] = (ubyte) syncP->objs.nFrame;
			Assert (bufI <= DATALIMIT);
			if (gameStates.multi.nGameType >= IPX_GAME)
				IPXSendInternetPacketData (
					objBuf, bufI, 
					syncP->player [1].player.network.ipx.server, 
					syncP->player [1].player.network.ipx.node);
			 }
		}
	if (i > gameData.objs.nLastObject [0]) {
		if (syncP->objs.nMode) {
			syncP->objs.nCurrent = i;
			// Send count so other tSide can make sure he got them all
			objBuf [0] = PID_OBJECT_DATA;
			objBuf [1] = 1;
			syncP->objs.nFrame++;
			if (gameStates.multi.nGameType == UDP_GAME) {
				bufI = 2;
				NW_SET_SHORT (objBuf, bufI, syncP->objs.nFrame); 
				}
			else {
				objBuf [2] = (ubyte) syncP->objs.nFrame;
				bufI = 3;
				}
			nRemoteObj = syncP->objs.missingFrames.nFrame ? -4 : -2;
			NW_SET_SHORT (objBuf, bufI, nRemoteObj);
			NW_SET_SHORT (objBuf, bufI, syncP->objs.nSent);
			syncP->nState = syncP->objs.missingFrames.nFrame ? 1 : 2;
			}
		else {
			syncP->objs.nCurrent = 0;
			syncP->objs.nMode = 1; // go to next mode
			}
		break;
		}
	}
}
コード例 #15
0
ファイル: netmisc-old.c プロジェクト: paud/d2x-xl
void BESendNetGamePacket(ubyte *server, ubyte *node, ubyte *net_address, int lite_flag)     // lite says shorter netgame packets
{
	uint tmpi;
	ushort tmps; // p;
	int i, j;
	int loc = 0;

	memset(out_buffer, 0, IPX_MAX_DATA_SIZE);
	memcpy(out_buffer + loc, &(netGame.type), 1);                 
	loc++;
	tmpi = INTEL_INT(netGame.Security);
	memcpy(out_buffer + loc, &tmpi, 4);                           
	loc += 4;
	memcpy(out_buffer + loc, netGame.game_name, NETGAME_NAME_LEN+1);  
	loc += (NETGAME_NAME_LEN+1);
	memcpy(out_buffer + loc, netGame.mission_title, MISSION_NAME_LEN+1);  
	loc += (MISSION_NAME_LEN+1);
	memcpy(out_buffer + loc, netGame.mission_name, 9);            
	loc += 9;
	tmpi = INTEL_INT(netGame.levelnum);
	memcpy(out_buffer + loc, &tmpi, 4);                           
	loc += 4;
	memcpy(out_buffer + loc, &(netGame.gamemode), 1);             
	loc++;
	memcpy(out_buffer + loc, &(netGame.RefusePlayers), 1);        
	loc++;
	memcpy(out_buffer + loc, &(netGame.difficulty), 1);           
	loc++;
	memcpy(out_buffer + loc, &(netGame.game_status), 1);          
	loc++;
	memcpy(out_buffer + loc, &(netGame.numplayers), 1);           
	loc++;
	memcpy(out_buffer + loc, &(netGame.max_numplayers), 1);       
	loc++;
	memcpy(out_buffer + loc, &(netGame.numconnected), 1);         
	loc++;
	memcpy(out_buffer + loc, &(netGame.game_flags), 1);           
	loc++;
	memcpy(out_buffer + loc, &(netGame.protocol_version), 1);     
	loc++;
	memcpy(out_buffer + loc, &(netGame.version_major), 1);        
	loc++;
	memcpy(out_buffer + loc, &(netGame.version_minor), 1);        
	loc++;
	memcpy(out_buffer + loc, &(netGame.team_vector), 1);          
	loc++;

	if (lite_flag)
		goto do_send;

// will this work -- damn bitfields -- totally bogus when trying to do
// this type of stuff
// Watcom makes bitfields from left to right.  CW7 on the mac goes
// from right to left.  then they are endian swapped

	tmps = *(ushort *)((ubyte *)(&netGame.team_vector) + 1);    // get the values for the first short bitfield
	tmps = INTEL_SHORT(tmps);
	memcpy(out_buffer + loc, &tmps, 2);                           
	loc += 2;

	tmps = *(ushort *)((ubyte *)(&netGame.team_vector) + 3);    // get the values for the second short bitfield
	tmps = INTEL_SHORT(tmps);
	memcpy(out_buffer + loc, &tmps, 2);                           
	loc += 2;

#if 0       // removed since I reordered bitfields on mac
	p = *(ushort *)((ubyte *)(&netGame.team_vector) + 1);       // get the values for the first short bitfield
	tmps = 0;
	for (i = 15; i >= 0; i--) {
		if (p & (1 << i))
			tmps |= (1 << (15 - i);
	}
	tmps = INTEL_SHORT(tmps);
	memcpy(out_buffer + loc, &tmps, 2);                           
	loc += 2;
	p = *(ushort *)((ubyte *)(&netGame.team_vector) + 3);       // get the values for the second short bitfield
	tmps = 0;
	for (i = 15; i >= 0; i--) {
		if (p & (1 << i))
			tmps |= (1 << (15 - i);
	}
	tmps = INTEL_SHORT(tmps);
	memcpy(out_buffer + loc, &tmps, 2);                           
	loc += 2;
#endif

	memcpy(out_buffer + loc, netGame.team_name, 2*(CALLSIGN_LEN+1)); loc += 2*(CALLSIGN_LEN+1);
	for (i = 0; i < MAX_PLAYERS; i++) {
		tmpi = INTEL_INT(netGame.locations[i]);
		memcpy(out_buffer + loc, &tmpi, 4);       
		loc += 4;   // SWAP HERE!!!
	}

	for (i = 0; i < MAX_PLAYERS; i++) {
		for (j = 0; j < MAX_PLAYERS; j++) {
			tmps = INTEL_SHORT(netGame.kills[i][j]);
			memcpy(out_buffer + loc, &tmps, 2);   
			loc += 2;   // SWAP HERE!!!
		}
	}

	tmps = INTEL_SHORT(netGame.segments_checksum);
	memcpy(out_buffer + loc, &tmps, 2);           
	loc += 2;   // SWAP_HERE
	tmps = INTEL_SHORT(netGame.team_kills[0]);
	memcpy(out_buffer + loc, &tmps, 2);           
	loc += 2;   // SWAP_HERE
	tmps = INTEL_SHORT(netGame.team_kills[1]);
	memcpy(out_buffer + loc, &tmps, 2);           
	loc += 2;   // SWAP_HERE
	for (i = 0; i < MAX_PLAYERS; i++) {
		tmps = INTEL_SHORT(netGame.killed[i]);
		memcpy(out_buffer + loc, &tmps, 2);       
		loc += 2;   // SWAP HERE!!!
	}
	for (i = 0; i < MAX_PLAYERS; i++) {
		tmps = INTEL_SHORT(netGame.player_kills[i]);
		memcpy(out_buffer + loc, &tmps, 2);       
		loc += 2;   // SWAP HERE!!!
	}

	tmpi = INTEL_INT(netGame.KillGoal);
	memcpy(out_buffer + loc, &tmpi, 4);           
	loc += 4;   // SWAP_HERE
	tmpi = INTEL_INT(netGame.PlayTimeAllowed);
	memcpy(out_buffer + loc, &tmpi, 4);           
	loc += 4;   // SWAP_HERE
	tmpi = INTEL_INT(netGame.level_time);
	memcpy(out_buffer + loc, &tmpi, 4);           
	loc += 4;   // SWAP_HERE
	tmpi = INTEL_INT(netGame.control_invul_time);
	memcpy(out_buffer + loc, &tmpi, 4);           
	loc += 4;   // SWAP_HERE
	tmpi = INTEL_INT(netGame.monitor_vector);
	memcpy(out_buffer + loc, &tmpi, 4);           
	loc += 4;   // SWAP_HERE
	for (i = 0; i < MAX_PLAYERS; i++) {
		tmpi = INTEL_INT(netGame.player_score[i]);
		memcpy(out_buffer + loc, &tmpi, 4);       
		loc += 4;   // SWAP_HERE
	}
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(out_buffer + loc, &(netGame.player_flags[i]), 1); loc++;
	}
	tmps = INTEL_SHORT(netGame.nPacketsPerSec);
	memcpy(out_buffer + loc, &tmps, 2);                   
	loc += 2;
	memcpy(out_buffer + loc, &(netGame.bShortPackets), 1); 
	loc++;

do_send:
	if (net_address != NULL)
		IPXSendPacketData(out_buffer, loc, server, node, net_address);
	else if ((server == NULL) && (node == NULL))
		IPXSendBroadcastData(out_buffer, loc);
	else
		IPXSendInternetPacketData(out_buffer, loc, server, node);
}
コード例 #16
0
ファイル: netmisc-old.c プロジェクト: paud/d2x-xl
void BESwapObject(object *objP)
{
	// swap the short and int entries for this object
	objP->signature     = INTEL_INT(objP->signature);
	objP->next          = INTEL_SHORT(objP->next);
	objP->prev          = INTEL_SHORT(objP->prev);
	objP->segnum        = INTEL_SHORT(objP->segnum);
	objP->pos.x         = INTEL_INT(objP->pos.x);
	objP->pos.y         = INTEL_INT(objP->pos.y);
	objP->pos.z         = INTEL_INT(objP->pos.z);

	objP->orient.rvec.x = INTEL_INT(objP->orient.rvec.x);
	objP->orient.rvec.y = INTEL_INT(objP->orient.rvec.y);
	objP->orient.rvec.z = INTEL_INT(objP->orient.rvec.z);
	objP->orient.fvec.x = INTEL_INT(objP->orient.fvec.x);
	objP->orient.fvec.y = INTEL_INT(objP->orient.fvec.y);
	objP->orient.fvec.z = INTEL_INT(objP->orient.fvec.z);
	objP->orient.uvec.x = INTEL_INT(objP->orient.uvec.x);
	objP->orient.uvec.y = INTEL_INT(objP->orient.uvec.y);
	objP->orient.uvec.z = INTEL_INT(objP->orient.uvec.z);

	objP->size          = INTEL_INT(objP->size);
	objP->shields       = INTEL_INT(objP->shields);

	objP->last_pos.x    = INTEL_INT(objP->last_pos.x);
	objP->last_pos.y    = INTEL_INT(objP->last_pos.y);
	objP->last_pos.z    = INTEL_INT(objP->last_pos.z);

	objP->lifeleft      = INTEL_INT(objP->lifeleft);

	switch (objP->movement_type) {

	case MT_PHYSICS:

		objP->mtype.phys_info.velocity.x = INTEL_INT(objP->mtype.phys_info.velocity.x);
		objP->mtype.phys_info.velocity.y = INTEL_INT(objP->mtype.phys_info.velocity.y);
		objP->mtype.phys_info.velocity.z = INTEL_INT(objP->mtype.phys_info.velocity.z);

		objP->mtype.phys_info.thrust.x   = INTEL_INT(objP->mtype.phys_info.thrust.x);
		objP->mtype.phys_info.thrust.y   = INTEL_INT(objP->mtype.phys_info.thrust.y);
		objP->mtype.phys_info.thrust.z   = INTEL_INT(objP->mtype.phys_info.thrust.z);

		objP->mtype.phys_info.mass       = INTEL_INT(objP->mtype.phys_info.mass);
		objP->mtype.phys_info.drag       = INTEL_INT(objP->mtype.phys_info.drag);
		objP->mtype.phys_info.brakes     = INTEL_INT(objP->mtype.phys_info.brakes);

		objP->mtype.phys_info.rotvel.x   = INTEL_INT(objP->mtype.phys_info.rotvel.x);
		objP->mtype.phys_info.rotvel.y   = INTEL_INT(objP->mtype.phys_info.rotvel.y);
		objP->mtype.phys_info.rotvel.z   = INTEL_INT(objP->mtype.phys_info.rotvel.z);

		objP->mtype.phys_info.rotthrust.x = INTEL_INT(objP->mtype.phys_info.rotthrust.x);
		objP->mtype.phys_info.rotthrust.y = INTEL_INT(objP->mtype.phys_info.rotthrust.y);
		objP->mtype.phys_info.rotthrust.z = INTEL_INT(objP->mtype.phys_info.rotthrust.z);

		objP->mtype.phys_info.turnroll   = INTEL_INT(objP->mtype.phys_info.turnroll);
		objP->mtype.phys_info.flags      = INTEL_SHORT(objP->mtype.phys_info.flags);

		break;

	case MT_SPINNING:

		objP->mtype.spin_rate.x = INTEL_INT(objP->mtype.spin_rate.x);
		objP->mtype.spin_rate.y = INTEL_INT(objP->mtype.spin_rate.y);
		objP->mtype.spin_rate.z = INTEL_INT(objP->mtype.spin_rate.z);
		break;
	}

	switch (objP->control_type) {

	case CT_WEAPON:
		objP->ctype.laser_info.parent_type       = INTEL_SHORT(objP->ctype.laser_info.parent_type);
		objP->ctype.laser_info.parent_num        = INTEL_SHORT(objP->ctype.laser_info.parent_num);
		objP->ctype.laser_info.parent_signature  = INTEL_INT(objP->ctype.laser_info.parent_signature);
		objP->ctype.laser_info.creation_time     = INTEL_INT(objP->ctype.laser_info.creation_time);
		objP->ctype.laser_info.last_hitobj       = INTEL_SHORT(objP->ctype.laser_info.last_hitobj);
		objP->ctype.laser_info.track_goal        = INTEL_SHORT(objP->ctype.laser_info.track_goal);
		objP->ctype.laser_info.multiplier        = INTEL_INT(objP->ctype.laser_info.multiplier);
		break;

	case CT_EXPLOSION:
		objP->ctype.expl_info.spawn_time     = INTEL_INT(objP->ctype.expl_info.spawn_time);
		objP->ctype.expl_info.delete_time    = INTEL_INT(objP->ctype.expl_info.delete_time);
		objP->ctype.expl_info.delete_objnum  = INTEL_SHORT(objP->ctype.expl_info.delete_objnum);
		objP->ctype.expl_info.attach_parent  = INTEL_SHORT(objP->ctype.expl_info.attach_parent);
		objP->ctype.expl_info.prev_attach    = INTEL_SHORT(objP->ctype.expl_info.prev_attach);
		objP->ctype.expl_info.next_attach    = INTEL_SHORT(objP->ctype.expl_info.next_attach);
		break;

	case CT_AI:
		objP->ctype.ai_info.hide_segment         = INTEL_SHORT(objP->ctype.ai_info.hide_segment);
		objP->ctype.ai_info.hide_index           = INTEL_SHORT(objP->ctype.ai_info.hide_index);
		objP->ctype.ai_info.path_length          = INTEL_SHORT(objP->ctype.ai_info.path_length);
		objP->ctype.ai_info.danger_laser_num     = INTEL_SHORT(objP->ctype.ai_info.danger_laser_num);
		objP->ctype.ai_info.danger_laser_signature = INTEL_INT(objP->ctype.ai_info.danger_laser_signature);
		objP->ctype.ai_info.dying_start_time     = INTEL_INT(objP->ctype.ai_info.dying_start_time);
		break;

	case CT_LIGHT:
		objP->ctype.light_info.intensity = INTEL_INT(objP->ctype.light_info.intensity);
		break;

	case CT_POWERUP:
		objP->ctype.powerup_info.count = INTEL_INT(objP->ctype.powerup_info.count);
		objP->ctype.powerup_info.creation_time = INTEL_INT(objP->ctype.powerup_info.creation_time);
		// Below commented out 5/2/96 by Matt.  I asked Allender why it was
		// here, and he didn't know, and it looks like it doesn't belong.
		// if (objP->id == POW_VULCAN_WEAPON)
		// objP->ctype.powerup_info.count = VULCAN_WEAPON_AMMO_AMOUNT;
		break;

	}

	switch (objP->render_type) {

	case RT_MORPH:
	case RT_POLYOBJ: {
		int i;

		objP->rtype.pobj_info.model_num      = INTEL_INT(objP->rtype.pobj_info.model_num);

		for (i=0;i<MAX_SUBMODELS;i++) {
			objP->rtype.pobj_info.anim_angles[i].p = INTEL_INT(objP->rtype.pobj_info.anim_angles[i].p);
			objP->rtype.pobj_info.anim_angles[i].b = INTEL_INT(objP->rtype.pobj_info.anim_angles[i].b);
			objP->rtype.pobj_info.anim_angles[i].h = INTEL_INT(objP->rtype.pobj_info.anim_angles[i].h);
		}

		objP->rtype.pobj_info.subobj_flags   = INTEL_INT(objP->rtype.pobj_info.subobj_flags);
		objP->rtype.pobj_info.tmap_override  = INTEL_INT(objP->rtype.pobj_info.tmap_override);
		objP->rtype.pobj_info.alt_textures   = INTEL_INT(objP->rtype.pobj_info.alt_textures);
		break;
	}

	case RT_WEAPON_VCLIP:
	case RT_HOSTAGE:
	case RT_POWERUP:
	case RT_FIREBALL:
	case RT_THRUSTER:
		objP->rtype.vclip_info.nClipIndex = INTEL_INT(objP->rtype.vclip_info.nClipIndex);
		objP->rtype.vclip_info.xFrameTime = INTEL_INT(objP->rtype.vclip_info.xFrameTime);
		break;

	case RT_LASER:
		break;

	}
//  END OF SWAPPING OBJECT STRUCTURE

}
コード例 #17
0
ファイル: polyobj.c プロジェクト: CDarrow/DXX-Retro
ubyte * old_dest(chunk o) // return where chunk is (in unaligned struct)
{
	return o.old_base + INTEL_SHORT(*((short *)(o.old_base + o.offset)));
}
コード例 #18
0
ファイル: font.cpp プロジェクト: n-kawamt/fs2open_snapshot
/**
 * @return -1 if couldn't init font, otherwise returns the font id number.
 */
int gr_create_font(char * typeface)
{
	CFILE *fp;
	font *fnt;
	int n, fontnum;

	fnt = Fonts;
	n = -1;
	for (fontnum=0; fontnum<Num_fonts; fontnum++ )	{
		if (fnt->id != 0 )	{
			if ( !_strnicmp( fnt->filename, typeface, MAX_FILENAME_LEN ) )	{
				return fontnum;
			}
		} else {
			if ( n < 0 )	{
				n = fontnum;
			}				
		}
		fnt++;
	}

	if ( fontnum == MAX_FONTS )	{
		Warning( LOCATION, "Too many fonts!\nSee John, or change MAX_FONTS in Graphics\\Font.h\n" );
		return -1;
	}

	if ( fontnum == Num_fonts )	{
		Num_fonts++;
	}
	
	bool localize = true;

	fp = cfopen( typeface, "rb", CFILE_NORMAL, CF_TYPE_ANY, localize );
	if ( fp == NULL ) return -1;

	strncpy( fnt->filename, typeface, MAX_FILENAME_LEN );
	cfread( &fnt->id, 4, 1, fp );
	cfread( &fnt->version, sizeof(int), 1, fp );
	cfread( &fnt->num_chars, sizeof(int), 1, fp );
	cfread( &fnt->first_ascii, sizeof(int), 1, fp );
	cfread( &fnt->w, sizeof(int), 1, fp );
	cfread( &fnt->h, sizeof(int), 1, fp );
	cfread( &fnt->num_kern_pairs, sizeof(int), 1, fp );
	cfread( &fnt->kern_data_size, sizeof(int), 1, fp );
	cfread( &fnt->char_data_size, sizeof(int), 1, fp );
	cfread( &fnt->pixel_data_size, sizeof(int), 1, fp );

	fnt->id = INTEL_SHORT( fnt->id ); //-V570
	fnt->version = INTEL_INT( fnt->version ); //-V570
	fnt->num_chars = INTEL_INT( fnt->num_chars ); //-V570
	fnt->first_ascii = INTEL_INT( fnt->first_ascii ); //-V570
	fnt->w = INTEL_INT( fnt->w ); //-V570
	fnt->h = INTEL_INT( fnt->h ); //-V570
	fnt->num_kern_pairs = INTEL_INT( fnt->num_kern_pairs ); //-V570
	fnt->kern_data_size = INTEL_INT( fnt->kern_data_size ); //-V570
	fnt->char_data_size = INTEL_INT( fnt->char_data_size ); //-V570
	fnt->pixel_data_size = INTEL_INT( fnt->pixel_data_size ); //-V570

	if ( fnt->kern_data_size )	{
		fnt->kern_data = (font_kernpair *)vm_malloc( fnt->kern_data_size );
		Assert(fnt->kern_data!=NULL);
		cfread( fnt->kern_data, fnt->kern_data_size, 1, fp );
	} else {
		fnt->kern_data = NULL;
	}
	if ( fnt->char_data_size )	{
		fnt->char_data = (font_char *)vm_malloc( fnt->char_data_size );
		Assert( fnt->char_data != NULL );
		cfread( fnt->char_data, fnt->char_data_size, 1, fp );

		for (int i=0; i<fnt->num_chars; i++) {
			fnt->char_data[i].spacing = INTEL_INT( fnt->char_data[i].spacing ); //-V570
			fnt->char_data[i].byte_width = INTEL_INT( fnt->char_data[i].byte_width ); //-V570
			fnt->char_data[i].offset = INTEL_INT( fnt->char_data[i].offset ); //-V570
			fnt->char_data[i].kerning_entry = INTEL_INT( fnt->char_data[i].kerning_entry ); //-V570
			fnt->char_data[i].user_data = INTEL_SHORT( fnt->char_data[i].user_data ); //-V570
		}
	} else {
		fnt->char_data = NULL;
	}
	if ( fnt->pixel_data_size )	{
		fnt->pixel_data = (ubyte *)vm_malloc( fnt->pixel_data_size );
		Assert(fnt->pixel_data!=NULL);
		cfread( fnt->pixel_data, fnt->pixel_data_size, 1, fp );
	} else {
		fnt->pixel_data = NULL;
	}
	cfclose(fp);

	// Create a bitmap for hardware cards.
	// JAS:  Try to squeeze this into the smallest square power of two texture.
	// This should probably be done at font generation time, not here.
	int w, h;
	if ( fnt->pixel_data_size*4 < 64*64 ) {
		w = h = 64;
	} else if ( fnt->pixel_data_size*4 < 128*128 ) {
		w = h = 128;
	} else if ( fnt->pixel_data_size*4 < 256*256 ) {
		w = h = 256;
	} else if ( fnt->pixel_data_size*4 < 512*512 ) {
		w = h = 512;
	} else {
		w = h = 1024;
	}

	fnt->bm_w = w;
	fnt->bm_h = h;
	fnt->bm_data = (ubyte *)vm_malloc(fnt->bm_w*fnt->bm_h);
	fnt->bm_u = (int *)vm_malloc(sizeof(int)*fnt->num_chars);
	fnt->bm_v = (int *)vm_malloc(sizeof(int)*fnt->num_chars);

	memset( fnt->bm_data, 0, fnt->bm_w * fnt->bm_h );

	int i,x,y;
	x = y = 0;
	for (i=0; i<fnt->num_chars; i++ )	{
		ubyte * ubp;
		int x1, y1;
		ubp = &fnt->pixel_data[fnt->char_data[i].offset];
		if ( x + fnt->char_data[i].byte_width >= fnt->bm_w )	{
			x = 0;
			y += fnt->h + 2;
			if ( y+fnt->h > fnt->bm_h ) {
				Error( LOCATION, "Font too big!\n" );
			}
		}
		fnt->bm_u[i] = x;
		fnt->bm_v[i] = y;

		for( y1=0; y1<fnt->h; y1++ )	{
			for (x1=0; x1<fnt->char_data[i].byte_width; x1++ )	{
				uint c = *ubp++;
				if ( c > 14 ) c = 14;
				fnt->bm_data[(x+x1)+(y+y1)*fnt->bm_w] = (unsigned char)(c);	
			}
		}
		x += fnt->char_data[i].byte_width + 2;
	}

	fnt->bitmap_id = bm_create( 8, fnt->bm_w, fnt->bm_h, fnt->bm_data, BMP_AABITMAP );

	return fontnum;
}
コード例 #19
0
//int pcx_read_bitmap_16bpp( char * real_filename, ubyte *org_data, ubyte bpp, int aabitmap, int nondark )
int pcx_read_bitmap( const char * real_filename, ubyte *org_data, ubyte *pal, int byte_size, int aabitmap, int nondark, int cf_type )
{
	PCXHeader header;
	CFILE * PCXfile;
	int row, col, count, xsize, ysize;
	ubyte data=0;
	int buffer_size, buffer_pos;
	ubyte buffer[1024];
	ubyte *pixdata;
	char filename[MAX_FILENAME_LEN];
	ubyte palette[768];	
	ushort bit_16;
	COLOR32 bit_32;
	ubyte r, g, b, al;
	
	strcpy_s( filename, real_filename );
	char *p = strchr( filename, '.' );
	if ( p ) *p = 0;
	strcat_s( filename, ".pcx" );

	
	PCXfile = cfopen( filename , "rb", CFILE_NORMAL, cf_type );
	if ( !PCXfile ){
	
		return PCX_ERROR_OPENING;
	}

	// read 128 char PCX header
	if (cfread( &header, sizeof(PCXHeader), 1, PCXfile )!=1)	{
		cfclose( PCXfile );
	
		return PCX_ERROR_NO_HEADER;
	}

	header.Xmin = INTEL_SHORT( header.Xmin ); //-V570
	header.Ymin = INTEL_SHORT( header.Ymin ); //-V570
	header.Xmax = INTEL_SHORT( header.Xmax ); //-V570
	header.Ymax = INTEL_SHORT( header.Ymax ); //-V570
	header.Hdpi = INTEL_SHORT( header.Hdpi ); //-V570
	header.Vdpi = INTEL_SHORT( header.Vdpi ); //-V570
	header.BytesPerLine = INTEL_SHORT( header.BytesPerLine ); //-V570

	// Is it a 256 color PCX file?
	if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))	{
		cfclose( PCXfile );
	
		return PCX_ERROR_WRONG_VERSION;
	}

	
	// Find the size of the image
	xsize = header.Xmax - header.Xmin + 1;
	ysize = header.Ymax - header.Ymin + 1;

	// Read the extended palette at the end of PCX file
	// Read in a character which should be 12 to be extended palette file

	cfseek( PCXfile, -768, CF_SEEK_END );
	cfread( palette, 1, (3 * 256), PCXfile );
	cfseek( PCXfile, sizeof(PCXHeader), CF_SEEK_SET );
	
	buffer_size = 1024;
	buffer_pos = 0;
	
//	Assert( buffer_size == 1024 );	// AL: removed to avoid optimized warning 'unreachable code'
	
	buffer_size = cfread( buffer, 1, buffer_size, PCXfile );

	count = 0;

	for (row=0; row<ysize;row++)      {
	
		pixdata = org_data;
		for (col=0; col<header.BytesPerLine;col++)     {
			if ( count == 0 )	{
				data = buffer[buffer_pos++];
				if ( buffer_pos == buffer_size )	{
					buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
					Assert( buffer_size > 0 );
					buffer_pos = 0;
				}
				if ((data & 0xC0) == 0xC0)     {
					count = data & 0x3F;
					data = buffer[buffer_pos++];
					if ( buffer_pos == buffer_size )	{
						buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
						Assert( buffer_size > 0 );
						buffer_pos = 0;
					}
				} else {
					count = 1;
				}
			}
			// stuff the pixel
			if ( col < xsize ) {
				// 8-bit PCX reads
				if ( byte_size == 1 ) {
					*pixdata++ = data;
				} else {
					// 16-bit AABITMAP reads
					if ( (byte_size == 2) && aabitmap ) {
						// stuff the pixel
						// memcpy(pixdata, &data, 2);
						*((ushort*)pixdata) = (ushort)data;
					} else {
						// stuff the 24 bit value				
						r = palette[data*3];
						g = palette[data*3 + 1];
						b = palette[data*3 + 2];

						// clear the pixel
						bit_16 = 0;
						memset(&bit_32, 0, sizeof(COLOR32));

						// 16-bit non-darkening reads
						if ( (byte_size == 2) && nondark ) {
							al = 0;
							if (palman_is_nondarkening(r, g, b)) {
								al = 255;
							}
						} else {
							// if the color matches the transparent color, make it so
							al = 255;

							if ( (0 == (int)palette[data*3]) && (255 == (int)palette[data*3+1]) && (0 == (int)palette[data*3+2]) ) {
								r = b = 0;
								g = (byte_size == 4) ? 0 : 255;
								al = 0;					
							}
						}

						// normal 16-bit reads
						if ( byte_size == 2 ) {
							// stuff the color
							bm_set_components((ubyte*)&bit_16, &r, &g, &b, &al);				

							// stuff the pixel
							*((ushort*)pixdata) = bit_16;
						}
						// normal 32-bit reads
						else if ( byte_size == 4 ) {
							if ( /*(r == 0) && (b == 0) && (g == 255) && (al == 0)*/ 0 ) {
								memset(&bit_32, 0, sizeof(COLOR32));
							} else {
								bit_32.r = r;
								bit_32.g = g;
								bit_32.b = b;
								bit_32.a = al;
							}

							// stuff the pixel
							*((COLOR32*)pixdata) = bit_32;
						}
					}

					pixdata += byte_size;
				}
			}

			count--;
		}

		org_data += (xsize * byte_size);
	}
	
	cfclose(PCXfile);
	
	return PCX_ERROR_NONE;
}
コード例 #20
0
ファイル: cfile.cpp プロジェクト: paud/d2x-xl
int CFWriteShort (short s, CFILE *file)
{
s = INTEL_SHORT (s);
return CFWrite (&s, sizeof (s), 1, file);
}
コード例 #21
0
ファイル: cfile.cpp プロジェクト: paud/d2x-xl
int CFWriteFixAng (fixang a, CFILE *file)
{
a = INTEL_SHORT (a);
return CFWrite (&a, sizeof (a), 1, file);
}
コード例 #22
0
ファイル: netmisc-old.c プロジェクト: paud/d2x-xl
void BEReceiveNetGamePacket(ubyte *data, netgame_info *netgame, int lite_flag)
{
	int i, j;
	int loc = 0;
	short bitfield; // new_field;

	memcpy(&(netgame->type), data + loc, 1);                      
	loc++;
	memcpy(&(netgame->Security), data + loc, 4);                  
	loc += 4;
	netgame->Security = INTEL_INT(netgame->Security);
	memcpy(netgame->game_name, data + loc, NETGAME_NAME_LEN+1);   
	loc += (NETGAME_NAME_LEN+1);
	memcpy(netgame->mission_title, data + loc, MISSION_NAME_LEN+1); 
	loc += (MISSION_NAME_LEN+1);
	memcpy(netgame->mission_name, data + loc, 9);                 
	loc += 9;
	memcpy(&(netgame->levelnum), data + loc, 4);                  
	loc += 4;
	netgame->levelnum = INTEL_INT(netgame->levelnum);
	memcpy(&(netgame->gamemode), data + loc, 1);                  
	loc++;
	memcpy(&(netgame->RefusePlayers), data + loc, 1);             
	loc++;
	memcpy(&(netgame->difficulty), data + loc, 1);                
	loc++;
	memcpy(&(netgame->game_status), data + loc, 1);               
	loc++;
	memcpy(&(netgame->numplayers), data + loc, 1);                
	loc++;
	memcpy(&(netgame->max_numplayers), data + loc, 1);            
	loc++;
	memcpy(&(netgame->numconnected), data + loc, 1);              
	loc++;
	memcpy(&(netgame->game_flags), data + loc, 1);                
	loc++;
	memcpy(&(netgame->protocol_version), data + loc, 1);          
	loc++;
	memcpy(&(netgame->version_major), data + loc, 1);             
	loc++;
	memcpy(&(netgame->version_minor), data + loc, 1);             
	loc++;
	memcpy(&(netgame->team_vector), data + loc, 1);               
	loc++;

	if (lite_flag)
		return;

	memcpy(&bitfield, data + loc, 2);                             
	loc += 2;
	bitfield = INTEL_SHORT(bitfield);
	memcpy(((ubyte *)(&netgame->team_vector) + 1), &bitfield, 2);

	memcpy(&bitfield, data + loc, 2);                             
	loc += 2;
	bitfield = INTEL_SHORT(bitfield);
	memcpy(((ubyte *)(&netgame->team_vector) + 3), &bitfield, 2);

#if 0       // not used since reordering mac bitfields
	memcpy(&bitfield, data + loc, 2);                             
	loc += 2;
	new_field = 0;
	for (i = 15; i >= 0; i--) {
		if (bitfield & (1 << i))
			new_field |= (1 << (15 - i);
	}
	new_field = INTEL_SHORT(new_field);
	memcpy(((ubyte *)(&netgame->team_vector) + 1), &new_field, 2);

	memcpy(&bitfield, data + loc, 2);                             
	loc += 2;
	new_field = 0;
	for (i = 15; i >= 0; i--) {
		if (bitfield & (1 << i))
			new_field |= (1 << (15 - i);
	}
	new_field = INTEL_SHORT(new_field);
	memcpy(((ubyte *)(&netgame->team_vector) + 3), &new_field, 2);
#endif

	memcpy(netgame->team_name, data + loc, 2*(CALLSIGN_LEN+1));   
	loc += 2*(CALLSIGN_LEN+1);
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->locations[i]), data + loc, 4);          
		loc += 4;
		netgame->locations[i] = INTEL_INT(netgame->locations[i]);
	}

	for (i = 0; i < MAX_PLAYERS; i++) {
		for (j = 0; j < MAX_PLAYERS; j++) {
			memcpy(&(netgame->kills[i][j]), data + loc, 2);       
			loc += 2;
			netgame->kills[i][j] = INTEL_SHORT(netgame->kills[i][j]);
		}
	}

	memcpy(&(netgame->segments_checksum), data + loc, 2);         
	loc += 2;
	netgame->segments_checksum = INTEL_SHORT(netgame->segments_checksum);
	memcpy(&(netgame->team_kills[0]), data + loc, 2);             
	loc += 2;
	netgame->team_kills[0] = INTEL_SHORT(netgame->team_kills[0]);
	memcpy(&(netgame->team_kills[1]), data + loc, 2);             
	loc += 2;
	netgame->team_kills[1] = INTEL_SHORT(netgame->team_kills[1]);
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->killed[i]), data + loc, 2);             
		loc += 2;
		netgame->killed[i] = INTEL_SHORT(netgame->killed[i]);
	}
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->player_kills[i]), data + loc, 2);       
		loc += 2;
		netgame->player_kills[i] = INTEL_SHORT(netgame->player_kills[i]);
	}
	memcpy(&(netgame->KillGoal), data + loc, 4);                  
	loc += 4;
	netgame->KillGoal = INTEL_INT(netgame->KillGoal);
	memcpy(&(netgame->PlayTimeAllowed), data + loc, 4);           
	loc += 4;
	netgame->PlayTimeAllowed = INTEL_INT(netgame->PlayTimeAllowed);

	memcpy(&(netgame->level_time), data + loc, 4);                
	loc += 4;
	netgame->level_time = INTEL_INT(netgame->level_time);
	memcpy(&(netgame->control_invul_time), data + loc, 4);        
	loc += 4;
	netgame->control_invul_time = INTEL_INT(netgame->control_invul_time);
	memcpy(&(netgame->monitor_vector), data + loc, 4);            
	loc += 4;
	netgame->monitor_vector = INTEL_INT(netgame->monitor_vector);
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->player_score[i]), data + loc, 4);       
		loc += 4;
		netgame->player_score[i] = INTEL_INT(netgame->player_score[i]);
	}
	for (i = 0; i < MAX_PLAYERS; i++) {
		memcpy(&(netgame->player_flags[i]), data + loc, 1);       
		loc++;
	}
	memcpy(&(netgame->nPacketsPerSec), data + loc, 2);             
	loc += 2;
	netgame->nPacketsPerSec = INTEL_SHORT(netgame->nPacketsPerSec);
	memcpy(&(netgame->bShortPackets), data + loc, 1);              
	loc ++;

}
コード例 #23
0
ファイル: pcxutils.cpp プロジェクト: lubomyr/freespace2
// #define GET_BUF()			do { buffer = &Pcx_load[Pcx_load_offset]; if(Pcx_load_offset + buffer_size > Pcx_load_size) { buffer_size = Pcx_load_size - Pcx_load_offset; } } while(0);
int pcx_read_bitmap_8bpp( char * real_filename, ubyte *org_data, ubyte *palette )
{
		PCXHeader header;
	CFILE * PCXfile;
	int row, col, count, xsize, ysize;
	ubyte data=0;
	int buffer_size, buffer_pos;
	ubyte buffer[1024];
	ubyte *pixdata;
	char filename[MAX_FILENAME_LEN];
		
	strcpy( filename, real_filename );
	char *p = strchr( filename, '.' );
	if ( p ) *p = 0;
	strcat( filename, ".pcx" );

	PCXfile = cfopen( filename , "rb" );
	if ( !PCXfile )
		return PCX_ERROR_OPENING;

	// read 128 char PCX header
	if (cfread( &header, sizeof(PCXHeader), 1, PCXfile )!=1)	{
		cfclose( PCXfile );
		return PCX_ERROR_NO_HEADER;
	}
        header.Xmin = INTEL_SHORT( header.Xmin );
        header.Ymin = INTEL_SHORT( header.Ymin );
        header.Xmax = INTEL_SHORT( header.Xmax );
        header.Ymax = INTEL_SHORT( header.Ymax );
        header.Hdpi = INTEL_SHORT( header.Hdpi );
        header.Vdpi = INTEL_SHORT( header.Vdpi );

        header.BytesPerLine = INTEL_SHORT( header.BytesPerLine );

	// Is it a 256 color PCX file?
	if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))	{
		cfclose( PCXfile );
		return PCX_ERROR_WRONG_VERSION;
	}

	// Find the size of the image
	xsize = header.Xmax - header.Xmin + 1;
	ysize = header.Ymax - header.Ymin + 1;

	// Read the extended palette at the end of PCX file
	// Read in a character which should be 12 to be extended palette file

	cfseek( PCXfile, -768, CF_SEEK_END );
	cfread( palette, 3, 256, PCXfile );
        
        for ( int i=0; i<256; i++ ){				//tigital
            palette[i] = INTEL_INT( palette[i] );
        }
	cfseek( PCXfile, sizeof(PCXHeader), CF_SEEK_SET );
	
	buffer_size = 1024;
	buffer_pos = 0;
	
//	Assert( buffer_size == 1024 );	// AL: removed to avoid optimized warning 'unreachable code'
	buffer_size = cfread( buffer, 1, buffer_size, PCXfile );

	count = 0;

	for (row=0; row<ysize;row++)      {
		pixdata = org_data;
		for (col=0; col<header.BytesPerLine;col++)     {
			if ( count == 0 )	{
				data = buffer[buffer_pos++];
				if ( buffer_pos == buffer_size )	{
					buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
					Assert( buffer_size > 0 );
					buffer_pos = 0;
				}
				if ((data & 0xC0) == 0xC0)     {
					count = data & 0x3F;
					data = buffer[buffer_pos++];
					if ( buffer_pos == buffer_size )	{
						buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
						Assert( buffer_size > 0 );
						buffer_pos = 0;
					}
				} else {
					count = 1;
				}
			}
			if ( col < xsize )
				*pixdata++ = data;
			count--;
		}
		org_data += xsize;
	}
	cfclose(PCXfile);
	return PCX_ERROR_NONE;
}
コード例 #24
0
ファイル: netmisc-new.cpp プロジェクト: paud/d2x-xl
void BEReceiveMissingObjFrames(ubyte *data, tMissingObjFrames *missingObjFrames)
{
memcpy (missingObjFrames, nmDataBuf, sizeof (tMissingObjFrames));
missingObjFrames->nFrame = INTEL_SHORT (missingObjFrames->nFrame);
}
コード例 #25
0
ファイル: cfile.cpp プロジェクト: paud/d2x-xl
int CFile::WriteFixAng (fixang a)
{
a = INTEL_SHORT (a);
return Write (&a, sizeof (a), 1);
}
コード例 #26
0
ファイル: network_read.cpp プロジェクト: paud/d2x-xl
void NetworkReadPDataPacket (tFrameInfo *pd)
{
    int nTheirPlayer;
    int theirObjNum;
    CObject * theirObjP = NULL;

// tFrameInfo should be aligned...for mac, make the necessary adjustments
#if defined (WORDS_BIGENDIAN) || defined (__BIG_ENDIAN__)
    if (gameStates.multi.nGameType >= IPX_GAME) {
        pd->nPackets = INTEL_INT (pd->nPackets);
        pd->objPos[X] = INTEL_INT (pd->objPos[X]);
        pd->objPos[Y] = INTEL_INT (pd->objPos[Y]);
        pd->objPos[Z] = INTEL_INT (pd->objPos[Z]);
        pd->objOrient.RVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[X]);
        pd->objOrient.RVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[Y]);
        pd->objOrient.RVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.RVec ()[Z]);
        pd->objOrient.UVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[X]);
        pd->objOrient.UVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[Y]);
        pd->objOrient.UVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.UVec ()[Z]);
        pd->objOrient.FVec ()[X] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[X]);
        pd->objOrient.FVec ()[Y] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[Y]);
        pd->objOrient.FVec ()[Z] = (fix)INTEL_INT ((int)pd->objOrient.FVec ()[Z]);
        pd->physVelocity[X] = (fix)INTEL_INT ((int)pd->physVelocity[X]);
        pd->physVelocity[Y] = (fix)INTEL_INT ((int)pd->physVelocity[Y]);
        pd->physVelocity[Z] = (fix)INTEL_INT ((int)pd->physVelocity[Z]);
        pd->physRotVel[X] = (fix)INTEL_INT ((int)pd->physRotVel[X]);
        pd->physRotVel[Y] = (fix)INTEL_INT ((int)pd->physRotVel[Y]);
        pd->physRotVel[Z] = (fix)INTEL_INT ((int)pd->physRotVel[Z]);
        pd->nObjSeg = INTEL_SHORT (pd->nObjSeg);
        pd->dataSize = INTEL_SHORT (pd->dataSize);
    }
#endif
    nTheirPlayer = pd->nPlayer;
    theirObjNum = gameData.multiplayer.players [pd->nPlayer].nObject;
    if (nTheirPlayer < 0) {
        Int3 (); // This packet is bogus!!
        return;
    }
    if ((networkData.sync [0].nPlayer != -1) && (nTheirPlayer == networkData.sync [0].nPlayer))
        networkData.sync [0].nPlayer = -1;
    if (!gameData.multigame.bQuitGame && (nTheirPlayer >= gameData.multiplayer.nPlayers)) {
        if (networkData.nStatus != NETSTAT_WAITING) {
            Int3 (); // We missed an important packet!
            NetworkConsistencyError ();
        }
        return;
    }
    if (gameStates.app.bEndLevelSequence || (networkData.nStatus == NETSTAT_ENDLEVEL)) {
        int old_Endlevel_sequence = gameStates.app.bEndLevelSequence;
        gameStates.app.bEndLevelSequence = 1;
        if (pd->dataSize > 0)
            // pass pd->data to some parser function....
            MultiProcessBigData (reinterpret_cast<char*> (pd->data), pd->dataSize);
        gameStates.app.bEndLevelSequence = old_Endlevel_sequence;
        return;
    }
    if ((sbyte)pd->nLevel != gameData.missions.nCurrentLevel) {
#if 1
        console.printf (CON_DBG, "Got frame packet from CPlayerData %d wrong level %d!\n", pd->nPlayer, pd->nLevel);
#endif
        return;
    }

    theirObjP = OBJECTS + theirObjNum;
//------------- Keep track of missed packets -----------------
    gameData.multiplayer.players [nTheirPlayer].nPacketsGot++;
    networkData.nTotalPacketsGot++;
    ResetPlayerTimeout (nTheirPlayer, -1);
    if  (pd->nPackets != gameData.multiplayer.players [nTheirPlayer].nPacketsGot) {
        networkData.nMissedPackets = pd->nPackets - gameData.multiplayer.players [nTheirPlayer].nPacketsGot;
        if ((pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot) > 0)
            networkData.nTotalMissedPackets += pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot;
#if 1
        if (networkData.nMissedPackets > 0)
            console.printf (0,
                            "Missed %d packets from CPlayerData #%d (%d total)\n",
                            pd->nPackets-gameData.multiplayer.players [nTheirPlayer].nPacketsGot,
                            nTheirPlayer,
                            networkData.nMissedPackets);
        else
            console.printf (CON_DBG,
                            "Got %d late packets from CPlayerData #%d (%d total)\n",
                            gameData.multiplayer.players [nTheirPlayer].nPacketsGot-pd->nPackets,
                            nTheirPlayer,
                            networkData.nMissedPackets);
#endif
        gameData.multiplayer.players [nTheirPlayer].nPacketsGot = pd->nPackets;
    }
//------------ Read the CPlayerData's ship's CObject info ----------------------
    theirObjP->info.position.vPos = pd->objPos;
    theirObjP->info.position.mOrient = pd->objOrient;
    theirObjP->mType.physInfo.velocity = pd->physVelocity;
    theirObjP->mType.physInfo.rotVel = pd->physRotVel;
    if ((theirObjP->info.renderType != pd->objRenderType) && (pd->objRenderType == RT_POLYOBJ))
        MultiMakeGhostPlayer (nTheirPlayer);
    OBJECTS [theirObjNum].RelinkToSeg (pd->nObjSeg);
    if (theirObjP->info.movementType == MT_PHYSICS)
        theirObjP->SetThrustFromVelocity ();
//------------ Welcome them back if reconnecting --------------
    if (!gameData.multiplayer.players [nTheirPlayer].connected) {
        gameData.multiplayer.players [nTheirPlayer].connected = 1;
        if (gameData.demo.nState == ND_STATE_RECORDING)
            NDRecordMultiReconnect (nTheirPlayer);
        MultiMakeGhostPlayer (nTheirPlayer);
        OBJECTS [theirObjNum].CreateAppearanceEffect ();
        audio.PlaySound (SOUND_HUD_MESSAGE);
        ClipRank (reinterpret_cast<char*> (&netPlayers.players [nTheirPlayer].rank));
        if (gameOpts->multi.bNoRankings)
            HUDInitMessage ("'%s' %s", gameData.multiplayer.players [nTheirPlayer].callsign, TXT_REJOIN);
        else
            HUDInitMessage ("%s'%s' %s",
                            pszRankStrings [netPlayers.players [nTheirPlayer].rank],
                            gameData.multiplayer.players [nTheirPlayer].callsign, TXT_REJOIN);
        MultiSendScore ();
    }
//------------ Parse the extra dataP at the end ---------------
    if (pd->dataSize > 0)
        // pass pd->data to some parser function....
        MultiProcessBigData (reinterpret_cast<char*> (pd->data), pd->dataSize);
}
コード例 #27
0
ファイル: netmisc-new.cpp プロジェクト: paud/d2x-xl
void BESwapObject (tObject *objP)
{
// swap the short and int entries for this tObject
objP->info.nSignature = INTEL_INT (objP->info.nSignature);
objP->info.nNextInSeg = INTEL_SHORT (objP->info.nNextInSeg);
objP->info.nPrevInSeg = INTEL_SHORT (objP->info.nPrevInSeg);
objP->info.nSegment = INTEL_SHORT (objP->info.nSegment);
INTEL_VECTOR (objP->info.position.vPos);
INTEL_MATRIX (objP->info.position.mOrient);
objP->info.xSize = INTEL_INT (objP->info.xSize);
objP->info.xShields = INTEL_INT (objP->info.xShields);
INTEL_VECTOR (objP->info.vLastPos);
objP->info.xLifeLeft = INTEL_INT (objP->info.xLifeLeft);
switch (objP->info.movementType) {
	case MT_PHYSICS:
		INTEL_VECTOR (objP->mType.physInfo.velocity);
		INTEL_VECTOR (objP->mType.physInfo.thrust);
		objP->mType.physInfo.mass = INTEL_INT (objP->mType.physInfo.mass);
		objP->mType.physInfo.drag = INTEL_INT (objP->mType.physInfo.drag);
		objP->mType.physInfo.brakes = INTEL_INT (objP->mType.physInfo.brakes);
		INTEL_VECTOR (objP->mType.physInfo.rotVel);
		INTEL_VECTOR (objP->mType.physInfo.rotThrust);
		objP->mType.physInfo.turnRoll = INTEL_INT (objP->mType.physInfo.turnRoll);
		objP->mType.physInfo.flags = INTEL_SHORT (objP->mType.physInfo.flags);
		break;

	case MT_SPINNING:
		INTEL_VECTOR (objP->mType.spinRate);
		break;
	}

switch (objP->info.controlType) {
	case CT_WEAPON:
		objP->cType.laserInfo.parent.nType = INTEL_SHORT (objP->cType.laserInfo.parent.nType);
		objP->cType.laserInfo.parent.nObject = INTEL_SHORT (objP->cType.laserInfo.parent.nObject);
		objP->cType.laserInfo.parent.nSignature = INTEL_INT (objP->cType.laserInfo.parent.nSignature);
		objP->cType.laserInfo.xCreationTime = INTEL_INT (objP->cType.laserInfo.xCreationTime);
		objP->cType.laserInfo.nLastHitObj = INTEL_SHORT (objP->cType.laserInfo.nLastHitObj);
		if (objP->cType.laserInfo.nLastHitObj < 0)
			objP->cType.laserInfo.nLastHitObj = 0;
		else {
			gameData.objs.nHitObjects [OBJ_IDX (objP) * MAX_HIT_OBJECTS] = objP->cType.laserInfo.nLastHitObj;
			objP->cType.laserInfo.nLastHitObj = 1;
			}
		objP->cType.laserInfo.nHomingTarget = INTEL_SHORT (objP->cType.laserInfo.nHomingTarget);
		objP->cType.laserInfo.xScale = INTEL_INT (objP->cType.laserInfo.xScale);
		break;

	case CT_EXPLOSION:
		objP->cType.explInfo.nSpawnTime = INTEL_INT (objP->cType.explInfo.nSpawnTime);
		objP->cType.explInfo.nDeleteTime = INTEL_INT (objP->cType.explInfo.nDeleteTime);
		objP->cType.explInfo.nDeleteObj = INTEL_SHORT (objP->cType.explInfo.nDeleteObj);
		objP->cType.explInfo.attached.nParent = INTEL_SHORT (objP->cType.explInfo.attached.nParent);
		objP->cType.explInfo.attached.nPrev = INTEL_SHORT (objP->cType.explInfo.attached.nPrev);
		objP->cType.explInfo.attached.nNext = INTEL_SHORT (objP->cType.explInfo.attached.nNext);
		break;

	case CT_AI:
		objP->cType.aiInfo.nHideSegment = INTEL_SHORT (objP->cType.aiInfo.nHideSegment);
		objP->cType.aiInfo.nHideIndex = INTEL_SHORT (objP->cType.aiInfo.nHideIndex);
		objP->cType.aiInfo.nPathLength = INTEL_SHORT (objP->cType.aiInfo.nPathLength);
		objP->cType.aiInfo.nDangerLaser = INTEL_SHORT (objP->cType.aiInfo.nDangerLaser);
		objP->cType.aiInfo.nDangerLaserSig = INTEL_INT (objP->cType.aiInfo.nDangerLaserSig);
		objP->cType.aiInfo.xDyingStartTime = INTEL_INT (objP->cType.aiInfo.xDyingStartTime);
		break;

	case CT_LIGHT:
		objP->cType.lightInfo.intensity = INTEL_INT (objP->cType.lightInfo.intensity);
		break;

	case CT_POWERUP:
		objP->cType.powerupInfo.nCount = INTEL_INT (objP->cType.powerupInfo.nCount);
		objP->cType.powerupInfo.xCreationTime = INTEL_INT (objP->cType.powerupInfo.xCreationTime);
		break;
	}

switch (objP->info.renderType) {
	case RT_MORPH:
	case RT_POLYOBJ: {
		int i;

		objP->rType.polyObjInfo.nModel = INTEL_INT (objP->rType.polyObjInfo.nModel);

		for (i = 0; i < MAX_SUBMODELS; i++)
			INTEL_ANGVEC (objP->rType.polyObjInfo.animAngles [i]);
		objP->rType.polyObjInfo.nSubObjFlags = INTEL_INT (objP->rType.polyObjInfo.nSubObjFlags);
		objP->rType.polyObjInfo.nTexOverride = INTEL_INT (objP->rType.polyObjInfo.nTexOverride);
		objP->rType.polyObjInfo.nAltTextures = INTEL_INT (objP->rType.polyObjInfo.nAltTextures);
		break;
	}

	case RT_WEAPON_VCLIP:
	case RT_HOSTAGE:
	case RT_POWERUP:
	case RT_FIREBALL:
	case RT_THRUSTER:
		objP->rType.vClipInfo.nClipIndex = INTEL_INT (objP->rType.vClipInfo.nClipIndex);
		objP->rType.vClipInfo.xFrameTime = INTEL_INT (objP->rType.vClipInfo.xFrameTime);
		break;

	case RT_LASER:
		break;
	}
}
コード例 #28
0
ファイル: pcxutils.cpp プロジェクト: lubomyr/freespace2
int pcx_read_bitmap_16bpp_nondark( char * real_filename, ubyte *org_data )
{	
	PCXHeader header;
	CFILE * PCXfile;
	int row, col, count, xsize, ysize;
	ubyte data=0;
	int buffer_size, buffer_pos;
	ubyte buffer[1024];
	ubyte *pixdata;
	char filename[MAX_FILENAME_LEN];
	ubyte palette[768];	
	ushort bit_16;	
	ubyte r, g, b, al;
		
	strcpy( filename, real_filename );
	char *p = strchr( filename, '.' );
	if ( p ) *p = 0;
	strcat( filename, ".pcx" );

	PCXfile = cfopen( filename , "rb" );
	if ( !PCXfile ){
		return PCX_ERROR_OPENING;
	}

	// read 128 char PCX header
	if (cfread( &header, sizeof(PCXHeader), 1, PCXfile )!=1)	{
		cfclose( PCXfile );
		return PCX_ERROR_NO_HEADER;
	}
        header.Xmin = INTEL_SHORT( header.Xmin );
        header.Ymin = INTEL_SHORT( header.Ymin );
        header.Xmax = INTEL_SHORT( header.Xmax );
        header.Ymax = INTEL_SHORT( header.Ymax );
        header.Hdpi = INTEL_SHORT( header.Hdpi );
        header.Vdpi = INTEL_SHORT( header.Vdpi );
        header.BytesPerLine = INTEL_SHORT( header.BytesPerLine );       

	// Is it a 256 color PCX file?
	if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))	{
		cfclose( PCXfile );
		return PCX_ERROR_WRONG_VERSION;
	}

	// Find the size of the image
	xsize = header.Xmax - header.Xmin + 1;
	ysize = header.Ymax - header.Ymin + 1;

	// Read the extended palette at the end of PCX file
	// Read in a character which should be 12 to be extended palette file

	cfseek( PCXfile, -768, CF_SEEK_END );
	cfread( palette, 3, 256, PCXfile );
	cfseek( PCXfile, sizeof(PCXHeader), CF_SEEK_SET );
	
	buffer_size = 1024;
	buffer_pos = 0;
	
//	Assert( buffer_size == 1024 );	// AL: removed to avoid optimized warning 'unreachable code'
	buffer_size = cfread( buffer, 1, buffer_size, PCXfile );

	count = 0;

	for (row=0; row<ysize;row++)      {
		pixdata = org_data;
		for (col=0; col<header.BytesPerLine;col++)     {
			if ( count == 0 )	{
				data = buffer[buffer_pos++];
				if ( buffer_pos == buffer_size )	{
					buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
					Assert( buffer_size > 0 );
					buffer_pos = 0;
				}
				if ((data & 0xC0) == 0xC0)     {
					count = data & 0x3F;
					data = buffer[buffer_pos++];
					if ( buffer_pos == buffer_size )	{
						buffer_size = cfread( buffer, 1, buffer_size, PCXfile );
						Assert( buffer_size > 0 );
						buffer_pos = 0;
					}
				} else {
					count = 1;
				}
			}
			// stuff the pixel
			if ( col < xsize ){				
				// stuff the 24 bit value				
				r = palette[data*3];
				g = palette[data*3 + 1];
				b = palette[data*3 + 2];							

				// if this is a nondarkening texture				
				// if this color matches a nondarkening pixel color, set the alpha to high
				al = 0;
				if(palman_is_nondarkening(r, g, b)){
					al = 255;
				}

				// set the pixel
				bit_16 = 0;
				bm_set_components((ubyte*)&bit_16, &r, &g, &b, &al);					
				
				// stuff the pixel
				*((ushort*)pixdata) = bit_16;				
				pixdata += 2;
			}
			count--;
		}

		org_data += (xsize * 2);
	}
	cfclose(PCXfile);
	return PCX_ERROR_NONE;
}
コード例 #29
0
ファイル: cfile.cpp プロジェクト: paud/d2x-xl
int CFile::WriteShort (short s)
{
s = INTEL_SHORT (s);
return Write(&s, sizeof (s), 1);
}