public JudgeSummary(Potential overall_potential, StatFlags best_ivs, Potential best_potential, StatFlags zero_ivs)
{
OverallPotential = overall_potential;
BestIvs = best_ivs;
BestPotential = best_potential;
ZeroIvs = zero_ivs;
}
public JudgeSummary(Potential overall_potential, StatFlags best_ivs, Potential best_potential, StatFlags zero_ivs)
{
OverallPotential = overall_potential;
BestIvs = best_ivs;
BestPotential = best_potential;
ZeroIvs = zero_ivs;
}
T GetStatField <T> (StatFlags field, Func <T> value, T deflt = default(T))
{
if (valid.HasFlag(field))
{
return(value());
}
return(deflt);
}
public static string GetName(this StatFlags flags, string separator)
{
if (flags == StatFlags.None)
{
return("None");
}
return(String.Join(separator, flags.EnumerateValues <StatFlags>(true).Not(s => s == StatFlags.None)));
}
public static bool TryConvert(this StatFlags flags, out StatType stats)
{
stats = StatType.All;
var f = (byte)flags;
if (f < 0x1 || f > 0x7)
{
return(false);
}
stats = (StatType)flags;
return(true);
}
internal void Init()
{
valid = (StatFlags)stat.valid;
// We mustn't free stat.name, it's handled by libzip and freeing it here would cause a crash.
FullName = GetStatField(StatFlags.Name, () => Utilities.GetStringFromNativeAnsi(stat.name), String.Empty);
Index = GetStatField(StatFlags.Index, () => stat.index);
Size = GetStatField(StatFlags.Size, () => stat.size);
CompressedSize = GetStatField(StatFlags.CompSize, () => stat.comp_size);
// This value may be overriden on Unix systems if the extended fields with ID 0x000d, 0x5455 or 0x5855 are found for this entry
ModificationTime = GetStatField(StatFlags.MTime, () => Utilities.DateTimeFromUnixTime((ulong)stat.mtime.ToInt64()), Utilities.UnixEpoch);
CRC = GetStatField(StatFlags.CRC, () => stat.crc);
CompressionMethod = GetStatField(StatFlags.CompMethod, () => {
if (Enum.IsDefined(typeof(CompressionMethod), stat.comp_method))
{
return((CompressionMethod)stat.comp_method);
}
return(CompressionMethod.Unknown);
});
EncryptionMethod = GetStatField(StatFlags.EncryptionMethod, () => {
if (Enum.IsDefined(typeof(EncryptionMethod), stat.encryption_method))
{
return((EncryptionMethod)stat.encryption_method);
}
return(EncryptionMethod.Unknown);
});
IsDirectory = Size == 0 && FullName.EndsWith("/", StringComparison.Ordinal);
byte opsys;
uint xattr;
if (Native.zip_file_get_external_attributes(archive.ArchivePointer, Index, OperationFlags.None, out opsys, out xattr) == 0)
{
ExternalAttributes = xattr;
OperatingSystem = (OperatingSystem)opsys;
}
else
{
OperatingSystem = OperatingSystem.DOS;
ExternalAttributes = 0;
}
localExtraFieldsCount = Native.zip_file_extra_fields_count(archive.ArchivePointer, Index, OperationFlags.Local);
centralExtraFieldsCount = Native.zip_file_extra_fields_count(archive.ArchivePointer, Index, OperationFlags.Central);
PlatformServices.Instance.ReadAndProcessExtraFields(this);
}
public SequenceStats GetStats(StatFlags flags)
{
SequenceStats value;
DB_SEQUENCE_STAT *sp;
lock (rscLock) {
DB_SEQUENCE *seqp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = seqp->Stat(seqp, out sp, unchecked ((UInt32)flags));
Util.CheckRetVal(ret);
value.seqStats = *sp;
LibDb.os_ufree(null, sp);
}
}
return(value);
}
private void SetFlag(StatFlags f, bool b) => status = (byte)(b ? status | (byte)f : status & (byte)~f);
public static string GetName(this StatFlags flags)
{
return(GetName(flags, ", "));
}
public SequenceStats GetStats(StatFlags flags) {
SequenceStats value;
DB_SEQUENCE_STAT* sp;
lock (rscLock) {
DB_SEQUENCE* seqp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = seqp->Stat(seqp, out sp, unchecked((UInt32)flags));
Util.CheckRetVal(ret);
value.seqStats = *sp;
LibDb.os_ufree(null, sp);
}
}
return value;
}
public static void SendUpdateStat(Character chr, bool ExcelRequest, StatFlags StatFlag)
{
if (ExcelRequest || StatFlag > 0)
{
Packet pw = new Packet(ServerMessages.STAT_CHANGED);
pw.WriteBool(ExcelRequest);
pw.WriteUInt((uint)StatFlag);
if ((StatFlag & StatFlags.Skin) == StatFlags.Skin)
{
pw.WriteByte(chr.Skin);
}
if ((StatFlag & StatFlags.Eyes) == StatFlags.Eyes)
{
pw.WriteInt(chr.Face);
}
if ((StatFlag & StatFlags.Hair) == StatFlags.Hair)
{
pw.WriteInt(chr.Hair);
}
if ((StatFlag & StatFlags.Pet) == StatFlags.Pet)
{
pw.WriteLong(chr.PetCashId);
}
if ((StatFlag & StatFlags.Level) == StatFlags.Level)
{
pw.WriteByte(chr.Level);
}
if ((StatFlag & StatFlags.Job) == StatFlags.Job)
{
pw.WriteShort(chr.PrimaryStats.Job);
}
if ((StatFlag & StatFlags.Str) == StatFlags.Str)
{
pw.WriteShort(chr.PrimaryStats.Str);
}
if ((StatFlag & StatFlags.Dex) == StatFlags.Dex)
{
pw.WriteShort(chr.PrimaryStats.Dex);
}
if ((StatFlag & StatFlags.Int) == StatFlags.Int)
{
pw.WriteShort(chr.PrimaryStats.Int);
}
if ((StatFlag & StatFlags.Luk) == StatFlags.Luk)
{
pw.WriteShort(chr.PrimaryStats.Luk);
}
if ((StatFlag & StatFlags.Hp) == StatFlags.Hp)
{
pw.WriteShort(chr.PrimaryStats.HP);
}
if ((StatFlag & StatFlags.MaxHp) == StatFlags.MaxHp)
{
pw.WriteShort(chr.PrimaryStats.MaxHP);
}
if ((StatFlag & StatFlags.Mp) == StatFlags.Mp)
{
pw.WriteShort(chr.PrimaryStats.MP);
}
if ((StatFlag & StatFlags.MaxMp) == StatFlags.MaxMp)
{
pw.WriteShort(chr.PrimaryStats.MaxMP);
}
if ((StatFlag & StatFlags.Ap) == StatFlags.Ap)
{
pw.WriteShort(chr.PrimaryStats.AP);
}
if ((StatFlag & StatFlags.Sp) == StatFlags.Sp)
{
pw.WriteShort(chr.PrimaryStats.SP);
}
if ((StatFlag & StatFlags.Exp) == StatFlags.Exp)
{
pw.WriteInt(chr.PrimaryStats.EXP);
}
if ((StatFlag & StatFlags.Fame) == StatFlags.Fame)
{
pw.WriteShort(chr.PrimaryStats.Fame);
}
if ((StatFlag & StatFlags.Mesos) == StatFlags.Mesos)
{
pw.WriteInt(chr.Inventory.Mesos);
}
if ((StatFlag & StatFlags.Pet) == StatFlags.Pet)
{
pw.WriteBool(false);
}
chr.SendPacket(pw);
}
}
public LogStats GetLogStats(StatFlags flags) {
LogStats value;
DB_LOG_STAT* sp;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = evp->LogStat(evp, out sp, unchecked((UInt32)flags));
Util.CheckRetVal(ret);
value.logStats = *sp;
LibDb.os_ufree(null, sp);
}
}
return value;
}
public TxnStats GetTxnStats(StatFlags flags) {
TxnStats value;
DB_TXN_STAT* sp;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = evp->TxnStat(evp, out sp, unchecked((UInt32)flags));
Util.CheckRetVal(ret);
try {
value = new TxnStats(sp);
}
finally {
LibDb.os_ufree(null, sp);
}
}
}
return value;
}
public MutexStats GetMutexStats(StatFlags flags) {
MutexStats value;
DB_MUTEX_STAT* sp;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = evp->MutexStat(evp, out sp, unchecked((uint)flags));
Util.CheckRetVal(ret);
value.mtxStats = *sp;
LibDb.os_ufree(null, sp);
}
}
return value;
}
public CacheFileStats[] GetCacheFileStats(StatFlags flags) {
CacheFileStats[] value = null;
DB_MPOOL_FSTAT** fspp;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = evp->MemPoolStat(evp, null, &fspp, unchecked((UInt32)flags));
Util.CheckRetVal(ret);
if (fspp != null) {
int count = 0;
DB_MPOOL_FSTAT** tmpp = fspp;
try {
while (*(tmpp++) != null) count++;
value = new CacheFileStats[count];
for (int indx = 0; indx < value.Length; indx++) {
value[indx] = new CacheFileStats(*fspp);
fspp++;
}
}
finally {
LibDb.os_ufree(null, fspp);
}
}
}
}
return value;
}
public CacheStats GetCacheStats(StatFlags flags) {
CacheStats value;
DB_MPOOL_STAT* sp;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
RuntimeHelpers.PrepareConstrainedRegions();
try { }
finally {
DbRetVal ret = evp->MemPoolStat(evp, &sp, null, unchecked((UInt32)flags));
Util.CheckRetVal(ret);
value.cStats = *sp;
LibDb.os_ufree(null, sp);
}
}
return value;
}
