public void LoadParty(RaidParty heroParty, PhotonPlayer player)
{
Party.CreateFormation(heroParty, player);
Ranks.DistributeParty(Party);
Overlay.LockOnUnits(Party);
Overlay.UpdateOverlay();
foreach (var unit in Party.Units)
{
unit.OverlaySlot.HeroSelected += UpdateHero;
unit.Formation = this;
}
Party.Units.Sort((x, y) => { if (x.Rank == y.Rank)
{
return(0);
}
if (x.Rank > y.Rank)
{
return(1);
}
else
{
return(-1);
} });
}
static void testEnum()
{
Ranks particularRank = Ranks.Constable;
Move direction = Move.Up;
switch (direction)
{
case Move.Up:
Console.WriteLine(direction);
break;
default:
Console.WriteLine("Not " + direction.ToString());
break;
}
int directionInt = (int)Move.Up;
string[] longNames =
{
"Moving Up", "Moving Down"
};
Console.WriteLine(longNames[(int)Move.Up]);
}
public ActionResult Ranking(string mobile)
{
if (mobile != null)
{
DataTable dtContact = new DataTable();
UserDetails objUserDetails = new UserDetails();
Ranks objRanks = new Ranks();
// ViewBag.MySuggesstion = GetMySuggesstion();
dtContact = objUserDetails.GetRanking();
IList <Ranks> items = dtContact.AsEnumerable().Select(row =>
new Ranks
{
Point = row.Field <int>("Points"),
ContactName = row.Field <string>("ContactName"),
Rank = row.Field <Int64>("Rank")
}).ToList();
Session["Feedback"] = "Yes";
Session["Other"] = "Yes";
return(View(items));
}
else
{
return(RedirectToAction("Login", "Index"));
}
}
public StudentsPage()
{
InitializeComponent();
monthsPicker.ItemsSource = Lists.MonthsList();
monthsPicker.SelectedIndex = 8;
activePicker.ItemsSource = Lists.TrueFalse();
activePicker.SelectedIndex = 0;
studentPicker.ItemsSource = Lists.ActiveStudents();
studentPicker.SelectedIndex = 6;
genderPicker.ItemsSource = Lists.GenderList();
genderPicker.SelectedIndex = 0;
statePicker.ItemsSource = Lists.StateAbbList();
statePicker.SelectedIndex = 46;
rankPicker.ItemsSource = Ranks.RanksList();
rankPicker.SelectedIndex = 12;
var listOfRankReq = Lists.RankReq("Sandan - Black III");
RankReqListView.ItemsSource = listOfRankReq;
RankReqListView.HeightRequest = (listOfRankReq.Count * 40);
}
private void Start()
{
textHandler = GetComponent <TextHandler>();
ranks = GetComponent <Ranks>();
answersPlayerOne = new List <AnswerDATA>();
answersPlayerTwo = new List <AnswerDATA>();
}
/// <summary>
/// Compares two ranks
/// </summary>
/// <param name="rank">Rank standard</param>
/// <param name="relativeRank">Rank to compare</param>
/// <returns>Difference between ranks</returns>
public int GetRankDiff(Ranks rank, Ranks relativeRank)
{
int rankValue = (int)rank;
int relativeRankValue = (int)relativeRank;
return(relativeRankValue - rankValue); //returns negative value if relativeRank is below the rank in question
}
/// <summary>
/// Compares two ranks strings if are equal
/// </summary>
/// <param name="rank">First Rank</param>
/// <param name="rank2">Second Rank</param>
/// <returns>boolean result of equals comparision</returns>
public bool Equals(string rank, string rank2)
{
Ranks parsedRank = GetRankType(rank);
Ranks parsedRank2 = GetRankType(rank2);
return(parsedRank.Equals(parsedRank2));
}
private void RankApplicant(string name, bool knowsHTML, bool knowsSQL,
bool knowsJS, double yearsOfExperience, uint course)
{
List <Ranks> ranks = new List <Ranks>();
foreach (Ranks rank in criteriaMap.Keys)
{
if (criteriaMap[rank].CheckCriterion(knowsHTML, knowsSQL,
knowsJS, yearsOfExperience, course))
{
ranks.Add(rank);
}
}
Applicant applicant = new Applicant(name, knowsHTML, knowsSQL,
knowsJS, yearsOfExperience, course);
if (ranks.Count > 0)
{
Ranks max_rank =
(Ranks)ranks.Select(item => (int)item).Max();
string report = criteriaMap[max_rank].GenerateReport(
knowsHTML, knowsSQL, knowsJS, yearsOfExperience, course);
rankedApplicants[max_rank].Add(Tuple.Create(report, applicant));
}
else
{
Ranks min_rank = (Ranks)0;
string report = criteriaMap[min_rank].GenerateReport(
knowsHTML, knowsSQL, knowsJS, yearsOfExperience, course);
unrankedApplicants.Add(Tuple.Create(report, applicant));
}
}
/// <summary>
/// Parses rank string into Ranks Enum instance
/// </summary>
/// <param name="strRank">Rank String</param>
/// <returns>Rank value from Ranks enum</returns>
public Ranks GetRankType(String strRank)
{
Ranks rank = Ranks.NORANK;
if (strRank == null || strRank.Equals(string.Empty))
{
return(rank);
}
string upperStrRank = strRank.ToUpper();
if (Regex.Match(upperStrRank, @"^2.*").Success)
{
rank = Ranks.TWOLT;
}
else if (Regex.Match(upperStrRank, @"^1.*").Success)
{
rank = Ranks.ONELT;
}
else if (Regex.Match(upperStrRank, @"^LT.*").Success&& !(Regex.Match(upperStrRank, @".*[Gg]EN.*").Success))
{
rank = Ranks.LTCOL;
}
else if (Regex.Match(upperStrRank, @"^GS.*").Success || (Regex.Match(upperStrRank, @"^\d+$").Success))
{
rank = Ranks.GS;
}
else
{
Enum.TryParse <Ranks>(upperStrRank, out rank);
}
return(rank);
}
public static void DrawPlayerName(RendererDestinationData destData, Map activeMap, Enums.MapID targetMapID, IPlayer player)
{
Color playerColor = Color.DarkRed;
//if (player.PK) {
// playerColor = Color.DarkRed;
//} else {
playerColor = Ranks.GetRankColor(player.Access);
//}
string name = player.Name;
if (!string.IsNullOrEmpty(player.Status))
{
string status = player.Status;
if (Globals.FoolsMode)
{
status = "Itemized";
}
name += " [" + status + "]";
}
SpriteRenderer.DrawSpriteName(destData, activeMap, targetMapID, player, playerColor, name);
}
public int AddRank(Ranks rank)
{
db.Ranks.Add(rank);
int result = db.SaveChanges();
return(result);
}
static void RebuildIndex()
{
if (Ranks.Count == 0)
{
LowestRank = null;
HighestRank = null;
DefaultRank = null;
return;
}
// find highest/lowers ranks
HighestRank = Ranks.First();
LowestRank = Ranks.Last();
// assign indices
for (int i = 0; i < Ranks.Count; i++)
{
Ranks[i].Index = i;
}
// assign nextRankUp/nextRankDown
if (Ranks.Count > 1)
{
for (int i = 0; i < Ranks.Count - 1; i++)
{
Ranks[i + 1].NextRankUp = Ranks[i];
Ranks[i].NextRankDown = Ranks[i + 1];
}
}
HighestRank.NextRankUp = null;
LowestRank.NextRankDown = null;
}
/// <summary> Removes the specified rank from the list of available ranks </summary>
/// <param name="deletedRank"> Rank to be deleted. </param>
/// <param name="replacementRank"> Rank that will replace the deleted rank. </param>
/// <returns> Whether or not the rank was succesfully deleted/replaced. </returns>
/// <exception cref="ArgumentNullException"> If deletedRank or replacementRank is null. </exception>
/// <exception cref="InvalidOperationException"> If PlayerDB is already loaded. </exception>
public static bool DeleteRank([NotNull] Rank deletedRank, [NotNull] Rank replacementRank)
{
if (deletedRank == null)
{
throw new ArgumentNullException("deletedRank");
}
if (replacementRank == null)
{
throw new ArgumentNullException("replacementRank");
}
if (PlayerDB.IsLoaded)
{
throw new InvalidOperationException("You may not modify ranks after PlayerDB has been loaded.");
}
bool rankLimitsChanged = false;
Ranks.Remove(deletedRank);
RanksByName.Remove(deletedRank.Name.ToLower());
RanksByID.Remove(deletedRank.ID);
RanksByFullName.Remove(deletedRank.FullName);
LegacyRankMapping.Add(deletedRank.ID, replacementRank.ID);
foreach (Rank rank in Ranks)
{
for (int i = 0; i < rank.PermissionLimits.Length; i++)
{
if (rank.GetLimit((Permission)i) == deletedRank)
{
rank.ResetLimit((Permission)i);
rankLimitsChanged = true;
}
}
}
RebuildIndex();
return(rankLimitsChanged);
}
/// <summary>
/// Removes a rank for the specified character.
/// </summary>
/// <param name="name">The character to remove rank from.</param>
public void RemoveRank(long name)
{
lock (this.Ranks)
{
Ranks.Remove(name);
}
}
public DemonSlayerBuilder WithRank(Ranks rank)
{
_builderActions.Add(new OrderedAction <DemonSlayer>(slayer =>
slayer.Rank = rank, GetOrderFromEnum(ExecutionOrder.WithRank)));
return(this);
}
public async Task LocalCredits(IUser UserTag)
{
ulong id = UserTag.Id;
var tmp = await Ranks.GetLocalDosh(Context.Guild, id);
await ReplyAsync("", false, Embed.GetEmbed("Local Rank", $"You rank {tmp}"));
}
public Rank NewRank(string Name)
{
Rank NewRank;
try
{
NewRank = new Rank();
NewRank.Name = Name;
NewRank.DisplayedName = Name;
if (NewRank.Name.ToUpperInvariant() == "NULL")
{
if (NoRank == null)
{
return(NewRank);
}
else
{
return(NoRank);
}
}
Ranks.Insert(0, NewRank);
//RankDB.List.Add(NewRank);
Logger.Log.SystemMessage("Created Rank: " + NewRank.Name);
return(NewRank);
}
catch (Exception e)
{
Logger.Log.Bug(e, "Error Creating new rank.");
return(NoRank);
}
}
private static int RankRating(Ranks rank)
{
switch (rank)
{
case Ranks.ace:
return(1);
case Ranks.ten:
return(2);
case Ranks.king:
return(3);
case Ranks.queen:
return(4);
case Ranks.jack:
return(5);
case Ranks.nine:
return(6);
default:
return(7);
}
}
public async Task GlobalCredits(IUser UserTag)
{
ulong id = UserTag.Id;
var tmp = await Ranks.GetGlobalDosh(id);
await ReplyAsync("", false, Embed.GetEmbed("Global Rank", $"You rank {tmp}"));
}
public void GetValue_ShouldReturnCorrectResult_ForTwoCards(Ranks rank1, Ranks rank2, int expectedValue, Hand hand, Suits suit)
{
hand.AddCard(rank1.Of(suit));
hand.AddCard(rank2.Of(suit));
Assert.Equal(expectedValue, hand.GetValue());
}
public void SuitRankCollection_Clones()
{
var target1 = new SuitRankCollectionInt();
for (Suits s = Suits.Clubs; s <= Suits.Spades; s++)
{
for (Ranks r = Ranks.Two; r <= Ranks.Ace; r++)
{
target1[s, r] = 13 * (int)s + (int)r;
}
}
var target2 = target1.Clone();
for (Suits s = Suits.Clubs; s <= Suits.Spades; s++)
{
for (Ranks r = Ranks.Two; r <= Ranks.Ace; r++)
{
Assert.AreEqual <int>(target1[s, r], target2[s, r]);
}
}
target1[Suits.Hearts, Ranks.Jack] = 1;
Assert.AreEqual <int>(1, target1[Suits.Hearts, Ranks.Jack]);
Assert.AreEqual <int>(35, target2[Suits.Hearts, Ranks.Jack]);
}
public HandOf7Summary(HandOf7 handOf7)
{
Ranks = handOf7.Cards.Select(c => c.Rank).ToList();
Ranks.Sort();
var dict = new Dictionary <SuitEnum, int>();
foreach (var card in handOf7.Cards)
{
if (!dict.ContainsKey(card.Suit))
{
dict.Add(card.Suit, 0);
}
dict[card.Suit]++;
}
foreach (var entry in dict)
{
if (entry.Value >= 5)
{
SameColorRanks = handOf7.Cards.Where(c => c.Suit == entry.Key).Select(c => c.Rank).ToList();
SameColorRanks.Sort();
}
}
}
public UserProfile ToUserProfile()
{
return(new UserProfile()
{
Name = Name,
Awards =
AccountBattleAwards.GroupBy(x => x.AwardKey).Select(x => new UserProfile.UserAward()
{
AwardKey = x.Key, Collected = x.Count()
})
.ToList(),
Badges = GetBadges().Select(x => x.ToString()).ToList(),
EffectiveElo = (int)Math.Round(GetRating(RatingCategory.Casual).LadderElo),
EffectivePwElo = (int)Math.Round(GetRating(RatingCategory.Planetwars).LadderElo),
EffectiveMmElo = (int)Math.Round(GetRating(RatingCategory.MatchMaking).LadderElo),
Kudos = KudosGained,
Level = Level,
LevelUpRatio = GetLevelUpRatio().ToString("F2"),
Rank = Rank,
RankUpRatio = Ranks.GetRankProgress(this).ToString("F2"),
PwBombers = GetBombersAvailable().ToString("F2"),
PwDropships = GetDropshipsAvailable().ToString("F2"),
PwMetal = GetMetalAvailable().ToString("F2"),
PwWarpcores = GetWarpAvailable().ToString("F2"),
});
}
/// <summary> Adds a new rank to the list. Checks for duplicates. </summary>
public static void AddRank([NotNull] Rank rank)
{
if (rank == null)
{
throw new ArgumentNullException("rank");
}
if (PlayerDB.IsLoaded)
{
throw new InvalidOperationException("You may not add ranks after PlayerDB has already been loaded.");
}
// check for duplicate rank names
if (RanksByName.ContainsKey(rank.Name.ToLower()))
{
throw new RankDefinitionException(rank.Name,
"Duplicate definition for rank \"{0}\" (by Name) was ignored.",
rank.Name);
}
if (RanksByID.ContainsKey(rank.ID))
{
throw new RankDefinitionException(rank.Name,
"Duplicate definition for rank \"{0}\" (by ID) was ignored.",
rank.Name);
}
Ranks.Add(rank);
RanksByName[rank.Name.ToLower()] = rank;
RanksByFullName[rank.FullName] = rank;
RanksByID[rank.ID] = rank;
RebuildIndex();
}
private static string GetDetails(Ranks rank, IEnumerable <Card> cards)
{
return("Rank: "
+ rank.GetDescription()
+ "\nCards:"
+ cards.Aggregate(string.Empty, (current, card) => current + ("\n\t- " + card.Suit.GetDescription() + " of " + card.Description)));
}
public void UpdateVars()
{
int noOfRanks = Enum.GetNames(typeof(Ranks)).Length; //( == 13)
rank = (Ranks)(Index % noOfRanks);
suit = (Suits)((int)(Math.Floor((double)(Index / noOfRanks))));
}
// Update is called once per frame
void Update()
{
if (accuracy >= 99.5f)
{
ranks = Ranks.SS;
}
else if (accuracy >= 90.0f)
{
ranks = Ranks.S;
}
else if (accuracy >= 80)
{
ranks = Ranks.A;
}
else if (accuracy >= 70f)
{
ranks = Ranks.B;
}
else
{
ranks = Ranks.C;
}
scoreText.text = $"<color=#8B2635>S:</color><color=#4C86A8> {score.ToString("000000")}</color>\n<color=#8B2635>C:</color><color=#A5B452> x{combo.ToString("f0")} <color=#8B2635>R:</color> {ranks.ToString()}";
}
protected Card(Ranks rank, Suits suit)
{
Rank = rank;
Suit = suit;
CalculateVal();
}
public HandOf5Summary(HandOf5 handOf5)
{
Ranks = handOf5.Cards.Select(c => c.Rank).ToList();
Ranks.Sort();
SameColor = handOf5.Cards.All(c => c.Suit == handOf5.Cards.First().Suit);
Score = handOf5.Score;
}
public static void OnStep(Client client, PacketHitList hitlist)
{
// NOTE: Remove the mapper+ check for release
if (exPlayer.Get(client).AnniversaryEnabled&& client.Player.CurrentChapter == null && Ranks.IsAllowed(client, Enums.Rank.Mapper))
{
int currentAnniversarySection = client.Player.StoryHelper.ReadSetting("[Anniversary12]-CurrentSection").ToInt();
//Messenger.PlayerMsg(client, "Section: " + currentAnniversarySection, Text.BrightRed);
// NOTE: Do /not/ remove the mapper+ check here, this resets the story when you reach the end
if (currentAnniversarySection == annivRiddles.Length && Ranks.IsAllowed(client, Enums.Rank.Mapper))
{
currentAnniversarySection = 0;
client.Player.StoryHelper.SaveSetting("[Anniversary12]-CurrentSection", currentAnniversarySection.ToString());
Messenger.PlayerMsg(client, "Section reset!", Text.BrightRed);
}
if (currentAnniversarySection >= 0 && currentAnniversarySection < annivRiddles.Length)
{
AnniversaryRiddle currentRiddle = annivRiddles[currentAnniversarySection];
if (client.Player.MapID == currentRiddle.MapId &&
client.Player.X == currentRiddle.X && client.Player.Y == currentRiddle.Y)
{
client.Player.SetStoryState(currentRiddle.Story - 1, false);
StoryManager.PlayStory(client, currentRiddle.Story - 1);
currentAnniversarySection++;
client.Player.StoryHelper.SaveSetting("[Anniversary12]-CurrentSection", currentAnniversarySection.ToString());
}
}
}
if (exPlayer.Get(client).StoryEnabled&& client.Player.CurrentChapter == null)
{
int currentStorySection = client.Player.StoryHelper.ReadSetting("[MainStory]-CurrentSection").ToInt();
switch (client.Player.MapID)
{
case "s737": {
if (currentStorySection == 3) // Tiny Grotto complete, first time [Bulbasaur mission]
{
if (client.Player.X > 20 && client.Player.X < 35 && client.Player.Y > 43)
{
if (client.Player.GetDungeonCompletionCount(1 - 1) >= 1)
{
StoryManager.PlayStory(client, 614 - 1);
}
}
}
}
break;
case "s1934": {
if (currentStorySection == 6)
{
if (client.Player.X == 10 && client.Player.Y == 9)
{
StoryManager.PlayStory(client, 616 - 1);
}
}
}
break;
}
}
}
public override void HandleCardPlayed(Seats source, Suits suit, Ranks rank)
{
#if syncTrace
Log.Trace(2, "{0}.HandleCardPlayed: {1} plays {3} of {2}", this.Owner, source, suit, rank);
#endif
var manForCurrentCard = this.Play.man;
base.HandleCardPlayed(source, suit, rank);
#if syncTrace
Log.Trace(2, "{0}.HandleCardPlayed: next card by {1}", this.Owner, this.Play.whoseTurn);
#endif
if ((source == this.tmc.seat && this.tmc.seat != this.Play.Dummy) || (source == this.Play.Dummy && this.tmc.seat == this.Play.Dummy.Partner()))
{
var message = string.Format("{0} plays {2}{1}",
// TM bug: TM does not recognize the phrase 'Dummy plays 8C', eventhough the protocol defines it
//whoseTurn != this.seat ? "Dummy" : whoseTurn.ToString(),
source,
SuitHelper.ToXML(suit),
rank.ToXML());
if (manForCurrentCard == 1)
{
this.tmc.ChangeState(TableManagerProtocolState.WaitForLead, false, false, new string[] { "" }, message);
}
else
{
this.tmc.ChangeState(this.tmc.state, false, this.Play.PlayEnded || (this.Play.man == 1 && (this.Play.whoseTurn == this.tmc.seat || (this.Play.whoseTurn == this.Play.Dummy && this.tmc.seat == this.Play.Contract.Declarer))), this.tmc.tableManagerExpectedResponse, message);
}
}
}
public Employee(string line, Ranks ranks)
{
int last = Math.Max(line.LastIndexOf('-'), Math.Max(line.LastIndexOf('–'), line.LastIndexOf('—')));
string fullName = line.Substring(0, last).Trim();
string Position = line.Substring(last + 1).Trim();
string[] names = fullName.Split();
FirstName = names[0];
LastName = names[1];
Rank = ranks.Jobs[Position];
}
/// <summary>
///
/// </summary>
/// <param name="game"></param>
/// <param name="soloOrTeam"></param>
/// <param name="rank"></param>
/// <returns></returns>
public List<PlayerGameRankingType> GetGameRankings(GameType game, ParticipantTypes soloOrTeam, Ranks rank)
{
List<PlayerGameRankingType> rankings = new List<PlayerGameRankingType>();
foreach (PlayerGameRankingType r in backend.RankingList)
{
if ((r.Game == game) && (r.Ranking == rank) && (!rankings.Contains(r)))
{
rankings.Add(r);
}
}
return rankings;
}
public void ToString_ShouldReturnCorrectValue(Ranks rank, Suits suit)
{
Assert.Equal($"{rank} of {suit}", rank.Of(suit).ToString());
}
public Card(Suits suits, Ranks ranks)
{
this.suits = suits;
this.ranks = ranks;
}
public void setRank(Ranks rank)
{
this.ranks = rank;
}
public User(string username, string password, Ranks rank)
{
Username = username;
Password = password;
Rank = rank;
}
private Ranks GetYourRank(string userName, ProgrammingContestDataContextHandler pcdch)
{
long contestId = Convert.ToInt64(Session["ContestID"]);
List<User> users = pcdch.Users.GetAll();
List<Ranks> ranks = new List<Ranks>();
long i = 1;
long acceptId = pcdch.Result.GetByName("Accept").ID;
long notTry = pcdch.Result.GetByName("Not Try").ID;
foreach (User u in users)
if (pcdch.ContestPermission.GetByUserIdAndContestId(u.ID, contestId) != null)
{
Ranks rank = new Ranks();
rank.Name = u.Name;
rank.Position = i;
i++;
rank.Solved = 0;
List<Problem> pro1 = pcdch.Problems.GetByContestId(Convert.ToInt64(Session["ContestID"]));
List<ProblemTry> ppp1 = new List<ProblemTry>();
foreach (Problem p1 in pro1)
{
ProblemTry pblm = new ProblemTry();
pblm.Name = p1.PNumber;
List<Solution> so = pcdch.Solution.GetByProblemIdAndUserId(p1.ID, u.ID);
pblm.NumberOfSubmission = 0;
pblm.ResultId = notTry;
if (so.Count != 0)
{
pblm.NumberOfSubmission = so.Count;
foreach (Solution s in so)
{
if (s.ResultId == acceptId)
{
if (pblm.ResultId != acceptId)
{
pblm.ResultId = s.ResultId;
if (rank.Solved == 0)
rank.LastTimeOfAc = s.time;
else if (rank.LastTimeOfAc < s.time)
rank.LastTimeOfAc = s.time;
rank.Solved++;
}
}
else if (pblm.ResultId != acceptId)
{
pblm.ResultId = s.ResultId;
}
}
}
ppp1.Add(pblm);
}
rank.Problem = ppp1;
ranks.Add(rank);
}
Sort st = new Sort();
ranks = st.RanksSort(ranks);
foreach (Ranks ra21 in ranks)
if (ra21.Name == userName)
{
return ra21;
}
return null;
}
/// <summary> Default constructor. Defines the two necessary components of a playing card. </summary>
/// <param name="rank">Playing card's value.</param>
/// <param name="suit">Playing card's suit.</param>
public SuitPrecedencePlayingCard(Ranks rank, Suits suit)
: base(rank, (PlayingCard.Suits)TypeDescriptor.GetConverter(suit).ConvertTo(suit, typeof(PlayingCard.Suits)))
{
}
public bool TestForPromotion(Piece.Colour c, Ranks rank)
{
switch (c)
{
case Piece.Colour.White:
if (rank == Ranks.Eight)
return true;
break;
case Piece.Colour.Black:
if (rank == Ranks.One)
return true;
break;
}
return false;
}
public Employees(string file, Ranks ranks)
{
string[] lines = File.ReadAllLines(file);
int positions = lines.Length;
Staff = new Employee[positions];
for (int i = 0; i < positions; i++)
{
Staff[i] = new Employee(lines[i], ranks);
}
}
public Employees(int positions, Ranks ranks)
{
Staff = new Employee[positions];
for (int i = 0; i < positions; i++)
{
Staff[i] = new Employee(Console.ReadLine(), ranks);
}
}
public static UInt64 Set(this UInt64 bitboard, Ranks rank)
{
return bitboard | SetRankMasksField[(int)rank];
}
public static void Main()
{
//Ranks jobs = new Ranks("Ranks.in");
int n = int.Parse(Console.ReadLine());
Ranks jobs = new Ranks(n);
//Employees staff = new Employees("Employees.in", jobs);
int m = int.Parse(Console.ReadLine());
Employees staff = new Employees(m, jobs);
Array.Sort(staff.Staff);
staff.Print();
}
public static bool IsClear(this UInt64 bitboard, Ranks rank)
{
return (bitboard & Bitboard.SetRankMasksField[(int)rank]) == 0;
}
public static UInt64 Clear(this UInt64 bitboard, Ranks rank)
{
return bitboard & Bitboard.ClearRankMasksField[(int)rank];
}
public Card(Ranks rank, Suits suit)
{
Rank = rank;
Suit = suit;
}
public Card(Suits suit, Ranks rank, Backs back)
{
Suit = (rank == Ranks.Joker ? Suits.None : suit);
Rank = rank;
Back = back;
}
public void Equals_ShouldReturnTrue_ForSameCards(Ranks rank, Suits suit)
{
Assert.Equal(rank.Of(suit), rank.Of(suit));
}
public void Equals_ShouldReturnFalse_ForCardsWithDifferentSuits(Ranks rank)
{
Assert.NotEqual(rank.Of(Clubs), rank.Of(Diamonds));
}
public Card(Suits suit, Ranks rank)
: this(suit, rank, DefaultBack)
{
}
public Card(Suits suit, Ranks rank, bool visible = false)
{
_suit = suit;
_rank = rank;
_visible = visible;
}
private Ranks[] GetRanks(string ranksLine)
{
var ranks = ranksLine.Split(' ');
var ranksArray = new Ranks[ranks.Length];
var index = 0;
foreach (var rank in ranks)
{
switch (rank.ToUpperInvariant())
{
case "A":
ranksArray[index++] = Ranks.Ace;
break;
case "2":
ranksArray[index++] = Ranks.Two;
break;
case "3":
ranksArray[index++] = Ranks.Three;
break;
case "4":
ranksArray[index++] = Ranks.Four;
break;
case "5":
ranksArray[index++] = Ranks.Five;
break;
case "6":
ranksArray[index++] = Ranks.Six;
break;
case "7":
ranksArray[index++] = Ranks.Seven;
break;
case "8":
ranksArray[index++] = Ranks.Eight;
break;
case "9":
ranksArray[index++] = Ranks.Nine;
break;
case "10":
ranksArray[index++] = Ranks.Ten;
break;
case "J":
ranksArray[index++] = Ranks.Jack;
break;
case "Q":
ranksArray[index++] = Ranks.Queen;
break;
case "K":
ranksArray[index++] = Ranks.King;
break;
}
}
return ranksArray;
}
public Square(string id,Vector3 position, Files f, Ranks r)
: base(id, position)
{
File = f;
Rank = r;
}
public List<PlayerGameRankingType> GetGameRankings(GameType game, ParticipantTypes soloOrTeam, Ranks rank)
{
throw new NotImplementedException();
}
public Card(Ranks rank)
{
Rank = rank;
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["ContestID"] == null)
Response.Redirect("Default.aspx");
ProgrammingContestDataContextHandler pcdch = new ProgrammingContestDataContextHandler();
List<Problem> problem = pcdch.Problems.GetByContestId(Convert.ToInt64(Session["ContestID"]));
ContestSetting cs = pcdch.ContestSetting.GetById(Convert.ToInt64(Session["ContestID"]));
if (DateTime.Now > cs.EndTime)
{
_isCodePublished = true;
}
else
_isCodePublished = false;
_acceptId = pcdch.Result.GetByName("Accept").ID;
_allResult = pcdch.Result.GetAll();
ltlProblemName.Text = "<td style=\"width:150px\"></td>";
foreach (Problem p in problem)
{
ltlProblemName.Text += "<td style=\"width:150px\">" + p.PNumber + "</td>";
}
ltlProblemName.Text += "<td style=\"width:150px\">Total Solved</td>";
long contestId = Convert.ToInt64(Session["ContestID"]);
List<User> users = pcdch.Users.GetAll();
List<Ranks> ranks = new List<Ranks>();
long i = 1;
long acceptId = pcdch.Result.GetByName("Accept").ID;
long notTry = pcdch.Result.GetByName("Not Try").ID;
foreach (User u in users)
if (pcdch.ContestPermission.GetByUserIdAndContestId(u.ID, contestId) != null)
{
Ranks rank = new Ranks();
rank.Name = u.Name;
rank.Position = i;
i++;
rank.Solved = 0;
List<Problem> pro1 = pcdch.Problems.GetByContestId(Convert.ToInt64(Session["ContestID"]));
List<ProblemTry> ppp1 = new List<ProblemTry>();
foreach (Problem p1 in pro1)
{
ProblemTry pblm = new ProblemTry();
pblm.Name = p1.PNumber;
List<Solution> so = pcdch.Solution.GetByProblemIdAndUserId(p1.ID, u.ID);
pblm.NumberOfSubmission = 0;
pblm.ResultId = notTry;
if (so.Count != 0)
{
pblm.NumberOfSubmission = so.Count;
foreach (Solution s in so)
{
if (s.ResultId == acceptId)
{
if (pblm.ResultId != acceptId)
{
pblm.ResultId = s.ResultId;
pblm.RequireTime = s.RequireTime;
if (s.SolutionFileName != null)
pblm.SourceFilePath = s.SolutionFileName;
if (rank.Solved == 0)
rank.LastTimeOfAc = s.time;
else if (rank.LastTimeOfAc < s.time)
rank.LastTimeOfAc = s.time;
rank.Solved++;
}
else if (s.SolutionFileName != null)
pblm.SourceFilePath = s.SolutionFileName;
}
else if (pblm.ResultId != acceptId)
{
if (s.SolutionFileName != null)
pblm.SourceFilePath = s.SolutionFileName;
pblm.ResultId = s.ResultId;
}
}
}
ppp1.Add(pblm);
}
rank.Problem = ppp1;
ranks.Add(rank);
}
Sort st = new Sort();
rptProblems.DataSource = st.RanksSort(ranks);
rptProblems.DataBind();
}
