The designer of this FontStruction has chosen not to make it available for download from this website by choosing an “All Rights Reserved" license.
Please respect their decision and desist from requesting license changes in the comments.
If you would like to use the FontStruction for a specific project, you may be able to contact the designer directly about obtaining a license.
ZX82 ABCDEFG: a bicolor drolatique font generator
[dpla's ZX Spectrum edition – version 1.0 or ROIAOAIO]
294 visible text characters, in 'Extended ASCII' (U0020-FF) and a few beyond.
7 code pages (CP) to switch from, and 48 cells left unassigned (in CP 4 to 6).
Feel free to add your private glyphs, provided you retain the original mapping;
you may replace them with invisible formatting controls (e.g. for animations).
The CP switches are 7 visible control characters, applied once or indefinitely,
that is: K/B/R/M/G/C/Y → temporary; KY/BY/RY/MY/GY/CY/YY → permanent.
Please, bear in mind that my main mapping (CP 0) is based on our 6 vowels,
contrary to A-Z substitutions (like David B. Kelley's "6-Color Binary Alphabet").
This implementation uses 7 colors in ascending RGB on a white background
(hence my title: a 8-bit allusion to the ZX Spectrum Ink and Paper on screen).
Example: "Hello·world!" = "BY K RM RK MM MM GK •CR GK GM MM BM KK"
where the letters = their abbreviated color (0-6), and 'Space' / "•" = White (7).
Typically on a display, you can resort to a pair of characters (any block / bar)
but you can use the material of your choice (e.g. balloons, the air being "W"),
even derivate in color (symbols), size (micro), view (vector, 3D), language…
Script & mapping: copyright © 2014-2018 dpla; else: under CC BY-NC-SA 4.0.
dpla.fr/fonts/7-color
14 Comments
A primitive* representation of this script.
E.g. you can print, color, next lay objects…
Full Txt / Original Png. From my old Xlsb.
* Credit: David Kelley's "6-Color Binary Alphabet" (unknown release year on Omniglot.com), just for the incentive to push the idea further (in a mnemonical and programming way, hopefully).
I'll post some related/derived artwork later.
???
Hi! Thank you for your sign of interest.
I think it's already too late to answer to you both, Hensley Dodson (Hensilly) and Merrybot, otherwise (or for the others in the 2030s), you were right: my 2-line how-to, « A primitive representation of this script. E.g. you can print, color, next lay objects… », still sounds puzzling or looks too sober to me after a while. (So, I guess that the deceptive difficulty comes here from the lack of practical steps, and likely from the versatile design – which is simply a logical code that you can apply to a lot of materials). In my rustic, even banal exemple of application, I thought that this kind of __template builder__ would help in juxtaposing rectilinearly (at first) your elements. Then let's proceed as follows…
1. Enter your final code(*). The input keys of this fontstruction are straightforward: "01234567". These digits are virtually like computer bits: each of them is bound to a unique color. {In this case of 'ZX82' edition, these bound colors use the palette of the Sinclair ZX Spectrum, in the original order (which was thought to be well-known/mnemonics, at least to the old/retro coders): 0=blacK, 1=Blue, 2=Red, 3=Magenta, 4=Green, 5=Cyan, 6=Yellow, 7=White (or in other terms: "01234567" = "KBRMGCYW"/"kbrmgcyw" [the letters were only added for the support of the 'ZX82' palette]).}
2. Even if you didn't download/install this fontstruction, you'll need to print this sort of template on a sheet of white paper; at the desired size (which depends on the size of the elements you chose, and on the length of your message/code).
3. Color manually the boxes of your template (yes, this can get painstaking). The digits remind you which ones (from the first step, or arbitrarily in case your elements don't exist in the 'ZX82' colors – for example, the 7-color candies rarely meet the 'ZX82' requirement).
4. Lay manually your elements on the printed boxes. You may need to glue/bridge/string/… these objects at this step (since free and round elements like pearls would be tough to maintain in place).
5. Remove the template. (The spacing element should allow this step, hopefully.)
6. Optionally adjust the shape of your colored (= encoded) elements. For instance in a circle way to build a type of necklace.
* (NOTE: A ready code from the documentation above is: "BY K RM RK MM MM GK •CR GK GM MM BM KK". But you can ask me to convert your own 'Extended ASCII' message manually; I'll do my best for educational/training purpose, if it's not too long of course.)
Please bear in mind that this script can be applied to a good deal of derivations, therefore this tutorial remains merely an introduction to this world of rather cool text encoding.
Material sample(s) of mine still in due time…
Bye!
Other simple application (of this template 'generator'): 'hidden' text in colored/art dominoes.
16 0 11 60 20 00
=
(Code page 0 by default),
16 (switches permanently to code page #1),
0 (switches temporarily to code page #0),
11 (B),
60 (y),
20 (e),
00 (!).
W is this?
@Hensley Dodson (Hensilly) and Merrybot:
ZX82ABCDEFG
All right, here is a STEP-BY-STEP example…
TEXT CONVERSION
and formatting
• STEP 1 (initial):
FontStruct.com
(Hello world!)
• STEP 2:
[Switch permanently to (UC-optimized) CP #0
(by default => no code; 06 needed otherwise)]
21 [text: F]
16 [switch permanently to (LC-optimized) CP #1]
40 [text: o]
35 [text: n]
45 [text: t]
_0 [switch once to (UC-optimized) CP #0]
44 [text: S]
45 [text: t]
43 [text: r]
50 [text: u]
12 [text: c]
45 [text: t]
_0 [switch once to (6-punct.-optimized) CP #0]
00 [text: .]
12 [text: c]
40 [text: o]
34 [text: m]
-- [LF (undocumented)]
64 [text: (]
_0 [switch once to (UC-optimized) CP #0]
23 [text: H]
20 [text: e]
33 [text: l]
33 [text: l]
40 [text: o]
_7 [SP]
52 [text: w]
40 [text: o]
43 [text: r]
33 [text: l]
13 [text: d]
00 [text: !]
65 [text: )]
N.B. This kind of encoding (step 2) requires some training.
• STEP 3:
21 16 40 35 45 _0 44 45 43 50 12 45 _0 00 12 40 34 -- 64 _0 23 20 33 33 40 _7 52 40 43 33 13 00 65
• STEP 4:
2116403545_0444543501245_000124034--64_02320333340_752404333130065
• STEP 5:
01234567 [show the 8-bit palette, which starts the text]
2116403545_0444543501245_000124034 [text row #1]
-- [single line feed]
64_02320333340_752404333130065 [text row #2]
.. [ends the text]
• STEP 6:
01234567 [unchanged]
2116403545704445435012457000124034 [_ => 7]
7777 [- => 77]
647023203333407752404333130065 [_ => 7]
7 [.. => 7]
• STEP 7 (final):
01234567211640354570444543501245700012403477776470232033334077524043331300657
Which makes, in the 'ZX82' palette (after the character substitutions):
KBRMGCYWRBBYGKMCGCWKGGGCGMCKBRGCWKKKBRGKMGWWWWYGWKRMRKMMMMGKWWCRGKGMMMBMKKYCW
PALETTE,DATADATADATADATADATADATADATADATADATADATADATADATADATADATADATADATADATA.
00000000011111111112222222222333333333344444444445555555555666666666677777777
12345678901234567890123456789012345678901234567890123456789012345678901234567
= A strict 2-character implementation
+ beginning and ending (visual) info.
The length of this text string is 77;
the paper template has thus 77 boxes.
Enter the output code at the 7th step
in the fontstructor to add the boxes.
Print it and put all in a single row.
Color the surface of the (0-6) boxes.
Place your matching colored elements.
Have them joined together physically.
Remove the paper template if need be;
in this case you can shape the whole.
I should post its vector sample soon…
In the meantime, where are you stuck?
Here is a PIXEL SAMPLE below…
HOW it was made:
1. I pasted the output code (see step 7) to the View field
of the preview fontstructor (full screen, min. size, no spacing);
2. I copied (captured) the screen of my internet browser;
3. I pasted and joined the rows of boxes in a pixel editor;
4. I filled the 77 boxes of the code (quicker than on paper!);
5. I resized the whole to 700-px of width for the sample…
The spacing of the paired blocks has not been added yet, sorry.
THE GOAL of this colored template (i.e. of this fontstruction)
is simply to let you PLACE the colored objects on it safely…
Of course, you'll need to get this MATERIAL (pearls, dominoes…).
And do not forget that the LINEAR representation of this sample
is the rawest one can imagine – cf. David Kelley's DERIVATIONS.
Again, this kind of paired 8-bit encoding is not limited to this!
Oh, I get it now!
Oh, COME ON! >:|
I Don't Know, I Give Up Too!
34 16 20 43 43 60 11 40 45 76 55 70 23 20 35 44 33 20 60 77 70 13 40 13 44 40 35 77 64 70 23 20 35 44 30 33 33 60 65 = mocking duo?
I share my code/designs; stop trolling (via your Merrybot alias [PS deleted spams]).
https://fontstruct.com/fontstructions/show/1784319/abcdefg-small
Please sign in to comment.