void DrawReels( void ) { // int n; // for( n = 0; n < NUM_REELS; n++ ) // DrawReel( n ); UpdateDisplayPortion( g.render, REEL_OFSX, REEL_OFSY, REEL_STEPX*(g.nReels-1) + REEL_WIDTH, REEL_HEIGHT ); }
void flush( void ) { if( _wd && _ht ) { //Log4( WIDE("Flushing update to display... %d,%d - %d,%d"), _x, _y, _wd, _ht ); if( pDisplay ) UpdateDisplayPortion( pDisplay, _x, _y, _wd, _ht ); else SmudgeCommon( pControl ); } _wd = 0; _ht = 0; }
int CPROC MouseMethod( uintptr_t psv, int32_t x, int32_t y, uint32_t b ) { if( !g.flags.bSpinning ) { if( !b ) { g.ofs = -7; DrawReels(); } else if( b == 1 ) { if( g.ofs == -7 ) { int n; if( !g.flags.bBackgroundInitialized) { ClearImageTo( g.backgroundsurface, BASE_COLOR_BLACK ); BlotImage( g.backgroundsurface, g.background, 0, 0 ); g.flags.bBackgroundInitialized = 1; } for( n = 0; n < NUM_REELS; n++ ) { g.bReelSpinning[n] = 1; } g.flags.bSpinning = 1; if( 0 )//yucky. real cheesey. { int n, i; for( n = 0; n < g.nReels; n++ ) for( i = 0; i < NUM_PICS+2; i++ ) { g.reel[n][i] = g.images[rand()%10]; } } DrawSpinningReels(TRUE); } } } else { if( b ) { int reel = (x - REEL_OFSX) / REEL_STEPX; if( reel >= 0 && reel < NUM_REELS ) { if( g.bReelSpinning[reel] ) { g.bReelSpinning[reel] = 0; g.ofs = -32; // DrawReel(reel); UpdateDisplayPortion( g.render , REEL_OFSX , REEL_OFSY , REEL_STEPX*(reel) , REEL_WIDTH ); g.ofs = 7; // DrawReel(reel); UpdateDisplayPortion( g.render , REEL_OFSX , REEL_OFSY , REEL_STEPX*(reel) , REEL_WIDTH ); WakeableSleep( 100 ); g.ofs = 0; // DrawReel(reel); UpdateDisplayPortion( g.render , REEL_OFSX , REEL_OFSY , REEL_STEPX*(reel) , REEL_WIDTH ); { int n; for( n = 0; n < NUM_REELS; n++ ) if( g.bReelSpinning[n] ) break; if( n == NUM_REELS ) { g.flags.bSpinning = 0; SyncRender( g.render); // SetReelSpeedStep(); } } } } } } return 1; }
void DrawSpinningReels( LOGICAL init ) { //Real sorry about all the static variables. It does look silly, but //it is preferable to maintain the static-ly declared variables within this scope. //could move them to the global, but right now it suits the task. //Remember, this function is called 4 times a second, and it is only this function //that uses these variables, so oh well. Call a spade a spade....they're static to //keep persistent data. int n; static LOGICAL bInit[NUM_REELS]; //static to maintain state. static uint32_t effectcount = 0; //static to maintain state. static LOGICAL bPlaying = FALSE; //static to maintain state. static int iBobble[5] = {0,-54,32,0,0}; //no need to declare this over and over 4 times a second. static INDEX idxBobbleCount[NUM_REELS]; //static to maintain state. uint32_t uiSmartYOffset = ( ( NUM_PICS - NUM_PICS_IN_WINDOW ) / 2 ); static uint32_t bBobbling[NUM_REELS]; // xlprintf(LOG_NOISE)("DrawSpinningReels, init is %s g.flags.bSpinning is %d" // , (init?"TRUE":"FALSE") // , g.flags.bSpinning // ); for( n = 0; n < g.nReels; n++ ) { if( init ) { bInit[n] = TRUE; if( !bPlaying ) { SetReelSpeedStep(); bPlaying = TRUE; BlotScaledImageSizedTo( g.statussurface , g.playing , 0, 0 , 140, 68 ); } } if( g.bReelSpinning[n] ) { //uiStartStep is each reel's random starting order. if ( g.uiStartStep[n] ) { g.uiStartStep[n]--; } else { { //uiSpeedStep demonstrates speed of reel movement (FAST, medium, and ....slllowwww). And stop.stutter.stop. if( g.uiSpeedStep[n] == 0 ) { BlotImageSizedTo( g.subsurface[n] , g.dodges[rand()%NUM_BLURS] , 0, 0 , 0, 0, 96, (96 * NUM_PICS_IN_WINDOW) ); //effectcount is how long reels should be speedy-blurry, and normal-blurry. if( effectcount < (NUM_ITERATIONS / 2 ) ) effectcount++; else { effectcount = 0; g.uiSpeedStep[n]++; } } else if( g.uiSpeedStep[n] == 1 ) { BlotImageSizedTo( g.subsurface[n] , g.blurs[rand()%NUM_BLURS] , 0 ,0 , 0, 0, 96, (96 * NUM_PICS_IN_WINDOW) ); if( effectcount < (NUM_ITERATIONS / 2 ) ) effectcount++; else { effectcount = 0; g.uiSpeedStep[n]++; } } else if( g.uiSpeedStep[n] == 2 ) { if( g.uiSpeedCounter[n] == 0 ) { // could move this entire declaration into the global, and control the init process differently, but for now // declaring static variable arrays suit the task. the reason why these arrays are static is that // state needs to be maintained every time the function is entered and exited, and these variables are // not really global (that is, this scope is the only scope that counts). // count[n] counts the number of times the reel has spun before it begins to stop. // iteration[n] determines the maximum number of times the reel must spin before it begins to stop. // last[y][x] maintains what the last pic was in that position, and is later incremented to demonstrate movement. static INDEX count[NUM_REELS], iteration[NUM_REELS]; static INDEX last[NUM_REELS][NUM_PICS]; if( bInit[n] ) { int y; idxBobbleCount[n] = uiSmartYOffset; bBobbling[n] = 0; for( y = 0; y < NUM_REELS; y++ ) { last[y][0] = GetPositionIndex( TRUE, n ); last[y][1] = last[y][0] + 1; last[y][2] = last[y][1] + 1; last[y][3] = last[y][2] + 1; last[y][4] = last[y][3] + 1; } //this doesn't work yet....or does it? { IMAGE_RECTANGLE rect; rect.x = 0;//REEL_OFSX + REEL_STEPX * n; rect.y = 0;//REEL_OFSY; rect.width = REEL_WIDTH; rect.height = REEL_HEIGHT; //FixImagePosition( g.subsurface[n] ); //SetImageBound( g.subsurface[n], &rect ); } bInit[n] = FALSE; count[n] = 0; iteration[n] = (rand()%NUM_ITERATIONS) + ITERATIONS_OFFSET; } { INDEX idx; int x; for( x = uiSmartYOffset; x < ( NUM_PICS_IN_WINDOW + uiSmartYOffset) ; x++) { idx = last[n][x]; DrawPosition( n, idx, x, 0); } //--- This is just quality assurance.-------- // for( x = 0; x < NUM_PICS; x++ ) // { // idx = last[n][x]; // BlotImageSizedTo( g.testsurface[n] // , g.images[idx] // , 0, ( 96 * x ) // , 0, 0, REEL_WIDTH, ( 96 * NUM_PICS ) // ); // } //--- This is just quality assurance.-------- } if( idxBobbleCount[n] == uiSmartYOffset ) { // xlprintf(LOG_NOISE)("Well, %d is shifting" // , n // ); last[n][4] = last[n][3]; last[n][3] = last[n][2]; last[n][2] = last[n][1]; last[n][1] = last[n][0]; last[n][0] = GetPositionIndex( FALSE, n ); count[n]++; } if(count[n] == (iteration[n] + 2 ) ) { uint32_t x; for( x = uiSmartYOffset; x < ( NUM_PICS_IN_WINDOW + uiSmartYOffset) ; x++) { DrawPosition( n, last[n][x], x, iBobble[idxBobbleCount[n]]); } if( idxBobbleCount[n] >= ( NUM_PICS_IN_WINDOW + uiSmartYOffset) ) { xlprintf(LOG_NOISE)("Bobbling"); g.uiSpeedStep[n] = DO_NOT_SPIN; //g.bReelSpinning[n] = 0; bBobbling[n] = 1; g.uiSpeedCounter[n] = 0; g.ofs = -7; //might figure out if this is even necessary to maintain later. { int m; for( m = 0; m < NUM_REELS; m++ ) // if( g.bReelSpinning[m] ) if( !bBobbling[m] ) { // xlprintf(LOG_NOISE)(" %d is * still * spinning." // , m // ); break; } else { idxBobbleCount[m] = uiSmartYOffset + 1; } if( m == NUM_REELS ) { g.flags.bSpinning = 0; { //reset the bobbleness. int z; for( z = 0; z < NUM_REELS; z++) { g.bReelSpinning[z] = 0; idxBobbleCount[z] = uiSmartYOffset; } } if( bPlaying ) { BlotScaledImageSizedTo( g.statussurface , g.playagain , 0 , 0 //490, 10 , 140, 68 ); UpdateDisplay(g.render); bPlaying = FALSE; } } } } else { idxBobbleCount[n]++; } } else if( count[n] > iteration[n] ) { g.uiSpeedCounter[n] = count[n] - iteration[n] ; } } else g.uiSpeedCounter[n]--; } } } } } UpdateDisplayPortion( g.render, REEL_OFSX, REEL_OFSY, REEL_STEPX*(g.nReels-1) + REEL_WIDTH, REEL_HEIGHT ); }