//обновление модели
public void UpdateModel(SyncObjectModel clientModel)
{
//определяет кто главный над объектом
clientModel.Authority = Context.ConnectionId;
_broadcaster.updateModel(clientModel);
}
public void UpdateMoving(SyncObjectModel model)
{
NetWorkingTransform value;
modelsLoadedFromServerDictionary.TryGetValue(model.ModelId, out value);
//value?.UpdateMoving();
}
private IEnumerator SendAndSyncData()
{
yield return(new WaitForSeconds(0.06f)); //каждые 60 мс шлет Update
if (IsPlayerRegister)
{
//реализация дисконекта
DisconnectInUpdate();
if (GameHelper.CurrentPlayerGameObject)
{
Vector3 pos = _playerController.SyncPosition;
Quaternion rot = _playerController.SyncRotation;
SyncObjectModel syncObjectModel = new SyncObjectModel()
{
Id = GameHelper.CurrentPlayerGameObject.GetComponent <SignalRIdentity>().NetworkID,
X = pos.x,
Y = pos.y,
Z = pos.z,
aX = rot.x,
aY = rot.y,
aZ = rot.z,
aQ = rot.w
};
//отправляет на обновление syncObjectModel
HubProxy.Invoke("UpdateModel", syncObjectModel);
}
//синкаем позицию
if (_syncObjectPool.Count > 0)
{
foreach (var syncObjectModel in _syncObjectPool)
{
SignalRIdentity signalRIdentity = GameHelper.OtherPlayers.FirstOrDefault(p => p.NetworkID == syncObjectModel.Id);
if (signalRIdentity)
{
PlayerController playerController = signalRIdentity.GetComponent <PlayerController>();
Vector3 pos = new Vector3(syncObjectModel.X, syncObjectModel.Y, syncObjectModel.Z);
Quaternion rot = new Quaternion(syncObjectModel.aX,
syncObjectModel.aY,
syncObjectModel.aZ,
syncObjectModel.aQ);
playerController.SyncPosition = pos;
playerController.SyncRotation = rot;
}
}
}
_syncObjectPool.Clear();
}
StartCoroutine(SendAndSyncData());
}
public NetWorkingTransform(SyncObjectModel syncObjectModel)
{
VectorConverter g = new VectorConverter(true, true, true);
this.syncObjectModel = syncObjectModel;
CreatorAuthority = syncObjectModel.UserName;
ModelAuthority = syncObjectModel.ModelId;
PrefabName = syncObjectModel.PrefabName;
this.newPosition = JsonConvert.DeserializeObject <Vector3>(syncObjectModel.ModelPosition, g);
this.newRotation = JsonConvert.DeserializeObject <Vector3>(syncObjectModel.ModelRotation, g);
}
/// <summary>
/// Создание чужой модели
/// </summary>
/// <param name="inModel"></param>
public void CreateModelOther(SyncObjectModel inModel)
{
if (UserManager.CurrentUser.connectionId == inModel.UserModel.connectionId)
{
ObjectsStateManager.Instance.myModelsDictionartLocal.TryGetValue(inModel.ModelId,
out var transform);
if (transform != null)
{
ObjectsStateManager.Instance.myModelsDictionary.Enqueue(transform);
}
else
{
Debug.Log("Object you want to instantiate does not exist in current scene");
}
return;
}
/*
* Проверяем, есть ли данная модель на сцене
* Если есть, не создаем повторную и выходим из тела метода
*/
if (ObjectsStateManager.Instance.modelsLoadedFromServerDictionary.ContainsKey(inModel.ModelId))
{
return;
}
VectorConverter g = new VectorConverter(true, true, true);
var position = JsonConvert.DeserializeObject <Vector3>(inModel.ModelPosition, g);
g = new VectorConverter(true, true, true);
var rotation = JsonConvert.DeserializeObject <Vector3>(inModel.ModelRotation, g);
/*
* Модель может создаваться только в основном потоке,
* Поэтому диспатчим ее и засовываем в основной поток.
*/
UnityMainThreadDispatcher.Instance().Enqueue(delegate
{
var otherModelPrefab = Instantiate(Resources.Load(inModel.PrefabName), position,
new Quaternion(rotation.x, rotation.y, rotation.z, 1)) as GameObject;
var netWorkingTransform = otherModelPrefab.GetComponent <NetWorkingTransform>();
netWorkingTransform.SyncObjectModel = inModel;
ObjectsStateManager.Instance.modelsLoadedFromServerDictionary.TryAdd(inModel.ModelId, netWorkingTransform);
});
}
//добавляем объект на сцену
public void InstantiatePlayer(string prefabName, Vector3 pos, Quaternion rot)
{
//это отправится на сервер и вышлется всем игрокам
SyncObjectModel syncObjectModel = new SyncObjectModel()
{
PrefabName = prefabName,
X = pos.x,
Y = pos.y,
Z = pos.z,
aX = rot.x,
aY = rot.y,
aZ = rot.z,
aQ = rot.w
};
HubProxy.Invoke("RegisterPlayer", syncObjectModel);
}
//удаляем пулю, регистрируем попадание у остальных игроков
private void HitInUpdate()
{
if (_hitBulletPool.Count > 0)
{
foreach (var hitModel in _hitBulletPool)
{
foreach (var bullet in BulletsInGame)
{
int bulletNetworkID = bullet.GetComponent <SignalRIdentity>().NetworkID;
int bulletDamage = bullet.GetComponent <BulletStats>().Damage;
if (bulletNetworkID == hitModel.bulletID)
{
foreach (var target in _gameHelper.AllPlayers)
{
int targetHealth = target.GetComponent <PlayerStats>().Health;
int targetNetworkID = target.GetComponent <SignalRIdentity>().NetworkID;
BulletController bulletController = bullet.GetComponent <BulletController>();
if (bulletNetworkID == hitModel.targetID)
{
targetHealth -= bulletDamage;
//если мало здоровья то отключаем игрока, надо будет переделать под рестарт игрока, либо переход его в меню со статистикой.
if (targetHealth <= 0)
{
SyncObjectModel syncObjectModel = new SyncObjectModel();
syncObjectModel.Id = targetNetworkID;
_signalRClient._disconnectedModels.Add(syncObjectModel);
}
if (!bullet.GetComponent <BulletStats>().Perforation)
{
bulletController.BulletOff();
}
}
}
}
}
}
}
_hitBulletPool.Clear();
}
//добавление игрока в игру
public void registerPlayer(SyncObjectModel clientmodel)
{
//даем уникальный ID
clientmodel.Id = _registerModels.Count();
_registerModels.Enqueue(clientmodel);
//тут надо сделать проверку был или не был этот игрок
_hubContext.Clients.All.instantiatePrefab(clientmodel);
//вновь зарегестрированному игроку отправляются все кто подключился до него
foreach (var item in _registerModels)
{
if (item.Authority != clientmodel.Authority)
{
_hubContext.Clients.Client(clientmodel.Authority).instantiatePrefab(item);
}
}
}
//обновление модели
public void updateModel(SyncObjectModel clientmodel)
{
_oneFrameSyncModels.Enqueue(clientmodel);
_modelUpdated = true;
}
//регистрация игрока
public void RegisterPlayer(SyncObjectModel obj)
{
obj.Authority = Context.ConnectionId;
_broadcaster.registerPlayer(obj);
}
//Конект к хабу!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
private void StartSignalR()
{
Debug.Log("StartSignalR");
if (HubConnection == null)
{
try
{
HubConnection = new HubConnection(signalRUrl);
Debug.Log(signalRUrl);
HubConnection.Error += hubConnection_Error;
HubProxy = HubConnection.CreateHubProxy("h");
//подписываемся на рассылку сообщений
Subscription subscriptionMessage = HubProxy.Subscribe("broadcastMessage");
subscriptionMessage.Received += subscription_DataMessage =>
{
Debug.Log("Message1");
foreach (var item in subscription_DataMessage)
{
Debug.Log(item);
//десериализуем объект в item
ChatModel chatModel = new ChatModel();
chatModel = JsonConvert.DeserializeObject <ChatModel>(item.ToString());
//добавляем эти объекты в Pool и когда смогу, то Instantiate их в LateUpdate
_chatModels = (chatModel.Name + ": " + chatModel.Message + Environment.NewLine);
}
};
//подписываемся на рассылку обновления игры
Subscription subscription = HubProxy.Subscribe("updateGameModels");
subscription.Received += subscription_Data =>
{
foreach (var item in subscription_Data)
{
//десериализуем объект syncObjectModel в item
SyncObjectModel syncObjectModel = new SyncObjectModel();
syncObjectModel = JsonConvert.DeserializeObject <SyncObjectModel>(item.ToString());
//добавляем эти объекты в syncPool
_syncObjectPool.Add(syncObjectModel);
}
};
//подписываемся на рассылку спауна
Subscription subscriptionInstantiatePrefab = HubProxy.Subscribe("instantiatePrefab");
subscriptionInstantiatePrefab.Received += subscription_DataInstantiatePrefab =>
{
if (!IsPlayerRegister)
{
return;
}
foreach (var item in subscription_DataInstantiatePrefab)
{
//десериализуем объект в item
SyncObjectModel syncObjectModel = new SyncObjectModel();
syncObjectModel = JsonConvert.DeserializeObject <SyncObjectModel>(item.ToString());
if (syncObjectModel.Authority == HubConnection.ConnectionId)
{
GameHelper.CurrentPlayer = syncObjectModel;
}
//добавляем эти объекты в Pool и когда смогу, то Instantiate их в LateUpdate
_instantiatePlayerPool.Add(syncObjectModel);
}
};
////подписываемся на рассылку пуль
GetComponent <SignalRShooting>().StartShooting();
//Subscription subscriptionInstantiateBullet = HubProxy.Subscribe("instantiateBullet");
//subscriptionInstantiateBullet.Received += subscription_DataInstantiateBullet =>
//{
// foreach (var item in subscription_DataInstantiateBullet)
// {
// //десериализуем объект в item
// SyncObjectModel syncObjectModel = new SyncObjectModel();
// syncObjectModel = JsonConvert.DeserializeObject<SyncObjectModel>(item.ToString());
// //добавляем эти объекты в Pool и когда смогу, то Instantiate их в LateUpdate
// _instantiateBulletPool.Add(syncObjectModel);
// }
//};
//подписываемся на рассылку выхода игрока
Subscription subscriptionDisconnectPrefab = HubProxy.Subscribe("disconnectPrefab");
subscriptionDisconnectPrefab.Received += subscription_DataDisconnectPrefab =>
{
foreach (var item in subscription_DataDisconnectPrefab)
{
//десериализуем объект в item
SyncObjectModel disModel = new SyncObjectModel();
disModel = JsonConvert.DeserializeObject <SyncObjectModel>(item.ToString());
//добавляем эти объекты в Pool и когда смогу, то удалят их в LateUpdate
_disconnectedModels.Add(disModel);
}
};
Debug.Log("hubConnection.Start");
HubConnection.Start();
}
catch (InvalidCastException e)
{
Debug.Log("Ошибка: " + e);
OnApplicationQuit();
}
}
else
{
Debug.Log("SignalR already connected...");
}
}
