All Classes and Interfaces
Class
Description
A rectangle that can be pressed, dragged or scrolled over, in page pixels.
Where a book goes when something on a page is pressed.
Rewrites a book written in an older format into a newer one, a format at a time, as it loads: Folios then only ever
reads the current format.
What an upgrade made: the files, rewritten; translations to add to the book's lang file (en_us); and what changed, by file.
The server's quests on the client: what the server sent of each (books show them as they are written), what it found
of the player's progress, and claiming their rewards.
A server quest as a book shows it.
Where a book model wants its cover lettering, marked in the model itself: an element whose name has
#title
in it is where the book's name goes, one with #subtitle where its subtitle goes, one with #summary
where its summary goes (a book with a summary has its subtitle under its name instead; one without has its subtitle
where the summary would go, if nothing marks a subtitle), and one with #icon is the gem the book's cover icon
is set in (CoverEmblem; its middle and size, square, turned 45° as a setting is) (in Blockbench, rename the
cube; a plate, or an invisible box, either works).RULE: a soft rule with a diamond stud at its middle, its line's size its thickness, its width its length.
What is lettered where: the book's name, its subtitle, its summary (up to
lines lines), each its own colour.A marked line: where and how large, and the z of the face it lies on.
What a model marks; any may be null.
A lettering's rows of text and how large:
scale model units to a font pixel, top the first row's y.A band round the spine: from
y0 to y1 up it (0 at the foot, 16 at the head), standing out
off it (in x's units), its face from that part of texture (0 to 1), tinted as a face's "tintindex" says.What a reveal effect draws over a page, faded out towards the page's edges and its fold, so sparks, smoke, light and
runes melt into the paper instead of stopping short at its border.
How an element is set on its page, beside what it shows: what happens when it doesn't fit (
"overflow"),
where its parts sit across the page ("alignment", "title_alignment") and down a box taller than they
are ("anchor").Where an element's parts sit down a box taller than they are.
How tall an element's box is:
ElementLayout.Height.Kind.FILL the rest of the page, ElementLayout.Height.Kind.FIT only as tall as what it
holds (up to the rest of the page), ElementLayout.Height.Kind.FIXED that many pixels, or ElementLayout.Height.Kind.PERCENT that share of the
page's content.What an element does when it doesn't fit in what is left of its page.
Where something sits across a page: an element's text and what it shows, as
"alignment" and
"title_alignment" in JSON ("left", "center", "right" or "justify").Gives the search field the keyboard: the screen's focus and the field's own.
A guide book, as read from
assets/<namespace>/folios/<path>/book.json and the categories and entries beside
it.A book's colour scheme:
"colors" in book.json, each colour "#RRGGBB" (or "#AARRGGBB").Where a book's name and subtitle are lettered on its cover, on the book item and a handheld book alike:
"cover_text" in book.json.A line of lettering: its middle (x, y), how large, and how much room it has across.
What a reader can do while holding a handheld book open:
"handheld" in book.json.Where the things around a page's content sit, in page pixels, in both styles:
"layout" in book.json.A place in a book: an entry, and a page of it (0 for its first).
The models a book is shown with:
"models" in book.json.How a handheld book's leaves turn (
"page_turn" in book.json).Where what is read in a book is kept (
"progress" in book.json): the entries read, the pages shown, the
bookmarks and where the reader left off.The texture layers a book is drawn with, in both styles:
"textures" in book.json, each a texture path.An item that opens a guide book when used.
Guide books from either side: the item that carries one, and opening one for a player from the server.
The sources Folios gives itself, worked out from the game as a page observing one is laid out, so a data pack can
list live game content with no code.
A category of a book's entries.
Each player's own preferences.
A corner of the screen.
An entry of a book: a titled run of pages, in a category.
A page of the entry, with what applies to it whatever its kind.
The JSON formats books are written in.
Guide books on the client: the books loaded from resource packs, and opening them.
A book's, category's or entry's 16-pixel icon: items (
FoliosStack, e.g.Where pages are laid out: the page's size and margins, the font, and helpers for the parts most pages have (a
title, and text that continues onto further pages).
What a page asked
FoliosLayout.flow(String, int, String, FoliosPageElement.Part) for: its title, its own part and how tall it is, and its text.Kinds of link a book's text can make:
[label](scheme:target) in any book goes to the kind registered for
scheme, which says what the link shows under the pointer and does when pressed.A link's kind and the part of it after the scheme.
What a kind of link does.
What keeps a category, entry or page closed until the player has earned it.
Mentions of a book's pages in chat.
A condition the player makes progress on: an objective of a quest page, shown with a bar, and what a lock
(
"requires", FoliosLock) waits for.Values a mod reports for books to follow: an objective
{"source": "mymod:mana", "goal": 100} is as far along
as the source's value is towards its goal.A value to follow, for the local player.
A page of an entry, as its JSON describes it.
A page ready to draw.
Something drawn on a page from a given height down, such as what comes before a page's text.
A laid page that is half of a spread: the book draws its frame joined with the
other half's over the fold, and one page number for both, at the fold.
The types of element a page shows, by the
"type" their JSON names.What a page draws with.
What a dragged rectangle does as the pointer moves while it is held: by how far, in page pixels.
What a rectangle does when the mouse wheel turns over it: by how many notches, away from the reader positive.
The colours a page is drawn in (ARGB).
The advancements a player has completed: all of them (
reset), or ones newly completed or revoked.A client claiming the reward of a server quest its player has done.
The server opening a book, at an entry or its start.
A client sending what its player has done with a book, to be kept: with the player (
hand -1), or on the
book in that hand, for a book that keeps its own.The server's quests (data packs'
folios/quests), each as its file is written, sent to a player.A client saying its player started or stopped reading the handheld book in a hand (-1 for no hand).
A client saying which spread of the handheld book its player has open, or that none is (
open false);
shut while it is held up shut, about to be opened.How one recipe looks, as the recipe book shows it; empty for a recipe the server doesn't have.
A client asking how recipes look.
The server telling a player which spread someone near them has open in their hands, to read along.
A source's rows (FoliosSources), from the server, for the pages observing it, and the ids data packs took out.
A structure's blocks: its
palette of states, and each block as four numbers in blocks, its x, y and
z and its state's place in the palette.A client asking for structures' blocks.
A client saying which entry of a book is on its player's screen, as that changes;
FoliosPayloads.NO_BOOK once none is.A small window a link opens over the book: under the pointer while it is over the link's words, and pinned in place
once they are pressed, until the reader presses elsewhere or Esc.
Quests the server follows: those data packs give (
data/<namespace>/folios/quests/<name>.json), checked by the
server alone and rewarded by it.Told when a player finishes a server quest.
Leaves in the air: what was open and what is opening (their pages and spreads), and which way they turn.
A place in the book: a part of it ("home", "category:", "entry:", "search:", "bookmarks", "index") and the left page of a spread.
What a reader has done with one book: the entries read, the spreads shown (for reveals that play only on unread
pages), the quests done and what has been celebrated, the bookmarks, and where they left off.
A page of an entry.
How a page's content shows once the page is turned to: everything drawn on it (text, pictures, items, scenes,
whatever a page type draws) asks the effect how it looks at this point of the reveal, by where it is on the page.
How a thing looks: how much it shows (0 not at all, 1 fully; items and scenes, which can't fade, show once past
a half), how far it is moved from its place in page pixels, a colour it is tinted towards (
tint's alpha
is how far: 0 not at all), and what share of its letters, if it is text, show as runes (0 none, 1 all).A reveal: an effect, how long it takes in seconds, whether it plays only the first time each spread is seen this
game (
once; pages of entries read in an earlier game count as seen), and whether it plays only on spreads
the reader has never been shown in full (unread; kept with the player, or with the copy of a book that
keeps its own, so it doesn't play again after a restart or on another computer).The reveal effects books can use (
FoliosReveal), by id.The server's rules for its quests: how reading is checked, and how strictly rewarded quests are held.
An entry's pages, ready to draw: markers and the pages of its JSON point into them.
Where a link goes.
The rows of
FoliosSources: on the server, those data packs add (data/<namespace>/folios/sources/*.json)
and the sending of every server source to players; on the client, what the server sent.Live lists a book's pages can show: a page element with
"observe": {"source": "mymod:spells", "row": "..."}
writes a line for each row of the source, and is written again whenever the list changes, so content added by addons
or data packs shows in the book without anyone editing it.A row of a source: its id, and its fields by name.
Items as a page names them, worked out only when they're first drawn (item components need the world's registries,
which a book loaded with resources doesn't have yet).
A structure as the server told of it: its blocks by place, or why there are none.
The ways a book can be shown, named by its
book.json's "style".Shows a book.
Text written for a book, set out in lines to a width.
What a line is part of, which decides how it is drawn.
One line, at (x, y) from the text's top left.
Items an objective asks for, as the server matches them: written as a book writes them (
"minecraft:diamond",
"#minecraft:logs", a stack object, or a list of these), matched by item alone.An entry to link to (its id, with an optional
#marker), and the words shown for it; empty for its name.An element's
"observe": text written from a live list (FoliosSources), a line of markup for each of its
rows, put after the element's own text and written again whenever the list changes.One of the books' small pixel-art icons: a white image (its softer pixels part see-through), drawn at its own size,
a pixel to a pixel, tinted with the colour it is drawn in.
What the server knows of a player's quests: kept with the player, sent only to them.
One quest's progress: each objective's, 0 to 1; whether it is open (its
"requires" met once, and open
from then on); whether it is done (and stays so, whatever happens after); and whether its reward has been claimed.A book's popup windows (
FoliosPopup), over everything else on the screen: the one a link under the pointer
shows, in place of a tooltip, and the one pressing it pinned, which stays where it was until the reader presses off
it, presses Esc or turns the page.The entities books show in scenes (entity pages, entity popups), made on the client and in no world, so nothing else
ticks them.
What the server counts as reading, for quests'
"read" objectives.A quest's
"rewards": items it always gives, and random gifts, each drawn from a list:A random gift's choice, picked
weight times as often as one of weight 1.The server's quests: loaded from data packs, followed for each player and rewarded.
Folios's own popup links: a window over the book showing what the link names, turning, as the page elements of the
same kind show it.
An objective of a server quest, read from the same JSON a book's quest takes and checked by the server alone.
A quest a data pack gives (
data/<namespace>/folios/quests/<name>.json): its objectives, followed by the server,
and what it gives once done.The little controls printed on pages: each a pixel icon on a clasp ('X' in its ink, 'o' a softer shade).
A build in the window: a multiblock page's pattern and mapping.
The map: its places, the paths between them (pairs of ids), and a picture under them.
A place on the map: where it is in the window, what it shows, the entry it opens, and its label.
The sprites a book's widgets are drawn from: bars, clasps, panels, slots, the flip pager.
An element of a page, how it is set there, and the source its text observes (null for none).
An item handed to the screen, with the colour it was handed with.
A curved page: where a point of it is in the pose's space, and which way its axes point there.