void NetManager::readSpriteResponse(ENetPacket* packet, size_t& position)
{
size_t numSprites;
readFromPacket(packet, position, numSprites);
auto renderer = FARender::Renderer::get();
for(size_t i = 0; i < numSprites; i++)
{
size_t index;
readFromPacket(packet, position, index);
std::string path;
char c = 0;
do
{
readFromPacket(packet, position, c);
if(c)
path += c;
} while(c);
renderer->fillServerSprite(index, path);
std::cout << "response recieved " << index << " " << path << std::endl;
}
}
void NetManager::readSpriteRequest(ENetPacket* packet, ENetPeer* peer, size_t& position)
{
size_t numSprites;
readFromPacket(packet, position, numSprites);
std::vector<size_t> requestedSprites(numSprites);
for(size_t i = 0; i < numSprites; i++)
readFromPacket(packet, position, requestedSprites[i]);
std::vector<std::string> paths(numSprites);
auto renderer = FARender::Renderer::get();
size_t size = 0;
for(size_t i = 0; i < numSprites; i++)
{
paths[i] = renderer->getPathForIndex(requestedSprites[i]);
size += paths[i].size();
size += 1; // null terminator
std::cout << "responding to: " << requestedSprites[i] << " " << paths[i] << std::endl;
}
size += numSprites * sizeof(size_t);
size += sizeof(int32_t); // type header
size += sizeof(size_t); // numSprites count
int32_t typeHeader = ReliableMessageKind::Sprite;
ENetPacket* responsePacket = enet_packet_create(NULL, size, ENET_PACKET_FLAG_RELIABLE);
size_t writePosition = 0;
writeToPacket(responsePacket, writePosition, typeHeader);
writeToPacket(responsePacket, writePosition, numSprites);
for(size_t i = 0; i < numSprites; i++)
{
writeToPacket(responsePacket, writePosition, requestedSprites[i]);
std::string& path = paths[i];
char c;
for(size_t j = 0; j < path.size(); j++)
{
c = path[j];
writeToPacket(responsePacket, writePosition, c);
}
c = 0;
writeToPacket(responsePacket, writePosition, c);
}
enet_peer_send(peer, RELIABLE_CHANNEL_ID, responsePacket);
}
void NetManager::readServerPacket(ENetEvent& event)
{
FAWorld::World& world = *FAWorld::World::get();
size_t position = 0;
ServerPacketHeader header;
readFromPacket(event.packet, position, header);
if(header.tick > mLastServerTickProcessed)
{
for(size_t i = 0; i < header.numPlayers; i++)
{
uint32_t playerId;
readFromPacket<uint32_t>(event.packet, position, playerId);
auto player = world.getPlayer(playerId);
if(player == NULL)
{
spawnPlayer(playerId);
player = world.getPlayer(playerId);
}
position = player->readFrom(event.packet, position);
}
}
}
void NetManager::readClientPacket(ENetEvent& event)
{
if(event.packet->flags & ENET_PACKET_FLAG_RELIABLE)
{
int32_t typeHeader;
size_t position = 0;
readFromPacket(event.packet, position, typeHeader);
switch(typeHeader)
{
case ReliableMessageKind::Sprite:
{
readSpriteRequest(event.packet, event.peer, position);
break;
}
}
}
else
{
ClientPacket data;
size_t position = 0;
readFromPacket(event.packet, position, data);
auto world = FAWorld::World::get();
auto player = mServerPlayerList[event.peer->connectID];
player->destination().first = data.destX;
player->destination().second = data.destY;
if(data.levelIndex != -1 && (player->getLevel() == NULL || data.levelIndex != (int32_t)player->getLevel()->getLevelIndex()))
{
auto level = world->getLevel(data.levelIndex);
if(player->getLevel() != NULL && data.levelIndex < (int32_t)player->getLevel()->getLevelIndex())
player->mPos = FAWorld::Position(level->downStairsPos().first, level->downStairsPos().second);
else
player->mPos = FAWorld::Position(level->upStairsPos().first, level->upStairsPos().second);
player->setLevel(level);
}
}
}
UserRight::UserRight( const Packet* p, int& pos )
: UserElement( UserConstants::TYPE_RIGHT )
{
readFromPacket( p, pos );
}
void NetManager::readServerPacket(ENetEvent& event)
{
if(event.packet->flags & ENET_PACKET_FLAG_RELIABLE)
{
size_t position = 0;
if(mClientRecievedId == false)
{
mClientRecievedId = true;
size_t playerId;
readFromPacket(event.packet, position, playerId);
FAWorld::World::get()->getCurrentPlayer()->mId = playerId;
return;
}
int32_t typeHeader;
readFromPacket(event.packet, position, typeHeader);
switch(typeHeader)
{
case ReliableMessageKind::Level:
{
readLevel(event.packet, position);
FAWorld::World::get()->setLevel(0);
break;
}
case ReliableMessageKind::Sprite:
{
readSpriteResponse(event.packet, position);
break;
}
}
}
else
{
FAWorld::World& world = *FAWorld::World::get();
size_t position = 0;
ServerPacketHeader header;
readFromPacket(event.packet, position, header);
if(header.tick > mLastServerTickProcessed)
{
for(size_t i = 0; i < header.numPlayers; i++)
{
int32_t classId;
int32_t actorId;
readFromPacket(event.packet, position, classId);
readFromPacket(event.packet, position, actorId);
FAWorld::Actor* actor = world.getActorById(actorId);
if(actor == NULL)
{
actor = dynamic_cast<FAWorld::Actor*>(FAWorld::NetObject::construct(classId));
actor->mId = actorId;
}
actor->readFrom(event.packet, position);
}
}
}
}
