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();
}
