static void MainD(string[] args) { Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var io = new Io(args); var T = io.Read<int>(); T.Times((X) => { var L = io.ReadArray<int>(); int K = L[0], C = L[1], S = L[2]; if (C*S < K) { WriteLine($"Case #{X + 1}: IMPOSSIBLE"); return; } var pos = new List<long>(); int i = 0; while (i < K) { int pi = i; i = Math.Min(i + C - 1, K - 1); long p = 0; while (pi <= i) p = p*K + (pi++); pos.Add(p+1); ++i; } WriteLine($"Case #{X+1}: "+ string.Join(" ", pos)); }); }
private static void Main(string[] args) { Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var io = new Io(args); var T = io.Read<int>(); T.Times((C) => { WriteLine($"Case #{C+1}:"); var L = io.ReadArray<int>(); int N = L[0], J = L[1]; int ij = 0; while (J > 0) { var jc = string.Concat('1', Convert.ToString(ij++, 2).PadLeft(N - 2, '0'), '1'); var bases = GetBaseValues(jc); var divisors = GetDivisors(bases); if (divisors.Length() == bases.Length()) { WriteLine($"{jc} "+string.Join(" ", divisors)); --J; } } }); }
static void MainB(string[] args) { Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var io = new Io(args); var T = io.Read<int>(); T.Times((C) => { var stack = io.In.ReadLine() .Select(c => int.Parse(c + "1")).ToArray(); int i = 0, flipCnt = 0, startSide = stack.FirstOrDefault(); while (startSide != 0 && i < stack.Length) { if (stack[i] != startSide) { ++flipCnt; startSide *= -1; } ++i; } if (startSide < 0) ++flipCnt; WriteLine($"Case #{C+1}: {flipCnt}"); }); }
public AssetHandlerManager(SiteConfiguration configuration, Io io, IEnumerable<IHandlerPlugin> customHandlerPlugins) { _configuration = configuration; _io = io; TemplateHandler = new TemplateHandler(configuration, io, this); PostHandler = new PostHandler(configuration, io); GeneratedContentHandler = new GeneratedContentHandler(configuration); MarkdownPageHandler = new MarkdownPageHandler(configuration, io); TransformableContentHandler = new TransformableContentHandler(configuration, io); StaticContentHandler = new StaticContentHandler(configuration, io); _allHandlers = new List<IAssetHandler> { TemplateHandler, PostHandler, GeneratedContentHandler, MarkdownPageHandler, TransformableContentHandler }; var customHandlers = customHandlerPlugins.Select(plugin => plugin.CreateHandler(configuration, io)); _allHandlers.AddRange(customHandlers); _allHandlers.Add(StaticContentHandler); }
public FileStrategy(Io.Strategy.IStrategy persistenceStrategy, string filePath) { _file = new Io.Client(persistenceStrategy); _filePath = filePath; if (!_file.Exists(_filePath)) _file.Write(filePath, new List<Response>()); Trail = _file.Read<List<Response>>(filePath); }
/// <summary> /// A bit of a kitchen sink. Will instantiate Dispatch, Email, File, Audit, Notification, and map default commands and listeners. /// </summary> /// <param name="smtpClient"></param> /// <param name="ioStrategy"></param> public AppContext(SmtpClient smtpClient, Io.Strategy.IStrategy ioStrategy) { Dispatch = new Client(); Email = new Email.Client(smtpClient); File = new Io.Client(ioStrategy); Audit = new Audit.Client(); Notification = new Notification.Client(Email); RegisterCommands(); MapListeners(); }
public override void Execute(List <ushort> args) { var stream = Io.Restore(); if (stream != null) { RestoreState(stream); } if (Memory.Header.Version < 5) { Memory.Jump(true); } else { Memory.VariableManager.Store(Memory.GetCurrentByteAndInc(), 1); } }
private static void Main(string[] args) { Io.Initialize(); var game = new Game(); game.InitializeMap(); var agent = new ReactAgent(game); // game loop while (true) { game.ReadTurn(); Io.WriteLine(agent.Think()); // MOVE <pacId> <x> <y> } }
/// <summary> /// Finds the folder that contains the content.opf folder for loading the file /// </summary> /// <param name="newContent"></param> /// <returns></returns> private async Task <StorageFolder> FindContentOpfFolder(string[] newContent) { StorageFolder directoryFolder; StorageFolder folderOne; StorageFolder folderTwo; switch (newContent.Length) { case 2: return(await Io.CreateOrGetFolder(newContent[0], _appFolder)); case 3: directoryFolder = await Io.CreateOrGetFolder(newContent[0], _appFolder); return(await Io.CreateOrGetFolder(newContent[1], directoryFolder)); case 4: directoryFolder = await Io.CreateOrGetFolder(newContent[0], _appFolder); folderOne = await Io.CreateOrGetFolder(newContent[1], directoryFolder); return(await Io.CreateOrGetFolder(newContent[2], folderOne)); case 5: directoryFolder = await Io.CreateOrGetFolder(newContent[0], _appFolder); folderOne = await Io.CreateOrGetFolder(newContent[1], directoryFolder); folderTwo = await Io.CreateOrGetFolder(newContent[2], folderOne); return(await Io.CreateOrGetFolder(newContent[3], folderTwo)); default: directoryFolder = await Io.CreateOrGetFolder(newContent[0], _appFolder); folderOne = await Io.CreateOrGetFolder(newContent[1], directoryFolder); folderTwo = await Io.CreateOrGetFolder(newContent[2], folderOne); var folderThree = await Io.CreateOrGetFolder(newContent[3], folderTwo); return(await Io.CreateOrGetFolder(newContent[4], folderThree)); } }
public void DeleteSource() { var src = Get("Complex.zip"); var dest = Get("DeleteSource"); var args = Preset.Extract.ToArguments().Concat(src); var value = new ExtractSetting { SaveLocation = SaveLocation.Preset, SaveDirectory = dest, DeleteSource = true, }; Io.Copy(GetSource("Complex.1.0.0.zip"), src, true); Assert.That(Io.Exists(src), Is.True); using var vm = NewVM(args, value); vm.Test(); Assert.That(Io.Exists(src), Is.False); Assert.That(Io.Exists(Io.Combine(dest, "Complex")), Is.True); }
static void MainA(string[] args) { Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var io = new Io(args); var T = io.Read<int>(); T.Times((C) => { var digits = New(); int i = 0, n = io.Read<int>(); while (i++ < 100) { KeepTrack(digits, i*n); if (AllSeen(digits)) break; } WriteLine($"Case #{C + 1}: "+ (n == 0 ? "INSOMNIA" : (i*n).ToString())); }); }
public void BasicSequenceTest() { var xs = new[] { 1, 2, 3, 4, 5 }; var expectedResult = new[] { 2, 3, 4, 5, 6 }; var expectedState = 5; var program = from x in xs.ToIoStateEnumerable <Tuple <int, int>, int>() from _1 in State.Mod <Tuple <int, int> >(pair => Tuple.Create(pair.Item1 + 1, pair.Item2)).ToIoStateEnumerable() where x > 3 from _2 in State.Mod <Tuple <int, int> >(pair => Tuple.Create(pair.Item1, pair.Item2 + 1)).ToIoStateEnumerable() from _3 in Io.Apply(() => Console.WriteLine(x)).ToIoStateEnumerable <Tuple <int, int>, Unit>() select x + 1; var result = program.Out().UnsafePerformIo().Run(Tuple.Create(0, 0)); Assert.AreEqual(expectedState, result.Item1); Assert.AreEqual(expectedResult, result.Item2); }
public void WithFilter() { var src = GetSource("SampleFilter.zip"); var dest = Get(nameof(WithFilter)); var files = new[] { ".DS_Store", "Thumbs.db", "__MACOSX", "desktop.ini" }; var opts = new ArchiveOption { Filter = Filter.From(files) }; using (var archive = new ArchiveReader(src, opts)) archive.Save(dest); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用")), Is.True); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\.DS_Store")), Is.False); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\desktop.ini")), Is.False); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\DS_Store.txt")), Is.True); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\Thumbs.db")), Is.False); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\__MACOSX")), Is.False); Assert.That(Io.Exists(Io.Combine(dest, @"フィルタリング テスト用\フィルタリングされないファイル.txt")), Is.True); }
public void TestDualSocketWebSocket() { bool hit1 = false; bool hit2 = false; var randomPort = RandomPort.Get(); var socketListener = Io.CreateListener("127.0.0.1", randomPort, SocketHandlerType.WebSocket); var socketSender = Io.CreateSender("127.0.0.1", randomPort, SocketHandlerType.WebSocket); socketListener.On("connect", () => { hit1 = true; socketListener.On("test", (int package) => { if (package == 5) { hit2 = true; } }); socketSender.Emit("test", 5); }); socketSender.Emit("connect"); int timer = 0; int timeout = 5000; while ((!hit1 || !hit2) && timer < timeout) { Thread.Sleep(100); timer += 100; } socketSender.Close(); socketListener.Close(); Assert.IsTrue(hit1 && hit2); }
public void SearchPosition(ref S_SearchInfo info) { // Iterative deepening int bestMove = Variables.NO_MOVE; int bestScore = -infinite; int currentDepth = 0; Clear(ref info); for (currentDepth = 1; currentDepth <= info.Depth; ++currentDepth) { bestScore = AlphaBeta(-infinite, infinite, currentDepth, ref info, true); if (info.Stopped) { break; } var pvMoves = PvTable.GetLine(currentDepth, board); bestMove = board.PvArray[0]; // First move in the PvArray, is the best move. Console.Write("info score cp {0} depth {1} nodes {2} time {3} ", bestScore, currentDepth, info.Nodes, Variables.Watch.ElapsedMilliseconds - info.StartTime); pvMoves = PvTable.GetLine(currentDepth, board); Console.Write("pv:"); for (int PvNum = 0; PvNum < pvMoves; ++PvNum) { int move = board.PvArray[PvNum]; Console.Write(" {0}", Io.MoveToString(move)); } Console.Write("\n"); /* * if (info.Fh != 0) { // Cannot divide by zero. * Console.Write("Ordering: {0}\n", info.Fhf / info.Fh); * } */ } // info score cp 13 depth 1 nodes 13 time 15 pv f1b5 Console.Write("bestmove {0}\n", Io.MoveToString(bestMove)); }
public async Task TestDualSocketUDPAsync() { bool hit1 = false; bool hit2 = false; var randomPort = RandomPort.Get(); var socketSender = await Io.CreateSenderAsync(IP, randomPort, SocketHandlerType.Udp); var socketListener = Io.CreateListener(IP, randomPort, SocketHandlerType.Udp); socketListener.On("connect", async() => { hit1 = true; socketListener.On("test", (int package) => { if (package == 5) { hit2 = true; } }); await socketSender.EmitAsync("test", 5); }); await socketSender.EmitAsync("connect"); int timer = 0; int timeout = 5000; while ((!hit1 || !hit2) && timer < timeout) { Thread.Sleep(100); timer += 100; } socketSender.Close(); socketListener.Close(); Assert.True(hit1 && hit2); }
public void Extract(string dest, IEnumerable <string> files, IEnumerable <string> args, ExtractSetting settings) { settings.SaveDirectory = Get("Preset"); using var vm = NewVM(args.Concat(files.Select(e => GetSource(e))), settings); using (vm.SetPassword("password")) // if needed using (vm.SetDestination(Get("Runtime"))) { Assert.That(vm.State, Is.EqualTo(TimerState.Stop)); Assert.That(vm.Cancelable, Is.False); Assert.That(vm.Suspended, Is.False); Assert.That(vm.Count, Is.Not.Null.And.Not.Empty); Assert.That(vm.Title, Does.StartWith("0%").And.EndsWith("CubeICE")); Assert.That(vm.Text, Does.StartWith("ファイルを解凍する準備をしています")); vm.Test(); GetType().LogDebug(vm.Elapsed, vm.Remaining, vm.Title); } Assert.That(Io.Exists(Get(dest)), Is.True, dest); }
public void Rename() { var dummy = GetSource("Sample.txt"); var dest = Get(@"Rename"); var args = Preset.Extract.ToArguments().Concat(GetSource("Complex.1.0.0.zip")); var value = new ExtractSetting { SaveLocation = SaveLocation.Preset, SaveDirectory = dest, }; Io.Copy(dummy, Io.Combine(dest, @"Complex.1.0.0\Foo.txt"), true); Io.Copy(dummy, Io.Combine(dest, @"Complex.1.0.0\Directory\Empty.txt"), true); using var vm = NewVM(args, value); using (vm.SetOverwrite(OverwriteMethod.Rename)) vm.Test(); Assert.That(Io.Exists(Io.Combine(dest, @"Complex.1.0.0\Foo(1).txt")), Is.True); Assert.That(Io.Exists(Io.Combine(dest, @"Complex.1.0.0\Directory\Empty(1).txt")), Is.True); }
private void SetupInternalRegisters() { InternalRegisters = Enumerable.Range(0, 16) .Select(x => Enumerable.Range(0, 16).Select(y => { var reg = _byteRegisterFactory.Create(updateWire => { Io.UpdateData(new BusMessage <IByte> { Name = $@"RamInternalRegister{x}{y}", Data = updateWire }); Io.UpdateSubs(); }, $@"RamInternalRegister{x}{y}"); return(reg); }).ToList()).ToList(); foreach (var register in InternalRegisters.SelectMany(internalRegisterRow => internalRegisterRow)) { Io.AddRegister(register); } }
private List <(string src, string dst)> GetFilesToCopy(NugetInfo nugetInfo) { var filesToCopy = new List <(string src, string dst)>(); var dir = $"{nugetInfo.Name}.{nugetInfo.Version}"; var extractionDir = Path.Combine(_composeSettings.TmpExtractionPath, dir); foreach (var copyPath in nugetInfo.CopyPaths) { var s = copyPath.Src.StartsWith("/") ? copyPath.Src.Substring(1) : copyPath.Src; var d = copyPath.Dst.StartsWith("/") ? copyPath.Dst.Substring(1) : copyPath.Dst; var src1 = Path.Combine(extractionDir, s); var dst1 = Path.Combine(_composeSettings.CefSharpEnvPath, d); Io.CreateDirIfNotExist(dst1); var files = GetFiles(src1); var copyList = CreateCopyList(src1, dst1, files); filesToCopy.AddRange(copyList); } return(filesToCopy); }
private async Task StepGetNugetPackages(ComposeSettings settings) { foreach (var p in settings.Nugets) { var file = $"{p.Name}.{p.Version}.nupkg"; var path = Path.Combine(settings.LocalNugetSourcePath, p.Name, p.Version); var local = Path.Combine(path, file); if (File.Exists(local) && settings.UseLocalNugetSource) { _logFn($"Copy '{p.Name}' from local repository"); var dst = Path.Combine(settings.TmpDownloadPath, file); await Io.CopyFileAsync(local, dst); } else { _logFn($"Download '{p.Name}' from nuget repository"); await DownloadOneNuget(settings, p, file); } } }
/// <summary> /// Adds the piece to the board on the parameter square. /// </summary> /// <param name="sq"> The position of the piece </param> /// <param name="pce"> The piece to add to the board </param> /// <param name="board"> The board to add to </param> public static void AddPiece(int sq, Board.Board board, int pce) { Debug.Assert(Validators.PieceValid(pce), String.Format("Invalid Piece integer value {0}", pce)); Debug.Assert(Validators.IsSq(sq), String.Format("Invalid Square {0}", Io.SqToString(sq))); int colour = (int)Data.PIECE_COLOURS[pce]; // Hash in the piece MakeMove.HashPiece(board, pce, sq); // Add the piece to the board board[sq] = pce; // Add the value of the piece to the material total. board.Material[colour] += Data.PIECE_VAL[pce]; if (Data.IS_PIECE_BIG[pce]) { board.BigPieces[colour]++; if (Data.IS_PIECE_MAJ[pce]) { board.MajPieces[colour]++; } else // else piece is minor piece { board.MinPieces[colour]++; } } else // else piece is pawn. { int sq64 = Conversion.getSq120ToSq64(sq); BitBoard.SetBit(ref board.Pawns[colour], sq64); BitBoard.SetBit(ref board.Pawns[(int)Colour.BOTH], sq64); } // holds the position of every piece on the board. // pList[(int) wN][0] = E1; // pList[(int) wN][1] = D4; ... ... // emptySquares initialized to NO_SQ. board.PList[pce, board.PceNum[pce]++] = sq; }
private MoveAction MoveToNeighbourPellet(Pac pac, Cell cell) { var cellsToConsider = new List <Cell>(); foreach (var(_, neighbour) in cell.Neighbours) { if (neighbour.HasPellet && !ShouldAvoidCell(pac, neighbour)) { cellsToConsider.Add(neighbour); } } if (cellsToConsider.Any()) { if (pac.SpeedTurnsLeft > 0) { foreach (var cellConsider in cellsToConsider) { foreach (var(_, neighbour) in cellConsider.Neighbours) { if (neighbour.HasPellet && !ShouldAvoidCell(pac, neighbour)) { Io.Debug($"Pac Id {pac.Id} : Neighbour Pellet Speed : {cellConsider.Position} : {neighbour.Position}"); _chosenCells[pac.Id] = neighbour; _moveCells.Add(cellConsider); _moveCells.Add(neighbour); return(new MoveAction(neighbour.Position)); } } } } var nextCell = cellsToConsider.First(); Io.Debug($"Pac Id {pac.Id} : Neighbour Pellet : {nextCell.Position}"); _chosenCells[pac.Id] = nextCell; _moveCells.Add(nextCell); return(new MoveAction(nextCell.Position)); } return(null); }
/// <summary> /// Revives the IONpcData. /// </summary> /// <param name="reposition">if <tt>true</tt> IONpcData is moved to their initial position</param> public void ReviveNpc(bool reposition) { // TODO - check if secondary inventory belongs to the IONpcData // and kill it // if ((TSecondaryInventory) && (TSecondaryInventory->io == io)) { // TSecondaryInventory = NULL; // } Script.Instance.SetMainEvent(Io, "MAIN"); Io.RemoveIOFlag(IoGlobals.IO_07_NO_COLLISIONS); RestoreLifeToMax(); Script.Instance.ResetObject(io, true); RestoreLifeToMax(); if (reposition) { MoveToInitialPosition(); } // reset texture - later // long goretex = -1; // for (long i = 0; i < io->obj->nbmaps; i++) { // if (io->obj->texturecontainer // && io->obj->texturecontainer[i] // && (IsIn(io->obj->texturecontainer[i]->m_strName, "GORE"))) { // goretex = i; // break; // } // } // for (long ll = 0; ll < io->obj->nbfaces; ll++) { // if (io->obj->facelist[ll].texid != goretex) { // io->obj->facelist[ll].facetype &= ~POLY_HIDE; // } else { // io->obj->facelist[ll].facetype |= POLY_HIDE; // } // } cuts = 0; }
private void btnSubmit_Click(object sender, RoutedEventArgs e) { int numprocs = Convert.ToInt32(txtNumOfProcs.Text); var userin = new UserInput(); List <Process> lp = userin.makeProcesses(numprocs); var processLoad = new ProcessLoad { Processes = userin.makeProcesses(numprocs), }; int last = numprocs + 1; int arraycpu = 0; int arrayio = 0; int time2 = 0; var scheduler = new FirstComeFirstServed(processLoad); var io = new Io(); var cpu = new Cpu(); ProcessDispatcher = new ProcessDispatcher(); var result = this.ProcessDispatcher.Start(scheduler, cpu, io); var cpuHistory = cpu.History; var ioHistory = io.History; var consoleOutput = new ConsoleOutput(); consoleOutput.PrintHistory(cpuHistory, ioHistory); double cpuutil = Convert.ToDouble(arraycpu) / Convert.ToDouble(time2) * 100.0; Int32 total = Convert.ToInt32(cpuutil); pfcfs.Value = total; int waittime = (time2 - arrayio) / numprocs; lfcfswait.Content = waittime; }
private async Task <PackagesInfo[]> Download(PackagesInfo[] packages) { var tmp = Path.Combine(_tmpDir, "download"); Io.CreateDirIfNotExist(tmp); foreach (var packagesInfo in packages) { var n = packagesInfo.NugetInfo; var url = $"https://www.nuget.org/api/v2/package/{n.Name}/{n.Version}"; var fileName = $"{n.Name.ToLower()}.{n.Version.ToLower()}.nupkg"; var dstFile = Path.Combine(tmp, fileName); if (!File.Exists(dstFile)) { await Common.Download.DownloadFileAsync(url, dstFile); } packagesInfo.SetNugetPath(dstFile); } return(packages); }
public void MoveFailed() { var dir = Get("MoveFailed"); var src = new[] { GetSource("Sample.txt") }; var dest = Io.Combine(dir, "Sample.zip"); var args = Preset.CompressZip.ToArguments().Concat(new[] { "/o:runtime" }).Concat(src); var value = new CompressSetting { SaveLocation = SaveLocation.Preset, SaveDirectory = dir, OpenMethod = OpenMethod.None, }; Io.Copy(GetSource("Single.1.0.0.zip"), dest, true); using var vm = NewVM(args, value); using (Io.Open(dest)) using (vm.SetDestination(dest)) { vm.Test(); } }
/* ----------------------------------------------------------------- */ /// /// Invoke /// /// <summary> /// Invokes the file association. /// </summary> /// /* ----------------------------------------------------------------- */ public static void Invoke(AssociateSetting src) => typeof(AssociateAction).LogWarn(() => { if (!src.Changed) { return; } var dir = typeof(AssociateAction).Assembly.GetDirectoryName(); var exe = Io.Combine(dir, Properties.Resources.FileAssociate); if (Io.Exists(exe)) { System.Diagnostics.Process.Start(exe).WaitForExit(); } else { typeof(AssociateAction).LogWarn($"{exe} not found"); } src.Changed = false; });
public ActionResult AjaxIndexBannerDelete(IndexBannerParameter param) { var result = new JsonNetResult(); var r = new GeneralResponse(); try { var detail = IndexBannerTableProvider.Detail(param); r.Code = IndexBannerTableProvider.Delete(param).ToString(Section.Get.Common.Culture); if (!string.IsNullOrEmpty(detail.ImgPath)) { Io.DeleteFile(System.Web.HttpContext.Current.Server.MapPath($"~{detail.ImgPath}")); } } catch (Exception ex) { Log.Error(ex.Message, ex); r.Code = "-11"; } result.Data = r; return(result); }
/* ----------------------------------------------------------------- */ /// /// Invoke /// /// <summary> /// Extracts an archive item of the specified index. /// </summary> /// /* ----------------------------------------------------------------- */ private void Invoke(ArchiveReader src, int index, ExtractDirectory dir) { GetType().LogDebug($"Format:{src.Format}", $"Source:{src.Source}"); SetDestination(src, dir); var item = src.Items[index]; Retry(() => src.Save(Temp, item, GetProgress())); var dest = Io.Combine(Temp, item.FullName); if (Formatter.FromFile(dest) != Format.Tar) { Move(item); } else { using var e = new ArchiveReader(dest, Password, src.Options); Invoke(e, dir); } }
// Use this for initialization void Start() { status = GetComponent <Status>(); bstatus = GetComponent <BulletStatus>(); bullet_base.Add("Long", long_bullet_base); bullet_base.Add("Middle", middle_bullet_base); bullet_base.Add("Short", short_bullet_base); bullet_base_scale.Add("Long", bullet_base["Long"].transform.localScale); bullet_base_scale.Add("Middle", bullet_base["Middle"].transform.localScale); bullet_base_scale.Add("Short", bullet_base["Short"].transform.localScale); bs.Add("Long", bstatus.type["Long"]); bs.Add("Middle", bstatus.type["Middle"]); bs.Add("Short", bstatus.type["Short"]); bullet_base["Long"].transform.localScale = Vector3.zero; bullet_base["Middle"].transform.localScale = Vector3.zero; bullet_base["Short"].transform.localScale = Vector3.zero; io = GameObject.Find("System").GetComponent <Io> (); id = int.Parse(tag.Substring(6, 1)) - 1; tk = GameObject.Find("System").GetComponent <TimeKeeper> (); }
private IAction GetNextSpell(Spell spell, int[] inventory, List <Spell> spells) { Io.Debug($"Checking spell {spell}"); var ingredientsCost = spell.IngredientsCost; var needsReset = false; for (var i = 0; i < Constants.IngredientTiers; i++) { if (ingredientsCost[i] < 0) { Io.Debug($"Needs {-ingredientsCost[i]} of Tier{i}"); if (inventory[i] > 0) { Io.Debug($"Has {inventory[i]} of Tier{i}"); } if (inventory[i] < -ingredientsCost[i]) { Io.Debug($"Needs spell for Tier{i}"); var requiredSpell = spells.FirstOrDefault(s => s.IngredientsCost[i] > 0); if (requiredSpell == null) { needsReset = true; } else { return(GetNextSpell(requiredSpell, inventory, spells)); } } } } if (needsReset) { return(new RestAction()); } return(new CastAction(spell.ActionId)); }
public void Compress(string dest, IEnumerable <string> files, IEnumerable <string> args, CompressSetting settings) { using var vm = NewVM(args.Concat(files.Select(e => GetSource(e))), settings); var filename = GetFileName(GetSource(files.First()), dest); var cvt = Get("Runtime", filename); using (vm.SetPassword("password")) using (vm.SetDestination(cvt)) using (vm.SetRuntime(cvt)) { Assert.That(vm.State, Is.EqualTo(TimerState.Stop)); Assert.That(vm.Cancelable, Is.False); Assert.That(vm.Suspended, Is.False); Assert.That(vm.Count, Is.Not.Null.And.Not.Empty); Assert.That(vm.Title, Does.StartWith("0%").And.EndsWith("CubeICE")); Assert.That(vm.Text, Does.StartWith("ファイルを圧縮する準備をしています")); vm.Test(); GetType().LogDebug(vm.Elapsed, vm.Remaining, vm.Title); } Assert.That(Io.Exists(Get(dest)), Is.True, dest); }
public override void Execute(List <ushort> args) { var state = CreateState(); try { var saveSuccessful = Io.Save(state); state.Dispose(); if (Memory.Header.Version < 5) { Memory.Jump(saveSuccessful); } else { Memory.VariableManager.Store(Memory.GetCurrentByteAndInc(), saveSuccessful.ToOneOrZero()); } } catch (Exception) { // ignored: we don't want to crash the machine so ignore any IO errors } }
public async Task TestWebSocketAsync() { bool hit1 = false; bool hit2 = false; var randomPort = RandomPort.Get(); var socket = await Io.CreateAsync("127.0.0.1", randomPort, randomPort, SocketHandlerType.WebSocket); socket.On("connect", async() => { hit1 = true; socket.On("test", (int package) => { if (package == 5) { hit2 = true; } }); await socket.EmitAsync("test", 5); }); await socket.EmitAsync("connect"); int timer = 0; int timeout = 5000; while ((!hit1 || !hit2) && timer < timeout) { Thread.Sleep(100); timer += 100; } socket.Close(); Assert.IsTrue(hit1 && hit2); }
private void ParseActions() { var numberOfActions = int.Parse(Io.ReadLine()); for (var i = 0; i < numberOfActions; i++) { var inputs = Io.ReadLine().Split(' '); var actionType = ActionTypeExtension.FromString(inputs[1]); if (actionType == ActionType.Brew) { Potions.Add(new Potion(int.Parse(inputs[0]), int.Parse(inputs[2]), int.Parse(inputs[3]), int.Parse(inputs[4]), int.Parse(inputs[5]), int.Parse(inputs[6]))); } else if (actionType == ActionType.Cast) { Spells.Add(new Spell(int.Parse(inputs[0]), int.Parse(inputs[2]), int.Parse(inputs[3]), int.Parse(inputs[4]), int.Parse(inputs[5]), int.Parse(inputs[9]) != 0)); } else if (actionType == ActionType.OpponentCast) { OpponentSpells.Add(new Spell(int.Parse(inputs[0]), int.Parse(inputs[2]), int.Parse(inputs[3]), int.Parse(inputs[4]), int.Parse(inputs[5]), int.Parse(inputs[9]) != 0)); } } }
public void TestUDP() { bool hit1 = false; bool hit2 = false; var randomPort = RandomPort.Get(); var socket = Io.Create(IP, randomPort, randomPort, SocketHandlerType.Udp); socket.On("connect", () => { hit1 = true; socket.On("test", (int package) => { if (package == 5) { hit2 = true; } }); socket.Emit("test", 5); }); socket.Emit("connect"); int timer = 0; int timeout = 5000; while ((!hit1 || !hit2) && timer < timeout) { Thread.Sleep(100); timer += 100; } socket.Close(); Assert.True(hit1 && hit2); }
public PostHandler(SiteConfiguration configuration, Io io) { _configuration = configuration; _io = io; _posts = new List<Post>(); }
public TransformableContentHandler(SiteConfiguration configuration, Io io) { _configuration = configuration; _io = io; }
public TemplateHandler(SiteConfiguration configuration, Io io, AssetHandlerManager handlers) { _configuration = configuration; _handlers = handlers; _io = io; }
public StaticContentHandler(SiteConfiguration configuration, Io io) { _configuration = configuration; _io = io; }
public MarkdownPageHandler(SiteConfiguration configuration, Io io) { _configuration = configuration; _io = io; }
public Page(string absoluteFilePath) { this._absoluteFilePath = absoluteFilePath; this._io = new Io(); }