What about...UDMF Editor?

[Sgt. Mark IV]

Eu só poderia ajudar com os testes, basicamente.

[Lord DooM1.666]

E eu adoraria participar. Adoraria mesmo. Mas não tenho base NENHUMA pra programador.

Ué vossa eminência não estava estudando C\C++?

[Fabio914]

E eu adoraria participar. Adoraria mesmo. Mas não tenho base NENHUMA pra programador.

Não é apenas isso que conta. Você pode ajudar com a interface do usuário, sugestões, entre outras coisas...

Mas mas mas mas a coisa fica tão mais organizada quando orientada à objetos D:

Em estruturada também. Basta usar os headers e separar o código em vários arquivos (pode-se fazer compilação em partes e depois linkar as outras partes para gerar o executavel final, assim como em muitas outras linguagens).


Off:

Tipos de dados base:

Código: Selecionar todos

/*

Descricao: Tipos de dados para UDMF. Aqui estao os tipos de dados basicos,
outros serao necessarios para montagem de estruturas de dados (TADs)
para organizacao dos dados.

OBS.:  Strings para texturas tem tamanho maximo de 50 posicoes (50*sizeof(char)).
OBS.2: Variaveis float tem dupla precisao (double).
OBS.3: Tipos baseados na especificacao UDMF 1.1.

*/

typedef enum{ false = 0, true = 1} boolean;

typedef struct {

   int id;			// ID of line. Interpreted as tag or scripting id.
                      		// Default = -1. *** see below.

   /* vertice */
   int v1; 			// Index of first vertex. No valid default.
   int v2; 			// Index of second vertex. No valid default.

   /* flags (falso padrao) */
   boolean blocking; 		// true = line blocks things.
   boolean blockmonsters; 	// true = line blocks monsters.
   boolean twosided; 		// true = line is 2S.
   boolean dontpegtop; 		// true = upper texture unpegged.
   boolean dontpegbottom; 	// true = lower texture unpegged.
   boolean secret; 		// true = drawn as 1S on map.
   boolean blocksound; 		// true = blocks sound.
   boolean dontdraw; 		// true = line never drawn on map.
   boolean mapped; 		// true = always appears on map.

   /* flag BOOM (nao suportado em Strife/Heretic/Hexen) */
   boolean passuse; 		// true = passes use action.

   /* flags do Strife */
   boolean translucent; 	// true = line is a Strife translucent line.
   boolean jumpover; 		// true = line is a Strife railing.
   boolean blockfloaters; 	// true = line is a Strife float-blocker.

   /* SPAC flags */
   boolean playercross; 	// true = player can cross.
   boolean playeruse; 		// true = player can use.
   boolean monstercross; 	// true = monster can cross.
   boolean monsteruse; 		// true = monster can use.
   boolean impact; 		// true = projectile can activate.
   boolean playerpush; 		// true = player can push.
   boolean monsterpush; 	// true = monster can push.
   boolean missilecross; 	// true = projectile can cross.
   boolean repeatspecial; 	// true = repeatable special.

   /* acao da linha */
   int special; 		// Special. Default = 0.
   int arg0; 			// Argument 0. Default = 0.
   int arg1; 			// Argument 1. Default = 0.
   int arg2; 			// Argument 2. Default = 0.
   int arg3; 			// Argument 3. Default = 0.
   int arg4; 			// Argument 4. Default = 0.

   int sidefront; 		// Sidedef 1 index. No valid default.
   int sideback; 		// Sidedef 2 index. Default = -1.

   char *comment; 		// A comment. Implementors should attach no special
                          	// semantic meaning to this field.
   /* OBS.: Aloca o comentario apenas se usar */

} linedef;

typedef struct {

   int offsetx; 		// X Offset. Default = 0.
   int offsety; 		// Y Offset. Default = 0.
      
   char texturetop[50]; 	// Upper texture. Default = "-".
   char texturebottom[50]; 	// Lower texture. Default = "-".
   char texturemiddle[50]; 	// Middle texture. Default = "-".
      
   int sector; 			// Sector index. No valid default.

   char *comment; 		// A comment. Implementors should attach no special
                         	// semantic meaning to this field.
   /* OBS.: Aloca o comentario apenas se usar */

} sidedef;

typedef struct {
   
   double x;			// X coordinate. No valid default.
   double y;			// Y coordinate. No valid default.

} vertex;

typedef struct {

   int heightfloor; 		// Floor height. Default = 0.
   int heightceiling; 		// Ceiling height. Default = 0.
      
   char texturefloor[50]; 	// Floor flat. No valid default.
   char textureceiling[50];	// Ceiling flat. No valid default.
      
   int lightlevel; 		// Light level. Default = 160.
      
   int special; 		// Sector special. Default = 0.
   int id; 			// Sector tag/id. Default = 0.

   char *comment; 		// A comment. Implementors should attach no special
                          	// semantic meaning to this field.
   /* OBS.: Aloca o comentario apenas se usar */

} sector;

typedef struct {
      
   int id; 			// Thing ID. Default = 0.
      
   double x; 			// X coordinate. No valid default.
   double y; 			// Y coordinate. No valid default.
      
   double height; 		// Z height relative to floor. Default = 0.
                        	// (Relative to ceiling for SPAWNCEILING items).
                          
   int angle; 			// Map angle of thing in degrees. Default = 0 (East).
      
   int type; 			// DoomedNum. No valid default.
      
   /* flags (falso padrao) */
      
   boolean skill1; 		// true = in skill 1.
   boolean skill2; 		// true = in skill 2.
   boolean skill3; 		// true = in skill 3.
   boolean skill4; 		// true = in skill 4.
   boolean skill5; 		// true = in skill 5.
   boolean ambush; 		// true = thing is deaf.
   boolean single; 		// true = in SP mode.
   boolean dm; 			// true = in DM mode.
   boolean coop; 		// true = in Coop.
      
   boolean friend; 		// true = MBF friend (nao suportado em Strife/Heretic/Hexen)
      
   /* Hexen flags (nao suportada em Doom/Strife/Heretic) */
      
   boolean dormant; 		// true = dormant thing.
   boolean class1; 		// true = Present for pclass 1.
   boolean class2; 		// true = Present for pclass 2.
   boolean class3; 		// true = Present for pclass 3.
      
   /* flags do Strife */
   boolean standing; 		// true = Strife NPC flag.
   boolean strifeally; 		// true = Strife ally flag.
   boolean translucent; 	// true = Strife translucency flag.
   boolean invisible; 		// true = Strife invisibility flag.
            
      
   /* acoes do objeto */
   int special; 		// Scripting special. Default = 0;
   int arg0; 			// Argument 0. Default = 0.
   int arg1; 			// Argument 1. Default = 0.
   int arg2; 			// Argument 2. Default = 0.
   int arg3; 			// Argument 3. Default = 0.
   int arg4; 			// Argument 4. Default = 0.

   char *comment; 		// A comment. Implementors should attach no special
                          	// semantic meaning to this field.
   /* OBS.: Aloca o comentario apenas se usar */

} thing;

[Logan MTM]

Tem muita coisa faltando ai.

Eu sugeri ao Graf que pense na possibilidade de otimizar o TEXTMAP. Um MegaWad simples de 32 MBs pode chegar a absurdos 960 MBs só de Mapas!!!
Não clevando em conta nenhum tipo de compactação (.zip, .pk3, .pk7).

[Drak[X]]

Em estruturada também. Basta usar os headers e separar o código em vários arquivos (pode-se fazer compilação em partes e depois linkar as outras partes para gerar o executavel final, assim como em muitas outras linguagens).

Ahhh.... o bom e velho Makefile !!!!

Como eu gosto desse arquivo.... simples e eficiente!

Tem muita coisa faltando ai.

Eu sugeri ao Graf que pense na possibilidade de otimizar o TEXTMAP. Um MegaWad simples de 32 MBs pode chegar a absurdos 960 MBs só de Mapas!!!
Não clevando em conta nenhum tipo de compactação (.zip, .pk3, .pk7).

Hehehehehehe...... o Logan não acreditava em mim!!!!!
Viu Logan, a minha continha básica estava correta!!!!

32 mapas * 30 megas em cada mapa (só de TEXTMAP) = 960 megas!!!

É ou não é um absurdo, 960 megas só de arquivos de textos!!!!

[Logan MTM]

Sim, mas isso é em formato .wad. O Graf disse que como o UDMF é exclusivo do ZDoom familly, presume-se que será compactado em formatos exclusivos do mesmo.

Continuará maior do que no modo binary, mas já é uma melhoria significativa levando em conta as vantagens do formato UDMF.

[Drak[X]]

Sim, mas isso é em formato .wad. O Graf disse que como o UDMF é exclusivo do ZDoom familly, presume-se que será compactado em formatos exclusivos do mesmo.

Continuará maior do que no modo binary, mas já é uma melhoria significativa levando em conta as vantagens do formato UDMF.

Tomara que eles tratem de melhorar a compactação desse bagulho logo!!!!
Quero usar isso pra criar mapas, mas não quero ter mapas enormes.... por enquanto vou apenas fazer testes aqui.. e aprender a usar o "produto".

[xducke]

Soh comprar HDs grandes

[Drak[X]]

Soh comprar HDs grandes

Se continuar desse jeito.. somente se for HD de 1 Tera pra cima!

Doom com 32 mapas New School com 4.5 gigas!!!! eebbaaaaaaaaaaaaaaaaaaa!!!!

[Fabio914]

Realmente, não é nada otimizado se escrever todo um texto para representar cada setor, linha e vértice... Por exemplo, cada caractere tem tamanho de 1 byte, para representarmos o numero 1000000 gastamos 7 bytes, o que, se armazenado em memória (formato inteiro), gastariamos 4 bytes [isto sem levar em conta o texto que indica a que se refere este 1000000]. Mas isso não impede que tenhamos uma boa compactação, como a tabela ASCII tem 256 posições (ou seja, limitada) , uma compactação eficiente seria indicar quantas vezes aparece determinado caractere (assim teríamos 256 valores armazenados) e a posição XY que ele aparece no texto a cada vez (mais alguns números por caractere). Algo mais eficiente ainda (algo semelhante ao feito por compactadores como ZIP e RAR) é pegar palavras (ou até frases inteiras) com muita incidência no texto (no nosso caso, todas as palavras da descrição dos linedefs, sidedefs, sectors, things e vertex) e marcar quantas vezes estas se repetem (muitas vezes!) e armazenar a posição desta no texto. Assim não precisamos armazenar a mesma informação repetidas vezes, poupando memória...

Um exemplo:

O texto:

Código: Selecionar todos

vertex { // ID = 1
   x=100.00;
   y=200.00;
}
vertex { // ID = 2
   x=120.10;
   y=210.20;
}

Pode ser armazenado como (obs.: palavra seguida da incidência) :

Código: Selecionar todos

vertex 2 ID = 2 1 5 2 5 x= 2 y= 2 { 2 } 2 0. 4 0; 4 // 2

(mais a informação da posição de cada um)

Assim da pra se ter uma boa compactação de texto...