/** * Propagate a livery change to a group's children. * @param g Group. */ void PropagateChildLivery(const Group *g) { /* Company colour data is indirectly cached. */ Vehicle *v; FOR_ALL_VEHICLES(v) { if (v->group_id == g->index && (!v->IsGroundVehicle() || v->IsFrontEngine())) { for (Vehicle *u = v; u != nullptr; u = u->Next()) { u->colourmap = PAL_NONE; u->InvalidateNewGRFCache(); } } } Group *cg; FOR_ALL_GROUPS(cg) { if (cg->parent == g->index) { if (!HasBit(cg->livery.in_use, 0)) cg->livery.colour1 = g->livery.colour1; if (!HasBit(cg->livery.in_use, 1)) cg->livery.colour2 = g->livery.colour2; PropagateChildLivery(cg); } } }
bool Controller::AssignFields(templateIO& myArr, std::string type, Vehicle& neededUnit, VehicleGun& newGun) { neededUnit.SetName(myArr.myStringArr[0]); neededUnit.SetArmor(true, 0, myArr.myIntArr[0]); neededUnit.SetArmor(true, 90, myArr.myIntArr[1]); neededUnit.SetArmor(true, 180, myArr.myIntArr[2]); neededUnit.SetArmor(false, 0, myArr.myIntArr[3]); neededUnit.SetArmor(false, 90, myArr.myIntArr[4]); neededUnit.SetArmor(false, 180, myArr.myIntArr[5]); neededUnit.SetBDurability(myArr.myIntArr[6]); neededUnit.SetTDurability(myArr.myIntArr[7]); neededUnit.SetADurability(100); neededUnit.SetTMDurability(100); neededUnit.SetEDurability(100); neededUnit.SetEngineFueled(true); neededUnit.MyGun->SetAmmoType(newGun.GetAmmoType()); neededUnit.MyGun->SetArmorPiercing(newGun.GetArmorPiercing()); neededUnit.MyGun->SetDamage(newGun.GetDamage()); neededUnit.MyGun->SetName(newGun.GetName()); return true; }
void display(void) { glClearColor(1,1,1,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ); convertToView(); glMatrixMode(GL_MODELVIEW); glLoadMatrixf( modelViewMatrix ); glColor4f(1,1,1,1); drawFloor(textures[FLOORID]); drawWalls(textures[WALLID]); //draw the items on the screen glRotatef(angle,0,1,0); //rotate the square //draw the snowman snowman.display(); snowman2.display(); snowman3.display(); //draw the car vehicle.display(translateToThirdPerson, textures[SIRENID], textures[VEHICLEID], firstPersonView, overheadView); //scoreboard sb.setMsg2(msgDamage); //draw the Snowdift snowcave.display(textures[FLOORID]); snowcave2.display(textures[FLOORID]); //pond display pond.display(textures[PONDID],textures[WATERID]); //gifts //for (int i=0; i<giftCount;i++) // gifts[i].display(); glPushMatrix(); for (int i=0; i<giftCount;i++) gifts[i].display(); glPopMatrix(); // Tractor Beam Function pullInObject(); glPopMatrix(); //ScoreBoard() glPushMatrix(); glLoadIdentity(); if(!overheadView) glTranslatef(sbOrigin.x,sbOrigin.y,sbOrigin.z); else glTranslatef(0,0,-40); sb.display(overheadView); glPopMatrix(); drawCieling(); npc.display(textures[FLOORID]); //draw the snowballs in flight displayProjectiles(); glFlush(); glutSwapBuffers(); }
void keyBoard( unsigned char key, int x, int y ) { static int angle =0; if(!gameInPlay) return; switch( key ) { case ' ': vehicle.setSpeed(vehicle.getSpeed() + 0.06f); break; case 0: vehicle.setSpeed(-vehicle.getSpeed()); break; case 'i': firstPersonRotate.x+=0.2; break; case 'I': firstPersonRotate.x-=0.2; break; case 'w': firstPersonRotate.z+=0.2; break; case 'W': firstPersonRotate.z-=0.2; break; case 'a': translate(1,0,0); break; case 'd': translate(-1,0,0); break; case 's': translate(0,-1,0); break; case 'S': translate(0,1,0); break; case 'x': shadowx++; //translate(1,0,0); break; case 'X': shadowx--; //translate(1,0,0); break; case 'z': //translate(0,0,1); shadowz++; break; case 'Z': //translate(0,0,1); shadowz--; break; case 'y': //translate(0,0,1); shadowy++; break; case 'Y': //translate(0,0,1); shadowy--; break; case 'p': //currMap.printState(); currMap.printState(); break; } vehicle.shadowX=shadowx; vehicle.shadowY=shadowy; vehicle.shadowZ=shadowz; //cout <<" firstPersonRotate = "<<firstPersonRotate.x<<","<<firstPersonRotate.y<<","<<firstPersonRotate.z<<endl; //cout <<"Shadow "<<shadowx<<" ,"<<shadowy<<","<<shadowz<<endl; //translateToThirdPerson.x += shadowx; //translateToThirdPerson.y +=shadowy; translateToThirdPerson.y +=shadowz; display(); }
/** * Loads the craft from a YAML file. * @param node YAML node. * @param mod Mod for the saved game. * @param save Pointer to the saved game. */ void Craft::load(const YAML::Node &node, const Mod *mod, SavedGame *save) { MovingTarget::load(node); _id = node["id"].as<int>(_id); _fuel = node["fuel"].as<int>(_fuel); _damage = node["damage"].as<int>(_damage); size_t j = 0; for (YAML::const_iterator i = node["weapons"].begin(); i != node["weapons"].end(); ++i) { if (_rules->getWeapons() > j) { std::string type = (*i)["type"].as<std::string>(); if (type != "0" && mod->getCraftWeapon(type)) { CraftWeapon *w = new CraftWeapon(mod->getCraftWeapon(type), 0); w->load(*i); _weapons[j] = w; } else { _weapons[j] = 0; } j++; } } _items->load(node["items"]); for (std::map<std::string, int>::iterator i = _items->getContents()->begin(); i != _items->getContents()->end();) { if (std::find(mod->getItemsList().begin(), mod->getItemsList().end(), i->first) == mod->getItemsList().end()) { _items->getContents()->erase(i++); } else { ++i; } } for (YAML::const_iterator i = node["vehicles"].begin(); i != node["vehicles"].end(); ++i) { std::string type = (*i)["type"].as<std::string>(); if (mod->getItem(type)) { Vehicle *v = new Vehicle(mod->getItem(type), 0, 4); v->load(*i); _vehicles.push_back(v); } } _status = node["status"].as<std::string>(_status); _lowFuel = node["lowFuel"].as<bool>(_lowFuel); _mission = node["mission"].as<bool>(_mission); _interceptionOrder = node["interceptionOrder"].as<int>(_interceptionOrder); if (const YAML::Node name = node["name"]) { _name = Language::utf8ToWstr(name.as<std::string>()); } if (const YAML::Node &dest = node["dest"]) { std::string type = dest["type"].as<std::string>(); int id = dest["id"].as<int>(); if (type == "STR_BASE") { returnToBase(); } else if (type == "STR_UFO") { for (std::vector<Ufo*>::iterator i = save->getUfos()->begin(); i != save->getUfos()->end(); ++i) { if ((*i)->getId() == id) { setDestination(*i); break; } } } else if (type == "STR_WAYPOINT") { for (std::vector<Waypoint*>::iterator i = save->getWaypoints()->begin(); i != save->getWaypoints()->end(); ++i) { if ((*i)->getId() == id) { setDestination(*i); break; } } } else if (type == "STR_ALIEN_BASE") { for (std::vector<AlienBase*>::iterator i = save->getAlienBases()->begin(); i != save->getAlienBases()->end(); ++i) { if ((*i)->getId() == id) { setDestination(*i); break; } } } else { // Backwards compatibility if (type == "STR_ALIEN_TERROR") type = "STR_TERROR_SITE"; for (std::vector<MissionSite*>::iterator i = save->getMissionSites()->begin(); i != save->getMissionSites()->end(); ++i) { if ((*i)->getId() == id && (*i)->getDeployment()->getMarkerName() == type) { setDestination(*i); break; } } } } _takeoff = node["takeoff"].as<int>(_takeoff); _inBattlescape = node["inBattlescape"].as<bool>(_inBattlescape); if (_inBattlescape) setSpeed(0); }
void UpdateAI(const uint32 uiDiff) { npc_escortAI::UpdateAI(uiDiff); if (!UpdateVictim()) return; if (uiBuffTimer <= uiDiff) { if (!me->HasAura(SPELL_SHIELD)) DoCastSpellShield(); uiBuffTimer = urand(30000, 45000); }else uiBuffTimer -= uiDiff; if (uiChargeTimer <= uiDiff) { Map::PlayerList const& players = me->GetMap()->GetPlayers(); if (me->GetMap()->IsDungeon() && !players.isEmpty()) { for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr) { Player* player = itr->getSource(); if (player && !player->isGameMaster() && me->IsInRange(player, 8.0f, 25.0f, false)) { DoResetThreat(); me->AddThreat(player, 1.0f); DoCast(player, SPELL_CHARGE); break; } } } uiChargeTimer = 5000; }else uiChargeTimer -= uiDiff; //dosen't work at all if (uiShieldBreakerTimer <= uiDiff) { Vehicle* vehicle = me->GetVehicleKit(); if (!vehicle) return; if (Unit* pPassenger = vehicle->GetPassenger(SEAT_ID_0)) { Map::PlayerList const& players = me->GetMap()->GetPlayers(); if (me->GetMap()->IsDungeon() && !players.isEmpty()) { for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr) { Player* player = itr->getSource(); if (player && !player->isGameMaster() && me->IsInRange(player, 10.0f, 30.0f, false)) { pPassenger->CastSpell(player, SPELL_SHIELD_BREAKER, true); break; } } } } uiShieldBreakerTimer = 7000; }else uiShieldBreakerTimer -= uiDiff; DoMeleeAttackIfReady(); }
void SSControlSurf::UpdateDrawObjs() { SubSurface::UpdateDrawObjs(); Vehicle* veh = VehicleMgr.GetVehicle(); if ( !veh ) { return; } Geom* geom = veh->FindGeom( m_CompID ); if ( geom ) { vector< VspSurf > surf_vec; geom->GetSurfVec( surf_vec ); int ncopy = geom->GetNumSymmCopies(); m_HingeDO.m_PntVec.clear(); m_HingeDO.m_LineWidth = 2.0; m_HingeDO.m_Type = DrawObj::VSP_LINES; m_HingeDO.m_GeomID = m_ID + string( "_ss_hinge" ); m_HingeDO.m_GeomChanged = true; m_ArrowDO.m_PntVec.clear(); m_ArrowDO.m_Type = DrawObj::VSP_SHADED_TRIS; m_ArrowDO.m_GeomID = m_ID + string( "_ss_arrow" ); m_ArrowDO.m_GeomChanged = true; for ( int i = 0; i < 4; i++ ) { m_ArrowDO.m_MaterialInfo.Ambient[i] = 0.2; m_ArrowDO.m_MaterialInfo.Diffuse[i] = 0.1; m_ArrowDO.m_MaterialInfo.Specular[i] = 0.7; m_ArrowDO.m_MaterialInfo.Emission[i] = 0.0; } m_ArrowDO.m_MaterialInfo.Diffuse[3] = 0.5; m_ArrowDO.m_MaterialInfo.Shininess = 5.0; int isurf = m_MainSurfIndx(); vector < int > symms = geom->GetSymmIndexs( isurf ); assert( ncopy == symms.size() ); int npt = m_UWStart.size(); for ( int s = 0 ; s < ncopy ; s++ ) { VspSurf* surf = &( surf_vec[ symms[ s ] ] ); vec3d pst, pend; for ( int i = 0; i < npt; i++ ) { pst = pst + surf->CompPnt01( m_UWStart[i].x(), m_UWStart[i].y() ); pend = pend + surf->CompPnt01( m_UWEnd[i].x(), m_UWEnd[i].y() ); } pst = pst / ( 1.0 * npt ); pend = pend / ( 1.0 * npt ); vec3d pmid = ( pst + pend ) * 0.5; vec3d dir = pend - pst; double len = dir.mag(); dir.normalize(); m_HingeDO.m_PntVec.push_back( pst ); m_HingeDO.m_PntVec.push_back( pend ); MakeCircleArrow( pmid, dir, 0.25, m_HingeDO, m_ArrowDO ); } m_ArrowDO.m_NormVec = vector <vec3d> ( m_ArrowDO.m_PntVec.size() ); } }
//-------------------------------------------------------------- void testApp::mouseDragged(int x, int y, int button){ Vehicle v; v.setup(mouseX, mouseY); vehicles.push_back(v); }
/** * Check the validity of some of the caches. * Especially in the sense of desyncs between * the cached value and what the value would * be when calculated from the 'base' data. */ static void CheckCaches() { /* Return here so it is easy to add checks that are run * always to aid testing of caches. */ if (_debug_desync_level <= 1) return; /* Check the town caches. */ SmallVector<TownCache, 4> old_town_caches; Town *t; FOR_ALL_TOWNS(t) { MemCpyT(old_town_caches.Append(), &t->cache); } extern void RebuildTownCaches(); RebuildTownCaches(); RebuildSubsidisedSourceAndDestinationCache(); uint i = 0; FOR_ALL_TOWNS(t) { if (MemCmpT(old_town_caches.Get(i), &t->cache) != 0) { DEBUG(desync, 2, "town cache mismatch: town %i", (int)t->index); } i++; } /* Check company infrastructure cache. */ SmallVector<CompanyInfrastructure, 4> old_infrastructure; Company *c; FOR_ALL_COMPANIES(c) MemCpyT(old_infrastructure.Append(), &c->infrastructure); extern void AfterLoadCompanyStats(); AfterLoadCompanyStats(); i = 0; FOR_ALL_COMPANIES(c) { if (MemCmpT(old_infrastructure.Get(i), &c->infrastructure) != 0) { DEBUG(desync, 2, "infrastructure cache mismatch: company %i", (int)c->index); } i++; } /* Strict checking of the road stop cache entries */ const RoadStop *rs; FOR_ALL_ROADSTOPS(rs) { if (IsStandardRoadStopTile(rs->xy)) continue; assert(rs->GetEntry(DIAGDIR_NE) != rs->GetEntry(DIAGDIR_NW)); rs->GetEntry(DIAGDIR_NE)->CheckIntegrity(rs); rs->GetEntry(DIAGDIR_NW)->CheckIntegrity(rs); } Vehicle *v; FOR_ALL_VEHICLES(v) { extern void FillNewGRFVehicleCache(const Vehicle *v); if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue; uint length = 0; for (const Vehicle *u = v; u != NULL; u = u->Next()) length++; NewGRFCache *grf_cache = CallocT<NewGRFCache>(length); VehicleCache *veh_cache = CallocT<VehicleCache>(length); GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length); TrainCache *tra_cache = CallocT<TrainCache>(length); length = 0; for (const Vehicle *u = v; u != NULL; u = u->Next()) { FillNewGRFVehicleCache(u); grf_cache[length] = u->grf_cache; veh_cache[length] = u->vcache; switch (u->type) { case VEH_TRAIN: gro_cache[length] = Train::From(u)->gcache; tra_cache[length] = Train::From(u)->tcache; break; case VEH_ROAD: gro_cache[length] = RoadVehicle::From(u)->gcache; break; default: break; } length++; } switch (v->type) { case VEH_TRAIN: Train::From(v)->ConsistChanged(CCF_TRACK); break; case VEH_ROAD: RoadVehUpdateCache(RoadVehicle::From(v)); break; case VEH_AIRCRAFT: UpdateAircraftCache(Aircraft::From(v)); break; case VEH_SHIP: Ship::From(v)->UpdateCache(); break; default: break; } length = 0; for (const Vehicle *u = v; u != NULL; u = u->Next()) { FillNewGRFVehicleCache(u); if (memcmp(&grf_cache[length], &u->grf_cache, sizeof(NewGRFCache)) != 0) { DEBUG(desync, 2, "newgrf cache mismatch: type %i, vehicle %i, company %i, unit number %i, wagon %i", (int)v->type, v->index, (int)v->owner, v->unitnumber, length); } if (memcmp(&veh_cache[length], &u->vcache, sizeof(VehicleCache)) != 0) { DEBUG(desync, 2, "vehicle cache mismatch: type %i, vehicle %i, company %i, unit number %i, wagon %i", (int)v->type, v->index, (int)v->owner, v->unitnumber, length); } switch (u->type) { case VEH_TRAIN: if (memcmp(&gro_cache[length], &Train::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) { DEBUG(desync, 2, "train ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length); } if (memcmp(&tra_cache[length], &Train::From(u)->tcache, sizeof(TrainCache)) != 0) { DEBUG(desync, 2, "train cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length); } break; case VEH_ROAD: if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) { DEBUG(desync, 2, "road vehicle ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length); } break; default: break; } length++; } free(grf_cache); free(veh_cache); free(gro_cache); free(tra_cache); } /* Check whether the caches are still valid */ FOR_ALL_VEHICLES(v) { byte buff[sizeof(VehicleCargoList)]; memcpy(buff, &v->cargo, sizeof(VehicleCargoList)); v->cargo.InvalidateCache(); assert(memcmp(&v->cargo, buff, sizeof(VehicleCargoList)) == 0); } Station *st; FOR_ALL_STATIONS(st) { for (CargoID c = 0; c < NUM_CARGO; c++) { byte buff[sizeof(StationCargoList)]; memcpy(buff, &st->goods[c].cargo, sizeof(StationCargoList)); st->goods[c].cargo.InvalidateCache(); assert(memcmp(&st->goods[c].cargo, buff, sizeof(StationCargoList)) == 0); } } }
void CFAPI::updateFollowerAcclr(int step, double time, Vehicle& veh, Vehicle predVeh) { // Followers controlled by car follow model. // Create a new vehicle state with same state as current vehicle. // Acclr for new state is calculated here. Position and velocity // will be calculated in future when time = currTime + reactionTime; Vehicle followerNewState(veh.getId(), veh.getPosX(), veh.getVel(), veh.getAcclr(), veh.getHdwayTime(), veh.hasSafetyDev(), veh.getSafetyDevStartTime()); double newAcclr = 0.0; double newHdwayTime = 0.0; if((veh.hasSafetyDev()) && (time >= veh.getSafetyDevStartTime())) { if(m_adjHdwayTime == HDWAY_SAFE) { newAcclr = m_cfModel->getAcclrRespInNetSafe(time, veh, predVeh, newHdwayTime); } else { newAcclr = m_cfModel->getAcclrRespInNetResume(time, veh, predVeh, newHdwayTime); } std::cout << "Recv safety message: Veh: " << veh.getId() << " at time " << time << std::endl; } else { newAcclr = m_cfModel->getAcclrResp(time, veh, predVeh, newHdwayTime); } // Adjust for unrealistic acclr and decclr values if(newAcclr > ACCLR_LIMIT) { newAcclr = ACCLR_LIMIT; } if(newAcclr < DECCLR_LIMIT) { newAcclr = DECCLR_LIMIT; } std::cout << "Next Acclr: Veh " << veh.getId() << " acclr " << newAcclr << std::endl; followerNewState.setAcclr(newAcclr); followerNewState.setHdwayTime(newHdwayTime); m_vehStateTable[step + m_factor].push_back(followerNewState); }
//==== Parm Changed ====// void LinkMgrSingleton::ParmChanged( const string& pid, bool start_flag ) { //==== Find Parm Ptr ===// Parm* parm_ptr = ParmMgr.FindParm( pid ); if ( !parm_ptr ) return; //==== Check For Advanced Links ====// bool adv_link_flag = AdvLinkMgr.IsInputParm( pid ); //==== Look for Reg Links ====// vector < Link* > parm_link_vec; for ( int i = 0 ; i < ( int )m_LinkVec.size() ; i++ ) { if ( m_LinkVec[i]->GetParmA() == pid ) { parm_link_vec.push_back( m_LinkVec[i] ); } } //==== Check Links ====// bool reg_link_flag = false; if ( parm_link_vec.size() ) { reg_link_flag = true; } //==== Abort if No Links ====// if ( !adv_link_flag && !reg_link_flag ) return; //==== Set Link Update Flag ====// parm_ptr->SetLinkUpdateFlag( true ); m_UpdatedParmVec.push_back( parm_ptr->GetID() ); //==== Update Linked Parms ====// for ( int i = 0 ; i < ( int )parm_link_vec.size() ; i++ ) { Link* pl = parm_link_vec[i]; Parm* pB = ParmMgr.FindParm( pl->GetParmB() ); if ( pB && ! pB->GetLinkUpdateFlag() ) // Prevent Circular { double offset = 0.0; if ( pl->GetOffsetFlag() ) { offset = pl->m_Offset(); } double scale = 1.0; if ( pl->GetScaleFlag() ) { scale = pl->m_Scale(); } double val = parm_ptr->Get() * scale + offset; if ( pl->GetLowerLimitFlag() && val < pl->m_LowerLimit() ) // Constraints { val = pl->m_LowerLimit(); } if ( pl->GetUpperLimitFlag() && val > pl->m_UpperLimit() ) // Constraints { val = pl->m_UpperLimit(); } pB->SetFromLink( val ); } } //==== Update Adv Link ===// if ( adv_link_flag ) { AdvLinkMgr.UpdateLinks( pid ); } //==== Clean Up ====/ if ( start_flag ) { for ( int i = 0 ; i < ( int )m_UpdatedParmVec.size() ; i++ ) { Parm* p = ParmMgr.FindParm( m_UpdatedParmVec[i] ); if ( p ) { p->SetLinkUpdateFlag( false ); } } m_UpdatedParmVec.clear(); Vehicle* veh = VehicleMgr.GetVehicle(); if ( veh ) { veh->ParmChanged( parm_ptr, Parm::SET ); } } }
virtual double GetDiscountRate(Vehicle& vehicle) { return vehicle.GetBaseDiscountRate(); }
void option4() { string inSSN; string choice; string test; string inData; Person testUpdatePerson; PersonFile * pPersonFile = new PersonFile; Person * pPerson = new Person; VehicleFile * pVehicleFile = new VehicleFile; Vehicle * pVehicle = new Vehicle; State * pState = new State; County * pCounty = new County; VMake * pVMake = new VMake; Color * pColor = new Color; VType * pVType = new VType; while(true) { PrintHeading4(); getline(cin,inSSN); cin.sync(); if(inSSN[0] == 'q' || inSSN[0] == 'Q') break; *pPerson = pPersonFile->SearchBySSN(inSSN); //Ensuring that the Record does not alrady exist if(pPerson->IsFound() == true || pPerson->IsDeleted()) { cout << "\n\t\t\tRecord for SSN: " << SSNHyphens(inSSN) << " already exists." << endl; test = UserWait(); if(test[0] == 'q' || test[0] =='Q') break; continue; } //This Block only runs if the SSN was not found in the file //SetFound is run so the Person can be displayed as before they are written out pPerson->SetFound(true); pPerson->SetSSN(Trim(inSSN)); while(true) { cout << "\n\n\t\tEnter new OLN: "; getline(cin, inData); cin.sync(); testUpdatePerson = pPersonFile->SearchByOLN(inData); //IsDeleted is included because duplicate OLNs cause issues with SearchByOLN if(testUpdatePerson.IsFound() || testUpdatePerson.IsDeleted()) { cout << "\n\t\tOLN Already Exists in File. Choose Different OLN." << endl; UserWait(); system("clear"); continue; } break; } pPerson->SetOLN(Trim(inData)); cout << "\n\n\t\tEnter new Last Name : "; getline(cin, inData); cin.sync(); pPerson->SetLastName(Trim(inData)); cout << "\n\n\t\tEnter new First Name : "; getline(cin, inData); cin.sync(); pPerson->SetFirstName(Trim(inData)); cout << "\n\n\t\tEnter new Middle Initial: "; getline(cin, inData); cin.sync(); pPerson->SetMI(Trim(inData)); cout << "\n\n\t\tEnter new Street Address: "; getline(cin, inData); cin.sync(); pPerson->SetStreet(Trim(inData)); cout << "\n\n\t\tEnter new City : "; getline(cin, inData); cin.sync(); pPerson->SetCity(Trim(inData)); system("clear"); cout << "\n\t\tNow Displaying Codes for: State"; pState->DisplayStates(); cout << "\n\n\t\tEnter State Code : "; getline(cin, inData); cin.sync(); pPerson->SetStateCode(Trim(inData)); //Only prompts for County if State is Alabama if(pPerson->GetStateCode() != "02") { pPerson->SetCountyCode("00"); } else { system("clear"); cout << "\n\t\tNow Displaying Codes for: County"; pCounty->DisplayCounties(); cout << "\n\n\t\tEnter County Code : "; getline(cin, inData); cin.sync(); pPerson->SetCountyCode(Trim(inData)); } cout << "\n\n\t\tEnter new Zip Code : "; getline(cin, inData); cin.sync(); //Like SSN, the Set takes care of removing hyphens pPerson->SetZip(Trim(inData)); system("clear"); pPerson->DisplayPerson(); cout << "\n\t\tAdd Vehicle for this Record? (Y/N): " << flush; getline(cin, choice); cin.sync(); //Everything in this if block is Populating the Vehicle Record if(choice[0] == 'y' || choice[0] =='Y') { UserInputVehicle(*pPerson, *pVehicle); } system("clear"); pPerson->DisplayPerson(); pVehicle->DisplayVehicle(); cout << "\n\t\tCommit Record to File? (Y/N): " << flush; getline(cin, choice); cin.sync(); if(choice[0] != 'y' && choice[0] !='Y') { cout << "\n\t\tRecord not Committed to File. " << endl; test = UserWait(); if(test[0] == 'q' || test[0] =='Q') break; continue; } pPersonFile->AddPerson(*pPerson); pVehicleFile->AddVehicle(*pVehicle); cout << "\n\t\tRecord Committed to File." << endl; test = UserWait(); if(test[0] == 'q' || test[0] =='Q') break; } delete pPerson; delete pPersonFile; delete pVehicle; delete pVehicleFile; delete pState; delete pCounty; }
void CfdMeshScreen::CallBack( Fl_Widget* w ) { bool update_flag = true; if ( w == m_CfdMeshUI->rigorLimitButton ) { if ( m_CfdMeshUI->rigorLimitButton->value() ) { CfdMeshMgr.GetGridDensityPtr()->SetRigorLimit( true ); } else { CfdMeshMgr.GetGridDensityPtr()->SetRigorLimit( false ); } } else if ( w == m_CfdMeshUI->farMeshButton ) { if ( m_CfdMeshUI->farMeshButton->value() ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarMeshFlag( true ); } else { CfdMeshMgr.GetCfdSettingsPtr()->SetFarMeshFlag( false ); } } else if ( w == m_CfdMeshUI->halfMeshButton ) { if ( m_CfdMeshUI->halfMeshButton->value() ) { CfdMeshMgr.GetCfdSettingsPtr()->SetHalfMeshFlag( true ); } else { CfdMeshMgr.GetCfdSettingsPtr()->SetHalfMeshFlag( false ); } } else if ( w == m_CfdMeshUI->finalMeshButton ) { redirecter redir( std::cout, CfdMeshMgr.m_OutStream ); CfdMeshMgr.GenerateMesh(); // Hide all geoms. Vehicle* veh = m_ScreenMgr->GetVehiclePtr(); veh->HideAll(); } else if ( w == m_CfdMeshUI->addDefaultsButton ) { CfdMeshMgr.AddDefaultSourcesCurrGeom(); } // else if ( m_FarXScaleSlider->GuiChanged( w ) ) // { // double val = m_FarXScaleSlider->GetVal(); // bool change = false; // // if ( CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( false ); // change = true; // } // // CfdMeshMgr.SetFarXScale( val ); // CfdMeshMgr.UpdateDomain(); // char xstr[255]; // sprintf( xstr, "%0.4f", CfdMeshMgr.GetFarLength() ); // cfdMeshUI->farXScaleAbsInput->value(xstr); // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( true ); // // update_flag = false; // } // else if ( m_FarYScaleSlider->GuiChanged( w ) ) // { // double val = m_FarYScaleSlider->GetVal(); // bool change = false; // // if ( CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( false ); // change = true; // } // // CfdMeshMgr.SetFarYScale( val ); // CfdMeshMgr.UpdateDomain(); // char ystr[255]; // sprintf( ystr, "%0.4f", CfdMeshMgr.GetFarWidth() ); // cfdMeshUI->farYScaleAbsInput->value(ystr); // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( true ); // // update_flag = false; // } // else if ( m_FarZScaleSlider->GuiChanged( w ) ) // { // double val = m_FarZScaleSlider->GetVal(); // bool change = false; // // if ( CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( false ); // change = true; // } // // CfdMeshMgr.SetFarZScale( val ); // CfdMeshMgr.UpdateDomain(); // char zstr[255]; // sprintf( zstr, "%0.4f", CfdMeshMgr.GetFarHeight() ); // cfdMeshUI->farZScaleAbsInput->value(zstr); // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( true ); // // update_flag = false; // } // else if ( w == cfdMeshUI->SourceNameInput ) // { // CfdMeshMgr.GUI_Val( "SourceName", cfdMeshUI->SourceNameInput->value() ); // } else if ( w == m_CfdMeshUI->compChoice ) { //==== Load List of Parts for Comp ====// int id = m_CfdMeshUI->compChoice->value(); CfdMeshMgr.SetCurrSourceGeomID( m_GeomVec[ id ] ); CfdMeshMgr.SetCurrMainSurfIndx( 0 ); } else if ( w == m_CfdMeshUI->surfChoice ) { int id = m_CfdMeshUI->surfChoice->value(); CfdMeshMgr.SetCurrMainSurfIndx( id ); } else if ( w == m_CfdMeshUI->wakeCompChoice ) { //==== Load List of Parts for Comp ====// int id = m_CfdMeshUI->wakeCompChoice->value(); CfdMeshMgr.SetWakeGeomID( m_WingGeomVec[ id ] ); } else if ( w == m_CfdMeshUI->farCompChoice ) { //==== Load List of Parts for Comp ====// int id = m_CfdMeshUI->farCompChoice->value(); CfdMeshMgr.GetCfdSettingsPtr()->SetFarGeomID( m_GeomVec[ id ] ); } else if ( w == m_CfdMeshUI->sourceBrowser ) { CfdMeshMgr.GUI_Val( "SourceID", m_CfdMeshUI->sourceBrowser->value() - 1 ); } else if ( w == m_CfdMeshUI->setChoice ) { CfdMeshMgr.GetCfdSettingsPtr()->m_SelectedSetIndex = m_CfdMeshUI->setChoice->value(); } else if ( w == m_CfdMeshUI->addSourceButton ) { int type = m_CfdMeshUI->sourceTypeChoice->value(); if ( type >= 0 && type < vsp::NUM_SOURCE_TYPES ) { CfdMeshMgr.AddSource( type ); } } else if ( w == m_CfdMeshUI->deleteSourceButton ) { CfdMeshMgr.DeleteCurrSource(); } else if ( w == m_CfdMeshUI->adjLenDownButton ) { CfdMeshMgr.AdjustAllSourceLen( 1.0 / 1.1 ); } else if ( w == m_CfdMeshUI->adjLenUpButton ) { CfdMeshMgr.AdjustAllSourceLen( 1.1 ); } else if ( w == m_CfdMeshUI->adjLenDownDownButton ) { CfdMeshMgr.AdjustAllSourceLen( 1.0 / 1.5 ); } else if ( w == m_CfdMeshUI->adjLenUpUpButton ) { CfdMeshMgr.AdjustAllSourceLen( 1.5 ); } else if ( w == m_CfdMeshUI->adjRadDownButton ) { CfdMeshMgr.AdjustAllSourceRad( 1.0 / 1.1 ); } else if ( w == m_CfdMeshUI->adjRadUpButton ) { CfdMeshMgr.AdjustAllSourceRad( 1.1 ); } else if ( w == m_CfdMeshUI->adjRadDownDownButton ) { CfdMeshMgr.AdjustAllSourceRad( 1.0 / 1.5 ); } else if ( w == m_CfdMeshUI->adjRadUpUpButton ) { CfdMeshMgr.AdjustAllSourceRad( 1.5 ); } else if ( w == m_CfdMeshUI->datButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select NASCART .dat file.", "*.dat" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_DAT_FILE_NAME ); } } else if ( w == m_CfdMeshUI->keyButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select NASCART .key file.", "*.key" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_KEY_FILE_NAME ); } } else if ( w == m_CfdMeshUI->objButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .obj file.", "*.obj" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_OBJ_FILE_NAME ); } } else if ( w == m_CfdMeshUI->polyButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .poly file.", "*.poly" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_POLY_FILE_NAME ); } } else if ( w == m_CfdMeshUI->stlButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .stl file.", "*.stl" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_STL_FILE_NAME ); } } else if ( w == m_CfdMeshUI->triButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .tri file.", "*.tri" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_TRI_FILE_NAME ); } } else if ( w == m_CfdMeshUI->gmshButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .msh file.", "*.msh" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_GMSH_FILE_NAME ); } } else if ( w == m_CfdMeshUI->srfButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .srf file.", "*.srf" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_SRF_FILE_NAME ); } } else if ( w == m_CfdMeshUI->tkeyButton ) { string newfile = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select .tkey file.", "*.tkey" ); if ( newfile.compare( "" ) != 0 ) { CfdMeshMgr.GetCfdSettingsPtr()->SetExportFileName( newfile, vsp::CFD_TKEY_FILE_NAME ); } } else if ( w == m_CfdMeshUI->addWakeButton ) { bool flag = !!( m_CfdMeshUI->addWakeButton->value() ); vector<string> geomVec = m_Vehicle->GetGeomVec(); string wakeGeomID = CfdMeshMgr.GetWakeGeomID(); Geom* g = m_Vehicle->FindGeom( wakeGeomID ); if ( g ) { g->SetWakeActiveFlag( flag ); } } else if ( w == m_CfdMeshUI->farBoxGenButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarCompFlag( false ); } else if ( w == m_CfdMeshUI->farComponentGenButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarCompFlag( true ); } else if ( w == m_CfdMeshUI->farCenLocButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarManLocFlag( false ); } else if ( w == m_CfdMeshUI->farManLocButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarManLocFlag( true ); } else if ( w == m_CfdMeshUI->farRelSizeButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarAbsSizeFlag( false ); } else if ( w == m_CfdMeshUI->farAbsSizeButton ) { CfdMeshMgr.GetCfdSettingsPtr()->SetFarAbsSizeFlag( true ); } // else if ( w == m_CfdMeshUI->farXScaleAbsInput ) // { // bool change = false; // // if ( !CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( true ); // change = true; // } // // double val = atof( m_CfdMeshUI->farXScaleAbsInput->value() ); // CfdMeshMgr.SetFarLength( val ); // CfdMeshMgr.UpdateDomain(); // double scale = CfdMeshMgr.GetFarXScale(); // m_FarXScaleSlider.SetVal( scale ); // m_FarXScaleSlider.UpdateGui(); // // update_flag = false; // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( false ); // } // // else if ( w == m_CfdMeshUI->farYScaleAbsInput ) // { // bool change = false; // // if ( !CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( true ); // change = true; // } // // double val = atof( m_CfdMeshUI->farYScaleAbsInput->value() ); // CfdMeshMgr.SetFarWidth( val ); // CfdMeshMgr.UpdateDomain(); // double scale = CfdMeshMgr.GetFarYScale(); // m_FarYScaleSlider.SetVal( scale ); // m_FarYScaleSlider.UpdateGui(); // // update_flag = false; // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( false ); // } // // else if ( w == m_CfdMeshUI->farZScaleAbsInput ) // { // bool change = false; // // if ( !CfdMeshMgr.GetFarAbsSizeFlag() ) // { // CfdMeshMgr.SetFarAbsSizeFlag( true ); // change = true; // } // // double val = atof( m_CfdMeshUI->farZScaleAbsInput->value() ); // CfdMeshMgr.SetFarHeight( val ); // CfdMeshMgr.UpdateDomain(); // double scale = CfdMeshMgr.GetFarZScale(); // m_FarZScaleSlider.SetVal( scale ); // m_FarZScaleSlider.UpdateGui(); // // update_flag = false; // // if ( change ) // CfdMeshMgr.SetFarAbsSizeFlag( false ); // } if ( update_flag ) { Update(); } m_ScreenMgr->SetUpdateFlag( true ); }
/** * Change the company's company-colour * @param tile unused * @param flags operation to perform * @param p1 bitstuffed: * p1 bits 0-7 scheme to set * p1 bits 8-9 set in use state or first/second colour * @param p2 new colour for vehicles, property, etc. * @param text unused * @return the cost of this operation or an error */ CommandCost CmdSetCompanyColour(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { Colours colour = Extract<Colours, 0, 4>(p2); LiveryScheme scheme = Extract<LiveryScheme, 0, 8>(p1); byte state = GB(p1, 8, 2); if (scheme >= LS_END || state >= 3 || colour == INVALID_COLOUR) return CMD_ERROR; Company *c = Company::Get(_current_company); /* Ensure no two companies have the same primary colour */ if (scheme == LS_DEFAULT && state == 0) { const Company *cc; FOR_ALL_COMPANIES(cc) { if (cc != c && cc->colour == colour) return CMD_ERROR; } } if (flags & DC_EXEC) { switch (state) { case 0: c->livery[scheme].colour1 = colour; /* If setting the first colour of the default scheme, adjust the * original and cached company colours too. */ if (scheme == LS_DEFAULT) { _company_colours[_current_company] = colour; c->colour = colour; CompanyAdminUpdate(c); } break; case 1: c->livery[scheme].colour2 = colour; break; case 2: c->livery[scheme].in_use = colour != 0; /* Now handle setting the default scheme's in_use flag. * This is different to the other schemes, as it signifies if any * scheme is active at all. If this flag is not set, then no * processing of vehicle types occurs at all, and only the default * colours will be used. */ /* If enabling a scheme, set the default scheme to be in use too */ if (colour != 0) { c->livery[LS_DEFAULT].in_use = true; break; } /* Else loop through all schemes to see if any are left enabled. * If not, disable the default scheme too. */ c->livery[LS_DEFAULT].in_use = false; for (scheme = LS_DEFAULT; scheme < LS_END; scheme++) { if (c->livery[scheme].in_use) { c->livery[LS_DEFAULT].in_use = true; break; } } break; default: break; } ResetVehicleColourMap(); MarkWholeScreenDirty(); /* All graph related to companies use the company colour. */ InvalidateWindowData(WC_INCOME_GRAPH, 0); InvalidateWindowData(WC_OPERATING_PROFIT, 0); InvalidateWindowData(WC_DELIVERED_CARGO, 0); InvalidateWindowData(WC_PERFORMANCE_HISTORY, 0); InvalidateWindowData(WC_COMPANY_VALUE, 0); /* The smallmap owner view also stores the company colours. */ BuildOwnerLegend(); InvalidateWindowData(WC_SMALLMAP, 0, 1); /* Company colour data is indirectly cached. */ Vehicle *v; FOR_ALL_VEHICLES(v) { if (v->owner == _current_company) v->InvalidateNewGRFCache(); } extern void UpdateObjectColours(const Company *c); UpdateObjectColours(c); } return CommandCost(); }
void UpdateAI(const uint32 diff) { if (!UpdateVictim()) return; events.Update(diff); if (me->HasUnitState(UNIT_STAT_CASTING)) return; if (events.GetTimer() > 15000 && !me->IsWithinMeleeRange(me->getVictim())) DoCastAOE(SPELL_PETRIFY_BREATH, true); if (!left && !right) DoCast(me, SPELL_STONE_SHOUT, true); switch(events.GetEvent()) { case EVENT_NONE: break; case EVENT_SMASH: if (left && right) { if (me->IsWithinMeleeRange(me->getVictim())) DoCastVictim(SPELL_TWO_ARM_SMASH, true); } else if (left || right) { if (me->IsWithinMeleeRange(me->getVictim())) DoCastVictim(SPELL_ONE_ARM_SMASH, true); } events.RescheduleEvent(EVENT_SMASH, 15000); break; case EVENT_SWEEP: if (left) DoCastAOE(SPELL_ARM_SWEEP, true); events.RescheduleEvent(EVENT_SWEEP, 15000); break; case EVENT_GRIP: if (right && instance) { if (Unit* RightArm = vehicle->GetPassenger(1)) { me->MonsterTextEmote(EMOTE_STONE, 0, true); DoScriptText(SAY_GRAB_PLAYER, me); // Grip up to 3 players for (int32 n = 0; n < RAID_MODE(1, 3); ++n) { if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 40, true)) GripTargetGUID[n] = pTarget->GetGUID(); } RightArm->ToCreature()->AI()->DoAction(ACTION_GRIP); } } events.RescheduleEvent(EVENT_GRIP, 40000); break; case EVENT_SHOCKWAVE: if (left) { DoScriptText(SAY_SHOCKWAVE, me); DoCastAOE(SPELL_SHOCKWAVE, true); DoCastAOE(SPELL_SHOCKWAVE_VISUAL, true); } events.RescheduleEvent(EVENT_SHOCKWAVE, urand(15000, 25000)); break; case EVENT_EYEBEAM: if (Unit *pTarget = SelectTarget(SELECT_TARGET_FARTHEST, 0, 50, true)) { if (Creature* EyeBeam = me->SummonCreature(NPC_EYEBEAM_1,pTarget->GetPositionX(),pTarget->GetPositionY()+3,pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,10000)) { EyeBeam->CastSpell(me, SPELL_EYEBEAM_VISUAL_1, true); EyeBeam->AI()->AttackStart(pTarget); } if (Creature* EyeBeam = me->SummonCreature(NPC_EYEBEAM_2,pTarget->GetPositionX(),pTarget->GetPositionY()-3,pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,10000)) { EyeBeam->CastSpell(me, SPELL_EYEBEAM_VISUAL_2, true); EyeBeam->AI()->AttackStart(pTarget); } } events.RescheduleEvent(EVENT_EYEBEAM, 20000); break; case EVENT_LEFT: if (Unit* LeftArm = me->SummonCreature(NPC_LEFT_ARM, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation())) { LeftArm->EnterVehicle(vehicle, 0); DoCast(me, SPELL_ARM_RESPAWN, true); me->MonsterTextEmote(EMOTE_LEFT, 0, true); if (instance) instance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_DISARMED_START_EVENT); } events.CancelEvent(EVENT_LEFT); break; case EVENT_RIGHT: if (Unit* RightArm = me->SummonCreature(NPC_RIGHT_ARM, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation())) { RightArm->EnterVehicle(vehicle, 1); DoCast(me, SPELL_ARM_RESPAWN, true); me->MonsterTextEmote(EMOTE_RIGHT, 0, true); if (instance) instance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_DISARMED_START_EVENT); } events.CancelEvent(EVENT_RIGHT); break; } DoMeleeAttackIfReady(); }
void GUI::paintEvent(QPaintEvent *event) { event->accept(); //rysowanie pojazdu if(this->vehicles.size() == 0 || currentVehicle < 0 || currentVehicle >= vehicles.size()) return; QPainter painter(this); Vehicle v = this->vehicles[currentVehicle]; double length = v.getLength(); unsigned axles = v.getAxlesNumber(); double positions[axles]; for(unsigned i = 0; i < axles; i++) { positions[i] = v.getAxlePosition(i); } const double scale = 1000 / this->scale_length; //1000pix = 24m; QPoint vehicleStart, vehicleEnd; vehicleStart.setX(this->startx); vehicleEnd.setX(this->startx + length * scale); vehicleStart.setY(this->starty); vehicleEnd.setY(this->starty + this->v_height); QRect vehicle; vehicle.setTopLeft(vehicleStart); vehicle.setBottomRight(vehicleEnd); painter.drawRoundedRect(vehicle, 40, 10); painter.fillRect(vehicle, QColor(0, 0, 0, 70)); for(unsigned i = 0; i < axles; i++) { //sprawdz warunek na podniesioną oś unsigned axle_offset_y = 0; if(axles == 5 && v.is5up() && i == 2) axle_offset_y = -5;// 3 os auta 5 os. z podniesioną osią QPoint center; center.setX(this->startx + scale * positions[i]); center.setY(this->starty + this->v_height + axle_offset_y); painter.setBrush(QWidget::palette().color(QWidget::backgroundRole())); painter.setPen(QWidget::palette().color(QWidget::backgroundRole())); painter.drawEllipse(center, this->wheel_size + 5, this->wheel_size + 5); painter.setPen(Qt::black); painter.setBrush(Qt::black); painter.drawEllipse(center, this->wheel_size, this->wheel_size); painter.setBrush(Qt::white); painter.drawEllipse(center, this->wheel_size - 5, this->wheel_size - 5); } const unsigned scale_offset = 100; QPoint scaleStart, scaleEnd; scaleStart.setX(this->startx); scaleStart.setY(this->starty + this->v_height + scale_offset); scaleEnd.setX(this->startx + scale * this->scale_length); scaleEnd.setY(this->starty + this->v_height + scale_offset); painter.drawLine(scaleStart, scaleEnd); //rysuj skale co 4m for(int pos = 0; pos <= this->scale_length; pos += 4) { QPoint scaleTop, scaleBottom, scaleCenter; scaleTop.setX(this->startx + pos * scale); scaleTop.setY(this->starty + this->v_height + scale_offset - 10); scaleBottom.setX(this->startx + pos * scale); scaleBottom.setY(this->starty + this->v_height + scale_offset + 10); scaleCenter.setX(this->startx + pos * scale); scaleCenter.setY(this->starty + this->v_height + scale_offset); painter.drawLine(scaleTop, scaleBottom); painter.drawText(scaleCenter, QString::number(pos) + QString("m")); } //rysuj wartości położenia dla osi //długość pojazdu QPoint vehicleLengthStart, vehicleLengthEnd; QPoint scaleTop, scaleBottom, scaleCenter; vehicleLengthStart.setX(this->startx); vehicleLengthEnd.setX(this->startx + length * scale); vehicleLengthStart.setY(this->starty + this->v_height + 70); vehicleLengthEnd.setY(this->starty + this->v_height + 70); painter.drawLine(vehicleLengthStart, vehicleLengthEnd); scaleCenter.setX((this->startx + length * scale + this->startx) / 2); scaleCenter.setY(this->starty + this->v_height + 70); painter.drawText(scaleCenter, QString().sprintf("%.2f", length) + QString("m")); //podzialka na początku i końcu scaleTop.setX(this->startx); scaleTop.setY(this->starty + this->v_height + 70 - 10); scaleBottom.setX(this->startx); scaleBottom.setY(this->starty + this->v_height + 70 + 10); painter.drawLine(scaleTop, scaleBottom); scaleTop.setX(this->startx + length * scale); scaleTop.setY(this->starty + this->v_height + 70 - 10); scaleBottom.setX(this->startx + length * scale); scaleBottom.setY(this->starty + this->v_height + 70 + 10); painter.drawLine(scaleTop, scaleBottom); //odległości między osiami double start = 0; double end = 0; //początek do osi 1 start = 0; end = positions[0]; scaleStart.setX(this->startx); scaleEnd.setX(this->startx + end * scale); scaleStart.setY(this->starty + this->v_height + 40); scaleEnd.setY(this->starty + this->v_height + 40); painter.drawLine(scaleStart, scaleEnd); scaleCenter.setX((this->startx + end * scale + this->startx) / 2); scaleCenter.setY(this->starty + this->v_height + 40); painter.drawText(scaleCenter, QString().sprintf("%.2f", end) + QString("m")); //podzialka na początku i końcu scaleTop.setX(this->startx); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); scaleTop.setX(this->startx + end * scale); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx + end * scale); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); for(unsigned axle = 0; axle < axles - 1; axle++) { start = end; end = positions[axle + 1]; scaleStart.setX(this->startx + start * scale); scaleEnd.setX(this->startx + end * scale); scaleStart.setY(starty + this->v_height + 40); scaleEnd.setY(starty + this->v_height + 40); painter.drawLine(scaleStart, scaleEnd); scaleCenter.setX((this->startx + end * scale + this->startx + start * scale) / 2); scaleCenter.setY(this->starty + this->v_height + 40); painter.drawText(scaleCenter, QString().sprintf("%.2f", end - start) + QString("m")); //podzialka na początku i końcu scaleTop.setX(this->startx + start * scale); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx + start * scale); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); scaleTop.setX(this->startx + end * scale); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx + end * scale); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); } //koniec pojazdu start = end; end = length; scaleStart.setX(this->startx + start * scale); scaleEnd.setX(this->startx + end * scale); scaleStart.setY(this->starty + this->v_height + 40); scaleEnd.setY(this->starty + this->v_height + 40); painter.drawLine(scaleStart, scaleEnd); scaleCenter.setX((this->startx + end * scale + this->startx + start * scale) / 2); scaleCenter.setY(this->starty + this->v_height + 40); painter.drawText(scaleCenter, QString().sprintf("%.2f", end - start) + QString("m")); //podzialka na początku i końcu scaleTop.setX(this->startx + start * scale); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx + start * scale); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); scaleTop.setX(this->startx + end * scale); scaleTop.setY(this->starty + this->v_height + 40 - 10); scaleBottom.setX(this->startx + end * scale); scaleBottom.setY(this->starty + this->v_height + 40 + 10); painter.drawLine(scaleTop, scaleBottom); }
/** * Replace a whole vehicle chain * @param chain vehicle chain to let autoreplace/renew operator on * @param flags command flags * @param wagon_removal remove wagons when the resulting chain occupies more tiles than the old did * @param nothing_to_do is set to 'false' when something was done (only valid when not failed) * @return cost or error */ static CommandCost ReplaceChain(Vehicle **chain, DoCommandFlag flags, bool wagon_removal, bool *nothing_to_do) { Vehicle *old_head = *chain; assert(old_head->IsPrimaryVehicle()); CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0); if (old_head->type == VEH_TRAIN) { /* Store the length of the old vehicle chain, rounded up to whole tiles */ uint16 old_total_length = CeilDiv(Train::From(old_head)->gcache.cached_total_length, TILE_SIZE) * TILE_SIZE; int num_units = 0; ///< Number of units in the chain for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++; Train **old_vehs = CallocT<Train *>(num_units); ///< Will store vehicles of the old chain in their order Train **new_vehs = CallocT<Train *>(num_units); ///< New vehicles corresponding to old_vehs or NULL if no replacement Money *new_costs = MallocT<Money>(num_units); ///< Costs for buying and refitting the new vehicles /* Collect vehicles and build replacements * Note: The replacement vehicles can only successfully build as long as the old vehicles are still in their chain */ int i; Train *w; for (w = Train::From(old_head), i = 0; w != NULL; w = w->GetNextUnit(), i++) { assert(i < num_units); old_vehs[i] = w; CommandCost ret = BuildReplacementVehicle(old_vehs[i], (Vehicle**)&new_vehs[i], true); cost.AddCost(ret); if (cost.Failed()) break; new_costs[i] = ret.GetCost(); if (new_vehs[i] != NULL) *nothing_to_do = false; } Train *new_head = (new_vehs[0] != NULL ? new_vehs[0] : old_vehs[0]); /* Note: When autoreplace has already failed here, old_vehs[] is not completely initialized. But it is also not needed. */ if (cost.Succeeded()) { /* Separate the head, so we can start constructing the new chain */ Train *second = Train::From(old_head)->GetNextUnit(); if (second != NULL) cost.AddCost(CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true)); assert(Train::From(new_head)->GetNextUnit() == NULL); /* Append engines to the new chain * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time. * That way we also have less trouble when exceeding the unitnumber limit. * OTOH the vehicle attach callback is more expensive this way :s */ Train *last_engine = NULL; ///< Shall store the last engine unit after this step if (cost.Succeeded()) { for (int i = num_units - 1; i > 0; i--) { Train *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]); if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) continue; if (new_vehs[i] != NULL) { /* Move the old engine to a separate row with DC_AUTOREPLACE. Else * moving the wagon in front may fail later due to unitnumber limit. * (We have to attach wagons without DC_AUTOREPLACE.) */ CmdMoveVehicle(old_vehs[i], NULL, DC_EXEC | DC_AUTOREPLACE, false); } if (last_engine == NULL) last_engine = append; cost.AddCost(CmdMoveVehicle(append, new_head, DC_EXEC, false)); if (cost.Failed()) break; } if (last_engine == NULL) last_engine = new_head; } /* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */ if (cost.Succeeded() && wagon_removal && new_head->gcache.cached_total_length > old_total_length) cost = CommandCost(STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT); /* Append/insert wagons into the new vehicle chain * We do this from back to front, so we can stop when wagon removal or maximum train length (i.e. from mammoth-train setting) is triggered. */ if (cost.Succeeded()) { for (int i = num_units - 1; i > 0; i--) { assert(last_engine != NULL); Vehicle *append = (new_vehs[i] != NULL ? new_vehs[i] : old_vehs[i]); if (RailVehInfo(append->engine_type)->railveh_type == RAILVEH_WAGON) { /* Insert wagon after 'last_engine' */ CommandCost res = CmdMoveVehicle(append, last_engine, DC_EXEC, false); /* When we allow removal of wagons, either the move failing due * to the train becoming too long, or the train becoming longer * would move the vehicle to the empty vehicle chain. */ if (wagon_removal && (res.Failed() ? res.GetErrorMessage() == STR_ERROR_TRAIN_TOO_LONG : new_head->gcache.cached_total_length > old_total_length)) { CmdMoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false); break; } cost.AddCost(res); if (cost.Failed()) break; } else { /* We have reached 'last_engine', continue with the next engine towards the front */ assert(append == last_engine); last_engine = last_engine->GetPrevUnit(); } } } /* Sell superfluous new vehicles that could not be inserted. */ if (cost.Succeeded() && wagon_removal) { assert(new_head->gcache.cached_total_length <= _settings_game.vehicle.max_train_length * TILE_SIZE); for (int i = 1; i < num_units; i++) { Vehicle *wagon = new_vehs[i]; if (wagon == NULL) continue; if (wagon->First() == new_head) break; assert(RailVehInfo(wagon->engine_type)->railveh_type == RAILVEH_WAGON); /* Sell wagon */ CommandCost ret = DoCommand(0, wagon->index, 0, DC_EXEC, GetCmdSellVeh(wagon)); assert(ret.Succeeded()); new_vehs[i] = NULL; /* Revert the money subtraction when the vehicle was built. * This value is different from the sell value, esp. because of refitting */ cost.AddCost(-new_costs[i]); } } /* The new vehicle chain is constructed, now take over orders and everything... */ if (cost.Succeeded()) cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags)); if (cost.Succeeded()) { /* Success ! */ if ((flags & DC_EXEC) != 0 && new_head != old_head) { *chain = new_head; } /* Transfer cargo of old vehicles and sell them */ for (int i = 0; i < num_units; i++) { Vehicle *w = old_vehs[i]; /* Is the vehicle again part of the new chain? * Note: We cannot test 'new_vehs[i] != NULL' as wagon removal might cause to remove both */ if (w->First() == new_head) continue; if ((flags & DC_EXEC) != 0) TransferCargo(w, new_head, true); /* Sell the vehicle. * Note: This might temporarly construct new trains, so use DC_AUTOREPLACE to prevent * it from failing due to engine limits. */ cost.AddCost(DoCommand(0, w->index, 0, flags | DC_AUTOREPLACE, GetCmdSellVeh(w))); if ((flags & DC_EXEC) != 0) { old_vehs[i] = NULL; if (i == 0) old_head = NULL; } } if ((flags & DC_EXEC) != 0) CheckCargoCapacity(new_head); } /* If we are not in DC_EXEC undo everything, i.e. rearrange old vehicles. * We do this from back to front, so that the head of the temporary vehicle chain does not change all the time. * Note: The vehicle attach callback is disabled here :) */ if ((flags & DC_EXEC) == 0) { /* Separate the head, so we can reattach the old vehicles */ Train *second = Train::From(old_head)->GetNextUnit(); if (second != NULL) CmdMoveVehicle(second, NULL, DC_EXEC | DC_AUTOREPLACE, true); assert(Train::From(old_head)->GetNextUnit() == NULL); for (int i = num_units - 1; i > 0; i--) { CommandCost ret = CmdMoveVehicle(old_vehs[i], old_head, DC_EXEC | DC_AUTOREPLACE, false); assert(ret.Succeeded()); } } } /* Finally undo buying of new vehicles */ if ((flags & DC_EXEC) == 0) { for (int i = num_units - 1; i >= 0; i--) { if (new_vehs[i] != NULL) { DoCommand(0, new_vehs[i]->index, 0, DC_EXEC, GetCmdSellVeh(new_vehs[i])); new_vehs[i] = NULL; } } } free(old_vehs); free(new_vehs); free(new_costs); } else { /* Build and refit replacement vehicle */ Vehicle *new_head = NULL; cost.AddCost(BuildReplacementVehicle(old_head, &new_head, true)); /* Was a new vehicle constructed? */ if (cost.Succeeded() && new_head != NULL) { *nothing_to_do = false; /* The new vehicle is constructed, now take over orders and everything... */ cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags)); if (cost.Succeeded()) { /* The new vehicle is constructed, now take over cargo */ if ((flags & DC_EXEC) != 0) { TransferCargo(old_head, new_head, true); *chain = new_head; } /* Sell the old vehicle */ cost.AddCost(DoCommand(0, old_head->index, 0, flags, GetCmdSellVeh(old_head))); } /* If we are not in DC_EXEC undo everything */ if ((flags & DC_EXEC) == 0) { DoCommand(0, new_head->index, 0, DC_EXEC, GetCmdSellVeh(new_head)); } } } return cost; }
/* * Finds the best trajectory according to WEIGHTED_COST_FUNCTIONS (global). * * @param: ref_state - [s, s_dot, s_ddot, d, d_dot, d_ddot] * @param: target_vehicle - id of leading vehicle (int) which can be used to retrieve that vehicle from the "predictions" dictionary. This is the vehicle that we are setting our trajectory relative to. * @param: delta - a length 6 array indicating the offset we are aiming for between us and the target_vehicle. So if at time 5 the target vehicle will be at [100, 10, 0, 0, 0, 0] and delta is [-10, 0, 0, 4, 0, 0], then our goal state for t = 5 will be [90, 10, 0, 4, 0, 0]. This would correspond to a goal of "follow 10 meters behind and 4 meters to the right of target vehicle" * @param: T - the desired time at which we will be at the goal (relative to now as t=0) * @param: predictions - dictionary of {v_id : vehicle }. Each vehicle has a method vehicle.state_in(time) which returns a length 6 array giving that vehicle's expected [s, s_dot, s_ddot, d, d_dot, d_ddot] state at that time. * * @return: (best_s, best_d, best_t) where best_s are the 6 coefficients representing s(t) best_d gives coefficients for d(t) and best_t gives duration associated w/ this trajectory. */ struct trajectory* Ptg::PTG(struct state* ref_state, int8_t target_vehicle, struct state* delta, double T, std::map<int8_t, Vehicle>* predictions) { struct trajectory* best_traj = NULL; if (target_vehicle > -1) { Vehicle* target = &predictions->at(target_vehicle); // generate alternative goals std::vector<struct goal> all_goals; double timestep = 0.2; double t = T - 4 * timestep; while (t <= T + 4 * timestep) // loop 8 times = 8 traj { struct state target_state = target->state_in(t); target_state.add(&delta->s, &delta->d); struct model goal_s = target_state.s; struct model goal_d = target_state.d; struct goal goals; goals.s = goal_s; goals.d = goal_d; goals.t = t; all_goals.push_back(goals); t += timestep; } // find best trajectory std::map<double, struct trajectory*> cost_traj; for (std::vector<struct goal>::iterator it=all_goals.begin(); it!=all_goals.end(); ++it) { double cost = 0; struct trajectory* traj = new trajectory(); struct model s_goal = it->s; struct model d_goal = it->d; double t = it->t; JMT(traj->s_coeffs, &ref_state->s, &s_goal, t); JMT(traj->d_coeffs, &ref_state->d, &d_goal, t); traj->T = t; cost = calculate_cost(traj, target_vehicle, delta, T, predictions); cost_traj[cost] = traj; // Sort by cost #ifdef VISUAL_DEBUG graph->plot_trajectory(ref_state->s.m, traj); #endif // VISUAL_DEBUG } if (cost_traj.size() > 0) { best_traj = cost_traj.begin()->second; // Minimum cost } } else { printf("[ERROR] Can not find vehicle with id: %d\n", target_vehicle); } return best_traj; }
/** * Autoreplaces a vehicle * Trains are replaced as a whole chain, free wagons in depot are replaced on their own * @param tile not used * @param flags type of operation * @param p1 Index of vehicle * @param p2 not used * @param text unused * @return the cost of this operation or an error */ CommandCost CmdAutoreplaceVehicle(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text) { Vehicle *v = Vehicle::GetIfValid(p1); if (v == NULL) return CMD_ERROR; CommandCost ret = CheckOwnership(v->owner); if (ret.Failed()) return ret; if (!v->IsInDepot()) return CMD_ERROR; if (v->vehstatus & VS_CRASHED) return CMD_ERROR; bool free_wagon = false; if (v->type == VEH_TRAIN) { Train *t = Train::From(v); if (t->IsArticulatedPart() || t->IsRearDualheaded()) return CMD_ERROR; free_wagon = !t->IsFrontEngine(); if (free_wagon && t->First()->IsFrontEngine()) return CMD_ERROR; } else { if (!v->IsPrimaryVehicle()) return CMD_ERROR; } const Company *c = Company::Get(_current_company); bool wagon_removal = c->settings.renew_keep_length; /* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */ Vehicle *w = v; bool any_replacements = false; while (w != NULL) { EngineID e; CommandCost cost = GetNewEngineType(w, c, e); if (cost.Failed()) return cost; any_replacements |= (e != INVALID_ENGINE); w = (!free_wagon && w->type == VEH_TRAIN ? Train::From(w)->GetNextUnit() : NULL); } CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0); bool nothing_to_do = true; if (any_replacements) { bool was_stopped = free_wagon || ((v->vehstatus & VS_STOPPED) != 0); /* Stop the vehicle */ if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, true)); if (cost.Failed()) return cost; assert(v->IsStoppedInDepot()); /* We have to construct the new vehicle chain to test whether it is valid. * Vehicle construction needs random bits, so we have to save the random seeds * to prevent desyncs and to replay newgrf callbacks during DC_EXEC */ SavedRandomSeeds saved_seeds; SaveRandomSeeds(&saved_seeds); if (free_wagon) { cost.AddCost(ReplaceFreeUnit(&v, flags & ~DC_EXEC, ¬hing_to_do)); } else { cost.AddCost(ReplaceChain(&v, flags & ~DC_EXEC, wagon_removal, ¬hing_to_do)); } RestoreRandomSeeds(saved_seeds); if (cost.Succeeded() && (flags & DC_EXEC) != 0) { CommandCost ret; if (free_wagon) { ret = ReplaceFreeUnit(&v, flags, ¬hing_to_do); } else { ret = ReplaceChain(&v, flags, wagon_removal, ¬hing_to_do); } assert(ret.Succeeded() && ret.GetCost() == cost.GetCost()); } /* Restart the vehicle */ if (!was_stopped) cost.AddCost(CmdStartStopVehicle(v, false)); } if (cost.Succeeded() && nothing_to_do) cost = CommandCost(STR_ERROR_AUTOREPLACE_NOTHING_TO_DO); return cost; }
void UpdateAI(uint32 const diff) { if (!UpdateVictim()) return; events.Update(diff); if (me->HasUnitState(UNIT_STATE_CASTING)) return; while (uint32 eventId = events.ExecuteEvent()) { switch (eventId) { case EVENT_MELEE_CHECK: if (!me->IsWithinMeleeRange(me->getVictim())) DoCast(SPELL_PETRIFY_BREATH); events.ScheduleEvent(EVENT_MELEE_CHECK, 1 * IN_MILLISECONDS); break; case EVENT_SWEEP: if (left) DoCast(me->FindNearestCreature(NPC_ARM_SWEEP_STALKER, 500.0f, true), SPELL_ARM_SWEEP, true); events.ScheduleEvent(EVENT_SWEEP, 25 * IN_MILLISECONDS); break; case EVENT_SMASH: if (left && right) DoCastVictim(SPELL_TWO_ARM_SMASH); else if (left || right) DoCastVictim(SPELL_ONE_ARM_SMASH); events.ScheduleEvent(EVENT_SMASH, 15 * IN_MILLISECONDS); break; case EVENT_STONE_SHOUT: DoCast(SPELL_STONE_SHOUT); events.ScheduleEvent(EVENT_STONE_SHOUT, 2 * IN_MILLISECONDS); break; case EVENT_ENRAGE: DoCast(SPELL_BERSERK); Talk(SAY_BERSERK); break; case EVENT_RESPAWN_LEFT_ARM: case EVENT_RESPAWN_RIGHT_ARM: { if (vehicle) { int8 seat = eventId == EVENT_RESPAWN_LEFT_ARM ? 0 : 1; uint32 entry = eventId == EVENT_RESPAWN_LEFT_ARM ? NPC_LEFT_ARM : NPC_RIGHT_ARM; vehicle->InstallAccessory(entry, seat, true, TEMPSUMMON_MANUAL_DESPAWN, 0); } break; } case EVENT_STONE_GRIP: { if (right) { DoCast(SPELL_STONE_GRIP); Talk(SAY_GRAB_PLAYER); Talk(EMOTE_STONE_GRIP); } events.ScheduleEvent(EVENT_STONE_GRIP, 25 * IN_MILLISECONDS); break; } case EVENT_FOCUSED_EYEBEAM: if (Unit* eyebeamTargetUnit = SelectTarget(SELECT_TARGET_FARTHEST, 0, 0, true)) { eyebeamTarget = eyebeamTargetUnit->GetGUID(); DoCast(me, SPELL_SUMMON_FOCUSED_EYEBEAM, true); } events.ScheduleEvent(EVENT_FOCUSED_EYEBEAM, urand(15, 35) * IN_MILLISECONDS); break; } } DoMeleeAttackIfReady(); }
void AddArticulatedParts(Vehicle *first) { VehicleType type = first->type; if (!HasBit(EngInfo(first->engine_type)->callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return; Vehicle *v = first; for (uint i = 1; i < MAX_ARTICULATED_PARTS; i++) { bool flip_image; EngineID engine_type = GetNextArticPart(i, first->engine_type, first, &flip_image); if (engine_type == INVALID_ENGINE) return; /* In the (very rare) case the GRF reported wrong number of articulated parts * and we run out of available vehicles, bail out. */ if (!Vehicle::CanAllocateItem()) return; const Engine *e_artic = Engine::Get(engine_type); switch (type) { default: NOT_REACHED(); case VEH_TRAIN: { Train *front = Train::From(first); Train *t = new Train(); v->SetNext(t); v = t; t->subtype = 0; t->track = front->track; t->railtype = front->railtype; t->tcache.first_engine = front->engine_type; // needs to be set before first callback t->spritenum = e_artic->u.rail.image_index; if (e_artic->CanCarryCargo()) { t->cargo_type = e_artic->GetDefaultCargoType(); t->cargo_cap = e_artic->u.rail.capacity; // Callback 36 is called when the consist is finished } else { t->cargo_type = front->cargo_type; // Needed for livery selection t->cargo_cap = 0; } t->SetArticulatedPart(); } break; case VEH_ROAD: { RoadVehicle *front = RoadVehicle::From(first); RoadVehicle *rv = new RoadVehicle(); v->SetNext(rv); v = rv; rv->subtype = 0; rv->rcache.first_engine = front->engine_type; // needs to be set before first callback rv->rcache.cached_veh_length = 8; // Callback is called when the consist is finished rv->state = RVSB_IN_DEPOT; rv->roadtype = front->roadtype; rv->compatible_roadtypes = front->compatible_roadtypes; rv->spritenum = e_artic->u.road.image_index; if (e_artic->CanCarryCargo()) { rv->cargo_type = e_artic->GetDefaultCargoType(); rv->cargo_cap = e_artic->u.road.capacity; // Callback 36 is called when the consist is finished } else { rv->cargo_type = front->cargo_type; // Needed for livery selection rv->cargo_cap = 0; } rv->SetArticulatedPart(); } break; } /* get common values from first engine */ v->direction = first->direction; v->owner = first->owner; v->tile = first->tile; v->x_pos = first->x_pos; v->y_pos = first->y_pos; v->z_pos = first->z_pos; v->build_year = first->build_year; v->vehstatus = first->vehstatus & ~VS_STOPPED; v->cargo_subtype = 0; v->max_speed = 0; v->max_age = 0; v->engine_type = engine_type; v->value = 0; v->cur_image = SPR_IMG_QUERY; v->random_bits = VehicleRandomBits(); if (flip_image) v->spritenum++; VehicleMove(v, false); } }
void Reset() { _Reset(); if (vehicle) vehicle->RemoveAllPassengers(); }
int main() { cout << endl << "Boolean test" << endl; AWS::Boolean boolean("boolean"); boolean.setValue(true); cout << boolean.valueAsString() << endl; cout << (boolean.value() == true ? "T" : "F") << endl; boolean.setStringValue("FaLsE"); cout << boolean.valueAsString() << endl; cout << (boolean.value() == true ? "T" : "F") << endl; boolean.setStringValue("trUE"); cout << boolean.valueAsString() << endl; cout << (boolean.value() == true ? "T" : "F") << endl; cout << endl << "Integer test" << endl; AWS::Integer integer("integer"); integer.setStringValue("35"); cout << integer.value() << endl; cout << integer.valueAsString() << endl; cout << "is 35: " << (integer.value() == 35 ? "T" : "F") << endl; integer.setStringValue("-5"); cout << integer.value() << endl; cout << integer.valueAsString() << endl; cout << "is -5: " << (integer.value() == -5 ? "T" : "F") << endl; integer.setValue(10); cout << integer.value() << endl; cout << integer.valueAsString() << endl; cout << "is 10: " << (integer.value() == 10 ? "T" : "F") << endl; try { integer.setStringValue("684654851684654681680468406840165416149"); cout << integer.value() << endl; cout << integer.valueAsString() << endl; cout << "is -5: " << (integer.value() == -5 ? "T" : "F") << endl; } catch (const out_of_range& e) { cout << "exception" << endl; } cout << endl << "Array of int test" << endl; AWS::ArrayElement arrayElement("array"); AWS::Integer* integ1 = new AWS::Integer("integ1"); integ1->setValue(1); AWS::Integer* integ2 = new AWS::Integer("integ2"); integ2->setValue(2147483647); // long int AWS::Integer* integ3 = new AWS::Integer("integ3"); integ3->setValue(4294967295); // -1 AWS::Integer* integ4 = new AWS::Integer("integ4"); integ4->setValue(92233720368547758074294967295); // -1 arrayElement.add(integ1); arrayElement.add(integ2); arrayElement.add(integ3); arrayElement.add(integ4); std::vector<int> vect; arrayElement.fill(&vect, NULL); for (std::vector<int>::iterator iter = vect.begin(); iter != vect.end(); ++iter) cout << *iter << endl; cout << endl << "Array of real test" << endl; AWS::ArrayElement realArrayElement("array"); AWS::Real* real1 = new AWS::Real("real1"); real1->setValue(1.0); AWS::Real* real2 = new AWS::Real("real2"); real2->setValue(2147483647.0); // long int AWS::Real* real3 = new AWS::Real("real3"); real3->setValue(4294967295); // -1 AWS::Real* real4 = new AWS::Real("real4"); real4->setValue(2); // -1 realArrayElement.add(real1); realArrayElement.add(real2); realArrayElement.add(real3); realArrayElement.add(real4); std::vector<double> realVect; realArrayElement.fill(&realVect, NULL); for (std::vector<double>::iterator iter = realVect.begin(); iter != realVect.end(); ++iter) cout << *iter << endl; cout << endl << "Array of string test" << endl; AWS::ArrayElement arrayStringElement("array"); AWS::String* string1 = new AWS::String("integ1"); string1->setValue("a"); AWS::String* string2 = new AWS::String("integ2"); string2->setValue("b"); AWS::String* string3 = new AWS::String("integ3"); string3->setValue("c"); AWS::String* string4 = new AWS::String("integ4"); string4->setValue("d"); arrayStringElement.add(string1); arrayStringElement.add(string2); arrayStringElement.add(string3); arrayStringElement.add(string4); std::vector<std::string> vectString; arrayStringElement.fill(&vectString, NULL); for (std::vector<std::string>::iterator iter = vectString.begin(); iter != vectString.end(); ++iter) cout << *iter << endl; cout << endl << "Class test" << endl; AWS::ClassElement classVehicle("vehicle"); AWS::Boolean* isMotorized = new AWS::Boolean("isMotorized"); isMotorized->setValue(true); AWS::Integer* wheels = new AWS::Integer("wheels"); wheels->setValue(4); AWS::String* brand = new AWS::String("brand"); brand->setValue("Renault"); AWS::String* david = new AWS::String("name"); david->setValue("David"); AWS::ClassElement* people = new AWS::ClassElement(""); people->add(david);// Class name not necessary because it is in an array. AWS::ArrayElement* peoples = new AWS::ArrayElement("people"); peoples->add(people); classVehicle.add(isMotorized); classVehicle.add(wheels ); classVehicle.add(brand ); classVehicle.add(peoples ); Vehicle vehicle; classVehicle.fill(&vehicle, NULL); cout << "isMotorized: " << vehicle.isMotorized << endl; cout << "wheels : " << vehicle.wheels << endl; cout << "brand : " << vehicle.brand << endl; cout << "people : " << vehicle.people[0]->name << endl; cout << endl << "Element test" << endl; AWS::ClassElement* classElement = (AWS::ClassElement*)vehicle.toElement(""); cout << "isMotorized: " << ((AWS::Boolean*)classElement->get("isMotorized"))->value() << endl; cout << "brand : " << ((AWS::String*)classElement->get("brand") )->value() << endl; cout << "wheels : " << ((AWS::Integer*)classElement->get("wheels") )->value() << endl; cout << "people : " << ((AWS::String*)((AWS::ClassElement*)((AWS::ArrayElement*)classElement->get("people"))->m_elements[0])->get("name"))->value() << endl; return 0; }
void WorldSession::HandleEjectPassenger(WorldPacket& data) { Vehicle* vehicle = _player->GetVehicleKit(); if (!vehicle) { data.rfinish(); // prevent warnings spam TC_LOG_ERROR("network", "HandleEjectPassenger: Player %u is not in a vehicle!", GetPlayer()->GetGUIDLow()); return; } uint64 guid; data >> guid; if (IS_PLAYER_GUID(guid)) { Player* player = ObjectAccessor::FindPlayer(guid); if (!player) { TC_LOG_ERROR("network", "Player %u tried to eject player %u from vehicle, but the latter was not found in world!", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); return; } if (!player->IsOnVehicle(vehicle->GetBase())) { TC_LOG_ERROR("network", "Player %u tried to eject player %u, but they are not in the same vehicle", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); return; } VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(player); ASSERT(seat); if (seat->IsEjectable()) player->ExitVehicle(); else TC_LOG_ERROR("network", "Player %u attempted to eject player %u from non-ejectable seat.", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); } else if (IS_CREATURE_GUID(guid)) { Unit* unit = ObjectAccessor::GetUnit(*_player, guid); if (!unit) // creatures can be ejected too from player mounts { TC_LOG_ERROR("network", "Player %u tried to eject creature guid %u from vehicle, but the latter was not found in world!", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); return; } if (!unit->IsOnVehicle(vehicle->GetBase())) { TC_LOG_ERROR("network", "Player %u tried to eject unit %u, but they are not in the same vehicle", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); return; } VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(unit); ASSERT(seat); if (seat->IsEjectable()) { ASSERT(GetPlayer() == vehicle->GetBase()); unit->ExitVehicle(); } else TC_LOG_ERROR("network", "Player %u attempted to eject creature GUID %u from non-ejectable seat.", GetPlayer()->GetGUIDLow(), GUID_LOPART(guid)); } else TC_LOG_ERROR("network", "HandleEjectPassenger: Player %u tried to eject invalid GUID " UI64FMTD, GetPlayer()->GetGUIDLow(), guid); }
void Reset() { ASSERT(vehicle); vehicle->Reset(); }
void initializeGraphics() { //Build Pop Up Menu BuildPopupMenu(); glutAttachMenu (GLUT_RIGHT_BUTTON); //inittextures for(int i=0;i<MAXTEXTURES;i++) textures[i]=0; // disable Lighting glDisable( GL_LIGHTING ); glClearColor (0.0f, 0.0f, 0.0f, 0.0f); glEnable( GL_DEPTH_TEST ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glGetFloatv( GL_MODELVIEW_MATRIX, modelViewMatrix ); // save MY copy in modelViewMatrix glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); //Load Textures textures[SIRENID] = loadtextures(sirenFile, 52,45); textures[VEHICLEID] = loadtextures(vehicleFile, 207,177); textures[WALLID] = loadtextures(wallFile, 512,512); textures[FLOORID] = loadtextures(floorFile, 512,512); textures[CARROTID] = loadtextures(carrotFile, 52,45); textures[BUTTONID] = loadtextures(buttonFile, 52,45); textures[PARTICLEID]=textures[VEHICLEID]; textures[PONDID] = loadtextures(marbleFile,225,225); textures[WATERID] = loadtextures(waterFile,393,385); //snow drifts snowcave.resetPoints(snowCavePoints); snowcave.setBoundingBoxes(driftBuffer); snowcave2.resetPoints(snowCavePoints2); // snowcave2.setBoundingBox(-50,-27, //min max X // -50,-30, //min max Y // -50,10); //min max z snowcave2.setBoundingBoxes(driftBuffer); //snowman snowman = Snowman(snowmanOrigin, SNOWMANID, snowmanSize, textures[FLOORID], textures[CARROTID], textures[BUTTONID]); snowman2 = Snowman(snowmanOrigin2, SNOWMANID, snowmanSize, textures[FLOORID], textures[CARROTID], textures[BUTTONID]); snowman3 = Snowman(snowmanOrigin3, SNOWMANID, snowmanSize, textures[FLOORID], textures[CARROTID], textures[BUTTONID]); //Pond pond = Pond(pondOrigin,PONDID,pondRadius,pondHeight); pond.setSpaceDimensions(Point(10,10,10)); pond.setBoundingBox(pondOrigin.x-10,pondOrigin.x+10,-50,pondOrigin.y+5,pondOrigin.z-10,pondOrigin.z+10); //Gifts gifts[0] = Gift(giftOrigin1,GIFT1ID,giftSize); gifts[1] = Gift(giftOrigin2,GIFT2ID,giftSize); gifts[2] = Gift(giftOrigin3,GIFT3ID,giftSize); gifts[3] = Gift(giftOrigin4,GIFT4ID,giftSize); gifts[4] = Gift(giftOrigin5,GIFT5ID,giftSize); //enemy npc.setSpeed(npcSpeed); npc.setSpaceDimensions(Point(bodyRadius/2,bodyRadius/2,bodyRadius/2)); npc.setThrowRange(20); npc.setInDanger(true); //vehicle vehicle.setDamage(0); vehicle.setMaxDamage(100); vehicle.setIsAlive(true); vehicle.setStrikeRange(30); //init shadow paramteres glEnable(GL_COLOR_MATERIAL); glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glShadeModel (GL_SMOOTH); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //this is defined //bool (*fp_processCollision)(Obstacle); fp_processCollision = &processCollision; //Map Creation assessment currMap.createMap(minCoords, maxCoords, npc, gifts, giftCount, fp_processCollision ); currMap.printState(); //setup the controller controller = PathController(&currMap,&npc,&vehicle); controller.setNextTarget(); //set the target controller.setMaxPath(100); }
bool SVGOptionsScreen::Update() { Vehicle *veh = VehicleMgr.GetVehicle(); if( veh ) { m_LenUnitChoice.Update( veh->m_SVGLenUnit.GetID() ); m_2DViewType.Update( veh->m_SVGView.GetID() ); m_4ViewChoice1.Update( veh->m_SVGView1.GetID() ); m_4ViewChoice2.Update( veh->m_SVGView2.GetID() ); m_4ViewChoice3.Update( veh->m_SVGView3.GetID() ); m_4ViewChoice4.Update( veh->m_SVGView4.GetID() ); m_4RotChoice1.Update( veh->m_SVGView1_rot.GetID() ); m_4RotChoice2.Update( veh->m_SVGView2_rot.GetID() ); m_4RotChoice3.Update( veh->m_SVGView3_rot.GetID() ); m_4RotChoice4.Update( veh->m_SVGView4_rot.GetID() ); m_ProjectionLineToggle.Update( veh->m_SVGProjectionFlag.GetID() ); m_TessSlider.Update( veh->m_SVGTessFactor.GetID() ); m_XSecToggle.Update( veh->m_SVGAllXSecFlag.GetID() ); if ( veh->m_SVGProjectionFlag() ) { m_TessSlider.Activate(); } else { m_TessSlider.Deactivate(); } if ( veh->m_SVGLenUnit() == vsp::LEN_UNITLESS ) { veh->m_Scale.Set( 0 ); } else { GetScale( veh->m_SVGSet.Get() ); } if ( veh->m_SVGView() == vsp::VIEW_1 ) { m_4ViewChoice1.Activate(); m_4ViewChoice2.Deactivate(); m_4ViewChoice3.Deactivate(); m_4ViewChoice4.Deactivate(); m_4RotChoice1.Activate(); m_4RotChoice2.Deactivate(); m_4RotChoice3.Deactivate(); m_4RotChoice4.Deactivate(); } else if ( veh->m_SVGView() == vsp::VIEW_2HOR ) { m_4ViewChoice1.Activate(); m_4ViewChoice2.Activate(); m_4ViewChoice3.Deactivate(); m_4ViewChoice4.Deactivate(); m_4RotChoice1.Activate(); m_4RotChoice2.Activate(); m_4RotChoice3.Deactivate(); m_4RotChoice4.Deactivate(); } else if ( veh->m_SVGView() == vsp::VIEW_2VER ) { m_4ViewChoice1.Activate(); m_4ViewChoice2.Deactivate(); m_4ViewChoice3.Activate(); m_4ViewChoice4.Deactivate(); m_4RotChoice1.Activate(); m_4RotChoice2.Deactivate(); m_4RotChoice3.Activate(); m_4RotChoice4.Deactivate(); } else if ( veh->m_SVGView() == vsp::VIEW_4 ) { m_4ViewChoice1.Activate(); m_4ViewChoice2.Activate(); m_4ViewChoice3.Activate(); m_4ViewChoice4.Activate(); m_4RotChoice1.Activate(); m_4RotChoice2.Activate(); m_4RotChoice3.Activate(); m_4RotChoice4.Activate(); } } m_FLTK_Window->redraw(); return false; }
void update() { Obstacle tmpObj = vehicle; tmpObj.moveObstacle(); //MapNode *location =currMap.getNode(tmpObj.getOrigin()); //MapNode *currLocation =currMap.getNode(vehicle.getOrigin()); if (processCollision(tmpObj)) //process collisions and damage taken { //make accomodations to ensure that vehicle.setSpeed(0); vehicle.moveObstacle(); } vehicle.moveObstacle(); translate(0,0,vehicle.getSpeed()); if(activeBeam) //do not respond to events when beam is activated-drop vehicle velocity to zero { vehicle.setSpeed( -vehicle.getSpeed()); return; } //if (speed>0) if ( vehicle.getSpeed()>0 ) vehicle.setSpeed(vehicle.getSpeed()-0.001f); else vehicle.setSpeed(0); //move the enemy player controller.advanceCharacter(); //if NPC is throwing snowball then handle it //create a snowball projectile if(npc.getCurrentState()==RELEASE_SNOWBALL) { Snowball *newSnowball = new Snowball( SNOWBALLID, npc.getOrigin(), //startPoint vehicle.getOrigin(),// endPoint npc.getSnowRadius(), snowballSpeed, //speed at which the snowball flies through the air minCoords, //the coords that the snowball will crash and dissolve maxCoords, snowballDamage, snowballGravity, snowballAirFriction, textures[FLOORID] ); projectiles.push_back(newSnowball); } //manage snowballs and the damage inflicted on the vehicle advanceProjectiles(); display(); }
void MoveInLineOfSight(Unit *who) { if(who->GetTypeId() == TYPEID_PLAYER && CAST_PLR(who)->isGameMaster() && !who->GetVehicle() && vehicle->GetPassenger(SEAT_TURRET)) who->EnterVehicle(vehicle, SEAT_PLAYER); }