void Game_loadMenus(Game *g, const char *dirname) {
Util_pushd(dirname);
Parser the_parser;
if(!Parser_init(&the_parser, "menus.txt"))
exit(EXIT_FAILURE); /* Le message d'erreur a été affiché. */
PARSER_BEGIN(&the_parser)
PARSER_EXPECT_TEXTURE(&the_parser, "texture")
PARSER_EXPECT_SPRITE(&the_parser, "sky", &g->main_menu.sky)
PARSER_EXPECT_SPRITE(&the_parser, "bg0", g->main_menu.bg)
PARSER_EXPECT_SPRITE(&the_parser, "bg1", g->main_menu.bg+1)
PARSER_EXPECT_SPRITE(&the_parser, "bg2", g->main_menu.bg+2)
PARSER_EXPECT_SPRITE(&the_parser, "bg3", g->main_menu.bg+3)
PARSER_EXPECT_SPRITE(&the_parser, "title", &g->main_menu.title)
PARSER_EXPECT_SPRITE(&the_parser, "oneplayer", &g->main_menu.oneplayer)
PARSER_EXPECT_SPRITE(&the_parser, "twoplayers", &g->main_menu.twoplayers)
PARSER_EXPECT_SPRITE(&the_parser, "ship_menu_title0", g->ship_menu.titles)
PARSER_EXPECT_SPRITE(&the_parser, "ship_menu_title1", g->ship_menu.titles+1)
PARSER_EXPECT_SPRITE(&the_parser, "ship_cell", &g->ship_menu.ship_cell)
PARSER_EXPECT_SPRITE(&the_parser, "map_left_arrow", &g->map_menu.left_arrow)
PARSER_EXPECT_SPRITE(&the_parser, "clap_top", &g->clap_transition.top)
PARSER_EXPECT_SPRITE(&the_parser, "clap_bottom", &g->clap_transition.bottom)
PARSER_END(&the_parser)
Parser_deinit(&the_parser);
Util_popd();
}
static void loadMapData(MapData *m, const char *filename) {
Parser the_parser;
if(!Parser_init(&the_parser, filename))
exit(EXIT_FAILURE); /* Le message d'erreur a été affiché. */
Wall * current_wall = NULL;
PARSER_BEGIN(&the_parser)
PARSER_EXPECT_STRING(&the_parser, "name", m->name, MAP_NAME_LEN)
PARSER_EXPECT_VEC2(&the_parser, "size", &m->size)
PARSER_EXPECT_TEXTURE(&the_parser, "texture")
PARSER_EXPECT_SPRITE(&the_parser, "artwork", &m->artwork)
PARSER_EXPECT_SPRITE(&the_parser, "banner", &m->banner)
PARSER_EXPECT_TILEDQUAD(&the_parser, "terrain_tile", &m->terrain, &m->size)
PARSER_EXPECT_COLOR3(&the_parser, "color", &m->color)
PARSER_EXPECT_FLOAT(&the_parser, "friction", &m->friction)
PARSER_EXPECT_COLOR3(&the_parser, "checkpoint_color", &m->checkpoint_color)
PARSER_EXPECT_COLOR3(&the_parser, "checkpoint_highlight", &m->checkpoint_highlight)
PARSER_EXPECT_MAPSTARTS(&the_parser, "start", m->start)
PARSER_EXPECT_CHECKPOINTS(&the_parser, "checkpoint", m)
PARSER_EXPECT_OBSTACLE(&the_parser, "obstacle")
PARSER_EXPECT_WALL(&the_parser, "wall", m)
PARSER_EXPECT_MUSIC(&the_parser, "music", m)
PARSER_END(&the_parser)
Parser_deinit(&the_parser);
if(current_wall) ConvexShape_free_content(&(current_wall->physic_obstacle.shape));
free(current_wall);
}
static void loadShipData(ShipData *s, const char *filename) {
float width;
Parser the_parser;
if(!Parser_init(&the_parser, filename))
exit(EXIT_FAILURE); /* Le message d'erreur a été affiché. */
PARSER_BEGIN(&the_parser)
PARSER_EXPECT_FLOAT(&the_parser, "friction", &s->friction)
PARSER_EXPECT_FLOAT(&the_parser, "tilt_step", &s->tilt_step)
PARSER_EXPECT_FLOAT(&the_parser, "accel_multiplier", &s->accel_multiplier)
PARSER_EXPECT_FLOAT(&the_parser, "max_speed", &s->max_speed)
PARSER_EXPECT_FLOAT(&the_parser, "width", &width)
PARSER_EXPECT_TEXTURE(&the_parser, "texture")
PARSER_EXPECT_PALETTE(&the_parser, "palette")
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "banner", s->banner)
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "side", s->side)
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "icon", s->icon)
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "artwork", s->artwork)
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above0", s->above[0])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above1", s->above[1])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above2", s->above[2])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above3", s->above[3])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above4", s->above[4])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above5", s->above[5])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above6", s->above[6])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above7", s->above[7])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above8", s->above[8])
PARSER_EXPECT_PALETTED_SPRITES(&the_parser, "above9", s->above[9])
PARSER_EXPECT_VEC2(&the_parser, "reactor_position", &(s->reactor_position))
PARSER_END(&the_parser)
Parser_deinit(&the_parser);
size_t i, p;
for(i=0 ; i<10 ; ++i)
for(p=0 ; p<MAX_PALETTES ; ++p)
Sprite_resizeToWidth(&s->above[i][p], width);
s->reactor_distance_to_center = sqrt(Scal2(s->reactor_position,
s->reactor_position));
}
int processXMsg( int streamId, char *readmsg,
RuleEngineEventParam *param, Node *node,
Env *env, ruleExecInfo_t *rei ) {
char myhdr[HEADER_TYPE_LEN];
char mymsg[MAX_NAME_LEN];
char *outStr = NULL;
int i, n;
int iLevel, wCnt;
int ruleInx = 0;
Region *r;
Res *res;
rError_t errmsg;
errmsg.len = 0;
errmsg.errMsg = NULL;
r = make_region( 0, NULL );
ParserContext *context = newParserContext( &errmsg, r );
Pointer *e = newPointer2( readmsg );
int rulegen = 1;
int found;
int grdf[2];
int cmd = 0;
int smallW;
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName );
memset( mymsg, 0, sizeof( mymsg ) );
PARSER_BEGIN( DbgCmd )
TRY( DbgCmd )
TTEXT2( "n", "next" );
cmd = REDEBUG_STEP_OVER;
OR( DbgCmd )
TTEXT2( "s", "step" );
cmd = REDEBUG_NEXT;
OR( DbgCmd )
TTEXT2( "f", "finish" );
cmd = REDEBUG_STEP_OUT;
OR( DbgCmd )
TTEXT2( "b", "break" );
TRY( Param )
TTYPE( TK_TEXT );
int breakPointsInx2;
for ( breakPointsInx2 = 0; breakPointsInx2 < 100; breakPointsInx2++ ) {
if ( breakPoints[breakPointsInx2].actionName == NULL ) {
break;
}
}
if ( breakPointsInx2 == 100 ) {
_writeXMsg( streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n" );
cmd = REDEBUG_WAIT;
}
else {
breakPoints[breakPointsInx2].actionName = strdup( token->text );
char * base_ptr = NULL;
TRY( loc )
TTYPE( TK_TEXT );
base_ptr = ( char * ) malloc( sizeof( token->text ) + 2 );
base_ptr[0] = 'f';
strcpy( base_ptr + 1, token->text );
TTEXT( ":" );
TTYPE( TK_INT );
breakPoints[breakPointsInx2].base = strdup( base_ptr );
breakPoints[breakPointsInx2].line = atoi( token->text );
rodsLong_t range[2];
char rulesFileName[MAX_NAME_LEN];
getRuleBasePath( base_ptr, rulesFileName );
FILE *file;
/* char errbuf[ERR_MSG_LEN]; */
file = fopen( rulesFileName, "r" );
if ( file == NULL ) {
free( context );
deletePointer( e );
free( base_ptr );
return RULES_FILE_READ_ERROR;
}
Pointer *p = newPointer( file, base_ptr );
if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
breakPoints[breakPointsInx2].start = range[0];
breakPoints[breakPointsInx2].finish = range[1];
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
deletePointer( p );
OR( loc )
TTYPE( TK_INT );
if ( node != NULL ) {
breakPoints[breakPointsInx2].base = strdup( node->base );
breakPoints[breakPointsInx2].line = atoi( token->text );
rodsLong_t range[2];
Pointer *p = newPointer2( breakPoints[breakPointsInx2].base );
if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) {
breakPoints[breakPointsInx2].start = range[0];
breakPoints[breakPointsInx2].finish = range[1];
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
deletePointer( p );
}
else {
breakPoints[breakPointsInx2].actionName = NULL;
}
OR( loc )
/* breakPoints[breakPointsInx].base = NULL; */
END_TRY( loc )
free( base_ptr );
if ( breakPoints[breakPointsInx2].actionName != NULL )
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2,
breakPoints[breakPointsInx2].actionName );
else {
snprintf( mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n" );
}
_writeXMsg( streamId, myhdr, mymsg );
if ( breakPointsInx <= breakPointsInx2 ) {
breakPointsInx = breakPointsInx2 + 1;
}
cmd = REDEBUG_WAIT;
}
OR( Param )
NEXT_TOKEN_BASIC;
_writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TRY( Where )
TTEXT2( "w", "where" );
smallW = 1;
OR( Where )
TTEXT2( "W", "Where" );
smallW = 0;
END_TRY( Where )
wCnt = 20;
OPTIONAL_BEGIN( Param )
TTYPE( TK_INT );
wCnt = atoi( token->text );
OPTIONAL_END( Param )
iLevel = 0;
i = reDebugStackCurrPtr - 1;
while ( i >= 0 && wCnt > 0 ) {
if ( !smallW || ( reDebugPCType( ( RuleEngineEvent ) reDebugStackCurr[i].label ) & 1 ) != 0 ) {
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i", iLevel );
char msg[HEADER_TYPE_LEN - 1];
RuleEngineEventParam param;
param.ruleIndex = 0;
param.actionName = reDebugStackCurr[i].step;
printRuleEngineEventLabel( msg, HEADER_TYPE_LEN - 1, ( RuleEngineEvent ) reDebugStackCurr[i].label, ¶m );
_writeXMsg( streamId, myhdr, msg );
if ( reDebugStackCurr[i].label != EXEC_ACTION_BEGIN ) {
iLevel++;
}
wCnt--;
}
i--;
}
OR( DbgCmd )
TTEXT2( "l", "list" );
TRY( Param )
TTEXT2( "r", "rule" );
TRY( ParamParam )
TTYPE( TK_TEXT );
mymsg[0] = '\n';
mymsg[1] = '\0';
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
RuleIndexListNode *node;
found = 0;
while ( findNextRule2( token->text, ruleInx, &node ) != NO_MORE_RULES_ERR ) {
found = 1;
if ( node->secondaryIndex ) {
n = node->condIndex->valIndex->len;
int i;
for ( i = 0; i < n; i++ ) {
Bucket *b = node->condIndex->valIndex->buckets[i];
while ( b != NULL ) {
RuleDesc *rd = getRuleDesc( *( int * )b->value );
char buf[MAX_RULE_LEN];
ruleToString( buf, MAX_RULE_LEN, rd );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
b = b->next;
}
}
}
else {
RuleDesc *rd = getRuleDesc( node->ruleIndex );
char buf[MAX_RULE_LEN];
ruleToString( buf, MAX_RULE_LEN, rd );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "\n %i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf );
}
ruleInx ++;
}
if ( !found ) {
snprintf( mymsg, MAX_NAME_LEN, "Rule %s not found\n", token->text );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( ParamParam )
_writeXMsg( streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( ParamParam )
OR( Param )
TTEXT2( "b", "breakpoints" );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
mymsg[0] = '\n';
mymsg[1] = '\0';
for ( i = 0; i < breakPointsInx; i++ ) {
if ( breakPoints[i].actionName != NULL ) {
if ( breakPoints[i].base != NULL ) {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s %s:%d\n", i , breakPoints[i].actionName, breakPoints[i].base[0] == 's' ? "<source>" : breakPoints[i].base + 1, breakPoints[i].line );
}
else {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName );
}
}
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
TTEXT( "*" );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
Env *cenv = env;
mymsg[0] = '\n';
mymsg[1] = '\0';
found = 0;
while ( cenv != NULL ) {
n = cenv->current->size;
for ( i = 0; i < n; i++ ) {
Bucket *b = cenv->current->buckets[i];
while ( b != NULL ) {
if ( b->key[0] == '*' ) { /* skip none * variables */
found = 1;
char typeString[128];
typeToString( ( ( Res * )b->value )->exprType, NULL, typeString, 128 );
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%s of type %s\n", b->key, typeString );
}
b = b->next;
}
}
cenv = cenv->previous;
}
if ( !found ) {
snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "<empty>\n" );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
syncTokenQueue( e, context );
skipWhitespace( e );
ABORT( lookAhead( e, 0 ) != '$' );
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text );
mymsg[0] = '\n';
mymsg[1] = '\0';
Hashtable *vars = newHashTable( 100 );
for ( i = 0; i < coreRuleVarDef .MaxNumOfDVars; i++ ) {
if ( lookupFromHashTable( vars, coreRuleVarDef.varName[i] ) == NULL ) {
snprintf( &mymsg[strlen( mymsg )], MAX_NAME_LEN - strlen( mymsg ), "$%s\n", coreRuleVarDef.varName[i] );
insertIntoHashTable( vars, coreRuleVarDef.varName[i], coreRuleVarDef.varName[i] );
}
}
deleteHashTable( vars, NULL );
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
NEXT_TOKEN_BASIC;
_writeXMsg( streamId, myhdr, "Unknown parameter type.\n" );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TTEXT2( "c", "continue" );
cmd = REDEBUG_STEP_CONTINUE;
OR( DbgCmd )
TTEXT2( "C", "Continue" );
cmd = REDEBUG_CONTINUE_VERBOSE;
OR( DbgCmd )
TTEXT2( "del", "delete" );
TRY( Param )
TTYPE( TK_INT );
n = atoi( token->text );
if ( breakPoints[n].actionName != NULL ) {
free( breakPoints[n].actionName );
if ( breakPoints[n].base != NULL ) {
free( breakPoints[n].base );
}
breakPoints[n].actionName = NULL;
breakPoints[n].base = NULL;
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n );
}
else {
snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n );
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( Param )
_writeXMsg( streamId, myhdr, "Debugger command \'delete\' requires one argument.\n" );
cmd = REDEBUG_WAIT;
END_TRY( Param )
OR( DbgCmd )
TTEXT2( "p", "print" );
Node *n = parseTermRuleGen( e, 1, context );
if ( getNodeType( n ) == N_ERROR ) {
errMsgToString( context->errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
}
else {
snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing " );
char * ptr = myhdr + strlen( myhdr );
i = HEADER_TYPE_LEN - 1 - strlen( myhdr );
termToString( &ptr, &i, 0, MIN_PREC, n, 0 );
snprintf( ptr, i, "\n" );
if ( env != NULL ) {
disableReDebugger( grdf );
res = computeNode( n, NULL, regionRegionCpEnv( env, r, ( RegionRegionCopyFuncType * ) regionRegionCpNode ), rei, 0, &errmsg, r );
enableReDebugger( grdf );
outStr = convertResToString( res );
snprintf( mymsg, MAX_NAME_LEN, "%s\n", outStr );
free( outStr );
if ( getNodeType( res ) == N_ERROR ) {
errMsgToString( &errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) );
}
}
else {
snprintf( mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n" );
}
}
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
OR( DbgCmd )
TTEXT2( "d", "discontinue" );
cmd = REDEBUG_WAIT;
OR( DbgCmd )
snprintf( mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg );
_writeXMsg( streamId, myhdr, mymsg );
cmd = REDEBUG_WAIT;
END_TRY( DbgCmd )
PARSER_END( DbgCmd )
freeRErrorContent( &errmsg );
region_free( r );
deletePointer( e );
free( context );
return cmd;
}
