private bool NeedPub(InitFileType fileType)
{
switch (fileType)
{
case InitFileType.Item:
return(_pubFileRepository.EIFFile == null ||
_loginFileChecksumProvider.EIFChecksum != _pubFileRepository.EIFFile.CheckSum ||
_loginFileChecksumProvider.EIFLength != _pubFileRepository.EIFFile.Length);
case InitFileType.Npc:
return(_pubFileRepository.ENFFile == null ||
_loginFileChecksumProvider.ENFChecksum != _pubFileRepository.ENFFile.CheckSum ||
_loginFileChecksumProvider.ENFLength != _pubFileRepository.ENFFile.Length);
case InitFileType.Spell:
return(_pubFileRepository.ESFFile == null ||
_loginFileChecksumProvider.ESFChecksum != _pubFileRepository.ESFFile.CheckSum ||
_loginFileChecksumProvider.ESFLength != _pubFileRepository.ESFFile.Length);
case InitFileType.Class:
return(_pubFileRepository.ECFFile == null ||
_loginFileChecksumProvider.ECFChecksum != _pubFileRepository.ECFFile.CheckSum ||
_loginFileChecksumProvider.ECFLength != _pubFileRepository.ECFFile.Length);
default:
throw new ArgumentOutOfRangeException(nameof(fileType), fileType, null);
}
}
public bool RequestFile(InitFileType file, short mapID = -1)
{
if (!m_client.ConnectedAndInitialized || !Initialized)
{
return(false);
}
if (file == InitFileType.Map && mapID <= 0)
{
return(false);
}
Packet builder = new Packet(PacketFamily.Welcome, PacketAction.Agree);
builder.AddChar((byte)file);
m_client.ExpectingFile = true;
m_init_requestedMap = mapID;
if (!m_client.SendPacket(builder) || !m_init_responseEvent.WaitOne(Constants.ResponseFileTimeout))
{
return(false);
}
return(true);
}
public bool NeedsFileForLogin(InitFileType fileType, short optionalID = 0)
{
var expectedChecksum = _numberEncoderService.DecodeNumber(_loginFileChecksumProvider.MapChecksum);
var expectedLength = _loginFileChecksumProvider.MapLength;
return(fileType == InitFileType.Map
? NeedMap(optionalID, expectedChecksum, expectedLength)
: NeedPub(fileType));
}
private void _checkPub(InitFileType file, int rid, short len)
{
const string fName = "pub\\";
if (!Directory.Exists(fName))
{
Directory.CreateDirectory(fName);
}
switch (file)
{
case InitFileType.Item:
NeedEIF = !_tryLoadItems();
if (EIF != null)
{
NeedEIF = rid != EIF.Rid || len != EIF.Len;
}
break;
case InitFileType.Npc:
NeedENF = !_tryLoadNPCs();
if (ENF != null)
{
NeedENF = rid != ENF.Rid || len != ENF.Len;
}
break;
case InitFileType.Spell:
NeedESF = !_tryLoadSpells();
if (ESF != null)
{
NeedESF = rid != ESF.Rid || len != ESF.Len;
}
break;
case InitFileType.Class:
NeedECF = !_tryLoadClasses();
if (ECF != null)
{
NeedECF = rid != ECF.Rid || len != ECF.Len;
}
break;
default:
return;
}
}
public async Task <IPubFile> RequestFile(InitFileType fileType)
{
var request = new PacketBuilder(PacketFamily.Welcome, PacketAction.Agree)
.AddChar((byte)fileType)
.Build();
var response = await _packetSendService.SendEncodedPacketAndWaitAsync(request);
if (!PacketIsValid(response))
{
throw new EmptyPacketReceivedException();
}
var responseFileType = (InitReply)response.ReadChar();
var extraByte = response.ReadChar();
if (extraByte != 1)
{
throw new MalformedPacketException("Missing extra single byte in file transfer packet", response);
}
IPubFile retFile;
switch (responseFileType)
{
case InitReply.ItemFile: retFile = new EIFFile(); break;
case InitReply.NpcFile: retFile = new ENFFile(); break;
case InitReply.SpellFile: retFile = new ESFFile(); break;
case InitReply.ClassFile: retFile = new ECFFile(); break;
default: throw new EmptyPacketReceivedException();
}
var responseBytes = response.ReadBytes(response.Length - response.ReadPosition)
.ToArray();
retFile.DeserializeFromByteArray(responseBytes, _numberEncoderService);
return(retFile);
}
private void _checkPub(InitFileType file, int rid, short len)
{
const string fName = "pub\\";
if (!Directory.Exists(fName))
Directory.CreateDirectory(fName);
switch (file)
{
case InitFileType.Item:
NeedEIF = !_tryLoadItems();
if(EIF != null)
NeedEIF = rid != EIF.Rid || len != EIF.Len;
break;
case InitFileType.Npc:
NeedENF = !_tryLoadNPCs();
if (ENF != null)
NeedENF = rid != ENF.Rid || len != ENF.Len;
break;
case InitFileType.Spell:
NeedESF = !_tryLoadSpells();
if (ESF != null)
NeedESF = rid != ESF.Rid || len != ESF.Len;
break;
case InitFileType.Class:
NeedECF = !_tryLoadClasses();
if (ECF != null)
NeedECF = rid != ECF.Rid || len != ECF.Len;
break;
default:
return;
}
}
private static byte[] CreateFilePacket(InitFileType type)
{
IPacketBuilder packetBuilder = new PacketBuilder();
var nes = new NumberEncoderService();
switch (type)
{
case InitFileType.Item:
packetBuilder = packetBuilder
.AddChar((byte)InitReply.ItemFile).AddChar(1) //spacer
.AddString("EIF").AddInt(1) //RID
.AddShort(2) //Len
.AddByte(1) //filler byte
.AddBytes(new EIFRecord {
ID = 1, Name = "Test1"
}.SerializeToByteArray(nes))
.AddBytes(new EIFRecord {
ID = 2, Name = "eof"
}.SerializeToByteArray(nes));
break;
case InitFileType.Npc:
packetBuilder = packetBuilder
.AddChar((byte)InitReply.NpcFile).AddChar(1) //spacer
.AddString("ENF").AddInt(1) //RID
.AddShort(2) //Len
.AddByte(1) //filler byte
.AddBytes(new ENFRecord {
ID = 1, Name = "Test1"
}.SerializeToByteArray(nes))
.AddBytes(new ENFRecord {
ID = 2, Name = "eof"
}.SerializeToByteArray(nes));
break;
case InitFileType.Spell:
packetBuilder = packetBuilder
.AddChar((byte)InitReply.SpellFile).AddChar(1) //spacer
.AddString("ESF").AddInt(1) //RID
.AddShort(2) //Len
.AddByte(1) //filler byte
.AddBytes(new ESFRecord {
ID = 1, Name = "Test1", Shout = ""
}.SerializeToByteArray(nes))
.AddBytes(new ESFRecord {
ID = 2, Name = "eof", Shout = ""
}.SerializeToByteArray(nes));
break;
case InitFileType.Class:
packetBuilder = packetBuilder
.AddChar((byte)InitReply.ClassFile).AddChar(1) //spacer
.AddString("ECF").AddInt(1) //RID
.AddShort(2) //Len
.AddByte(1) //filler byte
.AddBytes(new ECFRecord {
ID = 1, Name = "Test1"
}.SerializeToByteArray(nes))
.AddBytes(new ECFRecord {
ID = 2, Name = "eof"
}.SerializeToByteArray(nes));
break;
}
return(packetBuilder.Build().RawData.ToArray());
}
private static bool IsCorrectFileRequestPacket(IPacket packet, InitFileType type)
{
return(packet.Family == PacketFamily.Welcome && packet.Action == PacketAction.Agree && packet.ReadChar() == (byte)type);
}
public bool RequestFile(InitFileType file, short mapID = -1)
{
if (!m_client.ConnectedAndInitialized || !Initialized)
return false;
if (file == InitFileType.Map && mapID <= 0)
return false;
Packet builder = new Packet(PacketFamily.Welcome, PacketAction.Agree);
builder.AddChar((byte)file);
m_client.ExpectingFile = true;
m_init_requestedMap = mapID;
if (!m_client.SendPacket(builder) || !m_init_responseEvent.WaitOne(Constants.ResponseFileTimeout))
return false;
return true;
}
private static bool _isPubValid(InitFileType fileType)
{
try
{
EODataFile file;
switch (fileType)
{
case InitFileType.Item:
file = new ItemFile();
break;
case InitFileType.Npc:
file = new NPCFile();
break;
case InitFileType.Spell:
file = new SpellFile();
break;
case InitFileType.Class:
file = new ClassFile();
break;
default:
return false;
}
if (file.Data.Count <= 1) return false;
}
catch
{
return false;
}
return true;
}
