bool Scene::update() { if(pG_floor->pMovepath) { /* if(step>allSteps) { step=0; pfMoveStepNow[0]=-pfMoveStepNow[0]; pfMoveStepNow[1]=-pfMoveStepNow[1]; pfMoveStepNow[2]=-pfMoveStepNow[2]; } */ getMovesteps(); updateMove(); renewPhyScene(); //step++; }else { //LOGI("update 0"); pG_floor->draw(); //LOGI("num_coins: %d",num_coins); for(int i=0;i<num_coins;i++) {//LOGI("num_coins i: %d",i); vCoin[i]->update(pLR); } /* for(int i=0;i<num_enemys;i++) { if(vEnemy[i]->state==2) continue; updateOneEnemy( vEnemy[i]); } */ for(int i=0;i<num_thorns;i++) { vThorn[i]->update(pLR); } for(int i=0;i<num_thornballs;i++) { vThornball[i]->update(pLR); } } return true; }
bool Scene::updateLess() { //LOGI("updateL0"); if(pG_floor->pMovepath) { getMovesteps(); updateMoveLess(); //renewPhyScene(); //step++; }else { pG_floor->draw(); /* for(int i=0;i<num_coins;i++) { vCoin[i]->updateLess(); } for(int i=0;i<num_enemys;i++) { if(vEnemy[i]->state==2) continue; updateOneEnemy( vEnemy[i]); } */ for(int i=0;i<num_thorns;i++) { //if(vThorn[i]) vThorn[i]->updateLess(); } for(int i=0;i<num_thornballs;i++) { vThornball[i]->updateLess();//update(pLR);// } } //LOGI("updateL1"); return true; }
void Motion::gcode_precalc(GCode& gcode, float& feedin, Point* lastend) { if(gcode.state >= GCode::PREPARED) return; if(gcode[G].isUnused()) return; if(gcode[G].getInt() == 92) { // Just carry over new position for(int ax=0;ax<NUM_AXES;ax++) { if(!gcode[ax].isUnused()) { (*lastend)[ax] = gcode[ax].getFloat(); } } gcode.state = GCode::PREPARED; return; } if(gcode[G].getInt() != 1 and gcode[G].getInt() != 2) { // no precalc for anything but 92, 1, 2 gcode.state = GCode::PREPARED; return; } // We want to carry over the previous ending position and feedrate if possible. gcode.startpos = *lastend; if(gcode[F].isUnused()) gcode.feed = feedin; else gcode.feed = gcode[F].getFloat(); if(gcode.feed == 0) gcode.feed = SAFE_DEFAULT_FEED; getMovesteps(gcode); getActualEndpos(gcode); *lastend = gcode.endpos; feedin = gcode.feed; gcode.state = GCode::PREPARED; if(gcode.movesteps == 0) return; // Calculate actual distance of move along vector gcode.actualmm = 0; for(int ax=0;ax<NUM_AXES;ax++) { gcode.actualmm += pow(gcode.axismovesteps[ax]/AXES[ax].getStepsPerMM(), 2); } gcode.actualmm = sqrt(gcode.actualmm); float axisspeeds[NUM_AXES]; // Calculate individual axis movement speeds float mult = gcode.feed/gcode.actualmm; for(int ax=0;ax<NUM_AXES;ax++) { axisspeeds[ax] = (gcode.axismovesteps[ax] / AXES[ax].getStepsPerMM()) * mult; #ifdef DEBUG_LAME HOST.labelnum("AS", ax, false); HOST.labelnum(":", axisspeeds[ax]); #endif } // Calculate ratio of movement speeds to main axis for(int ax=0;ax < NUM_AXES;ax++) { if(axisspeeds[ax] != 0) gcode.axisratio[ax] = axisspeeds[gcode.leading_axis] / axisspeeds[ax]; else gcode.axisratio[ax] = 0; } // Check all axis for violation o top speed. Take the biggest violator and change // the leading axis speed to match it. float bigdiff = 0; float littlediff = 0; for(int ax = 0;ax<NUM_AXES;ax++) { if(axisspeeds[ax] > AXES[ax].getMaxFeed()) { float d = (axisspeeds[ax] - AXES[ax].getMaxFeed()) * gcode.axisratio[ax]; #ifdef DEBUG_LAME HOST.labelnum("D",ax,false); HOST.labelnum(":",axisspeeds[ax] - AXES[ax].getMaxFeed(),false); HOST.labelnum(" rat: ", gcode.axisratio[ax]); #endif if(d > bigdiff) bigdiff = d; } if(axisspeeds[ax] > AXES[ax].getStartFeed()/2) { float d = (axisspeeds[ax] - (AXES[ax].getStartFeed()/2)) * gcode.axisratio[ax]; if(d > littlediff) littlediff = d; } } #ifdef DEBUG_LAME HOST.labelnum("BD:", bigdiff); HOST.labelnum("LD:", littlediff); #endif gcode.maxfeed = axisspeeds[gcode.leading_axis] - bigdiff; gcode.startfeed = axisspeeds[gcode.leading_axis] - littlediff; gcode.endfeed = gcode.startfeed; gcode.currentfeed = gcode.startfeed; gcode.minfeed = gcode.startfeed; // TODO: We shoudl treat accel as we do the speeds above and scale it to fit the chosen axis. // instead we just take the accel of the leadng axis. float accel = AXES[gcode.leading_axis].getAccel(); gcode.accel = accel; for(int ax=0;ax<NUM_AXES;ax++) { if(gcode.axismovesteps[ax]) AXES[ax].enable(); } #ifdef DEBUG_LAME HOST.labelnum("F1: ", gcode.startfeed); HOST.labelnum("F2: ", gcode.maxfeed); HOST.labelnum("Accel: ", accel); #endif uint32_t dist = AXES[gcode.leading_axis].getAccelDist(gcode.startfeed, gcode.maxfeed, accel); uint32_t halfmove = gcode.movesteps >> 1; if(halfmove <= dist) { gcode.accel_until = gcode.movesteps - halfmove; gcode.decel_from = halfmove; } else { gcode.accel_until = gcode.movesteps - dist; gcode.decel_from = dist; } gcode.currentinterval = AXES[gcode.leading_axis].int_interval_from_feedrate(gcode.startfeed); gcode.currentfeed = gcode.startfeed; // TODO: this only changes when we change accel rates; can we just store it per-axis until we scale accels properly? gcode.accel_inc = (float)((float)accel * 60.0f / ACCELS_PER_SECOND); gcode.accel_timer = ACCEL_INC_TIME; gcode.optimized = false; }