Пример #1
0
bool PSpawnedVehicles::UnspawnVehicle( u32 nLocalId )
{
  u16 Index;
  PSpawnedVehicle* tVhc;

  if (( nLocalId <= mVhcBaseLocalId ) && ( nLocalId > ( mVhcBaseLocalId - mSpawnedVehicles.size() ) ) )
  {
    Index = mVhcBaseLocalId - nLocalId;
    tVhc = mSpawnedVehicles[Index];
    if ( tVhc )
    {
      if ( tVhc->GetInformation().GetStatus() != 2 )
      {
        tVhc->SetStatus( 0 );
      }
      delete tVhc;
      mSpawnedVehicles[Index] = NULL;
      if ( mNextFreeHint > Index )
      {
        mNextFreeHint = Index;
      }
      return true;
    }
  }

  return false;
}
Пример #2
0
PSpawnedVehicle* PSpawnedVehicles::SpawnVehicle( PVehicleInformation const* nVhcInfo, PVhcCoordinates const* nVhcPos )
{
  PSpawnedVehicle* newVhc = NULL;
  u32 nSize;

  if ( nVhcInfo->GetStatus() == 0 ) // only if in garage
  {
    nSize = mSpawnedVehicles.size();
    while (( mNextFreeHint < nSize ) && mSpawnedVehicles[mNextFreeHint] )
    {
      ++mNextFreeHint;
    }
    if ( mNextFreeHint > nSize )
    {
      mNextFreeHint = nSize;
    }
    if ( mNextFreeHint == nSize )
    {
      mSpawnedVehicles.push_back( static_cast<PSpawnedVehicle *>(NULL) );
    }

    if ( mNextFreeHint < mMaxLocalVhc )
    {
      newVhc = new PSpawnedVehicle( mVhcBaseLocalId - mNextFreeHint, nVhcInfo, mLocation, nVhcPos );
      mSpawnedVehicles[mNextFreeHint++] = newVhc;
      newVhc->SetStatus( 1 );
    }
  }

  return newVhc;
}
Пример #3
0
bool PVehicles::GetVehicleInfo( u32 nVehicleId, PVehicleInformation* nInfo ) const
{
  PSpawnedVehicle* tVhc = GetSpawnedVehicle( nVehicleId );
  if ( tVhc )
  {
    *nInfo = tVhc->GetInformation();
    return true;
  }
  else
  {
    return nInfo->Load( nVehicleId );
  }
}
Пример #4
0
PSpawnedVehicle* PVehicles::SpawnVehicle( u32 nVehicleId, u32 nLocation, PVhcCoordinates const* nVhcPos )
{
  PSpawnedVehicle* newVhc = NULL;
  PWorld* cWorld;
  PVehicleInformation nVhcInfo;

  if (( nLocation != PWorlds::mNcSubwayWorldId ) && IsValidVehicle( nVehicleId ) && !IsSpawned( nVehicleId ) )
  {
    cWorld = Worlds->LeaseWorld( nLocation );

    if ( cWorld && GetVehicleInfo( nVehicleId, &nVhcInfo ) )
    {
      newVhc = cWorld->GetSpawnedVehicules()->SpawnVehicle( &nVhcInfo, nVhcPos );
      if ( newVhc )
      {
        if ( !RegisterSpawnedVehicle( newVhc ) )
        {
          Console->Print( RED, BLACK, "[Error] PVehicles::SpawnVehicle : Could not register spawned vhc" );
        }
        if( gDevDebug )
          Console->Print( "%d Spawned vhc %d (local 0x%04x) type %d (requested: %d)", Console->ColorText( CYAN, BLACK, "[DEBUG]" ), newVhc->GetVehicleId(), newVhc->GetLocalId(), newVhc->GetInformation().GetVehicleType(), nVhcInfo.GetVehicleType() );
      }
      else
        Console->Print( RED, BLACK, "[Error] PVehicles::SpawnVehicle : Could not create vhc" );
    }

    Worlds->ReleaseWorld( nLocation );
  }

  return newVhc;
}
Пример #5
0
bool PUdpSync2::DoAction()
{
  if (( mDecodeData->mState & DECODE_ACTION_READY ) && ( mDecodeData->mClientState->UDP.mState == PGameState::UDP::GUS_SYNC2 ) )
  {
    PClient* nClient = mDecodeData->mClient;

    // Baseline message chunking & sending
    PMessage* BaselineMsg = MsgBuilder->BuildBaselineMsg( nClient );
    nClient->FragmentAndSendUDPMessage( BaselineMsg, 0x19 );

    // Sending "CharInfo3/Zoning2Msg" message
    // Removed because same as Zoning2Msg
    PMessage* Zoning2Msg = MsgBuilder->BuildZoning2Msg( nClient, mClientTime );
    nClient->SendUDPMessage( Zoning2Msg );

    mDecodeData->mClientState->UDP.mState = PGameState::UDP::GUS_SYNC3;
    nClient->SetZoning( false );

    // If char is sitting (vhz zoning), send it now to client
    u32 nSeatableObjectId;
    u8 nSeatId;
    if( nClient->GetChar()->GetSeatInUse(&nSeatableObjectId, &nSeatId) )
    {
      if( gDevDebug )
        Console->Print( YELLOW, BLACK, "[DEBUG] PUdpSync2::DoAction : Char %d sitting on vhc id %d, seat %d", nClient->GetLocalID(), nSeatableObjectId, nSeatId  );
      PMessage* SittingMsg = MsgBuilder->BuildCharUseSeatMsg( nClient, nSeatableObjectId, nSeatId );
      nClient->FillInUDP_ID(SittingMsg);
      nClient->SendUDPMessage( SittingMsg );
    }

    //Temp: send Subway to client if in subway
    if ( nClient->GetChar()->GetLocation() == PWorlds::mNcSubwayWorldId )
    {
      PMessage* SubwayMsg = MsgBuilder->BuildSubwaySpawnMsg( nClient, false );
      nClient->SendUDPMessage( SubwayMsg );
      SubwayMsg = MsgBuilder->BuildSubwaySpawnMsg( nClient, true );
      nClient->SendUDPMessage( SubwayMsg );
    }

    // Send spawned vehicles
    PWorld* CurrentWorld = Worlds->GetWorld( nClient->GetChar()->GetLocation() );
    if ( CurrentWorld )
    {
      PSpawnedVhcList* VhcList = CurrentWorld->GetSpawnedVehicules()->GetSpawnedVehicles();
      PSpawnedVehicle* VhcEntry;
      PMessage* VhcMsg;

      while ( ! VhcList->empty() )
      {
        VhcEntry = VhcList->front();
        VhcList->pop();
        if( gDevDebug )
          Console->Print( YELLOW, BLACK, "[DEBUG] PUdpSync2::DoAction : Send info for vhc id %d", VhcEntry->GetLocalId() );
        VhcMsg = MsgBuilder->BuildVhcPosUpdateMsg( VhcEntry );
        nClient->FillInUDP_ID( VhcMsg );
        nClient->SendUDPMessage( VhcMsg );
        VhcMsg = MsgBuilder->BuildVhcInfoMsg( nClient, VhcEntry );
        nClient->SendUDPMessage( VhcMsg );
      }
    }

    // Dispatching info to & from other chars in zone
    int nbSent;
    nbSent = ClientManager->SendUDPZoneWelcomeToClient( nClient );
//Console->Print(GREEN, BLACK, " %d Welcome message were sent to client %d", nbSent, Client->GetIndex());

    PMessage* HelloMsg = MsgBuilder->BuildCharHelloMsg( nClient );
    nbSent = ClientManager->UDPBroadcast( HelloMsg, nClient );
//Console->Print(GREEN, BLACK, "Client %d: Hello message sent to %d chars", Client->GetIndex(), nbSent);

    // Send worldactors to client
    WorldActors->InitWorld( nClient );

    // Send NPC information to client
    NPCManager->InitPlayer( nClient );

    //Console->Print("OP Data inc");
    Outposts->SendOPAreaData( nClient );

    mDecodeData->mState = DECODE_ACTION_DONE | DECODE_FINISHED;
    return true;
  }
  else
    return false;
}