void CmpProjectileWeaponUsable::use() { if(m_timeTillCanFire == 0) { // Determine the character which is firing the projectile (the owner of the weapon). ICmpOwnable_CPtr cmpOwnable = m_objectManager->get_component(m_objectID, cmpOwnable); ObjectID firer = cmpOwnable->owner(); if(!firer.valid()) throw Exception("Can't use a projectile weapon when it's not owned"); // Check that there's enough ammo. ICmpInventory_Ptr cmpFirerInventory = m_objectManager->get_component(firer, cmpFirerInventory); if(!cmpFirerInventory) throw Exception("The firer must have an inventory component"); if(cmpFirerInventory->consumables_count(m_ammoType) > 0) { // Fire a bullet from each hotspot of the weapon (note that this in principle makes it easy to implement things like double-barrelled shotguns). const std::vector<std::string>& spots = hotspots(); for(size_t i=0, size=spots.size(); i<size; ++i) { boost::optional<Vector3d> pos = hotspot_position(spots[i]); boost::optional<Vector3d> ori = hotspot_orientation(spots[i]); if(pos && ori) { ObjectSpecification specification = m_objectManager->get_archetype(m_ammoType); specification.set_component_property("Projectile", "Firer", firer); specification.set_component_property("Simulation", "Position", *pos); specification.set_component_property("Simulation", "Velocity", m_muzzleSpeed * *ori); m_objectManager->queue_for_construction(specification); } } cmpFirerInventory->destroy_consumables(m_ammoType, 1); m_timeTillCanFire = m_firingInterval; } } }
//#################### PUBLIC METHODS #################### Properties CmpScriptedUsable::save() const { Properties properties; properties.set("Group", usable_group()); properties.set("Hotspots", hotspots()); properties.set("Script", m_scriptName); return properties; }
Properties CmpProjectileWeaponUsable::save() const { Properties properties; properties.set("AmmoType", m_ammoType); properties.set("FiringInterval", m_firingInterval); properties.set("Group", usable_group()); properties.set("Hotspots", hotspots()); properties.set("MuzzleSpeed", m_muzzleSpeed); properties.set("TimeTillCanFire", m_timeTillCanFire); return properties; }
void MyWidget::play(){ //check if we are playing. This may mean we must pause if (playing) { playing = false; b_play->setText("Play"); return; } //never play an empty file if (list->size() == 0) { return; } QPainter p1; QImage pic; int count = frameIndex-1; status->setText("Calculating"); //find everything there is to know about the person in the video hotspots(); status->setText("Playing"); //initial start time double cur = clock(); playing = true; b_play->setText("Pause"); //move through all the frames while (frameIndex < list->size() && playing) { count++; //load a picture loadPic(pic,frameIndex); //do all tracking tracker->trackFrame(pic,frameIndex,edge_t,skin_t,l_algo->currentText()); //to make sure the frame rate is constant while ( (clock() - cur)/CLOCKS_PER_SEC*100 < fps){} //draw the frame p1.begin(this); p1.drawPixmap(0,0,pic); p1.end(); //get the time now cur = clock(); //next frame frameIndex++; s_frame->setValue(count); qApp->processEvents(); } //check how we stopped playing if (playing) { b_play->setText("Play"); frameIndex = 1; status->setText("Stopped"); } else { status->setText("Paused"); } playing = false; }
TrafficPattern * TrafficPattern::New(string const & pattern, int nodes) { string pattern_name; string param_str; size_t left = pattern.find_first_of('('); if(left == string::npos) { pattern_name = pattern; } else { pattern_name = pattern.substr(0, left); size_t right = pattern.find_last_of(')'); if(right == string::npos) { param_str = pattern.substr(left+1); } else { param_str = pattern.substr(left+1, right-left-1); } } vector<string> params = tokenize(param_str); TrafficPattern * result = NULL; if(pattern_name == "bitcomp") { result = new BitCompTrafficPattern(nodes); } else if(pattern_name == "transpose") { result = new TransposeTrafficPattern(nodes); } else if(pattern_name == "bitrev") { result = new BitRevTrafficPattern(nodes); } else if(pattern_name == "shuffle") { result = new ShuffleTrafficPattern(nodes); } else if(pattern_name == "randperm") { int perm_seed = params.empty() ? 0 : atoi(params[0].c_str()); result = new RandomPermutationTrafficPattern(nodes, perm_seed); } else if(pattern_name == "uniform") { result = new UniformRandomTrafficPattern(nodes); } else if(pattern_name == "background") { vector<string> excludes_str = tokenize(params[0]); vector<int> excludes(excludes_str.size()); for(size_t i = 0; i < excludes.size(); ++i) { excludes[i] = atoi(excludes_str[i].c_str()); } result = new UniformBackgroundTrafficPattern(nodes, excludes); } else if(pattern_name == "diagonal") { result = new DiagonalTrafficPattern(nodes); } else if(pattern_name == "asymmetric") { result = new AsymmetricTrafficPattern(nodes); } else if(pattern_name == "taper64") { result = new Taper64TrafficPattern(nodes); } else if(pattern_name == "bad_dragon") { if(params.size() < 2) { cout << "Error: Missing parameters for dragonfly bad permutation traffic pattern: " << pattern << endl; exit(-1); } int k = atoi(params[0].c_str()); int n = atoi(params[1].c_str()); result = new BadPermDFlyTrafficPattern(nodes, k, n); } else if((pattern_name == "tornado") || (pattern_name == "neighbor") || (pattern_name == "badperm_yarc")) { if(params.size() < 3) { cout << "Error: Missing parameters for digit permutation traffic pattern: " << pattern << endl; exit(-1); } int k = atoi(params[0].c_str()); int n = atoi(params[1].c_str()); int xr = atoi(params[2].c_str()); if(pattern_name == "tornado") { result = new TornadoTrafficPattern(nodes, k, n, xr); } else if(pattern_name == "neighbor") { result = new NeighborTrafficPattern(nodes, k, n, xr); } else if(pattern_name == "badperm_yarc") { result = new BadPermYarcTrafficPattern(nodes, k, n, xr); } } else if(pattern_name == "hotspot") { if(params.empty()) { cout << "Error: Missing parameter for hotspot traffic pattern: " << pattern << endl; exit(-1); } vector<string> hotspots_str = tokenize(params[0]); vector<int> hotspots(hotspots_str.size()); for(size_t i = 0; i < hotspots.size(); ++i) { hotspots[i] = atoi(hotspots_str[i].c_str()); } vector<int> rates(hotspots.size(), 1); if(params.size() >= 2) { vector<string> rates_str = tokenize(params[1]); rates_str.resize(hotspots.size(), rates_str.back()); for(size_t i = 0; i < rates.size(); ++i) { rates[i] = atoi(rates_str[i].c_str()); } } result = new HotSpotTrafficPattern(nodes, hotspots, rates); } else { cout << "Error: Unknown traffic pattern: " << pattern << endl; exit(-1); } return result; }