¿Cuál es el formato de Fantasy Westward Journey?
Esta clase fue escrita por mí y se utiliza principalmente para leer el formato de archivo de mapa de "Westward Journey II" y "Fantasy Westward". Viaje". Sin embargo, esta clase no contiene la función de procesamiento para cada unidad en el mapa, por lo que se pueden escribir otras clases relacionadas para hacer esto. Este curso se utiliza principalmente para la enseñanza y la investigación científica y no debe usarse en el campo comercial u otros lugares que infrinjan los intereses de NetEase. No puedo garantizar la seguridad o calidad de este curso. En caso de duda, no lo use. Materiales de referencia:
Formato de archivo de mapa antiguo
Formato de archivo de mapa nuevo
El nuevo formato de mapa de 1302.
Dahua 0038 nuevo formato de mapa
/****************************** ************************************************* ***** *******************
*Westward Journey II y Fantasy Westward Journey
*Lectura de formato de archivo de mapa clase
* -
*Versión 2.2.0
*
* wdl@sina.com Wang Dali
* 20 de mayo de 2006
* -
*Declaración:
*Este código fuente se utiliza para leer el formato de archivo de mapas de los juegos en línea NetEase " Viaje hacia el oeste II" y "Viaje de fantasía hacia el oeste".
*Los derechos de autor del formato de archivo correspondiente a este código fuente pertenecen a NetEase.
*Este código fuente tiene fines educativos y está prohibido su uso con fines comerciales. De lo contrario, usted será responsable de las consecuencias.
*Si tiene alguna objeción, utilice este código fuente y elimínelo permanentemente.
* -
*Copyright (c) 2006 Wangchengxing, todos los derechos reservados.
********************************************* *** ************************************************* **** /
#include "ReadGameMap.h "
Usar el espacio de nombres de NetEase //Usar el espacio de nombres de NetEase ReadGameMap::ReadGameMap(void)
{
//m _ MapWidth = 0; //Inicializa el ancho del mapa
//m _ map height = 0 //Inicializa el alto del mapa
m _ SubMapWidth = 320//Inicializa el ancho del submapa
m _ SubMapHeight = 240//Inicializa la altura del submapa
m _ mask temp = 1; //Inicializa la variable temporal de máscara
//m _ sub prownum = 0; //El número de filas en el submapa
//m _ SubMapColNum = 0; //El número de columnas en el submapa
//m _ sub maptoal = 0; //Número total de submapas
} leer mapa de juego::~ leer mapa de juego(void )
{
}//Cargar archivo de mapa
bool leer mapa de juego:: LoadMap(char * nombre de archivo)
{
FILE * fp
//m_FileName = filename; //Nombre de archivo de mapeo de variables globales strcpy (m_filename, filename); //Abrir secuencia
if( (fp) = fopen(m_FileName, "Rb")= = NULL)
{
Printf("Error al abrir el archivo.\n ");
Devuelve falso
}//Leer Obtener el encabezado del archivo del mapa
MapHeader title;
Fred(ampheader, sizeof(MapHeader), 1, FP); encabezado del archivo de mapa m_mapwidth = header.width//Ancho del mapa
m_MapHeight=header. //Alto del mapa m _ submapflownum = ceil((float)(m _ map width/m _ submapwidth) ); //Línea de cálculo El número de submapas.
m _ SubMapColNum = ceil((float)(m _ map height/m _ SubMapHeight)); //Calcula el número de submapas en la columna.
m _ sub maptotal = m _ sub prownum * m _ sub mapcolnum; // Calcula el número total de submapas en el mapa // printf ("flag = 0x x \ n", header . bandera);
//printf("Ancho=d\n ", encabezado. Ancho
//printf("Alto=d\n ", encabezado).
height);
//printf(" m _ sub maptoal = d \ n ", m _ sub maptoal // Determina si el encabezado del archivo es correcto (MapX);
if((Encabezado. Bandera! = 0x4d 415058) amp; amp (Encabezado. Bandera! = 0x4D312E30))
{
Printf("No compatible Formato de archivo de mapa. \n ");
Devuelve falso
}//Lee la lista de valores de compensación del submapa.
m _ SubMapOffsetList = new uint 32[m _ sub mapotal]; // Asignar automáticamente espacio en la lista
fread(m_SubMapOffsetList, sizeof(uint32), m _ SubMapTotal, FP); //Leer lista
fred(ampm_MapSize, sizeof(uint32), 1, FP); //Leer tamaño de archivo o tamaño de encabezado //printf(" m_suboffsetlist = 0x x \n ", m_suboffsetlist[60] ); // MAPX
if (Encabezado. Bandera == 0x4D415058)
{
leer jpgh(FP) //Leer datos JPGH; >
m _ file type = 1; //Establece el tipo de archivo de mapeo
}
// M1.0
if (Header. Flag == 0x4D312E30)
{
Cabezal de lectura (FP); //Lee los datos del nuevo mapa.
m _ FileType = 2; //Establecer el tipo de archivo de mapeo
} f close(FP); //Cerrar la secuencia
Devuelve verdadero
}//Leer datos JPGH del mapa
bool leer mapa del juego::leer jpgh(FILE * FP)
{
UnitHeader JpegHead
Fred(ampJpegHead, sizeof(JpegHead), 1, FP); //Lee los datos del encabezado de la celda //Juzga si la bandera es correcta (HGPJ)
if (JpegHead. Bandera! =0x4A504748)
{
Printf("Error de bandera de encabezado JPEG.\n ");
Devuelve falso
}
m_jpgh. Datos = nuevo uint8[JpegHead. size]; //Asignar espacio de memoria para los datos de la unidad
m_jpgh. Tamaño = JpegHead. Tamaño;
fread(m_jpgh.data, JpegHead.size, 1, FP); //Leer datos de la celda
//PrintHex(m_JpegHeadDate, JpegHead.size);
Devuelve verdadero
}//Lee los datos del encabezado del mapa.
bool read gamemap::read head(FILE * FP)
{
uint32 HeaderSizeheader size = m_SubMapOffsetList[0]-m_MapSize;/ /Calcular el tamaño de datos del encabezado del mapa
m_head. Tamaño = Tamaño del encabezado
m_head. data = new uint 8[tamaño del encabezado];
fread(m_head.Data, sizeof(uint8), HeaderSize, FP //Leer datos del encabezado del mapa
//PrintHex ( MapHeadData. Data, MapHeadData. Size);
Return true
}//Lee los datos de la unidad del mapa
bool read gamemap::read unit( uint 32 UnitNum)
{
ARCHIVO * fp
int64 buscar
Resultado booleano;
bucle bool = true
char *nombre de archivo;
m _ máscara temp = 1; //Abrir flujo
//printf("m_FileName=s\n " , m_FileName);
if( (fp = fopen(m_FileName, "Rb") = = NULL)
{
Printf("Error al abrir archivo. \n ");
Devuelve falso
} seek = m _ SubMapOffsetList[UnitNum];
//printf("Seek=0xX\n ", Seek);
fseek(fp, seek, SEEK_SET);
fred(ampm_MaskNum, sizeof(uint32), 1, FP); //Leer número de máscaras
//printf("m_MaskNum=d\n ", m _ mask num); //Nuevo uso del mapa
if((m _ FileType = = 2 ) amp; amp(m _ MaskNum gt0))
{
//printf("¡Nuevo mapa!\ n ");
m _ lista de máscaras = nuevo uint 32[m _ máscara num];
fread(m_MaskList, sizeof(uint32), m_MaskNum, FP);
} unidad UnitHeader; while (bucle)
{
Fred(ampunit, sizeof(UnitHeader), 1, FP); //Leer los datos del encabezado de la unidad //printf ("unit flag =X\n ", unit . flag);
//printf ("tamaño de celda =d\n ", unidad. tamaño switch (unidad. bandera)
{
/ / GAMI "47 41 4D 49 "
Caso 0x494D4147:
Resultado=ReadIMAG(fp, unidad. bandera, unidad.
tamaño);
Pausa; // GEPJ "47 45 50 4A "
Caso 0x4A504547:
Resultado=LeerJPEG(fp, unidades. banderas, unidades. size);
Break; // KSAM "4B 53 41 4D"
Caso 0x4D41534B:
resultado = readmask(fp,units.flags, unit. size);
Break; // KOLB "4B 4F 4C 42"
Caso 0x424C4F4B:
Resultado=ReadBLOK(fp, unit.flag, unit. tamaño);
Pausa; // LLEC "4C 4C 45 43"
Caso 0x43454C4C:
Resultado=ReadCELL(fp, unit.flag, unit. size);
Break; //GIRB 47 49 52 42
Caso 0x42524947:
Resultado=ReadBRIG(fp,units.flags,units. size) ;
loop = false
Break; //Procesamiento predeterminado
Valor predeterminado:
m_EndUnit. bandera = unidad. Bandera;
m_EndUnit. tamaño = unidad. Tamaño;
bucle = false
//printf("¡Error de bandera!\n");
//printf("Flag=0xX\n\ n ", unidad. bandera);
Break;
//Return false
} }
fclose(FP);
}//Leer ancho del mapa
uint 32 leer gamemap::leer mapwidth()
{
Devolver m _ MapWidth
p>}//Leer altura del mapa
uint 32 leer gamemap::readmap height()
{
Devolver m _ MapHeight
}//Leer el ancho del submapa
uint 32 leer gamemap::ReadSubMapWidth()
{
Devolver m _ SubMapWidth
}//Leer la altura del submapa
uint 32 leer gamemap::ReadSubMapHeight()
{
Regresar m _ SubMapHeight
}//Leer el número total de submapas.
uint 32 read gamemap::ReadSubMapTotal()
{
Return m_SubMapTotal
}//Leer máscara de submapa El número total de códigos.
uint 32 read gamemap::ReadMaskTotal()
{
Devolver m_MaskNum
}//Leer el tamaño del archivo del mapa
uint32 ReadGameMap::ReadMapSize()
{
Return m_MapSize
}//Leer los datos de la imagen del mapa
bool leer mapa de juego::leer imag(FILE * FP, bandera uint32, tamaño uint32)
{
if (Flag==0x494D4147)
{
m_imag. data = new uint 8[Size]; //Asignar espacio de memoria para los datos de la unidad
fread(m_imag.data, size, 1, FP //Leer los datos de la unidad IMAG
<); p>m_imag. tamaño = tamaño;//printf("Datos IMAG:\n");
//PrintHex(m_ImagData, Tamaño);
}
}
p>Otros
{
Printf("¡Error de indicador IMAG!\n ");
Devuelve falso
}
Devuelve verdadero
}//Leer datos JPEG del mapa.
bool leer mapa de juego::leer JPEG(ARCHIVO *FP, bandera uint32, tamaño uint32)
{
if (Flag==0x4A504547)
{
Fred(ampm_SubMapWidth, sizeof(uint16), 1, FP); //El ancho del submapa
Fred(ampm_SubMapHeight, sizeof(uint16), 1 , FP); //Altura del submapa
m_jpeg. data = new uint 8[Size-4]; //Asignar espacio de memoria para los datos de la unidad
fread(m_jpeg.data, size-4, 1, FP) //Leer datos JPEG de la unidad
m_jpeg. tamaño=tamaño;
//printf("Datos JPEG:\n");
//PrintHex(m_JpegData, Tamaño-4);
}
Otros
{
Printf("¡Error de indicador JPEG!\n ");
Devuelve falso
}Devolver verdadero
}//Leer datos de la máscara del mapa
bool leer mapa de juego::leer máscara(FILE * FP, bandera uint32, tamaño uint32)
{
if (Flag==0x4D41534B)
{
//printf("m_MaskTemp=d\n ",m _ máscara temp);
m_mask[m_MaskTemp]. data = new uint 8[Size]; //Asignar espacio de memoria para los datos de la unidad
m_mask[m_MaskTemp].
size = size;
fread(m_mask[m_MaskTemp].data, size, 1, FP); //Lee los datos de la máscara de la unidad.
//printf("Datos de máscara: \n ");
//PrintHex(máscara[m_MaskTemp]). m_MaskData, Tamaño); m _ mask temp;
}
Otros
{
Printf("¡Error de indicador de máscara!\ n ");
Devuelve falso
}Devuelve verdadero
}//Lee los datos del mosaico del mapa
bool leer mapa del juego: :read blok(ARCHIVO * FP, bandera uint32, tamaño uint32)
{
if (Flag==0x424C4F4B)
{
m_blok. data = new uint 8[Size]; //Asignar espacio de memoria para los datos de la celda
Fred(m_blok.data, size, 1, FP); //Leer los datos de la celda BLOK.
m_blok. tamaño = tamaño;
//printf("BLOK data:\n");
//PrintHex(m_BlokData, Tamaño);
}< / p>
Otro
{
Printf("¡Error de indicador BLOK!\n ");
Devuelve falso
} Devuelve verdadero
}//Leer datos de la celda del mapa
bool read gamemap::read cell(FILE * FP, uint32 flag, uint32 size)
{
if (Flag==0x43454C4C)
{
m_cell. data = new uint 8[Size]; //Asignar espacio de memoria para los datos de la celda
fread(m_cell.data, size, 1, FP); //Leer datos de la celda
m_cell); .
tamaño = tamaño;
//printf("Datos de celda:\n");
//PrintHex(m_CellData, Tamaño);
}
Otros
{
Printf("¡Error de marca de celda!\n ");
Devuelve falso
} Devuelve verdadero
}//Leer datos del puente del mapa
bool read gamemap::read brig(FILE * FP, uint32 flag, uint32 size)
{
if (Flag==0x42524947)
{
m _ brig . Data = new uint 8[Size] // es la unidad de espacio de memoria de asignación de datos;
fread(m_brig.Data, Size, 1, FP); //Leer datos de la batería de la unidad
m _ brig. Tamaño = Tamaño
//printf (" datos del bergantín:\n ");
//PrintHex(m_BirgData, Size);
}
Otros
{
Printf("¡Error de bandera BRIG!\n ");
Devuelve falso
}Devuelve verdadero
}//Leer JPGH data
MapData leer mapa del juego:: ReadJpghData()
{
Return m_jpgh
}//Leer los datos del cabezal magnético .
MapData leer mapa del juego::leer datos de cabeza()
{
Devolver m_head
}//Leer datos IMAG
MapData leer gamemap::readi magdata()
{
Regresar m_imag
}//Leer datos JPEG.
MapData leer mapa del juego::leer datos JPEG()
{
devolver m_jpeg
}
/ /Leer los datos de la máscara.
MapData leer mapa del juego::ReadMaskData(uint 8 ID)
{
Devuelve m_mask[ID];
}
//Leer datos de BLOK
MapData leer mapa de juego:: leer datos de blok()
{
Devolver m _ blok
}//Leer datos de celda
MapData leer gamemap::ReadCellData()
{
Devolver m_cell
}// Leer datos BRIG
MapData leer gamemap::leer brigdata()
{
Devolver m _ brig
}