// Use this for initialization
void Start()
{
gameMaster = Camera.main.GetComponent<GameMaster> ();
playerControl = Camera.main.GetComponent<PlayerControl> ();
stats = Camera.main.GetComponent<Statistics> ();
source = Camera.main.GetComponent<AudioSource> ();
}
public Statistics GetStatistics()
{
if (statistics == null) {
statistics = GameObject.Find ("GameManager").GetComponent<Statistics> ();
}
return statistics;
}
public DebugManager(Game game, Camera camera, ChunkCache chunkCache, SpriteFont debugFont)
: base(game)
{
m_graphs = new GraphManager(game);
m_debugger = new InGameDebugger(game, camera);
var statistics = new Statistics(game, chunkCache);
m_components = new GameComponentCollection
{
m_debugger,
new DebugBar(game, statistics, chunkCache),
statistics,
m_graphs,
new GameConsole(game, new SpriteBatch(game.GraphicsDevice), new GameConsoleOptions
{
Font = debugFont,
FontColor = Color.LawnGreen,
Prompt = ">",
PromptColor = Color.Crimson,
CursorColor = Color.OrangeRed,
BackgroundColor = Color.Black*0.8f,
PastCommandOutputColor = Color.Aqua,
BufferColor = Color.Gold
}, m_debugger.ToggleInGameDebugger)
};
}
public StressBenchmark(Storage storage, BenchmarkOptions options)
{
this.storage = storage;
this.readDelayInSeconds = TimeSpan.FromSeconds(5);
this.statistics = new Statistics(readDelayInSeconds);
this.options = options;
}
private DriverDetailsViewModel BuildDriverDetailsViewModel(Driver driver, Statistics statistic)
{
return new DriverDetailsViewModel
{
Name = driver.Name,
CurrentTeam = driver.CurrentTeam != null ? driver.CurrentTeam.Name : "* Not Contracted *",
AtomicName = driver.AtomicName,
BestQualifyingResult = statistic.BestQualifyingResult,
BestRaceResult = statistic.BestRaceResult,
BestChampionshipResult = statistic.BestChampionshipResult,
RacerRatio = statistic.RacerRatio,
Races = statistic.Entered,
Points = statistic.Points,
PointsPerRace = statistic.PointsPerRace,
Wins = statistic.Wins,
WinsPercent = statistic.WinsPercent,
Poles = statistic.Poles,
PolesPercent = statistic.PolesPercent,
Podiums = statistic.Podiums,
PodiumsPercent = statistic.PodiumsPercent,
FastestLaps = statistic.FastestLaps,
FastestLapsPercent = statistic.FastestLapsPercent,
Finishes = statistic.Finished,
FinishesPercent = statistic.FinishedPercent,
Seasons = statistic.Seasons
};
}
static void Main(string[] args)
{
// create the subject and observers
WeatherData weatherData = new WeatherData();
CurrentConditions conditions = new CurrentConditions(weatherData);
Statistics statistics = new Statistics(weatherData);
Forecast forecast = new Forecast(weatherData);
// create the readings
WeatherMeasurements readings = new WeatherMeasurements();
readings.humidity = 40.5F;
readings.pressure = 20F;
readings.temperature = 72F;
// update the readings - everyone should print
weatherData.UpdateReadings(readings);
// update
readings.pressure = 10F;
weatherData.UpdateReadings(readings);
// update
readings.humidity = 100;
readings.temperature = 212.75F;
readings.pressure = 950;
weatherData.UpdateReadings(readings);
Console.ReadLine();
}
public Sender(Log log, Statistics statistics, ProgramConfiguration programConfiguration)
: base(log, programConfiguration)
{
var destinationEndPoint =
new IPEndPoint(_programConfiguration.DestinationIpAddress, programConfiguration.DestinationPort);
_networkProtocol =
new UdpNetworkProtocol(
log, statistics, destinationEndPoint, UdpNetworkProtocolType.Udp, _programConfiguration.PacketSize,
_programConfiguration.VerifyOrder);
_sendDataTask =
new HighResolutionTimer
{
Mode = TimerMode.Periodic,
Period = 1000,
Resolution = 0,
IsAsync = true
};
_sendDataTask.Tick += (sender, args) => SendData();
var bindedIp =
MachineAddress.FirstOrDefault(i => i.Equals(_programConfiguration.SourceIpAddress)) ?? IPAddress.Any;
var bindedPort = programConfiguration.SourcePort ?? 0;
_networkProtocol.Bind(new IPEndPoint(bindedIp, bindedPort));
if (programConfiguration.NetworkBufferSize.HasValue)
_networkProtocol.SetSendBufferSize(programConfiguration.NetworkBufferSize.Value);
}
public Aura()
{
Damage = new Damage();
Healing = new Damage();
Duration = 1f;
Cooldown = new Cooldown(1f);
Statistics = new Statistics();
}
private void btnPlot_Click(object sender, EventArgs e)
{
Statistics stats = new Statistics(picFiles);
List<StatItem> statsList = stats.GenerateFocalStatsBar();
statsList.Sort();
new ChartForm(statsList, "bar").Show();
}
public override void GoToScene(string sceneName)
{
//Saves the statistics in the Session object
Statistics stats = new Statistics(_score, _kills, _wave);
Session.Instance.GameStats = stats;
base.GoToScene(sceneName);
//GoToScene(Scene.GameOver);
}
public FormLines()
{
InitializeComponent();
game = new Game(numberOfCells, ShowItem, ShowStat, HandlingFinishInfo);
CreateBoxes();
this.Size = new Size(numberOfCells * cellSize + 10, numberOfCells * cellSize + 55);
timer.Enabled = true;
statistics = new Statistics("ToR.dat");
}
public Game2048()
{
InitializeComponent();
InitBackColors();
InitLabels();
logic = new Logic(size, Show, ShowStat);
logic.InitGame();
statistics = new Statistics("ToR.dat");
}
public CombatTable(Random random, Statistics actorStatistics, Statistics targetStatistics, Ability ability)
{
this.random = random;
dodgeChance = ability.CanBeDodged ? targetStatistics.For<Dodge>().Chance : 0;
hitChance = ability.CanMiss ? actorStatistics.For<Hit>().Chance : 1;
critChance = ability.CanCrit ? actorStatistics.For<CriticalStrike>().Chance : 0;
blockChance = ability.CanBeBlocked ? targetStatistics.For<Block>().Chance : 0;
}
public CombatTable(Random random, Statistics actorStatistics, Statistics targetStatistics)
{
this.random = random;
dodgeChance = targetStatistics.For<Dodge>().Chance;
hitChance = actorStatistics.For<Hit>().Chance;
critChance = actorStatistics.For<CriticalStrike>().Chance;
blockChance = targetStatistics.For<Block>().Chance;
}
public ActorDefinition()
{
BaseStatistics = new Statistics();
Abilities = new List<Ability>();
Equipment = new List<ItemDefinition>();
Diameter = 1f;
MovementSpeed = 5f;
}
public Chat()
: base(new Irc("Tomestone", "oauth:npafwpg44j0a5iullxo2dt385n5jeco", new[] { MainChannel }))
{
var twitch = new TwitchConnection();
_userDatabase = new UserDatabase(_db, twitch);
_gameDatabase = new GameDatabase(_db, twitch);
_statistics = new Statistics(_userDatabase, _gameDatabase, twitch);
}
public JsonResult GetStatistics(DateTime startDate, DateTime endDate)
{
var statistics = new Statistics
{
BingMapAuthKey = Configuration.BingMapsAuthenticationKey,
ClientStatisticses = GetDistrictAgresivityRates(startDate, endDate),
Counties = null
};
return Json(statistics, JsonRequestBehavior.AllowGet);
}
public static XmlWriter Serialize(XmlWriter writer, Statistics statistics)
{
writer.WriteStartElement(DTD.TagRequest);
writer.WriteAttributeString("StartTime", statistics.StartTime);
writer.WriteAttributeString("EndTime", statistics.EndTime);
writer.WriteAttributeString("ElapsedTime", statistics.ElapsedTime);
writer.WriteEndElement();
return writer;
}
public ActionResult Create(Statistics statistics)
{
if (ModelState.IsValid)
{
_dataContext.StatisticsItemValues.Add(statistics);
_dataContext.SaveChanges();
return RedirectToAction("Index");
}
return View(statistics);
}
public static string GetStatisticsString(Statistics statistics, ActorResourceTypes resourceType, bool hideZero)
{
StringBuilder sb = new StringBuilder();
foreach (var stat in statistics.OrderBy(x => x.Name))
{
sb.AppendLine(stat.Name + ": " + stat.ToValueString());
}
return sb.ToString();
}
private void IsHighScoreCompleted(object sender, Statistics.IsHighScoreCompletedEventArgs e)
{
if(e.Result) {
Message.Text = Strings.GameWinText + "\n\n" + Strings.GameWinHigh;
Player.Visibility = Visibility.Visible;
}
else {
Message.Text = Strings.GameWinText + "\n\n" + Strings.GameWinNoHigh;
Player.Visibility = Visibility.Collapsed;
}
}
private static void ReadInts(Statistics statics)
{
int value;
for (int i = 0; i < 10; ++i)
{
while (!int.TryParse(Console.ReadLine(), out value))
{
Console.WriteLine("Du måste ange ett heltal!");
}
statics.Add(value);
}
}
public async Task<IReadOnlyDictionary<string, string>> ListAsync(Statistics statistics, CancellationToken cancellationToken)
{
if (null == S3Util.KeyAlphabet)
return await ListAsync(_pathManager.BlobPrefix, statistics, cancellationToken).ConfigureAwait(false);
var tasks = S3Util.KeyAlphabet
.Select(ch => ListAsync(_pathManager.BlobPrefix + ch, statistics, cancellationToken))
.ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
return tasks.SelectMany(t => t.Result).ToDictionary(kv => kv.Key, kv => kv.Value);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
m_camera = new Camera(this);
Components.Add(m_camera);
m_stats = new Statistics(this, Content);
Components.Add(m_stats);
m_map = new Map(this, Content);
Components.Add(m_map);
base.Initialize();
}
public GenericCombatStoryline()
{
_neededAmmo = new List<Ammo>();
_agentInteraction = new AgentInteraction();
_arm = new Arm();
_combat = new Combat();
_drones = new Drones();
_salvage = new Salvage();
_statistics = new Statistics();
_combatMissionCtrl = new CombatMissionCtrl();
Settings.Instance.SettingsLoaded += ApplySettings;
}
private void GetScoresCompleted(object sender, Statistics.GetScoresCompletedEventArgs e)
{
if(e.Result != null) {
Values.Visibility = Visibility.Visible;
Values.Children.Clear();
int place = 1;
Header.Text = Strings.HighScore;
foreach(Statistics.DataItem score in e.Result) {
AddStatistics(place, score.Name, score.Value);
place++;
}
}
}
private void Fixup(string srcPath, string dstPath)
{
Message message;
var stats = new Statistics();
var classifier = new MessageClassifier();
var translator = new LiveMessageTranslator();
using(var input = File.OpenRead(srcPath))
using(var reader = new DecoratedObjectReader(input))
using(var output = File.Create(dstPath))
using(var writer = new DecoratedObjectWriter(output))
{
while(true)
{
if((message = reader.Read<Message>()) == null)
{
break;
}
++stats.Read;
if(classifier.IsTranslated(message))
{
++stats.OrgTranslated;
continue;
}
writer.Write(message);
++stats.Written;
if((message = translator.Translate(message)) != null)
{
if(message is CompositeMessage)
{
foreach(var component in ((CompositeMessage)message).Messages)
{
writer.Write(component);
++stats.Written;
++stats.NewTranslated;
}
}
else
{
writer.Write(message);
++stats.Written;
++stats.NewTranslated;
}
}
}
writer.Write(null);
}
stats.Print();
}
void Plot9(Statistics stat, int sessionId)
{
var data = "X position, Z position\n";
foreach (var artefact in stat.artefacts)
{
data += artefact.Value.spawnPosition.x.ToString("F2") + "," + artefact.Value.spawnPosition.y.ToString("F2") + "\n";
}
var path = directory.Remove(directory.LastIndexOf(@"\")) + @"\Position Of Artefacts";
if (Directory.Exists(path) == false)
Directory.CreateDirectory(path);
File.WriteAllText(path + @"\data" + sessionId + ".csv", data);
}
protected void okButton_Click(object sender, EventArgs e)
{
//Game game = new Game();
//game.Play();
//Dart dart = new Dart(random);
//dart.Throw();
//resultLabel.Text = String.Format("Dart landed on {0} with ringmultiplier {1}x", dart.Score, dart.RingMultiplier);
int games = 9999999;
Statistics player1Stats = new Statistics(games);
Statistics player2Stats = new Statistics(games);
for (int i = 0; i < player1Stats.Length; i++)
{
Game game = new Game();
game.Play();
if (game.Player1Score > game.Player2Score)
{
player1Stats.AddGameResult(1);
player2Stats.AddGameResult(0);
}
else
{
player1Stats.AddGameResult(0);
player2Stats.AddGameResult(1);
}
}
//string winningPlayer = "";
//if (game.Player1Score > game.Player2Score)
//{
// winningPlayer = "Player 1";
//}
//else
// winningPlayer = "Player 2";
resultLabel.Text = String.Format("Player 1 won : {0}% of the time.<br/>Player 2 won : {1}% of the time.<br/>",
player1Stats.GetWinPercentage().ToString(),
player2Stats.GetWinPercentage().ToString());
//resultLabel.Text = String.Format("Player 1: {0}<br/>Player 2: {1}<br/>{2} wins!",
// game.Player1Score,
// game.Player2Score,
// winningPlayer);
}
/// <summary>Dumps a MultiMediaCard or SecureDigital flash card</summary>
public void SecureDigital()
{
if (_dumpRaw)
{
if (_force)
{
ErrorMessage?.
Invoke("Raw dumping is not supported in MultiMediaCard or SecureDigital devices. Continuing...");
}
else
{
StoppingErrorMessage?.
Invoke("Raw dumping is not supported in MultiMediaCard or SecureDigital devices. Aborting...");
return;
}
}
bool sense;
const ushort SD_PROFILE = 0x0001;
const uint TIMEOUT = 5;
double duration;
uint blocksToRead = 128;
uint blockSize = 512;
ulong blocks = 0;
byte[] csd = null;
byte[] ocr = null;
byte[] ecsd = null;
byte[] scr = null;
uint physicalBlockSize = 0;
bool byteAddressed = true;
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
switch (_dev.Type)
{
case DeviceType.MMC:
{
UpdateStatus?.Invoke("Reading Extended CSD");
_dumpLog.WriteLine("Reading Extended CSD");
sense = _dev.ReadExtendedCsd(out ecsd, out _, TIMEOUT, out duration);
if (!sense)
{
ExtendedCSD ecsdDecoded = Decoders.MMC.Decoders.DecodeExtendedCSD(ecsd);
blocksToRead = ecsdDecoded.OptimalReadSize;
blocks = ecsdDecoded.SectorCount;
blockSize = (uint)(ecsdDecoded.SectorSize == 1 ? 4096 : 512);
if (ecsdDecoded.NativeSectorSize == 0)
{
physicalBlockSize = 512;
}
else if (ecsdDecoded.NativeSectorSize == 1)
{
physicalBlockSize = 4096;
}
// Supposing it's high-capacity MMC if it has Extended CSD...
byteAddressed = false;
mediaTags.Add(MediaTagType.MMC_ExtendedCSD, null);
}
else
{
ecsd = null;
}
UpdateStatus?.Invoke("Reading CSD");
_dumpLog.WriteLine("Reading CSD");
sense = _dev.ReadCsd(out csd, out _, TIMEOUT, out duration);
if (!sense)
{
if (blocks == 0)
{
CSD csdDecoded = Decoders.MMC.Decoders.DecodeCSD(csd);
blocks = (ulong)((csdDecoded.Size + 1) * Math.Pow(2, csdDecoded.SizeMultiplier + 2));
blockSize = (uint)Math.Pow(2, csdDecoded.ReadBlockLength);
}
mediaTags.Add(MediaTagType.MMC_CSD, null);
}
else
{
csd = null;
}
UpdateStatus?.Invoke("Reading OCR");
_dumpLog.WriteLine("Reading OCR");
sense = _dev.ReadOcr(out ocr, out _, TIMEOUT, out duration);
if (sense)
{
ocr = null;
}
else
{
mediaTags.Add(MediaTagType.MMC_OCR, null);
}
break;
}
case DeviceType.SecureDigital:
{
UpdateStatus?.Invoke("Reading CSD");
_dumpLog.WriteLine("Reading CSD");
sense = _dev.ReadCsd(out csd, out _, TIMEOUT, out duration);
if (!sense)
{
Decoders.SecureDigital.CSD csdDecoded = Decoders.SecureDigital.Decoders.DecodeCSD(csd);
blocks = (ulong)(csdDecoded.Structure == 0
? (csdDecoded.Size + 1) * Math.Pow(2, csdDecoded.SizeMultiplier + 2)
: (csdDecoded.Size + 1) * 1024);
blockSize = (uint)Math.Pow(2, csdDecoded.ReadBlockLength);
// Structure >=1 for SDHC/SDXC, so that's block addressed
byteAddressed = csdDecoded.Structure == 0;
mediaTags.Add(MediaTagType.SD_CSD, null);
}
else
{
csd = null;
}
UpdateStatus?.Invoke("Reading OCR");
_dumpLog.WriteLine("Reading OCR");
sense = _dev.ReadSdocr(out ocr, out _, TIMEOUT, out duration);
if (sense)
{
ocr = null;
}
else
{
mediaTags.Add(MediaTagType.SD_OCR, null);
}
UpdateStatus?.Invoke("Reading SCR");
_dumpLog.WriteLine("Reading SCR");
sense = _dev.ReadScr(out scr, out _, TIMEOUT, out duration);
if (sense)
{
scr = null;
}
else
{
mediaTags.Add(MediaTagType.SD_SCR, null);
}
break;
}
}
UpdateStatus?.Invoke("Reading CID");
_dumpLog.WriteLine("Reading CID");
sense = _dev.ReadCid(out byte[] cid, out _, TIMEOUT, out duration);
if (sense)
{
cid = null;
}
else
{
mediaTags.Add(_dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_CID : MediaTagType.MMC_CID, null);
}
DateTime start;
DateTime end;
double totalDuration = 0;
double currentSpeed = 0;
double maxSpeed = double.MinValue;
double minSpeed = double.MaxValue;
if (blocks == 0)
{
_dumpLog.WriteLine("Unable to get device size.");
StoppingErrorMessage?.Invoke("Unable to get device size.");
return;
}
UpdateStatus?.Invoke($"Device reports {blocks} blocks.");
_dumpLog.WriteLine("Device reports {0} blocks.", blocks);
byte[] cmdBuf;
bool error;
while (true)
{
error = _dev.Read(out cmdBuf, out _, 0, blockSize, blocksToRead, byteAddressed, TIMEOUT, out duration);
if (error)
{
blocksToRead /= 2;
}
if (!error ||
blocksToRead == 1)
{
break;
}
}
if (error)
{
_dumpLog.WriteLine("ERROR: Cannot get blocks to read, device error {0}.", _dev.LastError);
StoppingErrorMessage?.Invoke($"Device error {_dev.LastError} trying to guess ideal transfer length.");
return;
}
UpdateStatus?.Invoke($"Device can read {blocksToRead} blocks at a time.");
_dumpLog.WriteLine("Device can read {0} blocks at a time.", blocksToRead);
if (_skip < blocksToRead)
{
_skip = blocksToRead;
}
DumpHardwareType currentTry = null;
ExtentsULong extents = null;
ResumeSupport.Process(true, false, blocks, _dev.Manufacturer, _dev.Model, _dev.Serial, _dev.PlatformId,
ref _resume, ref currentTry, ref extents, _dev.FirmwareRevision);
if (currentTry == null ||
extents == null)
{
StoppingErrorMessage?.Invoke("Could not process resume file, not continuing...");
return;
}
bool ret = true;
foreach (MediaTagType tag in mediaTags.Keys)
{
if (_outputPlugin.SupportedMediaTags.Contains(tag))
{
continue;
}
ret = false;
_dumpLog.WriteLine($"Output format does not support {tag}.");
ErrorMessage?.Invoke($"Output format does not support {tag}.");
}
if (!ret)
{
if (_force)
{
_dumpLog.WriteLine("Several media tags not supported, continuing...");
ErrorMessage?.Invoke("Several media tags not supported, continuing...");
}
else
{
_dumpLog.WriteLine("Several media tags not supported, not continuing...");
StoppingErrorMessage?.Invoke("Several media tags not supported, not continuing...");
return;
}
}
var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead);
var ibgLog = new IbgLog(_outputPrefix + ".ibg", SD_PROFILE);
ret = _outputPlugin.Create(_outputPath,
_dev.Type == DeviceType.SecureDigital ? MediaType.SecureDigital : MediaType.MMC,
_formatOptions, blocks, blockSize);
// Cannot create image
if (!ret)
{
_dumpLog.WriteLine("Error creating output image, not continuing.");
_dumpLog.WriteLine(_outputPlugin.ErrorMessage);
StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
if (_resume.NextBlock > 0)
{
UpdateStatus?.Invoke($"Resuming from block {_resume.NextBlock}.");
_dumpLog.WriteLine("Resuming from block {0}.", _resume.NextBlock);
}
start = DateTime.UtcNow;
double imageWriteDuration = 0;
bool newTrim = false;
DateTime timeSpeedStart = DateTime.UtcNow;
ulong sectorSpeedStart = 0;
InitProgress?.Invoke();
for (ulong i = _resume.NextBlock; i < blocks; i += blocksToRead)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
break;
}
if (blocks - i < blocksToRead)
{
blocksToRead = (byte)(blocks - i);
}
#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
if (currentSpeed > maxSpeed &&
currentSpeed != 0)
{
maxSpeed = currentSpeed;
}
if (currentSpeed < minSpeed &&
currentSpeed != 0)
{
minSpeed = currentSpeed;
}
#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
UpdateProgress?.Invoke($"Reading sector {i} of {blocks} ({currentSpeed:F3} MiB/sec.)", (long)i,
(long)blocks);
error = _dev.Read(out cmdBuf, out _, (uint)i, blockSize, blocksToRead, byteAddressed, TIMEOUT,
out duration);
if (!error)
{
mhddLog.Write(i, duration);
ibgLog.Write(i, currentSpeed * 1024);
DateTime writeStart = DateTime.Now;
_outputPlugin.WriteSectors(cmdBuf, i, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
extents.Add(i, blocksToRead, true);
}
else
{
if (i + _skip > blocks)
{
_skip = (uint)(blocks - i);
}
for (ulong b = i; b < i + _skip; b++)
{
_resume.BadBlocks.Add(b);
}
mhddLog.Write(i, duration < 500 ? 65535 : duration);
ibgLog.Write(i, 0);
DateTime writeStart = DateTime.Now;
_outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
_dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", _skip, i);
i += _skip - blocksToRead;
newTrim = true;
}
sectorSpeedStart += blocksToRead;
_resume.NextBlock = i + blocksToRead;
double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;
if (elapsed < 1)
{
continue;
}
currentSpeed = (sectorSpeedStart * blockSize) / (1048576 * elapsed);
sectorSpeedStart = 0;
timeSpeedStart = DateTime.UtcNow;
}
end = DateTime.Now;
EndProgress?.Invoke();
mhddLog.Close();
ibgLog.Close(_dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024,
(blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000),
_devicePath);
UpdateStatus?.Invoke($"Dump finished in {(end - start).TotalSeconds} seconds.");
UpdateStatus?.
Invoke($"Average dump speed {((double)blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000):F3} KiB/sec.");
UpdateStatus?.
Invoke($"Average write speed {((double)blockSize * (double)(blocks + 1)) / 1024 / imageWriteDuration:F3} KiB/sec.");
_dumpLog.WriteLine("Dump finished in {0} seconds.", (end - start).TotalSeconds);
_dumpLog.WriteLine("Average dump speed {0:F3} KiB/sec.",
((double)blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000));
_dumpLog.WriteLine("Average write speed {0:F3} KiB/sec.",
((double)blockSize * (double)(blocks + 1)) / 1024 / imageWriteDuration);
#region Trimming
if (_resume.BadBlocks.Count > 0 &&
!_aborted &&
_trim &&
newTrim)
{
start = DateTime.UtcNow;
UpdateStatus?.Invoke("Trimming bad sectors");
_dumpLog.WriteLine("Trimming bad sectors");
ulong[] tmpArray = _resume.BadBlocks.ToArray();
InitProgress?.Invoke();
foreach (ulong badSector in tmpArray)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
break;
}
PulseProgress?.Invoke($"Trimming sector {badSector}");
error = _dev.Read(out cmdBuf, out _, (uint)badSector, blockSize, 1, byteAddressed, TIMEOUT,
out duration);
totalDuration += duration;
if (error)
{
continue;
}
_resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
_outputPlugin.WriteSector(cmdBuf, badSector);
}
EndProgress?.Invoke();
end = DateTime.UtcNow;
UpdateStatus?.Invoke($"Trimmming finished in {(end - start).TotalSeconds} seconds.");
_dumpLog.WriteLine("Trimmming finished in {0} seconds.", (end - start).TotalSeconds);
}
#endregion Trimming
#region Error handling
if (_resume.BadBlocks.Count > 0 &&
!_aborted &&
_retryPasses > 0)
{
int pass = 1;
bool forward = true;
bool runningPersistent = false;
InitProgress?.Invoke();
repeatRetryLba:
ulong[] tmpArray = _resume.BadBlocks.ToArray();
foreach (ulong badSector in tmpArray)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
break;
}
PulseProgress?.Invoke(string.Format("Retrying sector {0}, pass {1}, {3}{2}", badSector, pass,
forward ? "forward" : "reverse",
runningPersistent ? "recovering partial data, " : ""));
error = _dev.Read(out cmdBuf, out _, (uint)badSector, blockSize, 1, byteAddressed, TIMEOUT,
out duration);
totalDuration += duration;
if (!error)
{
_resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
_outputPlugin.WriteSector(cmdBuf, badSector);
UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
_dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
}
else if (runningPersistent)
{
_outputPlugin.WriteSector(cmdBuf, badSector);
}
}
if (pass < _retryPasses &&
!_aborted &&
_resume.BadBlocks.Count > 0)
{
pass++;
forward = !forward;
_resume.BadBlocks.Sort();
_resume.BadBlocks.Reverse();
goto repeatRetryLba;
}
EndProgress?.Invoke();
}
#endregion Error handling
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
_outputPlugin.SetDumpHardware(_resume.Tries);
// TODO: Drive info
var metadata = new CommonTypes.Structs.ImageInfo
{
Application = "DiscImageChef", ApplicationVersion = Version.GetVersion()
};
if (!_outputPlugin.SetMetadata(metadata))
{
ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
_outputPlugin.ErrorMessage);
}
if (_preSidecar != null)
{
_outputPlugin.SetCicmMetadata(_preSidecar);
}
_dumpLog.WriteLine("Closing output file.");
UpdateStatus?.Invoke("Closing output file.");
DateTime closeStart = DateTime.Now;
_outputPlugin.Close();
DateTime closeEnd = DateTime.Now;
UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
_dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
if (_aborted)
{
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
return;
}
double totalChkDuration = 0;
if (_metadata)
{
UpdateStatus?.Invoke("Creating sidecar.");
_dumpLog.WriteLine("Creating sidecar.");
var filters = new FiltersList();
IFilter filter = filters.GetFilter(_outputPath);
IMediaImage inputPlugin = ImageFormat.Detect(filter);
if (!inputPlugin.Open(filter))
{
StoppingErrorMessage?.Invoke("Could not open created image.");
}
DateTime chkStart = DateTime.UtcNow;
_sidecarClass = new Sidecar(inputPlugin, _outputPath, filter.Id, _encoding);
_sidecarClass.InitProgressEvent += InitProgress;
_sidecarClass.UpdateProgressEvent += UpdateProgress;
_sidecarClass.EndProgressEvent += EndProgress;
_sidecarClass.InitProgressEvent2 += InitProgress2;
_sidecarClass.UpdateProgressEvent2 += UpdateProgress2;
_sidecarClass.EndProgressEvent2 += EndProgress2;
_sidecarClass.UpdateStatusEvent += UpdateStatus;
CICMMetadataType sidecar = _sidecarClass.Create();
if (_preSidecar != null)
{
_preSidecar.BlockMedia = sidecar.BlockMedia;
sidecar = _preSidecar;
}
switch (_dev.Type)
{
case DeviceType.MMC:
sidecar.BlockMedia[0].MultiMediaCard = new MultiMediaCardType();
break;
case DeviceType.SecureDigital:
sidecar.BlockMedia[0].SecureDigital = new SecureDigitalType();
break;
}
DumpType cidDump = null;
DumpType csdDump = null;
DumpType ocrDump = null;
if (cid != null)
{
cidDump = new DumpType
{
Image = _outputPath, Size = (ulong)cid.Length, Checksums = Checksum.GetChecksums(cid).ToArray()
};
ret =
_outputPlugin.WriteMediaTag(cid,
_dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_CID
: MediaTagType.MMC_CID);
// Cannot write CID to image
if (!ret &&
!_force)
{
_dumpLog.WriteLine("Cannot write CID to output image.");
StoppingErrorMessage?.Invoke("Cannot write CID to output image." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
}
if (csd != null)
{
csdDump = new DumpType
{
Image = _outputPath, Size = (ulong)csd.Length, Checksums = Checksum.GetChecksums(csd).ToArray()
};
ret =
_outputPlugin.WriteMediaTag(csd,
_dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_CSD
: MediaTagType.MMC_CSD);
// Cannot write CSD to image
if (!ret &&
!_force)
{
_dumpLog.WriteLine("Cannot write CSD to output image.");
StoppingErrorMessage?.Invoke("Cannot write CSD to output image." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
}
if (ecsd != null)
{
sidecar.BlockMedia[0].MultiMediaCard.ExtendedCSD = new DumpType
{
Image = _outputPath, Size = (ulong)ecsd.Length,
Checksums = Checksum.GetChecksums(ecsd).ToArray()
};
ret = _outputPlugin.WriteMediaTag(ecsd, MediaTagType.MMC_ExtendedCSD);
// Cannot write Extended CSD to image
if (!ret &&
!_force)
{
_dumpLog.WriteLine("Cannot write Extended CSD to output image.");
StoppingErrorMessage?.Invoke("Cannot write Extended CSD to output image." +
Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
}
if (ocr != null)
{
ocrDump = new DumpType
{
Image = _outputPath, Size = (ulong)ocr.Length, Checksums = Checksum.GetChecksums(ocr).ToArray()
};
ret =
_outputPlugin.WriteMediaTag(ocr,
_dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_OCR
: MediaTagType.MMC_OCR);
// Cannot write OCR to image
if (!ret &&
!_force)
{
_dumpLog.WriteLine("Cannot write OCR to output image.");
StoppingErrorMessage?.Invoke("Cannot write OCR to output image." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
}
if (scr != null)
{
sidecar.BlockMedia[0].SecureDigital.SCR = new DumpType
{
Image = _outputPath, Size = (ulong)scr.Length, Checksums = Checksum.GetChecksums(scr).ToArray()
};
ret = _outputPlugin.WriteMediaTag(scr, MediaTagType.SD_SCR);
// Cannot write SCR to image
if (!ret &&
!_force)
{
_dumpLog.WriteLine("Cannot write SCR to output image.");
StoppingErrorMessage?.Invoke("Cannot write SCR to output image." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
}
switch (_dev.Type)
{
case DeviceType.MMC:
sidecar.BlockMedia[0].MultiMediaCard.CID = cidDump;
sidecar.BlockMedia[0].MultiMediaCard.CSD = csdDump;
sidecar.BlockMedia[0].MultiMediaCard.OCR = ocrDump;
break;
case DeviceType.SecureDigital:
sidecar.BlockMedia[0].SecureDigital.CID = cidDump;
sidecar.BlockMedia[0].SecureDigital.CSD = csdDump;
sidecar.BlockMedia[0].SecureDigital.OCR = ocrDump;
break;
}
end = DateTime.UtcNow;
totalChkDuration = (end - chkStart).TotalMilliseconds;
UpdateStatus?.Invoke($"Sidecar created in {(end - chkStart).TotalSeconds} seconds.");
UpdateStatus?.
Invoke($"Average checksum speed {((double)blockSize * (double)(blocks + 1)) / 1024 / (totalChkDuration / 1000):F3} KiB/sec.");
_dumpLog.WriteLine("Sidecar created in {0} seconds.", (end - chkStart).TotalSeconds);
_dumpLog.WriteLine("Average checksum speed {0:F3} KiB/sec.",
((double)blockSize * (double)(blocks + 1)) / 1024 / (totalChkDuration / 1000));
(string type, string subType)xmlType = (null, null);
switch (_dev.Type)
{
case DeviceType.MMC:
xmlType = CommonTypes.Metadata.MediaType.MediaTypeToString(MediaType.MMC);
sidecar.BlockMedia[0].Dimensions = Dimensions.DimensionsFromMediaType(MediaType.MMC);
break;
case DeviceType.SecureDigital:
CommonTypes.Metadata.MediaType.MediaTypeToString(MediaType.SecureDigital);
sidecar.BlockMedia[0].Dimensions = Dimensions.DimensionsFromMediaType(MediaType.SecureDigital);
break;
}
sidecar.BlockMedia[0].DiskType = xmlType.type;
sidecar.BlockMedia[0].DiskSubType = xmlType.subType;
// TODO: Implement device firmware revision
sidecar.BlockMedia[0].LogicalBlocks = blocks;
sidecar.BlockMedia[0].PhysicalBlockSize = physicalBlockSize > 0 ? physicalBlockSize : blockSize;
sidecar.BlockMedia[0].LogicalBlockSize = blockSize;
sidecar.BlockMedia[0].Manufacturer = _dev.Manufacturer;
sidecar.BlockMedia[0].Model = _dev.Model;
sidecar.BlockMedia[0].Serial = _dev.Serial;
sidecar.BlockMedia[0].Size = blocks * blockSize;
UpdateStatus?.Invoke("Writing metadata sidecar");
var xmlFs = new FileStream(_outputPrefix + ".cicm.xml", FileMode.Create);
var xmlSer = new XmlSerializer(typeof(CICMMetadataType));
xmlSer.Serialize(xmlFs, sidecar);
xmlFs.Close();
}
UpdateStatus?.Invoke("");
UpdateStatus?.
Invoke($"Took a total of {(end - start).TotalSeconds:F3} seconds ({totalDuration / 1000:F3} processing commands, {totalChkDuration / 1000:F3} checksumming, {imageWriteDuration:F3} writing, {(closeEnd - closeStart).TotalSeconds:F3} closing).");
UpdateStatus?.
Invoke($"Average speed: {((double)blockSize * (double)(blocks + 1)) / 1048576 / (totalDuration / 1000):F3} MiB/sec.");
UpdateStatus?.Invoke($"Fastest speed burst: {maxSpeed:F3} MiB/sec.");
UpdateStatus?.Invoke($"Slowest speed burst: {minSpeed:F3} MiB/sec.");
UpdateStatus?.Invoke($"{_resume.BadBlocks.Count} sectors could not be read.");
UpdateStatus?.Invoke("");
if (_resume.BadBlocks.Count > 0)
{
_resume.BadBlocks.Sort();
}
switch (_dev.Type)
{
case DeviceType.MMC:
Statistics.AddMedia(MediaType.MMC, true);
break;
case DeviceType.SecureDigital:
Statistics.AddMedia(MediaType.SecureDigital, true);
break;
}
}
public static int Invoke(bool verbose, bool debug, string encoding, bool filesystems, bool partitions,
string imagePath)
{
MainClass.PrintCopyright();
if (debug)
{
AaruConsole.DebugWriteLineEvent += System.Console.Error.WriteLine;
}
if (verbose)
{
AaruConsole.VerboseWriteLineEvent += System.Console.WriteLine;
}
Statistics.AddCommand("analyze");
AaruConsole.DebugWriteLine("Analyze command", "--debug={0}", debug);
AaruConsole.DebugWriteLine("Analyze command", "--encoding={0}", encoding);
AaruConsole.DebugWriteLine("Analyze command", "--filesystems={0}", filesystems);
AaruConsole.DebugWriteLine("Analyze command", "--input={0}", imagePath);
AaruConsole.DebugWriteLine("Analyze command", "--partitions={0}", partitions);
AaruConsole.DebugWriteLine("Analyze command", "--verbose={0}", verbose);
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(imagePath);
if (inputFilter == null)
{
AaruConsole.ErrorWriteLine("Cannot open specified file.");
return((int)ErrorNumber.CannotOpenFile);
}
Encoding encodingClass = null;
if (encoding != null)
{
try
{
encodingClass = Claunia.Encoding.Encoding.GetEncoding(encoding);
if (verbose)
{
AaruConsole.VerboseWriteLine("Using encoding for {0}.", encodingClass.EncodingName);
}
}
catch (ArgumentException)
{
AaruConsole.ErrorWriteLine("Specified encoding is not supported.");
return((int)ErrorNumber.EncodingUnknown);
}
}
PluginBase plugins = GetPluginBase.Instance;
bool checkRaw = false;
try
{
IMediaImage imageFormat = ImageFormat.Detect(inputFilter);
if (imageFormat == null)
{
AaruConsole.WriteLine("Image format not identified, not proceeding with analysis.");
return((int)ErrorNumber.UnrecognizedFormat);
}
if (verbose)
{
AaruConsole.VerboseWriteLine("Image format identified by {0} ({1}).", imageFormat.Name,
imageFormat.Id);
}
else
{
AaruConsole.WriteLine("Image format identified by {0}.", imageFormat.Name);
}
AaruConsole.WriteLine();
try
{
if (!imageFormat.Open(inputFilter))
{
AaruConsole.WriteLine("Unable to open image format");
AaruConsole.WriteLine("No error given");
return((int)ErrorNumber.CannotOpenFormat);
}
if (verbose)
{
ImageInfo.PrintImageInfo(imageFormat);
AaruConsole.WriteLine();
}
Statistics.AddMediaFormat(imageFormat.Format);
Statistics.AddMedia(imageFormat.Info.MediaType, false);
Statistics.AddFilter(inputFilter.Name);
}
catch (Exception ex)
{
AaruConsole.ErrorWriteLine("Unable to open image format");
AaruConsole.ErrorWriteLine("Error: {0}", ex.Message);
AaruConsole.DebugWriteLine("Analyze command", "Stack trace: {0}", ex.StackTrace);
return((int)ErrorNumber.CannotOpenFormat);
}
List <string> idPlugins;
IFilesystem plugin;
string information;
if (partitions)
{
List <Partition> partitionsList = Core.Partitions.GetAll(imageFormat);
Core.Partitions.AddSchemesToStats(partitionsList);
if (partitionsList.Count == 0)
{
AaruConsole.DebugWriteLine("Analyze command", "No partitions found");
if (!filesystems)
{
AaruConsole.WriteLine("No partitions founds, not searching for filesystems");
return((int)ErrorNumber.NothingFound);
}
checkRaw = true;
}
else
{
AaruConsole.WriteLine("{0} partitions found.", partitionsList.Count);
for (int i = 0; i < partitionsList.Count; i++)
{
AaruConsole.WriteLine();
AaruConsole.WriteLine("Partition {0}:", partitionsList[i].Sequence);
AaruConsole.WriteLine("Partition name: {0}", partitionsList[i].Name);
AaruConsole.WriteLine("Partition type: {0}", partitionsList[i].Type);
AaruConsole.WriteLine("Partition start: sector {0}, byte {1}", partitionsList[i].Start,
partitionsList[i].Offset);
AaruConsole.WriteLine("Partition length: {0} sectors, {1} bytes", partitionsList[i].Length,
partitionsList[i].Size);
AaruConsole.WriteLine("Partition scheme: {0}", partitionsList[i].Scheme);
AaruConsole.WriteLine("Partition description:");
AaruConsole.WriteLine(partitionsList[i].Description);
if (!filesystems)
{
continue;
}
AaruConsole.WriteLine("Identifying filesystem on partition");
Core.Filesystems.Identify(imageFormat, out idPlugins, partitionsList[i]);
if (idPlugins.Count == 0)
{
AaruConsole.WriteLine("Filesystem not identified");
}
else if (idPlugins.Count > 1)
{
AaruConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
foreach (string pluginName in idPlugins)
{
if (plugins.PluginsList.TryGetValue(pluginName, out plugin))
{
AaruConsole.WriteLine($"As identified by {plugin.Name}.");
plugin.GetInformation(imageFormat, partitionsList[i], out information,
encodingClass);
AaruConsole.Write(information);
Statistics.AddFilesystem(plugin.XmlFsType.Type);
}
}
}
else
{
plugins.PluginsList.TryGetValue(idPlugins[0], out plugin);
if (plugin == null)
{
continue;
}
AaruConsole.WriteLine($"Identified by {plugin.Name}.");
plugin.GetInformation(imageFormat, partitionsList[i], out information, encodingClass);
AaruConsole.Write("{0}", information);
Statistics.AddFilesystem(plugin.XmlFsType.Type);
}
}
}
}
if (checkRaw)
{
var wholePart = new Partition
{
Name = "Whole device", Length = imageFormat.Info.Sectors,
Size = imageFormat.Info.Sectors * imageFormat.Info.SectorSize
};
Core.Filesystems.Identify(imageFormat, out idPlugins, wholePart);
if (idPlugins.Count == 0)
{
AaruConsole.WriteLine("Filesystem not identified");
}
else if (idPlugins.Count > 1)
{
AaruConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
foreach (string pluginName in idPlugins)
{
if (plugins.PluginsList.TryGetValue(pluginName, out plugin))
{
AaruConsole.WriteLine($"As identified by {plugin.Name}.");
plugin.GetInformation(imageFormat, wholePart, out information, encodingClass);
AaruConsole.Write(information);
Statistics.AddFilesystem(plugin.XmlFsType.Type);
}
}
}
else
{
plugins.PluginsList.TryGetValue(idPlugins[0], out plugin);
if (plugin != null)
{
AaruConsole.WriteLine($"Identified by {plugin.Name}.");
plugin.GetInformation(imageFormat, wholePart, out information, encodingClass);
AaruConsole.Write(information);
Statistics.AddFilesystem(plugin.XmlFsType.Type);
}
}
}
}
catch (Exception ex)
{
AaruConsole.ErrorWriteLine($"Error reading file: {ex.Message}");
AaruConsole.DebugWriteLine("Analyze command", ex.StackTrace);
return((int)ErrorNumber.UnexpectedException);
}
return((int)ErrorNumber.NoError);
}
protected override string GetValue(Summary summary, BenchmarkCase benchmarkCase, Statistics baseline, Statistics current, bool isBaseline)
{
double mean = isBaseline ? 1 : Statistics.DivMean(current, baseline);
double stdDev = isBaseline ? 0 : Math.Sqrt(Statistics.DivVariance(current, baseline));
switch (Kind)
{
case ScaledKind.Mean:
return(IsNonBaselinesPrecise(summary, baseline, benchmarkCase) ? mean.ToStr("N3") : mean.ToStr("N2"));
case ScaledKind.StdDev:
return(stdDev.ToStr("N2"));
default:
throw new NotSupportedException();
}
}
public static int Invoke(bool debug, bool verbose, string cicmXml, string devicePath, bool resume,
string encoding, bool firstPregap, bool fixOffset, bool force, bool metadata,
bool trim, string outputPath, string options, bool persistent, ushort retryPasses,
uint skip, byte speed, bool stopOnError, string format, string subchannel,
bool @private, bool fixSubchannelPosition, bool retrySubchannel, bool fixSubchannel,
bool fixSubchannelCrc, bool skipCdireadyHole)
{
MainClass.PrintCopyright();
if (debug)
{
AaruConsole.DebugWriteLineEvent += System.Console.Error.WriteLine;
}
if (verbose)
{
AaruConsole.VerboseWriteLineEvent += System.Console.WriteLine;
}
if (fixSubchannelCrc)
{
fixSubchannel = true;
}
if (retrySubchannel || fixSubchannel)
{
fixSubchannelPosition = true;
}
Statistics.AddCommand("dump-media");
AaruConsole.DebugWriteLine("Dump-Media command", "--cicm-xml={0}", cicmXml);
AaruConsole.DebugWriteLine("Dump-Media command", "--debug={0}", debug);
AaruConsole.DebugWriteLine("Dump-Media command", "--device={0}", devicePath);
AaruConsole.DebugWriteLine("Dump-Media command", "--encoding={0}", encoding);
AaruConsole.DebugWriteLine("Dump-Media command", "--first-pregap={0}", firstPregap);
AaruConsole.DebugWriteLine("Dump-Media command", "--fix-offset={0}", fixOffset);
AaruConsole.DebugWriteLine("Dump-Media command", "--force={0}", force);
AaruConsole.DebugWriteLine("Dump-Media command", "--format={0}", format);
AaruConsole.DebugWriteLine("Dump-Media command", "--metadata={0}", metadata);
AaruConsole.DebugWriteLine("Dump-Media command", "--options={0}", options);
AaruConsole.DebugWriteLine("Dump-Media command", "--output={0}", outputPath);
AaruConsole.DebugWriteLine("Dump-Media command", "--persistent={0}", persistent);
AaruConsole.DebugWriteLine("Dump-Media command", "--resume={0}", resume);
AaruConsole.DebugWriteLine("Dump-Media command", "--retry-passes={0}", retryPasses);
AaruConsole.DebugWriteLine("Dump-Media command", "--skip={0}", skip);
AaruConsole.DebugWriteLine("Dump-Media command", "--stop-on-error={0}", stopOnError);
AaruConsole.DebugWriteLine("Dump-Media command", "--trim={0}", trim);
AaruConsole.DebugWriteLine("Dump-Media command", "--verbose={0}", verbose);
AaruConsole.DebugWriteLine("Dump-Media command", "--subchannel={0}", subchannel);
AaruConsole.DebugWriteLine("Dump-Media command", "--private={0}", @private);
AaruConsole.DebugWriteLine("Dump-Media command", "--fix-subchannel-position={0}", fixSubchannelPosition);
AaruConsole.DebugWriteLine("Dump-Media command", "--retry-subchannel={0}", retrySubchannel);
AaruConsole.DebugWriteLine("Dump-Media command", "--fix-subchannel={0}", fixSubchannel);
AaruConsole.DebugWriteLine("Dump-Media command", "--fix-subchannel-crc={0}", fixSubchannelCrc);
AaruConsole.DebugWriteLine("Dump-Media command", "--skip-cdiready-hole={0}", skipCdireadyHole);
// TODO: Disabled temporarily
//AaruConsole.DebugWriteLine("Dump-Media command", "--raw={0}", raw);
Dictionary <string, string> parsedOptions = Core.Options.Parse(options);
AaruConsole.DebugWriteLine("Dump-Media command", "Parsed options:");
foreach (KeyValuePair <string, string> parsedOption in parsedOptions)
{
AaruConsole.DebugWriteLine("Dump-Media command", "{0} = {1}", parsedOption.Key, parsedOption.Value);
}
Encoding encodingClass = null;
if (encoding != null)
{
try
{
encodingClass = Claunia.Encoding.Encoding.GetEncoding(encoding);
if (verbose)
{
AaruConsole.VerboseWriteLine("Using encoding for {0}.", encodingClass.EncodingName);
}
}
catch (ArgumentException)
{
AaruConsole.ErrorWriteLine("Specified encoding is not supported.");
return((int)ErrorNumber.EncodingUnknown);
}
}
DumpSubchannel wantedSubchannel = DumpSubchannel.Any;
switch (subchannel?.ToLowerInvariant())
{
case "any":
case null:
wantedSubchannel = DumpSubchannel.Any;
break;
case "rw":
wantedSubchannel = DumpSubchannel.Rw;
break;
case "rw-or-pq":
wantedSubchannel = DumpSubchannel.RwOrPq;
break;
case "pq":
wantedSubchannel = DumpSubchannel.Pq;
break;
case "none":
wantedSubchannel = DumpSubchannel.None;
break;
default:
AaruConsole.WriteLine("Incorrect subchannel type \"{0}\" requested.", subchannel);
break;
}
if (devicePath.Length == 2 &&
devicePath[1] == ':' &&
devicePath[0] != '/' &&
char.IsLetter(devicePath[0]))
{
devicePath = "\\\\.\\" + char.ToUpper(devicePath[0]) + ':';
}
Devices.Device dev;
try
{
dev = new Devices.Device(devicePath);
if (dev.IsRemote)
{
Statistics.AddRemote(dev.RemoteApplication, dev.RemoteVersion, dev.RemoteOperatingSystem,
dev.RemoteOperatingSystemVersion, dev.RemoteArchitecture);
}
if (dev.Error)
{
AaruConsole.ErrorWriteLine(Error.Print(dev.LastError));
return((int)ErrorNumber.CannotOpenDevice);
}
}
catch (DeviceException e)
{
AaruConsole.ErrorWriteLine(e.Message ?? Error.Print(e.LastError));
return((int)ErrorNumber.CannotOpenDevice);
}
Statistics.AddDevice(dev);
string outputPrefix = Path.Combine(Path.GetDirectoryName(outputPath),
Path.GetFileNameWithoutExtension(outputPath));
Resume resumeClass = null;
var xs = new XmlSerializer(typeof(Resume));
if (File.Exists(outputPrefix + ".resume.xml") && resume)
{
try
{
var sr = new StreamReader(outputPrefix + ".resume.xml");
resumeClass = (Resume)xs.Deserialize(sr);
sr.Close();
}
catch
{
AaruConsole.ErrorWriteLine("Incorrect resume file, not continuing...");
return((int)ErrorNumber.InvalidResume);
}
}
if (resumeClass != null &&
resumeClass.NextBlock > resumeClass.LastBlock &&
resumeClass.BadBlocks.Count == 0 &&
!resumeClass.Tape &&
(resumeClass.BadSubchannels is null || resumeClass.BadSubchannels.Count == 0))
{
AaruConsole.WriteLine("Media already dumped correctly, not continuing...");
return((int)ErrorNumber.AlreadyDumped);
}
CICMMetadataType sidecar = null;
var sidecarXs = new XmlSerializer(typeof(CICMMetadataType));
if (cicmXml != null)
{
if (File.Exists(cicmXml))
{
try
{
var sr = new StreamReader(cicmXml);
sidecar = (CICMMetadataType)sidecarXs.Deserialize(sr);
sr.Close();
}
catch
{
AaruConsole.ErrorWriteLine("Incorrect metadata sidecar file, not continuing...");
return((int)ErrorNumber.InvalidSidecar);
}
}
else
{
AaruConsole.ErrorWriteLine("Could not find metadata sidecar, not continuing...");
return((int)ErrorNumber.FileNotFound);
}
}
PluginBase plugins = GetPluginBase.Instance;
List <IWritableImage> candidates = new List <IWritableImage>();
// Try extension
if (string.IsNullOrEmpty(format))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t =>
t.KnownExtensions.
Contains(Path.GetExtension(outputPath))));
}
// Try Id
else if (Guid.TryParse(format, out Guid outId))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => t.Id.Equals(outId)));
}
// Try name
else
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => string.Equals(t.Name, format,
StringComparison.
InvariantCultureIgnoreCase)));
}
if (candidates.Count == 0)
{
AaruConsole.WriteLine("No plugin supports requested extension.");
return((int)ErrorNumber.FormatNotFound);
}
if (candidates.Count > 1)
{
AaruConsole.WriteLine("More than one plugin supports requested extension.");
return((int)ErrorNumber.TooManyFormats);
}
IWritableImage outputFormat = candidates[0];
var dumpLog = new DumpLog(outputPrefix + ".log", dev, @private);
if (verbose)
{
dumpLog.WriteLine("Output image format: {0} ({1}).", outputFormat.Name, outputFormat.Id);
AaruConsole.VerboseWriteLine("Output image format: {0} ({1}).", outputFormat.Name, outputFormat.Id);
}
else
{
dumpLog.WriteLine("Output image format: {0}.", outputFormat.Name);
AaruConsole.WriteLine("Output image format: {0}.", outputFormat.Name);
}
var dumper = new Dump(resume, dev, devicePath, outputFormat, retryPasses, force, false, persistent,
stopOnError, resumeClass, dumpLog, encodingClass, outputPrefix, outputPath,
parsedOptions, sidecar, skip, metadata, trim, firstPregap, fixOffset, debug,
wantedSubchannel, speed, @private, fixSubchannelPosition, retrySubchannel,
fixSubchannel, fixSubchannelCrc, skipCdireadyHole);
dumper.UpdateStatus += Progress.UpdateStatus;
dumper.ErrorMessage += Progress.ErrorMessage;
dumper.StoppingErrorMessage += Progress.ErrorMessage;
dumper.UpdateProgress += Progress.UpdateProgress;
dumper.PulseProgress += Progress.PulseProgress;
dumper.InitProgress += Progress.InitProgress;
dumper.EndProgress += Progress.EndProgress;
dumper.InitProgress2 += Progress.InitProgress2;
dumper.EndProgress2 += Progress.EndProgress2;
dumper.UpdateProgress2 += Progress.UpdateProgress2;
System.Console.CancelKeyPress += (sender, e) =>
{
e.Cancel = true;
dumper.Abort();
};
dumper.Start();
dev.Close();
return((int)ErrorNumber.NoError);
}
protected void OnMenuOpen(object sender, EventArgs e)
{
// TODO: Extensions
OpenFileDialog dlgOpenImage = new OpenFileDialog {
Title = "Choose image to open"
};
DialogResult result = dlgOpenImage.ShowDialog(this);
if (result != DialogResult.Ok)
{
return;
}
FiltersList filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(dlgOpenImage.FileName);
if (inputFilter == null)
{
MessageBox.Show("Cannot open specified file.", MessageBoxType.Error);
return;
}
try
{
IMediaImage imageFormat = ImageFormat.Detect(inputFilter);
if (imageFormat == null)
{
MessageBox.Show("Image format not identified.", MessageBoxType.Error);
return;
}
DicConsole.WriteLine("Image format identified by {0} ({1}).", imageFormat.Name, imageFormat.Id);
try
{
if (!imageFormat.Open(inputFilter))
{
MessageBox.Show("Unable to open image format", MessageBoxType.Error);
DicConsole.ErrorWriteLine("Unable to open image format");
DicConsole.ErrorWriteLine("No error given");
return;
}
// TODO: SVG
Stream logo =
ResourceHandler
.GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{imageFormat.Info.MediaType}.png");
TreeGridItem imageGridItem = new TreeGridItem
{
Values = new object[]
{
logo == null ? null : new Bitmap(logo),
$"{Path.GetFileName(dlgOpenImage.FileName)} ({imageFormat.Info.MediaType})",
dlgOpenImage.FileName,
new pnlImageInfo(dlgOpenImage.FileName, inputFilter, imageFormat), inputFilter,
imageFormat
}
};
List <Partition> partitions = Core.Partitions.GetAll(imageFormat);
Core.Partitions.AddSchemesToStats(partitions);
bool checkraw = false;
List <string> idPlugins;
IFilesystem plugin;
PluginBase plugins = GetPluginBase.Instance;
if (partitions.Count == 0)
{
DicConsole.DebugWriteLine("Analyze command", "No partitions found");
checkraw = true;
}
else
{
DicConsole.WriteLine("{0} partitions found.", partitions.Count);
foreach (string scheme in partitions.Select(p => p.Scheme).Distinct().OrderBy(s => s))
{
TreeGridItem schemeGridItem = new TreeGridItem
{
Values = new object[]
{
nullImage, // TODO: Add icons to partition schemes
scheme
}
};
foreach (Partition partition in partitions
.Where(p => p.Scheme == scheme).OrderBy(p => p.Start))
{
TreeGridItem partitionGridItem = new TreeGridItem
{
Values = new object[]
{
nullImage, // TODO: Add icons to partition schemes
$"{partition.Name} ({partition.Type})", null, new pnlPartition(partition)
}
};
DicConsole.WriteLine("Identifying filesystem on partition");
Core.Filesystems.Identify(imageFormat, out idPlugins, partition);
if (idPlugins.Count == 0)
{
DicConsole.WriteLine("Filesystem not identified");
}
else
{
DicConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
foreach (string pluginName in idPlugins)
{
if (plugins.PluginsList.TryGetValue(pluginName, out plugin))
{
plugin.GetInformation(imageFormat, partition, out string information, null);
IReadOnlyFilesystem fsPlugin = plugin as IReadOnlyFilesystem;
if (fsPlugin != null)
{
Errno error =
fsPlugin.Mount(imageFormat, partition, null,
new Dictionary <string, string>(), null);
if (error != Errno.NoError)
{
fsPlugin = null;
}
}
TreeGridItem filesystemGridItem = new TreeGridItem
{
Values = new object[]
{
nullImage, // TODO: Add icons to filesystems
plugin.XmlFsType.VolumeName is null
? $"{plugin.XmlFsType.Type}"
: $"{plugin.XmlFsType.VolumeName} ({plugin.XmlFsType.Type})",
fsPlugin, new pnlFilesystem(plugin.XmlFsType, information)
}
};
if (fsPlugin != null)
{
Statistics.AddCommand("ls");
filesystemGridItem.Children.Add(placeholderItem);
}
Statistics.AddFilesystem(plugin.XmlFsType.Type);
partitionGridItem.Children.Add(filesystemGridItem);
}
}
}
schemeGridItem.Children.Add(partitionGridItem);
}
imageGridItem.Children.Add(schemeGridItem);
}
}
if (checkraw)
{
Partition wholePart = new Partition
{
Name = "Whole device",
Length = imageFormat.Info.Sectors,
Size = imageFormat.Info.Sectors * imageFormat.Info.SectorSize
};
Core.Filesystems.Identify(imageFormat, out idPlugins, wholePart);
if (idPlugins.Count == 0)
{
DicConsole.WriteLine("Filesystem not identified");
}
else
{
DicConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
foreach (string pluginName in idPlugins)
{
if (plugins.PluginsList.TryGetValue(pluginName, out plugin))
{
plugin.GetInformation(imageFormat, wholePart, out string information, null);
IReadOnlyFilesystem fsPlugin = plugin as IReadOnlyFilesystem;
if (fsPlugin != null)
{
Errno error = fsPlugin.Mount(imageFormat, wholePart, null,
new Dictionary <string, string>(), null);
if (error != Errno.NoError)
{
fsPlugin = null;
}
}
TreeGridItem filesystemGridItem = new TreeGridItem
{
Values = new object[]
{
nullImage, // TODO: Add icons to filesystems
plugin.XmlFsType.VolumeName is null
? $"{plugin.XmlFsType.Type}"
: $"{plugin.XmlFsType.VolumeName} ({plugin.XmlFsType.Type})",
fsPlugin, new pnlFilesystem(plugin.XmlFsType, information)
}
};
if (fsPlugin != null)
{
Statistics.AddCommand("ls");
filesystemGridItem.Children.Add(placeholderItem);
}
Statistics.AddFilesystem(plugin.XmlFsType.Type);
imageGridItem.Children.Add(filesystemGridItem);
}
}
}
}
imagesRoot.Children.Add(imageGridItem);
treeImages.ReloadData();
Statistics.AddMediaFormat(imageFormat.Format);
Statistics.AddMedia(imageFormat.Info.MediaType, false);
Statistics.AddFilter(inputFilter.Name);
}
public void Add(Statistics stats)
{
CachedStatistics = stats;
}
public async Task GetTimesheettatisticsAsyncShouldQueryDocument()
{
var storageService = Substitute.For <IStorageService>();
var stat1 = new Statistics <TimesheetStatistics[]>
{
Date = "2020-08-14",
Time = "20:00",
Data = new TimesheetStatistics[]
{
new TimesheetStatistics
{
DepartmentName = ".NET",
State = TimesheetStates.Unsubmitted,
},
new TimesheetStatistics
{
DepartmentName = ".NET",
State = TimesheetStates.Unsubmitted,
},
new TimesheetStatistics
{
DepartmentName = "QA",
State = TimesheetStates.Unsubmitted,
},
}
};
var stat2 = new Statistics <TimesheetStatistics[]>
{
Date = "2020-08-07",
Time = "20:00",
Data = new TimesheetStatistics[]
{
new TimesheetStatistics
{
DepartmentName = ".NET",
State = TimesheetStates.Unsubmitted,
},
new TimesheetStatistics
{
DepartmentName = "QA",
State = TimesheetStates.Unsubmitted,
},
}
};
var stats3 = new Statistics <TimesheetStatistics[]> [0];
var context = MockFunction.GetContext(
new ServiceDescriptor(typeof(IStorageService), storageService),
GetAccessTokenServiceDescriptor());
var request = MockFunction.GetRequest(null, context);
SetUserRole(request, UserRoles.User);
storageService.GetStatisticsAsync <TimesheetStatistics[]>(null, null)
.ReturnsForAnyArgs(new[] { stat1 }, new[] { stat2 }, stats3);
var result = await Queries.GetTimesheetStatisticsAsync(request, context);
var array = result.ToArray();
Assert.AreEqual(4, array.Length);
Assert.AreEqual("QA", array[0].Department);
Assert.AreEqual(1, array[0].Count);
Assert.AreEqual(".NET", array[1].Department);
Assert.AreEqual(1, array[1].Count);
Assert.AreEqual("QA", array[2].Department);
Assert.AreEqual(1, array[2].Count);
Assert.AreEqual(".NET", array[3].Department);
Assert.AreEqual(2, array[3].Count);
}
public RetentionTimeSummary(Statistics statistics) : base(statistics)
{
Min = statistics.Min();
Max = statistics.Max();
}
public AreaNormalizedSummary(Statistics statistics) : base(statistics)
{
}
public AreaRatioSummary(Statistics statistics) : base(statistics)
{
}
private void OnValidate()
{
bool reloadModel = false;
statistics = new Statistics();
if (material != Enums.eMaterial.NONE)
{
statistics += MaterialsDB.List[(int)material].statistics;
if (_material != (int)material)
{
reloadModel = true;
}
_material = (int)material;
}
if (category == Enums.eBladeCategory.DAGGER && dagger != Enums.eDaggerBlade.None)
{
_bladeId = (ushort)dagger;
}
else if (category == Enums.eBladeCategory.SWORD && sword != Enums.eSwordBlade.None)
{
_bladeId = (ushort)sword;
}
else if (category == Enums.eBladeCategory.GREAT_SWORD && greatSword != Enums.eGreatSwordBlade.None)
{
_bladeId = (ushort)greatSword;
}
else if (category == Enums.eBladeCategory.AXE && axe != Enums.eAxeBlade.None)
{
_bladeId = (ushort)axe;
}
else if (category == Enums.eBladeCategory.MACE && mace != Enums.eMaceBlade.None)
{
_bladeId = (ushort)mace;
}
else if (category == Enums.eBladeCategory.GREAT_AXE && greatAxe != Enums.eGreatAxeBlade.None)
{
_bladeId = (ushort)greatAxe;
}
else if (category == Enums.eBladeCategory.STAFF && staff != Enums.eStaffBlade.None)
{
_bladeId = (ushort)staff;
}
else if (category == Enums.eBladeCategory.HEAVY_MACE && heavyMace != Enums.eHeavyMaceBlade.None)
{
_bladeId = (ushort)heavyMace;
}
else if (category == Enums.eBladeCategory.POLEARM && polearm != Enums.ePolearmBlade.None)
{
_bladeId = (ushort)polearm;
}
else if (category == Enums.eBladeCategory.CROSSBOW && crossbow != Enums.eCrossbowBlade.None)
{
_bladeId = (ushort)crossbow;
}
else if (category == Enums.eBladeCategory.SHIELD && shield != Enums.eShield.None)
{
_bladeId = (ushort)shield;
}
if (category != Enums.eBladeCategory.SHIELD)
{
if (_bladeId > 0)
{
statistics += BladesDB.List[_bladeId].statistics;
if (_modelId != BladesDB.List[_bladeId].wepID)
{
_modelId = BladesDB.List[_bladeId].wepID;
reloadModel = true;
}
}
}
else
{
if (_bladeId > 0)
{
statistics += ArmorsDB.ShieldList[_bladeId - 90].statistics;
}
if (_modelId != ArmorsDB.ShieldList[_bladeId - 90].wepID)
{
_modelId = ArmorsDB.ShieldList[_bladeId - 90].wepID;
reloadModel = true;
}
}
if (category == Enums.eBladeCategory.DAGGER || category == Enums.eBladeCategory.SWORD || category == Enums.eBladeCategory.GREAT_SWORD)
{
gripType = Enums.eGripCategory.Guard;
grip = Enums.eGrip.None;
pole = Enums.ePole.None;
bolt = Enums.eBolt.None;
if (guard != Enums.eGuard.None)
{
_gripId = (ushort)guard;
gemSlot = GripsDB.List[_gripId].gemSlots;
statistics += GripsDB.List[_gripId].statistics;
}
else
{
gemSlot = 0;
}
RefreshGemSlots();
}
else if (category == Enums.eBladeCategory.AXE || category == Enums.eBladeCategory.MACE || category == Enums.eBladeCategory.GREAT_AXE ||
category == Enums.eBladeCategory.STAFF || category == Enums.eBladeCategory.HEAVY_MACE)
{
gripType = Enums.eGripCategory.Grip;
guard = Enums.eGuard.None;
pole = Enums.ePole.None;
bolt = Enums.eBolt.None;
if (grip != Enums.eGrip.None)
{
_gripId = (ushort)grip;
gemSlot = GripsDB.List[_gripId].gemSlots;
statistics += GripsDB.List[_gripId].statistics;
}
else
{
gemSlot = 0;
}
RefreshGemSlots();
}
else if (category == Enums.eBladeCategory.POLEARM)
{
gripType = Enums.eGripCategory.Pole;
guard = Enums.eGuard.None;
grip = Enums.eGrip.None;
bolt = Enums.eBolt.None;
if (pole != Enums.ePole.None)
{
_gripId = (ushort)pole;
gemSlot = GripsDB.List[_gripId].gemSlots;
statistics += GripsDB.List[_gripId].statistics;
}
else
{
gemSlot = 0;
}
RefreshGemSlots();
}
else if (category == Enums.eBladeCategory.CROSSBOW)
{
gripType = Enums.eGripCategory.Bolt;
guard = Enums.eGuard.None;
grip = Enums.eGrip.None;
pole = Enums.ePole.None;
if (bolt != Enums.eBolt.None)
{
_gripId = (ushort)bolt;
gemSlot = GripsDB.List[_gripId].gemSlots;
statistics += GripsDB.List[_gripId].statistics;
}
else
{
gemSlot = 0;
}
RefreshGemSlots();
}
else if (category == Enums.eBladeCategory.SHIELD)
{
// shields have no grip, but have gem slots
_gripId = 0;
gripType = Enums.eGripCategory.None;
guard = Enums.eGuard.None;
grip = Enums.eGrip.None;
pole = Enums.ePole.None;
bolt = Enums.eBolt.None;
if (shield != Enums.eShield.None)
{
gemSlot = ArmorsDB.ShieldList[(int)shield - 90].gemSlots;
}
else
{
gemSlot = 0;
}
RefreshGemSlots();
}
else
{
_gripId = 0;
gripType = Enums.eGripCategory.None;
guard = Enums.eGuard.None;
grip = Enums.eGrip.None;
pole = Enums.ePole.None;
bolt = Enums.eBolt.None;
gemSlot = 0;
RefreshGemSlots();
}
if (reloadModel)
{
//LoadWEPModel(_modelId);
}
}
/// <summary>
/// i don't cache images because i don't wanna store a lot of SKCanvas in the memory
/// </summary>
/// <returns>true if an icon has been drawn</returns>
public static bool TryDrawIcon(string assetPath, FName[] exportTypes, IUExport[] exports)
{
var d = new DirectoryInfo(assetPath);
string assetName = d.Name;
string assetFolder = d.Parent.Name;
if (Text.TypeFaces.NeedReload(false))
{
Text.TypeFaces = new Typefaces(); // when opening bundle creator settings without loading paks first
}
int index = Globals.Game.ActualGame == EGame.Valorant || Globals.Game.ActualGame == EGame.Spellbreak ? 1 : 0;
string exportType = exportTypes.Length > index ? exportTypes[index].String : string.Empty;
switch (exportType)
{
case "AthenaConsumableEmoteItemDefinition":
case "AthenaSkyDiveContrailItemDefinition":
case "AthenaLoadingScreenItemDefinition":
case "AthenaVictoryPoseItemDefinition":
case "AthenaPetCarrierItemDefinition":
case "AthenaMusicPackItemDefinition":
case "AthenaBattleBusItemDefinition":
case "AthenaCharacterItemDefinition":
case "AthenaBackpackItemDefinition":
case "AthenaPickaxeItemDefinition":
case "AthenaGadgetItemDefinition":
case "AthenaGliderItemDefinition":
case "AthenaDailyQuestDefinition":
case "AthenaSprayItemDefinition":
case "AthenaDanceItemDefinition":
case "AthenaEmojiItemDefinition":
case "AthenaItemWrapDefinition":
case "AthenaToyItemDefinition":
case "FortHeroType":
case "FortTokenType":
case "FortAbilityKit":
case "FortWorkerType":
case "RewardGraphToken":
case "FortBannerTokenType":
case "FortVariantTokenType":
case "FortDecoItemDefinition":
case "FortFeatItemDefinition":
case "FortStatItemDefinition":
case "FortTrapItemDefinition":
case "FortAmmoItemDefinition":
case "FortQuestItemDefinition":
case "FortBadgeItemDefinition":
case "FortAwardItemDefinition":
case "FortGadgetItemDefinition":
case "FortPlaysetItemDefinition":
case "FortGiftBoxItemDefinition":
case "FortSpyTechItemDefinition":
case "FortOutpostItemDefinition":
case "FortAccoladeItemDefinition":
case "FortCardPackItemDefinition":
case "FortDefenderItemDefinition":
case "FortCurrencyItemDefinition":
case "FortResourceItemDefinition":
case "FortCodeTokenItemDefinition":
case "FortSchematicItemDefinition":
case "FortExpeditionItemDefinition":
case "FortIngredientItemDefinition":
case "FortAccountBuffItemDefinition":
case "FortWeaponMeleeItemDefinition":
case "FortContextTrapItemDefinition":
case "FortPlayerPerksItemDefinition":
case "FortPlaysetPropItemDefinition":
case "FortHomebaseNodeItemDefinition":
case "FortWeaponRangedItemDefinition":
case "FortNeverPersistItemDefinition":
case "RadioContentSourceItemDefinition":
case "FortPlaysetGrenadeItemDefinition":
case "FortPersonalVehicleItemDefinition":
case "FortGameplayModifierItemDefinition":
case "FortHardcoreModifierItemDefinition":
case "FortConsumableAccountItemDefinition":
case "FortConversionControlItemDefinition":
case "FortAccountBuffCreditItemDefinition":
case "FortPersistentResourceItemDefinition":
case "FortHomebaseBannerIconItemDefinition":
case "FortCampaignHeroLoadoutItemDefinition":
case "FortConditionalResourceItemDefinition":
case "FortChallengeBundleScheduleDefinition":
case "FortWeaponMeleeDualWieldItemDefinition":
case "FortDailyRewardScheduleTokenDefinition":
case "FortCreativeRealEstatePlotItemDefinition":
{
BaseIcon icon = new BaseIcon(exports[index], exportType, ref assetName);
int height = icon.Size + icon.AdditionalSize;
using (var ret = new SKBitmap(icon.Size, height, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
Rarity.DrawRarity(c, icon);
}
LargeSmallImage.DrawPreviewImage(c, icon);
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoText)
{
Text.DrawBackground(c, icon);
Text.DrawDisplayName(c, icon);
Text.DrawDescription(c, icon);
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.Mini)
{
if (!icon.ShortDescription.Equals(icon.DisplayName) && !icon.ShortDescription.Equals(icon.Description))
{
Text.DrawToBottom(c, icon, ETextSide.Left, icon.ShortDescription);
}
Text.DrawToBottom(c, icon, ETextSide.Right, icon.CosmeticSource);
}
}
UserFacingFlag.DrawUserFacingFlags(c, icon);
// has more things to show
if (height > icon.Size)
{
Statistics.DrawStats(c, icon);
}
}
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "FortPlaylistAthena":
{
BasePlaylist icon = new BasePlaylist(exports[index]);
using (var ret = new SKBitmap(icon.Width, icon.Height, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
Rarity.DrawRarity(c, icon);
}
LargeSmallImage.DrawPreviewImage(c, icon);
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoText)
{
Text.DrawBackground(c, icon);
Text.DrawDisplayName(c, icon);
Text.DrawDescription(c, icon);
}
}
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "AthenaSeasonItemDefinition":
{
BaseSeason icon = new BaseSeason(exports[index], assetFolder);
using (var ret = new SKBitmap(icon.Width, icon.HeaderHeight + icon.AdditionalSize, SKColorType.Rgba8888, SKAlphaType.Opaque))
using (var c = new SKCanvas(ret))
{
icon.Draw(c);
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "FortMtxOfferData":
{
BaseOffer icon = new BaseOffer(exports[index]);
using (var ret = new SKBitmap(icon.Size, icon.Size, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
icon.DrawBackground(c);
}
icon.DrawImage(c);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "MaterialInstanceConstant":
{
if (assetFolder.Equals("MI_OfferImages"))
{
BaseOfferMaterial icon = new BaseOfferMaterial(exports[index]);
using (var ret = new SKBitmap(icon.Size, icon.Size, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
icon.DrawBackground(c);
}
icon.DrawImage(c);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
return(false);
}
case "FortItemSeriesDefinition":
{
BaseIcon icon = new BaseIcon();
using (var ret = new SKBitmap(icon.Size, icon.Size, SKColorType.Rgba8888, SKAlphaType.Opaque))
using (var c = new SKCanvas(ret))
{
Serie.GetRarity(icon, exports[index]);
Rarity.DrawRarity(c, icon);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "PlaylistUserOptionEnum":
case "PlaylistUserOptionBool":
case "PlaylistUserOptionString":
case "PlaylistUserOptionIntEnum":
case "PlaylistUserOptionIntRange":
case "PlaylistUserOptionColorEnum":
case "PlaylistUserOptionFloatEnum":
case "PlaylistUserOptionFloatRange":
case "PlaylistUserOptionPrimaryAsset":
case "PlaylistUserOptionCollisionProfileEnum":
{
BaseUserOption icon = new BaseUserOption(exports[index]);
using (var ret = new SKBitmap(icon.Width, icon.Height, SKColorType.Rgba8888, SKAlphaType.Opaque))
using (var c = new SKCanvas(ret))
{
icon.Draw(c);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "FortChallengeBundleItemDefinition":
{
BaseBundle icon = new BaseBundle(exports[index], assetFolder);
using (var ret = new SKBitmap(icon.Width, icon.HeaderHeight + icon.AdditionalSize, SKColorType.Rgba8888, SKAlphaType.Opaque))
using (var c = new SKCanvas(ret))
{
HeaderStyle.DrawHeaderPaint(c, icon);
HeaderStyle.DrawHeaderText(c, icon);
QuestStyle.DrawQuests(c, icon);
QuestStyle.DrawCompletionRewards(c, icon);
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "FortItemAccessTokenType":
{
BaseItemAccess icon = new BaseItemAccess(exports[index]);
using (var ret = new SKBitmap(icon.Size, icon.Size, SKColorType.Rgba8888, SKAlphaType.Opaque))
using (var c = new SKCanvas(ret))
{
icon.Draw(c);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "MapUIData":
{
BaseMapUIData icon = new BaseMapUIData(exports[index]);
using (var ret = new SKBitmap(icon.Width, icon.Height, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
icon.Draw(c);
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
case "ArmorUIData":
case "SprayUIData":
case "ThemeUIData":
case "ContractUIData":
case "CurrencyUIData":
case "GameModeUIData":
case "CharacterUIData":
case "SprayLevelUIData":
case "EquippableUIData":
case "PlayerCardUIData":
case "Gun_UIData_Base_C":
case "CharacterRoleUIData":
case "EquippableSkinUIData":
case "EquippableCharmUIData":
case "EquippableSkinLevelUIData":
case "EquippableSkinChromaUIData":
case "EquippableCharmLevelUIData":
{
BaseUIData icon = new BaseUIData(exports, index);
using (var ret = new SKBitmap(icon.Width + icon.AdditionalWidth, icon.Height, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
icon.Draw(c);
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
//case "StreamedVideoDataAsset": // must find a way to automatically gets the right version in the url
// {
// if (Globals.Game.ActualGame == EGame.Valorant && exports[index].GetExport<StructProperty>("Uuid") is StructProperty s && s.Value is FGuid uuid)
// {
// Process.Start(new ProcessStartInfo
// {
// FileName = string.Format(
// "http://valorant.dyn.riotcdn.net/x/videos/release-01.05/{0}_default_universal.mp4",
// $"{uuid.A:x8}-{uuid.B >> 16:x4}-{uuid.B & 0xFFFF:x4}-{uuid.C >> 16:x4}-{uuid.C & 0xFFFF:x4}{uuid.D:x8}"),
// UseShellExecute = true
// });
// }
// return false;
// }
case "GAccolade":
case "GCosmeticSkin":
case "GCosmeticCard":
case "GCosmeticTitle":
case "GCosmeticBadge":
case "GCosmeticEmote":
case "GCosmeticTriumph":
case "GCosmeticRunTrail":
case "GCosmeticArtifact":
case "GCosmeticDropTrail":
{
BaseGCosmetic icon = new BaseGCosmetic(exports[index], exportType);
using (var ret = new SKBitmap(icon.Width, icon.Height, SKColorType.Rgba8888, SKAlphaType.Premul))
using (var c = new SKCanvas(ret))
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign == EIconDesign.Flat)
{
icon.Draw(c);
}
else
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
Rarity.DrawRarity(c, icon);
}
}
LargeSmallImage.DrawPreviewImage(c, icon);
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoBackground)
{
if ((EIconDesign)Properties.Settings.Default.AssetsIconDesign != EIconDesign.NoText)
{
Text.DrawBackground(c, icon);
Text.DrawDisplayName(c, icon);
Text.DrawDescription(c, icon);
}
}
Watermark.DrawWatermark(c); // watermark should only be applied on icons with width = 512
ImageBoxVm.imageBoxViewModel.Set(ret, assetName);
}
return(true);
}
}
return(false);
}
private void Update(IEntity entity, ITypeFieldValueList valueTypeList, Type type, ITransaction tx)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(type);
ICollection <EntityFieldValue> keys = new List <EntityFieldValue>();
ICollection <EntityFieldValue> values = new List <EntityFieldValue>();
StringBuilder logSb = new StringBuilder();
string query;
if (entityInfo.TableInfo.UpdateStrategy == UpdateStrategy.ChangedColumns)
{
values = GetModifiedFieldValues(entity, type);
if (values.Count == 0)
{
return;
}
keys = OperationUtils.ExtractEntityKeyValues(entity).FieldValues;
ICollection <IColumn> keysAndModified = new List <IColumn>();
foreach (EntityFieldValue fieldValue in values)
{
keysAndModified.Add(fieldValue.Column);
}
foreach (EntityFieldValue fieldValue in keys)
{
keysAndModified.Add(fieldValue.Column);
}
query = DbLayer.DataManipulate().CreateUpdateQuery(entityInfo.TableInfo.TableName, keysAndModified);
}
else
{
query = entityInfo.GetUpdateQuery(DbLayer);
foreach (EntityFieldValue fieldValue in valueTypeList.FieldValues)
{
if (fieldValue.Column.Key)
{
keys.Add(fieldValue);
}
else
{
values.Add(fieldValue);
}
}
}
bool showQuery = Config.ShowQueries;
if (showQuery)
{
logSb.Append(query);
}
IDbCommand cmd = tx.CreateCommand();
cmd.CommandText = query;
int count = 0;
foreach (EntityFieldValue fieldValue in values)
{
if (showQuery)
{
logSb.Append(" ,").Append(fieldValue.Column.ColumnName).Append("=").Append(fieldValue.Value);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue.Value, ++count, fieldValue.Column);
}
foreach (EntityFieldValue fieldValue in keys)
{
if (showQuery)
{
logSb.Append(" ,").Append(fieldValue.Column.ColumnName).Append("=").Append(fieldValue.Value);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue.Value, ++count, fieldValue.Column);
}
if (showQuery)
{
Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
}
if (Config.EnableStatistics)
{
Statistics.RegisterUpdate(type);
}
cmd.ExecuteNonQuery();
DbMgtUtility.Close(cmd);
}
/// <inheritdoc />
public async Task <Playlist> GetPlaylistAsync(string playlistId, int maxPages)
{
playlistId.GuardNotNull(nameof(playlistId));
maxPages.GuardPositive(nameof(maxPages));
if (!ValidatePlaylistId(playlistId))
{
throw new ArgumentException($"Invalid YouTube playlist ID [{playlistId}].", nameof(playlistId));
}
// Get parser for the first page
var parser = await GetPlaylistAjaxParserAsync(playlistId, 0);
// Parse info
var author = parser.ParseAuthor();
var title = parser.ParseTitle();
var description = parser.ParseDescription();
var viewCount = parser.ParseViewCount();
var likeCount = parser.ParseLikeCount();
var dislikeCount = parser.ParseDislikeCount();
// Parse videos from all pages
var page = 0;
var index = 0;
var videoIds = new HashSet <string>();
var videos = new List <Video>();
do
{
// Parse videos
var countTotal = 0;
var countDelta = 0;
foreach (var videoParser in parser.GetVideos())
{
// Parse info
var videoId = videoParser.ParseId();
var videoAuthor = videoParser.ParseAuthor();
var videoUploadDate = videoParser.ParseUploadDate();
var videoTitle = videoParser.ParseTitle();
var videoDescription = videoParser.ParseDescription();
var videoDuration = videoParser.ParseDuration();
var videoKeywords = videoParser.ParseKeywords();
var videoViewCount = videoParser.ParseViewCount();
var videoLikeCount = videoParser.ParseLikeCount();
var videoDislikeCount = videoParser.ParseDislikeCount();
var videoStatistics = new Statistics(videoViewCount, videoLikeCount, videoDislikeCount);
var videoThumbnails = new ThumbnailSet(videoId);
var video = new Video(videoId, videoAuthor, videoUploadDate, videoTitle, videoDescription,
videoThumbnails, videoDuration, videoKeywords, videoStatistics);
// Add video to the list if it's not already there
if (videoIds.Add(video.Id))
{
videos.Add(video);
countDelta++;
}
countTotal++;
}
// Break if no distinct videos were added to the list
if (countDelta <= 0)
{
break;
}
// Prepare for the next page
page++;
index += countTotal;
// Get parser for the next page
parser = await GetPlaylistAjaxParserAsync(playlistId, index);
} while (page < maxPages);
var statistics = new Statistics(viewCount, likeCount, dislikeCount);
return(new Playlist(playlistId, author, title, description, statistics, videos));
}
public FwhmSummary(Statistics statistics) : base(statistics)
{
}
public void Reset()
{
CachedStatistics = null;
}
public async ValueTask <IActionResult> GetUserStats(int id)
{
var data = await _repo.Item().Where(uc => uc.Id == id)
.Include(uc => uc.UserTests)
.ThenInclude(ut => ut.UserQuizzes)
.Include(uc => uc.UserTests)
.ThenInclude(ut => ut.UserVideos)
.Include(uc => uc.UserTests)
.ThenInclude(ut => ut.Test)
.FirstOrDefaultAsync();
var tests = await _test.Item().Where(c => c.CourseId == data.CourseId)
.Include(c => c.Videos)
.Include(c => c.Quizes)
.Select(c => new { c.Id, Quizzes = c.Quizes.Count, Videos = c.Videos.Count })
.ToListAsync();
float allQuizzes, allVideos, userQuizzes, userVideos, possiblePoints, userPoint, percentQuiz, percentVideo, percentMastery = 0;
var activities = new List <Activity>();
if (data != null)
{
allQuizzes = tests.Aggregate(0, (aggregate, current) =>
{
aggregate += current.Quizzes;
return(aggregate);
});
allVideos = tests.Aggregate(0, (aggregate, current) =>
{
aggregate += current.Videos;
return(aggregate);
});
userQuizzes = data.UserTests.Aggregate(0, (aggregate, current) =>
{
aggregate += current.UserQuizzes.Where(u => u.Mode == Mode.Free).Count();
return(aggregate);
});
userVideos = data.UserTests.Aggregate(0, (aggregate, current) =>
{
aggregate += current.UserVideos.Count();
return(aggregate);
});
possiblePoints = allQuizzes * 2;
userPoint = userQuizzes * 2;
percentQuiz = allQuizzes == 0 ? 0 : userQuizzes / allQuizzes;
percentVideo = allVideos == 0 ? 0 : userVideos / allVideos;
percentMastery = possiblePoints == 0 ? 0 : userPoint / possiblePoints;
var ut = new List <UserQuizClassification>();
var uv = new List <UserVideoClassification>();
foreach (var userTest in data.UserTests)
{
//get for ten levels for video and quizzes
ut.AddRange(userTest.UserQuizzes.Aggregate(new List <UserQuizClassification>(), (aggregate, current) =>
{
var agg = aggregate.Find(c =>
c.UserTestId == current.UserTestId &&
c.DateTime.Date == current.DateTaken.Date);
if (agg != null)
{
aggregate.Remove(agg);
agg.UserQuizzes.Add(current);
aggregate.Add(agg);
}
else
{
var ags = new UserQuizClassification
{
UserTestId = current.UserTestId,
TestId = current.UserTest.TestId,
DateTime = current.DateTaken.Date,
UserQuizzes = new List <UserQuiz> {
current
}
};
aggregate.Add(ags);
}
return(aggregate);
}));
uv.AddRange(userTest.UserVideos.Aggregate(new List <UserVideoClassification>(), (aggregate, current) =>
{
var agg = aggregate.Find(c =>
c.UserTestId == current.UserTestId &&
c.DateTime.Date == current.DateWatched.Date);
if (agg != null)
{
aggregate.Remove(agg);
agg.UserVideo.Add(current);
aggregate.Add(agg);
}
else
{
var ags = new UserVideoClassification
{
UserTestId = current.UserTestId,
TestId = current.UserTest.TestId,
DateTime = current.DateWatched.Date,
UserVideo = new List <UserVideo> {
current
}
};
aggregate.Add(ags);
}
return(aggregate);
}));
}
if (ut.Count > 0)
{
foreach (var item in ut)
{
var totalQuizin = 0;
var point = item.UserQuizzes.Aggregate(0, (aggregate, current) =>
{
aggregate += current.CorrectOption == current.UserOption ? 1 : 0;
return(aggregate);
});
var testQuiz = tests.Where(u => u.Id == item.TestId).FirstOrDefault();
if (testQuiz != null)
{
totalQuizin = testQuiz.Quizzes;
}
activities.Add(new Activity
{
Description = "Quiz",
Date = item.DateTime.ToShortDateString(),
TestType = "Quiz",
Point = point,
Overall = $"{point}/{totalQuizin}",
DayOfWeek = item.DateTime.DayOfWeek
});
}
}
if (uv.Count > 0)
{
foreach (var item in uv)
{
var totalVideoin = 0;
var point = item.UserVideo.Count();
var testQuiz = tests.Where(u => u.Id == item.TestId).FirstOrDefault();
if (testQuiz != null)
{
totalVideoin = testQuiz.Videos;
}
point = point > totalVideoin ? totalVideoin : point;
activities.Add(new Activity
{
Description = "Video",
Date = item.DateTime.ToShortDateString(),
TestType = "Video",
Point = 0,
Overall = $"{point}/{totalVideoin}",
DayOfWeek = item.DateTime.DayOfWeek
});
}
}
var dto = new Statistics
{
PercentQuiz = String.Format("{0:0.##}", percentQuiz),
PercentVideo = String.Format("{0:0.##}", percentVideo),
PercentMastery = String.Format("{0:0.##}", percentMastery),
Activities = activities
};
return(Ok(dto));
}
return(BadRequest(new { Message = "No such item" }));
}
/// <summary>
/// Initializes the current instance
/// </summary>
/// <param name="pipelineExecuter">The current pipeline executer.</param>
public void PrepareForExecution(IPipelineExecuter pipelineExecuter)
{
Statistics.MarkStarted();
this.pipelineExeuter = pipelineExecuter;
}
public static RealTimeCore Run(
ConfigurationProvider <RealTimeConfig> configProvider,
string rootPath,
ILocalizationProvider localizationProvider,
bool setDefaultTime)
{
if (configProvider == null)
{
throw new ArgumentNullException(nameof(configProvider));
}
if (string.IsNullOrEmpty(rootPath))
{
throw new ArgumentException("The root path cannot be null or empty string", nameof(rootPath));
}
if (localizationProvider == null)
{
throw new ArgumentNullException(nameof(localizationProvider));
}
List <IPatch> patches = GetMethodPatches();
var patcher = new MethodPatcher(HarmonyId, patches);
HashSet <IPatch> appliedPatches = patcher.Apply();
if (!CheckRequiredMethodPatches(appliedPatches))
{
Log.Error("The 'Real Time' mod failed to perform method redirections for required methods");
patcher.Revert();
return(null);
}
if (StorageBase.CurrentLevelStorage != null)
{
LoadStorageData(new[] { configProvider }, StorageBase.CurrentLevelStorage);
}
var timeInfo = new TimeInfo(configProvider.Configuration);
var buildingManager = new BuildingManagerConnection();
var randomizer = new GameRandomizer();
var weatherInfo = new WeatherInfo(new WeatherManagerConnection());
var gameConnections = new GameConnections <Citizen>(
timeInfo,
new CitizenConnection(),
new CitizenManagerConnection(),
buildingManager,
randomizer,
new TransferManagerConnection(),
weatherInfo);
var eventManager = new RealTimeEventManager(
configProvider.Configuration,
CityEventsLoader.Instance,
new EventManagerConnection(),
buildingManager,
randomizer,
timeInfo);
if (!SetupCustomAI(timeInfo, configProvider.Configuration, gameConnections, eventManager))
{
Log.Error("The 'Real Time' mod failed to setup the customized AI and will now be deactivated.");
patcher.Revert();
return(null);
}
var timeAdjustment = new TimeAdjustment(configProvider.Configuration);
DateTime gameDate = timeAdjustment.Enable(setDefaultTime);
SimulationHandler.CitizenProcessor.UpdateFrameDuration();
CityEventsLoader.Instance.ReloadEvents(rootPath);
var customTimeBar = new CustomTimeBar();
customTimeBar.Enable(gameDate);
customTimeBar.CityEventClick += CustomTimeBarCityEventClick;
var vanillaEvents = VanillaEvents.Customize();
var result = new RealTimeCore(timeAdjustment, customTimeBar, eventManager, patcher, vanillaEvents);
eventManager.EventsChanged += result.CityEventsChanged;
var statistics = new Statistics(timeInfo, localizationProvider);
if (statistics.Initialize())
{
statistics.RefreshUnits();
}
else
{
statistics = null;
}
SimulationHandler.NewDay += result.CityEventsChanged;
SimulationHandler.TimeAdjustment = timeAdjustment;
SimulationHandler.DayTimeSimulation = new DayTimeSimulation(configProvider.Configuration);
SimulationHandler.EventManager = eventManager;
SimulationHandler.WeatherInfo = weatherInfo;
SimulationHandler.Buildings = BuildingAIPatches.RealTimeAI;
SimulationHandler.Buildings.UpdateFrameDuration();
if (appliedPatches.Contains(BuildingAIPatches.PrivateShowConsumption))
{
SimulationHandler.Buildings.InitializeLightState();
}
SimulationHandler.Statistics = statistics;
if (appliedPatches.Contains(WorldInfoPanelPatches.UpdateBindings))
{
WorldInfoPanelPatches.CitizenInfoPanel = CustomCitizenInfoPanel.Enable(ResidentAIPatch.RealTimeAI, localizationProvider);
WorldInfoPanelPatches.VehicleInfoPanel = CustomVehicleInfoPanel.Enable(ResidentAIPatch.RealTimeAI, localizationProvider);
}
AwakeSleepSimulation.Install(configProvider.Configuration);
result.storageData.Add(eventManager);
result.storageData.Add(ResidentAIPatch.RealTimeAI.GetStorageService());
if (StorageBase.CurrentLevelStorage != null)
{
StorageBase.CurrentLevelStorage.GameSaving += result.GameSaving;
LoadStorageData(result.storageData, StorageBase.CurrentLevelStorage);
}
result.storageData.Add(configProvider);
result.Translate(localizationProvider);
result.IsRestrictedMode = appliedPatches.Count != patches.Count;
return(result);
}
public StatisticsAggregator(Statistics stats)
{
_stats = stats;
}
void DumpUmd()
{
const uint blockSize = 2048;
const MediaType dskType = MediaType.UMD;
uint blocksToRead = 16;
double totalDuration = 0;
double currentSpeed = 0;
double maxSpeed = double.MinValue;
double minSpeed = double.MaxValue;
DateTime start;
DateTime end;
byte[] senseBuf;
bool sense = _dev.Read12(out byte[] readBuffer, out _, 0, false, true, false, false, 0, 512, 0, 1, false,
_dev.Timeout, out _);
if (sense)
{
_dumpLog.WriteLine("Could not read...");
StoppingErrorMessage?.Invoke("Could not read...");
return;
}
ushort fatStart = (ushort)((readBuffer[0x0F] << 8) + readBuffer[0x0E]);
ushort sectorsPerFat = (ushort)((readBuffer[0x17] << 8) + readBuffer[0x16]);
ushort rootStart = (ushort)((sectorsPerFat * 2) + fatStart);
ushort rootSize = (ushort)((((readBuffer[0x12] << 8) + readBuffer[0x11]) * 32) / 512);
ushort umdStart = (ushort)(rootStart + rootSize);
UpdateStatus?.Invoke($"Reading root directory in sector {rootStart}...");
_dumpLog.WriteLine("Reading root directory in sector {0}...", rootStart);
sense = _dev.Read12(out readBuffer, out _, 0, false, true, false, false, rootStart, 512, 0, 1, false,
_dev.Timeout, out _);
if (sense)
{
_dumpLog.WriteLine("Could not read...");
StoppingErrorMessage?.Invoke("Could not read...");
return;
}
uint umdSizeInBytes = BitConverter.ToUInt32(readBuffer, 0x3C);
ulong blocks = umdSizeInBytes / blockSize;
string mediaPartNumber = Encoding.ASCII.GetString(readBuffer, 0, 11).Trim();
ulong totalSize = blocks * blockSize;
if (totalSize > 1099511627776)
{
UpdateStatus?.
Invoke($"Media has {blocks} blocks of {blockSize} bytes/each. (for a total of {totalSize / 1099511627776d:F3} TiB)");
}
else if (totalSize > 1073741824)
{
UpdateStatus?.
Invoke($"Media has {blocks} blocks of {blockSize} bytes/each. (for a total of {totalSize / 1073741824d:F3} GiB)");
}
else if (totalSize > 1048576)
{
UpdateStatus?.
Invoke($"Media has {blocks} blocks of {blockSize} bytes/each. (for a total of {totalSize / 1048576d:F3} MiB)");
}
else if (totalSize > 1024)
{
UpdateStatus?.
Invoke($"Media has {blocks} blocks of {blockSize} bytes/each. (for a total of {totalSize / 1024d:F3} KiB)");
}
else
{
UpdateStatus?.
Invoke($"Media has {blocks} blocks of {blockSize} bytes/each. (for a total of {totalSize} bytes)");
}
UpdateStatus?.Invoke($"Device reports {blocks} blocks ({blocks * blockSize} bytes).");
UpdateStatus?.Invoke($"Device can read {blocksToRead} blocks at a time.");
UpdateStatus?.Invoke($"Device reports {blockSize} bytes per logical block.");
UpdateStatus?.Invoke($"Device reports {2048} bytes per physical block.");
UpdateStatus?.Invoke($"SCSI device type: {_dev.ScsiType}.");
UpdateStatus?.Invoke($"Media identified as {dskType}.");
UpdateStatus?.Invoke($"Media part number is {mediaPartNumber}.");
_dumpLog.WriteLine("Device reports {0} blocks ({1} bytes).", blocks, blocks * blockSize);
_dumpLog.WriteLine("Device can read {0} blocks at a time.", blocksToRead);
_dumpLog.WriteLine("Device reports {0} bytes per logical block.", blockSize);
_dumpLog.WriteLine("Device reports {0} bytes per physical block.", 2048);
_dumpLog.WriteLine("SCSI device type: {0}.", _dev.ScsiType);
_dumpLog.WriteLine("Media identified as {0}.", dskType);
_dumpLog.WriteLine("Media part number is {0}.", mediaPartNumber);
bool ret;
var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
var ibgLog = new IbgLog(_outputPrefix + ".ibg", 0x0010);
ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
// Cannot create image
if (!ret)
{
_dumpLog.WriteLine("Error creating output image, not continuing.");
_dumpLog.WriteLine(_outputPlugin.ErrorMessage);
StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
_outputPlugin.ErrorMessage);
return;
}
start = DateTime.UtcNow;
double imageWriteDuration = 0;
(_outputPlugin as IWritableOpticalImage)?.SetTracks(new List <Track>
{
new Track
{
TrackBytesPerSector = (int)blockSize,
TrackEndSector = blocks - 1,
TrackSequence = 1,
TrackRawBytesPerSector = (int)blockSize,
TrackSubchannelType = TrackSubchannelType.None,
TrackSession = 1,
TrackType = TrackType.Data
}
});
DumpHardwareType currentTry = null;
ExtentsULong extents = null;
ResumeSupport.Process(true, _dev.IsRemovable, blocks, _dev.Manufacturer, _dev.Model, _dev.Serial,
_dev.PlatformId, ref _resume, ref currentTry, ref extents, _dev.FirmwareRevision,
_private);
if (currentTry == null ||
extents == null)
{
StoppingErrorMessage?.Invoke("Could not process resume file, not continuing...");
return;
}
if (_resume.NextBlock > 0)
{
_dumpLog.WriteLine("Resuming from block {0}.", _resume.NextBlock);
}
bool newTrim = false;
DateTime timeSpeedStart = DateTime.UtcNow;
ulong sectorSpeedStart = 0;
InitProgress?.Invoke();
for (ulong i = _resume.NextBlock; i < blocks; i += blocksToRead)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
break;
}
if (blocks - i < blocksToRead)
{
blocksToRead = (uint)(blocks - i);
}
if (currentSpeed > maxSpeed &&
currentSpeed > 0)
{
maxSpeed = currentSpeed;
}
if (currentSpeed < minSpeed &&
currentSpeed > 0)
{
minSpeed = currentSpeed;
}
UpdateProgress?.Invoke($"Reading sector {i} of {blocks} ({currentSpeed:F3} MiB/sec.)", (long)i,
(long)blocks);
sense = _dev.Read12(out readBuffer, out senseBuf, 0, false, true, false, false,
(uint)(umdStart + (i * 4)), 512, 0, blocksToRead * 4, false, _dev.Timeout,
out double cmdDuration);
totalDuration += cmdDuration;
if (!sense &&
!_dev.Error)
{
mhddLog.Write(i, cmdDuration);
ibgLog.Write(i, currentSpeed * 1024);
DateTime writeStart = DateTime.Now;
_outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
extents.Add(i, blocksToRead, true);
}
else
{
_errorLog?.WriteLine(i, _dev.Error, _dev.LastError, senseBuf);
// TODO: Reset device after X errors
if (_stopOnError)
{
return; // TODO: Return more cleanly
}
if (i + _skip > blocks)
{
_skip = (uint)(blocks - i);
}
// Write empty data
DateTime writeStart = DateTime.Now;
_outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
for (ulong b = i; b < i + _skip; b++)
{
_resume.BadBlocks.Add(b);
}
mhddLog.Write(i, cmdDuration < 500 ? 65535 : cmdDuration);
ibgLog.Write(i, 0);
_dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", _skip, i);
i += _skip - blocksToRead;
newTrim = true;
}
sectorSpeedStart += blocksToRead;
_resume.NextBlock = i + blocksToRead;
double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;
if (elapsed < 1)
{
continue;
}
currentSpeed = (sectorSpeedStart * blockSize) / (1048576 * elapsed);
sectorSpeedStart = 0;
timeSpeedStart = DateTime.UtcNow;
}
end = DateTime.UtcNow;
EndProgress?.Invoke();
mhddLog.Close();
ibgLog.Close(_dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024,
(blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000), _devicePath);
UpdateStatus?.Invoke($"Dump finished in {(end - start).TotalSeconds} seconds.");
UpdateStatus?.
Invoke($"Average dump speed {((double)blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000):F3} KiB/sec.");
UpdateStatus?.
Invoke($"Average write speed {((double)blockSize * (double)(blocks + 1)) / 1024 / imageWriteDuration:F3} KiB/sec.");
_dumpLog.WriteLine("Dump finished in {0} seconds.", (end - start).TotalSeconds);
_dumpLog.WriteLine("Average dump speed {0:F3} KiB/sec.",
((double)blockSize * (double)(blocks + 1)) / 1024 / (totalDuration / 1000));
_dumpLog.WriteLine("Average write speed {0:F3} KiB/sec.",
((double)blockSize * (double)(blocks + 1)) / 1024 / imageWriteDuration);
#region Trimming
if (_resume.BadBlocks.Count > 0 &&
!_aborted &&
_trim &&
newTrim)
{
start = DateTime.UtcNow;
_dumpLog.WriteLine("Trimming skipped sectors");
ulong[] tmpArray = _resume.BadBlocks.ToArray();
InitProgress?.Invoke();
foreach (ulong badSector in tmpArray)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
_dumpLog.WriteLine("Aborted!");
break;
}
PulseProgress?.Invoke($"Trimming sector {badSector}");
sense = _dev.Read12(out readBuffer, out senseBuf, 0, false, true, false, false,
(uint)(umdStart + (badSector * 4)), 512, 0, 4, false, _dev.Timeout,
out double _);
if (sense || _dev.Error)
{
_errorLog?.WriteLine(badSector, _dev.Error, _dev.LastError, senseBuf);
continue;
}
_resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
_outputPlugin.WriteSector(readBuffer, badSector);
}
EndProgress?.Invoke();
end = DateTime.UtcNow;
_dumpLog.WriteLine("Trimming finished in {0} seconds.", (end - start).TotalSeconds);
}
#endregion Trimming
#region Error handling
if (_resume.BadBlocks.Count > 0 &&
!_aborted &&
_retryPasses > 0)
{
int pass = 1;
bool forward = true;
bool runningPersistent = false;
Modes.ModePage?currentModePage = null;
byte[] md6;
if (_persistent)
{
Modes.ModePage_01 pg;
sense = _dev.ModeSense6(out readBuffer, out _, false, ScsiModeSensePageControl.Current, 0x01,
_dev.Timeout, out _);
if (!sense)
{
Modes.DecodedMode?dcMode6 = Modes.DecodeMode6(readBuffer, _dev.ScsiType);
if (dcMode6.HasValue)
{
foreach (Modes.ModePage modePage in dcMode6.Value.Pages.Where(modePage =>
modePage.Page == 0x01 &&
modePage.Subpage == 0x00))
{
currentModePage = modePage;
}
}
}
if (currentModePage == null)
{
pg = new Modes.ModePage_01
{
PS = false,
AWRE = true,
ARRE = true,
TB = false,
RC = false,
EER = true,
PER = false,
DTE = true,
DCR = false,
ReadRetryCount = 32
};
currentModePage = new Modes.ModePage
{
Page = 0x01,
Subpage = 0x00,
PageResponse = Modes.EncodeModePage_01(pg)
};
}
pg = new Modes.ModePage_01
{
PS = false,
AWRE = false,
ARRE = false,
TB = true,
RC = false,
EER = true,
PER = false,
DTE = false,
DCR = false,
ReadRetryCount = 255
};
var md = new Modes.DecodedMode
{
Header = new Modes.ModeHeader(),
Pages = new[]
{
new Modes.ModePage
{
Page = 0x01,
Subpage = 0x00,
PageResponse = Modes.EncodeModePage_01(pg)
}
}
};
md6 = Modes.EncodeMode6(md, _dev.ScsiType);
_dumpLog.WriteLine("Sending MODE SELECT to drive (return damaged blocks).");
sense = _dev.ModeSelect(md6, out senseBuf, true, false, _dev.Timeout, out _);
if (sense)
{
UpdateStatus?.
Invoke("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
AaruConsole.DebugWriteLine("Error: {0}", Sense.PrettifySense(senseBuf));
_dumpLog.
WriteLine("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
}
else
{
runningPersistent = true;
}
}
InitProgress?.Invoke();
repeatRetry:
ulong[] tmpArray = _resume.BadBlocks.ToArray();
foreach (ulong badSector in tmpArray)
{
if (_aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
_dumpLog.WriteLine("Aborted!");
break;
}
PulseProgress?.
Invoke($"Retrying sector {badSector}, pass {pass}, {(runningPersistent ? "recovering partial data, " : "")}{(forward ? "forward" : "reverse")}");
sense = _dev.Read12(out readBuffer, out senseBuf, 0, false, true, false, false,
(uint)(umdStart + (badSector * 4)), 512, 0, 4, false, _dev.Timeout,
out double cmdDuration);
totalDuration += cmdDuration;
if (sense || _dev.Error)
{
_errorLog?.WriteLine(badSector, _dev.Error, _dev.LastError, senseBuf);
}
if (!sense &&
!_dev.Error)
{
_resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
_outputPlugin.WriteSector(readBuffer, badSector);
UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
_dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
}
else if (runningPersistent)
{
_outputPlugin.WriteSector(readBuffer, badSector);
}
}
if (pass < _retryPasses &&
!_aborted &&
_resume.BadBlocks.Count > 0)
{
pass++;
forward = !forward;
_resume.BadBlocks.Sort();
if (!forward)
{
_resume.BadBlocks.Reverse();
}
goto repeatRetry;
}
if (runningPersistent && currentModePage.HasValue)
{
var md = new Modes.DecodedMode
{
Header = new Modes.ModeHeader(),
Pages = new[]
{
currentModePage.Value
}
};
md6 = Modes.EncodeMode6(md, _dev.ScsiType);
_dumpLog.WriteLine("Sending MODE SELECT to drive (return device to previous status).");
_dev.ModeSelect(md6, out _, true, false, _dev.Timeout, out _);
}
EndProgress?.Invoke();
AaruConsole.WriteLine();
}
#endregion Error handling
_resume.BadBlocks.Sort();
foreach (ulong bad in _resume.BadBlocks)
{
_dumpLog.WriteLine("Sector {0} could not be read.", bad);
}
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
var metadata = new CommonTypes.Structs.ImageInfo
{
Application = "Aaru",
ApplicationVersion = Version.GetVersion(),
MediaPartNumber = mediaPartNumber
};
if (!_outputPlugin.SetMetadata(metadata))
{
ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
_outputPlugin.ErrorMessage);
}
_outputPlugin.SetDumpHardware(_resume.Tries);
if (_preSidecar != null)
{
_outputPlugin.SetCicmMetadata(_preSidecar);
}
_dumpLog.WriteLine("Closing output file.");
UpdateStatus?.Invoke("Closing output file.");
DateTime closeStart = DateTime.Now;
_outputPlugin.Close();
DateTime closeEnd = DateTime.Now;
_dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
if (_aborted)
{
UpdateStatus?.Invoke("Aborted!");
_dumpLog.WriteLine("Aborted!");
return;
}
double totalChkDuration = 0;
if (_metadata)
{
WriteOpticalSidecar(blockSize, blocks, dskType, null, null, 1, out totalChkDuration, null);
}
UpdateStatus?.Invoke("");
UpdateStatus?.
Invoke($"Took a total of {(end - start).TotalSeconds:F3} seconds ({totalDuration / 1000:F3} processing commands, {totalChkDuration / 1000:F3} checksumming, {imageWriteDuration:F3} writing, {(closeEnd - closeStart).TotalSeconds:F3} closing).");
UpdateStatus?.
Invoke($"Average speed: {((double)blockSize * (double)(blocks + 1)) / 1048576 / (totalDuration / 1000):F3} MiB/sec.");
if (maxSpeed > 0)
{
UpdateStatus?.Invoke($"Fastest speed burst: {maxSpeed:F3} MiB/sec.");
}
if (minSpeed > 0 &&
minSpeed < double.MaxValue)
{
UpdateStatus?.Invoke($"Slowest speed burst: {minSpeed:F3} MiB/sec.");
}
UpdateStatus?.Invoke($"{_resume.BadBlocks.Count} sectors could not be read.");
UpdateStatus?.Invoke("");
Statistics.AddMedia(dskType, true);
}
/// <summary>
/// Order:
/// 1. Rarity
/// 2. Image
/// 3. Text
/// 1. DisplayName
/// 2. Description
/// 3. Misc
/// 4. GameplayTags
/// 1. order doesn't matter
/// 2. the importance here is to get the description before gameplay tags
/// </summary>
public BaseIcon(IUExport export, string exportType, ref string assetName) : this()
{
// rarity
if (export.GetExport <ObjectProperty>("Series") is ObjectProperty series)
{
Serie.GetRarity(this, series);
}
else if (Properties.Settings.Default.UseGameColors) // override default green
{
Rarity.GetInGameRarity(this, export.GetExport <EnumProperty>("Rarity")); // uncommon will be triggered by Rarity being null
}
else if (export.GetExport <EnumProperty>("Rarity") is EnumProperty rarity)
{
Rarity.GetHardCodedRarity(this, rarity);
}
// image
if (Properties.Settings.Default.UseItemShopIcon &&
DisplayAssetImage.GetDisplayAssetImage(this, export.GetExport <SoftObjectProperty>("DisplayAssetPath"), ref assetName))
{
} // ^^^^ will return false if image not found, if so, we try to get the normal icon
else if (export.GetExport <ObjectProperty>("HeroDefinition", "WeaponDefinition") is ObjectProperty itemDef)
{
LargeSmallImage.GetPreviewImage(this, itemDef, assetName);
}
else if (export.GetExport <ObjectProperty>("SmallPreviewImage") is ObjectProperty smallPreviewImage)
{
this.IconImage = Utils.GetObjectTexture(smallPreviewImage);
}
else if (export.GetExport <SoftObjectProperty>("LargePreviewImage", "SmallPreviewImage", "ItemDisplayAsset") is SoftObjectProperty previewImage)
{
LargeSmallImage.GetPreviewImage(this, previewImage);
}
else if (export.GetExport <StructProperty>("IconBrush") is StructProperty iconBrush) // abilities
{
LargeSmallImage.GetPreviewImage(this, iconBrush);
}
// text
if (export.GetExport <TextProperty>("DisplayName", "DefaultHeaderText", "UIDisplayName") is TextProperty displayName)
{
DisplayName = Text.GetTextPropertyBase(displayName);
}
if (export.GetExport <TextProperty>("Description", "DefaultBodyText") is TextProperty description)
{
Description = Text.GetTextPropertyBase(description);
}
else if (export.GetExport <ArrayProperty>("Description") is ArrayProperty arrayDescription) // abilities
{
Description = Text.GetTextPropertyBase(arrayDescription);
}
if (export.GetExport <StructProperty>("MaxStackSize") is StructProperty maxStackSize)
{
ShortDescription = Text.GetMaxStackSize(maxStackSize);
}
else if (export.GetExport <TextProperty>("ShortDescription") is TextProperty shortDescription)
{
ShortDescription = Text.GetTextPropertyBase(shortDescription);
}
else if (exportType.Equals("AthenaItemWrapDefinition")) // if no ShortDescription it's most likely a wrap
{
ShortDescription = Localizations.GetLocalization("Fort.Cosmetics", "ItemWrapShortDescription", "Wrap");
}
// gameplaytags
if (export.GetExport <StructProperty>("GameplayTags") is StructProperty gameplayTags)
{
GameplayTag.GetGameplayTags(this, gameplayTags, exportType);
}
else if (export.GetExport <ObjectProperty>("cosmetic_item") is ObjectProperty cosmeticItem) // variants
{
CosmeticSource = cosmeticItem.Value.Resource.ObjectName.String;
}
if (export.GetExport <SoftObjectProperty>("AmmoData") is SoftObjectProperty ammoData)
{
Statistics.GetAmmoData(this, ammoData);
}
if (export.GetExport <StructProperty>("WeaponStatHandle") is StructProperty weaponStatHandle)
{
Statistics.GetWeaponStats(this, weaponStatHandle);
}
if (export.GetExport <ObjectProperty>("HeroGameplayDefinition") is ObjectProperty heroGameplayDefinition)
{
Statistics.GetHeroStats(this, heroGameplayDefinition);
}
/* Please do not add Schematics support because it takes way too much memory */
/* Thank the STW Dev Team for using a 5,69Mb file to get... Oh nvm, they all left */
AdditionalSize = 48 * Stats.Count;
}
private void Enqueue(BaseAction action)
{
_flushHandler.Process(action).GetAwaiter().GetResult();
this.Statistics.Submitted = Statistics.Increment(this.Statistics.Submitted);
}
public virtual void Reset()
{
Points = 0;
Statistics.Reset();
}
private void Stats(object sender, RoutedEventArgs e)
{
Statistics stats = new Statistics(this._idEvent);
stats.Show();
}
public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Target target)
{
LogData = logData;
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
CombatData = combatData;
PlayerList = playerList;
BoonSourceFinder = Boon.GetBoonSourceFinder(logData.GW2Version);
LegacyTarget = target;
MechanicData = new MechanicData(fightData);
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
PlayerIDs = new HashSet <ushort>(playerList.Select(x => x.InstID));
FightData.SetSuccess(this);
FightData.SetCM(this);
CombatData.Update(FightData.FightEnd);
if (FightData.FightDuration <= 2200)
{
throw new TooShortException();
}
if (Properties.Settings.Default.SkipFailedTries && !FightData.Success)
{
throw new SkipException();
}
// init combat replay
if (Properties.Settings.Default.ParseCombatReplay && FightData.Logic.CanCombatReplay)
{
foreach (Player p in PlayerList)
{
if (p.Account == ":Conjured Sword")
{
continue;
}
p.InitCombatReplay(this, GeneralHelper.PollingRate, false, true);
}
foreach (Target tar in FightData.Logic.Targets)
{
tar.InitCombatReplay(this, GeneralHelper.PollingRate, true, FightData.GetMainTargets(this).Contains(tar));
}
FightData.Logic.InitTrashMobCombatReplay(this, GeneralHelper.PollingRate);
// Ensuring all combat replays are initialized before extra data (and agent interaction) is computed
foreach (Player p in PlayerList)
{
if (p.Account == ":Conjured Sword")
{
continue;
}
p.ComputeAdditionalCombatReplayData(this);
}
foreach (Target tar in FightData.Logic.Targets)
{
tar.ComputeAdditionalCombatReplayData(this);
}
foreach (Mob mob in FightData.Logic.TrashMobs)
{
mob.ComputeAdditionalCombatReplayData(this);
}
}
FightData.Logic.ComputeMechanics(this);
Statistics = new Statistics(this);
}
protected internal ConsistencyCheckerTask(string name, Statistics statistics, int threads)
{
this.Name = name;
this.Statistics = statistics;
this.NumberOfThreads = threads;
}
private static void ServeImageContent(string politicianKey, string column,
string defaultColumn, DateTime lastModDate, bool isModified, bool noCache)
{
var response = HttpContext.Current.Response;
//var maxAge = new TimeSpan(24, 0, 0); // 24 hours -- used in headers
var maxAge = new TimeSpan(0, 0, 0); // force a server query always
var expiration = DateTime.UtcNow + maxAge;
var isProfileOriginal =
column.IsEqIgnoreCase(
PoliticiansImagesBlobs.GetColumnName(
PoliticiansImagesBlobs.Column.ProfileOriginal));
if (!isModified)
{
response.StatusCode = 304;
response.StatusDescription = "Not Modified";
}
response.Cache.SetCacheability(HttpCacheability.Public);
response.Cache.SetETag('"' +
lastModDate.Ticks.ToString(CultureInfo.InvariantCulture) + '"');
response.Cache.SetLastModified(lastModDate);
response.Cache.SetMaxAge(maxAge);
response.Cache.SetExpires(expiration);
response.Cache.SetSlidingExpiration(false);
response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
if (isModified) // serve actual image
{
var cache = HttpContext.Current.Cache;
var cacheKey = "politicianImage." + politicianKey + "." + column;
ApplicationCacheEntry cacheEntry = null;
// We don't use memory cache for profile originals
if (!noCache && !isProfileOriginal)
{
cacheEntry = cache.Get(cacheKey) as ApplicationCacheEntry;
}
if (cacheEntry != null && cacheEntry.Expiration > DateTime.UtcNow)
{
response.ContentType = cacheEntry.ContentType;
response.BinaryWrite(cacheEntry.Blob);
Interlocked.Increment(ref CurrentStatistics.ImagesServedFromMemoryCache);
}
else
{
var blob = GetPoliticianImage(politicianKey, column, defaultColumn,
noCache);
if (blob != null)
{
// we get the content type from the actual image
var contentType = GetContentType(blob);
response.ContentType = contentType;
response.BinaryWrite(blob);
if (!isProfileOriginal)
{
var cacheExpiration =
DateTime.UtcNow.AddMinutes(MemCache.CacheExpiration);
cacheEntry = new ApplicationCacheEntry
{
Expiration = cacheExpiration,
Blob = blob,
ContentType = contentType
};
cache.Add(cacheKey, cacheEntry, null, cacheExpiration,
Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
}
Interlocked.Increment(ref CurrentStatistics.ImagesServedFromDisc);
}
}
}
else // tell browser to use cached version
{
response.AddHeader("Content-Length", "0");
Interlocked.Increment(ref CurrentStatistics.ImagesServedFromBrowserCache);
}
if (_LastStatisticsSnapshot.SnapshotTime + StatisticsSnapshotInterval <
DateTime.UtcNow)
{
// May need to snapshot statistics, but make sure only one thread does it
if (Interlocked.Exchange(ref _SnapshottingStatistics, 1) == 0)
// it's our job
{
var previousSnapshot = _LastStatisticsSnapshot;
_LastStatisticsSnapshot = CurrentStatistics.Clone();
_LastStatisticsSnapshot.SnapshotTime = DateTime.UtcNow;
VotePage.LogInfo("ImageCaching",
$"Image caching from {previousSnapshot.SnapshotTime} to {_LastStatisticsSnapshot.SnapshotTime}:" +
$" {_LastStatisticsSnapshot.ImagesServedFromBrowserCache - previousSnapshot.ImagesServedFromBrowserCache} from browser cache," +
$" {_LastStatisticsSnapshot.ImagesServedFromMemoryCache - previousSnapshot.ImagesServedFromMemoryCache} from memory cache," +
$" {_LastStatisticsSnapshot.ImagesServedFromDisc - previousSnapshot.ImagesServedFromDisc} from disc");
Interlocked.Exchange(ref _SnapshottingStatistics, 0);
}
}
response.End();
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var user = new User
{
Id = 2,
FirstName = "Ivan",
SecondName = "Bad",
Birthday = DateTime.Now,
Email = "*****@*****.**",
Password = "******",
Role = "user"
};
var admin = new User
{
Id = 1,
FirstName = "Admin",
SecondName = "admin",
Birthday = DateTime.Now,
Email = "*****@*****.**",
Password = "******",
Role = "admin"
};
modelBuilder.Entity <User>().HasData(user);
modelBuilder.Entity <User>().HasData(admin);
var beeGarder = new BeeGarden
{
Id = 1,
Name = "Bee Garden 1",
Description = "Description Bee Garden 1",
UserId = user.Id
};
modelBuilder.Entity <BeeGarden>().HasData(beeGarder);
var beehive = new Beehive
{
Id = 1,
Name = "Beehive 1",
Description = "Description Beehives 1",
NumberOfTheFrames = 10,
Type = "Dadan",
YearOfTheQueenBee = 2020,
BeeGardenId = beeGarder.Id
};
modelBuilder.Entity <Beehive>().HasData(beehive);
var beehive2 = new Beehive
{
Id = 2,
Name = "Beehive 2",
Description = "Description Beehives 2",
NumberOfTheFrames = 12,
Type = "Dadan",
YearOfTheQueenBee = 2019,
BeeGardenId = beeGarder.Id
};
modelBuilder.Entity <Beehive>().HasData(beehive2);
var statistics = new Statistics
{
Id = 1,
DateTime = DateTime.Now,
Temperature = 21.3,
MoisturePercentage = 50,
Weight = 85.7,
Location = "49.82236707355737, 34.532303261131425",
BeehiveId = beehive.Id
};
modelBuilder.Entity <Statistics>().HasData(statistics);
var statistics2 = new Statistics
{
Id = 2,
DateTime = DateTime.Now,
Temperature = 22.3,
MoisturePercentage = 55,
Weight = 80.7,
Location = "48.82236707355737, 33.532303261131425",
BeehiveId = beehive.Id
};
modelBuilder.Entity <Statistics>().HasData(statistics2);
var statistics3 = new Statistics
{
Id = 3,
DateTime = DateTime.Now,
Temperature = 30.3,
MoisturePercentage = 70,
Weight = 70.7,
Location = "45.82236707355737, 31.532303261131425",
BeehiveId = beehive.Id
};
modelBuilder.Entity <Statistics>().HasData(statistics3);
base.OnModelCreating(modelBuilder);
}
public async Task AddAsync(Statistics statistics) => await Stats.InsertOneAsync(statistics);
private void LoadStatistics()
{
_filteredStatistics =
Service.FilteredStatistics ??
Service.RawStatistics ??
_filteredStatistics;
}
