public void LoadScenePlayers()
{
if (!isMainClient)
{
SendPackage(PackageFactory.GetPackage(PackageType.LoadScenePlayer) as LoadScenePlayerPackage);
}
}
private void OnChunkDataSave(object[] param)
{
NetRemovedChunk savedChunk = param[0] as NetRemovedChunk;
if (savedChunk.needSave)
{
Chunk chunk = savedChunk.chunk;
for (int i = 0; i < savedChunk.changedEntityInfos.Count; i++)
{
EntityData entityData = new EntityData();
ClientEntityInfo info = savedChunk.changedEntityInfos[i];
entityData.id = info.entityId;
entityData.type = info.type;
entityData.pos = info.position;
entityData.exData = info.extData;
chunk.AddEntityData(entityData);
}
NetChunkData netChunkData = WorldPersistanceManager.Instance.GetNetChunkData(chunk, roleId);
//如果当前客户端是主机客户端，直接保存文件到当前本地，否则，将数据发送给服务器，保存在主机
if (isMainClient)
{
World.world.WorldGenerator.DataProcessorManager.EnqueueSaveNetChunkData(netChunkData);
}
else
{
PlayerSaveChunkOnServerPackage package = PackageFactory.GetPackage(PackageType.PlayerSaveChunkOnServer)
as PlayerSaveChunkOnServerPackage;
package.pos = chunk.worldPos;
package.chunkByteData = netChunkData.data.data;
package.compressType = (byte)netChunkData.data.compressType;
package.roleId = netChunkData.roleId;
SendPackage(package);
}
}
}
//addChunk到服务器上必须比UpdateAfterPopulation早，因此，只要数据产生，无论是读取网络数据、本地数据、产生数据都需要发送
private void OnChunkDataGenerateFinish(object[] param)
{
Chunk chunk = param[0] as Chunk;
PlayerAddChunkPackage package = PackageFactory.GetPackage(PackageType.PlayerAddChunk) as PlayerAddChunkPackage;
package.pos = chunk.worldPos;
package.sign = chunk.GetSign();
SendPackage(package);
}
private void SyncPlayerPosition()
{
PositionPackage package = PackageFactory.GetPackage(PackageType.Position) as PositionPackage;
GameObject mainPlayer = HasActionObjectManager.Instance.playerManager.getMyPlayer();
package.position = mainPlayer.transform.position;
package.aoId = mainPlayer.GetComponent <GOPlayerController>().playerAttribute.aoId;
SendPackage(package);
}
public void JoinGame(int playerId)
{
EventManager.RegisterEvent(EventMacro.ON_JOIN_SCENE_SUCCESS, OnJoinSceneSuccess);
Debug.Log("正在进入游戏...");
JoinGamePackage package = PackageFactory.GetPackage(PackageType.JoinGame) as JoinGamePackage;
package.roleId = roleId;
package.playerId = playerId;
SendPackage(package);
}
private IEnumerator SyncGameTime()
{
while (true)
{
GameTimePackage package = PackageFactory.GetPackage(PackageType.GameTime) as GameTimePackage;
package.time = DayNightTime.Instance.TotalTime;
SendPackage(package);
yield return(new WaitForSeconds(5f));
}
}
public void LoadSceneEntities()
{
if (!isMainClient)
{
LoadSceneEntityPackage package = PackageFactory.GetPackage(PackageType.LoadSceneEntity)
as LoadSceneEntityPackage;
package.list = new List <ClientEntityInfo>();
SendPackage(package);
}
}
public void GetPackageFailedManifestRead()
{
PlatformMock.Setup(p => p.ReadFileText(It.IsAny <string>()))
.Returns(new Result <string>(ResultCode.Failure));
PackageFactory test = new PackageFactory(PlatformManagerMock.Object, ManifestExtractorMock.Object, PackageVerifierMock.Object);
IResult <IPackage> result = test.GetPackage(TempDirectory);
Assert.Equal(ResultCode.Failure, result.ResultCode);
}
public void DelayRefreshEntity(int aoId)
{
if (!isConnection)
{
return;
}
DelayRefreshEntityPackage package = PackageFactory.GetPackage(PackageType.DelayRefreshEntity)
as DelayRefreshEntityPackage;
package.aoId = aoId;
package.needRefresh = false;
SendPackage(package);
}
private void SyncPlayerAction()
{
ActionPackage package = PackageFactory.GetPackage(PackageType.Action) as ActionPackage;
GameObject mainPlayer = HasActionObjectManager.Instance.playerManager.getMyPlayer();
GOPlayerController controller = mainPlayer.GetComponent <GOPlayerController>();
package.aoId = controller.playerAttribute.aoId;
package.direction = controller.playerInputState.moveDirection;
package.isJump = controller.playerInputState.jump;
package.actionId = controller.goActionController.curAction.actionData.id;
package.yRotate = mainPlayer.transform.localRotation.eulerAngles.y;
SendPackage(package);
}
private void SyncMonsterPosition()
{
List <GameObject> list = HasActionObjectManager.Instance.monsterManager.listObj();
for (int i = 0; i < list.Count; i++)
{
MonsterSyncPositionPackage package = PackageFactory.GetPackage(PackageType.MonsterSyncPosition)
as MonsterSyncPositionPackage;
package.position = list[i].transform.position;
package.aoId = list[i].GetComponent <GameObjectController>().baseAttribute.aoId;
SendPackage(package);
}
}
public void GetPackage()
{
PackageFactory test = new PackageFactory(PlatformManagerMock.Object, ManifestExtractorMock.Object, PackageVerifierMock.Object);
IResult <IPackage> result = test.GetPackage(TempDirectory);
string fqn = PackageManifest.Namespace + "." + PackageManifest.Name;
Assert.Equal(ResultCode.Success, result.ResultCode);
Assert.Equal(TempDirectory, result.ReturnValue.DirectoryName);
Assert.Equal(fqn, result.ReturnValue.FQN);
Assert.Equal(PackageManifest.Name, result.ReturnValue.Manifest.Name);
Assert.Equal(PackageManifest.Namespace, result.ReturnValue.Manifest.Namespace);
}
private void OnBlockUpdateAfterPopulation(object[] param)
{
ChunkBlockChangedPackage package = PackageFactory.GetPackage(PackageType.ChunkBlockChanged) as ChunkBlockChangedPackage;
WorldPos pos = (WorldPos)param[0];
int x = (int)param[1];
int y = (int)param[2];
int z = (int)param[3];
Block b = (Block)param[4];
Int16 index = ClientChangedChunk.GetChunkIndex(x, y, z);
byte blockType = (byte)b.BlockType;
byte extendId = b.ExtendId;
package.pos = pos;
package.changedBlock = new ClientChangedBlock(index, blockType, extendId);
SendPackage(package);
}
private void OnChunkDataRemoveFinish(object[] param)
{
NetRemovedChunk netRemovedChunk = param[0] as NetRemovedChunk;
Chunk chunk = netRemovedChunk.chunk;
//当chunk为移除时，向服务器发送chunk移除消息
PlayerRemoveChunkPackage removePackage = PackageFactory.GetPackage(PackageType.PlayerRemoveChunk) as PlayerRemoveChunkPackage;
removePackage.pos = chunk.worldPos;
SendPackage(removePackage);
if (netRemovedChunk.needSave)
{
for (int i = 0; i < netRemovedChunk.changedEntityInfos.Count; i++)
{
EntityData entityData = new EntityData();
ClientEntityInfo info = netRemovedChunk.changedEntityInfos[i];
entityData.id = info.entityId;
entityData.type = info.type;
entityData.pos = info.position;
entityData.exData = info.extData;
chunk.AddEntityData(entityData);
}
NetChunkData netChunkData = WorldPersistanceManager.Instance.GetNetChunkData(chunk, roleId);
//如果当前客户端是主机客户端，直接保存文件到当前本地，否则，将数据发送给服务器，保存在主机
if (isMainClient)
{
World.world.WorldGenerator.DataProcessorManager.EnqueueSaveNetChunkData(netChunkData);
}
else
{
// //上面已经移除掉了
// //先移除
// PlayerRemoveChunkPackage removeChunkPackage = PackageFactory.GetPackage(PackageType.PlayerRemoveChunk) as PlayerRemoveChunkPackage;
// removeChunkPackage.pos = chunk.worldPos;
// SendPackage(removeChunkPackage);
//先需要从服务器上拿最新的entity数据,更新后再保存
//再保存
PlayerSaveChunkOnServerPackage package = PackageFactory.GetPackage(PackageType.PlayerSaveChunkOnServer)
as PlayerSaveChunkOnServerPackage;
package.pos = chunk.worldPos;
package.chunkByteData = netChunkData.data.data;
package.compressType = (byte)netChunkData.data.compressType;
package.roleId = netChunkData.roleId;
SendPackage(package);
}
}
}
private void InitServerMainPlayerInfo()
{
//初始化主玩家的一些信息
MainClientInitPackage package = PackageFactory.GetPackage(PackageType.MainClientInit) as MainClientInitPackage;
GameObject mainPlayer = HasActionObjectManager.Instance.playerManager.getMyPlayer();
package.roleId = roleId;
package.position = mainPlayer.transform.position;
package.aoId = mainPlayer.GetComponent <PlayerAttributes>().aoId;
package.playerId = mainPlayer.GetComponent <PlayerAttributes>().playerId;
package.worldConfigName = WorldConfig.Instance.name;
package.seed = WorldConfig.Instance.seed;
package.time = DayNightTime.Instance.TotalTime;
SendPackage(package);
//初始化当前玩家内存中的chunk信息到服务器
foreach (var key in World.world.chunks)
{
WorldPos chunkPos = key.Key;
int sign = key.Value.GetSign();
PlayerAddChunkPackage addChunkPackage = PackageFactory.GetPackage(PackageType.PlayerAddChunk) as PlayerAddChunkPackage;
addChunkPackage.pos = chunkPos;
addChunkPackage.sign = sign;
SendPackage(addChunkPackage);
}
//初始化主玩家的entity信息到服务器上(暂时只同步怪物)
MainClientEntityInitPackage entityInitPackage = PackageFactory.GetPackage(PackageType.MainClientEntityInit) as MainClientEntityInitPackage;
List <ClientEntityInfo> list = new List <ClientEntityInfo>();
List <GameObject> listMonster = HasActionObjectManager.Instance.monsterManager.listObj();
for (int i = 0; i < listMonster.Count; i++)
{
GOMonsterController controller = listMonster[i].GetComponent <GOMonsterController>();
ClientEntityInfo info = new ClientEntityInfo();
EntityData entityData = controller.GetEntityData();
info.roleId = roleId;
info.aoId = controller.monsterAttribute.aoId;
info.entityId = entityData.id;
info.type = EntityType.MONSTER;
info.position = entityData.pos;
info.extData = entityData.exData;
list.Add(info);
}
entityInitPackage.entityInfos = list;
SendPackage(entityInitPackage);
}
private void SyncMonsterAction()
{
List <GameObject> list = HasActionObjectManager.Instance.monsterManager.listObj();
for (int i = 0; i < list.Count; i++)
{
MonsterSyncActionPakage package = PackageFactory.GetPackage(PackageType.MonsterSyncAction)
as MonsterSyncActionPakage;
GameObjectController controller = list[i].GetComponent <GameObjectController>();
package.aoId = controller.baseAttribute.aoId;
package.direction = controller.gameObjectInputState.moveDirection;
package.isJump = controller.gameObjectInputState.jump;
package.actionId = controller.goActionController.curAction.actionData.id;
package.yRotate = list[i].transform.localRotation.eulerAngles.y;
SendPackage(package);
}
}
public void Connect(string ip, int port)
{
Debug.Log("正在连接服务器:" + ip + ":" + port + " ....");
this.ip = ip;
this.port = port;
TcpConnection conn = new TcpConnection(ip, port, false);
conn.Connect();
serverConnectionWorker = new ServerConnectionWorker(conn);
serverConnectionWorker.Start();
isConnection = true;
StartCoroutine(HandleReadPackage());
//连接成功后缓存当前人物的roleId
roleId = GetRoleId();
LinkStatePackage package = PackageFactory.GetPackage(PackageType.LinkState) as LinkStatePackage;
SendPackage(package);
AddClientEvents();
}
public void DoWork()
{
while (true)
{
// Debug.Log(this is ClientConnectionWorker ? "ServerDetailWorker:work" : "ClientDetailWorker");
int length = 0;
//这里要检测是否有一段可读数据的时候只读一部分仍然检测为可读
if (conn.CanRead())
{
length = conn.Read(buffer);
if (length > 0)
{
readBuffer.Write(buffer, 0, length);
}
}
if (conn.CanWrite())
{
byte[] tempBuffer = writeBuffer.GetDataBuffer();
int readPos = writeBuffer.GetReadPos();
length = writeBuffer.GetDataLength();
if (length > 0)
{
int writeLen = conn.Write(tempBuffer, readPos, length);
if (length > 0)
{
writeBuffer.SetReadPos(length, SeekOrigin.Current);
}
}
}
if (conn.HasError())
{
//Debug.Log ("HasError~~~~~~~~~~~");
stop = true;
break;
}
//从buffer中读package
while (!stop)
{
int dataLength = readBuffer.GetDataLength();
if (dataLength < 8)
{
break;
}
int packageLeng = readBuffer.ReadInt();
System.Diagnostics.Debug.Assert(packageLeng > 0);
if (dataLength < packageLeng)
{
readBuffer.SetReadPos(-4, SeekOrigin.Current);
break;
}
int packageId = readBuffer.ReadInt();
byte[] packageData = readBuffer.ReadBytes(packageLeng - 8);
NetPackage package = PackageFactory.GetPackage(packageId);
System.Diagnostics.Debug.Assert(package != null);
package.Deserialize(packageData);
package.DeserializeRemoteEndPoint(conn.RemoteEndPoint);
lock (readPackageQueue)
{
readPackageQueue.Enqueue(package);
}
}
if (stop)
{
break;
}
lock (writePackageQueue)
{
while (writePackageQueue.Count > 0)
{
NetPackage package = writePackageQueue.Dequeue();
lock (package)
{
package.Serialize();
MemoryStream ms = package.GetMemoryStream();
writeBuffer.Write(ms.GetBuffer(), 0, (int)ms.Length);
}
}
}
Thread.Sleep(1);
}
}
