static void writeLevHGP( void ) {
MSGGROUP *grp;
int index;
fputs( "\n\n", o_levh );
fputs( "#define MSGTYPES_DEFS \\\n", o_levh );
for( index = 0; index < MSG_TYPE_END; ++index ) {
fputs( "MSGTYPES_DEF( ", o_levh );
fputs( msgTypeNamesGP[ index ], o_levh );
fputs( " )\\\n", o_levh );
}
fputs( "\n\n", o_levh );
fputs( "//define GRP_DEF( name,prefix,num,index,eindex )\n", o_levh );
fputs( "#define GRP_DEFS \\\n", o_levh );
for( grp = allGroups; grp != NULL; grp = grp->next ) {
fputs( "GRP_DEF( ", o_levh );
fputs( grp->name, o_levh );
fputc( ',', o_levh );
fputs( grp->prefix, o_levh );
fputc( ',', o_levh );
outputNum( o_levh, grp->num );
fputc( ',', o_levh );
outputNum( o_levh, grp->msgIndex );
fputc( ',', o_levh );
outputNum( o_levh, grp->emsgIndex );
fputs( " )\\\n", o_levh );
}
fputs( "\n\n", o_levh );
}
static void writeMsgHGP( void ) {
MSGSYM *m;
MSGGROUP *grp;
int index;
fputs( "//MSG_DEF( name, group, kind, level, group_index )\n",o_msgh );
fputs( "\n\n", o_msgh );
fputs( "#define MSG_DEFS \\\n", o_msgh );
index = 0;
for( m = messageSyms; m != NULL; m = m->next,++index ) {
fputs( "MSG_DEF( ", o_msgh );
fputs( m->name, o_msgh );
fputs( " , ", o_msgh );
grp = m->grp;
if( grp != NULL ){
fputs( grp->name, o_msgh );
fputs( " , ", o_msgh );
}
fputs( msgTypeNamesGP[ m->mtype ], o_msgh );
fputs( " , ", o_msgh );
outputNum( o_msgh, m->level );
fputs( " , ", o_msgh );
outputNum( o_msgh, m->grpIndex );
fputs( " )\\\n", o_msgh );
}
fputs( "\n\n", o_msgh );
}
static void writeMsgH( void ) {
MSGSYM *m;
fputs( "#pragma read_only_file;\n", o_msgh );
if( ! flags.gen_pick ) {
for( m = messageSyms; m != NULL; m = m->next ) {
fputs( "#define ", o_msgh );
fputs( m->name, o_msgh );
fputc( ' ', o_msgh );
outputNum( o_msgh, m->index );
fputc( '\n', o_msgh );
}
} else {
fputs( "#define MSG_DEFS \\\n", o_msgh );
for( m = messageSyms; m != NULL; m = m->next ) {
fputs( "MSG_DEF( ", o_msgh );
fputs( m->name, o_msgh );
fputs( " , ", o_msgh );
outputNum( o_msgh, m->index );
fputs( " )\\\n", o_msgh );
}
fputs( "\n\n", o_msgh );
}
writeExtraDefs( o_msgh );
}
static void writeLevH( void ) {
MSGSYM *m;
fputs( "#pragma read_only_file;\n", o_levh );
fputs( "#ifndef MSG_CONST\n", o_levh );
fputs( "#define MSG_CONST const\n", o_levh );
fputs( "#endif\n", o_levh );
fprintf( o_levh, "typedef enum {\n" );
#define def_msg_type( e,p ) fprintf( o_levh, " MSG_TYPE_" #e ",\n" );
ALL_MSG_TYPES
#undef def_msg_type
fprintf( o_levh, "} MSG_TYPE;\n" );
outputTableName( o_levh, "unsigned char MSG_CONST", "msg_level" );
for( m = messageSyms; m != NULL; m = m->next ) {
fputc( '(', o_levh );
fputc( ' ', o_levh );
fputs( msgTypeNames[ m->mtype ], o_levh );
if( m->level == 0 ) {
fputs( " << 4 ), /* ", o_levh );
} else {
fputs( " << 4 ) | ", o_levh );
outputNum( o_levh, m->level );
fputs( ", /* ", o_levh );
}
fputs( m->name, o_levh );
fputs( " */\n", o_levh );
}
totalBytes += messageIndex;
fputs( "};\n", o_levh );
}
static void writeExtraDefs( FILE *fp ) {
fputc( '\n', fp );
fputs(
"#define ENC_BIT 0x80\n"
"#define LARGE_BIT 0x40\n"
"#define MAX_MSG ", fp );
outputNum( fp, maxMsgLen );
fputc( '\n', fp );
fputc( '\n', fp );
}
void Display()
{
glClear(GL_COLOR_BUFFER_BIT);
double l = (pos.x-(_screenw/2)/scale);
double r = (pos.x+(_screenw/2)/scale);
double b = (pos.y-(_screenh/2)/scale);
double t = (pos.y+(_screenh/2)/scale);
setWindow(l,r,b,t);
world->drawBodies();
double BP = world->GetProfile("bp");
double NP = world->GetProfile("np");
double SLV = world->GetProfile("slv");
double MV = world->GetProfile("mv");
glColor3f(1,1,1);
outputNum(fps, 10, _screenh-20, true);
outputString("bp:", 10, _screenh-40, true);
outputNum(((int)(BP*1000000000))/1000000.0, 50, _screenh-40, true);
outputString("np:", 10, _screenh-60, true);
outputNum(((int)(NP*1000000000))/1000000.0, 50, _screenh-60, true);
outputString("slv:", 10, _screenh-80, true);
outputNum(((int)(SLV*1000000000))/1000000.0, 50, _screenh-80, true);
outputString("mv:", 10, _screenh-100, true);
outputNum(((int)(MV*1000000000))/1000000.0, 50, _screenh-100, true);
outputString("best:", 10, _screenh-120, true);
outputNum(world->best(), 100, _screenh-120, true);
glFlush();
glutSwapBuffers();
glutPostRedisplay();
}
static void writeWordTable( void ) {
WORD *w;
unsigned i;
auto data_word_tables data_w;
data_w.current_base = 0;
data_w.word_base = malloc( ( multiRefWords + 1 ) * sizeof( unsigned ) );
data_w.keep_base = malloc( ( multiRefWords + 1 ) * sizeof( WORD * ) );
data_w.current_text = 0;
outputTableName( o_msgc, "char const", "word_text" );
traverseHiToLoRefs( refWords, doEncodeWORD, &data_w );
fputs( "};\n", o_msgc );
totalBytes += data_w.current_text;
data_w.word_base[ data_w.current_base ] = data_w.current_text;
data_w.keep_base[ data_w.current_base ] = NULL;
data_w.current_base++;
totalBytes += data_w.current_base * sizeof( short );
outputTableName( o_msgc, "unsigned short const", "word_base" );
for( i = 0; i < data_w.current_base; ++i ) {
w = data_w.keep_base[ i ];
outputNumJ( o_msgc, data_w.word_base[ i ], 6 );
fputc( ',', o_msgc );
if( w != NULL ) {
fputs( " /* ", o_msgc );
outputNumJ( o_msgc, w->references, 6 );
fputc( ' ', o_msgc );
fputc( '(', o_msgc );
outputNum( o_msgc, i );
fputc( ')', o_msgc );
fputc( ' ', o_msgc );
fputs( w->name, o_msgc );
fputs( " */", o_msgc );
}
fputc( '\n', o_msgc );
}
fputs( "};\n", o_msgc );
free( data_w.word_base );
free( data_w.keep_base );
}
static void writeMsgTable( void ) {
MSGSYM *m;
unsigned *msg_base;
unsigned current_base;
unsigned current_text;
unsigned i;
WORDREF *r;
WORD *w;
char *p;
current_text = 0;
current_base = 0;
msg_base = malloc( ( messageCounter + 1 ) * sizeof( unsigned ) );
outputTableName( o_msgc, "uint_8 const", "msg_text" );
for( m = messageSyms; m != NULL; m = m->next ) {
msg_base[ current_base++ ] = current_text;
fputs( "\n/* ", o_msgc );
outputNumJ( o_msgc, m->index, 4 );
fputc( ' ', o_msgc );
fputs( m->lang_txt[LANG_English], o_msgc );
fputs( " */\n", o_msgc );
for( r = m->words; r != NULL; r = r->next ) {
w = r->word;
if( w->index == NO_INDEX ) {
outputNum( o_msgc, w->len );
fputs( ", ", o_msgc );
for( p = w->name; *p; ++p ) {
outputChar( o_msgc, *p );
}
fputc( '\n', o_msgc );
current_text += 1 + w->len;
} else {
if( w->index <= USE_SMALL_ENC ) {
fputs( "ENC_BIT | ", o_msgc );
outputNum( o_msgc, w->index );
++current_text;
} else {
fputs( "ENC_BIT | LARGE_BIT | ", o_msgc );
outputNum( o_msgc, ( w->index >> 8 ) );
fputs( ", ", o_msgc );
outputNum( o_msgc, ( w->index & 0x0ff ) );
current_text += 2;
}
fputs( ", /* ", o_msgc );
fputs( w->name, o_msgc );
fputs( " */\n", o_msgc );
}
}
}
fputs( "};\n", o_msgc );
totalBytes += current_text;
msg_base[ current_base++ ] = current_text;
totalBytes += current_base * sizeof( short );
outputTableName( o_msgc, "unsigned short const", "msg_base" );
for( i = 0; i < current_base; ++i ) {
outputNum( o_msgc, msg_base[ i ] );
fputc( ',', o_msgc );
fputc( '\n', o_msgc );
}
fputs( "};\n", o_msgc );
if( allGroups != NULL ) {
MSGGROUP *g;
outputTableName( o_msgc, "unsigned short const", "msg_group_base" );
for( g = allGroups; g != NULL; g = g->next ) {
outputNum( o_msgc, g->msgIndex );
fputc( ',', o_msgc );
fputc( '\n', o_msgc );
}
assert( messageIndex == 0 );
outputNum( o_msgc, messageCounter );
fputs( ",\n};\n", o_msgc );
fputs( "MSG_SCOPE char const MSG_MEM msg_group_name[][2] = {\n"
, o_msgc );
for( g = allGroups; g != NULL; g = g->next ) {
char buf[10];
buf[0] = '\'';
buf[1] = g->name[0];
buf[2] = '\'';
buf[3] = ',';
buf[4] = '\'';
buf[5] = g->name[1];
buf[6] = '\'';
buf[7] = ',';
buf[8] = '\n';
buf[9] = '\0';
fputs( buf, o_msgc );
}
fputs( "};\n", o_msgc );
fputs( "#define MSGS_GROUPED\n", o_msgc );
}
free( msg_base );
}
