/// <summary>
/// Extract to specific directory, retaining filename
/// </summary>
public static void WriteEntryToDirectory(this IReader reader, string destinationDirectory,
ExtractOptions options = ExtractOptions.Overwrite)
{
string destinationFileName = string.Empty;
string file = Path.GetFileName(reader.Entry.Key);
if (FlagUtility.HasFlag(options, ExtractOptions.ExtractFullPath))
{
string folder = Path.GetDirectoryName(reader.Entry.Key);
string destdir = Path.Combine(destinationDirectory, folder);
if (!Directory.Exists(destdir))
{
Directory.CreateDirectory(destdir);
}
destinationFileName = Path.Combine(destdir, file);
}
else
{
destinationFileName = Path.Combine(destinationDirectory, file);
}
if (!reader.Entry.IsDirectory)
{
reader.WriteEntryToFile(destinationFileName, options);
}
else if (FlagUtility.HasFlag(options, ExtractOptions.ExtractFullPath) && !Directory.Exists(destinationFileName))
{
Directory.CreateDirectory(destinationFileName);
}
}
#pragma warning restore 0649
#endregion
#region Base - Override
public override bool PassCondition(EventConditionData hData)
{
var hPlayer = Global_GameplayManager.playerController;
if (hPlayer == null || hPlayer.actorData.m_hRigid == null)
{
return(false);
}
var vVel = hPlayer.actorData.m_hRigid.velocity;
if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Zero) && vVel.y == m_fCheckY)
{
return(true);
}
if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Up) && vVel.y > m_fCheckY)
{
return(true);
}
if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Down) && vVel.y < m_fCheckY)
{
return(true);
}
return(false);
}
public void doUnpack()
{
bool solid = FlagUtility.HasFlag(fileHeader.FileFlags, FileFlags.SOLID);
if (fileHeader.PackingMethod == 0x30)
{
unstoreFile();
return;
}
switch (fileHeader.RarVersion)
{
case 15: // rar 1.5 compression
unpack15(solid);
break;
case 20:
// rar 2.x compression
case 26: // files larger than 2GB
unpack20(solid);
break;
case 29:
// rar 3.x compression
case 36: // alternative hash
unpack29(solid);
break;
}
}
public override void OnUpdateBehaviour(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData)
{
base.OnUpdateBehaviour(hActorData, lstBehaviourData);
if (hActorData.m_hRigid == null || hActorData.m_hStatus == null)
{
return;
}
float fHorizontal = hActorData.m_hInputData.m_fHorizontal;
if (fHorizontal == 0)
{
if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking))
{
return;
}
hActorData.m_eStateFlag &= ~ActorStateFlag.Walking;
}
else if (FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsWalling))
{
return;
}
else if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking))
{
hActorData.m_eStateFlag |= ActorStateFlag.Walking;
}
float fMoveSpeed = hActorData.m_hStatus.status.m_fMoveSpeed;
Vector2 vVelocity = hActorData.m_hRigid.velocity;
vVelocity.x = hActorData.m_hInputData.m_fHorizontal * fMoveSpeed;
hActorData.m_hRigid.velocity = vVelocity;
}
protected virtual void OnJump(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData)
{
if (hActorData.m_hRigid == null || hActorData.m_hStatus == null ||
!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.CanDoubleJump) ||
FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.WallJumping))
{
return;
}
var vVel = hActorData.m_hRigid.velocity;
vVel.y = 0;
hActorData.m_hRigid.velocity = vVel;
hActorData.m_hRigid.AddForce(new Vector2(0, hActorData.m_hStatus.status.m_fDoubleJumpForce));
hActorData.m_fJumpStartTime = Time.time;
hActorData.m_eStateFlag |= ActorStateFlag.Jumping;
hActorData.m_eStateFlag |= ActorStateFlag.HoldingJump;
hActorData.m_eStateFlag &= ~ActorStateFlag.CanDoubleJump;
if (hActorData.m_hAnimation != null)
{
hActorData.m_hAnimation.m_hSpineAnimationState.SetAnimation(0, hActorData.m_hAnimation.m_sJumpStartAnimation, false);
hActorData.m_hAnimation.m_hSpineAnimationState.AddAnimation(0, hActorData.m_hAnimation.m_sJumpingAnimation, true, 0.2f);
hActorData.m_eCurrentAnimation = ActorAnimation.Airing;
}
}
protected Stream GetCryptoStream(Stream plainStream)
{
if ((Header.CompressedSize == 0)
&& (Header.PkwareTraditionalEncryptionData != null))
{
throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
}
if ((Header.CompressedSize == 0) &&
FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
{
plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
}
else
{
plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
}
if (Header.PkwareTraditionalEncryptionData != null)
{
return(new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData,
CryptoMode.Decrypt));
}
return(plainStream);
}
protected Stream GetCryptoStream(Stream plainStream)
{
if ((Header.CompressedSize == 0)
#if !PORTABLE && !NETFX_CORE
&& ((Header.PkwareTraditionalEncryptionData != null) ||
(Header.WinzipAesEncryptionData != null)))
#else
&& (Header.PkwareTraditionalEncryptionData != null))
#endif
{
throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
}
if ((Header.CompressedSize == 0) &&
FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
{
plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
}
else
{
plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
}
if (Header.PkwareTraditionalEncryptionData != null)
{
return(new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData,
CryptoMode.Decrypt));
}
#if !PORTABLE && !NETFX_CORE
if (Header.WinzipAesEncryptionData != null)
{
//only read 10 less because the last ten are auth bytes
return(new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10));
}
#endif
return(plainStream);
}
protected override void SetHoldingInputData(InputEventType eEventType, GetInputType eGetType)
{
if (actorData == null)
{
return;
}
var hInputData = m_hActorData.m_hInputData;
InputEventType eHoldingInput = hInputData.m_eHoldingInput;
if (eGetType == GetInputType.Down)
{
if (!FlagUtility.HasFlagUnsafe(eHoldingInput, eEventType))
{
eHoldingInput |= eEventType;
}
}
else if (eGetType == GetInputType.HoldEnd || eGetType == GetInputType.Up)
{
if (FlagUtility.HasFlagUnsafe(eHoldingInput, eEventType))
{
eHoldingInput &= ~eEventType;
}
}
hInputData.m_eHoldingInput = eHoldingInput;
m_hActorData.m_hInputData = hInputData;
}
#pragma warning restore 0649
#endregion
#endregion
#region Base - Override
public override void OnStart(List <IDialogueEventData> lstData)
{
base.OnStart(lstData);
if (!lstData.TryGetData(out DialogueEventData_MonoBehaviour <DSC_Dialogue_TypingController> hOutTyping))
{
return;
}
var hTyping = hOutTyping.m_hMono;
if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.TypingDelayTime))
{
hTyping.typingDelayTime = m_fTypingDelayTime;
}
if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.TypingSound))
{
hTyping.typingSound = m_hTypingSound;
}
if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.EndEventDelayTime))
{
hTyping.endEventDelayTime = m_fEndEventDelayTime;
}
}
public override void RunEvent(BaseActorController hBaseController, BaseActorBehaviour hBaseBehaviour)
{
var hInput = hBaseController.baseActorInput;
if (hInput == null || !hBaseController.TryGetActorData(out ActorData hActorData))
{
return;
}
float fHorizontal = hInput.inputData.m_fHorizontal;
if (fHorizontal == 0)
{
if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking))
{
return;
}
hActorData.m_eStateFlag &= ~ActorStateFlag.Walking;
}
else if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking))
{
hActorData.m_eStateFlag |= ActorStateFlag.Walking;
}
}
private void Start()
{
if (FlagUtility.HasFlagUnsafe(Global_GameplayManager.playerSkill, m_eSkill))
{
GetSkill();
}
}
public void doUnpack()
{
bool solid = FlagUtility.HasFlag <FileFlags>(this.fileHeader.FileFlags, FileFlags.SOLID);
if (this.fileHeader.PackingMethod == 0x30)
{
this.unstoreFile();
}
else
{
switch (this.fileHeader.RarVersion)
{
case 0x1a:
case 20:
base.unpack20(solid);
break;
case 0x1d:
case 0x24:
this.unpack29(solid);
break;
case 15:
base.unpack15(solid);
break;
}
}
}
protected Stream CreateDecompressionStream(Stream stream)
{
byte[] buffer;
switch (this.Header.CompressionMethod)
{
case ZipCompressionMethod.None:
return(stream);
case ZipCompressionMethod.Deflate:
return(new DeflateStream(stream, CompressionMode.Decompress, CompressionLevel.Default, false));
case ZipCompressionMethod.BZip2:
return(new BZip2Stream(stream, CompressionMode.Decompress, false, false));
case ZipCompressionMethod.LZMA:
{
if (FlagUtility.HasFlag <HeaderFlags>(this.Header.Flags, HeaderFlags.Encrypted))
{
throw new NotSupportedException("LZMA with pkware encryption.");
}
BinaryReader reader = new BinaryReader(stream);
reader.ReadUInt16();
buffer = new byte[reader.ReadUInt16()];
reader.Read(buffer, 0, buffer.Length);
return(new LzmaStream(buffer, stream, (this.Header.CompressedSize > 0) ? ((this.Header.CompressedSize - 4) - buffer.Length) : -1L, FlagUtility.HasFlag <HeaderFlags>(this.Header.Flags, HeaderFlags.Bit1) ? -1L : ((long)this.Header.UncompressedSize)));
}
case ZipCompressionMethod.PPMd:
buffer = new byte[2];
stream.Read(buffer, 0, buffer.Length);
return(new PpmdStream(new PpmdProperties(buffer), stream, false));
case ZipCompressionMethod.WinzipAes:
{
ExtraData data = Enumerable.SingleOrDefault <ExtraData>(Enumerable.Where <ExtraData>(this.Header.Extra, delegate(ExtraData x) {
return(x.Type == ExtraDataType.WinZipAes);
}));
if (data == null)
{
throw new InvalidFormatException("No Winzip AES extra data found.");
}
if (data.Length != 7)
{
throw new InvalidFormatException("Winzip data length is not 7.");
}
ushort num = BitConverter.ToUInt16(data.DataBytes, 0);
if ((num != 1) && (num != 2))
{
throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata");
}
if (BitConverter.ToUInt16(data.DataBytes, 2) != 0x4541)
{
throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
}
this.Header.CompressionMethod = (ZipCompressionMethod)BitConverter.ToUInt16(data.DataBytes, 5);
return(this.CreateDecompressionStream(stream));
}
}
throw new NotSupportedException("CompressionMethod: " + this.Header.CompressionMethod);
}
protected virtual void OnWallJump(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData)
{
if (hActorData.m_hRigid == null || hActorData.m_hStatus == null ||
hActorData.m_hInputData.m_fHorizontal == 0 || !FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsWalling) ||
FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.WallJumping) ||
!lstBehaviourData.TryGetDataRW(out WallJumpCacheData hData))
{
return;
}
Vector2 vForce = m_vJumpForce;
if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.FacingRight))
{
vForce.x = -vForce.x;
}
hActorData.m_hRigid.velocity = Vector2.zero;
hActorData.m_hRigid.AddForce(vForce);
hActorData.m_fJumpStartTime = Time.time;
hActorData.m_eStateFlag |= ActorStateFlag.Jumping;
hActorData.m_eStateFlag |= ActorStateFlag.HoldingJump;
hActorData.m_eStateFlag |= ActorStateFlag.WallJumping;
hData.m_fWallJumpLastTime = Time.time;
if (hActorData.m_hAnimation)
{
hActorData.m_hAnimation.m_hSpineAnimationState.SetAnimation(0, hActorData.m_hAnimation.m_sClimbAnimation, false);
hActorData.m_hAnimation.m_hSpineAnimationState.AddAnimation(0, hActorData.m_hAnimation.m_sJumpingAnimation, true, 0.3f);
}
}
public bool RemoveFlag <Flag>(FlagType eType, Flag eFlag, Object hObject) where Flag : unmanaged, System.Enum
{
if (dicCurrentSetFlag == null || !dicCurrentSetFlag.ContainsKey(eType))
{
return(false);
}
if (!FlagUtility.TryParseInt(eFlag, out int nFlag))
{
Debug.LogWarning("Can remove flag type int only.");
return(false);
}
if (!dicCurrentSetFlag[eType].ContainsKey(nFlag))
{
return(false);
}
var lstData = dicCurrentSetFlag[eType][nFlag].m_lstSetObject;
lstData.Remove(hObject);
if (lstData.Count <= 0)
{
MainRemoveFlag(eType, nFlag, hObject);
}
return(true);
}
#pragma warning restore 0649
#endregion
#endregion
#region Base - Override
public override void OnStart(List <IDialogueEventData> lstData)
{
base.OnStart(lstData);
var hGroupController = GetImageGroupController(lstData);
if (hGroupController == null)
{
return;
}
if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetSprite))
{
SetSprite(hGroupController);
}
if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetPosition))
{
SetPosition(hGroupController);
}
if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetSize))
{
SetSize(hGroupController);
}
if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetRotation))
{
SetRotation(hGroupController);
}
}
public virtual void Flip()
{
Quaternion qRightRot;
Quaternion qLeftRot;
if (m_bDefaultRightFacing)
{
qLeftRot = Quaternion.Euler(0, 180, 0);
qRightRot = Quaternion.Euler(0, 0, 0);
}
else
{
qLeftRot = Quaternion.Euler(0, 0, 0);
qRightRot = Quaternion.Euler(0, 180, 0);
}
if (FlagUtility.HasFlagUnsafe(m_hData.m_eStateFlag, ActorStateFlag.FacingRight))
{
transform.localRotation = qLeftRot;
m_hData.m_eStateFlag &= ~ActorStateFlag.FacingRight;
}
else
{
transform.localRotation = qRightRot;
m_hData.m_eStateFlag |= ActorStateFlag.FacingRight;
}
}
protected override void OnUpdate()
{
Entities.ForEach((ref DSC_ADD_MoveSpeed3D hSpeed
, ref DSC_ADD_Run hRun
, in DSC_ADD_Input hInput) =>
{
switch (hRun.m_eInputType)
{
case GetInputType.Down:
if (FlagUtility.HasFlagUnsafe(hInput.m_eButtonDown, hRun.m_eButton))
{
hRun.m_bRunning = !hRun.m_bRunning;
}
break;
case GetInputType.Hold:
hRun.m_bRunning = FlagUtility.HasFlagUnsafe(hInput.m_eButtonHold, hRun.m_eButton);
break;
case GetInputType.Up:
if (FlagUtility.HasFlagUnsafe(hInput.m_eButtonUp, hRun.m_eButton))
{
hRun.m_bRunning = !hRun.m_bRunning;
}
break;
}
if (hRun.m_bRunning)
{
hSpeed.m_fCurrentSpeed *= hRun.m_fSpeedMultiplier;
}
}).ScheduleParallel();
}
private static Options FixOptions(Options options)
{
if (options_HasFlag(options, Options.KeepStreamsOpen))
{
options = (Options)((int)FlagUtility.SetFlag <Options>(options, Options.KeepStreamsOpen, false));
}
return(options);
}
protected byte[] EncodeString(string str)
{
if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
{
return(Encoding.UTF8.GetBytes(str));
}
return(ArchiveEncoding.Default.GetBytes(str));
}
protected override IEnumerable <ZipVolume> LoadVolumes(FileInfo file, Options options)
{
if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
{
options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
return(new ZipVolume(file.OpenRead(), options).AsEnumerable());
}
protected string DecodeString(byte[] str)
{
if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
{
return(Encoding.UTF8.GetString(str, 0, str.Length));
}
return(ArchiveEncoding.Default.GetString(str, 0, str.Length));
}
protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader)
{
switch (headerBytes)
{
case ENTRY_HEADER_BYTES:
{
var entryHeader = new LocalEntryHeader();
entryHeader.Read(reader);
LoadHeader(entryHeader, reader.BaseStream);
lastEntryHeader = entryHeader;
return(entryHeader);
}
case DIRECTORY_START_HEADER_BYTES:
{
var entry = new DirectoryEntryHeader();
entry.Read(reader);
return(entry);
}
case POST_DATA_DESCRIPTOR:
{
if (FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
{
lastEntryHeader.Crc = reader.ReadUInt32();
lastEntryHeader.CompressedSize = reader.ReadUInt32();
lastEntryHeader.UncompressedSize = reader.ReadUInt32();
}
else
{
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
}
return(null);
}
case DIGITAL_SIGNATURE:
return(null);
case DIRECTORY_END_HEADER_BYTES:
{
var entry = new DirectoryEndHeader();
entry.Read(reader);
return(entry);
}
case SPLIT_ARCHIVE_HEADER_BYTES:
{
return(new SplitHeader());
}
case ZIP64_END_OF_CENTRAL_DIRECTORY:
default:
throw new NotSupportedException("Unknown header: " + headerBytes);
}
}
private void LoadHeader(ZipFileEntry entryHeader, Stream stream)
{
if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.Encrypted))
{
if (!entryHeader.IsDirectory &&
entryHeader.CompressedSize == 0 &&
FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
{
throw new NotSupportedException("SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner.");
}
if (password == null)
{
throw new CryptographicException("No password supplied for encrypted zip.");
}
if (entryHeader.CompressionMethod != ZipCompressionMethod.WinzipAes)
{
byte[] buffer = new byte[12];
stream.Read(buffer, 0, 12);
entryHeader.PkwareTraditionalEncryptionData = PkwareTraditionalEncryptionData.ForRead(password, entryHeader, buffer);
entryHeader.CompressedSize -= 12;
}
else
{
throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7.");
}
}
if (entryHeader.IsDirectory)
{
return;
}
//if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
//{
// entryHeader.PackedStream = new ReadOnlySubStream(stream);
//}
//else
//{
switch (mode)
{
case StreamingMode.Seekable:
{
entryHeader.DataStartPosition = stream.Position;
stream.Position += entryHeader.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
entryHeader.PackedStream = stream;
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
//}
}
protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader)
{
switch (headerBytes)
{
case 0x5054b50:
return(null);
case 0x6054b50:
{
DirectoryEndHeader header3 = new DirectoryEndHeader();
header3.Read(reader);
return(header3);
}
case 0x2014b50:
{
DirectoryEntryHeader header2 = new DirectoryEntryHeader();
header2.Read(reader);
return(header2);
}
case 0x4034b50:
{
LocalEntryHeader entryHeader = new LocalEntryHeader();
entryHeader.Read(reader);
this.LoadHeader(entryHeader, reader.BaseStream);
this.lastEntryHeader = entryHeader;
return(entryHeader);
}
case 0x6064b50:
case 0x7064b50:
{
IgnoreHeader header4 = new IgnoreHeader(ZipHeaderType.Ignore);
header4.Read(reader);
return(header4);
}
case 0x8074b50:
if (FlagUtility.HasFlag <HeaderFlags>(this.lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
{
this.lastEntryHeader.Crc = reader.ReadUInt32();
this.lastEntryHeader.CompressedSize = reader.ReadUInt32();
this.lastEntryHeader.UncompressedSize = reader.ReadUInt32();
}
else
{
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt32();
}
return(null);
case 0x30304b50:
return(new SplitHeader());
}
throw new NotSupportedException("Unknown header: " + headerBytes);
}
public void DoDamage(int nDamage, GameObject hAttacker)
{
if (FlagUtility.HasFlagUnsafe(m_hActorController.actorData.m_eStateFlag, ActorStateFlag.IsDamage))
{
return;
}
DoDamage(nDamage);
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream rewindableStream;
if (stream is RewindableStream)
{
rewindableStream = stream as RewindableStream;
}
else
{
rewindableStream = new RewindableStream(stream);
}
while (true)
{
ZipHeader header = null;
BinaryReader reader = new BinaryReader(rewindableStream);
if (_lastEntryHeader != null &&
(FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
{
reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
uint crc = reader.ReadUInt32();
if (crc == POST_DATA_DESCRIPTOR)
{
crc = reader.ReadUInt32();
}
_lastEntryHeader.Crc = crc;
_lastEntryHeader.CompressedSize = reader.ReadUInt32();
_lastEntryHeader.UncompressedSize = reader.ReadUInt32();
if (pos.HasValue)
{
_lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
}
}
_lastEntryHeader = null;
uint headerBytes = reader.ReadUInt32();
header = ReadHeader(headerBytes, reader);
if (header == null)
{
yield break;
}
//entry could be zero bytes so we need to know that.
if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
{
bool isRecording = rewindableStream.IsRecording;
if (!isRecording)
{
rewindableStream.StartRecording();
}
uint nextHeaderBytes = reader.ReadUInt32();
header.HasData = !IsHeader(nextHeaderBytes);
rewindableStream.Rewind(!isRecording);
}
yield return(header);
}
}
#pragma warning restore 0649
#endregion
#region Base - Override
public override bool PassCondition(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData)
{
if (!PassAllCondition(hActorData, lstBehaviourData))
{
return(false);
}
return(m_bIsHolding == FlagUtility.HasFlagUnsafe(hActorData.m_hInputData.m_eHoldingInput, m_eInput));
}
#pragma warning restore 0649
#endregion
#region Base - Override
public override bool PassCondition(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData)
{
if (!PassAllCondition(hActorData, lstBehaviourData))
{
return(false);
}
return(m_bIsTrue == FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsGrounding));
}
private static Options FixOptions(Options options)
{
//make sure we're closing streams with fileinfo
if (options.HasFlag(Options.KeepStreamsOpen))
{
options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
}
return(options);
}
