/*
;***********************************************************************
; Name: displayMenu
; Description: Displays Menu for user and their current selection.
; There are 3 menu selections that need to be drawn.
;
;***********************************************************************/
void displayMenu(char selection)
{
//int r,l;
//unsigned char **menu_image = NULL;
// pick image to draw
switch(selection)
{
case 1:
writeBackground(image_menu_select1);
break;
case 2:
writeBackground(image_menu_select2);
break;
case 3:
writeBackground(image_menu_select3);
break;
default:
break;
}
}
/***********************************************************************
; Name: startMatch
; Description: This function is the main game loop. All player movement
; and scorekeeping has to be performed inside this loop.
;***********************************************************************/
void startMatch(void)
{
char quit = 0;
writeBackground(selected_field);
display_character(&player0);
display_character(&player1);
while (!quit)
{
if (hCnt > HSYNCHIGH || hCnt < HSYNCLOW)
{
// update horizontal and vertical velocity for player 0
updateVelAcc(&player0,joy0hor,joy0ver);
updateVelAcc(&player1,joy1hor,joy1ver);
// check for jumping.
checkPlayerJump(&player0);
checkPlayerJump(&player1);
// TEMPORARY EXIT CONDITION
//if (player0.attacking == 2) // pushbutton 2 pressed
//{
// quit = 1;
//}
// attack for player
player0.attack(&player0);
player1.attack(&player1);
// move player (it can be any function)
player0.move(&player0);
player1.move(&player1);
// display the character at his location
//display_character(&player0);
displayLives();
displayDamage();
quit = quit || checkDeath(&player0);
quit = quit || checkDeath(&player1);
}
}
// reset player lives and other values
player0.lives = 5;
player1.lives = 5;
player0.damage = 0;
player1.damage = 0;
}
/*
;***********************************************************************
; Name: displaySplash
; Description: Displays Splash screen for the game and gives the user
; time to see it.
;***********************************************************************/
void displaySplash(void)
{
//int r,l;
// copy the splash screen to the screen
// note that the screen now needs to be
// output to the monitor using the non-maskable
// interrupt service routine (IRQ)
/*
for (r = 0; r < SCREENH; r++)
{
for (l = 0; l < SCREENW/2; l++)
{
screen[r*(SCREENW/2) + l] = image_splash[r][l];
}
}
*/
writeBackground(image_splash);
while (splash_screen_enable < TIMEFORONESECOND);
}
/* ========================================================================= */
static int writeHMM(xmlTextWriterPtr writer, ghmm_xmlfile* f, int number) {
#define CUR_PROC "writeHMM"
int rc=0, i, N;
int w_cos;
double w_prior;
char *w_name;
char * w_type;
/* start HMM */
if (0 > xmlTextWriterStartElement(writer, BAD_CAST "HMM")) {
GHMM_LOG(LERROR, "Error at xmlTextWriterStartElement (HMM)");
goto STOP;;
}
/* write HMM attributes applicable */
switch (f->modelType & PTR_TYPE_MASK) {
case GHMM_kDiscreteHMM:
w_name = f->model.d[number]->name;
w_type = strModeltype(f->model.d[number]->model_type);
w_prior = f->model.d[number]->prior;
N = f->model.d[number]->N;
w_cos = 1;
break;
case (GHMM_kDiscreteHMM+GHMM_kTransitionClasses):
w_name = f->model.ds[number]->name;
w_type = strModeltype(f->model.ds[number]->model_type);
w_prior = f->model.ds[number]->prior;
N = f->model.ds[number]->N;
w_cos = 0;
break;
case (GHMM_kDiscreteHMM+GHMM_kPairHMM):
case (GHMM_kDiscreteHMM+GHMM_kPairHMM+GHMM_kTransitionClasses):
/*
w_name = f->model.dp[number]->name;
w_type = strModeltype(f->model.dp[number]->model_type);
w_prior = f->model.dp[number]->prior;
N = f->model.dp[number]->N;
w_cos = 0;
*/
break;
case GHMM_kContinuousHMM:
case (GHMM_kContinuousHMM+GHMM_kMultivariate):
case (GHMM_kContinuousHMM+GHMM_kTransitionClasses):
case (GHMM_kContinuousHMM+GHMM_kMultivariate+GHMM_kTransitionClasses):
w_name = f->model.c[number]->name;
if (f->model.c[number]->model_type)
w_type = strModeltype(f->model.c[number]->model_type);
else
w_type = strModeltype(f->modelType);
w_prior = f->model.c[number]->prior;
N = f->model.c[number]->N;
w_cos = f->model.c[number]->cos;
break;
default:
GHMM_LOG(LERROR, "invalid modelType");
goto STOP;}
if (w_name) {
if (xmlTextWriterWriteAttribute(writer, BAD_CAST "name", w_name))
GHMM_LOG(LERROR, "writing HMM name failed");
}
if (xmlTextWriterWriteAttribute(writer, BAD_CAST "type", BAD_CAST w_type))
GHMM_LOG(LERROR, "writing HMM type failed");
if (w_prior >= 0.0) {
WRITE_DOUBLE_ATTRIBUTE(writer, "prior", w_prior);
}
if (w_cos > 1)
if (0 > xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "transitionClasses",
"%d", w_cos))
GHMM_LOG(LERROR, "failed to write no of transitionClasses");
/* write alphabet if applicable */
switch (f->modelType & (GHMM_kDiscreteHMM + GHMM_kTransitionClasses
+ GHMM_kPairHMM)) {
case GHMM_kDiscreteHMM:
rc = writeAlphabet(writer, f->model.d[number]->alphabet, kAlphabet);
break;
case (GHMM_kDiscreteHMM+GHMM_kTransitionClasses):
/*rc = writeAlphabet(writer, f->model.ds[number]->alphabet, kAlphabet);*/
break;
case (GHMM_kDiscreteHMM+GHMM_kPairHMM):
case (GHMM_kDiscreteHMM+GHMM_kPairHMM+GHMM_kTransitionClasses):
/*rc = writeAlphabet(writer, f->model.dp[number]->alphabets[0], kAlphabet);
if (rc) {
GHMM_LOG(LERROR, "writing first alphabet of discrete pair HMM failed");
goto STOP;
}
rc = writeAlphabet(writer, f->model.dp[number]->alphabets[1], kAlphabet);*/
break;
}
if (rc) {
GHMM_LOG_PRINTF(LERROR, LOC, "writing alphabet for HMM %d (type %s) failed",
number, strModeltype(f->modelType));
goto STOP;
}
/* write label alphabet if applicable */
if ((f->modelType & PTR_TYPE_MASK) == GHMM_kDiscreteHMM
&& f->modelType & GHMM_kLabeledStates) {
if (writeAlphabet(writer, f->model.d[number]->label_alphabet, kLabelAlphabet))
GHMM_LOG(LERROR, "writing of label alphabet failed");
}
/* write background distributions if applicable */
if ((f->modelType & PTR_TYPE_MASK) == GHMM_kDiscreteHMM
&& f->modelType & GHMM_kBackgroundDistributions) {
if (writeBackground(writer, f->model.d[number]->bp))
GHMM_LOG(LERROR, "writing of background distributions failed");
}
/* write all states */
for (i=0; i<N; i++)
if (writeState(writer, f, number, i)) {
GHMM_LOG_PRINTF(LERROR, LOC, "writing of state %d in HMM %d failed", i, number);
goto STOP;
}
/* write all outgoing transitions */
for (i=0; i<N; i++)
if (writeTransition(writer, f, number, i)) {
GHMM_LOG_PRINTF(LERROR, LOC, "writing transitions of state %d in HMM %d failed",
i, number);
goto STOP;
}
/*end HMM*/
if (0 > xmlTextWriterEndElement(writer)) {
GHMM_LOG(LERROR, "Error at xmlTextWriterEndElement (HMM)");
goto STOP;
}
return 0;
STOP:
return -1;
#undef CUR_PROC
}
void selectCharacter(void)
{
writeBackground(image_character_select);
}
