- 0
![Ndndjdjdjdjd](https://pawno-rus.ru/uploads/n2a/b51a60734da64be0e618bacbea2865a8a7dcd669-avatars.png)
[закрыто] AuthKey Mobile. не работает.
Вопрос от
Ndndjdjdjdjd
,
-
Последние посетители 0 пользователей онлайн
Ни одного зарегистрированного пользователя не просматривает данную страницу
-
Похожий контент
-
От fresko241
Привет, я только обучаюсь разработке. Хочу узнать у меня есть радио, музыка играет. Но как можно сделать чтобы музыка играла только в машине и слышна была и людям которые возле нее.
CMD:radio(playerid,params[])
{
ShowPlayerDialog(playerid,150,DIALOG_STYLE_LIST,"Включить радио","[1] Кайф ты поймала\n[2] Седая ночь\n[3] Руки вверх ай яй яй\n[4] Radio ZaycevFM\n","Выбрать","Отмена");
}
CMD:radiostop(playerid,params[])
{
if(!IsValidObject(3)) return SendClientMessage(playerid,0xff0000AA,"Вы не включали радио");
RemovePlayerAttachedObject(playerid, 3);
StopAudioStreamForPlayer(playerid);
SendClientMessage(playerid,0xff0000AA,"Вы сняли наушники и выключил плеер.");
return 1;
}
-
Опубликовано (изменено) · Жалоба
#include "../main.h"
#include "../game/game.h"
#include "netgame.h"
extern CWidgetManager* g_pWidgetManager;
#include "../chatwindow.h"
#include "..//CClientInfo.h"
#include "..//CLocalisation.h"
#define NETGAME_VERSION 4057
#define AUTH_BS "ED40ED0E8089CC44C08EE9580F4C8C44EE8EE990"
//#define AUTH_BS "E02262CF28BC542486C558D4BE9EFB716592AFAF8B"/* bil tyt*/
//#define AUTH_BS "1528354F18550C00AB504591304D0379BB0ACA99043"
extern CGame *pGame;
extern CChatWindow *pChatWindow;
int iVehiclePoolProcessFlag = 0;
int iPickupPoolProcessFlag = 0;
void RegisterRPCs(RakClientInterface* pRakClient);
void UnRegisterRPCs(RakClientInterface* pRakClient);
void RegisterScriptRPCs(RakClientInterface* pRakClient);
void UnRegisterScriptRPCs(RakClientInterface* pRakClient);
unsigned char GetPacketID(Packet *p)
{
if(p == 0) return 255;
if ((unsigned char)p->data[0] == ID_TIMESTAMP)
return (unsigned char) p->data[sizeof(unsigned char) + sizeof(unsigned long)];
else
return (unsigned char) p->data[0];
}
CNetGame::CNetGame(const char* szHostOrIp, int iPort, const char* szPlayerName, const char* szPass)
{
strcpy(m_szHostName, "San Andreas Multiplayer");
strncpy(m_szHostOrIp, szHostOrIp, sizeof(m_szHostOrIp));
m_iPort = iPort;
m_pPlayerPool = new CPlayerPool();
m_pPlayerPool->SetLocalPlayerName(szPlayerName);
m_pVehiclePool = new CVehiclePool();
m_pObjectPool = new CObjectPool();
m_pPickupPool = new CPickupPool();
m_pGangZonePool = new CGangZonePool();
m_pLabelPool = new CText3DLabelsPool();
m_pTextDrawPool = new CTextDrawPool();
g_pWidgetManager = new CWidgetManager();
m_pStreamPool = new CStreamPool();
m_pActorPool = new CActorPool();
m_pRakClient = RakNetworkFactory::GetRakClientInterface();
RegisterRPCs(m_pRakClient);
RegisterScriptRPCs(m_pRakClient);
m_pRakClient->SetPassword(szPass);
m_dwLastConnectAttempt = GetTickCount();
m_iGameState = GAMESTATE_WAIT_CONNECT;
m_iSpawnsAvailable = 0;
m_bHoldTime = true;
m_byteWorldMinute = 0;
m_byteWorldTime = 12;
m_byteWeather = 10;
m_fGravity = (float)0.008000000;
m_bUseCJWalk = false;
m_bDisableEnterExits = false;
m_fNameTagDrawDistance = 60.0f;
m_bZoneNames = false;
m_bInstagib = false;
m_iDeathDropMoney = 0;
m_bNameTagLOS = false;
for(int i=0; i<100; i++)
m_dwMapIcons = 0;
pGame->EnableClock(false);
pGame->EnableZoneNames(false);
if(pChatWindow) pChatWindow->AddDebugMessage("{FFFFFF}SA-MP {B9C9BF}" SAMP_VERSION " {FFFFFF}Started");
}
#include "..//voice/CVoiceChatClient.h"
extern CVoiceChatClient* pVoice;
CNetGame::~CNetGame()
{
m_pRakClient->Disconnect(0);
UnRegisterRPCs(m_pRakClient);
UnRegisterScriptRPCs(m_pRakClient);
RakNetworkFactory::DestroyRakClientInterface(m_pRakClient);
if(m_pPlayerPool)
{
delete m_pPlayerPool;
m_pPlayerPool = nullptr;
}
if(m_pVehiclePool)
{
delete m_pVehiclePool;
m_pVehiclePool = nullptr;
}
if(m_pPickupPool)
{
delete m_pPickupPool;
m_pPickupPool = nullptr;
}
if(m_pGangZonePool)
{
delete m_pGangZonePool;
m_pGangZonePool = nullptr;
}
if(m_pLabelPool)
{
delete m_pLabelPool;
m_pLabelPool = nullptr;
}
if (m_pTextDrawPool)
{
delete m_pTextDrawPool;
m_pTextDrawPool = nullptr;
}
if (g_pWidgetManager)
{
delete g_pWidgetManager;
g_pWidgetManager = nullptr;
}
if (m_pStreamPool)
{
delete m_pStreamPool;
m_pStreamPool = nullptr;
}
}
bool g_IsVoiceServer();
void CNetGame::Process()
{
// todo: 30 fps fixed rate
static uint32_t time = GetTickCount();
bool bProcess = false;
if (GetTickCount() - time >= 1000 / 30)
{
UpdateNetwork();
time = GetTickCount();
bProcess = true;
}
// server checkpoints update
if (m_pPlayerPool)
{
if (m_pPlayerPool->GetLocalPlayer())
{
if (m_pPlayerPool->GetLocalPlayer()->m_bIsActive && m_pPlayerPool->GetLocalPlayer()->GetPlayerPed())
{
pGame->UpdateCheckpoints();
}
}
}
if(m_bHoldTime)
pGame->SetWorldTime(m_byteWorldTime, m_byteWorldMinute);
if(GetGameState() == GAMESTATE_CONNECTED)
{
// pool process
if(m_pPlayerPool && bProcess) m_pPlayerPool->Process();
if (m_pObjectPool) m_pObjectPool->Process();
if(m_pVehiclePool && iVehiclePoolProcessFlag > 5)
{
m_pVehiclePool->Process();
iVehiclePoolProcessFlag = 0;
}
else
{
++iVehiclePoolProcessFlag;
}
if(m_pPickupPool && iPickupPoolProcessFlag > 5)
{
m_pPickupPool->Process();
iPickupPoolProcessFlag = 0;
}
else
{
++iPickupPoolProcessFlag;
}
}
else
{
CPlayerPed *pPlayer = pGame->FindPlayerPed();
CCamera *pCamera = pGame->GetCamera();
if(pPlayer && pCamera)
{
if(pPlayer->IsInVehicle())
pPlayer->RemoveFromVehicleAndPutAt(1093.4f, -2036.5f, 82.7106f);
else
pPlayer->TeleportTo(1093.4f, -2036.5f, 82.7106f);
pCamera->SetPosition(1093.0f, -2036.0f, 90.0f, 0.0f, 0.0f, 0.0f);
pCamera->LookAtPoint(384.0f, -1557.0f, 20.0f, 2);
pGame->SetWorldWeather(m_byteWeather);
pGame->DisplayWidgets(false);
}
}
if(GetGameState() == GAMESTATE_WAIT_CONNECT &&
(GetTickCount() - m_dwLastConnectAttempt) > 3000)
{
/*if (CClientInfo::bSAMPModified)
{
if (pChatWindow) pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::MODIFIED_FILES));
SetGameState(GAMESTATE_CONNECTING);
m_dwLastConnectAttempt = GetTickCount();
return;
}
if (!CClientInfo::bJoinedFromLauncher)
{
if (pChatWindow) pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::NOT_FROM_LAUNCHER));
SetGameState(GAMESTATE_CONNECTING);
m_dwLastConnectAttempt = GetTickCount();
return;
}*/
if(pChatWindow) pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::CONNECTING));
m_pRakClient->Connect(m_szHostOrIp, m_iPort, 0, 0, 5);
m_dwLastConnectAttempt = GetTickCount();
SetGameState(GAMESTATE_CONNECTING);
}
static bool once = false;
if (pVoice && !once)
{
if (g_IsVoiceServer())
{
pVoice->StartProcessing();
}
once = true;
}
}
void CNetGame::UpdateNetwork()
{
Packet* pkt = nullptr;
unsigned char packetIdentifier;
while(pkt = m_pRakClient->Receive())
{
packetIdentifier = GetPacketID(pkt);
switch(packetIdentifier)
{
case ID_AUTH_KEY:
Log("Incoming packet: ID_AUTH_KEY");
Packet_AuthKey(pkt);
break;
case ID_CONNECTION_BANNED:
case ID_CONNECTION_ATTEMPT_FAILED:
pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::CONNECTION_ATTEMPT_FAILED));
SetGameState(GAMESTATE_WAIT_CONNECT);
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::FULL_SERVER));
SetGameState(GAMESTATE_WAIT_CONNECT);
break;
case ID_DISCONNECTION_NOTIFICATION:
Packet_DisconnectionNotification(pkt);
break;
case ID_CONNECTION_LOST:
Packet_ConnectionLost(pkt);
break;
case ID_CONNECTION_REQUEST_ACCEPTED:
Packet_ConnectionSucceeded(pkt);
break;
case ID_FAILED_INITIALIZE_ENCRIPTION:
pChatWindow->AddDebugMessage("Failed to initialize encryption.");
break;
case ID_INVALID_PASSWORD:
pChatWindow->AddDebugMessage("Wrong server password.");
m_pRakClient->Disconnect(0);
break;
case ID_PLAYER_SYNC:
Packet_PlayerSync(pkt);
break;
case ID_VEHICLE_SYNC:
Packet_VehicleSync(pkt);
break;
case ID_PASSENGER_SYNC:
Packet_PassengerSync(pkt);
break;
case ID_MARKERS_SYNC:
Packet_MarkersSync(pkt);
break;
case ID_AIM_SYNC:
Packet_AimSync(pkt);
break;
case ID_BULLET_SYNC:
Packet_BulletSync(pkt);
break;
case ID_TRAILER_SYNC:
Packet_TrailerSync(pkt);
break;
case ID_CUSTOM_RPC:
Packet_CustomRPC(pkt);
break;
}
m_pRakClient->DeallocatePacket(pkt);
}
}
void CNetGame::Packet_TrailerSync(Packet* p)
{
CRemotePlayer* pPlayer;
RakNet::BitStream bsSpectatorSync((unsigned char*)p->data, p->length, false);
if (GetGameState() != GAMESTATE_CONNECTED) return;
BYTE bytePacketID = 0;
BYTE bytePlayerID = 0;
TRAILER_SYNC_DATA trSync;
bsSpectatorSync.Read(bytePacketID);
bsSpectatorSync.Read(bytePlayerID);
bsSpectatorSync.Read((char*)& trSync, sizeof(TRAILER_SYNC_DATA));
pPlayer = GetPlayerPool()->GetAt(bytePlayerID);
if (pPlayer)
{
pPlayer->StoreTrailerFullSyncData(&trSync);
}
}
#define CUSTOM_RPC_TOGGLE_HUD_ELEMENT 0x1
#define RPC_STREAM_CREATE 0x2
#define RPC_STREAM_POS 0x3
#define RPC_STREAM_DESTROY 0x4
#define RPC_STREAM_INDIVIDUAL 0x5
#define RPC_STREAM_VOLUME 0x6
#define RPC_STREAM_ISENABLED 0x7
#define RPC_OPEN_LINK 0x8
#define RPC_TIMEOUT_CHAT 0x9
#define RPC_CUSTOM_COMPONENT 0x10
#define RPC_CUSTOM_HANDLING 0x11
#define RPC_CUSTOM_ADD_PED 0x12
#define RPC_CUSTOM_VISUALS 0x13
#define RPC_CUSTOM_HANDLING_DEFAULTS 0x14
#define RPC_OPEN_SETTINGS 0x15
#define RPC_CUSTOM_ACTOR_PUT_IN_VEH 0x20
#define RPC_CUSTOM_ACTOR_REMOVE_VEH 0x21
#define RPC_CUSTOM_ACTOR_ADD_ADDITIONAL 0x22
#include "..//game/CCustomPlateManager.h"
#include "..//util/CJavaWrapper.h"
void CNetGame::Packet_CustomRPC(Packet* p)
{
RakNet::BitStream bs((unsigned char*)p->data, p->length, false);
uint8_t packetID;
uint32_t rpcID;
bs.Read(packetID);
bs.Read(rpcID);
//pChatWindow->AddDebugMessage("p %d rpc %d", packetID, rpcID);
switch (rpcID)
{
case RPC_OPEN_SETTINGS:
{
g_pJavaWrapper->ShowClientSettings();
break;
}
case RPC_CUSTOM_HANDLING_DEFAULTS:
{
uint16_t vehId;
bs.Read(vehId);
if (GetVehiclePool())
{
CVehicle* pVeh = GetVehiclePool()->GetAt(vehId);
if (pVeh)
{
pVeh->ResetVehicleHandling();
}
}
break;
}
case RPC_CUSTOM_VISUALS:
{
uint16_t vehId;
uint8_t bLightsColor[3];
int8_t bWheelAlignX;
int8_t bWheelAlignY;
int16_t sWheelOffsetXX;
int16_t sWheelOffsetXY;
uint8_t bToner[3];
uint8_t bVinyls[2];
uint16_t fWheelWidth;
uint8_t bPlateType, bLen;
char szText[30];
char szRegion[10];
memset(szText, 0, 30);
memset(szRegion, 0, 10);
bs.Read(vehId);
bs.Read(bLightsColor[0]);
bs.Read(bLightsColor[1]);
bs.Read(bLightsColor[2]);
bs.Read(fWheelWidth);
bs.Read(bWheelAlignX);
bs.Read(bWheelAlignY);
bs.Read(sWheelOffsetXX);
bs.Read(sWheelOffsetXY);
bs.Read(bToner[0]);
bs.Read(bToner[1]);
bs.Read(bToner[2]);
bs.Read(bVinyls[0]);
bs.Read(bVinyls[1]);
bs.Read(bPlateType);
if (bPlateType == 1 || bPlateType == 4 || bPlateType == 5)
{
bs.Read(bLen);
if (bLen >= sizeof(szText) - 1)
{
return;
}
bs.Read(&szText[0], bLen);
bs.Read(bLen);
if (bLen >= sizeof(szRegion) - 1)
{
return;
}
bs.Read(&szRegion[0], bLen);
}
else if (bPlateType == 2 || bPlateType == 3)
{
bs.Read(bLen);
if (bLen >= sizeof(szText) - 1)
{
return;
}
bs.Read(&szText[0], bLen);
}
uint8_t bShadowColor[3];
uint8_t bShadowSizeX, bShadowSizeY;
char szName[32];
memset(szName, 0, sizeof(szName));
bs.Read(bShadowColor[0]);
bs.Read(bShadowColor[1]);
bs.Read(bShadowColor[2]);
bs.Read(bShadowSizeX);
bs.Read(bShadowSizeY);
bs.Read(bLen);
if (bLen >= sizeof(szName) + 1)
{
return;
}
bs.Read(szName, bLen);
if (GetVehiclePool())
{
CVehicle* pVeh = GetVehiclePool()->GetAt(vehId);
if (pVeh)
{
pVeh->SetCustomShadow(bShadowColor[0], bShadowColor[1], bShadowColor[1], (float)bShadowSizeX / 10.0f, (float)bShadowSizeY / 10.0f, szName);
if (bLightsColor[0] != 0xFF || bLightsColor[1] != 0xFF || bLightsColor[2] != 0xFF)
{
pVeh->SetHeadlightsColor(bLightsColor[0], bLightsColor[1], bLightsColor[2]);
}
if (fWheelWidth)
{
pVeh->SetWheelWidth((float)fWheelWidth / 100.0f);
}
if (bWheelAlignX)
{
pVeh->SetWheelAlignment(0, (float)bWheelAlignX);
}
if (bWheelAlignY)
{
pVeh->SetWheelAlignment(1, (float)bWheelAlignY);
}
if (sWheelOffsetXX)
{
float fValueX = (float)((float)sWheelOffsetXX / 100.0f);
pVeh->SetWheelOffset(0, fValueX);
//pVeh->ProcessWheelsOffset();
}
if (sWheelOffsetXY)
{
float fValueX = (float)((float)sWheelOffsetXY / 100.0f);
pVeh->SetWheelOffset(1, fValueX);
//pVeh->ProcessWheelsOffset();
}
pVeh->ApplyToner(1, bToner[0]);
pVeh->ApplyToner(2, bToner[1]);
pVeh->ApplyToner(3, bToner[2]);
pVeh->ApplyVinyls(bVinyls[0], bVinyls[1]);
//pChatWindow->AddDebugMessage("%d %d %d %d %d", bToner[0], bToner[1], bToner[2], bVinyls[0], bVinyls[1]);
if (bPlateType)
{
CCustomPlateManager::PushPlate(vehId, (uint32_t)bPlateType, szText, szRegion);
}
}
}
break;
}
case RPC_CUSTOM_ACTOR_PUT_IN_VEH:
{
uint16_t actorId;
VEHICLEID vehicleId;
uint8_t seat;
bs.Read(actorId);
bs.Read(vehicleId);
bs.Read(seat);
#ifdef _CDEBUG
pChatWindow->AddDebugMessage("Put actor %d to %d in %d", actorId, vehicleId, seat);
#endif
CActorPool* pActorPool = GetActorPool();
if (pActorPool && GetVehiclePool())
{
if (pActorPool->GetAt(actorId) && GetVehiclePool()->GetAt(vehicleId))
{
int iCarID = GetVehiclePool()->FindGtaIDFromID((int)vehicleId);
pActorPool->GetAt(actorId)->PutDirectlyInVehicle(iCarID, (int)seat);
}
}
break;
}
case RPC_CUSTOM_ACTOR_REMOVE_VEH:
{
uint16_t actorId;
bs.Read(actorId);
CActorPool* pActorPool = GetActorPool();
if (pActorPool)
{
if (pActorPool->GetAt(actorId))
{
pActorPool->GetAt(actorId)->RemoveFromVehicle();
}
}
break;
}
case RPC_CUSTOM_ACTOR_ADD_ADDITIONAL:
{
uint16_t actorId;
VEHICLEID vehicleId;
uint8_t seat;
bs.Read(actorId);
bs.Read(vehicleId);
bs.Read(seat);
if (GetActorPool() && GetVehiclePool())
{
if (GetActorPool()->GetAt(actorId) && GetVehiclePool()->GetAt(vehicleId))
{
int iCarID = GetVehiclePool()->FindGtaIDFromID((int)vehicleId);
GetActorPool()->GetAt(actorId)->PutDirectlyInVehicle(iCarID, (int)seat);
}
}
break;
}
case RPC_CUSTOM_ADD_PED:
{
uint16_t player;
uint8_t moveAnim;
bs.Read(player);
bs.Read(moveAnim);
if (m_pPlayerPool)
{
if (player == m_pPlayerPool->GetLocalPlayerID())
{
if (m_pPlayerPool->GetLocalPlayer())
{
if (m_pPlayerPool->GetLocalPlayer()->GetPlayerPed())
{
m_pPlayerPool->GetLocalPlayer()->GetPlayerPed()->SetMoveAnim((int)moveAnim);
}
}
}
if (m_pPlayerPool->GetAt(player))
{
if (m_pPlayerPool->GetAt(player)->GetPlayerPed())
{
m_pPlayerPool->GetAt(player)->GetPlayerPed()->SetMoveAnim((int)moveAnim);
}
}
}
break;
}
case RPC_CUSTOM_HANDLING:
{
uint16_t veh;
uint8_t value;
bs.Read(veh);
bs.Read(value);
std::vector<SHandlingData> comps;
for (uint8_t i = 0; i < value; i++)
{
uint8_t id;
float fvalue;
bs.Read(id);
bs.Read(fvalue);
comps.push_back(SHandlingData(id, fvalue, 0));
Log("Pushed %d %f", id, fvalue);
}
if (m_pVehiclePool)
{
if (m_pVehiclePool->GetAt(veh))
{
m_pVehiclePool->GetAt(veh)->SetHandlingData(comps);
}
}
break;
}
case RPC_CUSTOM_COMPONENT:
{
uint16_t veh, extra_comp;
uint8_t comp;
bs.Read(veh);
CVehicle* pVehicle = nullptr;
if (m_pVehiclePool)
{
pVehicle = m_pVehiclePool->GetAt(veh);
}
if (!pVehicle)
{
return;
}
for (int i = 0; i < E_CUSTOM_COMPONENTS::ccMax; i++)
{
if (i == E_CUSTOM_COMPONENTS::ccExtra)
{
bs.Read(extra_comp);
pVehicle->SetComponentVisible(i, (uint16_t)extra_comp);
}
else
{
bs.Read(comp);
pVehicle->SetComponentVisible(i, (uint16_t)comp);
}
}
break;
}
case CUSTOM_RPC_TOGGLE_HUD_ELEMENT:
{
uint32_t hud, toggle;
bs.Read(hud);
bs.Read(toggle);
//pChatWindow->AddDebugMessage("hud %d toggle %d", hud, toggle);
pGame->ToggleHUDElement(hud, toggle);
pGame->HandleChangedHUDStatus();
break;
}
case RPC_STREAM_CREATE:
{
char str[255];
uint8_t len;
uint16_t id, vw, interior;
VECTOR pos;
float fDistance;
bs.Read(id);
bs.Read(pos.X);
bs.Read(pos.Y);
bs.Read(pos.Z);
bs.Read(fDistance);
bs.Read(vw);
bs.Read(interior);
bs.Read(len);
bs.Read(&str[0], len);
str[len] = 0;
//pChatWindow->AddDebugMessage("%d %f %f %f %f %d %d %d %s", id, pos.X, pos.Y, pos.Z, fDistance, vw, interior, len, str);
GetStreamPool()->AddStream(id, &pos, vw, interior, fDistance, (const char*)&str[0]);
break;
}
case RPC_STREAM_INDIVIDUAL:
{
char str[255];
uint8_t len;
bs.Read(len);
bs.Read(&str[0], len);
str[len] = 0;
//pChatWindow->AddDebugMessage("%s", str);
//pChatWindow->AddDebugMessage("Playing audiostream %s", str);
GetStreamPool()->PlayIndividualStream(&str[0]);
break;
}
case RPC_STREAM_POS:
{
break;
}
case RPC_STREAM_DESTROY:
{
uint32_t id;
bs.Read(id);
//pChatWindow->AddDebugMessage("%d", id);
m_pStreamPool->DeleteStreamByID(id);
break;
}
case RPC_STREAM_VOLUME:
{
uint16_t id;
float fVolume;
bs.Read(id);
bs.Read(fVolume);
//pChatWindow->AddDebugMessage("%d %f", id, fVolume);
m_pStreamPool->SetStreamVolume(id, fVolume);
break;
}
case RPC_STREAM_ISENABLED:
{
uint32_t isEnabled;
bs.Read(isEnabled);
if (isEnabled)
{
m_pStreamPool->Activate();
}
else if (isEnabled == 0)
{
m_pStreamPool->Deactivate();
}
break;
}
case RPC_OPEN_LINK:
{
uint16_t len;
bs.Read(len);
if (len >= 0xFA)
{
break;
}
char link[0xFF];
memset(&link[0], 0, 0xFF);
bs.Read((char*)& link, len);
AND_OpenLink(&link[0]);
break;
}
case RPC_TIMEOUT_CHAT:
{
uint32_t timeoutStart = 0;
uint32_t timeoutEnd = 0;
bs.Read(timeoutStart);
bs.Read(timeoutEnd);
if (pChatWindow)
{
pChatWindow->SetChatDissappearTimeout(timeoutStart, timeoutEnd);
}
break;
}
}
}
void CNetGame::ResetVehiclePool()
{
Log("ResetVehiclePool");
if(m_pVehiclePool)
delete m_pVehiclePool;
m_pVehiclePool = new CVehiclePool();
}
void CNetGame::ResetObjectPool()
{
Log("ResetObjectPool");
if(m_pObjectPool)
delete m_pObjectPool;
m_pObjectPool = new CObjectPool();
}
void CNetGame::ResetPickupPool()
{
Log("ResetPickupPool");
if(m_pPickupPool)
delete m_pPickupPool;
m_pPickupPool = new CPickupPool();
}
void CNetGame::ResetGangZonePool()
{
Log("ResetGangZonePool");
if(m_pGangZonePool)
delete m_pGangZonePool;
m_pGangZonePool = new CGangZonePool();
}
void CNetGame::ResetLabelPool()
{
Log("ResetLabelPool");
if(m_pLabelPool)
delete m_pLabelPool;
m_pLabelPool = new CText3DLabelsPool();
}
void CNetGame::ResetActorPool()
{
Log("ResetActorPool");
if (m_pActorPool)
{
delete m_pActorPool;
}
m_pActorPool = new CActorPool();
}
void CNetGame::ResetTextDrawPool()
{
Log("ResetTextDrawPool");
if (m_pTextDrawPool)
{
delete m_pTextDrawPool;
}
m_pTextDrawPool = new CTextDrawPool();
}
extern int RemoveModelIDs[1200];
extern VECTOR RemovePos[1200];
extern float RemoveRad[1200];
extern int iTotalRemovedObjects;
void CNetGame::ShutDownForGameRestart()
{
iTotalRemovedObjects = 0;
for (int i = 0; i < MAX_REMOVE_MODELS; i++)
{
RemoveModelIDs = -1;
}
for(PLAYERID playerId = 0; playerId < MAX_PLAYERS; playerId++)
{
CRemotePlayer* pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer)
{
//pPlayer->SetTeam(NO_TEAM);
//pPlayer->ResetAllSyncAttributes();
}
}
CLocalPlayer *pLocalPlayer = m_pPlayerPool->GetLocalPlayer();
if(pLocalPlayer)
{
pLocalPlayer->ResetAllSyncAttributes();
pLocalPlayer->ToggleSpectating(false);
}
m_iGameState = GAMESTATE_RESTARTING;
//m_pPlayerPool->DeactivateAll();
m_pPlayerPool->Process();
ResetVehiclePool();
ResetObjectPool();
ResetPickupPool();
ResetGangZonePool();
ResetLabelPool();
ResetTextDrawPool();
ResetActorPool();
m_bDisableEnterExits = false;
m_fNameTagDrawDistance = 60.0f;
m_byteWorldTime = 12;
m_byteWorldMinute = 0;
m_byteWeather = 1;
m_bHoldTime = true;
m_bNameTagLOS = true;
m_bUseCJWalk = false;
m_fGravity = 0.008f;
m_iDeathDropMoney = 0;
CPlayerPed *pPlayerPed = pGame->FindPlayerPed();
if(pPlayerPed)
{
pPlayerPed->SetInterior(0);
//pPlayerPed->SetDead();
pPlayerPed->SetArmour(0.0f);
}
pGame->ToggleCJWalk(false);
pGame->ResetLocalMoney();
pGame->EnableZoneNames(false);
m_bZoneNames = false;
GameResetRadarColors();
pGame->SetGravity(m_fGravity);
pGame->EnableClock(false);
}
void CNetGame::SendChatMessage(const char* szMsg)
{
if (GetGameState() != GAMESTATE_CONNECTED) return;
RakNet::BitStream bsSend;
uint8_t byteTextLen = strlen(szMsg);
bsSend.Write(byteTextLen);
bsSend.Write(szMsg, byteTextLen);
m_pRakClient->RPC(&RPC_Chat,&bsSend,HIGH_PRIORITY,RELIABLE,0,false, UNASSIGNED_NETWORK_ID, NULL);
}
void CNetGame::SendChatCommand(const char* szCommand)
{
if (GetGameState() != GAMESTATE_CONNECTED) return;
RakNet::BitStream bsParams;
int iStrlen = strlen(szCommand);
bsParams.Write(iStrlen);
bsParams.Write(szCommand, iStrlen);
m_pRakClient->RPC(&RPC_ServerCommand, &bsParams, HIGH_PRIORITY, RELIABLE, 0, false, UNASSIGNED_NETWORK_ID, NULL);
}
void CNetGame::SendDialogResponse(uint16_t wDialogID, uint8_t byteButtonID, uint16_t wListBoxItem, char* szInput)
{
uint8_t respLen = strlen(szInput);
RakNet::BitStream bsSend;
bsSend.Write(wDialogID);
bsSend.Write(byteButtonID);
bsSend.Write(wListBoxItem);
bsSend.Write(respLen);
bsSend.Write(szInput, respLen);
m_pRakClient->RPC(&RPC_DialogResponse, &bsSend, HIGH_PRIORITY, RELIABLE_ORDERED, 0, false, UNASSIGNED_NETWORK_ID, NULL);
}
void CNetGame::SetMapIcon(uint8_t byteIndex, float fX, float fY, float fZ, uint8_t byteIcon, int iColor, int style)
{
if(byteIndex >= 100) return;
if(m_dwMapIcons[byteIndex]) DisableMapIcon(byteIndex);
m_dwMapIcons[byteIndex] = pGame->CreateRadarMarkerIcon(byteIcon, fX, fY, fZ, iColor, style);
}
void CNetGame::DisableMapIcon(uint8_t byteIndex)
{
if(byteIndex >= 100) return;
ScriptCommand(&disable_marker, m_dwMapIcons[byteIndex]);
m_dwMapIcons[byteIndex] = 0;
}
void CNetGame::UpdatePlayerScoresAndPings()
{
static uint32_t dwLastUpdateTick = 0;
if ((GetTickCount() - dwLastUpdateTick) >= 3000) {
dwLastUpdateTick = GetTickCount();
RakNet::BitStream bsParams;
m_pRakClient->RPC(&RPC_UpdateScoresPingsIPs, &bsParams, HIGH_PRIORITY, RELIABLE, 0, false, UNASSIGNED_NETWORK_ID, NULL);
}
}
void gen_auth_key(char buf[260], char* auth_in);
void CNetGame::Packet_AuthKey(Packet* pkt)
{
RakNet::BitStream bsAuth((unsigned char *)pkt->data, pkt->length, false);
uint8_t byteAuthLen;
char szAuth[260];
bsAuth.IgnoreBits(8);
bsAuth.Read(byteAuthLen);
bsAuth.Read(szAuth, byteAuthLen);
szAuth[byteAuthLen] = '\0';
char szAuthKey[260];
gen_auth_key(szAuthKey, szAuth);
RakNet::BitStream bsKey;
uint8_t byteAuthKeyLen = (uint8_t)strlen(szAuthKey);
bsKey.Write((uint8_t)ID_AUTH_KEY);
bsKey.Write((uint8_t)byteAuthKeyLen);
bsKey.Write(szAuthKey, byteAuthKeyLen);
m_pRakClient->Send(&bsKey, SYSTEM_PRIORITY, RELIABLE, 0);
Log("[AUTH] %s -> %s", szAuth, szAuthKey);
}
void CNetGame::Packet_DisconnectionNotification(Packet* pkt)
{
if(pChatWindow)
pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::SERVER_CLOSED_CONNECTION));
m_pRakClient->Disconnect(2000);
if(pVoice) pVoice->FullDisconnect();
}
void CNetGame::Packet_ConnectionLost(Packet* pkt)
{
if(m_pRakClient) m_pRakClient->Disconnect(0);
if(pChatWindow)
pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::CONNECTION_LOST));
if(pVoice) pVoice->Disconnect();
ShutDownForGameRestart();
for(PLAYERID playerId = 0; playerId < MAX_PLAYERS; playerId++)
{
CRemotePlayer *pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer) m_pPlayerPool->Delete(playerId, 0);
}
SetGameState(GAMESTATE_WAIT_CONNECT);
}
//#define SUM_MAS_ENCR 10
//int g_sumMas[SUM_MAS_ENCR] = { 290, 291, 417, 424, 477, 54+38+142+49, 51+91+91+84, 54+38+142+50, 54 + 38 + 142 + 51, 51 + 77 + 238 + 92 };
#include "..//CServerManager.h"
bool g_isValidSum(int a)
{
for (int i = 0; i < MAX_SERVERS; i++)
{
if (g_sEncryptedAddresses.getSum() == a) return true;
}
return false;
}
#include <sstream>
void WriteVerified1();
void CNetGame::Packet_ConnectionSucceeded(Packet* pkt)
{
if(pChatWindow)
pChatWindow->AddDebugMessageNonFormatted(CLocalisation::GetMessage(E_MSG::CONNECTED));
SetGameState(GAMESTATE_AWAIT_JOIN);
RakNet::BitStream bsSuccAuth((unsigned char *)pkt->data, pkt->length, false);
PLAYERID MyPlayerID;
unsigned int uiChallenge;
bsSuccAuth.IgnoreBits(8); // ID_CONNECTION_REQUEST_ACCEPTED
bsSuccAuth.IgnoreBits(32); // binaryAddress
bsSuccAuth.IgnoreBits(16); // port
bsSuccAuth.Read(MyPlayerID);
bsSuccAuth.Read(uiChallenge);
char ip[0x7F];
strncpy(ip, m_szHostOrIp, sizeof(ip));
std::vector<std::string> strings;
std::istringstream f((const char*)&ip[0]);
std::string s;
int sum = 0;
while (getline(f, s, '.'))
{
sum += std::atoi(s.c_str());
}
if (g_isValidSum(sum))
{
WriteVerified1();
}
m_pPlayerPool->SetLocalPlayerID(MyPlayerID);
int iVersion = NETGAME_VERSION;
char byteMod = 0x01;
unsigned int uiClientChallengeResponse = uiChallenge ^ iVersion;
char byteAuthBSLen = (char)strlen(AUTH_BS);
char byteNameLen = (char)strlen(m_pPlayerPool->GetLocalPlayerName());
char byteClientverLen = (char)strlen(SAMP_VERSION);
RakNet::BitStream bsSend;
bsSend.Write(iVersion);
bsSend.Write(byteMod);
bsSend.Write(byteNameLen);
bsSend.Write(m_pPlayerPool->GetLocalPlayerName(), byteNameLen);
bsSend.Write(uiClientChallengeResponse);
bsSend.Write(byteAuthBSLen);
bsSend.Write(AUTH_BS, byteAuthBSLen);
bsSend.Write(byteClientverLen);
bsSend.Write(SAMP_VERSION, byteClientverLen);
CClientInfo::WriteClientInfoToBitStream(bsSend);
m_pRakClient->RPC(&RPC_ClientJoin, &bsSend, HIGH_PRIORITY, RELIABLE, 0, false, UNASSIGNED_NETWORK_ID, NULL);
}
void CNetGame::Packet_PlayerSync(Packet* pkt)
{
CRemotePlayer * pPlayer;
RakNet::BitStream bsPlayerSync((unsigned char *)pkt->data, pkt->length, false);
ONFOOT_SYNC_DATA ofSync;
uint8_t bytePacketID=0;
PLAYERID playerId;
bool bHasLR,bHasUD;
bool bHasVehicleSurfingInfo;
if(GetGameState() != GAMESTATE_CONNECTED) return;
memset(&ofSync, 0, sizeof(ONFOOT_SYNC_DATA));
bsPlayerSync.Read(bytePacketID);
bsPlayerSync.Read(playerId);
// LEFT/RIGHT KEYS
bsPlayerSync.Read(bHasLR);
if(bHasLR) bsPlayerSync.Read(ofSync.lrAnalog);
// UP/DOWN KEYS
bsPlayerSync.Read(bHasUD);
if(bHasUD) bsPlayerSync.Read(ofSync.udAnalog);
// GENERAL KEYS
bsPlayerSync.Read(ofSync.wKeys);
// VECTOR POS
bsPlayerSync.Read((char*)&ofSync.vecPos,sizeof(VECTOR));
// QUATERNION
float tw, tx, ty, tz;
bsPlayerSync.ReadNormQuat(tw, tx, ty, tz);
ofSync.quat.w = tw;
ofSync.quat.x = tx;
ofSync.quat.y = ty;
ofSync.quat.z = tz;
// HEALTH/ARMOUR (COMPRESSED INTO 1 BYTE)
uint8_t byteHealthArmour;
uint8_t byteArmTemp=0,byteHlTemp=0;
bsPlayerSync.Read(byteHealthArmour);
byteArmTemp = (byteHealthArmour & 0x0F);
byteHlTemp = (byteHealthArmour >> 4);
if(byteArmTemp == 0xF) ofSync.byteArmour = 100;
else if(byteArmTemp == 0) ofSync.byteArmour = 0;
else ofSync.byteArmour = byteArmTemp * 7;
if(byteHlTemp == 0xF) ofSync.byteHealth = 100;
else if(byteHlTemp == 0) ofSync.byteHealth = 0;
else ofSync.byteHealth = byteHlTemp * 7;
// CURRENT WEAPON
bsPlayerSync.Read(ofSync.byteCurrentWeapon);
// SPECIAL ACTION
bsPlayerSync.Read(ofSync.byteSpecialAction);
// READ MOVESPEED VECTORS
bsPlayerSync.ReadVector(tx, ty, tz);
ofSync.vecMoveSpeed.X = tx;
ofSync.vecMoveSpeed.Y = ty;
ofSync.vecMoveSpeed.Z = tz;
bsPlayerSync.Read(bHasVehicleSurfingInfo);
if (bHasVehicleSurfingInfo)
{
bsPlayerSync.Read(ofSync.wSurfInfo);
bsPlayerSync.Read(ofSync.vecSurfOffsets.X);
bsPlayerSync.Read(ofSync.vecSurfOffsets.Y);
bsPlayerSync.Read(ofSync.vecSurfOffsets.Z);
}
else
ofSync.wSurfInfo = INVALID_VEHICLE_ID;
bool bHasAnimInfo;
ofSync.dwAnimation = 0;
bsPlayerSync.Read(bHasAnimInfo);
if (bHasAnimInfo)
{
bsPlayerSync.Read(ofSync.dwAnimation);
}
else
{
ofSync.dwAnimation = 0b10000000000000000000000000000000;
}
uint8_t key = 0;
if(m_pPlayerPool)
{
pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer)
pPlayer->StoreOnFootFullSyncData(&ofSync, 0, key);
}
}
void CNetGame::Packet_VehicleSync(Packet* pkt)
{
CRemotePlayer *pPlayer;
RakNet::BitStream bsSync((unsigned char *)pkt->data, pkt->length, false);
uint8_t bytePacketID = 0;
PLAYERID playerId;
INCAR_SYNC_DATA icSync;
if(GetGameState() != GAMESTATE_CONNECTED) return;
memset(&icSync, 0, sizeof(INCAR_SYNC_DATA));
bsSync.Read(bytePacketID);
bsSync.Read(playerId);
bsSync.Read(icSync.VehicleID);
// keys
bsSync.Read(icSync.lrAnalog);
bsSync.Read(icSync.udAnalog);
bsSync.Read(icSync.wKeys);
// quaternion
bsSync.ReadNormQuat(
icSync.quat.w,
icSync.quat.x,
icSync.quat.y,
icSync.quat.z);
// position
bsSync.Read((char*)&icSync.vecPos, sizeof(VECTOR));
// speed
bsSync.ReadVector(
icSync.vecMoveSpeed.X,
icSync.vecMoveSpeed.Y,
icSync.vecMoveSpeed.Z);
// vehicle health
uint16_t wTempVehicleHealth;
bsSync.Read(wTempVehicleHealth);
icSync.fCarHealth = (float)wTempVehicleHealth;
// health/armour
uint8_t byteHealthArmour;
uint8_t byteArmTemp=0, byteHlTemp=0;
bsSync.Read(byteHealthArmour);
byteArmTemp = (byteHealthArmour & 0x0F);
byteHlTemp = (byteHealthArmour >> 4);
if(byteArmTemp == 0xF) icSync.bytePlayerArmour = 100;
else if(byteArmTemp == 0) icSync.bytePlayerArmour = 0;
else icSync.bytePlayerArmour = byteArmTemp * 7;
if(byteHlTemp == 0xF) icSync.bytePlayerHealth = 100;
else if(byteHlTemp == 0) icSync.bytePlayerHealth = 0;
else icSync.bytePlayerHealth = byteHlTemp * 7;
// CURRENT WEAPON
uint8_t byteTempWeapon;
bsSync.Read(byteTempWeapon);
icSync.byteCurrentWeapon ^= (byteTempWeapon ^ icSync.byteCurrentWeapon) & 0x3F;
bool bCheck;
// siren
bsSync.Read(bCheck);
if(bCheck) icSync.byteSirenOn = 1;
// landinggear
bsSync.Read(bCheck);
if(bCheck) icSync.byteLandingGearState = 1;
// train speed
bsSync.Read(bCheck);
if(bCheck) bsSync.Read(icSync.fTrainSpeed);
// triler id
bsSync.Read(bCheck);
if(bCheck) bsSync.Read(icSync.TrailerID);
if(m_pPlayerPool)
{
pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer)
{
pPlayer->StoreInCarFullSyncData(&icSync, 0);
}
}
}
void CNetGame::Packet_PassengerSync(Packet* pkt)
{
CRemotePlayer *pPlayer;
uint8_t bytePacketID;
PLAYERID playerId;
PASSENGER_SYNC_DATA psSync;
if(GetGameState() != GAMESTATE_CONNECTED) return;
RakNet::BitStream bsPassengerSync((unsigned char *)pkt->data, pkt->length, false);
bsPassengerSync.Read(bytePacketID);
bsPassengerSync.Read(playerId);
bsPassengerSync.Read((char*)&psSync, sizeof(PASSENGER_SYNC_DATA));
if(m_pPlayerPool)
{
pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer)
pPlayer->StorePassengerFullSyncData(&psSync);
}
}
void CNetGame::Packet_MarkersSync(Packet *pkt)
{
CRemotePlayer *pPlayer;
int iNumberOfPlayers = 0;
PLAYERID playerId;
short sPos[3];
bool bIsPlayerActive;
uint8_t unk0 = 0;
if(GetGameState() != GAMESTATE_CONNECTED) return;
RakNet::BitStream bsMarkersSync((unsigned char *)pkt->data, pkt->length, false);
bsMarkersSync.Read(unk0);
bsMarkersSync.Read(iNumberOfPlayers);
if(iNumberOfPlayers)
{
for(int i=0; i<iNumberOfPlayers; i++)
{
bsMarkersSync.Read(playerId);
bsMarkersSync.ReadCompressed(bIsPlayerActive);
if(bIsPlayerActive)
{
bsMarkersSync.Read(sPos[0]);
bsMarkersSync.Read(sPos[1]);
bsMark
ersSync.Read(sPos[2]);
}
if(playerId < MAX_PLAYERS && m_pPlayerPool->GetSlotState(playerId))
{
pPlayer = m_pPlayerPool->GetAt(playerId);
if(pPlayer)
{
if(bIsPlayerActive)
pPlayer->ShowGlobalMarker(sPos[0], sPos[1], sPos[2]);
else
pPlayer->HideGlobalMarker();
}
}
}
}
}
void CNetGame::Packet_BulletSync(Packet* pkt)
{
uint8_t bytePacketID;
uint16_t PlayerID;
BULLET_SYNC_DATA btSync;
RakNet::BitStream bsBulletSync((unsigned char*)pkt->data, pkt->length, false);
if (GetGameState() != GAMESTATE_CONNECTED) return;
bsBulletSync.Read(bytePacketID);
bsBulletSync.Read(PlayerID);
bsBulletSync.Read((char*)&btSync, sizeof(BULLET_SYNC_DATA));
CRemotePlayer* pRemotePlayer = m_pPlayerPool->GetAt(PlayerID);
if (pRemotePlayer)
{
pRemotePlayer->StoreBulletSyncData(&btSync);
}
}
void CNetGame::Packet_AimSync(Packet * p)
{
CRemotePlayer * pPlayer;
RakNet::BitStream bsAimSync((unsigned char*)p->data, p->length, false);
AIM_SYNC_DATA aimSync;
uint8_t bytePacketID = 0;
uint16_t bytePlayerID = 0;
if (GetGameState() != GAMESTATE_CONNECTED) return;
bsAimSync.Read(bytePacketID);
bsAimSync.Read(bytePlayerID);
bsAimSync.Read((char*)&aimSync, sizeof(AIM_SYNC_DATA));
pPlayer = GetPlayerPool()->GetAt(bytePlayerID);
if (pPlayer) {
pPlayer->UpdateAimFromSyncData(&aimSync);
}
}
@Ndndjdjdjdjdhttps://youtu.be/WN5Czefa8PI
Отредактировано пользователем Ndndjdjdjdjd
Поделиться сообщением
Ссылка на сообщение