public void Write(BeBinaryWriter bw)
{
bw.Write(Flag);
bw.Write(Unknown);
bw.Write(TP);
bw.Write(MaxTP);
bw.Write(Kick);
bw.Write(MaxKick);
bw.Write(Catch);
bw.Write(MaxCatch);
bw.Write(Body);
bw.Write(MaxBody);
bw.Write(Guard);
bw.Write(MaxGuard);
bw.Write(Control);
bw.Write(MaxControl);
bw.Write(Speed);
bw.Write(MaxSpeed);
bw.Write(Unk);
bw.Write(Kakusei);
bw.Write(XP);
bw.Write(MoveUnk);
bw.Write(MoveKakusei2);
bw.Write(MoveKakusei2_2);
bw.Write(MoveKakusei2_3);
bw.Write(MoveKakusei3);
bw.Write(MoveKakusei3_2);
bw.Write(MoveKakusei3_3);
bw.Write(Unk2);
}
/// <summary>
/// Patch app file to map D-Pad directions. This assumes the app file is decompressed.
/// </summary>
/// <param name="config">D-Pad configuration</param>
/// <param name="VCDir">VC directory</param>
private static void PatchApp1(DPadConfig config, string VCDir)
{
using (var app1 = new BeBinaryWriter(File.OpenWrite(Path.Combine(VCDir, "00000001.app"))))
{
var used = config.InUse;
var buttons = new VCControllerButton[]
{
VCControllerButton.DPadUp,
VCControllerButton.DPadDown,
VCControllerButton.DPadLeft,
VCControllerButton.DPadRight,
};
// Fix array for ordering of the fields in app file: Up, Down, Left, Right
used = new bool[] { used[0], used[2], used[3], used[1] };
for (int i = 0; i < used.Length; i++)
{
int offset = DPAD_MAPPING_OFFSET + (i * 4);
app1.Seek(offset, SeekOrigin.Begin);
if (used[i])
{
// If using this D-Pad direction, write its button flag
app1.WriteUInt32((uint)buttons[i]);
}
else
{
// Otherwise write the button flag for the L button
app1.WriteUInt32((uint)VCControllerButton.L);
}
}
}
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
using (var sfd = new SaveFileDialog())
{
sfd.Filter = "Move file(0 / 20.bin) (*.bin) | *.bin | All files(*.*) | *.* ";
sfd.DefaultExt = ".bin";
sfd.FileName = "waza.bin";
if (sfd.ShowDialog() == DialogResult.OK)
{
var filename = sfd.FileName;
var file = File.Open(filename, FileMode.Create);
using (var bw = new BeBinaryWriter(file))
{
bw.Write(data);
bw.BaseStream.Position = 28;
foreach (var waza in moves)
{
waza.Write(bw);
}
}
MessageBox.Show("Succesfully saved.", "Done");
}
}
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
using (var sfd = new SaveFileDialog())
{
sfd.Filter = "Player file(0 / 104.bin) (*.bin) | *.bin | All files(*.*) | *.* ";
sfd.DefaultExt = ".bin";
sfd.FileName = "players.bin";
if (sfd.ShowDialog() == DialogResult.OK)
{
var filename = sfd.FileName;
var file = File.Open(filename, FileMode.Create);
using (var bw = new BeBinaryWriter(file))
{
bw.Write(DataBackup);
bw.BaseStream.Position = 0x10;
bw.Write(Players.Count + 1);
bw.BaseStream.Position = 0xFA4;
foreach (var player in Players)
{
player.Write(bw);
}
}
MessageBox.Show("Succesfully saved.", "Done");
}
}
}
private void BatchLoop(string filename, int nlength)
{
var demotag = Path.Combine(Environment.CurrentDirectory, "demo.sound_looping");
using (var fs = new FileStream(demotag, FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var ds = new FileStream(filename + "_looping", FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var ms = new MemoryStream())
using (var bw = new BeBinaryWriter(ms))
using (var br = new BeBinaryReader(ms))
{
fs.CopyTo(ms);
ms.Position = 0;
var tagpath = filename.Substring(tagsdir.Length + 1);
tagpath = tagpath.Substring(0, tagpath.Length - 6);
MessageBox.Show(tagpath);
var namelength = tagpath.Length;
Byte nan = 0;
bw.BaseStream.Seek(220, SeekOrigin.Begin);
bw.Write(namelength);
bw.BaseStream.Seek(308, SeekOrigin.Begin);
bw.Write(tagpath);
bw.Write(nan);
ms.Position = 0;
fs.Position = 0;
ms.CopyTo(ds);
}
}
public void BeBinaryWriter_WriteBoolTest()
{
using var mstr = CreateMemStream();
using var bw = new BeBinaryWriter(mstr);
using var br = new BeBinaryReader(mstr);
bw.Write(false);
bw.Write(false);
bw.Write(true);
bw.Write(false);
bw.Write(true);
bw.Write(5);
bw.Write(0);
bw.Flush();
mstr.Position = 0;
Assert.That(br.ReadBoolean(), Is.EqualTo(false));
Assert.That(br.ReadBoolean(), Is.EqualTo(false));
Assert.That(br.ReadBoolean(), Is.EqualTo(true));
Assert.That(br.ReadBoolean(), Is.EqualTo(false));
Assert.That(br.ReadBoolean(), Is.EqualTo(true));
Assert.That(br.ReadInt32(), Is.EqualTo(5));
Assert.That(br.ReadInt32(), Is.EqualTo(0));
}
public static void padTo(BeBinaryWriter bw, int padding)
{
while ((bw.BaseStream.Length % padding) != 0)
{
bw.Write((byte)0x00);
}
}
public static void writeDelta(BeBinaryWriter JaiWriter, int delta)
{
if (delta < 0xFF) // 8-bit wait
{
JaiWriter.Write((byte)JaiSeqEvent.WAIT_8); // 8 bit wait command
JaiWriter.Write((byte)delta); // write delta
}
else if (delta < 0xFFFF) // 16 bit wait
{
JaiWriter.Write((byte)JaiSeqEvent.WAIT_16);
JaiWriter.Write((ushort)delta);
}
else // dont feel like writing VLQ timing, so i'll just spam u16 waits :V
{ // VLQ wait.
var total = delta;
while (total > 0xFFFA)
{
total -= 0xFFFA;
JaiWriter.Write((byte)JaiSeqEvent.WAIT_16);
JaiWriter.Write((ushort)0xFFFA);
}
if (total > 0)
{
JaiWriter.Write((byte)JaiSeqEvent.WAIT_16);
JaiWriter.Write((ushort)total);
}
}
}
/// <summary>
/// Convert to bytes.
/// </summary>
/// <returns>Bytes</returns>
public byte[] ToBytes()
{
using (var memStream = new MemoryStream())
using (var writer = new BeBinaryWriter(memStream))
{
writer.WriteUInt32(this.Version);
// Version 0
writer.WriteBytes(this.Hash);
writer.WriteUInt32(this.Flags);
// Version 1
if (this.Version >= 1)
{
writer.WriteUInt32(this.InternalFlags);
}
// Version 3
if (this.Version >= 3)
{
writer.WriteUInt32(this.Speedups);
writer.WriteUInt32(this.Shorts);
}
return(memStream.ToArray());
}
}
public static void pack_baa(string projectDir, jBAAProjectFile project, string fileName)
{
if (fileName == null)
{
fileName = project.originalFile;
}
var blockStrm = File.OpenWrite(fileName);
var blockWrite = new BeBinaryWriter(blockStrm);
Console.WriteLine("Prewriting BAA header data");
// Prewrite header data so it's length is absolute
blockWrite.Write(libJAudio.Loaders.JA_BAALoader.BAA_Header);
for (int i = 0; i < project.includes.Length; i++)
{
var w = project.includes[i];
var sz = baa_GetSectionHeaderInfo(w);
blockWrite.Write(w.hash);
for (int k = 0; k < sz.size; k++)
{
blockWrite.Write((int)0x00);
}
}
blockWrite.Write(libJAudio.Loaders.JA_BAALoader.BAA_Footer);
blockWrite.Flush();
var head_anchor = 4L; // Start past the AA_<
var tail_anchor = blockWrite.BaseStream.Position;
Console.WriteLine($"Header ends at 0x{tail_anchor:X}");
Console.WriteLine($"-> Project has {project.includes.Length} includes.");
Console.WriteLine("-> Building project...");
for (int i = 0; i < project.includes.Length; i++)
{
var dep = project.includes[i]; // load include
var data = File.ReadAllBytes($"{projectDir}/{dep.path}"); // read include data
Console.WriteLine($"->\t{projectDir}/{dep.path}\tL:0x{data.Length:X} added.");
var sPos = tail_anchor; // set start pos to tail anchor
blockWrite.Write(data); // sprawl data into file
while ((blockWrite.BaseStream.Position & 0xF) != 8)
{
blockWrite.Write((byte)0x00);
blockWrite.Flush();
}
var ePos = blockWrite.BaseStream.Position; // store end position
tail_anchor = ePos; // set tail anchor to end pos
blockWrite.BaseStream.Position = head_anchor; // jump to head anchor
baa_PackSection((int)sPos, (int)ePos, dep, blockWrite); // write section header
head_anchor = blockWrite.BaseStream.Position; // update head anchor.
blockWrite.BaseStream.Position = tail_anchor; // reseek to tail anchor.
// repeat :)
}
Console.WriteLine($"-> Flushing into {fileName}");
blockWrite.Flush();
blockStrm.Flush();
blockWrite.Close();
blockStrm.Close();
Console.WriteLine("Done.");
}
public void Write(BeBinaryWriter bw)
{
bw.Write(Id);
bw.Write(KitNumber);
bw.Write(FormationIndex);
bw.Write(ClubroomKit);
bw.Write(Flag);
}
/// <summary>
/// Create patch data from current ROM state and write to <see cref="Stream"/>.
/// </summary>
/// <param name="outStream">Output stream.</param>
/// <param name="originalMMFiles">Original <see cref="MMFile"/> collection.</param>
/// <returns><see cref="SHA256"/> hash of the patch.</returns>
public static byte[] CreatePatch(Stream outStream, List <MMFile> originalMMFiles)
{
var aes = Aes.Create();
var hashAlg = new SHA256Managed();
using (var cryptoStream = new CryptoStream(outStream, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write))
using (var hashStream = new CryptoStream(cryptoStream, hashAlg, CryptoStreamMode.Write))
using (var compressStream = new GZipStream(hashStream, CompressionMode.Compress))
using (var writer = new BeBinaryWriter(compressStream))
{
// Write magic value.
writer.WriteUInt32(PatchMagic);
Span <byte> headerBytes = stackalloc byte[PatchHeader.Size];
for (var fileIndex = 0; fileIndex < RomData.MMFileList.Count; fileIndex++)
{
var file = RomData.MMFileList[fileIndex];
// Check whether file should be included in the patch.
if (file.Data == null || (file.IsCompressed && !file.WasEdited))
{
continue;
}
if (fileIndex >= originalMMFiles.Count)
{
var index = (uint)fileIndex;
var address = (uint)file.Addr;
// Create header for appending new file.
var header = PatchHeader.CreateNew(index, address, file.Data.Length, file.IsStatic);
header.Write(headerBytes);
// Write header bytes and file contents.
writer.Write(headerBytes);
writer.Write(file.Data);
}
else
{
RomUtils.CheckCompressed(fileIndex, originalMMFiles);
var originalFile = originalMMFiles[fileIndex];
var index = (uint)fileIndex;
var address = (uint)file.Addr;
var diff = VcDiffEncodeManaged(originalFile.Data, file.Data);
// Create header for patching existing file.
var header = PatchHeader.CreateExisting(index, address, diff.Length, file.IsStatic);
header.Write(headerBytes);
// Write header bytes and diff bytes.
writer.Write(headerBytes);
writer.Write(diff);
}
}
}
return(hashAlg.Hash);
}
public static void writeInt24BE(BeBinaryWriter bw, int ta)
{
var b1 = (ta) & 0xFF;
var b2 = (ta >> 8) & 0xFF;
var b3 = (ta >> 16) & 0xFF;
bw.Write((byte)b3);
bw.Write((byte)b2);
bw.Write((byte)b1);
}
public static byte[] ToByteArray(Guid uuid)
{
using MemoryStream stream = new MemoryStream(new byte[16]);
// Needs to be big-endian because the Java ByteBuffer defaults to big-endian.
using BeBinaryWriter buffer = new BeBinaryWriter(stream);
buffer.Write(uuid.GetMostSignificantBits());
buffer.Write(uuid.GetLeastSignificantBits());
return(stream.ToArray());
}
public void Write(BeBinaryWriter bw)
{
bw.Write((ushort)Tier);
bw.Write(BasePower);
bw.Write(MaxPower);
bw.Write(Tp);
bw.Write((ushort)Element);
bw.Write((ushort)Status);
bw.Write(OutputRange);
bw.Write(OutputRangeAssist);
bw.Write(EffectRange);
bw.Write(Unk4);
bw.Write(CoopPartnersCount);
bw.Write(Unka);
bw.Write(Unkb);
bw.Write(Users);
bw.Write(Partners);
bw.Write(Unk5);
bw.Write(Unk6);
bw.Write(Unk7);
bw.Write(Unk8);
bw.Write(Unk9);
bw.Write(Unk10);
bw.Write(TextDescription);
bw.Write(Unk12);
bw.Write(Unk13);
bw.Write(Unk14);
bw.Write(TextUser);
bw.Write(Unk16);
bw.Write(Unk17);
bw.Write(Unk18);
bw.Write(Unk19);
bw.Write(Unk20);
bw.Write(Unk21);
bw.Write(Unk22);
bw.Write(Unk23);
bw.Write(Unk24);
bw.Write(Unk25);
bw.Write(Unk26);
bw.Write(Unk27);
bw.Write(Unk28);
bw.Write(Unk29);
bw.Write(Unk30);
bw.Write(Unk31);
bw.Write(Unk32);
bw.Write(Unk33);
bw.Write(Unk34);
bw.Write(Unk35);
bw.Write(Unk36);
bw.Write(Unk37);
bw.Write(Unk38);
bw.Write((ushort)PowerUpIndicator);
bw.Write(InvocationAnimationTimer);
bw.Write(Unk39);
}
/// <summary>
/// Convert to bytes.
/// </summary>
/// <returns>Bytes</returns>
public byte[] ToBytes()
{
using (var memoryStream = new MemoryStream())
using (var writer = new BeBinaryWriter(memoryStream))
{
writer.WriteUInt32(this.Version);
writer.Write(this.SequenceMaskFileIndex ?? 0);
return(memoryStream.ToArray());
}
}
public static void writeBARCString(BeBinaryWriter barcwrite, string str)
{
byte[] buff = new byte[16];
for (int i = 0; i < str.Length && i < 16; i++)
{
buff[i] = (byte)str[i];
}
buff[14] = 0xFF; // aaa? AAAa.
buff[15] = 0xFF;
barcwrite.BaseStream.Write(buff, 0, 16);
}
private void rebuildAw(int num)
{
var awTemp = File.OpenWrite("awBuild.temp");
var grp = root.currentWSYS.Groups[num];
var grpFile = grp.awFile;
var awOriginal = File.OpenRead(grpFile);
var wss = root.currentWSYSStream;
var wsysWrite = new BeBinaryWriter(wss);
var awWrite = new BeBinaryWriter(awTemp);
var awRead = new BeBinaryReader(awOriginal);
var awOffset = 0;
if (!rebuildData.ContainsKey(num))
{
return;
}
Console.WriteLine("Rebuild request found.");
var rbdWaves = rebuildData[num];
for (int i = 0; i < grp.Waves.Length; i++)
{
var originalWave = grp.Waves[i];
byte[] awBuff;
if (rbdWaves.ContainsKey(i))
{
awBuff = rbdWaves[i];
Console.WriteLine("Injecting custom wave...");
}
else
{
awRead.BaseStream.Position = originalWave.wsys_start;
awBuff = awRead.ReadBytes(originalWave.wsys_size);
}
awTemp.Write(awBuff, 0, awBuff.Length);
wsysWrite.BaseStream.Position = originalWave.mOffset;
wsysWrite.Seek(0x04, SeekOrigin.Current);
wsysWrite.Write((float)originalWave.sampleRate);
wsysWrite.Write(awOffset);
wsysWrite.Write(awBuff.Length);
originalWave.wsys_start = awOffset; // update in-memory copies
originalWave.wsys_size = awBuff.Length; // update in-memory copies
awOffset += awBuff.Length;
wsysWrite.Flush();
awTemp.Flush();
}
Console.WriteLine($"Rebuilt {grpFile}");
awTemp.Close();
awRead.Close();
awOriginal.Close();
File.Delete(grpFile);
File.Move("awBuild.temp", grpFile);
}
public void Write(BeBinaryWriter bw)
{
bw.BaseStream.Position += 2;
bw.Write((short)Kit);
bw.Write(Formation);
bw.Write(Manager);
bw.Write(Coach);
foreach (var player in Players)
{
player.Write(bw);
}
}
public static void writePrint(BeBinaryWriter bw, string data)
{
/*
* var b = Encoding.ASCII.GetBytes(data);
* bw.Write((byte)0xFB); // PrintF
* for (int i = 0; i < data.Length; i ++ )
* {
* bw.Write(data[i]);
* }
* bw.Write((byte)0x00);
* // bw.Write((byte)0x00);
*/
}
/// <summary>
/// Convert to bytes.
/// </summary>
/// <returns>Bytes</returns>
public byte[] ToBytes()
{
using (var memStream = new MemoryStream())
using (var writer = new BeBinaryWriter(memStream))
{
writer.WriteUInt32(this.Version);
foreach (var val in this.RupeeRepeatableLocations)
{
writer.WriteUInt16(val);
}
writer.WriteUInt16(RupeeRepeatableLocationsLength);
writer.WriteUInt16(this.LocationBottleRedPotion);
writer.WriteUInt16(this.LocationBottleGoldDust);
writer.WriteUInt16(this.LocationBottleMilk);
writer.WriteUInt16(this.LocationBottleChateau);
writer.WriteUInt16(this.LocationSwordKokiri);
writer.WriteUInt16(this.LocationSwordRazor);
writer.WriteUInt16(this.LocationSwordGilded);
writer.WriteUInt16(this.LocationMagicSmall);
writer.WriteUInt16(this.LocationMagicLarge);
writer.WriteUInt16(this.LocationWalletAdult);
writer.WriteUInt16(this.LocationWalletGiant);
writer.WriteUInt16(this.LocationWalletRoyal);
writer.WriteUInt16(this.LocationBombBagSmall);
writer.WriteUInt16(this.LocationBombBagBig);
writer.WriteUInt16(this.LocationBombBagBiggest);
writer.WriteUInt16(this.LocationQuiverSmall);
writer.WriteUInt16(this.LocationQuiverLarge);
writer.WriteUInt16(this.LocationQuiverLargest);
writer.WriteByte(this.ExtraStartingMaps);
writer.WriteByte(0); // padding
writer.WriteBytes(this.ExtraStartingItemIds);
writer.WriteUInt16(this.ExtraStartingItemIdsLength);
foreach (var val in this.ItemsToReturnIds)
{
writer.WriteUInt16(val);
}
writer.WriteUInt16(this.ItemsToReturnIdsLength);
return(memStream.ToArray());
}
}
public void Write(BeBinaryWriter bw)
{
bw.Write(ID);
bw.Write(MatchIndex);
bw.Write(HiddenName);
bw.Write(ShortName);
bw.Write(FullName);
bw.Write(Encoding.ASCII.GetBytes(Name));
bw.Write((int)Gender);
bw.Write(IdleAnimation);
bw.Write(Unk_34);
bw.Write(Description);
bw.Write((int)Bodytype);
bw.Write(Scale);
bw.Write(ShadowSize);
bw.Write((int)TacticalAction);
bw.Write(CourseAnimation);
bw.Write(Team);
bw.Write(Emblem);
bw.Write(TeamPortrait);
bw.Write(Position);
bw.Write(MatchFaceModel);
bw.Write(Facemodel);
bw.Write(Facemodel2);
bw.Write(Bodymodel);
bw.Write(Bodymodel2);
bw.Write(Unk_74);
bw.Write(Portrait);
bw.Write(Unk_7C);
bw.Write(LeftPortrait);
bw.Write(RightPortrait);
bw.Write(Encoding.ASCII.GetBytes(Equip[0]));
bw.Write(Encoding.ASCII.GetBytes(Equip[1]));
bw.Write(Unk_B8);
bw.Write(SkinColor1.ToArgb());
bw.Write(SkinColor2.ToArgb());
bw.Write(Unk_F0);
bw.Write((int)Element);
bw.Write(ChargeProfile);
bw.Write(Unk_FC);
bw.Write(Unk_100);
bw.Write(Voice);
bw.Write(ArmedAttribution);
bw.Write(Unk_10C);
bw.Write(Price);
bw.Write(ListPosition);
bw.Write(TeamListPosition);
bw.Write(Unk25);
bw.Write(Pad2);
}
/// <summary>
/// Convert to bytes.
/// </summary>
/// <returns>Bytes</returns>
public byte[] ToBytes()
{
using (var memStream = new MemoryStream())
using (var writer = new BeBinaryWriter(memStream))
{
writer.WriteUInt32(this.Version);
foreach (var color in this.Colors)
{
writer.WriteBytes(color.ToBytesRGB(0));
}
return(memStream.ToArray());
}
}
public static void Save(BeBinaryWriter bw, Save save)
{
save.Team.Write(bw);
bw.Write(save.Team.Emblem);
bw.Write(save.Team.Name);
for (int i = 0; i < 16; i++)
{
var teamPlayer = save.Team.Players[i];
var id = teamPlayer.Id;
var player = save.Players[id];
player.MoveList.Write(bw);
player.Stats.Write(bw);
}
}
/// <summary>
/// Convert to bytes.
/// </summary>
/// <returns>Bytes</returns>
public byte[] ToBytes()
{
using (var memStream = new MemoryStream())
using (var writer = new BeBinaryWriter(memStream))
{
writer.WriteUInt32(this.Version);
// Version 0
writer.WriteBytes(this.Items);
writer.WriteByte(this.State);
writer.WriteByte(this.Display);
return(memStream.ToArray());
}
}
public void ApplyEdits(string filePath)
{
var saveData = File.ReadAllBytes(filename);
var file = File.Open(filePath, FileMode.Create);
using (var bw = new BeBinaryWriter(file))
{
bw.Write(saveData);
bw.BaseStream.Position = ONLINE_PROFILE;
bw.Write(StringTo16LongArray(OnlineName));
bw.Write(OnlineProfile);
bw.BaseStream.Position = BaseOffset + 8;
bw.Write(CreationDate);
bw.Write(CreationTime);
bw.Write(HoursPlayed);
bw.Write(MinutesPlayed);
bw.BaseStream.Position = BaseOffset + INAZUMA_POINT_OFFSET;
bw.Write(InazumaPoints);
bw.BaseStream.Position = BaseOffset + PROFILENAME_OFFSET;
bw.Write(StringTo16LongArray(ProfileName));
for (var i = 0; i < 412; i++)
{
var player = Players[i];
// STATS
bw.BaseStream.Position = BaseOffset + STATS_OFFSET + i * 0x3c;
player.Stats.Write(bw);
// WAZA
bw.BaseStream.Position = BaseOffset + WAZA_OFFSET + i * 0x22;
player.MoveList.Write(bw);
}
bw.BaseStream.Position = BaseOffset + TEAM_OFFSET;
Team.Write(bw);
bw.BaseStream.Position = BaseOffset + PROFILENAME_OFFSET + 18;
bw.Write(StringTo16LongArray(Team.Name));
bw.BaseStream.Position = BaseOffset + TEAM_EMBLEM_OFFSET;
bw.Write(Team.Emblem);
bw.BaseStream.Position = BaseOffset + PROFILE_OFFSET;
bw.Write(Profile);
}
}
public void BatchChop(string FHost)
{
var files = Directory.GetFiles(FHost, "*.sound", SearchOption.AllDirectories);
foreach (var soundtag in files)
{
var filename = Path.GetFullPath(soundtag);
int permutation_count;
using (var fs = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var ms = new MemoryStream())
using (var bw = new BeBinaryWriter(ms))
using (var br = new BeBinaryReader(ms))
{
fs.CopyTo(ms);
ms.Position = 0;
bw.BaseStream.Seek(64, SeekOrigin.Begin);
bw.Write(2);
br.BaseStream.Seek(288, SeekOrigin.Begin);
permutation_count = br.ReadInt32();
bw.BaseStream.Seek(342, SeekOrigin.Begin);
for (var i = 0; i < permutation_count; i++)
{
if (i != permutation_count - 1)
{
bw.Write((short)(i + 1));
}
else
{
bw.Write((short)-1);
}
bw.BaseStream.Seek(122, SeekOrigin.Current);
}
ms.Position = 0;
fs.Position = 0;
ms.CopyTo(fs);
}
}
MessageBox.Show("Converted " + files.Length + " files");
}
private static void WriteTest <T>(T expected, Action <BeBinaryWriter, T> write, Func <BeBinaryReader, T> read)
{
using var memStream = CreateMemStream();
using var writer = new BeBinaryWriter(memStream);
using var reader = new BeBinaryReader(memStream);
write(writer, expected);
writer.Flush();
memStream.Position = 0;
var actual = read(reader);
Assert.That(actual, Is.EqualTo(expected));
Assert.Throws <EndOfStreamException>(() => read(reader));
}
private void btnTeamSave_Click(object sender, EventArgs e)
{
using (var sfd = new SaveFileDialog())
{
sfd.Filter = "STrikers teaM file (*.stm)|*.stm|All files (*.*)|*.*";
if (sfd.ShowDialog() == DialogResult.OK)
{
var file = File.OpenWrite(sfd.FileName);
using (var bw = new BeBinaryWriter(file))
{
bw.Write(0x5445414D);
TeamFile.Save(bw, save);
MessageBox.Show("Succesfully saved.", "Done");
}
}
}
}
public Peer(TorrentClient client, Torrent torrent, PeerInfo info)
{
_initiator = true;
_client = client;
_torrent = torrent;
Console.WriteLine($"[{info.Ip}:{info.Port}] Connecting");
_tcpClient = new TcpClient(info.Ip, info.Port);
NetworkStream stream = _tcpClient.GetStream();
_reader = new BeBinaryReader(stream);
_writer = new BeBinaryWriter(stream);
_readThread = new Thread(ReadThreadBody);
_readThread.Start();
SendHandshake();
}
