public WordEventInfo(Word word, WordEvent wordEvent, WordState wordState, DateTime lastStateChange)
{
this.word = word;
this.wordEvent = wordEvent;
this.wordState = wordState;
this.lastStateChange = lastStateChange;
}
public WordEventInfo(Word word, WordEvent wordEvent, WordState wordState, DateTime lastStateChange)
{
this.word = word;
this.wordEvent = wordEvent;
this.wordState = wordState;
this.lastStateChange = lastStateChange;
}
private void setWordState(WordState newState)
{
switch (newState)
{
case WordState.Waiting:
label2.Text = "Waiting for your guess ...";
label2.ForeColor = Color.Blue;
break;
case WordState.Right:
label2.Text = "Right :)";
label2.ForeColor = Color.Green;
break;
case WordState.Wrong:
label2.Text = "Wrong :(";
label2.ForeColor = Color.Red;
break;
}
}
public void AddState(WordState state)
{
if (table.Contains(state))
{
table[state] = (int)table[state] + 1;
}
else
{
table[state] = 1;
}
}
public int this[WordState state]
{
get
{
if (table.ContainsKey(state))
{
return((int)table[state]);
}
return(0);
}
private set { }
}
private void BuildWords(string keyword, WordState state)
{
if (_table.ContainsKey(keyword))
{
Word word = (Word)_table[keyword];
word.AddState(state);
}
else
{
Word word = new Word();
word.AddState(state);
_table[keyword] = word;
}
}
public void SetText(string text, WordState state)
{
if (state == WordState.correct)
{
SetText(text, correct_color);
}
else if (state == WordState.incorrect)
{
SetText(text, base_color);
}
else if (state == WordState.used)
{
SetText(text, used_color);
}
}
public void AddToWordSearch(int block_id)
{
if (is_searching && IsAdjacent(last_block, block_id) && !used_blocks.Contains(block_id))
{
current_word += board[block_id].value.ToUpper();
used_blocks.Add(block_id);
last_block = block_id;
line_display.AddPosition(board[block_id].transform.position);
WordState state = gm.ProcessWordHover(current_word);
word_display.SetText(current_word, state);
}
}
public WordState ProcessWordHover(string word)
{
WordState state = WordState.correct;
if (!current_game_dictionary.Contains(word))
{
state = WordState.incorrect;
}
else if (used_words.Contains(word))
{
state = WordState.used;
}
sfx.PlayClick();
return(state);
}
private void UpdateEvents()
{
WordState lastState = WordState.Unknown;
DateTime lastStateChange = DateTime.MinValue;
List <WordEventInfo> eventInfos = new List <WordEventInfo>();
foreach (WordInfo wordInfo in words)
{
WordEventInfo lastEventInfo = null;
foreach (WordEvent wordEvent in wordInfo.Word.Events)
{
if (wordEvent.EventType == WordEventType.Added || wordEvent.Translation == Translation)
{
lastEventInfo = CreateEventInfo(wordInfo.Word, lastEventInfo, wordEvent);
eventInfos.Add(lastEventInfo);
}
}
if (lastEventInfo != null && (lastState == WordState.Unknown || lastEventInfo.WordState < lastState))
{
lastState = lastEventInfo.WordState;
lastStateChange = lastEventInfo.LastStateChange;
}
}
State = lastState;
LastStateChange = lastStateChange;
eventInfos.Reverse();
eventInfos = eventInfos.OrderByDescending(e => e.WordEvent.EventDate).ToList();
Events.Clear();
foreach (WordEventInfo eventInfo in eventInfos)
{
Events.Add(eventInfo);
}
}
private static bool HasUpperCaseSequenceFinished(bool isCurrentCharLower, WordState currentWordState,
int currentIndex, int currentKeywordIndex)
{
return(isCurrentCharLower && currentWordState == WordState.UpperCase &&
currentIndex - currentKeywordIndex > 1);
}
public void Allow()
{
state = WordState.Allowed;
}
public void Ban()
{
state = WordState.Banned;
}
public void Restrict()
{
state = WordState.Restricted;
}
public Word(string word, WordState state)
{
myWord = word;
this.state = state;
}
/// <summary>
///
/// </summary>
/// <param name="chars"></param>
/// <param name="state"></param>
/// <param name="value"></param>
public Word(List<char> chars, WordState state, int value)
: this(chars, state)
{
this.value = value;
}
/// <summary>
///
/// </summary>
/// <param name="chars"></param>
/// <param name="state"></param>
public Word(List<char> chars, WordState state)
{
this.chars = chars;
this.state = state;
this.value = 0;
}
private void Start()
{
_currentUserId = PreferencesFactory.GetString(Constants.ProfileUserId);
if (ShouldGetChallengesList)
{
RefreshChallengesList();
}
GS.GameSparksAuthenticated = (playerId) => {
_currentUserId = playerId;
// connection was interupted
// user now reconnect but challenge was canceled
if (GameSparksManager.Instance.GetCurrentChallengeId() != null)
{
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnErrorReceived(LocaliseText.Get("Challenge.NotAvailable"));
}
}
};
ChallengeIssuedMessage.Listener = (listener) =>
{
_currentChallengeId = listener.Challenge.ChallengeId;
GameSparksManager.Instance.SetCurrentChallengeId(_currentChallengeId);
var challengerId = listener.Challenge.Challenger.Id;
if (_currentUserId != challengerId)
{
var username = listener.Challenge.Challenger.Name;
if (_onChallengeDetected != null)
{
if (!_isRematch)
{
_onChallengeDetected.OnChallengeIssued(_currentChallengeId, username);
}
else
{
new AcceptChallengeRequest()
.SetChallengeInstanceId(_currentChallengeId)
.Send((response) => { });
}
}
}
};
ChallengeStartedMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
if (challenge != null)
{
if (_currentUserId == null)
{
_currentUserId = PreferencesFactory.GetString(Constants.ProfileUserId);
}
_currentChallengeId = challenge.ChallengeId;
GameSparksManager.Instance.SetCurrentChallengeId(_currentChallengeId);
var acceptedPlayersEnumerator = challenge.Accepted.GetEnumerator();
var challengedEnumerator = challenge.Challenged.GetEnumerator();
var challenger = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = challenge.Challenger.Name,
UserId = challenge.Challenger.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(challenge.Challenger.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(challenge.Challenger.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Challenger = challenger;
while (challengedEnumerator.MoveNext())
{
var playerDetail = challengedEnumerator.Current;
if (playerDetail != null)
{
var challenged = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = playerDetail.Name,
UserId = playerDetail.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(playerDetail.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(playerDetail.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Challenged = challenged;
}
}
challengedEnumerator.Dispose();
while (acceptedPlayersEnumerator.MoveNext())
{
var playerDetail = acceptedPlayersEnumerator.Current;
if (playerDetail != null)
{
if (playerDetail.Id != _currentUserId)
{
var opponent = new Challenge
{
ChallengeId = challenge.ChallengeId,
UserName = playerDetail.Name,
UserId = playerDetail.Id,
AvatarUploadId = challenge.ScriptData.GetGSData(playerDetail.Id).GetString("avatarUploadId"),
ExternalIds = challenge.ScriptData.GetGSData(playerDetail.Id).GetGSData("externalIds")
};
GameSparksManager.Instance.Opponent = opponent;
}
}
}
acceptedPlayersEnumerator.Dispose();
var nextPlayerId = challenge.NextPlayer;
var isMyTurn = nextPlayerId == _currentUserId;
GameSparksManager.Instance.SetIsMyTurn(isMyTurn);
List <GSData> words = null;
var gsData = listener.Challenge.ScriptData;
_isRematch = false;
GameSparksManager.Instance.SetGameMode(GameMode.Multi);
if (gsData != null)
{
words = gsData.GetGSDataList("words");
GameSparksManager.Instance.SetWords(words);
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeStarted(isMyTurn, GameSparksManager.Instance.Challenger.UserName, GameSparksManager.Instance.Challenged.UserName);
}
}
if (words == null)
{
DialogManager.Instance.ShowError(LocaliseText.Get("Game.ChallengerNotCreated"), doneCallback: (DialogInstance dialogInstance) => {
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnErrorReceived("REJOIN_LOBBY");
}
});
return;
}
if (SceneManager.GetActiveScene().name != "Game")
{
GameManager.LoadSceneWithTransitions("Game");
}
}
}
else
{
MyDebug.Log("Challenge Started Error: " + listener.Errors.JSON.ToString());
}
};
ChallengeTurnTakenMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
_currentChallengeId = challenge.ChallengeId;
var nextPlayerId = challenge.ScriptData.GetString("nextPlayer");
var isMyTurn = nextPlayerId == _currentUserId;
GameSparksManager.Instance.SetIsMyTurn(isMyTurn);
var scriptData = challenge.ScriptData;
if (scriptData != null)
{
var eventKey = scriptData.GetString("EventKey");
if (eventKey == "WordFound" && scriptData != null &&
scriptData.GetString("SenderPlayerId") != _currentUserId &&
scriptData.ContainsKey("WordFound"))
{
GSData wordFound = scriptData.GetGSData("WordFound");
if (wordFound.ContainsKey("state"))
{
WordState state = (WordState)wordFound.GetInt("state");
string word = wordFound.GetString("word");
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnWordFound(word, state);
}
}
else // backward compability
{
if (scriptData.ContainsKey("found_words"))
{
List <GSData> found_words = scriptData.GetGSDataList("found_words");
foreach (GSData _w in found_words)
{
string word = _w.GetString("word");
string player_id = _w.GetString("player_id");
if (_onChallengeDetected != null && player_id != _currentUserId)
{
_onChallengeDetected.OnWordFound(word, WordState.Found);
}
}
}
}
}
var wordDrag = scriptData.GetGSData("WordDrag");
if (eventKey == "WordDrag" && wordDrag != null &&
wordDrag.ContainsKey("positions"))
{
if (scriptData.GetString("SenderPlayerId") != _currentUserId)
{
List <DrawQueueItem> _positions = new List <DrawQueueItem>();
var center = Vector3.zero;
if (wordDrag.ContainsKey("positions"))
{
List <GSData> _l = wordDrag.GetGSDataList("positions");
foreach (GSData _d in _l)
{
string json = _d.GetString("item");
_positions.Add(new DrawQueueItem(json));
}
}
if (wordDrag.ContainsKey("center_x") && wordDrag.ContainsKey("center_y"))
{
float cx = (float)wordDrag.GetFloat("center_x");
float cy = (float)wordDrag.GetFloat("center_y");
float cz = (float)wordDrag.GetFloat("center_z");
center = new Vector3(cx, cy, cz);
}
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnPositionDetected(_positions, center);
}
}
}
if (((eventKey == "takeTurn" || eventKey == null) &&
scriptData.GetString("SenderPlayerId") != _currentUserId &&
scriptData.GetString("SenderPlayerId") != nextPlayerId) ||
scriptData.GetBoolean("TimeOut") != null)
{
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnTurnEnd(Vector3.zero, "word");
}
}
}
}
else
{
MyDebug.Log("Challenge Turn Taken Error: " + listener.Errors.JSON.ToString());
}
};
ChallengeDeclinedMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var challenge = listener.Challenge;
if (challenge != null)
{
var declined = challenge.Declined;
var enumerator = declined.GetEnumerator();
while (enumerator.MoveNext())
{
var playerDetail = enumerator.Current;
var playerName = playerDetail.Name;
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeDeclined(playerName);
}
}
enumerator.Dispose();
}
}
};
ChallengeExpiredMessage.Listener = (listener) => { RefreshChallengesList(); };
ScriptMessage.Listener = (listener) =>
{
if (!listener.HasErrors)
{
var extCode = listener.ExtCode;
if (extCode == "userLeaved")
{
var gameStateMessage = new GameStateMessage
{
Message = listener.Summary,
Points = 0
};
if (_onChallengeDetected != null)
{
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Leaved, gameStateMessage);
}
}
if (extCode == "userTurn")
{
}
}
};
ChallengeWonMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId != null && _currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null)
{
var points = 0;
var point = scriptData.GetInt("winPoints");
if (point != null)
{
points = (int)point;
}
var message = LocaliseText.Get("Game.CongratsYouWon");
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Won,
gameStateMessage);
}
}
}
};
ChallengeDrawnMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null && scriptData.GetNumber("drawPoints") != null)
{
int points = (int)scriptData.GetNumber("drawPoints");
var message = "It's a draw game!";
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Draw,
gameStateMessage);
}
}
}
};
ChallengeLostMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
if (StringUtils.IsNullOrWhiteSpace(_currentChallengeId))
{
_currentChallengeId = GameSparksManager.Instance.GetCurrentChallengeId();
}
if (_currentChallengeId.Equals(listener.Challenge.ChallengeId))
{
var scriptData = listener.Challenge.ScriptData;
if (scriptData != null)
{
var points = 0;
var point = scriptData.GetInt("losePoints");
if (point != null)
{
points = (int)point;
}
var message = "You Lost. Better luck next time!";
if (_onChallengeDetected != null)
{
var gameStateMessage = new GameStateMessage
{
Message = message,
Points = points
};
_onChallengeDetected.OnChallengeFinishedEvent(GameStates.Lost,
gameStateMessage);
}
}
}
};
AchievementEarnedMessage.Listener = (listener) =>
{
if (listener.HasErrors)
{
return;
}
var achievementName = listener.AchievementName;
if (_onAchievementDetected != null)
{
_onAchievementDetected.OnAchievmentEarned(achievementName);
}
};
}
private static bool HasLowerCaseSequenceFinished(bool isCurrentCharLower, WordState currentWordState)
{
return(!isCurrentCharLower && currentWordState == WordState.LowerCase);
}
public void OnWordFound(string word, WordState state)
{
}
public string[] SplitToStrings(string sentence)
{
return(DicSplit.GetInstance().Do(sentence));
//获取概率矩阵
List <Word> probabilityMatrix = new List <Word>();
for (int i = 0; i < sentence.Length; i++)
{
if (_table.ContainsKey(sentence[i].ToString()))
{
Word word = (Word)_table[sentence[i].ToString()];
probabilityMatrix.Add(word);
}
else
{
probabilityMatrix.Add(null);
}
}
//最佳路径计算(计算矩阵的最佳路线,暴力法)
List <WordState> path = new List <WordState>();
WordState[] states = new WordState[4];
states[0] = WordState.SINGLE;
states[1] = WordState.MIDDLE;
states[2] = WordState.HEAD;
states[3] = WordState.END;
WordState lastState = WordState.END;
for (int j = 0; j < probabilityMatrix.Count; j++)
{
if (probabilityMatrix[j] == null)
{
path.Add(WordState.END);
continue;
}
List <WordState> currentStates = probabilityMatrix[j].SortStateCount();
for (int i = 0; i < currentStates.Count; i++)
{
if (currentStates[i] == WordState.SINGLE || currentStates[i] == WordState.HEAD)
{
if (lastState == WordState.END || lastState == WordState.SINGLE)
{
path.Add(currentStates[i]);
lastState = currentStates[i];
break;
}
}
else //if (currentStates[i] == State.MIDDLE || currentStates[i] == State.END)
{
if (lastState == WordState.HEAD || lastState == WordState.MIDDLE)
{
path.Add(currentStates[i]);
lastState = currentStates[i];
break;
}
}
}
}
List <string> resultList = new List <string>();
string strResult = "";
for (int i = 0; i < path.Count; i++)
{
strResult += sentence[i];
if (path[i] == WordState.END || path[i] == WordState.SINGLE)
{
resultList.Add(strResult);
strResult = "";
}
}
return(resultList.ToArray());
}
