Red de conocimiento informático - Conocimiento de la instalación - ¿Cuál es el formato de Fantasy Westward Journey?

¿Cuál es el formato de Fantasy Westward Journey?

Código de implementación de clase de lectura de formato de archivo de mapa "Westward Journey II" y "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

}