public ClearReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var key = new CharaLevelPair(chara, level);
if (parent.allScoreData.Rankings.ContainsKey(key))
{
var stageProgress =
parent.allScoreData.Rankings[key].Max(rank => rank.StageProgress);
if (stageProgress == StageProgress.Extra)
{
return("Not Clear");
}
else
{
return(stageProgress.ToShortName());
}
}
else
{
return(StageProgress.None.ToShortName());
}
});
}
public PracticeReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var stage = StageParser.Parse(match.Groups[3].Value);
if (level == Level.Extra)
{
return(match.ToString());
}
if (stage == Stage.Extra)
{
return(match.ToString());
}
var key = new CharaLevelPair(chara, level);
if (parent.allScoreData.PracticeScores.ContainsKey(key))
{
var scores = parent.allScoreData.PracticeScores[key];
return(scores.ContainsKey(stage)
? Utils.ToNumberString(scores[stage].HighScore) : "0");
}
else
{
return("0");
}
});
}
public ClearReplacer(Th09Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var type = int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture);
var count = parent.allScoreData.PlayStatus.ClearCounts[chara].Counts[level];
if (type == 1)
{
return(Utils.ToNumberString(count));
}
else
{
if (count > 0)
{
return("Cleared");
}
else
{
var score = parent.allScoreData.Rankings[new CharaLevelPair(chara, level)][0];
var date = Encoding.Default.GetString(score.Date).TrimEnd('\0');
return((date != "--/--") ? "Not Cleared" : "-------");
}
}
});
}
public ScoreReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var rank = Utils.ToZeroBased(
int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
var type = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture);
var key = new CharaLevelPair(chara, level);
var score = parent.allScoreData.Rankings.ContainsKey(key)
? parent.allScoreData.Rankings[key][rank] : InitialRanking[rank];
switch (type)
{
case 1: // name
return(Encoding.Default.GetString(score.Name).Split('\0')[0]);
case 2: // score
return(Utils.ToNumberString(score.Score));
case 3: // stage
return(score.StageProgress.ToShortName());
default: // unreachable
return(match.ToString());
}
});
}
public ScoreReplacer(Th09Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var rank = Utils.ToZeroBased(
int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
var type = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture);
var score = parent.allScoreData.Rankings[new CharaLevelPair(chara, level)][rank];
var date = string.Empty;
switch (type)
{
case 1: // name
return(Encoding.Default.GetString(score.Name).Split('\0')[0]);
case 2: // score
return(Utils.ToNumberString((score.Score * 10) + score.ContinueCount));
case 3: // date
date = Encoding.Default.GetString(score.Date).Split('\0')[0];
return((date != "--/--") ? date : "--/--/--");
default: // unreachable
return(match.ToString());
}
});
}
public PracticeReplacer(Th10Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = (CharaWithTotal)CharaParser.Parse(match.Groups[2].Value);
var stage = StageParser.Parse(match.Groups[3].Value);
if (level == Level.Extra)
{
return(match.ToString());
}
if (stage == Stage.Extra)
{
return(match.ToString());
}
if (parent.allScoreData.ClearData.ContainsKey(chara))
{
var key = new LevelStagePair(level, stage);
var practices = parent.allScoreData.ClearData[chara].Practices;
return(practices.ContainsKey(key)
? Utils.ToNumberString(practices[key].Score * 10) : "0");
}
else
{
return("0");
}
});
}
public ScoreReplacer(Th10Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = (CharaWithTotal)CharaParser.Parse(match.Groups[2].Value);
var rank = Utils.ToZeroBased(
int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture));
var type = int.Parse(match.Groups[4].Value, CultureInfo.InvariantCulture);
var ranking = parent.allScoreData.ClearData[chara].Rankings[level][rank];
switch (type)
{
case 1: // name
return(Encoding.Default.GetString(ranking.Name).Split('\0')[0]);
case 2: // score
return(Utils.ToNumberString((ranking.Score * 10) + ranking.ContinueCount));
case 3: // stage
if (ranking.DateTime > 0)
{
return((ranking.StageProgress == StageProgress.Extra)
? "Not Clear" : ranking.StageProgress.ToShortName());
}
else
{
return(StageProgress.None.ToShortName());
}
case 4: // date & time
if (ranking.DateTime > 0)
{
return(new DateTime(1970, 1, 1).AddSeconds(ranking.DateTime).ToLocalTime()
.ToString("yyyy/MM/dd HH:mm:ss", CultureInfo.CurrentCulture));
}
else
{
return("----/--/-- --:--:--");
}
case 5: // slow
if (ranking.DateTime > 0)
{
return(Utils.Format("{0:F3}%", ranking.SlowRate));
}
else
{
return("-----%");
}
default: // unreachable
return(match.ToString());
}
});
}
public ClearReplacer(Th10Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = (CharaWithTotal)CharaParser.Parse(match.Groups[2].Value);
var rankings = parent.allScoreData.ClearData[chara].Rankings[level]
.Where(ranking => ranking.DateTime > 0);
var stageProgress = (rankings.Count() > 0)
? rankings.Max(ranking => ranking.StageProgress) : StageProgress.None;
return((stageProgress == StageProgress.Extra)
? "Not Clear" : stageProgress.ToShortName());
});
}
public ClearReplacer(Th135Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
var cleared = false;
var flags = LevelFlag.None;
if (parent.allScoreData.StoryClearFlags.TryGetValue((Chara)chara, out flags))
{
switch (level)
{
case Level.Easy:
cleared = (flags & LevelFlag.Easy) == LevelFlag.Easy;
break;
case Level.Normal:
cleared = (flags & LevelFlag.Normal) == LevelFlag.Normal;
break;
case Level.Hard:
cleared = (flags & LevelFlag.Hard) == LevelFlag.Hard;
break;
case Level.Lunatic:
cleared = (flags & LevelFlag.Lunatic) == LevelFlag.Lunatic;
break;
default: // unreachable
break;
}
}
return(cleared ? "Clear" : "Not Clear");
});
}
public ClearRankReplacer(Th145Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var level = LevelParser.Parse(match.Groups[1].Value);
var chara = CharaParser.Parse(match.Groups[2].Value);
// FIXME
switch (parent.allScoreData.ClearRanks[level][chara])
{
case 1:
return("Bronze");
case 2:
return("Silver");
case 3:
return("Gold");
default:
return("Not Clear");
}
});
}