public virtualInp(Inp mapTo, KeyCode low, KeyCode high)
{
Type = type.KeyAxis;
MapTo = mapTo;
High = high;
Low = low;
}
// Return 'false' to quit unpacking the current file or 'true' to continue.
bool ReadEndOfBlock()
{
uint BitField = Inp.getbits();
bool NewTable, NewFile = false;
// "1" - no new file, new table just here.
// "00" - new file, no new table.
// "01" - new file, new table (in beginning of next file).
if ((BitField & 0x8000) != 0)
{
NewTable = true;
Inp.addbits(1);
}
else
{
NewFile = true;
NewTable = (BitField & 0x4000) != 0;
Inp.addbits(2);
}
TablesRead3 = !NewTable;
// Quit immediately if "new file" flag is set. If "new table" flag
// is present, we'll read the table in beginning of next file
// based on 'TablesRead3' 'false' value.
if (NewFile)
{
return(false);
}
return(ReadTables30()); // Quit only if we failed to read tables.
}
private bool ReadBlockHeader()
{
Header.HeaderSize = 0;
if (!Inp.ExternalBuffer && Inp.InAddr > ReadTop - 7)
{
if (!UnpReadBuf())
{
return(false);
}
}
//Inp.faddbits((8-Inp.InBit)&7);
Inp.faddbits((uint)((8 - Inp.InBit) & 7));
byte BlockFlags = (byte)(Inp.fgetbits() >> 8);
Inp.faddbits(8);
//uint ByteCount=((BlockFlags>>3)&3)+1; // Block size byte count.
uint ByteCount = (uint)(((BlockFlags >> 3) & 3) + 1); // Block size byte count.
if (ByteCount == 4)
{
return(false);
}
//Header.HeaderSize=2+ByteCount;
Header.HeaderSize = (int)(2 + ByteCount);
Header.BlockBitSize = (BlockFlags & 7) + 1;
byte SavedCheckSum = (byte)(Inp.fgetbits() >> 8);
Inp.faddbits(8);
int BlockSize = 0;
//for (uint I=0;I<ByteCount;I++)
for (int I = 0; I < ByteCount; I++)
{
//BlockSize+=(Inp.fgetbits()>>8)<<(I*8);
BlockSize += (int)(Inp.fgetbits() >> 8) << (I * 8);
Inp.AddBits(8);
}
Header.BlockSize = BlockSize;
byte CheckSum = (byte)(0x5a ^ BlockFlags ^ BlockSize ^ (BlockSize >> 8) ^ (BlockSize >> 16));
if (CheckSum != SavedCheckSum)
{
return(false);
}
Header.BlockStart = Inp.InAddr;
ReadBorder = Math.Min(ReadBorder, Header.BlockStart + Header.BlockSize - 1);
Header.LastBlockInFile = (BlockFlags & 0x40) != 0;
Header.TablePresent = (BlockFlags & 0x80) != 0;
return(true);
}
void Awake()
{
//make this singleton persistent & don't allow any other gameobject to have this component
if (instance != null && instance != this)
{
Destroy(this); return;
}
instance = this; DontDestroyOnLoad(this.gameObject);
inputHistory = new Dictionary <int, Vector2[]>();
inputHistoryIndex = new Dictionary <int, int>();
inputHistoryCount = new Dictionary <int, int>();
inputOverUIHistory = new Dictionary <int, bool>();
inputStart = new Dictionary <int, PositionAtTime>();
inputToBeRemoved = new List <int>();
#if UNITY_TVOS
if (Application.platform == RuntimePlatform.tvOS)
{
UnityEngine.Apple.TV.Remote.touchesEnabled = true;
}
#endif
if (!Input.touchSupported && !Input.mousePresent)
{
Debug.LogError("This platform is currently not supported by Inp.ut.");
}
}
private void UnpInitData(bool Solid)
{
if (!Solid)
{
Utility.Memset <uint>(OldDist, 0, OldDist.Length);
OldDistPtr = 0;
LastDist = LastLength = 0;
// memset(Window,0,MaxWinSize);
//memset(&BlockTables,0,sizeof(BlockTables));
BlockTables = new UnpackBlockTables();
// sharpcompress: no default ctor for struct
BlockTables.Init();
UnpPtr = WrPtr = 0;
WriteBorder = Math.Min(MaxWinSize, UNPACK_MAX_WRITE) & MaxWinMask;
}
// Filters never share several solid files, so we can safely reset them
// even in solid archive.
InitFilters();
Inp.InitBitInput();
WrittenFileSize = 0;
ReadTop = 0;
ReadBorder = 0;
//memset(&BlockHeader,0,sizeof(BlockHeader));
BlockHeader = new UnpackBlockHeader();
BlockHeader.BlockSize = -1; // '-1' means not defined yet.
#if !RarV2017_SFX_MODULE
UnpInitData20(Solid);
#endif
//UnpInitData30(Solid);
UnpInitData50(Solid);
}
private bool ReadFilter(UnpackFilter Filter)
{
if (!Inp.ExternalBuffer && Inp.InAddr > ReadTop - 16)
{
if (!UnpReadBuf())
{
return(false);
}
}
Filter.uBlockStart = ReadFilterData();
Filter.uBlockLength = ReadFilterData();
if (Filter.BlockLength > MAX_FILTER_BLOCK_SIZE)
{
Filter.BlockLength = 0;
}
//Filter.Type=Inp.fgetbits()>>13;
Filter.Type = (byte)(Inp.fgetbits() >> 13);
Inp.faddbits(3);
if (Filter.Type == (byte)FilterType.FILTER_DELTA)
{
//Filter.Channels=(Inp.fgetbits()>>11)+1;
Filter.Channels = (byte)((Inp.fgetbits() >> 11) + 1);
Inp.faddbits(5);
}
return(true);
}
public void GameOver(int score, Games gamein)
{
switch (gamein)
{
case Games.SNAKE:
SnakeGrid.Visibility = Visibility.Hidden;
Inp.Visibility = Visibility.Visible;
InpScroll.Visibility = Visibility.Hidden;
Inp.Focus();
((TermBind)DataContext).CurTerm = "Hypothalamic Terminal";
((TermBind)DataContext).WriteToDisp("\n\nFinal score of " + Snake.Score.ToString() + "\n\nEnter Name:");
Thread nameThread = new Thread(CommandList.CmdName);
nameThread.IsBackground = true;
nameThread.Start();
break;
case Games.CURVE:
ClearCanvas();
CurveCanvas.Visibility = Visibility.Hidden;
Inp.Visibility = Visibility.Visible;
InpScroll.Visibility = Visibility.Hidden;
Inp.Focus();
((TermBind)DataContext).CurTerm = "Hypothalamic Terminal";
TermBind.IsOpen = false;
break;
}
}
private void GetFlagsBuf()
{
uint Flags, NewFlagsPlace;
uint FlagsPlace = DecodeNum(Inp.fgetbits(), STARTHF2, DecHf2, PosHf2);
// Our Huffman table stores 257 items and needs all them in other parts
// of code such as when StMode is on, so the first item is control item.
// While normally we do not use the last item to code the flags byte here,
// we need to check for value 256 when unpacking in case we unpack
// a corrupt archive.
if (FlagsPlace >= ChSetC.Length)
{
return;
}
while (true)
{
Flags = ChSetC[FlagsPlace];
FlagBuf = Flags >> 8;
NewFlagsPlace = NToPlC[Flags++ & 0xff]++;
if ((Flags & 0xff) != 0)
{
break;
}
CorrHuff(ChSetC, NToPlC);
}
ChSetC[FlagsPlace] = ChSetC[NewFlagsPlace];
ChSetC[NewFlagsPlace] = (ushort)Flags;
}
public virtualInp(Inp mapTo, string axis, bool invert = false)
{
Type = type.Axis;
MapTo = mapTo;
Axis = axis;
Invert = invert;
}
void OnEnable()
{
//This should only ever get called on first load and after an Assembly reload in Unity.
// (because instance should be set on awake)
if (instance == null)
{
instance = this;
}
}
public MainWindow()
{
#region init
InitializeComponent();
DataContext = new TermBind();
Disp.Effect = new SmoothMagnifyEffect();
PixelGrid.Effect = new PixelateEffect();
BloomGrid.Effect = new BloomEffect();
Scan.Effect = new SmoothMagnifyEffect();
((PixelateEffect)PixelGrid.Effect).HorizontalPixelCounts = 1200;
((PixelateEffect)PixelGrid.Effect).VerticalPixelCounts = 800;
((SmoothMagnifyEffect)Disp.Effect).InnerRadius -= 0.7;
((SmoothMagnifyEffect)Disp.Effect).OuterRadius += 0.5;
((SmoothMagnifyEffect)Disp.Effect).Magnification -= 0.7;
((BloomEffect)BloomGrid.Effect).BaseIntensity++;
((SmoothMagnifyEffect)Scan.Effect).InnerRadius -= 0.7;
((SmoothMagnifyEffect)Scan.Effect).OuterRadius += 0.5;
((SmoothMagnifyEffect)Scan.Effect).Magnification -= 0.7;
((TermBind)DataContext).CurTerm = "Hypothalamic Terminal";
CurveCanvas.Children.Add(curveline);
CurveCanvas.Visibility = Visibility.Hidden;
InpScroll.Visibility = Visibility.Hidden;
Inp.Focus();
#endregion
/*
#region intro
* //
* ((TermBind)DataContext).WriteToDisp("\n ║ __ ________ __ __\n ╔═══╝║╚═══╗ | \\ | |_ _| \\/ |\n ╚══╗▒╠═╔══╝ | \\| | | | | \\ / | \n ╔════╩╗║░╠════╗ | . ` | | | | |\\/| | \n ╚══╗░╔╩╬═╝░╔══╝ | |\\ |_| |_| | | | \n╔═════╩═╗▒▓░╬═╩═════╗ |_|_\\_|_____|_|__|_| \n╚════╗░╗╚░▓▒╝░░╔════╝ | _ \\| | | |/ ____|\n ╔═══╝░╚══╩╗╔╗▒╚═══╗ | |_) | | | | (___ \n ╚═════╗░▒░╠╝╠═════╝ | _ <| | | |\\___ \\ \n ╔═╝▒░╔╝░╚═╗ | |_) | |__| |____) |\n ╚═══╗║╔═══╝ |____/ \\____/|_____/\n ║ ");
* ((TermBind)DataContext).Wait(2000);
* ((TermBind)DataContext).ClearScroll(Inp);
* ((TermBind)DataContext).WriteToDisp("\n███████╗██╗ ██╗███╗ ██╗ █████╗ ██████╗ ███████╗███████╗\n██╔════╝╚██╗ ██╔╝████╗ ██║██╔══██╗██╔══██╗██╔════╝██╔════╝\n███████╗ ╚████╔╝ ██╔██╗ ██║███████║██████╔╝███████╗█████╗ \n╚════██║ ╚██╔╝ ██║╚██╗██║██╔══██║██╔═══╝ ╚════██║██╔══╝ \n███████║ ██║ ██║ ╚████║██║ ██║██║ ███████║███████╗\n╚══════╝ ╚═╝ ╚═╝ ╚═══╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝\n\t\t\t\t\t\t\tv3.4");
* ((TermBind)DataContext).WriteToDisp("Welcome Amber!\nSynapse System v3.4 (TM) booting up");
* ((TermBind)DataContext).WriteToDisp("...\n", 1000);
* ((TermBind)DataContext).WriteToDisp("Performing primary diagnosis");
* ((TermBind)DataContext).Wait(2000);
* ((TermBind)DataContext).WriteToDisp("Exit Status 74\n302 Errors and 5888 Warnings\nShutting d");
* ((TermBind)DataContext).Wait(2000);
* ((TermBind)DataContext).WriteToDisp("status:override");
* ((TermBind)DataContext).WriteToDisp("value:'Force'\n");
* ((TermBind)DataContext).WriteToDisp("Manual Override succesful. Booting up in Basic Mode.\n");
* ((TermBind)DataContext).WriteToDisp("status:accesLevel");
* ((TermBind)DataContext).WriteToDisp("value:0\n");
* ((TermBind)DataContext).WriteToDisp("Flagging functions");
* ((TermBind)DataContext).WriteToDisp("...\n", 1000);
* ((TermBind)DataContext).WriteToDisp("Boot complete");
* ((TermBind)DataContext).Wait(2000);
* ((TermBind)DataContext).ClearScroll(Inp);
* ((TermBind)DataContext).WriteToDisp(" ");
*
* // ((TermBind)DataContext).WriteToDisp("\n ║ __ ________ __ __\n ╔═══╝║╚═══╗ | \\ | |_ _| \\/ |\n ╚══╗▒╠═╔══╝ | \\| | | | | \\ / | \n ╔════╩╗║░╠════╗ | . ` | | | | |\\/| | \n ╚══╗░╔╩╬═╝░╔══╝ | |\\ |_| |_| | | | \n╔═════╩═╗▒▓░╬═╩═════╗ |_|_\\_|_____|_|__|_| \n╚════╗░╗╚░▓▒╝░░╔════╝ | _ \\| | | |/ ____|\n ╔═══╝░╚══╩╗╔╗▒╚═══╗ | |_) | | | | (___ \n ╚═════╗░▒░╠╝╠═════╝ | _ <| | | |\\___ \\ \n ╔═╝▒░╔╝░╚═╗ | |_) | |__| |____) |\n ╚═══╗║╔═══╝ |____/ \\____/|_____/\n ║ ");
#endregion
*/
}
private uint DecodeNum(uint Num, uint StartPos, uint[] DecTab, uint[] PosTab)
{
int I;
for (Num &= 0xfff0, I = 0; DecTab[I] <= Num; I++)
{
StartPos++;
}
Inp.faddbits(StartPos);
return(((Num - (I != 0 ? DecTab[I - 1]:0)) >> (int)(16 - StartPos)) + PosTab[StartPos]);
}
public void ToggleScroll()
{
if (InpScroll.Visibility == Visibility.Visible)
{
InpScroll.Visibility = Visibility.Hidden;
Inp.Visibility = Visibility.Visible;
Inp.Focus();
return;
}
InpScroll.Visibility = Visibility.Visible;
Inp.Visibility = Visibility.Hidden;
Inp.Focus();
}
public void QueInput(Inp inp)
{
// check stack not full
if (inpQue.Count < 2)
{
inpQue.Push(inp);
}
else
{
Debug.Log("Que full");
}
// ad input to stack
}
private uint ReadFilterData()
{
uint ByteCount = (Inp.fgetbits() >> 14) + 1;
Inp.AddBits(2);
uint Data = 0;
//for (uint I=0;I<ByteCount;I++)
for (int I = 0; I < ByteCount; I++)
{
Data += (Inp.fgetbits() >> 8) << (I * 8);
Inp.AddBits(8);
}
return(Data);
}
public void PopInput()
{
if (inpQue.Count > 0)
{
Inp tarinp = inpQue.Pop();
switch (tarinp)
{
case Inp.Left:
Horizontal(-1);
break;
case Inp.Right:
Horizontal(1);
break;
default:
break;
}
}
}
bool ReadVMCode()
{
// Entire VM code is guaranteed to fully present in block defined
// by current Huffman table. Compressor checks that VM code does not cross
// Huffman block boundaries.
uint FirstByte = Inp.getbits() >> 8;
Inp.addbits(8);
uint Length = (FirstByte & 7) + 1;
if (Length == 7)
{
Length = (Inp.getbits() >> 8) + 7;
Inp.addbits(8);
}
else
if (Length == 8)
{
Length = Inp.getbits();
Inp.addbits(16);
}
if (Length == 0)
{
return(false);
}
Array <byte> VMCode(Length);
for (uint I = 0; I < Length; I++)
{
// Try to read the new buffer if only one byte is left.
// But if we read all bytes except the last, one byte is enough.
if (Inp.InAddr >= ReadTop - 1 && !UnpReadBuf30() && I < Length - 1)
{
return(false);
}
VMCode[I] = Inp.getbits() >> 8;
Inp.addbits(8);
}
return(AddVMCode(FirstByte, &VMCode[0], Length));
}
private void HuffDecode()
{
uint CurByte, NewBytePlace;
uint Length;
uint Distance;
int BytePlace;
uint BitField = Inp.fgetbits();
if (AvrPlc > 0x75ff)
{
BytePlace = (int)DecodeNum(BitField, STARTHF4, DecHf4, PosHf4);
}
else
if (AvrPlc > 0x5dff)
{
BytePlace = (int)DecodeNum(BitField, STARTHF3, DecHf3, PosHf3);
}
else
if (AvrPlc > 0x35ff)
{
BytePlace = (int)DecodeNum(BitField, STARTHF2, DecHf2, PosHf2);
}
else
if (AvrPlc > 0x0dff)
{
BytePlace = (int)DecodeNum(BitField, STARTHF1, DecHf1, PosHf1);
}
else
{
BytePlace = (int)DecodeNum(BitField, STARTHF0, DecHf0, PosHf0);
}
BytePlace &= 0xff;
if (StMode != 0)
{
if (BytePlace == 0 && BitField > 0xfff)
{
BytePlace = 0x100;
}
if (--BytePlace == -1)
{
BitField = Inp.fgetbits();
Inp.faddbits(1);
if ((BitField & 0x8000) != 0)
{
NumHuf = StMode = 0;
return;
}
else
{
Length = (BitField & 0x4000) != 0 ? 4U : 3;
Inp.faddbits(1);
Distance = DecodeNum(Inp.fgetbits(), STARTHF2, DecHf2, PosHf2);
Distance = (Distance << 5) | (Inp.fgetbits() >> 11);
Inp.faddbits(5);
CopyString15(Distance, Length);
return;
}
}
}
else
if (NumHuf++ >= 16 && FlagsCnt == 0)
{
StMode = 1;
}
AvrPlc += (uint)BytePlace;
AvrPlc -= AvrPlc >> 8;
Nhfb += 16;
if (Nhfb > 0xff)
{
Nhfb = 0x90;
Nlzb >>= 1;
}
Window[UnpPtr++] = (byte)(ChSet[BytePlace] >> 8);
--DestUnpSize;
while (true)
{
CurByte = ChSet[BytePlace];
NewBytePlace = NToPl[CurByte++ & 0xff]++;
if ((CurByte & 0xff) > 0xa1)
{
CorrHuff(ChSet, NToPl);
}
else
{
break;
}
}
ChSet[BytePlace] = ChSet[NewBytePlace];
ChSet[NewBytePlace] = (ushort)CurByte;
}
private void LongLZ()
{
uint Length;
uint Distance;
uint DistancePlace, NewDistancePlace;
uint OldAvr2, OldAvr3;
NumHuf = 0;
Nlzb += 16;
if (Nlzb > 0xff)
{
Nlzb = 0x90;
Nhfb >>= 1;
}
OldAvr2 = AvrLn2;
uint BitField = Inp.fgetbits();
if (AvrLn2 >= 122)
{
Length = DecodeNum(BitField, STARTL2, DecL2, PosL2);
}
else
if (AvrLn2 >= 64)
{
Length = DecodeNum(BitField, STARTL1, DecL1, PosL1);
}
else
if (BitField < 0x100)
{
Length = BitField;
Inp.faddbits(16);
}
else
{
for (Length = 0; ((BitField << (int)Length) & 0x8000) == 0; Length++)
{
;
}
Inp.faddbits(Length + 1);
}
AvrLn2 += Length;
AvrLn2 -= AvrLn2 >> 5;
BitField = Inp.fgetbits();
if (AvrPlcB > 0x28ff)
{
DistancePlace = DecodeNum(BitField, STARTHF2, DecHf2, PosHf2);
}
else
if (AvrPlcB > 0x6ff)
{
DistancePlace = DecodeNum(BitField, STARTHF1, DecHf1, PosHf1);
}
else
{
DistancePlace = DecodeNum(BitField, STARTHF0, DecHf0, PosHf0);
}
AvrPlcB += DistancePlace;
AvrPlcB -= AvrPlcB >> 8;
while (true)
{
Distance = ChSetB[DistancePlace & 0xff];
NewDistancePlace = NToPlB[Distance++ & 0xff]++;
if ((Distance & 0xff) != 0)
{
CorrHuff(ChSetB, NToPlB);
}
else
{
break;
}
}
ChSetB[DistancePlace & 0xff] = ChSetB[NewDistancePlace];
ChSetB[NewDistancePlace] = (ushort)Distance;
Distance = ((Distance & 0xff00) | (Inp.fgetbits() >> 8)) >> 1;
Inp.faddbits(7);
OldAvr3 = AvrLn3;
if (Length != 1 && Length != 4)
{
if (Length == 0 && Distance <= MaxDist3)
{
AvrLn3++;
AvrLn3 -= AvrLn3 >> 8;
}
else
if (AvrLn3 > 0)
{
AvrLn3--;
}
}
Length += 3;
if (Distance >= MaxDist3)
{
Length++;
}
if (Distance <= 256)
{
Length += 8;
}
if (OldAvr3 > 0xb0 || AvrPlc >= 0x2a00 && OldAvr2 < 0x40)
{
MaxDist3 = 0x7f00;
}
else
{
MaxDist3 = 0x2001;
}
OldDist[OldDistPtr++] = Distance;
OldDistPtr = OldDistPtr & 3;
LastLength = Length;
LastDist = Distance;
CopyString15(Distance, Length);
}
private void ShortLZ()
{
uint Length, SaveLength;
uint LastDistance;
uint Distance;
int DistancePlace;
NumHuf = 0;
uint BitField = Inp.fgetbits();
if (LCount == 2)
{
Inp.faddbits(1);
if (BitField >= 0x8000)
{
CopyString15((uint)LastDist, LastLength);
return;
}
BitField <<= 1;
LCount = 0;
}
BitField >>= 8;
// not thread safe, replaced by GetShortLen1 and GetShortLen2 macro
// ShortLen1[1]=ShortLen2[3]=Buf60+3;
if (AvrLn1 < 37)
{
for (Length = 0;; Length++)
{
if (((BitField ^ ShortXor1[Length]) & (~(0xff >> (int)GetShortLen1(Length)))) == 0)
{
break;
}
}
Inp.faddbits(GetShortLen1(Length));
}
else
{
for (Length = 0;; Length++)
{
if (((BitField ^ ShortXor2[Length]) & (~(0xff >> (int)GetShortLen2(Length)))) == 0)
{
break;
}
}
Inp.faddbits(GetShortLen2(Length));
}
if (Length >= 9)
{
if (Length == 9)
{
LCount++;
CopyString15((uint)LastDist, LastLength);
return;
}
if (Length == 14)
{
LCount = 0;
Length = DecodeNum(Inp.fgetbits(), STARTL2, DecL2, PosL2) + 5;
Distance = (Inp.fgetbits() >> 1) | 0x8000;
Inp.faddbits(15);
LastLength = Length;
LastDist = Distance;
CopyString15(Distance, Length);
return;
}
LCount = 0;
SaveLength = Length;
Distance = OldDist[(OldDistPtr - (Length - 9)) & 3];
Length = DecodeNum(Inp.fgetbits(), STARTL1, DecL1, PosL1) + 2;
if (Length == 0x101 && SaveLength == 10)
{
Buf60 ^= 1;
return;
}
if (Distance > 256)
{
Length++;
}
if (Distance >= MaxDist3)
{
Length++;
}
OldDist[OldDistPtr++] = Distance;
OldDistPtr = OldDistPtr & 3;
LastLength = Length;
LastDist = Distance;
CopyString15(Distance, Length);
return;
}
LCount = 0;
AvrLn1 += Length;
AvrLn1 -= AvrLn1 >> 4;
DistancePlace = (int)(DecodeNum(Inp.fgetbits(), STARTHF2, DecHf2, PosHf2) & 0xff);
Distance = ChSetA[DistancePlace];
if (--DistancePlace != -1)
{
LastDistance = ChSetA[DistancePlace];
ChSetA[DistancePlace + 1] = (ushort)LastDistance;
ChSetA[DistancePlace] = (ushort)Distance;
}
Length += 2;
OldDist[OldDistPtr++] = ++Distance;
OldDistPtr = OldDistPtr & 3;
LastLength = Length;
LastDist = Distance;
CopyString15(Distance, Length);
}
void Unpack20(bool Solid)
{
uint Bits;
if (Suspended)
{
UnpPtr = WrPtr;
}
else
{
UnpInitData(Solid);
if (!UnpReadBuf())
{
return;
}
if ((!Solid || !TablesRead2) && !ReadTables20())
{
return;
}
--DestUnpSize;
}
while (DestUnpSize >= 0)
{
UnpPtr &= MaxWinMask;
if (Inp.InAddr > ReadTop - 30)
{
if (!UnpReadBuf())
{
break;
}
}
if (((WrPtr - UnpPtr) & MaxWinMask) < 270 && WrPtr != UnpPtr)
{
UnpWriteBuf20();
if (Suspended)
{
return;
}
}
if (UnpAudioBlock)
{
uint AudioNumber = DecodeNumber(Inp, MD[UnpCurChannel]);
if (AudioNumber == 256)
{
if (!ReadTables20())
{
break;
}
continue;
}
Window[UnpPtr++] = DecodeAudio((int)AudioNumber);
if (++UnpCurChannel == UnpChannels)
{
UnpCurChannel = 0;
}
--DestUnpSize;
continue;
}
uint Number = DecodeNumber(Inp, BlockTables.LD);
if (Number < 256)
{
Window[UnpPtr++] = (byte)Number;
--DestUnpSize;
continue;
}
if (Number > 269)
{
uint Length = (uint)(LDecode[Number -= 270] + 3);
if ((Bits = LBits[Number]) > 0)
{
Length += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
uint DistNumber = DecodeNumber(Inp, BlockTables.DD);
uint Distance = DDecode[DistNumber] + 1;
if ((Bits = DBits[DistNumber]) > 0)
{
Distance += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
if (Distance >= 0x2000)
{
Length++;
if (Distance >= 0x40000L)
{
Length++;
}
}
CopyString20(Length, Distance);
continue;
}
if (Number == 269)
{
if (!ReadTables20())
{
break;
}
continue;
}
if (Number == 256)
{
CopyString20(LastLength, LastDist);
continue;
}
if (Number < 261)
{
uint Distance = OldDist[(OldDistPtr - (Number - 256)) & 3];
uint LengthNumber = DecodeNumber(Inp, BlockTables.RD);
uint Length = (uint)(LDecode[LengthNumber] + 2);
if ((Bits = LBits[LengthNumber]) > 0)
{
Length += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
if (Distance >= 0x101)
{
Length++;
if (Distance >= 0x2000)
{
Length++;
if (Distance >= 0x40000)
{
Length++;
}
}
}
CopyString20(Length, Distance);
continue;
}
if (Number < 270)
{
uint Distance = (uint)(SDDecode[Number -= 261] + 1);
if ((Bits = SDBits[Number]) > 0)
{
Distance += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
CopyString20(2, Distance);
continue;
}
}
ReadLastTables();
UnpWriteBuf20();
}
bool ReadTables20()
{
byte[] BitLength = new byte[BC20];
byte[] Table = new byte[MC20 * 4];
if (Inp.InAddr > ReadTop - 25)
{
if (!UnpReadBuf())
{
return(false);
}
}
uint BitField = Inp.getbits();
UnpAudioBlock = (BitField & 0x8000) != 0;
if ((BitField & 0x4000) != 0)
{
Utility.Memset(UnpOldTable20, 0, UnpOldTable20.Length);
}
Inp.addbits(2);
uint TableSize;
if (UnpAudioBlock)
{
UnpChannels = ((BitField >> 12) & 3) + 1;
if (UnpCurChannel >= UnpChannels)
{
UnpCurChannel = 0;
}
Inp.addbits(2);
TableSize = MC20 * UnpChannels;
}
else
{
TableSize = NC20 + DC20 + RC20;
}
for (uint I = 0; I < BC20; I++)
{
BitLength[I] = (byte)(Inp.getbits() >> 12);
Inp.addbits(4);
}
MakeDecodeTables(BitLength, 0, BlockTables.BD, BC20);
for (uint I = 0; I < TableSize;)
{
if (Inp.InAddr > ReadTop - 5)
{
if (!UnpReadBuf())
{
return(false);
}
}
uint Number = DecodeNumber(Inp, BlockTables.BD);
if (Number < 16)
{
Table[I] = (byte)((Number + this.UnpOldTable20[I]) & 0xf);
I++;
}
else
if (Number == 16)
{
uint N = (Inp.getbits() >> 14) + 3;
Inp.addbits(2);
if (I == 0)
{
return(false); // We cannot have "repeat previous" code at the first position.
}
else
{
while (N-- > 0 && I < TableSize)
{
Table[I] = Table[I - 1];
I++;
}
}
}
else
{
uint N;
if (Number == 17)
{
N = (Inp.getbits() >> 13) + 3;
Inp.addbits(3);
}
else
{
N = (Inp.getbits() >> 9) + 11;
Inp.addbits(7);
}
while (N-- > 0 && I < TableSize)
{
Table[I++] = 0;
}
}
}
TablesRead2 = true;
if (Inp.InAddr > ReadTop)
{
return(true);
}
if (UnpAudioBlock)
{
for (uint I = 0; I < UnpChannels; I++)
{
MakeDecodeTables(Table, (int)(I * MC20), MD[I], MC20);
}
}
else
{
MakeDecodeTables(Table, 0, BlockTables.LD, NC20);
MakeDecodeTables(Table, (int)NC20, BlockTables.DD, DC20);
MakeDecodeTables(Table, (int)(NC20 + DC20), BlockTables.RD, RC20);
}
//x memcpy(UnpOldTable20,Table,sizeof(UnpOldTable20));
Array.Copy(Table, 0, UnpOldTable20, 0, UnpOldTable20.Length);
return(true);
}
public static float Axis(Inp inp)
{
float val = 0f;
for (int i = 0; i < virtuals.Length; ++i)
{
if (virtuals[i].MapTo == inp)
val += virtuals[i].GetAxis();
}
if (val > 1f)
return 1f;
if (val < -1f)
return -1f;
return val;
}
public static bool GetDown(Inp inp)
{
for (int i = 0; i < virtuals.Length; ++i)
if (virtuals[i].MapTo == inp && virtuals[i].GetDown())
return true;
return false;
}
public static bool Get(Inp inp)
{
return Axis(inp) >= 0.5f;
}
public void Scroll()
{
Inp.CaretIndex = Inp.Text.Length;
Inp.ScrollToEnd();
InpScroll.ScrollToEnd();
}
public virtualInp(Inp mapTo, KeyCode key)
{
Type = type.Key;
MapTo = mapTo;
High = key;
}
private void Unpack5(bool Solid)
{
FileExtracted = true;
if (!Suspended)
{
UnpInitData(Solid);
if (!UnpReadBuf())
{
return;
}
// Check TablesRead5 to be sure that we read tables at least once
// regardless of current block header TablePresent flag.
// So we can safefly use these tables below.
if (!ReadBlockHeader(Inp, ref BlockHeader) ||
!ReadTables(Inp, ref BlockHeader, ref BlockTables) || !TablesRead5)
{
return;
}
}
while (true)
{
UnpPtr &= MaxWinMask;
if (Inp.InAddr >= ReadBorder)
{
bool FileDone = false;
// We use 'while', because for empty block containing only Huffman table,
// we'll be on the block border once again just after reading the table.
while (Inp.InAddr > BlockHeader.BlockStart + BlockHeader.BlockSize - 1 ||
Inp.InAddr == BlockHeader.BlockStart + BlockHeader.BlockSize - 1 &&
Inp.InBit >= BlockHeader.BlockBitSize)
{
if (BlockHeader.LastBlockInFile)
{
FileDone = true;
break;
}
if (!ReadBlockHeader(Inp, ref BlockHeader) || !ReadTables(Inp, ref BlockHeader, ref BlockTables))
{
return;
}
}
if (FileDone || !UnpReadBuf())
{
break;
}
}
if (((WriteBorder - UnpPtr) & MaxWinMask) < MAX_LZ_MATCH + 3 && WriteBorder != UnpPtr)
{
UnpWriteBuf();
if (WrittenFileSize > DestUnpSize)
{
return;
}
if (Suspended)
{
FileExtracted = false;
return;
}
}
uint MainSlot = DecodeNumber(Inp, BlockTables.LD);
if (MainSlot < 256)
{
if (Fragmented)
{
FragWindow[UnpPtr++] = (byte)MainSlot;
}
else
{
Window[UnpPtr++] = (byte)MainSlot;
}
continue;
}
if (MainSlot >= 262)
{
uint Length = SlotToLength(Inp, MainSlot - 262);
uint DBits, Distance = 1, DistSlot = DecodeNumber(Inp, BlockTables.DD);
if (DistSlot < 4)
{
DBits = 0;
Distance += DistSlot;
}
else
{
DBits = DistSlot / 2 - 1;
Distance += (2 | (DistSlot & 1)) << (int)DBits;
}
if (DBits > 0)
{
if (DBits >= 4)
{
if (DBits > 4)
{
Distance += ((Inp.getbits32() >> (int)(36 - DBits)) << 4);
Inp.addbits(DBits - 4);
}
uint LowDist = DecodeNumber(Inp, BlockTables.LDD);
Distance += LowDist;
}
else
{
Distance += Inp.getbits32() >> (int)(32 - DBits);
Inp.addbits(DBits);
}
}
if (Distance > 0x100)
{
Length++;
if (Distance > 0x2000)
{
Length++;
if (Distance > 0x40000)
{
Length++;
}
}
}
InsertOldDist(Distance);
LastLength = Length;
if (Fragmented)
{
FragWindow.CopyString(Length, Distance, ref UnpPtr, MaxWinMask);
}
else
{
CopyString(Length, Distance);
}
continue;
}
if (MainSlot == 256)
{
UnpackFilter Filter = new UnpackFilter();
if (!ReadFilter(Inp, Filter) || !AddFilter(Filter))
{
break;
}
continue;
}
if (MainSlot == 257)
{
if (LastLength != 0)
{
if (Fragmented)
{
FragWindow.CopyString(LastLength, OldDist[0], ref UnpPtr, MaxWinMask);
}
else
{
CopyString(LastLength, OldDist[0]);
}
}
continue;
}
if (MainSlot < 262)
{
uint DistNum = MainSlot - 258;
uint Distance = OldDist[DistNum];
for (uint I = DistNum; I > 0; I--)
{
OldDist[I] = OldDist[I - 1];
}
OldDist[0] = Distance;
uint LengthSlot = DecodeNumber(Inp, BlockTables.RD);
uint Length = SlotToLength(Inp, LengthSlot);
LastLength = Length;
if (Fragmented)
{
FragWindow.CopyString(Length, Distance, ref UnpPtr, MaxWinMask);
}
else
{
CopyString(Length, Distance);
}
continue;
}
}
UnpWriteBuf();
}
void Unpack29(bool Solid)
{
uint Bits;
if (DDecode[1] == 0)
{
int Dist = 0, BitLength = 0, Slot = 0;
for (int I = 0; I < DBitLengthCounts.Length; I++, BitLength++)
{
for (int J = 0; J < DBitLengthCounts[I]; J++, Slot++, Dist += (1 << BitLength))
{
DDecode[Slot] = Dist;
DBits[Slot] = (byte)BitLength;
}
}
}
FileExtracted = true;
if (!Suspended)
{
UnpInitData(Solid);
if (!UnpReadBuf30())
{
return;
}
if ((!Solid || !TablesRead3) && !ReadTables30())
{
return;
}
}
while (true)
{
UnpPtr &= MaxWinMask;
if (Inp.InAddr > ReadBorder)
{
if (!UnpReadBuf30())
{
break;
}
}
if (((WrPtr - UnpPtr) & MaxWinMask) < 260 && WrPtr != UnpPtr)
{
UnpWriteBuf30();
if (WrittenFileSize > DestUnpSize)
{
return;
}
if (Suspended)
{
FileExtracted = false;
return;
}
}
if (UnpBlockType == BLOCK_PPM)
{
// Here speed is critical, so we do not use SafePPMDecodeChar,
// because sometimes even the inline function can introduce
// some additional penalty.
int Ch = PPM.DecodeChar();
if (Ch == -1) // Corrupt PPM data found.
{
PPM.CleanUp(); // Reset possibly corrupt PPM data structures.
UnpBlockType = BLOCK_LZ; // Set faster and more fail proof LZ mode.
break;
}
if (Ch == PPMEscChar)
{
int NextCh = SafePPMDecodeChar();
if (NextCh == 0) // End of PPM encoding.
{
if (!ReadTables30())
{
break;
}
continue;
}
if (NextCh == -1) // Corrupt PPM data found.
{
break;
}
if (NextCh == 2) // End of file in PPM mode.
{
break;
}
if (NextCh == 3) // Read VM code.
{
if (!ReadVMCodePPM())
{
break;
}
continue;
}
if (NextCh == 4) // LZ inside of PPM.
{
uint Distance = 0, Length;
bool Failed = false;
for (int I = 0; I < 4 && !Failed; I++)
{
int _Ch = SafePPMDecodeChar();
if (_Ch == -1)
{
Failed = true;
}
else
if (I == 3)
{
Length = (byte)_Ch;
}
else
{
Distance = (Distance << 8) + (byte)_Ch;
}
}
if (Failed)
{
break;
}
CopyString(Length + 32, Distance + 2);
continue;
}
if (NextCh == 5) // One byte distance match (RLE) inside of PPM.
{
int Length = SafePPMDecodeChar();
if (Length == -1)
{
break;
}
CopyString((uint)(Length + 4), 1);
continue;
}
// If we are here, NextCh must be 1, what means that current byte
// is equal to our 'escape' byte, so we just store it to Window.
}
Window[UnpPtr++] = (byte)Ch;
continue;
}
uint Number = DecodeNumber(Inp, BlockTables.LD);
if (Number < 256)
{
Window[UnpPtr++] = (byte)Number;
continue;
}
if (Number >= 271)
{
uint Length = (uint)(LDecode[Number -= 271] + 3);
if ((Bits = LBits[Number]) > 0)
{
Length += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
uint DistNumber = DecodeNumber(Inp, BlockTables.DD);
uint Distance = (uint)(DDecode[DistNumber] + 1);
if ((Bits = DBits[DistNumber]) > 0)
{
if (DistNumber > 9)
{
if (Bits > 4)
{
Distance += ((Inp.getbits() >> (int)(20 - Bits)) << 4);
Inp.addbits(Bits - 4);
}
if (LowDistRepCount > 0)
{
LowDistRepCount--;
Distance += (uint)PrevLowDist;
}
else
{
uint LowDist = DecodeNumber(Inp, BlockTables.LDD);
if (LowDist == 16)
{
LowDistRepCount = (int)(LOW_DIST_REP_COUNT - 1);
Distance += (uint)PrevLowDist;
}
else
{
Distance += LowDist;
PrevLowDist = (int)LowDist;
}
}
}
else
{
Distance += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
}
if (Distance >= 0x2000)
{
Length++;
if (Distance >= 0x40000)
{
Length++;
}
}
InsertOldDist(Distance);
LastLength = Length;
CopyString(Length, Distance);
continue;
}
if (Number == 256)
{
if (!ReadEndOfBlock())
{
break;
}
continue;
}
if (Number == 257)
{
if (!ReadVMCode())
{
break;
}
continue;
}
if (Number == 258)
{
if (LastLength != 0)
{
CopyString(LastLength, OldDist[0]);
}
continue;
}
if (Number < 263)
{
uint DistNum = Number - 259;
uint Distance = OldDist[DistNum];
for (uint I = DistNum; I > 0; I--)
{
OldDist[I] = OldDist[I - 1];
}
OldDist[0] = Distance;
uint LengthNumber = DecodeNumber(Inp, BlockTables.RD);
int Length = LDecode[LengthNumber] + 2;
if ((Bits = LBits[LengthNumber]) > 0)
{
Length += (int)(Inp.getbits() >> (int)(16 - Bits));
Inp.addbits(Bits);
}
LastLength = (uint)Length;
CopyString((uint)Length, Distance);
continue;
}
if (Number < 272)
{
uint Distance = (uint)(SDDecode[Number -= 263] + 1);
if ((Bits = SDBits[Number]) > 0)
{
Distance += Inp.getbits() >> (int)(16 - Bits);
Inp.addbits(Bits);
}
InsertOldDist(Distance);
LastLength = 2;
CopyString(2, Distance);
continue;
}
}
UnpWriteBuf30();
}
public static bool Axis(Inp inp, out float value)
{
value = Axis(inp);
return value != 0f;
}
