Skip to content
BranchesTags

Repository files navigation

pack

This is a simple runlength packer for data in Pascal/Delphi. It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program. Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.

Use pack.exe to compress a file:

pack input-file output-file

As a very simple example, suppose you have a file level1.txt that represents a level for a game

XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck

Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:

OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas

The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:

bin2pas input-file output-file

So in this example, we can run: bin2pas level1.pck level1.inc

This produces a new file level1.inc, which has the following contents:

procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive

{$I level1.inc}

To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).

unpack.inc

In your Pascal or Delphi code, you can include the code to unpack your data by using the directive

{$I UNPACK.INC}

It contains two functions:

  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte

In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.

So in our example, you could have something like:

Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.

About

Simple compression / decompression for assets in Pascal / Delphi

Topics

compressiondatadecompressiondelphipascal

Resources

Readme
MIT license
Activity

Stars

7 stars

Watchers

1 watching

Forks

3 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - Wiering/Pack: Simple compression / decompression for assets in Pascal / Delphi · GitHub
Skip to content
BranchesTags
Repository files navigation
pack
This is a simple runlength packer for data in Pascal/Delphi.
It was used a lot in DOS to save valuable memory when storing data on disk or inside of a program.
Data that has many repeating characters can be compressed well. This is often useful for graphics, palettes, levels and other data used in games.
Use pack.exe to compress a file:
pack input-file output-file
As a very simple example, suppose you have a file level1.txt that represents a level for a game
XXXXXXXXXXXXXXX
Xsx.....x.....X
X.xxxxx.x.x.x.X
X...x.x.....x.X
Xxx.x.xxxx.xx.X
X...x......x.fX
XXXXXXXXXXXXXXX

Pack it with the command: pack level1.txt level1.pck
Old size: 119 New size: 79 Gain: 40 (33.6%)

The new (binary) file now looks something like this:
OX�.XsxE.�xE.�X.X.Exc.x�.X.XÃ..xx..xX�.XBxb.xCx�.Bx�.X.XC.�xF.�x.fX.OX�

bin2pas
The program bin2pas provides an easy way to get your packed file (or basically any file) right into your Pascal/Delphi code. It has the same syntax as pack:
bin2pas input-file output-file
So in this example, we can run: bin2pas level1.pck level1.inc
This produces a new file level1.inc, which has the following contents:
procedure level1pck; assembler;
asm
db 79, 88, 5, 13, 10, 88,115,120, 69, 46, 1,120, 69, 46, 5, 88
db 13, 10, 88, 46, 69,120, 99, 46,120, 5, 46, 88, 13, 10, 88,199
db 46, 46,120,120, 46, 46,120, 88, 3, 13, 10, 88, 66,120, 98, 46
db 120, 67,120, 1, 46, 66,120, 5, 46, 88, 13, 10, 88, 67, 46, 1
db 120, 70, 46, 6,120, 46,102, 88, 13, 10, 79, 88, 2, 13, 10
end;

You can include this file into your Pascal/Delphi code using the directive
{$I level1.inc}
To reference the data, you can use @level1pck (as a pointer) or @level1pck^ (the actual data).
unpack.inc
In your Pascal or Delphi code, you can include the code to unpack your data by using the directive
 {$I UNPACK.INC}
It contains two functions:
  • procedure Unpack(p: Pointer)
  • function GetNextByte(): Byte
In your code, start by calling unpack once and then use GetNextByte to get each next (uncompressed) byte of data. Note: You need to know the size of your data or have a way to recognize the end of the stream.
So in our example, you could have something like:
Unpack(@level1pck);
for j := 0 to LEVEL_SIZE_Y - 1 do
for i := 0 to LEVEL_SIZE_X - 1 do
case Chr(GetNextByte()) of
'X': ...

Of course, this example is way too small for this to be beneficial. However, this system was used successfully in most games by Wiering Software, at least the ones written in Pascal/Delphi.
About
Simple compression / decompression for assets in Pascal / Delphi
Topics
compressiondatadecompressiondelphipascal
Resources
Readme
MIT license
Activity
Stars
7 stars
Watchers
1 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages