int main() { freopen("numar4.in","r",stdin); freopen("numar4.out","w",stdout); scanf("%d %d",&ni,&nz); int i; a[0]=ni+nz; for(i=ni+nz; i>0; --i) scanf("%d",&a[i]); b[0]=nz+1; b[nz+1]=1; for(i=nz;i!=0 && a[1]%2==0;) { imp(a,2); imp(b,2); --i; } for(i=nz;i!=0 && a[1]%5==0;) { imp(a,5); imp(b,5); --i; } printf("%d\n",a[0]); afis(a); printf("\n%d\n",b[0]); afis(b); return 0; }
JSValue* JSSVGLength::getValueProperty(ExecState* exec, int token) const { switch (token) { case UnitTypeAttrNum: { SVGLength imp(*impl()); return jsNumber(imp.unitType()); } case ValueAttrNum: { SVGLength imp(*impl()); return jsNumber(imp.value()); } case ValueInSpecifiedUnitsAttrNum: { SVGLength imp(*impl()); return jsNumber(imp.valueInSpecifiedUnits()); } case ValueAsStringAttrNum: { SVGLength imp(*impl()); return jsString(imp.valueAsString()); } case ConstructorAttrNum: return getConstructor(exec); } return 0; }
void JSSVGLength::putValueProperty(ExecState* exec, int token, JSValue* value, int /*attr*/) { switch (token) { case ValueAttrNum: { SVGLength imp(*impl()); imp.setValue(value->toFloat(exec)); m_impl->commitChange(exec, imp); break; } case ValueInSpecifiedUnitsAttrNum: { SVGLength imp(*impl()); imp.setValueInSpecifiedUnits(value->toFloat(exec)); m_impl->commitChange(exec, imp); break; } case ValueAsStringAttrNum: { SVGLength imp(*impl()); imp.setValueAsString(valueToStringWithNullCheck(exec, value)); m_impl->commitChange(exec, imp); break; } } if (context()) context()->notifyAttributeChange(); }
int main(int argc, char** argv) { // lowpass response // cf = sr/10 // trans bw = sr/10 float max = 1.f; float min = 0.f; float cf = 0.1f; float tbw = 0.1f; // magnitude response curve float points[3]= {max,min,min}; float lens[3]= {cf,tbw,1-(cf+tbw)}; // using Hamming window // filter order = 3.33*sr/tbw int order = 333; HammingTable window(order, 0.54f); ImpulseTable imp(order,3, 1.f, points, lens, 0.f,&window); // test signal wavetable HarmTable t1(1024, 50, SAW); SndWave output("test.wav", OVERWRITE); /* output */ Oscili oscil(&t1, 100.f, 32767.f); /* test signal */ Convol fil(&imp, &oscil, 16.f); /* filter */ int dur = 5; for(int i=0; i<dur*(DEF_SR/DEF_VECSIZE); i++) { oscil.DoProcess(); fil.DoProcess(); fil >> output; } return 0; }
JSValue* JSSVGMatrix::rotate(ExecState* exec, const ArgList& args) { AffineTransform imp(*impl()); float angle = args[0]->toFloat(exec); return toJS(exec, JSSVGPODTypeWrapperCreatorReadOnly<AffineTransform>::create(imp.rotate(angle)).get(), m_context.get()); }
JSValue* JSSVGMatrix::multiply(ExecState* exec, const ArgList& args) { AffineTransform imp(*impl()); AffineTransform secondMatrix = toSVGMatrix(args[0]); return toJS(exec, JSSVGPODTypeWrapperCreatorReadOnly<AffineTransform>::create(imp.multiply(secondMatrix)).get(), m_context.get()); }
void MainWindow::writeGraphviz() { QFileDialog dialog(this); dialog.setFileMode(QFileDialog::AnyFile); dialog.setNameFilter(tr("Graphviz file (*.gv)")); if(dialog.exec()) { QFile f(dialog.selectedFiles()[0]); f.open(QIODevice::WriteOnly | QIODevice::Text); QTextStream out(&f); GameBoard b(*gbw->gameBoard()); QString fdir = QFileInfo(dialog.selectedFiles()[0]).dir().path(); GraphGen::setPrepareImageCallback([&](const GameBoard& b, const std::string& fname) { QFile imfile(fdir + "/" + QString::fromStdString(fname) + ".png"); if(!imfile.exists()) { QImage image(100, 100, QImage::Format_RGB888); QPainter imp(&image); GameBoardWidget::paintBoard(&b, imp); image.save(imfile.fileName()); std::cout << "Wrote image " << imfile.fileName().toStdString() << std::endl; } }); out << QString::fromStdString(GraphGen::graph(b, 3*2, 4)); } }
QString Record::dump() const { Table * t = table(); QStringList keys, values; keys << (t ? t->tableName() : QString("Invalid Record")) + " @ 0x" + QString::number((quint64)mImp,16); values << stateString(); if( t ) { QStringList fieldNames = t->schema()->fieldNames(); fieldNames.sort(); foreach( QString fieldName, fieldNames ) { Field * f = t->schema()->field(fieldName); QVariant v = imp()->isColumnSelected(f->pos()) ? getValue(f->pos()) : "NOT SELECTED"; keys << f->name(); if( f->type() == Field::Interval ) values << v.value<Interval>().toString(); else if( v.userType() == qMetaTypeId<Record>() && f->flag( Field::ForeignKey ) ) { Record r = v.value<Record>(); if( r.isRecord() ) values << QString::number(r.key()); else values << "<Uncommitted " + r.table()->schema()->className() + " @ 0x" + QString::number((quint64)r.mImp,16) + ">"; } else values << v.toString(); } }
void LogoutMessageBox::paintEvent(QPaintEvent *event) { QImage imp(":/images/exitBox"); QPainter painter(this); painter.drawImage(0, 0, imp.scaled(this->size())); QMessageBox::paintEvent(event); }
JSValue* JSSVGLengthPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args) { if (!thisObj->inherits(&JSSVGLength::info)) return throwError(exec, TypeError); JSSVGLength* castedThisObj = static_cast<JSSVGLength*>(thisObj); JSSVGPODTypeWrapper<SVGLength>* wrapper = castedThisObj->impl(); SVGLength imp(*wrapper); switch (id) { case JSSVGLength::NewValueSpecifiedUnitsFuncNum: { unsigned short unitType = args[0]->toInt32(exec); float valueInSpecifiedUnits = args[1]->toFloat(exec); imp.newValueSpecifiedUnits(unitType, valueInSpecifiedUnits); wrapper->commitChange(exec, imp); if (castedThisObj->context()) castedThisObj->context()->notifyAttributeChange(); return jsUndefined(); } case JSSVGLength::ConvertToSpecifiedUnitsFuncNum: { unsigned short unitType = args[0]->toInt32(exec); imp.convertToSpecifiedUnits(unitType); wrapper->commitChange(exec, imp); if (castedThisObj->context()) castedThisObj->context()->notifyAttributeChange(); return jsUndefined(); } } return 0; }
JSValue* JSSVGMatrix::scaleNonUniform(ExecState* exec, const ArgList& args) { AffineTransform imp(*impl()); float scaleFactorX = args[0]->toFloat(exec); float scaleFactorY = args[1]->toFloat(exec); return toJS(exec, JSSVGPODTypeWrapperCreatorReadOnly<AffineTransform>::create(imp.scaleNonUniform(scaleFactorX, scaleFactorY)).get(), m_context.get()); }
Impedance operator *(Impedance _imp) { //TODO: DRY this up std::complex<double> complex_impedance = \ (std::complex<double>)1/(_imp.inverse() + this->inverse()); Impedance imp(complex_impedance); return imp; }
void plantilla::mover(char _char){ gotox(x,y);cout<<" "; x--; if(x<2){ y=rand()%30+4; x=99; } imp(_char); }
JSValue* JSSVGMatrix::inverse(ExecState* exec, const ArgList&) { AffineTransform imp(*impl()); KJS::JSValue* result = toJS(exec, JSSVGPODTypeWrapperCreatorReadOnly<AffineTransform>::create(imp.inverse()).get(), m_context.get()); if (!imp.isInvertible()) setDOMException(exec, SVGException::SVG_MATRIX_NOT_INVERTABLE); return result; }
JSValue* JSSVGLength::convertToSpecifiedUnits(ExecState* exec, const ArgList& args) { JSSVGPODTypeWrapper<SVGLength>* wrapper = impl(); SVGLength imp(*wrapper); imp.convertToSpecifiedUnits(args.at(exec, 0)->toInt32(exec), context()); wrapper->commitChange(imp, context()); return jsUndefined(); }
void Environment::disableWallpaper(LogWriter *log) { log->info(_T("Try to disable wallpaper")); Impersonator imp(log); AutoImpersonator ai(&imp, log); if (SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, _T(""), 0) == 0) { throw SystemException(_T("Cannot disable desktop wallpaper")); } }
void Environment::restoreWallpaper(LogWriter *log) { // FIXME: Remove log from here. Log only from caller. log->info(_T("Try to restore wallpaper")); Impersonator imp(log); AutoImpersonator ai(&imp, log); if (SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, 0, 0) == 0) { throw SystemException(_T("Cannot restore desktop wallpaper")); } }
int main(void){ celula *lista; celula cabeca; celula *invertida; lista = &cabeca; cabeca.pc = NULL; ins(1, lista); ins(2, lista); ins(3, lista); ins(4, lista); imp(lista); libera(lista); imp(lista); }
JSValue JSSVGMatrix::inverse(ExecState* exec) { AffineTransform imp(*impl()); SVGElement* context = JSSVGContextCache::svgContextForDOMObject(this); JSValue result = toJS(exec, globalObject(), JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.inverse()).get(), context); if (!imp.isInvertible()) setDOMException(exec, SVGException::SVG_MATRIX_NOT_INVERTABLE); return result; }
void MainWindow::writeStateImage() { QFileDialog dialog(this); dialog.setFileMode(QFileDialog::AnyFile); dialog.setNameFilter(tr("PNG image (*.png)")); if(dialog.exec()) { QImage image(512, 512, QImage::Format_RGB888); QPainter imp(&image); GameBoardWidget::paintBoard(gbw->gameBoard(), imp); image.save(dialog.selectedFiles()[0]); } }
void KVFAZIA::Build(Int_t) { // Build the combined INDRA & FAZIA arrays GetGeometryParameters(); GenerateCorrespondanceFile(); if (!gGeoManager) { new TGeoManager("FAZIA", Form("FAZIA geometry for dataset %s", gDataSet->GetName())); TGeoMaterial* matVacuum = gGeoManager->GetMaterial("Vacuum"); if (!matVacuum) { matVacuum = new TGeoMaterial("Vacuum", 0, 0, 0); matVacuum->SetTitle("Vacuum"); } TGeoMedium* Vacuum = gGeoManager->GetMedium("Vacuum"); if (!Vacuum) Vacuum = new TGeoMedium("Vacuum", 1, matVacuum); TGeoVolume* top = gGeoManager->MakeBox("WORLD", Vacuum, 500, 500, 500); gGeoManager->SetTopVolume(top); } BuildFAZIA(); if (fBuildTarget) BuildTarget(); KVGeoImport imp(gGeoManager, KVMaterial::GetRangeTable(), this, kTRUE); imp.SetDetectorPlugin(ClassName()); imp.SetNameCorrespondanceList(fCorrespondanceFile.Data()); // any additional structure name formatting definitions DefineStructureFormats(imp); // the following parameters are optimized for a 12-block compact // geometry placed at 80cm with rings 1-5 of INDRA removed. // make sure that the expected number of detectors get imported! imp.ImportGeometry(fImport_dTheta, fImport_dPhi, fImport_ThetaMin, fImport_PhiMin, fImport_ThetaMax, fImport_PhiMax); /* KVFAZIADetector* det=0; TIter next_d(GetDetectors()); while ( det = (KVFAZIADetector* )next_d() ){ printf("%s %s %d %d %d\n",det->GetName(),det->GetFAZIAType(),det->GetBlockNumber(),det->GetQuartetNumber(),det->GetTelescopeNumber()); } */ SetIdentifications(); SortIDTelescopes(); KVDetector* det = GetDetector("SI2-T1-Q1-B001"); det->GetIDTelescopes()->ls(); SetDetectorThicknesses(); SetBit(kIsBuilt); }
JSValue* JSSVGMatrix::rotateFromVector(ExecState* exec, const ArgList& args) { AffineTransform imp(*impl()); float x = args[0]->toFloat(exec); float y = args[1]->toFloat(exec); KJS::JSValue* result = toJS(exec, JSSVGPODTypeWrapperCreatorReadOnly<AffineTransform>::create(imp.rotateFromVector(x, y)).get(), m_context.get()); if (x == 0.0 || y == 0.0) setDOMException(exec, SVGException::SVG_INVALID_VALUE_ERR); return result; }
JSValue JSSVGMatrix::rotateFromVector(ExecState* exec) { AffineTransform imp(*impl()); float x = exec->argument(0).toFloat(exec); float y = exec->argument(1).toFloat(exec); SVGElement* context = JSSVGContextCache::svgContextForDOMObject(this); JSValue result = toJS(exec, globalObject(), JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.rotateFromVector(x, y)).get(), context); if (x == 0.0 || y == 0.0) setDOMException(exec, SVGException::SVG_INVALID_VALUE_ERR); return result; }
void volume_polygonize(const XForm& xform, const Geometry::RGrid<float>& grid, HMesh::Manifold& mani, float tau, bool make_triangles) { mani.clear(); vector<Vec3d> quad_vertices; polygonize(xform, grid, quad_vertices, tau); vector<int> indices; vector<int> faces(quad_vertices.size()/4,4); for(int i=0;i<quad_vertices.size();++i) indices.push_back(i); build(mani, quad_vertices.size(), quad_vertices[0].get(), faces.size(), &faces[0], &indices[0]); stitch_more(mani, 1e-5); if(make_triangles) triangulate(mani); float avg_edge_len=0; for(HalfEdgeIDIterator h = mani.halfedges_begin(); h != mani.halfedges_end();++h) avg_edge_len += length(mani, *h); avg_edge_len /= mani.no_halfedges(); VolumetricImplicit imp(xform, grid); for(int iter=0;iter<4;++iter) { TAL_smoothing(mani, .25, 1); for(auto v: mani.vertices()) if(mani.in_use(v)) { Vec3d p = mani.pos(v); if(!std::isnan(p[0])) imp.push_to_surface(p,0,avg_edge_len*0.5); if(std::isnan(p[0])) mani.remove_vertex(v); else mani.pos(v) = p; } } mani.cleanup(); cout << "Produced " << mani.no_faces() << " faces " << endl; }
bool EventList::SearchInContact(MCONTACT hContact, TCHAR *strFind, ComparatorInterface* compFun) { InitFilters(); if (useImportedMessages) { std::vector<IImport::ExternalMessage> messages; { mir_cslock lck(csEventList); std::map<MCONTACT, EventList::ImportDiscData>::iterator it = contactFileMap.find(hContact); if (it != contactFileMap.end()) { ExportManager imp(hWnd, hContact, 1); imp.SetAutoImport(it->second.file); if (!imp.Import(it->second.type, messages, NULL)) messages.clear(); } } for (int i = 0; i < (int)importedMessages.size(); ++i) if (compFun->Compare((importedMessages[i].flags & DBEF_SENT) != 0, importedMessages[i].message, strFind)) return true; } std::list<EventTempIndex> tempList; GetTempList(tempList, false, true, hContact); EventIndex ei; EventData ed; TCHAR str[MAXSELECTSTR + 8]; // for safety reason for (std::list<EventTempIndex>::iterator itL = tempList.begin(); itL != tempList.end(); ++itL) { ei.isExternal = itL->isExternal; ei.hEvent = itL->hEvent; if (GetEventData(ei, ed)) { GetEventMessage(ei, str); if (compFun->Compare(ed.isMe, str, strFind)) return true; } } return false; }
std::vector<FlowRecord> TaintReachable::process(const ContextID ctxt, const ImmutableCallSite cs) const { DEBUG(errs() << "Using taint reachable signature for: " << *cs.getInstruction() << "\n"); FlowRecord exp(false,ctxt,ctxt); FlowRecord imp(true,ctxt,ctxt); // implicit from the pc of the call site and the function pointer imp.addSourceValue(*cs->getParent()); imp.addSourceValue(*cs.getCalledValue()); // Sources and sinks of the args for (ImmutableCallSite::arg_iterator arg = cs.arg_begin(), end = cs.arg_end(); arg != end; ++arg) { // every argument's value is a source exp.addSourceValue(**arg); // if the argument is a pointer, everything it reaches is a source // and everything it reaches is a sink if ((*arg)->getType()->isPointerTy()) { exp.addSourceReachablePtr(**arg); imp.addSourceValue(**arg); exp.addSinkReachablePtr(**arg); imp.addSinkReachablePtr(**arg); } } // if the function has a return value it is a sink if (!cs->getType()->isVoidTy()) { imp.addSinkValue(*cs.getInstruction()); exp.addSinkValue(*cs.getInstruction()); } std::vector<FlowRecord> flows; flows.push_back(imp); flows.push_back(exp); return flows; }
std::vector<FlowRecord> OverflowChecks::process(const ContextID ctxt, const ImmutableCallSite cs) const { DEBUG(errs() << "Using OverflowChecks signature...\n"); FlowRecord exp(false,ctxt,ctxt); FlowRecord imp(true,ctxt,ctxt); imp.addSourceValue(*cs->getParent()); // Add all argument values as sources for (ImmutableCallSite::arg_iterator arg = cs.arg_begin(), end = cs.arg_end(); arg != end; ++arg) exp.addSourceValue(**arg); assert(!cs->getType()->isVoidTy() && "Found 'void' overflow check?"); // And the return value as a sink exp.addSinkValue(*cs.getInstruction()); imp.addSinkValue(*cs.getInstruction()); std::vector<FlowRecord> flows; flows.push_back(imp); flows.push_back(exp); return flows; }
smt_astt smt_convt::overflow_arith(const expr2tc &expr) { // If in integer mode, this is completely pointless. Return false. if (int_encoding) return mk_smt_bool(false); const overflow2t &overflow = to_overflow2t(expr); const arith_2ops &opers = static_cast<const arith_2ops &>(*overflow.operand); assert(opers.side_1->type == opers.side_2->type); constant_int2tc zero(opers.side_1->type, BigInt(0)); lessthan2tc op1neg(opers.side_1, zero); lessthan2tc op2neg(opers.side_2, zero); equality2tc op1iszero(opers.side_1, zero); equality2tc op2iszero(opers.side_2, zero); or2tc containszero(op1iszero, op2iszero); // Guess whether we're performing a signed or unsigned comparison. bool is_signed = (is_signedbv_type(opers.side_1) || is_signedbv_type(opers.side_2)); if (is_add2t(overflow.operand)) { if (is_signed) { // Two cases: pos/pos, and neg/neg, which can over and underflow resp. // In pos/neg cases, no overflow or underflow is possible, for any value. constant_int2tc zero(opers.side_1->type, BigInt(0)); lessthan2tc op1pos(zero, opers.side_1); lessthan2tc op2pos(zero, opers.side_2); and2tc both_pos(op1pos, op2pos); not2tc negop1(op1pos); not2tc negop2(op2pos); and2tc both_neg(negop1, negop2); implies2tc nooverflow(both_pos, greaterthanequal2tc(overflow.operand, zero)); implies2tc nounderflow(both_neg, lessthanequal2tc(overflow.operand, zero)); return convert_ast(not2tc(and2tc(nooverflow, nounderflow))); } else { // Just ensure the result is >= both operands. greaterthanequal2tc ge1(overflow.operand, opers.side_1); greaterthanequal2tc ge2(overflow.operand, opers.side_2); and2tc res(ge1, ge2); not2tc inv(res); return convert_ast(inv); } } else if (is_sub2t(overflow.operand)) { if (is_signed) { // Convert to be an addition neg2tc negop2(opers.side_2->type, opers.side_2); add2tc anadd(opers.side_1->type, opers.side_1, negop2); expr2tc add_overflows(new overflow2t(anadd)); // Corner case: subtracting MIN_INT from many things overflows. The result // should always be positive. constant_int2tc zero(opers.side_1->type, BigInt(0)); uint64_t topbit = 1ULL << (opers.side_1->type->get_width() - 1); constant_int2tc min_int(opers.side_1->type, BigInt(topbit)); equality2tc is_min_int(min_int, opers.side_2); implies2tc imp(is_min_int, greaterthan2tc(overflow.operand, zero)); return convert_ast(or2tc(add_overflows, is_min_int)); } else { // Just ensure the result is >= the operands. lessthanequal2tc le1(overflow.operand, opers.side_1); lessthanequal2tc le2(overflow.operand, opers.side_2); and2tc res(le1, le2); not2tc inv(res); return convert_ast(inv); } } else { assert(is_mul2t(overflow.operand) && "unexpected overflow_arith operand"); // Zero extend; multiply; Make a decision based on the top half. unsigned int sz = zero->type->get_width(); smt_sortt boolsort = boolean_sort; smt_sortt normalsort = mk_sort(SMT_SORT_BV, sz, false); smt_sortt bigsort = mk_sort(SMT_SORT_BV, sz * 2, false); // All one bit vector is tricky, might be 64 bits wide for all we know. constant_int2tc allonesexpr(zero->type, BigInt((sz == 64) ? 0xFFFFFFFFFFFFFFFFULL : ((1ULL << sz) - 1))); smt_astt allonesvector = convert_ast(allonesexpr); smt_astt arg1_ext, arg2_ext; if (is_signed) { // sign extend top bits. arg1_ext = convert_ast(opers.side_1); arg1_ext = convert_sign_ext(arg1_ext, bigsort, sz - 1, sz); arg2_ext = convert_ast(opers.side_2); arg2_ext = convert_sign_ext(arg2_ext, bigsort, sz - 1, sz); } else { // Zero extend the top parts arg1_ext = convert_ast(opers.side_1); arg1_ext = convert_zero_ext(arg1_ext, bigsort, sz); arg2_ext = convert_ast(opers.side_2); arg2_ext = convert_zero_ext(arg2_ext, bigsort, sz); } smt_astt result = mk_func_app(bigsort, SMT_FUNC_BVMUL, arg1_ext, arg2_ext); // Extract top half. smt_astt toppart = mk_extract(result, (sz * 2) - 1, sz, normalsort); if (is_signed) { // It should either be zero or all one's; which depends on what // configuration of signs it had. If both pos / both neg, then the top // should all be zeros, otherwise all ones. Implement with xor. smt_astt op1neg_ast = convert_ast(op1neg); smt_astt op2neg_ast = convert_ast(op2neg); smt_astt allonescond = mk_func_app(boolsort, SMT_FUNC_XOR, op1neg_ast, op2neg_ast); smt_astt zerovector = convert_ast(zero); smt_astt initial_switch = mk_func_app(normalsort, SMT_FUNC_ITE, allonescond, allonesvector, zerovector); // either value being zero means the top must be zero. smt_astt contains_zero_ast = convert_ast(containszero); smt_astt second_switch = mk_func_app(normalsort, SMT_FUNC_ITE, contains_zero_ast, zerovector, initial_switch); smt_astt is_eq = mk_func_app(boolsort, SMT_FUNC_EQ, second_switch, toppart); return mk_func_app(boolsort, SMT_FUNC_NOT, &is_eq, 1); } else { // It should be zero; if not, overflow smt_astt iseq = mk_func_app(boolsort, SMT_FUNC_EQ, toppart, convert_ast(zero)); return mk_func_app(boolsort, SMT_FUNC_NOT, &iseq, 1); } } return NULL; }
/** Updates skidding status. * \param dt Time step size. * \param is_on_ground True if the kart is on ground. * \param steering Raw steering of the kart [-1,1], i.e. not adjusted by * the kart's max steering angle. * \param skidding True if the skid button is pressed. */ void Skidding::update(float dt, bool is_on_ground, float steering, KartControl::SkidControl skidding) { // If a kart animation is shown, stop all skidding bonuses. if(m_kart->getKartAnimation()) { reset(); return; } m_skid_bonus_ready = false; if (is_on_ground) { if((fabs(steering) > 0.001f) && m_kart->getSpeed()>m_min_skid_speed && (skidding==KartControl::SC_LEFT||skidding==KartControl::SC_RIGHT)) { m_skid_factor += m_skid_increase *dt/m_time_till_max_skid; } else if(m_skid_factor>1.0f) { m_skid_factor *= m_skid_decrease; } } else { m_skid_factor = 1.0f; // Lose any skid factor as soon as we fly } if(m_skid_factor>m_skid_max) m_skid_factor = m_skid_max; else if(m_skid_factor<1.0f) m_skid_factor = 1.0f; // FIXME hiker: remove once the new skidding code is finished. if(m_skid_state == SKID_OLD) { updateSteering(steering, dt); return; } // If skidding was started and a graphical jump should still // be displayed, update the data if(m_remaining_jump_time>0) { m_jump_speed -= World::getWorld()->getTrack()->getGravity()*dt; m_gfx_jump_offset += m_jump_speed * dt; m_remaining_jump_time -= dt; if(m_remaining_jump_time<0) { m_remaining_jump_time = 0.0f; m_gfx_jump_offset = 0.0f; } } // This is only reached if the new skidding is enabled // --------------------------------------------------- // There are four distinct states related to skidding, controlled // by m_skid_state: // SKID_NONE: no skidding is happening. From here SKID_ACCUMULATE // is reached when the skid key is pressed. // SKID_ACCUMULATE_{LEFT,RIGHT}: // The kart is still skidding. The skidding time will be // accumulated in m_skid_time, and once the minimum time for a // bonus is reached, the "bonus gfx now available" gfx is shown. // If the skid button is not pressed anymore, this will trigger // a potential bonus. Also the rotation of the physical body to // be in synch with the graphical kart is started (which is // independently handled in the kart physics). // SKID_SHOW_GFX_{LEFT<RIGHT} // Shows the skidding gfx while the bonus is available. // FIXME: what should we do if skid key is pressed while still in // SKID_SHOW_GFX??? Adjusting the body rotation is difficult. // For now skidding will only start again once SKID_SHOW_GFX // is changed to SKID_NONE. switch(m_skid_state) { case SKID_NONE: { if(skidding!=KartControl::SC_LEFT && skidding!=KartControl::SC_RIGHT) break; // Don't allow skidding while the kart is (apparently) // still in the air, or when the kart is too slow if(m_remaining_jump_time>0 || m_kart->getSpeed() <m_min_skid_speed) break; m_skid_state = skidding==KartControl::SC_RIGHT ? SKID_ACCUMULATE_RIGHT : SKID_ACCUMULATE_LEFT; // Add a little jump to the kart. Determine the vertical speed // necessary for the kart to go 0.5*jump_time up (then it needs // the same time to come down again), based on v = gravity * t. // Then use this speed to determine the impulse necessary to // reach this speed. float v = World::getWorld()->getTrack()->getGravity() * 0.5f*m_physical_jump_time; btVector3 imp(0, v / m_kart->getBody()->getInvMass(),0); m_kart->getVehicle()->getRigidBody()->applyCentralImpulse(imp); // Some karts might use a graphical-only jump. Set it up: m_jump_speed = World::getWorld()->getTrack()->getGravity() * 0.5f*m_graphical_jump_time; m_remaining_jump_time = m_graphical_jump_time; #ifdef SKID_DEBUG #define SPEED 20.0f updateSteering(steering, dt); m_actual_curve->clear(); m_actual_curve->setVisible(true); m_predicted_curve->clear(); m_predicted_curve->setVisible(true); m_predicted_curve->setPosition(m_kart->getXYZ()); m_predicted_curve->setHeading(m_kart->getHeading()); float angle = m_kart->getKartProperties() ->getMaxSteerAngle(m_kart->getSpeed()) * fabsf(getSteeringFraction()); angle = m_kart->getKartProperties() ->getMaxSteerAngle(SPEED) * fabsf(getSteeringFraction()); float r = m_kart->getKartProperties()->getWheelBase() / asin(angle)*1.0f; const int num_steps = 50; float dx = 2*r / num_steps; for(float x = 0; x <=2*r; x+=dx) { float real_x = m_skid_state==SKID_ACCUMULATE_LEFT ? -x : x; Vec3 xyz(real_x, 0.2f, sqrt(r*r-(r-x)*(r-x))*(1.0f+SPEED/150.0f) *(1+(angle/m_kart->getKartProperties()->getMaxSteerAngle(SPEED)-0.6f)*0.1f)); Vec3 xyz1=m_kart->getTrans()(xyz); printf("predict %f %f %f speed %f angle %f\n", xyz1.getX(), xyz1.getY(), xyz1.getZ(), m_kart->getSpeed(), angle); m_predicted_curve->addPoint(xyz); } #endif m_skid_time = 0; // fallthrough } case SKID_ACCUMULATE_LEFT: case SKID_ACCUMULATE_RIGHT: { #ifdef SKID_DEBUG Vec3 v=m_kart->getVelocity(); if(v.length()>5) { float r = SPEED/sqrt(v.getX()*v.getX() + v.getZ()*v.getZ()); v.setX(v.getX()*r); v.setZ(v.getZ()*r); m_kart->getBody()->setLinearVelocity(v); } m_actual_curve->addPoint(m_kart->getXYZ()); printf("actual %f %f %f turn %f speed %f angle %f\n", m_kart->getXYZ().getX(),m_kart->getXYZ().getY(),m_kart->getXYZ().getZ(), m_real_steering, m_kart->getSpeed(), m_kart->getKartProperties()->getMaxSteerAngle(m_kart->getSpeed())); #endif m_skid_time += dt; float bonus_time, bonus_speed, bonus_force; unsigned int level = getSkidBonus(&bonus_time, &bonus_speed, &bonus_force); // If at least level 1 bonus is reached, show appropriate gfx if(level>0) { m_skid_bonus_ready = true; m_kart->getKartGFX()->setSkidLevel(level); } // If player stops skidding, trigger bonus, and change state to // SKID_SHOW_GFX_* if(skidding == KartControl::SC_NONE) { m_skid_state = m_skid_state == SKID_ACCUMULATE_LEFT ? SKID_SHOW_GFX_LEFT : SKID_SHOW_GFX_RIGHT; float t = std::min(m_skid_time, m_skid_visual_time); t = std::min(t, m_skid_revert_visual_time); float vso = getVisualSkidRotation(); btVector3 rot(0, vso*m_post_skid_rotate_factor, 0); m_kart->getVehicle()->setTimedRotation(t, rot); // skid_time is used to count backwards for the GFX m_skid_time = t; if(bonus_time>0) { m_kart->getKartGFX() ->setCreationRateRelative(KartGFX::KGFX_SKID, 1.0f); m_kart->m_max_speed-> instantSpeedIncrease(MaxSpeed::MS_INCREASE_SKIDDING, bonus_speed, bonus_speed, bonus_force, bonus_time, /*fade-out-time*/ 1.0f); } else m_kart->getKartGFX() ->setCreationRateAbsolute(KartGFX::KGFX_SKID, 0); } break; } // case case SKID_SHOW_GFX_LEFT: case SKID_SHOW_GFX_RIGHT: m_skid_time -= dt; if(m_skid_time<=0) { m_skid_time = 0; m_kart->getKartGFX() ->setCreationRateAbsolute(KartGFX::KGFX_SKID, 0); m_skid_state = SKID_NONE; } } // switch updateSteering(steering, dt); } // update
pss_select::pss_select(const expr_list &list) : expr(list) { imp().ptr()->setOp(ExprImp::GraphSelect); }