public static string GetName(RankType type)
{
switch (type)
{
case RankType.Bronze:
return("青铜");
case RankType.Silver:
return("白银");
case RankType.Gold:
return("黄金");
case RankType.Platinum:
return("白金");
case RankType.Diamond:
return("钻石");
case RankType.Master:
return("大师");
case RankType.Challenger:
return("王者");
case RankType.Crown:
return("VIP");
default:
return("ERROR");
}
}
private Boolean CheckIsStraight()
{
var getStraight = from cards in this.CardsOnHand
group cards by cards.Rank into cards
orderby Convert.ChangeType(cards.Key, cards.Key.GetTypeCode())
select new { Rank = cards.Key, Count = cards.Count() };
var ordered = getStraight.OrderBy(r => r.Rank).ToArray();
var straightStart = (int)ordered.First().Rank;
for (var i = 0; i < ordered.Length; i++)
{
if ((int)ordered[i].Rank != straightStart + i)
{
this.IsStraight = false;
return(false);
}
}
var _rank = getStraight.DefaultIfEmpty().First().Rank;
this.DominantRank = (RankType)_rank;
this.IsStraight = true;
return(true);
}
public static Tuple <int, int> GetRankRange(RankType rankType)
{
switch (rankType)
{
case RankType.Bronze:
return(new Tuple <int, int>(0, S_SILVER - 1));
case RankType.Silver:
return(new Tuple <int, int>(S_SILVER, S_GOLD - 1));
case RankType.Gold:
return(new Tuple <int, int>(S_GOLD, S_PLATINUM - 1));
case RankType.Platinum:
return(new Tuple <int, int>(S_PLATINUM, S_DIAMOND - 1));
case RankType.Diamond:
return(new Tuple <int, int>(S_DIAMOND, S_MASTER - 1));
case RankType.Master:
return(new Tuple <int, int>(S_MASTER, S_CHALLENGER - 1));
case RankType.Challenger:
return(new Tuple <int, int>(S_CHALLENGER, 10000));
default:
return(new Tuple <int, int>(0, 0));
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
GUILayout.Space(15);
serializedObject.Update();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Initialize"))
{
RankType rank = (RankType)serializedObject.FindProperty("rankType").enumValueIndex;
SuitType suit = (SuitType)serializedObject.FindProperty("suitType").enumValueIndex;
Undo.RecordObject(peakCard, "Initialize");
peakCard.Initialize(suit, rank);
EditorUtility.SetDirty(peakCard);
}
if (GUILayout.Button("Set Color"))
{
Color tint = serializedObject.FindProperty("tint").colorValue;
Undo.RecordObject(peakCard, "Set Color");
peakCard.SetColor(tint);
EditorUtility.SetDirty(peakCard);
}
if (GUILayout.Button("Evaluate Atlas"))
{
string atlas = serializedObject.FindProperty("textureAtlas").stringValue;
Undo.RecordObject(peakCard, "Evaluate Atlas");
peakCard.EvaluateAtlas(atlas);
EditorUtility.SetDirty(peakCard);
}
EditorGUILayout.EndHorizontal();
serializedObject.ApplyModifiedProperties();
}
private void RankRequestFeedBack(byte[] data)
{
RankS2C feedback = ProtobufUtils.Deserialize <RankS2C>(data);
if (feedback.result)
{
CurrentType = feedback.rankType;
pageId = feedback.pageId;
isFriendRank = feedback.isFriendRank;
for (int i = 0; i < feedback.members.Count; i++)
{
members.Add(feedback.members[i]);
}
myRankInfo = feedback.selfInfo;
if (feedback.members.Count < 10)
{
view.isCanRequest = false;
}
else
{
view.isCanRequest = true;
}
//if ( feedback.members.Count > 0 )
{
view.ReFreshUI();
}
}
}
public RankDataKey(RankType type, DateTime fromDate, DateTime toDate, List <int> minValueList)
{
this.rankType = type;
this.StartDate = fromDate.ToString("yyyy-MM-dd HH:mm:ss");
this.EndDate = toDate.ToString("yyyy-MM-dd HH:mm:ss");
this.minGateValueList = minValueList;
}
private Boolean IsThreeOfAKind(ref PokerPlayerEvaluator player)
{
Boolean result;
List <PlayingCard> listOfPlayingCards = player.CardsOnHand;
var queryFindThreeOfAKind = from cardsOnHand in listOfPlayingCards
group cardsOnHand by cardsOnHand.Rank into cards
where cards.Count() == 3
orderby Convert.ChangeType(cards.Key, cards.Key.GetTypeCode())
select new { last = cards.Key, count = cards.Count() };
if (queryFindThreeOfAKind.Count() >= 1)
{
var _rank = queryFindThreeOfAKind.DefaultIfEmpty().First().last;
RankType d = (RankType)_rank;
player.IsThreeOfAKind = true;
result = true;
}
else
{
result = false;
}
return(result);
}
public static Ranking <UserRank> GetRankType(RankType rankType)
{
Ranking <UserRank> rankList;
if (rankType == RankType.UserLv)
{
rankList = RankingFactory.Get <UserRank>(UserLvRanking.RankingKey);
}
else if (rankType == RankType.Obtion)
{
rankList = RankingFactory.Get <UserRank>(ObtainRanking.RankingKey);
}
else if (rankType == RankType.GameCoin)
{
rankList = RankingFactory.Get <UserRank>(GameCoinRanking.RankingKey);
}
else if (rankType == RankType.ZhanLi)
{
rankList = RankingFactory.Get <UserRank>(CombatNumRanking.RankingKey);
}
else
{
throw new ArgumentNullException("rankType", string.Format("rankType:{0}", rankType));
}
return(rankList);
}
public void AddClearTrigger(RankManager _this, RankType rankType)
{
switch (rankType)
{
case RankType.DailyGift:
{
var triggerTime = DateTime.Today.AddDays(1);
const int autoInterval = 24 * 60 * 60 * 1000; // 天
_this.rank[(int)rankType].CreateClearTrigger(triggerTime, autoInterval);
}
break;
case RankType.WeeklyGift:
{
var dayOfWeek = Convert.ToInt32(DateTime.Now.DayOfWeek.ToString("d"));
if (dayOfWeek == 0) // 周日
{
dayOfWeek = 7;
}
var startWeek = DateTime.Today.AddDays(1 - dayOfWeek);
var triggerTime = startWeek.AddDays(7);
const int autoInterval = 7 * 24 * 60 * 60 * 1000; // 周
_this.rank[(int)rankType].CreateClearTrigger(triggerTime, autoInterval);
}
break;
}
}
void OnCheckRankLeftBtns(GameObject go)//点击排行榜左侧切换按钮
{
PlayBtnMusic();
int checkTag = 0;
for (int i = 0; i < m_RankLeftBtns.Length; ++i)
{
if (m_RankLeftBtns[i].m_BtnObj == go)
{
checkTag = m_RankLeftBtns[i].m_Tag + 1;
m_RankLeftBtns[i].m_IsChecked = true;
}
else
{
m_RankLeftBtns[i].m_IsChecked = false;
}
}
if ((int)m_RankType == checkTag)
{
return;
}
m_RankType = (RankType)checkTag;
UpdateRankContent();
UpdateMyRankContent();
ExChangeRankLeftBtnsBg();
}
public static Ranking<UserRank> GetRankType(RankType rankType)
{
Ranking<UserRank> rankList;
if (rankType == RankType.UserLv)
{
rankList = RankingFactory.Get<UserRank>(UserLvRanking.RankingKey);
}
else if (rankType == RankType.Obtion)
{
rankList = RankingFactory.Get<UserRank>(ObtainRanking.RankingKey);
}
else if (rankType == RankType.GameCoin)
{
rankList = RankingFactory.Get<UserRank>(GameCoinRanking.RankingKey);
}
else if (rankType == RankType.ZhanLi)
{
rankList = RankingFactory.Get<UserRank>(CombatNumRanking.RankingKey);
}
else
{
throw new ArgumentNullException("rankType", string.Format("rankType:{0}", rankType));
}
return rankList;
}
public AllieData(string allieID, Species species, RankType rankType, int currentLevel)
{
this.allieID = allieID;
this.species = species;
this.rankType = rankType;
this.currentLevel = currentLevel;
}
public void Init()
{
if (rank == 1)
{
rankType = RankType.Ace;
}
else
{
rankType = (RankType)rank;
}
switch (suit)
{
case "S":
suitType = SuitType.Spades;
break;
case "D":
suitType = SuitType.Diamonds;
break;
case "C":
suitType = SuitType.Clubs;
break;
case "H":
suitType = SuitType.Hearts;
break;
default:
break;
}
}
private static Card GetRandomCard()
{
RankType rank = (RankType)cardRanks.GetValue(random.Next(cardRanks.Length));
SuitType suit = (SuitType)cardSuits.GetValue(random.Next(cardSuits.Length));
return(new Card(rank, suit));;
}
public void UpdateInfo()
{
if (info == null)
{
return;
}
rankType = controler.GetCurrentRankType();
if (rankType == RankType.GradeRank)
{
gradingRoot.gameObject.SetActive(true);
countText.gameObject.SetActive(false);
if (info.score > 0)
{
emberMedalNone.gameObject.SetActive(false);
emberMedal.gameObject.SetActive(true);
emberMedalCountText.text = "x" + info.score.ToString();
}
else
{
emberMedalNone.gameObject.SetActive(true);
emberMedal.gameObject.SetActive(false);
}
}
else
{
gradingRoot.gameObject.SetActive(false);
countText.gameObject.SetActive(true);
}
if (info.rank <= 3)
{
rankIconImage.gameObject.SetActive(true);
rankText.gameObject.SetActive(false);
SetRankIconImage(info.rank);
}
else
{
rankIconImage.gameObject.SetActive(false);
rankText.gameObject.SetActive(true);
}
rankText.text = info.rank.ToString();
RefreshPlayerHeadIcon(info.portrait);
playerLvText.text = info.level.ToString();
playerNameText.text = info.playerName;
unionNameText.text = info.unionName;
countText.text = info.score.ToString();
if (info.isFriend)
{
addFriendBtn.gameObject.SetActive(false);
}
else
{
addFriendBtn.gameObject.SetActive(true);
}
gradingText.text = info.grading.ToString();
}
/// <summary>
/// Verify if contains Pair and assign value to Poker Hand
/// </summary>
/// <returns></returns>
private Boolean CheckIsPair()
{
//Sort first by Suit to consider in ranking
var cardsSortedBySuit = this.CardsOnHand.AsEnumerable().OrderBy(s => s.Suit);
var getPair = from cards in cardsSortedBySuit
group cards by cards.Rank into cards
where cards.Count() == 2
orderby Convert.ChangeType(cards.Key, cards.Key.GetTypeCode())
select new { Rank = cards.Key, Count = cards.Count() };
if (getPair.Count() >= 1)
{
var _rank = getPair.DefaultIfEmpty().First().Rank;
this.IsPair = true;
this.DominantRank = (RankType)_rank;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Returns the required result. Nondestructive.
/// </summary>
public int result(RankType type = RankType.MEDIAN)
{
switch (type)
{
case RankType.MIN:
return(cMin);
case RankType.MAX:
return(cMax);
case RankType.MIDDLE:
return((cMin + cMax + 1) >> 1);
default:
{
// I'm going to compute median..
int steps = card >> 1; // .. which is the (steps+1)-th least value ..
int median = cMin;
while (true)
{
steps -= h[median];
if (steps < 0)
{
break;
}
median++;
}
return(median);
}
}
}
private void OnUpdateUI()
{
if (Data is PersonalLevelRankItemData)
{
RankType = RankType.PersonalLevel;
}
else if (Data is AllianceLevelRankItemData)
{
RankType = RankType.AllianceLevel;
DealAlliance();
}
else if (Data is PersonalLadderRankItemData)
{
RankType = RankType.PersonalLadder;
}
else if (Data is PersonalArenaRankItemData)
{
RankType = RankType.PersonalArena;
}
else if (Data is InfiniteChallengeRankItemData)
{
RankType = RankType.PersonalInfinite;
}
else if (Data is PersonalChallengeInstanceRankItemData)
{
RankType = RankType.PersonalInstance;
}
}
public int GetValueCard(RankType rankType, int currentPoints)
{
var result = rankType.GetDescription();
var aceRank = RankType.Ace.GetDescription();
result = result == aceRank & currentPoints > 10 ? 1 : result;
return(result);
}
public void AndInputIsValidThenCorrectRankAndSuitAreAssigned(
string value, RankType expectedRank, SuitType expectedSuit)
{
var card = CardFactory.CreateCard(value);
Assert.AreEqual(expectedRank, card.Rank);
Assert.AreEqual(expectedSuit, card.Suit);
}
public static List <Rank_Char> GetRankChar(RankType type)
{
if (cache_c_rank == null || DateTime.Now.Subtract(cache_c_rank_date).TotalSeconds > CACHE_UPDATE)
{
GameCache.ReCache(true, false, false);
}
return(cache_c_rank[type]);
}
private void assertHandRank(string hand, RankType rankType, Value highestCardInRank)
{
var cards = Card.ParseHand(hand);
Rank expectedRank = new Rank(rankType, highestCardInRank);
Rank actualRank = Rank.ComputeBestRank(cards);
Assert.AreEqual(expectedRank, actualRank);
}
public ColorPalette GetRankColor(RankType type)
{
if (rankColors.TryGetValue(type, out ColorPalette value))
{
return(value);
}
Logger.LogWarning($"ColorPreset.GetRankColor - Unknown type: {type}");
return(new ColorPalette(Color.white));
}
private async Task SetUsersPointsAsync(Game game, UsersPoints usersPoints, RankType rank)
{
usersPoints.Points += (int)rank;
if (usersPoints.Points > Constants.GameSettings.WinningNumber)
{
game.State = UserGameStateType.Lose;
}
await _usersPointsRepository.UpdateAsync(usersPoints);
}
/// <summary> 랭킹 서버 연결 </summary>
public static void RankServerConnect(RankType rankType, RankServerConnectType serverConnectType, Action <bool> result)
{
if (rankServerCoroutine != null)
{
return;
}
rankServerCoroutine = Instance.StartCoroutine(Instance.RankServerConnectCoroutine(rankType, serverConnectType, result));
}
public void OnUserDoSomething(int roleID, RankType rankType, int value)
{
DBManager dbMgr = DBManager.getInstance();
if (null != dbMgr)
{
DBRoleInfo roleInfo = dbMgr.GetDBRoleInfo(ref roleID);
if (null != roleInfo)
{
double currSecond = Global.GetOffsetSecond(DateTime.Now);
roleInfo.RankValue.AddUserRankValue(rankType, value);
lock (this.RankDataDictLock)
{
foreach (KeyValuePair <string, RankData> item in this.RankDataDict)
{
RankDataKey rankDataKey = RankDataKey.GetKeyFromStr(item.Key);
if (null != rankDataKey)
{
if (rankType == rankDataKey.rankType)
{
double startTime = Global.GetOffsetSecond(DateTime.Parse(rankDataKey.StartDate));
double endTime = Global.GetOffsetSecond(DateTime.Parse(rankDataKey.EndDate));
if (currSecond >= startTime && currSecond <= endTime)
{
bool bExist = false;
foreach (InputKingPaiHangData rankData in item.Value.RankDataList)
{
if ((RankType.Charge == rankType && rankData.UserID == roleInfo.UserID) || (RankType.Consume == rankType && rankData.UserID == roleInfo.RoleID.ToString()))
{
rankData.PaiHangTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
rankData.PaiHangValue += value;
bExist = true;
break;
}
}
if (!bExist)
{
int userRankValue = roleInfo.RankValue.GetRankValue(rankDataKey);
InputKingPaiHangData phData = new InputKingPaiHangData
{
UserID = ((RankType.Charge == rankType) ? roleInfo.UserID : roleInfo.RoleID.ToString()),
PaiHang = 0,
PaiHangTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
PaiHangValue = userRankValue
};
item.Value.RankDataList.Add(phData);
}
this.BuildRank(item.Value);
}
}
}
}
}
}
}
}
public void Test_IsConnected_HandNotConnected_IsFalse(SuitType leftCardSuit, RankType leftCardRank, SuitType rightCardSuit, RankType rightCardRank)
{
Card leftCard = new Card(leftCardSuit, leftCardRank);
Card rightCard = new Card(rightCardSuit, rightCardRank);
Hand hand = new Hand(leftCard, rightCard);
bool expected = hand.IsConnected();
Assert.AreEqual(expected, false);
}
public void Test_IsPaired_HandPaired_IsTrue(SuitType leftCardSuit, RankType leftCardRank, SuitType rightCardSuit, RankType rightCardRank)
{
Card leftCard = new Card(leftCardSuit, leftCardRank);
Card rightCard = new Card(rightCardSuit, rightCardRank);
Hand hand = new Hand(leftCard, rightCard);
bool expected = hand.IsPaired();
Assert.AreEqual(expected, true);
}
public override void Close(bool isOpenLast = true)
{
base.Close(false);
curType = RankType.Riches;
for (int i = 0; i < itemList.Count; i++)
{
itemList[i].DestroyItem();
}
itemList.Clear();
}
public RankInfo(BoardInfo boardInfo, RankType type)
{
// Check if player has played any games for this queue
if (boardInfo.MaxMMR == 0 &&
boardInfo.Kills == 0 &&
boardInfo.Deaths == 0 &&
boardInfo.Wins == 0 &&
boardInfo.Losses == 0 &&
boardInfo.Abandons == 0 &&
boardInfo.Rank == 0 &&
boardInfo.MaxRank == 0)
{
// Unranked
var result = _ranks[0];
Name = result.Item1;
URL = result.Item4;
return;
}
if (type == RankType.RankIndex)
{
var rank = boardInfo.Rank;
// Get rank by index
if (rank < 0 || rank > _ranks.Length - 1)
{
throw new ArgumentOutOfRangeException("Rank index does not exist in the given range.");
}
else
{
var result = _ranks[rank];
Name = result.Item1;
URL = result.Item4;
}
}
else if (type == RankType.RankMMR)
{
var rank = boardInfo.MMR;
// Parse rank by MMR
if (rank < 0)
{
// MMR cannot be negative
throw new ArgumentOutOfRangeException("Rank MMR cannot be negative.");
}
else
{
// Get rank tuple where MMR is in range
var result = _ranks.Where(r => rank >= r.Item2 &&
rank <= r.Item3)
.First();
Name = result.Item1;
URL = result.Item4;
}
}
}
public Player(int number, IEnumerable <Card> cards)
{
if (cards.Count() != Rules.CardsPerHand)
{
throw new InvalidOperationException("Only three cards are allowed per player.");
}
PlayerNumber = number;
Cards = cards;
HandType = HandTypeCalculator.GetHandTypeFromCards(cards);
HighestRank = HandTypeCalculator.GetHighestRankFromCards(cards);
}
public void SetRank(RankType rankValue)
{
if (rankValue <= RankType.Ace && rankValue >= RankType.AceLow)
{
Rank = rankValue;
}
else
{
throw new ArgumentException("Invalid card.");
}
}
public async Task<UserInfo[]> LoadRankingsAsync(string userId, RankType type, int count, string accessToken, bool waitRequests = true)
{
using (await WaitRequestAvailability(waitRequests))
{
var rankData = (ArrayList)await Call("loadRankings", new
{
id = userId,
type = type.ToString().ToLower(),
count = count,
access_token = accessToken
});
return (from Hashtable userData in rankData
select new UserInfo
{
Id = (string)userData["id"],
Name = (string)userData["name"],
HighScore = int.Parse(userData["highscore"].ToString()),
TotalZombies = int.Parse(userData["totalzombies"].ToString()),
MapName = (string)userData["mapname"]
}).ToArray();
}
}
public static GamblerDW GetTopGamblerMonthly(DateTime today, RankType rankType)
{
string sql;
var monthStart = today.AddDays(1 - today.Day);
var monthEnd = monthStart.AddMonths(1);
if (rankType == RankType.Winner || rankType == RankType.Loser)
{
var strOrder = rankType.Equals(RankType.Winner) ? "DESC" : string.Empty;
sql = $@"SELECT TOP 1 UserID, UserName, SUM(ISNULL(Earning, 0)) AS Earning, SUM(ISNULL(Bet, 0)) AS TotalBet, SUM(ISNULL(Earning, 0) - ISNULL(Bet, 0)) AS Profit
FROM {Repository.GetTableAttr<Bet>().Name} WHERE (Earning IS NOT NULL) AND (Bet IS NOT NULL) AND (BetTime >= @monthStart) AND (BetTime < @monthEnd)
GROUP BY UserID, UserName ORDER BY Profit {strOrder}, TotalBet DESC";
}
else if (rankType == RankType.RP)
{
sql = $@"SELECT TOP 1 UserID, UserName, COUNT(EarningDesc) AS RPBonus, SUM(ISNULL(Earning, 0)) AS Earning, SUM(ISNULL(Bet, 0)) AS TotalBet
FROM {Repository.GetTableAttr<Bet>().Name} WHERE (Earning = 0) AND (EarningDesc = 'RP+1') AND (IsWin = 1) AND (BetTime >= @monthStart) AND (BetTime < @monthEnd)
GROUP BY UserID, UserName ORDER BY RPBonus DESC";
}
else
{
return null;
}
SqlParameter[] para = { new SqlParameter("@monthStart", monthStart), new SqlParameter("@monthEnd", monthEnd) };
var ds = DataAccess.ExecuteDataset(sql, para);
var dt = ds.Tables[0];
if (dt.Rows.Count > 0)
{
using (var reader = dt.CreateDataReader())
{
Mapper.Initialize(cfg =>
{
MapperRegistry.Mappers.Insert(0,
new DataReaderMapper.DataReaderMapper { YieldReturnEnabled = false });
CreateMap();
});
return Mapper.Map<IDataReader, IEnumerable<GamblerDW>>(reader).FirstOrDefault();
}
}
return null;
}
