private async Task <bool> LoginTest(AccountUser user)
{
IsLoading = true;
Result result = new Result();
try
{
result = await _authManager.RefreshAccessToken(user.RefreshToken);
var tokenResult = JsonConvert.DeserializeObject <Tokens>(result.Tokens);
result = await _userManager.GetUser(user.Username,
new UserAuthenticationEntity(tokenResult.AccessToken, tokenResult.RefreshToken, tokenResult.ExpiresIn),
user.Region, user.Language);
var userResult = JsonConvert.DeserializeObject <User>(result.ResultJson);
var didUpdate = await AccountAuthHelpers.UpdateUserAccount(user, tokenResult, null, userResult);
result.IsSuccess = didUpdate;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Error = ex.Message;
}
await ResultChecker.CheckSuccess(result);
IsLoading = false;
return(result.IsSuccess);
}
public async Task Refresh()
{
IsLoading = true;
string error = "";
try
{
var bookmarkResult = await _threadManager.GetAllBookmarks();
BookmarkedThreads = new ObservableCollection <Thread>();
foreach (var bookmark in bookmarkResult)
{
BookmarkedThreads.Add(bookmark);
}
await ApplicationData.Current.LocalSettings.SaveAsync(RefreshKey, DateTime.UtcNow);
await ForumsDatabase.RefreshBookmarkedThreads(BookmarkedThreads.ToList());
}
catch (Exception ex)
{
error = ex.Message;
}
if (!string.IsNullOrEmpty(error))
{
await ResultChecker.SendMessageDialogAsync($"Failed to get Bookmarks (Refresh): {error}", false);
}
IsLoading = false;
}
private async Task <bool> LoadFeed(ObservableCollection <Feed> testFeed)
{
var feedResultEntity =
await _recentActivityManager.GetActivityFeed(Locator.ViewModels.MainPageVm.CurrentUser.Username, _page, true, true, Locator.ViewModels.MainPageVm.CurrentTokens, Locator.ViewModels.MainPageVm.CurrentUser.Region, Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return(false);
}
if (string.IsNullOrEmpty(feedResultEntity.ResultJson))
{
// No Items, return false.
return(false);
}
var feedEntity = JsonConvert.DeserializeObject <RecentActivityResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Feed)
{
testFeed.Add(feed);
}
_page++;
return(true);
}
public async Task SendFriendLinkViaSms()
{
IsLoading = true;
var result = await ChatMessageManager.GetTransportsAsync();
if (!result.Any())
{
IsLoading = false;
await ResultChecker.SendMessageDialogAsync(_loader.GetString("NoSMS/Text"), false);
return;
}
var link = await CreateFriendLink();
if (!string.IsNullOrEmpty(link))
{
var chat = new ChatMessage
{
Subject = _loader.GetString("FriendRequestBody/Text"),
Body = string.Format("{0} {1}", _loader.GetString("FriendRequestBody/Text"), link)
};
await ChatMessageManager.ShowComposeSmsMessageAsync(chat);
}
IsLoading = false;
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
string error;
try
{
if (TrophyScrollingCollection == null || !TrophyScrollingCollection.Any())
{
if (!string.IsNullOrEmpty(parameter as string))
{
Username = parameter as string;
}
else
{
Username = Shell.Instance.ViewModel.CurrentUser.Username;
}
SetTrophyList();
}
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
private async Task <bool> LoadFeed(ObservableCollection <Feed> testFeed)
{
await Shell.Instance.ViewModel.UpdateTokens();
var feedResultEntity =
await _recentActivityManager.GetActivityFeed(Shell.Instance.ViewModel.CurrentUser.Username, _page, true, true, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, feedResultEntity);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return(false);
}
if (string.IsNullOrEmpty(feedResultEntity.ResultJson))
{
// No Items, return false.
return(false);
}
var feedEntity = JsonConvert.DeserializeObject <RecentActivityResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Feed)
{
testFeed.Add(feed);
}
_page++;
return(true);
}
public override async void Execute(object parameter)
{
if (string.IsNullOrEmpty(Locator.ViewModels.MessagesVm.FriendSearch))
{
return;
}
var friendFinderManager = new FriendFinderManager();
var friendResult =
await
friendFinderManager.SearchForFriends(Locator.ViewModels.MessagesVm.FriendSearch, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region,
Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(friendResult);
if (!result)
{
return;
}
var friendFinderResult = JsonConvert.DeserializeObject <FriendFinderResponse>(friendResult.ResultJson);
if (friendFinderResult.SearchResults != null)
{
Locator.ViewModels.MessagesVm.FriendSearchResults = friendFinderResult.SearchResults.ToList();
}
}
private async void AttachImage(object sender, RoutedEventArgs e)
{
string error;
try
{
var openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
openPicker.FileTypeFilter.Add(".gif");
var file = await openPicker.PickSingleFileAsync();
if (file == null)
{
return;
}
var stream = await file.OpenAsync(FileAccessMode.Read);
ViewModel.AttachedImage = stream;
ViewModel.IsImageAttached = true;
ViewModel.ImagePath = file.Path;
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
private async Task SetNicoDougaElements(bool interactive = false, string query = "")
{
var nicoNicoResultEntity =
await _liveStreamManager.GetNicoFeed("onair", "PS4", interactive, 0, 80, "view", query, Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, nicoNicoResultEntity);
var result = await ResultChecker.CheckSuccess(nicoNicoResultEntity);
if (!result)
{
return;
}
var nicoNicoEntity = JsonConvert.DeserializeObject <NicoNicoEntity>(nicoNicoResultEntity.ResultJson);
if (nicoNicoEntity?.programs == null)
{
return;
}
foreach (NicoNicoEntity.Program program in nicoNicoEntity.programs)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromNicoNico(program);
LiveBroadcastCollection.Add(entity);
}
}
public ActionResult SquadResult()
{
var resultChecker = new ResultChecker();
var result = resultChecker.GetResults();
return(View(result.Squads));
}
public async Task LoadInitialList()
{
IsLoading = true;
string error = "";
try
{
var bookmarks = await ForumsDatabase.GetBookmarkedThreadsFromDb();
if (bookmarks != null && bookmarks.Any())
{
BookmarkedThreads = bookmarks.OrderBy(node => node.OrderNumber).ToObservableCollection();
}
string refreshTime = await ApplicationData.Current.LocalSettings.ReadAsync <string>(RefreshKey);
if ((!BookmarkedThreads.Any() || (!string.IsNullOrEmpty(refreshTime) && DateTime.Parse(refreshTime) > (DateTime.UtcNow.AddHours(1.00)))))
{
await Refresh();
}
}
catch (Exception ex)
{
error = ex.Message;
}
if (!string.IsNullOrEmpty(error))
{
await ResultChecker.SendMessageDialogAsync($"Failed to get Bookmarks (Load Inital List): {error}", false);
}
IsLoading = false;
}
public async Task SendMessage()
{
string error;
try
{
if (AttachedImage != null && IsImageAttached)
{
await SendMessageWithMedia();
}
else
{
if (!string.IsNullOrEmpty(Message))
{
await SendMessageWithoutMedia();
}
}
Message = string.Empty;
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
private async Task SetUstreamElements(bool interactive = false, string query = "")
{
var filterList = new Dictionary <string, string>
{
{ "platform", "PS4" },
{ "type", "live" },
{ "interactive", interactive ? "true" : "false" }
};
var ustreamResultList =
await
_liveStreamManager.GetUstreamFeed(0, 80, "compact", filterList, "views", query,
Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, ustreamResultList);
var result = await ResultChecker.CheckSuccess(ustreamResultList);
if (!result)
{
return;
}
var ustreamList = JsonConvert.DeserializeObject <UstreamEntity>(ustreamResultList.ResultJson);
if (ustreamList?.items == null)
{
return;
}
foreach (UstreamEntity.Item ustream in ustreamList.items)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromUstream(ustream);
LiveBroadcastCollection.Add(entity);
}
}
private async Task <string> GetAvatarUrl(string username)
{
var userResult =
await
_userManager.GetUserAvatar(username, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, userResult);
var result = await ResultChecker.CheckSuccess(userResult);
if (!result)
{
return(string.Empty);
}
if (string.IsNullOrEmpty(userResult.ResultJson))
{
return(string.Empty);
}
var user = JsonConvert.DeserializeObject <User>(userResult.ResultJson);
if (user?.AvatarUrls != null)
{
return(user.AvatarUrls.First().AvatarUrlLink);
}
return(string.Empty);
}
private async Task SetTwitchElements(bool interactive = false, string query = "")
{
var twitchResult =
await _liveStreamManager.GetTwitchFeed(0, 80, "PS4", interactive, query, Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, twitchResult);
var result = await ResultChecker.CheckSuccess(twitchResult);
if (!result)
{
return;
}
var twitchList = JsonConvert.DeserializeObject <TwitchEntity>(twitchResult.ResultJson);
if (twitchList?.streams == null)
{
return;
}
foreach (TwitchEntity.Stream twitch in twitchList.streams)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromTwitch(twitch);
LiveBroadcastCollection.Add(entity);
}
}
public async Task DownloadImageAsync(MessageGroupItem item)
{
IsLoading = true;
var saved = true;
try
{
var imageBytes =
await
_messageManager.GetMessageContent(SelectedMessageGroup.MessageGroupId,
item.Message.SentMessageId,
Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await FileAccessCommands.SaveStreamToCameraRoll(imageBytes, item.Message.SentMessageId + ".png");
}
catch (Exception ex)
{
//Insights.Report(ex);
saved = false;
}
var loader = new ResourceLoader();
if (!saved)
{
await ResultChecker.SendMessageDialogAsync(loader.GetString("ErrorSaveImage/Text"), false);
}
else
{
await ResultChecker.SendMessageDialogAsync(loader.GetString("ImageSaved/Text"), true);
}
IsLoading = false;
}
public async Task RemoveMessageGroup(MessageGroupItem messageGroupItem)
{
try
{
var result =
await
_messageManager.DeleteMessageThread(messageGroupItem.MessageGroup.MessageGroupId,
Locator.ViewModels.MainPageVm.CurrentUser.Username,
Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (!resultCheck)
{
return;
}
if (SelectedMessageGroup != null && SelectedMessageGroup.MessageGroupId == messageGroupItem.MessageGroup.MessageGroupId)
{
GroupMemberSeperatedList = string.Empty;
SelectedMessageGroup = null;
MessageCollection.Clear();
IsSelected = false;
}
MessageGroupCollection.Remove(messageGroupItem);
}
catch (Exception ex)
{
// TODO: Proper Error handling if deleting fails :\
}
}
public ActionResult SquadDetail(string permutation)
{
var resultChecker = new ResultChecker();
var result = resultChecker.GetResults();
var squad = result.Squads.FirstOrDefault(s => s.Permutation == permutation);
return(View(squad.Positions));
}
public async Task GetMessageGroups(string userName)
{
Username = userName;
IsLoading = true;
MessageGroupCollection = new ObservableCollection <MessageGroupItem>();
try
{
await Shell.Instance.ViewModel.UpdateTokens();
var messageResult =
await
_messageManager.GetMessageGroup(userName, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, messageResult);
var result = await ResultChecker.CheckSuccess(messageResult);
if (!result)
{
return;
}
_messageGroupEntity = JsonConvert.DeserializeObject <MessageGroupResponse>(messageResult.ResultJson);
var avatarOnlineId = new Dictionary <string, string>();
var avatarOnlinelist = _messageGroupEntity.MessageGroups.Select(node => node.LatestMessage);
foreach (var member in avatarOnlinelist)
{
var avatar = await GetAvatarUrl(member.SenderOnlineId);
if (avatarOnlineId.All(node => node.Key != member.SenderOnlineId))
{
avatarOnlineId.Add(member.SenderOnlineId, avatar);
}
}
foreach (
var newMessage in
_messageGroupEntity.MessageGroups.Select(
message => new MessageGroupItem {
MessageGroup = message
}))
{
newMessage.AvatarUrl =
avatarOnlineId.FirstOrDefault(
node => node.Key == newMessage.MessageGroup.LatestMessage.SenderOnlineId).Value;
MessageGroupCollection.Add(newMessage);
}
}
catch (Exception ex)
{
//Insights.Report(ex);
}
if (MessageGroupCollection.Count <= 0)
{
MessageGroupEmpty = true;
}
IsLoading = false;
}
void CalculateWinner()
{
if (selectedRPS != RPSKind.None && selectedOppRPS != RPSKind.None)
{
isCheckWinner = true;
winner = ResultChecker.GetRPSWinner(selectedRPS, selectedOppRPS);
Debug.Log("계산완료 " + winner);
}
}
public async Task LoginUserWithPassword()
{
IsLoading = true;
await RemoveUserCookies();
var result = await _authenticationManager.AuthenticateAsync(Username, Password);
if (!result.IsSuccess)
{
await ResultChecker.SendMessageDialogAsync(result.Error, false);
IsLoading = false;
return;
}
WebManager = new WebClient(result.AuthenticationCookieContainer);
var userManager = new UserManager(WebManager);
// 0 gets us the default user.
var userResult = await userManager.GetUserFromProfilePageAsync(0);
if (userResult == null)
{
await ResultChecker.SendMessageDialogAsync("Failed to get user", false);
IsLoading = false;
return;
}
try
{
var newUser = new UserAuth {
AvatarLink = userResult.AvatarLink, IsDefaultUser = true, UserName = userResult.Username, CookiePath = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, Guid.NewGuid().ToString() + ".cookie")
};
await UserAuthDatabase.AddOrUpdateUser(newUser);
CookieManager.SaveCookie(result.AuthenticationCookieContainer, newUser.CookiePath);
}
catch (Exception ex)
{
await ResultChecker.SendMessageDialogAsync($"Failed to save user: {ex.Message}", false);
IsLoading = false;
return;
}
IsLoading = false;
IsLoggedIn = true;
App.ShellViewModel.PopulateNavItems();
NavigationService.Navigate(typeof(Views.MainPage));
}
public async Task <bool> LoadTrophies(string username)
{
Offset = Offset + MaxCount;
IsLoading = true;
await Shell.Instance.ViewModel.UpdateTokens();
var trophyManager = new TrophyManager();
var trophyResultList = await trophyManager.GetTrophyList(username, CompareUsername, Offset, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, trophyResultList);
var result = await ResultChecker.CheckSuccess(trophyResultList, false);
if (!result)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return(false);
}
var trophyList = JsonConvert.DeserializeObject <TrophyDetailResponse>(trophyResultList.ResultJson);
if (trophyList == null)
{
//HasMoreItems = false;
IsEmpty = true;
IsLoading = false;
return(false);
}
foreach (var trophy in trophyList.TrophyTitles)
{
Add(trophy);
}
if (trophyList.TrophyTitles.Any())
{
HasMoreItems = true;
MaxCount += 64;
}
else
{
if (Count <= 0)
{
IsEmpty = true;
}
HasMoreItems = false;
}
IsLoading = false;
return(true);
}
public async Task AddOrRemoveFavorite(Forum forum)
{
try
{
var result = await ForumsDatabase.UpdateForumBookmark(forum);
GetFavoriteForums();
}
catch (Exception e)
{
await ResultChecker.SendMessageDialogAsync($"Failed to add or remove favorite: {e.Message}", false);
}
}
public async Task SendSticker(StickerSelection stickerSelection)
{
string error;
try
{
var result = new Result();
if (GroupMembers.Any() && IsNewMessage)
{
result =
await
_messageManager.CreateStickerPostWithNewGroupMessage(GroupMembers.ToArray(),
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
else
{
result =
await
_messageManager.CreateStickerPost(SelectedMessageGroup.MessageGroupId,
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
SelectedMessageGroup = JsonConvert.DeserializeObject <MessageGroup>(result.ResultJson);
await GetMessages(SelectedMessageGroup);
//await GetMessageGroups(Shell.Instance.ViewModel.CurrentUser.Username);
IsNewMessage = false;
}
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
public void Setup()
{
var cache = new RedisCacheRepository(
connectionString: "localhost,abortConnect=false",
environment: "local",
functionalArea: "bts",
serializer: new JsonSerialiser(),
logger: new FakeCacheLogger(),
expire: false);
var playerStatsRepository = new CachedPlayerStatsRepository(
new PlayerStatsRepository(),
cache);
_sut = new ResultChecker(playerStatsRepository);
}
public async Task LoadAsync(bool forceRefresh = false)
{
IsLoading = true;
try
{
LoginUser();
GetFavoriteForums();
await GetMainPageForumsAsync(forceRefresh);
}
catch (Exception e)
{
await ResultChecker.SendMessageDialogAsync($"Failed to setup forum list: {e.Message}", false);
}
IsLoading = false;
}
public void ProcessUpcomingFixtures(out double expectedProfit)
{
List <MetricInterface> metrics = MetricFactory.GetMetrics(metricConfigs_, configManager_.GetYear(), configManager_, fixtureRetriever_);
List <Fixture> thisRoundFixtures = fixtureRetriever_.GetRound(configManager_.GetYear(), configManager_.GetMatchDay());
List <double> matchdayOdds = new List <double>(thisRoundFixtures.Count);
foreach (Fixture fixture in thisRoundFixtures)
{
int totalMetricsWithData = 0;
string aggregateResult = string.Empty;
foreach (MetricInterface metric in metrics)
{
ResultChecker checker = new ResultChecker(metric, fixture, configManager_);
if (checker.dataAvailable)
{
aggregateResult += checker.GetExpectedResult() + " ";
totalMetricsWithData++;
}
}
string computedResult = ComputeExpectedResult(aggregateResult, totalMetricsWithData);
if (computedResult.Length == 0)
{
totalMetricsWithData = 0;
}
else if (fixture.odds[computedResult] > configManager_.GetMaxOdds() &&
fixture.odds[computedResult] < configManager_.GetMinOdds())
{
totalMetricsWithData = 0;
}
string padding = new string(' ', 50 - fixture.homeTeamName.Length - fixture.awayTeamName.Length);
if (totalMetricsWithData == metrics.Count && computedResult != string.Empty)
{
logger_.LogInfo("{0} - {1},{2} result {3}, \t odds {4:0.00} \t aggregate {5} \t date {6} \n", fixture.homeTeamName, fixture.awayTeamName, padding, computedResult, fixture.odds[computedResult], aggregateResult, fixture.date);
matchdayOdds.Add(fixture.odds[computedResult]);
}
else
{
logger_.LogInfoFail("{0} - {1},{2} result {3}, \t odds {4:0.00} \t aggregate {5} \t date {6} \n", fixture.homeTeamName, fixture.awayTeamName, padding, computedResult, fixture.odds[computedResult], aggregateResult, fixture.date);
}
}
expectedProfit = GetMatchdayProfit(matchdayOdds);
logger_.LogInfo("Profit: {0}", expectedProfit);
}
public async Task <string> CreateFriendLink()
{
var result = await _friendManager.GetFriendLink(Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (!resultCheck)
{
return(string.Empty);
}
var tokenEntity = JsonConvert.DeserializeObject <TokenResponse>(result.ResultJson);
return(tokenEntity.Token);
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
var error = string.Empty;
try
{
await BuildList();
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
public void ChangeAnimationAction(ActionKind action)
{
//서버 클라이언트에서의 판정만 할 수 있으므로 Winner.serverPlayer면 자신의 승리로 다룹니다.
Winner rpsWinner = ResultChecker.GetRPSWinner(m_rps, m_opponentRps);
switch (rpsWinner)
{
case Winner.ServerPlayer: //가위바위보는 자신의 승리.
if (action == ActionKind.Attack)
{
ChangeAnimationAttack();
}
else if (action == ActionKind.Block)
{
ChangeAnimation(Motion.Defence);
}
break;
case Winner.ClientPlayer: //가위바위보는 자신의 패배.
if (action == ActionKind.Attack)
{
ChangeAnimationMiss();
}
else if (action == ActionKind.Block)
{
ChangeAnimation(Motion.Defence);
}
break;
case Winner.Draw: //가위바위보는 무승부.
if (action == ActionKind.Attack)
{
ChangeAnimationMiss();
}
else if (action == ActionKind.Block)
{
ChangeAnimation(Motion.Defence);
}
break;
}
//Debug.Log(m_currentMotion.ToString() + m_anim[m_currentMotion.ToString()].length);
//Debug.Log(m_anim[m_currentMotion.ToString()].speed);
//Debug.Log(m_anim[m_currentMotion.ToString()].normalizedTime);
m_anim[m_currentMotion.ToString()].speed = 0.1f; //느리게 재생.
}
