teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

[General] Simplify WorldPackets

Browse source
This commit is contained in:
Koncord 2017-06-03 03:10:47 +08:00
parent 556bf18535
commit fd8e833d6a
35 changed files with 148 additions and 681 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
components/openmw-mp/Packets/World/PacketContainer.cpp
View file

@ -7,49 +7,29 @@ using namespace mwmp;
PacketContainer::PacketContainer(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_CONTAINER;
hasCellData = true;
}
void PacketContainer::Packet(RakNet::BitStream *bs, bool send)
{
WorldPacket::Packet(bs, send);
if(!PacketHeader(bs, send))
return;
RW(event->action, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
worldObject.containerItemCount = (unsigned int)(worldObject.containerItems.size());
worldObject.containerItemCount = (unsigned int) (worldObject.containerItems.size());
}
else
{
worldObject.containerItems.clear();
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
Object(worldObject, send);
RW(worldObject.containerItemCount, send);
if (worldObject.containerItemCount > maxObjects || worldObject.refId.empty() || (worldObject.refNumIndex != 0 && worldObject.mpNum != 0))
@ -63,9 +43,7 @@ void PacketContainer::Packet(RakNet::BitStream *bs, bool send)
for (unsigned int j = 0; j < worldObject.containerItemCount; j++)
{
if (send)
{
containerItem = worldObject.containerItems.at(j);
}
RW(containerItem.refId, send);
RW(containerItem.count, send);
@ -73,14 +51,9 @@ void PacketContainer::Packet(RakNet::BitStream *bs, bool send)
RW(containerItem.actionCount, send);
if (!send)
{
worldObject.containerItems.push_back(containerItem);
}
}
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
}

44
components/openmw-mp/Packets/World/PacketDoorState.cpp
View file

@ -6,47 +6,11 @@ using namespace mwmp;
PacketDoorState::PacketDoorState(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_DOOR_STATE;
hasCellData = true;
}
void PacketDoorState::Packet(RakNet::BitStream *bs, bool send)
void PacketDoorState::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.doorState, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.doorState, send);
}

2
components/openmw-mp/Packets/World/PacketDoorState.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketDoorState(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

34
components/openmw-mp/Packets/World/PacketMusicPlay.cpp
View file

@ -8,37 +8,7 @@ PacketMusicPlay::PacketMusicPlay(RakNet::RakPeerInterface *peer) : WorldPacket(p
packetID = ID_MUSIC_PLAY;
}
void PacketMusicPlay::Packet(RakNet::BitStream *bs, bool send)
void PacketMusicPlay::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.filename, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
RW(worldObject.filename, send);
}

2
components/openmw-mp/Packets/World/PacketMusicPlay.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketMusicPlay(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

46
components/openmw-mp/Packets/World/PacketObjectAnimPlay.cpp
View file

@ -6,48 +6,12 @@ using namespace mwmp;
PacketObjectAnimPlay::PacketObjectAnimPlay(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_ANIM_PLAY;
hasCellData = true;
}
void PacketObjectAnimPlay::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectAnimPlay::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.animGroup, send);
RW(worldObject.animMode, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.animGroup, send);
RW(worldObject.animMode, send);
}

2
components/openmw-mp/Packets/World/PacketObjectAnimPlay.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectAnimPlay(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

43
components/openmw-mp/Packets/World/PacketObjectDelete.cpp
View file

@ -6,46 +6,5 @@ using namespace mwmp;
PacketObjectDelete::PacketObjectDelete(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_DELETE;
}
void PacketObjectDelete::Packet(RakNet::BitStream *bs, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
hasCellData = true;
}

2
components/openmw-mp/Packets/World/PacketObjectDelete.hpp
View file

@ -9,8 +9,6 @@ namespace mwmp
{
public:
PacketObjectDelete(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
};
}

43
components/openmw-mp/Packets/World/PacketObjectLock.cpp
View file

@ -8,45 +8,8 @@ PacketObjectLock::PacketObjectLock(RakNet::RakPeerInterface *peer) : WorldPacket
packetID = ID_OBJECT_LOCK;
}
void PacketObjectLock::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectLock::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.lockLevel, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.lockLevel, send);
}

2
components/openmw-mp/Packets/World/PacketObjectLock.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectLock(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

46
components/openmw-mp/Packets/World/PacketObjectMove.cpp
View file

@ -6,49 +6,11 @@ using namespace mwmp;
PacketObjectMove::PacketObjectMove(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_MOVE;
hasCellData = true;
}
void PacketObjectMove::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectMove::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.position.pos[0], send);
RW(worldObject.position.pos[1], send);
RW(worldObject.position.pos[2], send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.position.pos, send);
}

2
components/openmw-mp/Packets/World/PacketObjectMove.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectMove(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

50
components/openmw-mp/Packets/World/PacketObjectPlace.cpp
View file

@ -6,50 +6,14 @@ using namespace mwmp;
PacketObjectPlace::PacketObjectPlace(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_PLACE;
hasCellData = true;
}
void PacketObjectPlace::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectPlace::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.count, send);
RW(worldObject.charge, send);
RW(worldObject.goldValue, send);
RW(worldObject.position, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.count, send);
RW(worldObject.charge, send);
RW(worldObject.goldValue, send);
RW(worldObject.position, send);
}

2
components/openmw-mp/Packets/World/PacketObjectPlace.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectPlace(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

48
components/openmw-mp/Packets/World/PacketObjectRotate.cpp
View file

@ -6,49 +6,13 @@ using namespace mwmp;
PacketObjectRotate::PacketObjectRotate(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_ROTATE;
hasCellData = true;
}
void PacketObjectRotate::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectRotate::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.position.rot[0], send);
RW(worldObject.position.rot[1], send);
RW(worldObject.position.rot[2], send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.position.rot[0], send);
RW(worldObject.position.rot[1], send);
RW(worldObject.position.rot[2], send);
}

2
components/openmw-mp/Packets/World/PacketObjectRotate.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectRotate(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

44
components/openmw-mp/Packets/World/PacketObjectScale.cpp
View file

@ -6,47 +6,11 @@ using namespace mwmp;
PacketObjectScale::PacketObjectScale(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_SCALE;
hasCellData = true;
}
void PacketObjectScale::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectScale::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.scale, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.scale, send);
}

2
components/openmw-mp/Packets/World/PacketObjectScale.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectScale(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

54
components/openmw-mp/Packets/World/PacketObjectSpawn.cpp
View file

@ -6,56 +6,20 @@ using namespace mwmp;
PacketObjectSpawn::PacketObjectSpawn(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_SPAWN;
hasCellData = true;
}
void PacketObjectSpawn::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectSpawn::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
WorldPacket::Object(worldObject, send);
RW(worldObject.position, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(worldObject.hasMaster, send);
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
if (worldObject.hasMaster)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.position, send);
RW(worldObject.hasMaster, send);
if (worldObject.hasMaster)
{
RW(worldObject.master.refNumIndex, send);
RW(worldObject.master.mpNum, send);
RW(worldObject.master.guid, send);
}
if (!send)
{
event->worldObjects.push_back(worldObject);
}
RW(worldObject.master.refNumIndex, send);
RW(worldObject.master.mpNum, send);
RW(worldObject.master.guid, send);
}
}

2
components/openmw-mp/Packets/World/PacketObjectSpawn.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectSpawn(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

48
components/openmw-mp/Packets/World/PacketObjectTrap.cpp
View file

@ -6,50 +6,14 @@ using namespace mwmp;
PacketObjectTrap::PacketObjectTrap(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_OBJECT_TRAP;
hasCellData = true;
}
void PacketObjectTrap::Packet(RakNet::BitStream *bs, bool send)
void PacketObjectTrap::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
WorldPacket::Object(worldObject, send);
RW(worldObject.isDisarmed, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.isDisarmed, send);
if (!worldObject.isDisarmed)
RW(worldObject.position, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
if (!worldObject.isDisarmed)
RW(worldObject.position, send);
}

2
components/openmw-mp/Packets/World/PacketObjectTrap.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketObjectTrap(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

36
components/openmw-mp/Packets/World/PacketScriptGlobalShort.cpp
View file

@ -8,38 +8,8 @@ PacketScriptGlobalShort::PacketScriptGlobalShort(RakNet::RakPeerInterface *peer)
packetID = ID_SCRIPT_GLOBAL_SHORT;
}
void PacketScriptGlobalShort::Packet(RakNet::BitStream *bs, bool send)
void PacketScriptGlobalShort::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.varName, send);
RW(worldObject.shortVal, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
RW(worldObject.varName, send);
RW(worldObject.shortVal, send);
}

2
components/openmw-mp/Packets/World/PacketScriptGlobalShort.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketScriptGlobalShort(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

46
components/openmw-mp/Packets/World/PacketScriptLocalFloat.cpp
View file

@ -6,48 +6,12 @@ using namespace mwmp;
PacketScriptLocalFloat::PacketScriptLocalFloat(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_SCRIPT_LOCAL_FLOAT;
hasCellData = true;
}
void PacketScriptLocalFloat::Packet(RakNet::BitStream *bs, bool send)
void PacketScriptLocalFloat::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.index, send);
RW(worldObject.floatVal, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.index, send);
RW(worldObject.floatVal, send);
}

2
components/openmw-mp/Packets/World/PacketScriptLocalFloat.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketScriptLocalFloat(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &worldObject, bool send);
};
}

46
components/openmw-mp/Packets/World/PacketScriptLocalShort.cpp
View file

@ -6,48 +6,12 @@ using namespace mwmp;
PacketScriptLocalShort::PacketScriptLocalShort(RakNet::RakPeerInterface *peer) : WorldPacket(peer)
{
packetID = ID_SCRIPT_LOCAL_SHORT;
hasCellData = true;
}
void PacketScriptLocalShort::Packet(RakNet::BitStream *bs, bool send)
void PacketScriptLocalShort::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
RW(event->cell.mData.mFlags, send);
RW(event->cell.mData.mX, send);
RW(event->cell.mData.mY, send);
RW(event->cell.mName, send);
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
RW(worldObject.index, send);
RW(worldObject.shortVal, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
WorldPacket::Object(worldObject, send);
RW(worldObject.index, send);
RW(worldObject.shortVal, send);
}

2
components/openmw-mp/Packets/World/PacketScriptLocalShort.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketScriptLocalShort(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &obj, bool send);
};
}

38
components/openmw-mp/Packets/World/PacketScriptMemberShort.cpp
View file

@ -8,39 +8,9 @@ PacketScriptMemberShort::PacketScriptMemberShort(RakNet::RakPeerInterface *peer)
packetID = ID_SCRIPT_MEMBER_SHORT;
}
void PacketScriptMemberShort::Packet(RakNet::BitStream *bs, bool send)
void PacketScriptMemberShort::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.refId, send);
RW(worldObject.index, send);
RW(worldObject.shortVal, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
RW(worldObject.refId, send);
RW(worldObject.index, send);
RW(worldObject.shortVal, send);
}

2
components/openmw-mp/Packets/World/PacketScriptMemberShort.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketScriptMemberShort(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &obj, bool send);
};
}

36
components/openmw-mp/Packets/World/PacketVideoPlay.cpp
View file

@ -8,38 +8,8 @@ PacketVideoPlay::PacketVideoPlay(RakNet::RakPeerInterface *peer) : WorldPacket(p
packetID = ID_VIDEO_PLAY;
}
void PacketVideoPlay::Packet(RakNet::BitStream *bs, bool send)
void PacketVideoPlay::Object(WorldObject &worldObject, bool send)
{
WorldPacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return;
}
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
{
worldObject = event->worldObjects.at(i);
}
RW(worldObject.filename, send);
RW(worldObject.allowSkipping, send);
if (!send)
{
event->worldObjects.push_back(worldObject);
}
}
RW(worldObject.filename, send);
RW(worldObject.allowSkipping, send);
}

2
components/openmw-mp/Packets/World/PacketVideoPlay.hpp
View file

@ -10,7 +10,7 @@ namespace mwmp
public:
PacketVideoPlay(RakNet::RakPeerInterface *peer);
virtual void Packet(RakNet::BitStream *bs, bool send);
virtual void Object(WorldObject &obj, bool send);
};
}

51
components/openmw-mp/Packets/World/WorldPacket.cpp
View file

@ -7,6 +7,7 @@ using namespace mwmp;
WorldPacket::WorldPacket(RakNet::RakPeerInterface *peer) : BasePacket(peer)
{
hasCellData = false;
packetID = 0;
priority = HIGH_PRIORITY;
reliability = RELIABLE_ORDERED;
@ -24,3 +25,53 @@ void WorldPacket::setEvent(BaseEvent *event)
this->event = event;
guid = event->guid;
}
void WorldPacket::Packet(RakNet::BitStream *bs, bool send)
{
if(!PacketHeader(bs, send))
return;
WorldObject worldObject;
for (unsigned int i = 0; i < event->worldObjectCount; i++)
{
if (send)
worldObject = event->worldObjects.at(i);
Object(worldObject, send);
if (!send)
event->worldObjects.push_back(worldObject);
}
}
bool WorldPacket::PacketHeader(RakNet::BitStream *bs, bool send)
{
BasePacket::Packet(bs, send);
if (send)
event->worldObjectCount = (unsigned int)(event->worldObjects.size());
else
event->worldObjects.clear();
RW(event->worldObjectCount, send);
if (event->worldObjectCount > maxObjects)
{
event->isValid = false;
return false;
}
if(hasCellData)
{
RW(event->cell.mData, send, 1);
RW(event->cell.mName, send, 1);
}
return true;
}
void WorldPacket::Object(WorldObject &worldObject, bool send)
{
RW(worldObject.refId, send);
RW(worldObject.refNumIndex, send);
RW(worldObject.mpNum, send);
}

5
components/openmw-mp/Packets/World/WorldPacket.hpp
View file

@ -21,9 +21,14 @@ namespace mwmp
void setEvent(BaseEvent *event);
virtual void Packet(RakNet::BitStream *bs, bool send);
protected:
virtual void Object(WorldObject &worldObject, bool send);
bool PacketHeader(RakNet::BitStream *bs, bool send);
BaseEvent *event;
static const int maxObjects = 3000;
bool hasCellData;
};
}