public void Send(AppMessageBase message)
{
NetworkServer.SendToClient(message.ConnectionId, (short)message.Type, message);
#if NETWORK_DEBUG
DevLogger.Log("SendAppMessage: " + message.Type + "\n" + Newtonsoft.Json.JsonConvert.SerializeObject(message, Newtonsoft.Json.Formatting.Indented));
#endif
}
static ThreadSafeContext()
{
if (Thread.CurrentThread.ManagedThreadId == MainThreadId)
{
if (_isInitialized == false)
{
IsWebPlayer = Application.platform == RuntimePlatform.WebGLPlayer;
IsEditor = Application.isEditor;
BuildVersion = AppVersion;
PersistentDataPath = Application.persistentDataPath;
DeviceUniqueIdentifier = SystemInfo.deviceUniqueIdentifier;
Platform = Application.platform;
_isInitialized = true;
}
}
else
{
DevLogger.Warning("ThreadSafeContext should be initialized from the main thread.", LogChannel.Common);
}
}
public void MakeCall(RequestMethod method, string path, string data, Dictionary <string, string> headers, ApiCallCallback callback)
{
if (_baseHost == null)
{
DevLogger.Error(string.Format("Need initialize {0} before MakeCall",
GetType()), MarketLogType.MarketApi);
return;
}
var uri = new Uri(_baseHost, path);
Log(string.Format("{0} request: {1} \n{2}", method.ToString().ToUpper(),
GetShortUrl(uri.ToString()), data));
switch (method)
{
case RequestMethod.Get:
StartCoroutine(MakeGet(uri, headers, callback, _apiSettings.UseDebug));
break;
case RequestMethod.Post:
StartCoroutine(MakePost(uri, data, headers, callback, _apiSettings.UseDebug));
break;
case RequestMethod.Put:
StartCoroutine(MakePut(uri, data, headers, callback, _apiSettings.UseDebug));
break;
default:
throw new ArgumentOutOfRangeException("method", method, null);
}
}
private void OnAppMsgReceived(AppServerAnswerMessageBase answer)
{
var logString = "Client get app answer type {0} with error {1}";
DevLogger.Log(string.Format(logString,
answer.Type, answer.Error), DTanksLogChannel.Network);
}
private void OnErrorCallback(Error error)
{
DevLogger.Error(string.Format("Can't load {0} from API", Type));
FormModel.Text = string.Format("Load text error:\n{0}", Type);
View.SetLoadingState(false);
}
public void SendToPlayer(GameMessageBase message, int connectionId)
{
#if NETWORK_DEBUG
DevLogger.Log("SendToPlayer: " + connectionId + " " + message.Type + "\n" + Newtonsoft.Json.JsonConvert.SerializeObject(message, Newtonsoft.Json.Formatting.Indented));
#endif
NetworkServer.SendToClient(connectionId, (short)message.Type, message);
}
/* public static TComponent InstantiateAndGetSafeComponent<TComponent>(
* this RelativeLinkToGameObject relativeLinkToGameObject,
* Vector3? position = null,
* Quaternion? rotation = null) where TComponent : MonoBehaviour
* {
* GameObject go = relativeLinkToGameObject;
* return go.InstantiateAndGetSafeComponent<TComponent>(position, rotation);
* }*/
public static TComponent InstantiateAndGetSafeComponent <TComponent>(
this GameObject objectToInstantiate,
Vector3?position = null,
Quaternion?rotation = null) where TComponent : MonoBehaviour
{
if (objectToInstantiate != null)
{
GameObject o = UnityEngine.Object.Instantiate(
objectToInstantiate,
position != null ? position.Value : Vector3.zero,
rotation != null ? rotation.Value : Quaternion.identity);
if (o != null)
{
return(o.GetSafeComponent <TComponent>());
}
}
else
{
DevLogger.Error(
string.Format("Instantiated object with component {0} is null", typeof(TComponent)),
LogChannel.Common);
}
DevLogger.Error("Couldn't instantiate object", LogChannel.Common);
return(default(TComponent));
}
public void Open(IGameIntegrationModel gameItems)
{
if (!IsInitialized)
{
DevLogger.Error("Initialize MarketWidget before use.", MarketLogType.MarketWidget);
return;
}
if (gameItems == null)
{
DevLogger.Error("It's not impossible to Open MarketWidget. IGameIntegrationModel is null", MarketLogType.MarketWidget);
return;
}
ApplyMarketStrategy();
GameModel = gameItems;
_formContainer.Run();
var textPopUp = GetForm <MarketTextPopUp>();
PopUpController.Initialize(textPopUp);
_soundManager.IsRuning = true;
View = GetForm <MarketView>();
View.ApplyModel(Model);
ApplyState <MarketOpeningState>();
}
public void SendToAll(GameMessageBase message)
{
#if NETWORK_DEBUG
DevLogger.Log("SendToAll: " + message.Type + "\n" + Newtonsoft.Json.JsonConvert.SerializeObject(message, Newtonsoft.Json.Formatting.Indented));
#endif
NetworkServer.SendToAll((short)message.Type, message);
}
private void CheckTransactionsStatuses()
{
if (_pendingTransactions.Count > 0)
{
for (int i = 0; i < _pendingTransactions.Count; i++)
{
var transaction = _pendingTransactions[i];
int transactionConnectionId = transaction.Sender.ConnectionId;
string playerMarketAccessToken = Model.GetPlayerMarketAccessToken(transactionConnectionId);
DMarketApi.CheckAsyncOperation(playerMarketAccessToken, transaction.OperationIds,
(response, request) =>
{
var answerMessage = new AppChangingItemsAnswerMessage(new ItemsChangingResponse());
foreach (var transactionItem in response.Items)
{
var status = _apiResponseAdapter.GetTransactionStatusType(transactionItem.status);
switch (status)
{
case DMarketTransactionStatusType.Fail:
{
answerMessage.Response.MarketError = (ErrorCode)transactionItem.transferError.code;
transaction.RemoveOperation(transactionItem.operationId);
break;
}
case DMarketTransactionStatusType.Success:
{
OnSuccessMarketOperation(transactionItem, transaction);
transaction.RemoveOperation(transactionItem.operationId);
break;
}
}
}
var transactionLog = string.Format("Transaction for connection: {0}, operation left: {1}", transaction.Sender.ConnectionId,
transaction.OperationsCount);
DevLogger.Log(transactionLog, DTanksLogChannel.GameServer);
if (transaction.OperationsCount == 0)
{
SendMessageToClient(answerMessage, transactionConnectionId);
_pendingTransactions.Remove(transaction);
}
Storage.Change(GetPlayer(transactionConnectionId));
},
error =>
{
foreach (var transactionInfo in _pendingTransactions)
{
OnItemOperationError(transactionInfo.Sender, error);
}
_pendingTransactions.Clear();
});
}
}
}
protected void SendMessageToClient(AppServerAnswerMessageBase answerMessage, int connectionId)
{
answerMessage.ConnectionId = connectionId;
var logString = "Server send to {0} app answer type {1} with error {2}";
DevLogger.Log(string.Format(logString, answerMessage.ConnectionId,
answerMessage.Type, answerMessage.Error), DTanksLogChannel.Network);
Server.Send(answerMessage);
}
public void Send(GameMessageBase message)
{
message.ClientId = _currentClient.connection.connectionId;
_currentClient.Send((short)message.Type, message);
#if NETWORK_DEBUG
DevLogger.Log("Send GameMessageBase: " + message.Type + " body: \n" + Newtonsoft.Json.JsonConvert.SerializeObject(message, Newtonsoft.Json.Formatting.Indented));
#endif
}
public void AddItem(PlayerItemInfo item)
{
if (Items.Any(c => c.WorldId == item.WorldId))
{
DevLogger.Error("Item already in game inventory");
return;
}
Items.Add(item);
}
Vector3 IBattleField.GetSpawnPoint(int spawnPointIndex)
{
if (spawnPointIndex >= _spawnPoints.Count)
{
DevLogger.Warning("spawn point index {0} not exist", DTanksLogChannel.GameClient);
spawnPointIndex = 0;
}
return(_spawnPoints[spawnPointIndex].Pos);
}
protected string GetTargetString(ShowType showType, MarketItemModel model)
{
var result = string.Empty;
switch (showType)
{
case ShowType.Tittle:
result = model.Tittle;
break;
case ShowType.Description:
result = model.Description;
break;
case ShowType.ClassId:
result = model.ClassId;
break;
case ShowType.AssetId:
result = model.AssetId;
break;
case ShowType.CreationDate:
result = GetDateString(model.Created);
break;
case ShowType.LastUpdate:
result = GetDateString(model.Updated);
break;
case ShowType.Price:
result = model.Price.GetStringWithCurrencySprite(_text.color);
break;
case ShowType.Fee:
result = model.Fee.GetStringWithCurrencySprite(_text.color);
break;
case ShowType.OrderStatus:
result = model.Status.GetText();
break;
case ShowType.OffersCount:
result = model.OffersCount.ToString();
break;
case ShowType.SellOfferId:
result = model.SellOfferId;
break;
default:
result = "NOT IMPLEMENT";
DevLogger.Warning("Need implement for " + showType);
break;
}
return(result);
}
private void CheckTransactionsStatuses()
{
if (_pendingOperations.Count == 0)
{
return;
}
var transactionIds = _pendingOperations.Keys;
DMarketApi.CheckAsyncOperation(Model.GetPlayerMarketAccessToken(_connectionId), transactionIds.ToArray(),
(response, request) =>
{
foreach (var item in response.Items)
{
string itemAssetId = item.assetId;
string operationId = item.operationId;
var transactionStatus = _apiResponseAdapter.GetTransactionStatusType(item.status);
switch (transactionStatus)
{
case DMarketTransactionStatusType.Fail:
_pendingOperations.Remove(operationId);
DevLogger.Error(string.Format("Transaction for item: {0} was failed.", itemAssetId));
break;
case DMarketTransactionStatusType.Pending:
break;
case DMarketTransactionStatusType.Success:
_pendingOperations.Remove(operationId);
_successItemsIds.Add(itemAssetId);
break;
}
}
if (_pendingOperations.Count == 0)
{
if (_actionType == ItemActionType.FromMarket)
{
AddMovedItemsToInventory();
}
else
{
RemoveMovedItemsFromInventory();
}
SendLoadInventoryData();
Terminate();
}
},
error =>
{
_pendingOperations.Clear();;
OnItemOperationError(error);
});
}
private void OnAppMessageReceive(NetworkMessage msg)
{
AppMessageBase appMessage = NetworkingUtil.ReadAppMessage(msg);
#if NETWORK_DEBUG
DevLogger.Log("OnAppMessageReceive received: " + appMessage.Type + "\n" + Newtonsoft.Json.JsonConvert.SerializeObject(appMessage, Newtonsoft.Json.Formatting.Indented));
#endif
AppMsgReceived.SafeRaise(appMessage);
}
protected void SendAnswer(AppServerAnswerMessageBase answer,
AppMessageBase senderMessage)
{
answer.ConnectionId = senderMessage.ConnectionId;
var logString = "Server send to {0} app answer type {1} with error {2}";
DevLogger.Log(string.Format(logString, answer.ConnectionId,
answer.Type, answer.Error), TankGameLogChannel.Network);
Server.Send(answer);
}
void IWidget.Open()
{
if ((this as IWidget).IsInitialize)
{
ApplyState <WidgetOpeningState>();
}
else
{
DevLogger.Error("Need initialize widget before opening");
}
}
void IWidget.Logout()
{
if (Model.IsLogin)
{
ClientApi.Logout(Model.BasicAccessToken, Model.MarketAccessToken,
OnLogoutCallback, OnErrorCallback);
}
else
{
DevLogger.Warning("Try logout when user is not login");
}
}
private void ApplyMarketStrategy()
{
if (SceneManager.GetActiveScene().name.Equals("TestMarket"))
{
DevLogger.Log("Apply mockup models");
Strategy = new MarketMockupStrategy();
}
else
{
Strategy = new MarketOnlineStrategy();
}
}
protected static TPoolObject GetObjectOfType <TPoolObject>(PoolControllerBase instance)
where TPoolObject : IPoolObject
{
if (instance != null)
{
return(instance.GetObject <TPoolObject>());
}
DevLogger.Error("Pool controller is not exists", LogChannel.Common);
return(default(TPoolObject));
}
public void EquipItem(long worldId)
{
if (EquippedItems.Contains(worldId))
{
DevLogger.Error(string.Format("Item with Id:{0} already equipped.", worldId));
return;
}
PlayerItemInfo item = GetItem(worldId);
TakeOffEquipItems(item.ItemCategory);
EquippedItems.Add(worldId);
}
public void Initialize()
{
if (!IsInitialize)
{
_components = new List <ItemComponentBase>();
gameObject.GetComponentsInChildren(true, _components);
_components.ForEach(component => component.ApplyItem(this));
}
else
{
DevLogger.Warning("Try initialize twice");
}
}
public void Start(string serverIP, int port)
{
_currentClient = new NetworkClient();
RegisterHandles();
try
{
_currentClient.Connect(serverIP, port);
}
catch (Exception e)
{
DevLogger.Error(e.Message);
}
}
SoundInfo IMarketSoundCatalog.GetSoundInfo(MarketSoundType sound)
{
var result = Sounds.Find(item => item.SoundType == sound);
if (result == null)
{
DevLogger.Warning(string.Format("{0} sound missing", sound),
MarketLogType.Sound);
result = new SoundInfo();
}
return(result);
}
public GameItemType GetItemType(string classId)
{
try
{
return((GameItemType)Enum.Parse(typeof(GameItemType), classId));
}
catch (Exception e)
{
DevLogger.Error("Cannot find game item type for " + classId
+ " " + e.Message);
return(GameItemType.Unknow);
}
}
private static string GetCurrencySpriteName(string currency)
{
if (string.IsNullOrEmpty(currency))
{
return(string.Empty);
}
if (BindedCurrencyNames.ContainsKey(currency))
{
return(BindedCurrencyNames[currency]);
}
DevLogger.Error(string.Format("Currency {0} not binded", currency));
return(string.Empty);
}
public static AppMessageBase ReadAppMessage(NetworkMessage msg)
{
var type = (AppMsgType)msg.msgType;
if (AppMsgHandlers.ContainsKey(type))
{
var result = AppMsgHandlers[type](msg);
result.ConnectionId = msg.conn.connectionId;
return(result);
}
DevLogger.Error("Have no receive method for " + type, DTanksLogChannel.Network);
return(null);
}
protected virtual void OnServerCallback(ItemsChangingResponse parameters)
{
View.WaitingForm.Hide();
if (parameters.IsSuccess)
{
//TODO change to notification
DevLogger.Warning("Add notification here");
//FormView.ShowSuccesOperation();
}
else
{
MessageBox.Show("Error", parameters.ErrorText);
}
}
