public void NewOrder(int userId, int productId, int cityId)
{
IUserSystem iUserSystem = new UserSystem("为什么");
IStorageSystem iStorageSystem = new StorageSystem();
ILogisticsSystem iLogisticsSystem = new LogisticsSystem();
IOrderSystem iOrderSystem = new OrderSystem();
if (!iUserSystem.CheckUser(userId))
{
Console.WriteLine("用户检测失败");
}
else if (!iStorageSystem.CheckStorage(productId))
{
Console.WriteLine("仓储检测失败");
}
else if (!iLogisticsSystem.CheckLogistics(productId, cityId))
{
Console.WriteLine("物流检测失败");
//不能直接去物流增加一个检测失败的数据记录
//而是通过物流系统的方法去做
}
else if (!iOrderSystem.CheckOrder(userId, productId))
{
Console.WriteLine("订单检测失败");
}
else
{
iOrderSystem.NewOrder(userId, productId);
iLogisticsSystem.NewLogistics(productId, cityId);
}
}
private async Task CreateDefaultImage()
{
var imageWidth = ServiceLocator.SystemInformationService.ScreenWidth;
var imageHeight = ServiceLocator.SystemInformationService.ScreenHeight;
using (var storage = StorageSystem.GetStorage())
{
await storage.DeleteFileAsync(StorageConstants.TempPaintImagePath);
Stream stream = await storage.OpenFileAsync(StorageConstants.TempPaintImagePath,
StorageFileMode.Create, StorageFileAccess.Write);
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(
BitmapEncoder.PngEncoderId, stream.AsRandomAccessStream());
Byte[] pixels = new byte[imageWidth * imageHeight * 4];
for (var pixelStart = 0; pixelStart < pixels.Length; pixelStart += 4)
{
pixels[pixelStart + 0] = 0xAA; // Full transparent: 0x00
pixels[pixelStart + 1] = 0xAA;
pixels[pixelStart + 2] = 0xAA;
pixels[pixelStart + 3] = 0xAA;
}
encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight,
(uint)imageWidth, (uint)imageHeight, 96, 96, pixels);
await encoder.FlushAsync();
}
}
public async Task WriteAsJpg(string path)
{
using (var storage = StorageSystem.GetStorage())
{
await storage.SaveImageAsync(path, this, true, ImageFormat.Jpg);
}
}
private void ConfigureServices(IServiceCollection services)
{
Storage = new StorageSystem(LaunchSettings.WorkDir);
services.AddSingleton <Alex>(this);
services.AddSingleton <ContentManager>(Content);
services.AddSingleton <IStorageSystem>(Storage);
services.AddSingleton <IOptionsProvider, OptionsProvider>();
services.AddSingleton <ProfileManager>();
services.AddSingleton <IListStorageProvider <SavedServerEntry>, SavedServerDataProvider>();
services.AddSingleton <XBLMSAService>();
services.AddSingleton <IServerQueryProvider>(new ServerQueryProvider(this));
services.AddSingleton <IPlayerProfileService, PlayerProfileService>();
services.AddSingleton <IRegistryManager, RegistryManager>();
services.AddSingleton <AlexIpcService>();
services.AddSingleton <IEventDispatcher, EventDispatcher>();
services.AddSingleton <ResourceManager>();
services.AddSingleton <GuiManager>((o) => this.GuiManager)
; //Storage = storage;
}
/// <summary>
/// 门面模式通过是单例的
/// 门面模式不能直接新增一个物流或者仓储检测方法，只能通过调用物流系统或者仓储系统的检测方法，这是门面模式的严格界定
/// 用于分层
/// 门面模式就是为了屏蔽上端知道太多细节
/// </summary>
/// <param name="userId"></param>
/// <param name="productId"></param>
public void NewOrder(int userId, int productId)
{
IUserSystem iUser = new UserSystem();
ILogisticsSystem iLogistics = new LogisticsSystem();
IStorageSystem iStorage = new StorageSystem();
IOrderSystem iOrder = new OrderSystem();
if (!iUser.CheckUser(userId))
{
Console.WriteLine("用户检测失败");
}
else if (!iStorage.CheckStorage(productId))
{
Console.WriteLine("仓储检测失败");
}
else if (!iLogistics.CheckLogistics(userId, productId))
{
Console.WriteLine("物流检测失败");
}
else if (!iOrder.CheckOrder(userId, productId))
{
Console.WriteLine("订单检测失败");
}
else
{
iOrder.NewOrder(userId, productId);
iLogistics.NewLogistics(userId, productId);
}
}
protected void Button6_Click(object sender, EventArgs e)
{
TaskStatus ts = validateTask();
if (Session["CategoryList"] != null && ts != null)
{
List <Category> list = (List <Category>)Session["CategoryList"];
if (CheckBox2.Checked)
{
forwardKeywords(list, "root");
}
List <Category> initalList = new List <Category>();
foreach (Category cat in list)
{
List <String> keywords = cat.getKeywordList();
if (CheckBox2.Checked)
{
keywords = removeDuplicates(cat.getKeywordList());
}
Category newCat = new Category("", "", cat.getCatrgoryName().Trim(), keywords, cat.getConfidenceLevel());
initalList.Add(newCat);
}
StorageSystem.getInstance().setCategories(ts.getTaskID().Trim(), initalList);
List <Category> dbList = StorageSystem.getInstance().getCategories(ts.getTaskID().Trim());
foreach (Category cat in list)
{
string pid = getCategoryID(dbList, cat.getParentName());
string id = getCategoryID(dbList, cat.getCatrgoryName());
StorageSystem.getInstance().setParentToSon(pid, id);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
LabelUIVersion.Text = Version.getUIVersion();
LabelEngineVersion.Text = Version.getCoreVersion();
Label1.Text = "Invoke a Task";
TaskStatus requiredTask = null;
List <TaskStatus> tasks = StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.AllTasks);
foreach (TaskStatus task in tasks)
{
if (task.getTaskName().Trim() == Request["TID"])
{
requiredTask = task;
break;
}
}
if (requiredTask != null)
{
Session.Add("Task", requiredTask);
Label2.Text = requiredTask.getTaskName().Trim();
Label3.Text = TaskStatus.convertToStatusString(requiredTask.getTaskStatus());
Label4.Text = printWorkingTime(requiredTask.getTaskElapsedTime());
Label5.Text = StorageSystem.getInstance().getTotalURLs(requiredTask.getTaskID().Trim(), null).ToString();
}
Label6.Text = StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.ActiveTasks).Count.ToString();
Label7.Text = StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.WaitingTasks).Count.ToString();
Label8.Text = printList(StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.ActiveTasks));
Label9.Text = printList(StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.WaitingTasks));
}
private void resetDefaults()
{
DropDownList1.Items.Clear();
DropDownList2.Items.Clear();
ListBox2.Items.Clear();
TaskStatus ts = validateTask();
if (ts != null)
{
DropDownList1.Items.Add("root");
List <Category> cats = StorageSystem.getInstance().getCategories(ts.getTaskID().Trim());
List <Category> previewCats = new List <Category>();
foreach (Category cat in cats)
{
string pname = getCategoryName(cats, cat.getParentName());
Category newCat = new Category(cat.getCategoryID(), pname, cat.getCatrgoryName(), cat.getKeywordList(), cat.getConfidenceLevel());
previewCats.Add(newCat);
}
Session["CategoryList"] = previewCats;
foreach (Category cat in previewCats)
{
DropDownList1.Items.Add(cat.getCatrgoryName().Trim());
DropDownList2.Items.Add(cat.getCatrgoryName().Trim());
ListBox2.Items.Add(cat.getCatrgoryName().Trim());
}
DropDownList2_SelectedIndexChanged(null, null);
}
}
private static async Task WriteLooksToDisk(string basePathToLookFiles)
{
var lookFiles = new List <string>
{
LookFileNameBackground,
LookFileNameBackgroundFinished,
LookFileNameMole1,
LookFileNameMole2,
LookFileNameMole3
};
using (var storage = StorageSystem.GetStorage())
{
using (var loader = ServiceLocator.ResourceLoaderFactory.CreateResourceLoader())
{
foreach (var lookFile in lookFiles)
{
var inputStream = await loader.OpenResourceStreamAsync(ResourceScope.Ide, // TODO: change resourceScope to suppot phone and store app (after 8.1 upgrade)
Path.Combine(ResourcePathToLookFiles, lookFile));
var outputStream = await storage.OpenFileAsync(Path.Combine(basePathToLookFiles, lookFile),
StorageFileMode.Create, StorageFileAccess.Write);
inputStream.CopyTo(outputStream);
outputStream.Flush();
inputStream.Dispose();
outputStream.Dispose();
}
}
}
}
public async Task <Stream> CreateProgramPackageForExport(string programName)
{
var streamResult = new MemoryStream();
var tempPath = Path.Combine(StorageConstants.TempProgramExportPath, programName);
var programFolderPath = Path.Combine(StorageConstants.ProgramsPath, programName);
var programCodePath = Path.Combine(tempPath, StorageConstants.ProgramCodePath);
using (var storage = StorageSystem.GetStorage())
{
await storage.DeleteDirectoryAsync(tempPath);
await storage.CopyDirectoryAsync(programFolderPath, tempPath);
var programCode = await storage.ReadTextFileAsync(programCodePath);
var converterResult = await CatrobatVersionConverter.
ConvertToXmlVersion(programCode, XmlConstants.TargetOutputVersion);
if (converterResult.Error != CatrobatVersionConverter.VersionConverterStatus.NoError)
{
return(null);
}
}
var zipService = new ZipService();
await zipService.ZipCatrobatPackage(streamResult, tempPath);
streamResult.Seek(0, SeekOrigin.Begin);
return(streamResult);
}
protected void resetDefaults()
{
TaskStatus requiredTask = null;
List <TaskStatus> tasks = StorageSystem.getInstance().getWorkDetails("5df16977-d18e-4a0a-b81b-0073de3c9a7f", QueryOption.AllTasks);
foreach (TaskStatus task in tasks)
{
if (task.getTaskName().Trim() == Request["TID"])
{
requiredTask = task;
break;
}
}
if (requiredTask != null)
{
Session.Add("TID", requiredTask.getTaskID());
putTaskSettings(requiredTask);
ListBox1.Items.Clear();
List <string> seeds = StorageSystem.getInstance().getSeedList(requiredTask.getTaskID());
foreach (string seed in seeds)
{
ListBox1.Items.Add(seed);
}
if (requiredTask.getTaskStatus() != Status.Idle)
{
Button13.Enabled = false;
}
if (StorageSystem.getInstance().getTotalURLs(requiredTask.getTaskID().Trim(), null) != 0)
{
Button14.Enabled = false;
}
}
}
public async Task <Program> CopyProgramPart2(string sourceProgramName,
string newProgramName)
{
using (var storage = StorageSystem.GetStorage())
{
var sourcePath = Path.Combine(StorageConstants.ProgramsPath, sourceProgramName);
var destinationPath = Path.Combine(StorageConstants.ProgramsPath, newProgramName);
await storage.CopyDirectoryAsync(sourcePath, destinationPath);
var tempXmlPath = Path.Combine(destinationPath, StorageConstants.ProgramCodePath);
var xml = await storage.ReadTextFileAsync(tempXmlPath);
var xmlProgram = new XmlProgram(xml)
{
ProgramHeader = { ProgramName = newProgramName }
};
var path = Path.Combine(StorageConstants.ProgramsPath,
newProgramName, StorageConstants.ProgramCodePath);
var programConverter = new ProgramConverter();
var program = programConverter.Convert(xmlProgram);
var xmlString = xmlProgram.ToXmlString();
await storage.WriteTextFileAsync(path, xmlString);
return(program);
}
}
public async Task <Program> CreateEmptyProgram(string newProgramName)
{
// TODO: move this code into a ProjectGenerator see ProjectGeneratorWhackAMole
var newProject = new Program
{
Name = newProgramName,
UploadHeader = new UploadHeader
{
MediaLicense = "http://developer.catrobat.org/ccbysa_v3",
ProgramLicense = "http://developer.catrobat.org/agpl_v3",
Url = "http://pocketcode.org/details/871"
}
};
using (var storage = StorageSystem.GetStorage())
{
var destinationPath = Path.Combine(StorageConstants.ProgramsPath, newProgramName);
var counter = 1;
while (await storage.DirectoryExistsAsync(destinationPath))
{
newProgramName = newProgramName + counter;
destinationPath = Path.Combine(StorageConstants.ProgramsPath, newProgramName);
counter++;
}
}
await newProject.Save();
return(newProject);
}
public async Task <string> CopyProgramPart1(string sourceProgramName)
{
using (var storage = StorageSystem.GetStorage())
{
var newProgramName = sourceProgramName;
var sourcePath = Path.Combine(StorageConstants.ProgramsPath, sourceProgramName);
var destinationPath = Path.Combine(StorageConstants.ProgramsPath, newProgramName);
var counter = 1;
while (await storage.DirectoryExistsAsync(destinationPath))
{
newProgramName = newProgramName + counter;
destinationPath = Path.Combine(StorageConstants.ProgramsPath, newProgramName);
counter++;
}
var sourceScreenshotPathManual = Path.Combine(sourcePath, StorageConstants.ProgramManualScreenshotPath);
var destinationScreenshotPathManual = Path.Combine(destinationPath, StorageConstants.ProgramManualScreenshotPath);
await storage.CopyFileAsync(sourceScreenshotPathManual, destinationScreenshotPathManual);
var sourceScreenshotPathAutomated = Path.Combine(sourcePath, StorageConstants.ProgramAutomaticScreenshotPath);
var destinationScreenshotPathAutomated = Path.Combine(destinationPath, StorageConstants.ProgramAutomaticScreenshotPath);
await storage.CopyFileAsync(sourceScreenshotPathAutomated, destinationScreenshotPathAutomated);
return(newProgramName);
}
}
public async Task <string> AcceptTempProgram()
{
XmlProgramRenamerResult renameResult = new XmlProgramRenamerResult {
NewProgramName = _programName
};
var uniqueProgramName = await ServiceLocator.ContextService.
FindUniqueProgramName(_programName);
if (_programName != uniqueProgramName)
{
renameResult = await ServiceLocator.ContextService.RenameProgram(
Path.Combine(StorageConstants.TempProgramImportPath,
StorageConstants.ProgramCodePath),
uniqueProgramName);
}
using (var storage = StorageSystem.GetStorage())
{
var newPath = Path.Combine(StorageConstants.ProgramsPath,
renameResult.NewProgramName);
await storage.MoveDirectoryAsync(StorageConstants.TempProgramImportPath,
newPath);
}
return(uniqueProgramName);
}
protected void putTaskSettings(TaskStatus task)
{
Label2.Text = task.getTaskName().Trim();
Constraints limits = StorageSystem.getInstance().getRestrictions(task.getTaskID());
TextBox1.Text = limits.getAllowedDepth().ToString();
bool paramsAllowed = limits.isParametrizationAllowed();
if (paramsAllowed == true)
{
DropDownList1.SelectedIndex = 1;
}
else
{
DropDownList1.SelectedIndex = 0;
}
ListBox2.Items.Clear();
List <string> crawlNetworks = limits.getCrawlList();
foreach (string net in crawlNetworks)
{
ListBox2.Items.Add(net);
}
ListBox3.Items.Clear();
List <string> restrictNetworks = limits.getRestrictionList();
foreach (string net in restrictNetworks)
{
ListBox3.Items.Add(net);
}
}
private void saveOptions(StorageSystem ss, String tid)
{
ss.setProperty(tid, TaskProperty.THREADS.ToString(), TextBox1.Text);
ss.setProperty(tid, TaskProperty.FRONTIER.ToString(), DropDownList1.SelectedValue);
ss.setProperty(tid, TaskProperty.CAT_ALPHA.ToString(), TextBox2.Text);
ss.setProperty(tid, TaskProperty.CAT_BETA.ToString(), TextBox3.Text);
ss.setProperty(tid, TaskProperty.CAT_GAMMA.ToString(), TextBox4.Text);
ss.setProperty(tid, TaskProperty.CAT_MIN.ToString(), TextBox5.Text);
ss.setProperty(tid, TaskProperty.CAT_PENLTY.ToString(), TextBox6.Text);
ss.setProperty(tid, TaskProperty.NER_ALPHA.ToString(), TextBox12.Text);
ss.setProperty(tid, TaskProperty.NER_BETA.ToString(), TextBox13.Text);
ss.setProperty(tid, TaskProperty.NER_GAMMA.ToString(), TextBox14.Text);
ss.setProperty(tid, TaskProperty.NER_MIN.ToString(), TextBox15.Text);
ss.setProperty(tid, TaskProperty.NER_PENLTY.ToString(), TextBox16.Text);
ss.setProperty(tid, TaskProperty.ANC_ALPHA.ToString(), TextBox17.Text);
ss.setProperty(tid, TaskProperty.ANC_BETA.ToString(), TextBox18.Text);
ss.setProperty(tid, TaskProperty.ANC_GAMMA.ToString(), TextBox19.Text);
ss.setProperty(tid, TaskProperty.ANC_MIN.ToString(), TextBox20.Text);
ss.setProperty(tid, TaskProperty.ANC_PENLTY.ToString(), TextBox21.Text);
ss.setProperty(tid, TaskProperty.RAN_ALPHA.ToString(), TextBox22.Text);
ss.setProperty(tid, TaskProperty.RAN_BETA.ToString(), TextBox23.Text);
ss.setProperty(tid, TaskProperty.RAN_GAMMA.ToString(), TextBox24.Text);
ss.setProperty(tid, TaskProperty.RAN_DELTA.ToString(), TextBox25.Text);
ss.setProperty(tid, TaskProperty.RAN_NEARBY.ToString(), TextBox26.Text);
}
private static async Task WriteScreenshotsToDisk(string basePathToScreenshotFiles)
{
using (var storage = StorageSystem.GetStorage())
{
using (var loader = ServiceLocator.ResourceLoaderFactory.CreateResourceLoader())
{
var inputStream = await loader.OpenResourceStreamAsync(ResourceScope.Ide,
Path.Combine(ResourcePathToScreenshot, AutomatedScreenshotFilename));
var outputStream = await storage.OpenFileAsync(
Path.Combine(basePathToScreenshotFiles, AutomatedScreenshotFilename),
StorageFileMode.Create, StorageFileAccess.Write);
inputStream.CopyTo(outputStream);
outputStream.Flush();
inputStream.Dispose();
outputStream.Dispose();
var inputStream2 =
await loader.OpenResourceStreamAsync(ResourceScope.Ide,
Path.Combine(ResourcePathToScreenshot, ManualScreenshotFilename));
var outputStream2 = await storage.OpenFileAsync(
Path.Combine(basePathToScreenshotFiles, ManualScreenshotFilename),
StorageFileMode.Create, StorageFileAccess.Write);
inputStream2.CopyTo(outputStream2);
outputStream2.Flush();
inputStream2.Dispose();
outputStream2.Dispose();
}
}
}
public CombatDrone()
//////public Program()
{
shipComponents = new ShipComponents();
LocateAllParts();
log = new Logger(Me.CubeGrid, shipComponents);
communicationSystems = new CommunicationSystem(log, Me.CubeGrid, shipComponents);
navigationSystems = new NavigationSystem(log, Me.CubeGrid, shipComponents);
productionSystems = new ProductionSystem(log, Me.CubeGrid, shipComponents);
storageSystem = new StorageSystem(log, Me.CubeGrid, shipComponents);
trackingSystems = new TrackingSystem(log, Me.CubeGrid, shipComponents);
weaponSystems = new WeaponSystem(log, Me.CubeGrid, shipComponents);
operatingOrder.AddLast(new TaskInfo(LocateAllParts));
operatingOrder.AddLast(new TaskInfo(FollowOrders));
operatingOrder.AddLast(new TaskInfo(SensorScan));
operatingOrder.AddLast(new TaskInfo(AnalyzePlanetaryData));
operatingOrder.AddLast(new TaskInfo(InternalSystemScan));
//operatingOrder.AddLast(new TaskInfo(MaintainAltitude));
operatingOrder.AddLast(new TaskInfo(UpdateTrackedTargets));
operatingOrder.AddLast(new TaskInfo(FollowOrders));
operatingOrder.AddLast(new TaskInfo(UpdateDisplays));
maxCameraRange = 5000;
maxCameraAngle = 80;
//set new defaults
hoverHeight = 100;
}
private static void RemoveFromStorage(Player player, ref MsgStorage packet)
{
if (StorageSystem.TakeOut(player, packet.UniqueId, packet.Param))
{
player.Send(packet);
StorageSystem.ShowStock(player);
}
}
public async Task StoreLocalSettings(LocalSettings localSettings)
{
using (var storage = StorageSystem.GetStorage())
{
await storage.WriteSerializableObjectAsync(
StorageConstants.LocalSettingsFilePath, localSettings);
}
}
public StorageSystemTest()
{
_watchUseCase = new Mock <IWatchRequestUseCase>();
_requestAnalyser = new Mock <IAnalyseRequestUseCase>();
_eventAggregator = new EventAggregator();
_sendUseCase = new Mock <ISendResponseUseCase>();
_storageSystem = new StorageSystem(_watchUseCase.Object, _requestAnalyser.Object, _eventAggregator);
}
private static void ProcessStorage(Player player)
{
var storages = StorageSystem.GetStorageListForId(player, player.CurrentNpcId).ToList();
switch (Control)
{
case 0:
{
if (string.IsNullOrEmpty(Input))
{
goto case 2;
}
if (uint.TryParse(Input, out var storageId))
{
var found = storages.FirstOrDefault(storage => storage.StorageId == storageId);
if (found != null)
{
player.CurrentStorageId = found.StorageId;
player.Send(MsgAction.Create(player, 4, MsgActionType.Dialog));
YiScheduler.Instance.Do(SchedulerPriority.MediumLow, () => StorageSystem.ShowStock(player));
}
}
break;
}
case 1:
{
if (uint.TryParse(Input, out var storageId))
{
var found = storages.FirstOrDefault(storage => storage.StorageId == storageId);
if (found != null)
{
player.CurrentStorageId = found.StorageId;
player.Send(MsgAction.Create(player, 4, MsgActionType.Dialog));
YiScheduler.Instance.Do(SchedulerPriority.MediumLow, () => StorageSystem.ShowStock(player));
break;
}
}
DisplayStorages(player, storages);
break;
}
case 2:
{
if (storages.Count < 1)
{
StorageSystem.NewStorage(player, player.CurrentNpcId);
player.ForceSend(MsgAction.Create(player, 4, MsgActionType.Dialog), 24);
//Player.Send(MsgStorage.Create(Player.CurrentStorageId, MsgStorageAction.List));
YiScheduler.Instance.Do(SchedulerPriority.MediumLow, () => StorageSystem.ShowStock(player));
break;
}
DisplayStorages(player, storages);
break;
}
}
}
public static async Task <bool> Load()
{
try
{
UniqueIdGenerator.Load();
LoadItems();
SquigglyDb.LoadMaps();
SquigglyDb.LoadMobs();
SquigglyDb.LoadSpawns();
SquigglyDb.LoadNpcs();
SquigglyDb.LoadLevelExp();
SquigglyDb.LoadPortals();
SquigglyDb.LoadItemBonus();
SquigglyDb.Spawn();
await Task.WhenAll(LoadStatpoints(), LoadSkills(), LoadAccounts(),
LoadFloorItems(), LoadStoragePool(), LoadBoothPool());
StorageSystem.SetUpStorageSpaces();
BoothSystem.SetUpBooths();
FloorItemSystem.SetUpFloorItemSystem();
Output.WriteLine("|------------ Player Data ------------");
Output.WriteLine("|");
Output.WriteLine("|---> Accounts: " + SelectorSystem.Players.Count);
Output.WriteLine("|---> Storages: " + StorageSystem.StoragePool.Count);
Output.WriteLine("|---> Booths: " + BoothSystem.BoothPool.Count);
Output.WriteLine("|");
Output.WriteLine("|------------ Common Data ------------");
Output.WriteLine("|");
Output.WriteLine("|---> Bots: " + GameWorld.CountBots());
Output.WriteLine("|---> Monsters: " + GameWorld.CountMonsters());
Output.WriteLine("|---> Npcs: " + GameWorld.CountNpcs());
Output.WriteLine("|---> DynamicNpcs: " + GameWorld.CountDynNpcs());
Output.WriteLine("|---> Maps: " + GameWorld.Maps.Count);
Output.WriteLine("|---> FloorItems: " + FloorItemSystem.FloorItems.Count);
Output.WriteLine("|---> Items: " + Collections.Items.Count);
Output.WriteLine("|---> ItemBonus: " + Collections.ItemBonus.Count);
Output.WriteLine("|---> LevelExp: " + Collections.LevelExps.Count);
Output.WriteLine("|---> StatPoints: " + Collections.Statpoints.Count);
Output.WriteLine("|---> Skills: " + Collections.Skills.Count);
Output.WriteLine("|---> Portals: " + Collections.Portals.Count);
Output.WriteLine("|---> Mob Drops: " + MobDropSystem.Drops.Count);
await SetUpScriptingEngine();
Output.WriteLine("|-------------------------------------");
Output.WriteLine("");
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
YiCore.CompactLoh();
return(true);
}
catch (Exception ex)
{
Output.WriteLine(ex);
return(false);
}
}
protected void Button5_Click(object sender, EventArgs e)
{
TaskStatus task = validateTask();
if (task != null)
{
StorageSystem.getInstance().removeAllResults(task.getTaskID());
}
}
public async Task <ExtractProgramResult> ExtractProgram(CancellationToken taskCancellationToken)
{
ExtractProgramResult _extractResult = new ExtractProgramResult {
Status = ExtractProgramStatus.Success
};
try
{
if (_programStream == null && _onlineProgramHeader == null)
{
throw new Exception(
"SetProgramStream or SetDownloadHeader have to be called before calling StartImportProgram.");
}
if (_programStream == null && _onlineProgramHeader == null)
{
throw new Exception("SetProgramStream and SetDownloadHeader cannot be used together.");
}
// old simple portable downloader
var cancellationTokenSource = new CancellationTokenSource();
if (_onlineProgramHeader != null)
{
_programStream = await Task.Run(() => ServiceLocator.WebCommunicationService.DownloadAsync(
_onlineProgramHeader.DownloadUrl, _onlineProgramHeader.ProjectName, cancellationTokenSource.Token), taskCancellationToken);
}
// new downloader
//if (_onlineProgramHeader != null)
//{
// await Task.Run(() => ServiceLocator.WebCommunicationService.DownloadAsyncAlternativ(
// _onlineProgramHeader.DownloadUrl, _onlineProgramHeader.ProjectName), taskCancellationToken);
//}
//using (var storage = StorageSystem.GetStorage())
//{
// var stream = await storage.OpenFileAsync(Path.Combine(StorageConstants.TempProgramImportZipPath, _onlineProgramHeader.ProjectName + ".catrobat"),
// StorageFileMode.Open, StorageFileAccess.Read);
// await ServiceLocator.ZipService.UnzipCatrobatPackageIntoIsolatedStorage(
// stream, StorageConstants.TempProgramImportPath);
//}
if (_cancellationTokenSource.Token.IsCancellationRequested == false)
{
await ServiceLocator.ZipService.UnzipCatrobatPackageIntoIsolatedStorage(
_programStream, StorageConstants.TempProgramImportPath);
}
}
catch (Exception)
{
_extractResult.Status = ExtractProgramStatus.Error;
}
using (var storage = StorageSystem.GetStorage())
{
await storage.DeleteDirectoryAsync(StorageConstants.TempProgramImportZipPath);
}
return(_extractResult);
}
static void AssertStorageSystem(StorageSystem storageSystem, StorageSystemOptions options)
{
AssertContainer(storageSystem, options);
Assert.AreEqual(storageSystem.StorageUsed, options.StorageUsed);
Assert.AreEqual(storageSystem.StorageTotal, options.StorageTotal);
Assert.AreEqual(storageSystem.StorageFree, options.StorageFree);
Assert.AreEqual(storageSystem.StorageMedium, options.StorageMedium);
Assert.AreEqual(storageSystem.StorageMaxPartition, options.StorageMaxPartition);
}
public async Task CleanUpExport()
{
using (var storage = StorageSystem.GetStorage())
{
await storage.DeleteDirectoryAsync(StorageConstants.TempProgramExportPath);
await storage.DeleteDirectoryAsync(StorageConstants.TempProgramExportZipPath);
}
}
public async Task Delete(Program project)
{
var path = project.BasePath + "/" + StorageConstants.ProgramSoundsPath + "/" + _fileName;
using (var storage = StorageSystem.GetStorage())
{
await storage.DeleteFileAsync(path);
}
}
protected void Button2_Click(object sender, EventArgs e)
{
if (Session["Task"] != null)
{
TaskStatus task = (TaskStatus)Session["Task"];
task.setTaskStatus(Status.Waiting);
StorageSystem.getInstance().changeWorkDetails(task);
Page_Load(null, null);
}
}
