float pWheel2::getRpm() const
{
float a = NxMath::abs(mWheelShape->getAxleSpeed())/NxTwoPi * 60.0f;
if (getVehicle())
{
float b = NxMath::abs(mWheelShape->getAxleSpeed())/NxTwoPi * getVehicle()->_lastDT;
return b;
}
return NxMath::abs(mWheelShape->getAxleSpeed())/NxTwoPi * 60.0f;
}
void State_LeaveCurbside::Execute( CARCportEngine* pEngine )
{
if(m_bOutPath)
{
return getVehicle()->ChangeStateMoveToDest(pEngine);
}
//finding leave position
LandsidePosition exitPos;
if(m_pCurb->getParkingSpot().FindLeavePosition(getVehicle(), m_spot, exitPos) )
{
LandsideLaneInSim* plane = exitPos.pRes->toLane();
DistanceUnit distF = exitPos.distInRes - getVehicle()->GetHalfLength();
DistanceUnit distT = exitPos.distInRes + getVehicle()->GetHalfLength();
if(plane->isSpaceEmpty(getVehicle(), distF,distT))
{
double dSpeed = getVehicle()->getSpeed(plane, exitPos.distInRes);
MobileState lastState = m_pOwner->getLastState();
lastState.pos = exitPos.pos;
lastState.pRes = plane;
lastState.distInRes = exitPos.distInRes-1;
lastState.dSpeed = dSpeed*0.5;
m_pOwner->MoveToPos(lastState);
lastState.distInRes = exitPos.distInRes;
m_pOwner->MoveToPos(lastState);
m_bOutPath = true;
return getVehicle()->Continue();
}
}
return getVehicle()->StepTime(pEngine);
}
void State_TryParkingCurbside::Entry( CARCportEngine* pEngine )
{
CurbsideStrategyStateInSim* pStragy = getVehicle()->getCurbStragy();
if(!pStragy)
{
pStragy = getVehicle()->BeginCurbStrategy(m_pCurb->getName(),pEngine);
}
ElapsedTime maxWaitSpotTime(12*3600L);
if(pStragy)
{
maxWaitSpotTime = pStragy->getMaxWaitSpotTime();
}
m_waitTimer.StartTimer(this, curTime()+ maxWaitSpotTime );
Execute(pEngine);
}
void State_DropPaxAtCurbside::Execute( CARCportEngine* pEngine )
{
if(!m_pOwner->HavePaxGetOff(m_pCurb))
{
getVehicle()->SuccessProcessAtLayoutObject(m_pCurb,m_spot,pEngine);
}
}
void CityView::Render()
{
TileView::Render();
if (fw.state->showVehiclePath)
{
for (auto obj : this->map.activeObjects)
{
auto vTile = std::dynamic_pointer_cast<VehicleTileObject>(obj);
if (!vTile)
continue;
auto &v = vTile->getVehicle();
auto &path = v.missions.front()->getCurrentPlannedPath();
Vec3<float> prevPos = vTile->getPosition();
for (auto *tile : path)
{
Vec3<float> pos = tile->position;
Vec2<float> screenPosA = this->tileToScreenCoords(prevPos);
screenPosA.x += this->offsetX;
screenPosA.y += this->offsetX;
Vec2<float> screenPosB = this->tileToScreenCoords(pos);
screenPosB.x += this->offsetX;
screenPosB.y += this->offsetX;
fw.renderer->drawLine(screenPosA, screenPosB, Colour{255, 0, 0, 128});
prevPos = pos;
}
}
}
activeTab->Render();
fw.gamecore->MouseCursor->Render();
}
void State_LeaveCurbside::Exit(CARCportEngine* pEngine)
{
if(m_spot)
{
m_spot->OnVehicleExit(getVehicle(), curTime());
}
m_pCurb->NotifyObservers();//notify waiting vehicles
}
void ArrivalPaxLandsideBehavior::ProcessPutCarryonToVehicle( const ElapsedTime& eEventTime )
{
ElapsedTime serviceT = ElapsedTime(0L);
LandsideResourceInSim* pRes = getResource();
LandsideVehicleInSim* pV = getVehicle();
if(pRes && pV)
{
serviceT = pRes->getLayoutObject()->GetServiceTime(pV->getName());
}
ElapsedTime nextT = eEventTime+serviceT;
WriteLogEntry(nextT);
////go to the parking
//ARCVector3 bagPos = m_pVehicle->getLastState().pos;
//setDestination(bagPos);
//ElapsedTime dNextTime = eEventTime;
//dNextTime += moveTime();
////setLocation(bagPos);
//WriteLogEntry(dNextTime);
////write bag log
//Passenger* pPassenger = (Passenger*)m_pPerson;
//int nCount = pPassenger->m_pVisitorList.size();
//for( int i=nCount-1; i>=0; i-- )
//{
// PaxVisitor* pVis = pPassenger->m_pVisitorList[i];
// if (pVis == NULL)
// continue;
// VisitorLandsideBehavior* pCarryonBehavior = (VisitorLandsideBehavior*)pVis->getLandsideBehavior();
// ASSERT(pCarryonBehavior);
// //non passenger move to ground
// if(pCarryonBehavior)
// {
// pCarryonBehavior->setDestination(bagPos);
// ElapsedTime eMoveTime = moveTime();
// ElapsedTime eCurTime = dNextTime + eMoveTime;
// pCarryonBehavior->setLocation( bagPos);
// pCarryonBehavior->WriteLogEntry(eCurTime, i);
// }
// //detach to passenger
// pPassenger->m_pVisitorList[i] = NULL;
//}
setState(GetOnVehicle);
GenerateEvent(nextT);
}
void State_TryParkingCurbside::Execute( CARCportEngine * pEngine )
{
LandsideLaneNodeList path;
if(IParkingSpotInSim* spot = m_pCurb->getParkingSpot().FindParkingPos(getVehicle(),path) )
{
spot->SetPreOccupy(m_pOwner);
State_ParkingToCurbside* pNextState = new State_ParkingToCurbside(getVehicle(),spot,m_pCurb);
pNextState->SetPath(path);
getVehicle()->ChangeVehicleState(pNextState);
m_waitTimer.SetEnd(true);
return;
}
if( m_waitTimer.isEnded() ) //fail parking to curb
{
getVehicle()->FailedParkInCurb(m_pCurb,pEngine);
return;
}
else
{
m_pCurb->AddObserver(getVehicle());
///m_pOwner->ListenTo(m_pCurb);
}
}
bool
Person::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper) {
switch (variable) {
case TRACI_ID_LIST:
return wrapper->wrapStringList(objID, variable, getIDList());
case ID_COUNT:
return wrapper->wrapInt(objID, variable, getIDCount());
case VAR_POSITION:
return wrapper->wrapPosition(objID, variable, getPosition(objID));
case VAR_POSITION3D:
return wrapper->wrapPosition(objID, variable, getPosition(objID, true));
case VAR_ANGLE:
return wrapper->wrapDouble(objID, variable, getAngle(objID));
case VAR_SLOPE:
return wrapper->wrapDouble(objID, variable, getSlope(objID));
case VAR_SPEED:
return wrapper->wrapDouble(objID, variable, getSpeed(objID));
case VAR_ROAD_ID:
return wrapper->wrapString(objID, variable, getRoadID(objID));
case VAR_LANEPOSITION:
return wrapper->wrapDouble(objID, variable, getLanePosition(objID));
case VAR_COLOR:
return wrapper->wrapColor(objID, variable, getColor(objID));
case VAR_WAITING_TIME:
return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
case VAR_TYPE:
return wrapper->wrapString(objID, variable, getTypeID(objID));
case VAR_NEXT_EDGE:
return wrapper->wrapString(objID, variable, getNextEdge(objID));
case VAR_STAGES_REMAINING:
return wrapper->wrapInt(objID, variable, getRemainingStages(objID));
case VAR_VEHICLE:
return wrapper->wrapString(objID, variable, getVehicle(objID));
default:
return false;
}
}
void ArrivalPaxLandsideBehavior::ProcessGetOnVehicle( const ElapsedTime& eEventTime )
{
WriteLogEntry(eEventTime);
setState(StayOnVehicle);
WriteLogEntry(eEventTime);
//Notify vehicle that one passenger has moved into
//
LandsideVehicleInSim* pVehicle = getVehicle();
if(pVehicle)
{
if(LandsideResourceInSim* pRes = getResource())
{
pRes->PassengerMoveOut(this,eEventTime);
}
pVehicle->AddOnPax(this);
pVehicle->NotifyPaxMoveInto(m_pPerson->getEngine(),this, eEventTime);
}
else
{
ASSERT(FALSE);
}
}
void State_ParkingToCurbside::OnMoveOutRoute( CARCportEngine* _pEngine )
{
getVehicle()->DoParkingToSpot(m_spot);
getVehicle()->SuccessParkInCurb(m_pCurb,m_spot);
}
bool Activities::ExitVehicle::update(CharacterObject *character,
CharacterController *controller) {
RW_UNUSED(controller);
if (jacked) {
const auto jacked_lhs = AnimCycle::CarJackedLHS;
const auto jacked_rhs = AnimCycle::CarJackedRHS;
const auto cycle_current = character->getCurrentCycle();
if (cycle_current == jacked_lhs || cycle_current == jacked_rhs) {
if (character->animator->isCompleted(AnimIndexAction)) {
return true;
}
} else {
if (character->getCurrentVehicle() == nullptr) return true;
auto vehicle = character->getCurrentVehicle();
auto seat = character->getCurrentSeat();
auto door = vehicle->getSeatEntryDoor(seat);
RW_UNUSED(door);
auto exitPos = vehicle->getSeatEntryPositionWorld(seat);
auto exitPosLocal = vehicle->getSeatEntryPosition(seat);
character->rotation = vehicle->getRotation();
// Exit the vehicle immediatley
character->enterVehicle(nullptr, seat);
character->setPosition(exitPos);
if (exitPosLocal.x > 0.f) {
character->playCycle(jacked_rhs);
} else {
character->playCycle(jacked_lhs);
}
// No need to open the door, it should already be open.
}
return false;
}
if (character->getCurrentVehicle() == nullptr) return true;
auto vehicle = character->getCurrentVehicle();
auto seat = character->getCurrentSeat();
auto door = vehicle->getSeatEntryDoor(seat);
auto exitPos = vehicle->getSeatEntryPositionWorld(seat);
auto exitPosLocal = vehicle->getSeatEntryPosition(seat);
auto cycle_exit = AnimCycle::CarGetOutLHS;
if (exitPosLocal.x > 0.f) {
cycle_exit = AnimCycle::CarGetOutRHS;
}
if (vehicle->getVehicle()->vehicletype_ == VehicleModelInfo::BOAT) {
auto ppos = character->getPosition();
character->enterVehicle(nullptr, seat);
character->setPosition(ppos);
return true;
}
bool isDriver = vehicle->isOccupantDriver(character->getCurrentSeat());
// If the vehicle is going too fast, slow down
if (isDriver) {
if (!vehicle->canOccupantExit()) {
vehicle->setBraking(1.f);
return false;
}
}
if (character->getCurrentCycle() == cycle_exit) {
if (character->animator->isCompleted(AnimIndexAction)) {
character->enterVehicle(nullptr, seat);
character->setPosition(exitPos);
if (isDriver) {
// Apply the handbrake
vehicle->setHandbraking(true);
vehicle->setThrottle(0.f);
}
return true;
}
} else {
character->playCycle(cycle_exit);
if (door) {
vehicle->setPartTarget(door, true, door->openAngle);
}
}
return false;
}
