void menu::style::draw_row_bg(menu& menu_ref, const size_t /*row_index*/, const SDL_Rect& rect, ROW_TYPE type)
{
menu_ref.bg_restore(rect);
int rgb = 0;
double alpha = 0.0;
switch(type) {
case NORMAL_ROW:
rgb = normal_rgb_;
alpha = normal_alpha_;
break;
case SELECTED_ROW:
rgb = selected_rgb_;
alpha = selected_alpha_;
break;
case HEADING_ROW:
rgb = heading_rgb_;
alpha = heading_alpha_;
break;
}
draw_solid_tinted_rectangle(rect.x, rect.y, rect.w, rect.h,
(rgb&0xff0000) >> 16,(rgb&0xff00) >> 8,rgb&0xff,alpha,
menu_ref.video().getSurface());
}
void begin(menu& m)
{
ClearDrawScreen();
const unsigned int x=0;
const unsigned int y=195;
const unsigned int Green=GetColor(0,255,0);
unsigned int counter=0;
m.load_max_v();
DrawFormatString(520,450,GetColor(255,255,255),"Loading ...");
for(unsigned int count_down=3;
!ScreenFlip()&&!ProcessMessage()&&!ClearDrawScreen()&&count_down>0;
--count_down){
m.effectiving();
DrawStringToHandle(x+260,y,boost::lexical_cast<std::string>(count_down).c_str(),
Green,m.font_Handle[1]);
std::this_thread::sleep_for(std::chrono::seconds(1));
}
std::this_thread::sleep_for(std::chrono::seconds(1));
std::chrono::system_clock::time_point start=std::chrono::system_clock::now();
while(!ScreenFlip()&&!ProcessMessage()&&!ClearDrawScreen()){
m.effectiving();
DrawStringToHandle(x+100,y,"残り",Green,m.font_Handle[0]);
DrawStringToHandle(x+235,y,boost::lexical_cast<std::string>(m.max_v-counter).c_str(),
Green,m.font_Handle[1]);
DrawStringToHandle(x,0,
(std::string("回数: ")+=boost::lexical_cast<std::string>(m.max_v)).c_str(),
Green,m.font_Handle[2]);
DrawStringToHandle(x,45,
(std::string("現在: ")+=boost::lexical_cast<std::string>(counter)).c_str(),
Green,m.font_Handle[2]);
DrawStringToHandle(x,90,
(std::string("時間: ")+=boost::lexical_cast<std::string>(
std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start).count()
)).c_str(),
Green,m.font_Handle[2]);
DrawStringToHandle(x,135,"Q: 中止",Green,m.font_Handle[2]);
count(counter);
if(counter==m.max_v)break;
if(CheckHitKey(KEY_INPUT_Q))break;
}
Rank(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now()-start),m);
}
void display(void)
{
if (!ingame )
{
Menu.drawMenu();
}
else
{
//movements handling
playerMovement();//player collisons handled inside this function
enemyMovement();
//player drawing
glPushAttrib(GL_CURRENT_BIT);//keeps players color from changing
glColor4f(0.0, 1.0, 0.0,1.0);
drawPlayer();
//enemy drawing
for (int x=0; x<enemy_size; x++)
drawEnemy(enemy[x].getPosition().x, enemy[x].getPosition().y,enemy[x].getRadius());
}
glutSwapBuffers();//swap bufferes!!!! Important for animation
// glFlush();
}
void autoRestore(menu m)
{
//This still needs user input.
for(unsigned i = 0; i < m.getSize(); i++)
{
FS_Archive saveArch;
if(m.optSelected(i) && openSaveArch(&saveArch, sdTitle[i], false))
restoreData(sdTitle[i], saveArch, MODE_SAVE);
FSUSER_CloseArchive(&saveArch);
FS_Archive extArch;
if(m.optSelected(i) && openExtdata(&extArch, sdTitle[i], false))
restoreData(sdTitle[i], extArch, MODE_EXTDATA);
FSUSER_CloseArchive(&extArch);
}
}
//Update() is where the magic happens,
//It Draws everything to the screen
void update(vector<character> *objects)
{
drawRect(0, 0, camera.size.x, camera.size.y, 0,150,0);
//drawRect(loc.x, loc.y, size.x, size.y, r, g, b);
SDL_Rect square;
//SDL_Rect* clip = NULL;
for(unsigned int i = 0; i < objects->size(); i++)
{
if(collide(camera, objects->at(i)))
{
//dim size = objects->at(i).size;;
dim loc = objects->at(i).loc;
loc.x-=camera.loc.x;
loc.y-=camera.loc.y;
square.x = loc.x;
square.y = loc.y;
int index = 0;
if (objects->at(i).type == green)
index = 1;
if (objects->at(i).type == blue)
index = 3;
if (objects->at(i).type == purple)
index = 5;
if (objects->at(i).selected)
index--;
if (objects->at(i).type == red)
index = 6;
if (objects->at(i).type == rock)
index = 7;
if (objects->at(i).type == rock2)
index = 8;
SDL_BlitSurface(images[index], NULL, mainframe, &square);
}
}
if (dragBox.on && (dragBox.size.x <= camera.size.x && dragBox.size.y <= camera.size.y))
drawRect(dragBox.loc.x, dragBox.loc.y, dragBox.size.x, dragBox.size.y, 0, 255, 255);
drawRect(bottomMenu.getLoc().x, bottomMenu.getLoc().y, bottomMenu.getSize().x, bottomMenu.getSize().y, 100, 100, 100);
SDL_Flip(mainframe);
return;
}
void autoBackup(menu m)
{
showMessage("This can take a few minutes depending on how many titles are selected.");
progressBar autoDump((float)m.getSelectCount(), "Copying saves...");
//Keep track of what's done
float dumpCount = 0;
for(unsigned i = 0; i < m.getSize(); i++)
{
//This is for titles with no save archive ex. Fantasy Life
bool dumped = false;
FS_Archive saveArch;
if(m.optSelected(i) && openSaveArch(&saveArch, sdTitle[i], false))//if it's selected and we can open save archive
{
createTitleDir(sdTitle[i], MODE_SAVE);
backupData(sdTitle[i], saveArch, MODE_SAVE, true);
dumpCount++;
dumped = true;
}
FSUSER_CloseArchive(&saveArch);
FS_Archive extArch;
if(m.optSelected(i) && openExtdata(&extArch, sdTitle[i], false))
{
createTitleDir(sdTitle[i], MODE_EXTDATA);
backupData(sdTitle[i], extArch, MODE_EXTDATA, true);
//check first to make sure we don't count it twice because no save arch
if(!dumped)
dumpCount++;
}
FSUSER_CloseArchive(&extArch);
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
autoDump.draw(i);
sf2d_end_frame();
sf2d_swapbuffers();
}
showMessage("Complete!");
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitWindowPosition(0,0);
glutInitWindowSize(800,600);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
glutCreateWindow("PewPew");
//glEnable(GL_LIGHTING);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
//glShadeModel(GL_SMOOTH);
//glEnable(GL_LIGHT0);
glMatrixMode(GL_PROJECTION);
open_joystick();
mn.add_option(std::string("INFO"),(&info_action));
mn.add_option(std::string("PLAY"),(&run));
mn.add_option(std::string("NEW GAME"),(&new_game));
mn.add_option(std::string("OPTIONS"),(&option_action));
mn.add_option(std::string("QUIT"),(&end_0));
menu_pages.push(&mn);
opt.add_option(std::string("BACK"),(&back));
opt.add_option(std::string("SCORES"),(&scores_action));
opt.add_option(std::string("SOUNDS ON"),(&sound_off),std::string("SOUNDS OFF"),(&sound_on));
scores.add_option(std::string("BACK"), (&back));
info.add_option(std::string("BACK"),(&back));
//GLfloat filter[11] = {0.3,0.28,0.26,0.24,0.22,0.20,0.22,0.24,0.26,0.28,0.3}; //GOOD
//glSeparableFilter2D(GL_SEPARABLE_2D, GL_LUMINANCE, 11, 11, GL_LUMINANCE, GL_FLOAT, filter,filter); //<< segfault !!!
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glutReshapeFunc(reshape);
glutDisplayFunc(display);
//glutIdleFunc(mytimer);
glutTimerFunc(20,mytimer,1);
glutIgnoreKeyRepeat(1);
glutKeyboardUpFunc(kbRelF);
glutSpecialFunc(skbF);
glutKeyboardFunc(kbF);
glutPassiveMotionFunc(mIdleF);
glutMouseFunc(mF);
glutMainLoop();
return 0;
}
void init_speedo(void) {
Millis.init();
Serial.init(USART1, 115200L);
Serial.init(USART2, 115200L);
Serial.init(USART3, 115200L);
Serial.puts_ln(USART1, "=== Speedoino ===");
Serial.puts(USART1, GIT_REV); // print Software release
Serial.puts(USART1, " HW:");
Serial.puts_ln(USART1, Config.get_hw_version()); // print Hardware release
// first, set all variables to a zero value
Sensors.init();
Speedo.clear_vars(); // refresh cycle
// read configuration file from sd card
SD.init(); // try open SD Card
SD.open();
Config.read(CONFIG_FOLDER, "BASE.TXT", READ_MODE_CONFIGFILE, ""); // load base config
Config.read(CONFIG_FOLDER, "SPEEDO.TXT", READ_MODE_CONFIGFILE, ""); // speedovalues, avg,max,time
Config.read(CONFIG_FOLDER, "GANG.TXT", READ_MODE_CONFIGFILE, ""); // gang
Config.read(CONFIG_FOLDER, "TEMPER.TXT", READ_MODE_CONFIGFILE, ""); // Temperatur
Config.read_skin(); // skinning
// check if read SD read was okay, if not: load your default backup values
Aktors.check_vars(); // check if color of outer LED are OK
Sensors.check_vars(); // check if config read was successful
Speedo.check_vars(); // rettet das Skinning wenn SD_failed von den sensoren auf true gesetzt wird
Sensors.single_read(); // read all sensor values once to ensure we are ready to show them
Aktors.init(); // Start outer LEDs // ausschlag des zeigers // Motorausschlag und block bis motor voll ausgeschlagen, solange das letzte intro bild halten
TFT.init();
// SD.prefetched_animation(37); // 37
Menu.init(); // Start butons // adds the connection between pins and vars
Menu.display(); // execute this AFTER pOLED.init_speedo!! this will show the menu and, if state==11, draws speedosymbols
Speedo.reset_bak(); // reset all storages, to force the redraw of the speedo
Config.ram_info();
Serial.puts_ln(USART1, "=== Setup finished ===");
}
void moveCamera(dim move)
{
while(camera.loc.x+camera.size.x>currentMap->length-move.x)
move.x--;
while(camera.loc.y+camera.size.y>currentMap->length-move.y+bottomMenu.getSize().y)
move.y--;
while(camera.loc.x+move.x<0)
move.x++;
while(camera.loc.y+move.y<0)
move.y++;
camera.loc.x += move.x;
camera.loc.y += move.y;
}
void Setting(menu& m)
{
unsigned int Green=GetColor(255,255,255);
int max_f=-1;
m.effectiving();
DrawStringToHandle(0,145,"測定回数設定:",Green,m.font_Handle[2]);
max_f=KeyInputNumber(0,200,640,0,false);
std::ofstream ofs("data/max_v.dat");
if(!ofs.is_open())assert(0);
ofs<<max_f;
ofs.close();
}
void menu::style::draw_row(menu& menu_ref, const size_t row_index, const SDL_Rect& rect, ROW_TYPE type)
{
if(rect.w == 0 || rect.h == 0) {
return;
}
draw_row_bg(menu_ref, row_index, rect, type);
SDL_Rect minirect = rect;
if(type != HEADING_ROW) {
minirect.x += thickness_;
minirect.y += thickness_;
minirect.w -= 2*thickness_;
minirect.h -= 2*thickness_;
}
menu_ref.draw_row(row_index, minirect, type);
}
void menu::imgsel_style::draw_row_bg(menu& menu_ref, const size_t row_index, const SDL_Rect& rect, ROW_TYPE type)
{
if(type == SELECTED_ROW && has_background_ && !load_failed_) {
if(bg_cache_.width != rect.w || bg_cache_.height != rect.h)
{
//draw scaled background image
//scale image each time (to prevent loss of quality)
bg_cache_.surf = scale_surface(img_map_["background"], rect.w, rect.h);
bg_cache_.width = rect.w;
bg_cache_.height = rect.h;
}
SDL_Rect clip = rect;
menu_ref.video().blit_surface(rect.x,rect.y,bg_cache_.surf,nullptr,&clip);
}
else {
style::draw_row_bg(menu_ref, row_index, rect, type);
}
}
void menu::imgsel_style::draw_row(menu& menu_ref, const size_t row_index, const SDL_Rect& rect, ROW_TYPE type)
{
if(!load_failed_) {
//draw item inside
style::draw_row(menu_ref, row_index, rect, type);
if(type == SELECTED_ROW) {
// draw border
surface image;
SDL_Rect area;
SDL_Rect clip = rect;
area.x = rect.x;
area.y = rect.y;
image = img_map_["border-top"];
area.x = rect.x;
area.y = rect.y;
do {
menu_ref.video().blit_surface(area.x,area.y,image,nullptr,&clip);
area.x += image->w;
} while( area.x < rect.x + rect.w );
image = img_map_["border-left"];
area.x = rect.x;
area.y = rect.y;
do {
menu_ref.video().blit_surface(area.x,area.y,image,nullptr,&clip);
area.y += image->h;
} while( area.y < rect.y + rect.h );
image = img_map_["border-right"];
area.x = rect.x + rect.w - thickness_;
area.y = rect.y;
do {
menu_ref.video().blit_surface(area.x,area.y,image,nullptr,&clip);
area.y += image->h;
} while( area.y < rect.y + rect.h );
image = img_map_["border-bottom"];
area.x = rect.x;
area.y = rect.y + rect.h - thickness_;
do {
menu_ref.video().blit_surface(area.x,area.y,image,nullptr,&clip);
area.x += image->w;
} while( area.x < rect.x + rect.w );
image = img_map_["border-topleft"];
area.x = rect.x;
area.y = rect.y;
menu_ref.video().blit_surface(area.x,area.y,image);
image = img_map_["border-topright"];
area.x = rect.x + rect.w - image->w;
area.y = rect.y;
menu_ref.video().blit_surface(area.x,area.y,image);
image = img_map_["border-botleft"];
area.x = rect.x;
area.y = rect.y + rect.h - image->h;
menu_ref.video().blit_surface(area.x,area.y,image);
image = img_map_["border-botright"];
area.x = rect.x + rect.w - image->w;
area.y = rect.y + rect.h - image->h;
menu_ref.video().blit_surface(area.x,area.y,image);
}
}
else {
//default drawing
style::draw_row(menu_ref, row_index, rect, type);
}
}
int main(void) {
SystemInit(); // Quarz Einstellungen aktivieren
init_speedo();
// SD.prefetched_animation(37); // 37
// Speedo.initial_draw_screen(); // draw symbols
/******************** setup procedure ********************************************
* all initialisations must been made before the main loop, before THIS
******************** setup procedure ********************************************/
unsigned long previousMillis = 0;
#ifdef LOAD_CALC
unsigned long load_calc=0;
unsigned long lasttime_calc=0;
#endif
for (;;) {
Sensors.mCAN.check_message();
//////////////////////////////////////////////////
// Sensors.m_reset->set_deactive(false,false);
// Serial3.end();
// Serial3.begin(115200);
// while(true){
// while(Serial3.available()>0){
// Serial.print(Serial3.read(),BYTE);
// }
// while(Serial.available()>0){
// Serial3.print(Serial.read(),BYTE);
// }
// }
//////////////////////////////////////////////////
Sensors.mReset.toggle(); // toggle pin, if we don't toggle it, the ATmega8 will reset us, kind of watchdog<
Debug.speedo_loop(21, 1, 0, " "); // intensive debug= EVERY loop access reports the Menustate
Sensors.mGPS.check_flag(); // check if a GPS sentence is ready
// pAktors.check_flag(); // updated expander
Sensors.pull_values(); // very important, updates all the sensor values
/************************* timer *********************/
Timer.every_sec(); // 1000 ms
Timer.every_qsec(); // 250 ms
Timer.every_custom(); // one custom timer, redrawing the speedo, time is defined by "refresh_cycle" in the base.txt
/************************* push buttons *********************
* using true as argument, this will activate bluetooth input as well
************************* push buttons*********************/
//Menu.button_test(true,false); // important!! if we have a pushed button we will draw something, depending on the menustate
if (Menu.button_test(true, false)) { // important!! if we have a pushed button we will draw something, depending on the menustate
Serial.puts(USART1, "Menustate:");
Serial.puts_ln(USART1, Menu.state);
}
/************************ every deamon activity is clear, now draw speedo ********************
* we are round about 0000[1]1 - 0000[1]9
************************ every deamon activity is clear, now draw speedo ********************/
Sensors.mCAN.check_message();
if ((Menu.state / 10) == 1 || Menu.state == 7311111) {
Speedo.loop(previousMillis);
}
//////////////////// Sprint Speedo ///////////////////
else if (Menu.state == MENU_SPRINT * 10 + 1) {
Sprint.loop();
}
////////////////// Clock Mode ////////////////////////
else if (Menu.state == 291) {
Sensors.mClock.loop();
}
////////////////// Speed Cam Check - Mode ////////////////////////
else if (Menu.state
== BMP(0, 0, 0, 0, M_TOUR_ASSISTS,
SM_TOUR_ASSISTS_SPEEDCAM_STATUS, 1)) {
// SpeedCams.calc();
// SpeedCams.interface();
}
////////////////// race mode ////////////////////
else if (Menu.state == M_LAP_T * 100 + 11) {
LapTimer.waiting_on_speed_up();
} else if (Menu.state == M_LAP_T * 1000 + 111) {
LapTimer.race_loop();
}
////////////////// set gps point ////////////////////
else if (Menu.state == M_LAP_T * 10000L + 3111) {
LapTimer.gps_capture_loop();
}
//////////////////// voltage mode ///////////////////
else if (Menu.state == 531) {
Sensors.addinfo_show_loop();
}
//////////////////// stepper mode ///////////////////
else if (Menu.state == 541) {
// Aktors.mStepper.loop();
}
//////////////////// gps scan ///////////////////
else if (Menu.state == 511) {
Sensors.mGPS.loop();
}
//////////////////// outline scan ///////////////////
else if (Menu.state == 721) {
Sensors.mSpeed.check_umfang();
}
////////////////// gear scan ///////////////
else if (floor(Menu.state / 100) == 71) {
Sensors.mGear.calibrate();
}
#ifdef LOAD_CALC
load_calc++;
if(millis()-lasttime_calc>1000) {
Serial.print(load_calc);
Serial.println(" cps"); // 182 w/o interrupts, 175 w/ interrupts, 172 w/ much interrupts
load_calc=0;
lasttime_calc=millis();
}
#endif
} // end for
}