protected virtual void RecieveRandomSeedSync(TCPMessageType tcpMessageType, object messageObj)
{
if (this.isDisconnected)
{
global::Debug.Log("RandomSeedSync: 切断中");
return;
}
global::Debug.Log("RandomSeedSync: 受信");
if (base.stateManager.rootState.currentState.GetType() != typeof(SubStateWaitRandomSeedSync))
{
return;
}
RandomSeedSyncData randomSeedSyncData = TCPData <RandomSeedSyncData> .Convert(messageObj);
if (this.CheckRecieveData(randomSeedSyncData.playerUserId, randomSeedSyncData.hashValue))
{
return;
}
this.lastAction[TCPMessageType.RandomSeedSync] = delegate()
{
global::Debug.LogFormat("randomSeed:{0}", new object[]
{
randomSeedSyncData.randomSeed
});
UnityEngine.Random.InitState(randomSeedSyncData.randomSeed);
this.recieveChecks[TCPMessageType.RandomSeedSync] = true;
};
this.SendConfirmation(tcpMessageType, randomSeedSyncData.playerUserId, string.Empty);
}
public TCPData Parse_Data()
{
TCPData Data = new TCPData();
if (strReceived.Length > 1)
{
string[] sub = strReceived.Split(' '); // data sended with ' '
Data.message_number = int.Parse(sub[0]);
if (Data.message_number == 7)
{
Data.m_fSpeed = float.Parse(sub[1]);
Data.m_fComfSpd = float.Parse(sub[2]);
Data.m_fRepeatTime = int.Parse(sub[3]);
Data.m_fSteady_Time_Interval = float.Parse(sub[4]);
Data.global_current_time = float.Parse(sub[5]);
Data.body_detection = int.Parse(sub[6]);
}
else if (Data.message_number == 2)
{
Data.m_nMode = int.Parse(sub[1]);
}
}
else
{
Debug.Log("Data is unparsable. Data : " + strReceived);
}
return(Data); // return data
}
protected void RecieveAdventureSceneData(TCPMessageType tcpMessageType, object messageObj)
{
if (this.isDisconnected)
{
global::Debug.Log("AdventureSceneData: 切断中");
return;
}
global::Debug.Log("AdventureSceneData: 受信");
AdventureSceneData data = TCPData <AdventureSceneData> .Convert(messageObj);
if (this.CheckHash(data.hashValue))
{
return;
}
this.lastAction[tcpMessageType] = delegate()
{
this.isAdventureSceneAllEnd = (data.isEnd == 1);
if (this.isAdventureSceneAllEnd)
{
this.adventureSceneEndList.Clear();
}
this.recieveChecks[tcpMessageType] = true;
};
int num = (!base.stateManager.battleAdventureSceneManager.isUpdate) ? 1 : 0;
this.SendConfirmation(tcpMessageType, data.playerUserId, num.ToString());
}
private IEnumerator SendConfirm <T>(TCPMessageType tcpMessageType, TCPData <T> message, string targetId, bool enableDisconnected = true) where T : class
{
global::Debug.LogFormat("Send tcpMessageType:{0}", new object[]
{
tcpMessageType
});
float sendWaitTime = 2f;
for (;;)
{
if (sendWaitTime >= 2f)
{
sendWaitTime = 0f;
this.SendMessageForTarget(tcpMessageType, message, new string[]
{
targetId
}, enableDisconnected);
}
sendWaitTime += Time.unscaledDeltaTime;
if (this.otherUserCount == 0 || this.confirmationChecks[tcpMessageType].Where((string item) => item == targetId).Any <string>())
{
break;
}
yield return(null);
}
this.confirmationChecks[tcpMessageType].Clear();
yield break;
yield break;
}
// Use this for initialization
void Start()
{
TCPData tcpData = new TCPData();
tcpData.IP = "61.151.186.113";
tcpData.Port = 8080;
NetService.StartTCP(tcpData);
}
private static void Server_OnDataReceived(object sender, TCPData e)
{
Console.WriteLine(e.items.Length);
if (e.items.Length > 0)
{
foreach (Item i in e.items)
{
Console.WriteLine(i.name + " " + i.amount);
}
}
}
private void RecieveEmotion(TCPMessageType tcpMessageType, object messageObj)
{
global::Debug.Log("Emotion: 受信");
EmotionData emotionData = TCPData <EmotionData> .Convert(messageObj);
string spriteName = emotionData.spriteName;
int iconSpritesIndex = emotionData.iconSpritesIndex;
bool isOther = true;
base.stateManager.uiControlPvP.ShowEmotion(iconSpritesIndex, spriteName, isOther);
}
protected virtual void RecieveAttack(TCPMessageType tcpMessageType, object messageObj)
{
if (this.isDisconnected)
{
global::Debug.Log("Attack: 切断中");
return;
}
global::Debug.Log("Attack: 受信");
if (base.stateManager.rootState.currentState.GetType() != typeof(SubStateMultiWaitEnemySkillSelect) && base.stateManager.rootState.currentState.GetType() != typeof(SubStateWaitEnemySkillSelect))
{
global::Debug.LogWarning("まだ準備していない");
return;
}
AttackData attackData = TCPData <AttackData> .Convert(messageObj);
if (this.CheckRecieveData(attackData.playerUserId, attackData.hashValue))
{
return;
}
this.lastAction[TCPMessageType.Attack] = delegate()
{
CharacterStateControl currentSelectCharacterState = this.battleStateData.currentSelectCharacterState;
int targetIdx = attackData.targetIdx;
int selectSkillIdx = attackData.selectSkillIdx;
if (this.battleStateData.currentSelectCharacterState.isEnemy)
{
if (attackData.isTargetCharacterEnemy)
{
currentSelectCharacterState.targetCharacter = this.battleStateData.playerCharacters[targetIdx];
}
else
{
currentSelectCharacterState.targetCharacter = this.battleStateData.enemies[targetIdx];
}
}
else if (attackData.isTargetCharacterEnemy)
{
currentSelectCharacterState.targetCharacter = this.battleStateData.enemies[targetIdx];
}
else
{
currentSelectCharacterState.targetCharacter = this.battleStateData.playerCharacters[targetIdx];
}
currentSelectCharacterState.targetCharacter.myIndex = targetIdx;
currentSelectCharacterState.isSelectSkill = selectSkillIdx;
this.battleStateData.onSkillTrigger = true;
this.recieveChecks[TCPMessageType.Attack] = true;
};
this.SendConfirmation(tcpMessageType, attackData.playerUserId, string.Empty);
}
public IEnumerator SendMessageInsistently <T>(TCPMessageType tcpMessageType, TCPData <T> message, List <int> TCPSendUserIdList, string TCPKey = "activityList", Action <List <int> > SendFaildAction = null) where T : class
{
TCPUtil.isTCPSending = true;
int waitingCount = 0;
List <int> InsistentlySendUserIdList = new List <int>();
foreach (int item in TCPSendUserIdList)
{
InsistentlySendUserIdList.Add(item);
}
for (;;)
{
global::Debug.LogFormat("[SendMessage] tcpMessageType:{0}, MyPlayerUserId:{1} , waitingCount:{2}", new object[]
{
tcpMessageType,
this.myUserId,
waitingCount
});
for (int i = 0; i < this.confirmationChecks[tcpMessageType].Count; i++)
{
InsistentlySendUserIdList.Remove(int.Parse(this.confirmationChecks[tcpMessageType][i]));
}
bool sendResult = this.SendMessageForTarget(tcpMessageType, message, InsistentlySendUserIdList, TCPKey);
yield return(AppCoroutine.Start(Util.WaitForRealTime(1f), false));
waitingCount++;
bool finishForcely = false;
if ((float)waitingCount >= 10f || !sendResult)
{
finishForcely = true;
if ((float)waitingCount >= 10f && SendFaildAction != null)
{
SendFaildAction(InsistentlySendUserIdList);
}
}
if (this.confirmationChecks[tcpMessageType].Count == TCPSendUserIdList.Count || finishForcely)
{
break;
}
yield return(null);
}
this.confirmationChecks[tcpMessageType].Clear();
TCPUtil.isTCPSending = false;
global::Debug.LogFormat("[PacketEnd] tcpMessageType:{0}", new object[]
{
tcpMessageType
});
yield break;
yield break;
}
private void RecieveEnemyTurnSync(TCPMessageType tcpMessageType, object messageObj)
{
global::Debug.Log("EnemyTurnSync: 受信");
EnemyTurnSyncData enemyTurnSyncData = TCPData <EnemyTurnSyncData> .Convert(messageObj);
if (base.CheckRecieveData(enemyTurnSyncData.playerUserId, enemyTurnSyncData.hashValue))
{
return;
}
this.lastAction[TCPMessageType.EnemyTurnSync] = delegate()
{
this.recieveChecks[TCPMessageType.EnemyTurnSync] = true;
};
base.SendConfirmationDisconnected(tcpMessageType, enemyTurnSyncData.playerUserId, string.Empty);
}
protected void RecieveLastConfirmation(TCPMessageType tcpMessageType, object messageObj)
{
global::Debug.Log("LastConfirmation: 受信");
LastConfirmationData lastConfirmationData = TCPData <LastConfirmationData> .Convert(messageObj);
if (this.CheckRecieveData(lastConfirmationData.playerUserId, lastConfirmationData.hashValue))
{
return;
}
this.confirmationChecks[TCPMessageType.Confirmation].Add(lastConfirmationData.playerUserId);
this.RunLastAction((TCPMessageType)lastConfirmationData.tcpMessageType);
global::Debug.LogFormat("tcpMessageType:{0}", new object[]
{
(TCPMessageType)lastConfirmationData.tcpMessageType
});
}
private void RecieveRetire(TCPMessageType tcpMessageType, object messageObj)
{
global::Debug.Log("Retire: リタイア");
RetireData retierData = TCPData <RetireData> .Convert(messageObj);
if (base.CheckRecieveData(retierData.playerUserId, retierData.hashValue))
{
return;
}
this.lastAction[TCPMessageType.Retire] = delegate()
{
if (retierData.retiredPlayerId != ClassSingleton <MultiBattleData> .Instance.MyPlayerUserId)
{
this.ShowWinDialog();
}
};
base.SendConfirmation(tcpMessageType, retierData.playerUserId, string.Empty);
}
protected void RecieveLeaderChange(TCPMessageType tcpMessageType, object messageObj)
{
if (this.isDisconnected)
{
global::Debug.Log("LeaderChange: 切断中");
return;
}
global::Debug.Log("LeaderChange: 受信");
LeaderChangeData data = TCPData <LeaderChangeData> .Convert(messageObj);
if (this.CheckHash(data.hashValue))
{
return;
}
this.lastAction[tcpMessageType] = delegate()
{
this.battleStateData.ChangePlayerLeader(data.leaderIndex);
this.battleStateData.ChangeEnemyLeader(data.leaderIndex);
this.recieveChecks[tcpMessageType] = true;
};
this.SendConfirmation(tcpMessageType, data.playerUserId, string.Empty);
}
protected void RecieveConfirmation(TCPMessageType tcpMessageType, object messageObj)
{
global::Debug.Log("Confirmation: 受信");
ConfirmationData confirmationData = TCPData <ConfirmationData> .Convert(messageObj);
if (this.CheckRecieveData(confirmationData.playerUserId, confirmationData.hashValue))
{
return;
}
TCPMessageType tcpMessageType2 = (TCPMessageType)confirmationData.tcpMessageType;
this.confirmationChecks[tcpMessageType2].Add(confirmationData.playerUserId);
global::Debug.LogFormat("confirmationChecks : {0}から確認用{1}を受信しました. Count:{2}", new object[]
{
confirmationData.playerUserId,
tcpMessageType2,
this.confirmationChecks[tcpMessageType2].Count
});
if (tcpMessageType2 == TCPMessageType.AdventureScene && confirmationData.value1 == "1" && !this.adventureSceneEndList.Contains(confirmationData.playerUserId))
{
this.adventureSceneEndList.Add(confirmationData.playerUserId);
}
}
public TCPData GetProcessedData(KinectData kinectData)
{
TCPData pd = new TCPData()
{
Metadata = new Dictionary <string, string>()
};
int max = kinectData.MaxDepth;
int min = kinectData.MinDepth;
if (kinectData.DepthArray != null)
{
//enviamos tambien el array de profundidades
char[] depthsChar = kinectData.DepthArray.Select(p => Convert.ToChar(p)).ToArray();
string depthsArray = new string(depthsChar);
string b64 = Base64Encode(depthsArray);
//Metemos los atributos que queremos enviar
pd.Metadata.Add(KEY_DEPTH_WIDTH, kinectData.Width.ToString());
pd.Metadata.Add(KEY_DEPTH_HEIGHT, kinectData.Height.ToString());
pd.Metadata.Add(KEY_DEPTH_MIN, min.ToString());
pd.Metadata.Add(KEY_DEPTH_MAX, max.ToString());
pd.Metadata.Add(KEY_DEPTH_ARRAY, b64);
}
if (kinectData.DetectedObjects != null && kinectData.DetectedObjects.Count > 0)
{
//enviamos los objetos que se han detectado
foreach (Kinect.ObjectsDetection.DetectedObject o in kinectData.DetectedObjects)
{
pd.Metadata.Add(KEY_OBJ_PREFIX + o.Data, o.RelCenter.X + "," + o.RelCenter.Y);
}
}
return(pd);
}
public abstract IEnumerator SendMessageInsistently <T>(TCPMessageType tcpMessageType, TCPData <T> message, float waitingTerm = 2f) where T : class;
public override IEnumerator SendMessageInsistently <T>(TCPMessageType tcpMessageType, TCPData <T> message, float waitingTerm = 2f)
{
global::Debug.LogFormat("Send tcpMessageType:{0}", new object[]
{
tcpMessageType
});
float sendWaitTime = waitingTerm;
float sendTotalWaitTime = 0f;
for (;;)
{
while (this.isSendEvent || this.isDisconnected || this.isEnemyFailedAction)
{
yield return(null);
}
if (sendWaitTime >= waitingTerm)
{
sendWaitTime = 0f;
base.SendMessageForSync(tcpMessageType, message);
}
if (sendTotalWaitTime >= 45f)
{
sendTotalWaitTime = 0f;
IEnumerator enemyFailedAction = this.EnemyFailedAction();
while (enemyFailedAction.MoveNext())
{
yield return(null);
}
}
if (this.confirmationChecks[tcpMessageType].Count == base.otherUserCount)
{
break;
}
sendWaitTime += Time.unscaledDeltaTime;
sendTotalWaitTime += Time.unscaledDeltaTime;
yield return(null);
}
LastConfirmationData message2 = new LastConfirmationData
{
playerUserId = ClassSingleton <MultiBattleData> .Instance.MyPlayerUserId,
hashValue = Singleton <TCPUtil> .Instance.CreateHash(TCPMessageType.LastConfirmation, ClassSingleton <MultiBattleData> .Instance.MyPlayerUserId, tcpMessageType),
tcpMessageType = tcpMessageType.ToInteger()
};
base.SendMessageForSync(TCPMessageType.LastConfirmation, message2);
this.confirmationChecks[tcpMessageType].Clear();
yield break;
yield break;
}
