@openbooknetwork/hesap 0.3.0 → 0.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/src/client.css +165 -0
- package/src/families/counters/add-figures.js +85 -0
- package/src/families/counters/add-goals.js +82 -0
- package/src/families/counters/add-model.js +82 -0
- package/src/families/counters/add.js +442 -0
- package/src/families/counters/add.mjs +102 -0
- package/src/families/counters/bonds.js +5 -5
- package/src/families/counters/client.css +37 -0
- package/src/families/counters/client.js +2 -1
- package/src/families/counters/count.js +4 -5
- package/src/families/counters/counter.js +14 -0
- package/src/families/counters/goals.js +1 -9
- package/src/families/counters/i18n/en.yaml +89 -45
- package/src/families/counters/i18n/tr.yaml +56 -12
- package/src/families/counters/index.mjs +5 -3
- package/src/families/counters/match-model.js +10 -1
- package/src/families/counters/match.js +31 -11
- package/src/families/counters/match.mjs +7 -1
- package/src/families/line/client.css +118 -0
- package/src/families/line/client.js +12 -0
- package/src/families/line/figures.js +143 -0
- package/src/families/line/goals.js +168 -0
- package/src/families/line/i18n/en.yaml +61 -0
- package/src/families/line/i18n/tr.yaml +61 -0
- package/src/families/line/index.mjs +227 -0
- package/src/families/line/lens.js +49 -0
- package/src/families/line/line.js +624 -0
- package/src/families/line/model.js +219 -0
- package/src/families.mjs +2 -1
- package/src/i18n/en.yaml +158 -46
- package/src/i18n/tr.yaml +124 -12
- package/src/kit/i18n/en.yaml +8 -1
- package/src/kit/i18n/tr.yaml +7 -0
- package/src/kit/kit.css +9 -0
- package/src/kit/panel.js +2 -0
- package/src/kit/random.js +9 -0
- package/src/kit/written.js +70 -0
- package/src/node.mjs +3 -1
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
/* line: the colours are theme tokens and the two point colours of the family, so a theme switch needs no redraw. */
|
|
2
|
+
.hesap-line .line-svg{position:absolute;left:0;top:0;width:100%;height:100%;touch-action:none;font-family:var(--body);overflow:hidden}
|
|
3
|
+
.hesap-line text{fill:var(--ink);text-anchor:middle;dominant-baseline:central;pointer-events:none;font-variant-numeric:tabular-nums}
|
|
4
|
+
.hesap-line .line-c-point{--c:var(--z-line-point,#d1453b)}
|
|
5
|
+
.hesap-line .line-c-second{--c:var(--z-line-second,#2a6bd1)}
|
|
6
|
+
/* The flag of the number to find is ink, apart from both points' colours. */
|
|
7
|
+
.hesap-line .line-c-find{--c:var(--ink)}
|
|
8
|
+
.hesap-line .line-c-find .line-flag-text{fill:var(--paper)}
|
|
9
|
+
|
|
10
|
+
/* The line, its marks and their labels. */
|
|
11
|
+
.hesap-line .line-axis{stroke:var(--ink);stroke-width:2.5;stroke-linecap:round}
|
|
12
|
+
.hesap-line .line-mark{stroke:var(--ink);stroke-width:2;stroke-linecap:round}
|
|
13
|
+
.hesap-line .line-short{stroke:var(--ink-2);stroke-width:1.5}
|
|
14
|
+
.hesap-line .line-label{font-weight:400;font-variant-numeric:proportional-nums}
|
|
15
|
+
.hesap-line .line-label.line-lit{font-weight:700;fill:var(--accent)}
|
|
16
|
+
.hesap-line .line-guide{stroke:var(--ink-2);stroke-width:1;stroke-dasharray:2 4;opacity:.6}
|
|
17
|
+
|
|
18
|
+
/* A point is a disc or a square with a touch target round it, and its flag carries its number. */
|
|
19
|
+
.hesap-line .line-hit{fill:transparent}
|
|
20
|
+
.hesap-line .line-point{cursor:grab;outline:none}
|
|
21
|
+
.hesap-line .line-point.drag{cursor:grabbing}
|
|
22
|
+
.hesap-line .line-dot{fill:var(--c);stroke:var(--paper);stroke-width:2}
|
|
23
|
+
.hesap-line .line-point:focus-visible .line-hit{stroke:var(--accent);stroke-width:2.5}
|
|
24
|
+
.hesap-line .line-pole{stroke:var(--c);stroke-width:2}
|
|
25
|
+
.hesap-line .line-flag-box{fill:var(--c);stroke:var(--paper);stroke-width:1.5}
|
|
26
|
+
.hesap-line .line-flag-text{font-size:14px;font-weight:700;fill:#fff}
|
|
27
|
+
|
|
28
|
+
/* The jumps are arcs over the gaps they cross, with a head that shows their way. */
|
|
29
|
+
.hesap-line .line-arc{fill:none;stroke:var(--accent);stroke-width:2.5;stroke-linecap:round}
|
|
30
|
+
.hesap-line .line-arc-head{fill:var(--accent)}
|
|
31
|
+
|
|
32
|
+
/* The lens shows the marks around the point at full size, above a line whose gaps are too narrow to read. */
|
|
33
|
+
.hesap-line .line-lens{pointer-events:none}
|
|
34
|
+
.hesap-line .line-lens-box{fill:var(--panel);stroke:var(--ink-2);stroke-width:1.5}
|
|
35
|
+
.hesap-line .line-lens-tip{fill:var(--ink-2)}
|
|
36
|
+
|
|
37
|
+
/* The bracket over the tens round the point. */
|
|
38
|
+
.hesap-line .line-bracket{fill:none;stroke:var(--accent);stroke-width:2.5;stroke-linejoin:round;stroke-linecap:round}
|
|
39
|
+
|
|
40
|
+
/* A gap opens under the line as a line of its own. */
|
|
41
|
+
.hesap-line .line-gap{fill:transparent;cursor:pointer;outline:none}
|
|
42
|
+
.hesap-line .line-gap:hover,.hesap-line .line-gap[aria-pressed="true"]{fill:var(--accent);fill-opacity:.08}
|
|
43
|
+
.hesap-line .line-gap:focus-visible{stroke:var(--accent);stroke-width:2}
|
|
44
|
+
.hesap-line .line-open-gap{stroke:var(--accent);stroke-width:5;stroke-linecap:round}
|
|
45
|
+
.hesap-line .line-funnel{stroke:var(--ink-2);stroke-width:1;stroke-dasharray:3 3}
|
|
46
|
+
|
|
47
|
+
/* Blank label boxes and the label cards that fill them. */
|
|
48
|
+
.hesap-line .line-blank{fill:var(--paper);stroke:var(--ink-2);stroke-width:1.5;stroke-dasharray:4 3}
|
|
49
|
+
.hesap-line .line-card{cursor:grab;outline:none}
|
|
50
|
+
.hesap-line .line-card.drag{cursor:grabbing}
|
|
51
|
+
.hesap-line .line-card-box{fill:var(--panel);stroke:var(--ink);stroke-width:1.5}
|
|
52
|
+
.hesap-line .line-card-num{font-size:16px;font-weight:700}
|
|
53
|
+
|
|
54
|
+
/* The middle's long mark. */
|
|
55
|
+
.hesap-line .line-middle{stroke:var(--accent);stroke-width:2.5}
|
|
56
|
+
|
|
57
|
+
/* The street: a road, a house at each mark, door numbers on plaques, and the van as the point. */
|
|
58
|
+
.hesap-line .line-road{fill:color-mix(in srgb,var(--ink) 22%,var(--paper))}
|
|
59
|
+
.hesap-line .line-house-body{fill:color-mix(in srgb,#d99a1f 30%,var(--paper));stroke:var(--ink-2);stroke-width:1}
|
|
60
|
+
.hesap-line .line-door{fill:var(--ink-2)}
|
|
61
|
+
.hesap-line .line-plaque rect{fill:var(--paper);stroke:var(--ink);stroke-width:1.2}
|
|
62
|
+
.hesap-line .line-plaque text{font-weight:700}
|
|
63
|
+
.hesap-line .line-wheel{fill:var(--ink)}
|
|
64
|
+
.hesap-line .line-van-tip{fill:var(--c)}
|
|
65
|
+
.hesap-line .line-van-num{font-size:10px;font-weight:700;fill:#fff}
|
|
66
|
+
.hesap-line .line-card:focus-visible .line-card-box{stroke:var(--accent);stroke-width:3}
|
|
67
|
+
|
|
68
|
+
/* The estimate mark is pale, apart from the point and the marks. */
|
|
69
|
+
.hesap-line .line-estimate line{stroke:var(--accent);stroke-width:3;stroke-linecap:round;opacity:.55;stroke-dasharray:4 3}
|
|
70
|
+
.hesap-line .line-estimate path{fill:var(--accent);opacity:.55}
|
|
71
|
+
.hesap-line .line-fixed .line-dot{fill:var(--c);stroke:var(--paper);stroke-width:2}
|
|
72
|
+
|
|
73
|
+
/* The book: the edge of its pages between its covers, and the bookmark. */
|
|
74
|
+
.hesap-line .line-book-pages{fill:color-mix(in srgb,#f3e6c4 80%,var(--paper));stroke:var(--ink-2);stroke-width:1}
|
|
75
|
+
.hesap-line .line-book-leaf{stroke:var(--ink-2);stroke-width:.6;opacity:.5}
|
|
76
|
+
.hesap-line .line-book-cover{fill:color-mix(in srgb,#2a6bd1 60%,var(--ink))}
|
|
77
|
+
|
|
78
|
+
/* The touch band of a mark that the reader drags into place. */
|
|
79
|
+
.hesap-line .line-band{fill:transparent}
|
|
80
|
+
.hesap-line .line-handle{cursor:ew-resize;outline:none}
|
|
81
|
+
.hesap-line .line-mark-key{outline:none}
|
|
82
|
+
.hesap-line .line-handle.line-focus .line-band{stroke:var(--accent);stroke-width:2;fill:var(--accent);fill-opacity:.06}
|
|
83
|
+
|
|
84
|
+
/* The start of the jumps: a ring round its mark, and the point that moves by the buttons alone inside it. */
|
|
85
|
+
.hesap-line .line-ring{fill:none;stroke:var(--c);stroke-width:3}
|
|
86
|
+
.hesap-line .line-start.line-moves{cursor:grab;outline:none}
|
|
87
|
+
.hesap-line .line-start:focus-visible .line-hit{stroke:var(--accent);stroke-width:2.5}
|
|
88
|
+
.hesap-line .line-start.line-hot .line-ring{stroke-width:5}
|
|
89
|
+
.hesap-line .line-fixed{pointer-events:none}
|
|
90
|
+
.hesap-line .line-chip-wide{flex-basis:100%}
|
|
91
|
+
|
|
92
|
+
/* The words under the line. */
|
|
93
|
+
.hesap-line .line-reading{font-size:20px;font-weight:700}
|
|
94
|
+
|
|
95
|
+
/* The pond of the opening pages: the water, the bank, the stones and the frog. */
|
|
96
|
+
.hesap-line .line-water{fill:color-mix(in srgb,#2a8bd1 20%,var(--paper));stroke:none}
|
|
97
|
+
.hesap-line .line-bank{fill:color-mix(in srgb,#4a9d4f 40%,var(--paper));stroke:color-mix(in srgb,#4a9d4f 70%,var(--paper));stroke-width:2}
|
|
98
|
+
.hesap-line .line-stone-body{fill:color-mix(in srgb,var(--ink) 16%,var(--paper));stroke:var(--ink-2);stroke-width:1.5}
|
|
99
|
+
.hesap-line .line-stone-num{font-weight:700}
|
|
100
|
+
.hesap-line .line-frog-body,.hesap-line .line-frog-leg{fill:#3f9a46;stroke:#24622a;stroke-width:1.5}
|
|
101
|
+
.hesap-line .line-frog-eye{fill:#fff;stroke:#24622a;stroke-width:1.5}
|
|
102
|
+
.hesap-line .line-frog-pupil{fill:#1d1d1d}
|
|
103
|
+
.hesap-line .line-frog-mouth{fill:none;stroke:#24622a;stroke-width:1.5;stroke-linecap:round}
|
|
104
|
+
|
|
105
|
+
/* A part the text points at stands out. */
|
|
106
|
+
.hesap-line .line-hot .line-dot,.hesap-line .line-hot .line-flag-box{stroke:var(--accent);stroke-width:3}
|
|
107
|
+
.hesap-line .line-arcs.line-hot .line-arc{stroke-width:4}
|
|
108
|
+
.hesap-line .line-reading.line-hot{fill:var(--accent)}
|
|
109
|
+
.hesap-line .line-hot .line-frog-body{stroke:var(--accent);stroke-width:3}
|
|
110
|
+
|
|
111
|
+
/* The jump buttons keep to one row and show their sign large beside their name. */
|
|
112
|
+
.hesap-line .line-jumps{display:inline-flex;flex-wrap:nowrap;gap:.429rem}
|
|
113
|
+
.hesap-line .line-jump b{font-size:1.286rem;line-height:1}
|
|
114
|
+
|
|
115
|
+
@media (max-width:900px){
|
|
116
|
+
/* The figure ends above the peek card, which covers the foot of the stage until the reader closes it. */
|
|
117
|
+
.hesap-line .line-svg{height:calc(100% - var(--hesap-peek,0px))}
|
|
118
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
// The browser half of the line family. The family has one scene, the number line, so it hands every page to it.
|
|
2
|
+
import line from './line.js';
|
|
3
|
+
|
|
4
|
+
export default function family(api) {
|
|
5
|
+
const scene = line(api);
|
|
6
|
+
return {
|
|
7
|
+
show(spec, page) { scene.show(spec, page); },
|
|
8
|
+
hide() { scene.hide(); },
|
|
9
|
+
point(id, on) { scene.point(id, on); },
|
|
10
|
+
lang() { scene.lang(); },
|
|
11
|
+
};
|
|
12
|
+
}
|
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
// The parts of a line figure: the points with their flags, the arcs of the jumps, and the frog, the stones and the
|
|
2
|
+
// bank of the opening pages. Every part is drawn in pixels of the stage.
|
|
3
|
+
import { svg as el } from '../../kit/dom.js';
|
|
4
|
+
|
|
5
|
+
const HIT = 22; // The radius that takes a touch round a point, about 44px across.
|
|
6
|
+
|
|
7
|
+
// pointShape draws a point round 0, 0: a disc for the point and a smaller square for the second, so the disc shows
|
|
8
|
+
// round a square on the same mark. A hit area round it takes the touch.
|
|
9
|
+
export function pointShape(who, r) {
|
|
10
|
+
const shape = who === 'second'
|
|
11
|
+
? el('rect', { class: 'line-dot', x: -r * 0.72, y: -r * 0.72, width: r * 1.44, height: r * 1.44, rx: 2 })
|
|
12
|
+
: el('circle', { class: 'line-dot', r });
|
|
13
|
+
return [el('circle', { class: 'line-hit', r: HIT }), shape];
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
// flag draws a pole up from a point and a box with the point's number at its top. set writes the number and the
|
|
17
|
+
// pole's length, so two flags over one place stand one above the other.
|
|
18
|
+
export function flag(who) {
|
|
19
|
+
const pole = el('line', { class: 'line-pole', x1: 0, x2: 0 }), box = el('rect', { class: 'line-flag-box', height: 24, rx: who === 'second' ? 3 : 12 });
|
|
20
|
+
const text = el('text', { class: 'line-flag-text' });
|
|
21
|
+
const g = el('g', { class: `line-flag line-c-${who}`, 'data-ref': who }, [pole, box, text]);
|
|
22
|
+
return {
|
|
23
|
+
el: g, width: words => 16 + 8.4 * words.length,
|
|
24
|
+
set(words, from, length) {
|
|
25
|
+
const w = 16 + 8.4 * words.length, top = from - length;
|
|
26
|
+
if (text.textContent !== words) text.textContent = words;
|
|
27
|
+
pole.setAttribute('y1', from); pole.setAttribute('y2', top);
|
|
28
|
+
box.setAttribute('x', -w / 2); box.setAttribute('width', w); box.setAttribute('y', top - 24);
|
|
29
|
+
text.setAttribute('x', 0); text.setAttribute('y', top - 12);
|
|
30
|
+
},
|
|
31
|
+
};
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
// arc draws a jump from x1 to x2 at height y, rising h above it, or dipping h below it with down, with a head at
|
|
35
|
+
// its end that shows the way it went.
|
|
36
|
+
export function arc(x1, x2, y, h, down) {
|
|
37
|
+
const cy = down ? y + 2 * h : y - 2 * h, mx = (x1 + x2) / 2;
|
|
38
|
+
const a = Math.atan2(y - cy, x2 - mx), len = Math.max(4, Math.min(7, Math.abs(x2 - x1) * 0.3)), wide = len * 0.57;
|
|
39
|
+
const bx = x2 - len * Math.cos(a), by = y - len * Math.sin(a), nx = -Math.sin(a) * wide, ny = Math.cos(a) * wide;
|
|
40
|
+
return {
|
|
41
|
+
path: el('path', { class: 'line-arc', d: `M ${x1} ${y} Q ${mx} ${cy} ${x2} ${y}`, pathLength: 1 }),
|
|
42
|
+
head: el('path', { class: 'line-arc-head', d: `M ${x2} ${y} L ${bx + nx} ${by + ny} L ${bx - nx} ${by - ny} Z` }),
|
|
43
|
+
};
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
// frog draws the frog standing on 0, 0, size pixels tall.
|
|
47
|
+
export function frog(size) {
|
|
48
|
+
const k = size / 33, at = (x, y) => ({ cx: x * k, cy: y * k });
|
|
49
|
+
return el('g', { class: 'line-frog' }, [
|
|
50
|
+
el('circle', { class: 'line-hit', cy: -size / 2, r: Math.max(HIT, size / 2) }),
|
|
51
|
+
el('ellipse', { class: 'line-frog-leg', ...at(-11, -4), rx: 8 * k, ry: 4 * k }),
|
|
52
|
+
el('ellipse', { class: 'line-frog-leg', ...at(11, -4), rx: 8 * k, ry: 4 * k }),
|
|
53
|
+
el('ellipse', { class: 'line-frog-body', ...at(0, -14), rx: 14 * k, ry: 12 * k }),
|
|
54
|
+
...[-7, 7].flatMap(x => [el('circle', { class: 'line-frog-eye', ...at(x, -27), r: 5.5 * k }), el('circle', { class: 'line-frog-pupil', ...at(x, -27.5), r: 2.4 * k })]),
|
|
55
|
+
el('path', { class: 'line-frog-mouth', d: `M ${-6 * k} ${-12 * k} Q 0 ${-8 * k} ${6 * k} ${-12 * k}` }),
|
|
56
|
+
]);
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
// stone draws a stepping stone round x, y, w wide, with its number on it.
|
|
60
|
+
export function stone(x, y, w, words, size) {
|
|
61
|
+
return el('g', { class: 'line-stone' }, [
|
|
62
|
+
el('ellipse', { class: 'line-stone-body', cx: x, cy: y, rx: w / 2, ry: w * 0.3 }),
|
|
63
|
+
el('text', { class: 'line-stone-num', x, y, 'font-size': size }, [words]),
|
|
64
|
+
]);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
// pond draws the water under the stones from x1 to x2 and from y1 to y2, and the bank, which ends at bank.
|
|
68
|
+
export function pond(x1, x2, y1, y2, bank) {
|
|
69
|
+
return [
|
|
70
|
+
el('rect', { class: 'line-water', x: x1, y: y1, width: x2 - x1, height: y2 - y1, rx: 10 }),
|
|
71
|
+
el('path', { class: 'line-bank', d: `M 0 ${y1 - 6} L ${bank - 8} ${y1 - 6} Q ${bank + 6} ${(y1 + y2) / 2} ${bank - 8} ${y2 + 6} L 0 ${y2 + 6} Z` }),
|
|
72
|
+
];
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
// bracket draws the bracket over the line from the ten before the point to the ten after it, plain with no mark
|
|
76
|
+
// between its ends, as two halves that the text can point at one by one. set moves it from x1 to x2 at height y, or
|
|
77
|
+
// hides it with null.
|
|
78
|
+
export function bracket() {
|
|
79
|
+
const before = el('path', { class: 'line-bracket', 'data-ref': 'ten-before' }), after = el('path', { class: 'line-bracket', 'data-ref': 'ten-after' });
|
|
80
|
+
const g = el('g', {}, [before, after]);
|
|
81
|
+
return {
|
|
82
|
+
el: g,
|
|
83
|
+
set(x1, x2, y) {
|
|
84
|
+
g.setAttribute('display', x1 === null ? 'none' : 'inline');
|
|
85
|
+
if (x1 === null) return;
|
|
86
|
+
const m = (x1 + x2) / 2, top = y - 10;
|
|
87
|
+
before.setAttribute('d', `M ${x1} ${y} V ${top} H ${m}`);
|
|
88
|
+
after.setAttribute('d', `M ${x2} ${y} V ${top} H ${m}`);
|
|
89
|
+
},
|
|
90
|
+
};
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
export const BOX = { w: 40, h: 26 }; // An empty label box, and a label card a little larger.
|
|
94
|
+
export const CARD = { w: 46, h: 34 };
|
|
95
|
+
// blankBox draws an empty label box round x, y, narrower where the gaps are narrow.
|
|
96
|
+
export const blankBox = (x, y, w) => el('rect', { class: 'line-blank', x: x - w / 2, y: y - BOX.h / 2, width: w, height: BOX.h, rx: 5 });
|
|
97
|
+
// card draws a label card round 0, 0 with its number, and a hit area about 44px tall.
|
|
98
|
+
export const card = words => [
|
|
99
|
+
el('rect', { class: 'line-hit', x: -CARD.w / 2, y: -24, width: CARD.w, height: 48 }),
|
|
100
|
+
el('rect', { class: 'line-card-box', x: -CARD.w / 2, y: -CARD.h / 2, width: CARD.w, height: CARD.h, rx: 6 }),
|
|
101
|
+
el('text', { class: 'line-card-num' }, [words]),
|
|
102
|
+
];
|
|
103
|
+
|
|
104
|
+
// house draws a house standing on x, y, w wide and h tall, with a door. A house with a number carries it on a
|
|
105
|
+
// plaque over its door, which plaque draws at size font.
|
|
106
|
+
export function house(x, y, w, h) {
|
|
107
|
+
const roof = h * 0.4, d = Math.max(2, w * 0.28);
|
|
108
|
+
return el('g', { class: 'line-house' }, [
|
|
109
|
+
el('path', { class: 'line-house-body', d: `M ${x - w / 2} ${y} V ${y - h + roof} L ${x} ${y - h} L ${x + w / 2} ${y - h + roof} V ${y} Z` }),
|
|
110
|
+
el('rect', { class: 'line-door', x: x - d / 2, y: y - Math.min(h * 0.45, h - roof), width: d, height: Math.min(h * 0.45, h - roof) }),
|
|
111
|
+
]);
|
|
112
|
+
}
|
|
113
|
+
export function plaque(x, y, words, font) {
|
|
114
|
+
const w = 8 + 0.62 * font * words.length;
|
|
115
|
+
return el('g', { class: 'line-plaque' }, [el('rect', { x: x - w / 2, y: y - font * 0.75, width: w, height: font * 1.5, rx: 3 }), el('text', { x, y, 'font-size': font }, [words])]);
|
|
116
|
+
}
|
|
117
|
+
// van draws a small van on the road in front of the houses, round 0, dy, with a marker that points at its house, the
|
|
118
|
+
// number of its house on its side and a hit area about 44px across. say writes the number, or takes it away with null.
|
|
119
|
+
export function van(dy) {
|
|
120
|
+
const words = el('text', { class: 'line-van-num', x: -2, y: dy });
|
|
121
|
+
const g = [
|
|
122
|
+
el('rect', { class: 'line-hit', x: -22, y: dy - 22, width: 44, height: 44 }),
|
|
123
|
+
el('path', { class: 'line-van-tip', d: `M -4 ${dy - 8} L 0 ${dy - 13} L 4 ${dy - 8} Z` }),
|
|
124
|
+
el('path', { class: 'line-dot', d: `M -13 ${dy + 6} V ${dy - 7} H 6 L 13 ${dy - 1} V ${dy + 6} Z` }),
|
|
125
|
+
el('circle', { class: 'line-wheel', cx: -8, cy: dy + 7, r: 2.6 }), el('circle', { class: 'line-wheel', cx: 8, cy: dy + 7, r: 2.6 }),
|
|
126
|
+
words,
|
|
127
|
+
];
|
|
128
|
+
return { nodes: g, say(n) { words.textContent = n ?? ''; } };
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// book draws the edge of a closed book from x1 to x2 at height y: the edge of its pages between its two covers,
|
|
132
|
+
// with no mark along it.
|
|
133
|
+
export const book = (x1, x2, y) => [
|
|
134
|
+
el('rect', { class: 'line-book-pages', x: x1, y: y - 9, width: x2 - x1, height: 18 }),
|
|
135
|
+
el('line', { class: 'line-book-leaf', x1, x2, y1: y - 3, y2: y - 3 }), el('line', { class: 'line-book-leaf', x1, x2, y1: y + 3, y2: y + 3 }),
|
|
136
|
+
el('rect', { class: 'line-book-cover', x: x1 - 7, y: y - 12, width: 7, height: 24, rx: 2 }),
|
|
137
|
+
el('rect', { class: 'line-book-cover', x: x2, y: y - 12, width: 7, height: 24, rx: 2 }),
|
|
138
|
+
];
|
|
139
|
+
// bookmark draws a ribbon that stands top pixels above the edge round 0, 0, with a hit area about 44px across.
|
|
140
|
+
export const bookmark = top => [
|
|
141
|
+
el('rect', { class: 'line-hit', x: -22, y: -top - 6, width: 44, height: top + 20 }),
|
|
142
|
+
el('path', { class: 'line-dot', d: `M -6 8 V ${-top} L 0 ${-top + 6} L 6 ${-top} V 8 Z` }),
|
|
143
|
+
];
|
|
@@ -0,0 +1,168 @@
|
|
|
1
|
+
// The goals a challenge page of the line scene can name. The page declares ranges, and the goal draws a target from
|
|
2
|
+
// them each time the page opens and each time the reader asks for another one. Every goal answers Check the same way:
|
|
3
|
+
// the point is on the target, or to its left, or to its right, and its goal line and notes are those of place. The
|
|
4
|
+
// build and the browser both use this file.
|
|
5
|
+
import { gapsOf, numberAt, labelled } from './model.js';
|
|
6
|
+
import { PLUS, MINUS } from '../../kit/written.js';
|
|
7
|
+
|
|
8
|
+
const range = r => Array.isArray(r) && r.length === 2 && r.every(Number.isInteger) && r[0] <= r[1];
|
|
9
|
+
const span = (lo, hi) => Array.from({ length: Math.max(0, hi - lo + 1) }, (_, i) => lo + i);
|
|
10
|
+
// judge compares the number at the point with the target once the reader has pressed Check.
|
|
11
|
+
const judge = (state, target) => !state.checked ? { done: false } : state.point === target ? { done: true } : { done: false, note: state.point < target ? 'left' : 'right' };
|
|
12
|
+
// The line of place-unmarked is at least UNMARKED_APART long, and its length is one of UNMARKED_LENGTHS, so its
|
|
13
|
+
// middle is a ten.
|
|
14
|
+
export const UNMARKED_APART = 40, UNMARKED_LENGTHS = [20, 40, 60, 80, 100];
|
|
15
|
+
const lengths = () => UNMARKED_LENGTHS.filter(n => n >= UNMARKED_APART);
|
|
16
|
+
export const TWO_GAPS = 10, TWO_TOP = 100, TWO_STEPS = [2, 5, 10], TWO_APART = 3; // The line of place-two-labels.
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
// The words of a goal's hint and of its notes, as a string key and the numbers in it. The place goals share their
|
|
20
|
+
// notes: the side the point is on, and the number to move it to.
|
|
21
|
+
const sideNote = (t, note) => ({ key: `note-place-${note}`, vars: { target: t.target } });
|
|
22
|
+
|
|
23
|
+
export const GOALS = {
|
|
24
|
+
// The reader puts the point on a number of a marked line that carries no label, and presses Check. The target is
|
|
25
|
+
// a mark of the line in the page's range, with no label and away from the point's start.
|
|
26
|
+
place: {
|
|
27
|
+
fields: ['target'],
|
|
28
|
+
problem(c, spec) {
|
|
29
|
+
if (!range(c.target)) return `target is ${JSON.stringify(c.target ?? null)}, write the range of numbers to place as [low, high], such as [11, 99]`;
|
|
30
|
+
if (c.target[0] < spec.from || c.target[1] > spec.to) return `target is [${c.target}], write a range inside the line from ${spec.from} to ${spec.to}`;
|
|
31
|
+
return null;
|
|
32
|
+
},
|
|
33
|
+
targets(c, spec) {
|
|
34
|
+
const start = spec.point ?? spec.from;
|
|
35
|
+
return span(0, gapsOf(spec)).map(k => numberAt(spec, k)).filter(n => n >= c.target[0] && n <= c.target[1] && !labelled(spec, n) && n !== start);
|
|
36
|
+
},
|
|
37
|
+
draw(c, spec, dice) { const all = GOALS.place.targets(c, spec); return all.length ? { target: dice.pick(all) } : null; },
|
|
38
|
+
holds: (state, spec, c, t) => judge(state, t.target),
|
|
39
|
+
// Every mark of a marked line is in reach of the drag and of the jumps.
|
|
40
|
+
reach: () => null,
|
|
41
|
+
// The hint names the long marks either side of the number and counts from the nearer one.
|
|
42
|
+
hint(t, spec) {
|
|
43
|
+
const marks = span(0, gapsOf(spec)).map(k => numberAt(spec, k)).filter(n => labelled(spec, n));
|
|
44
|
+
const before = Math.max(...marks.filter(n => n < t.target)), after = Math.min(...marks.filter(n => n > t.target));
|
|
45
|
+
return { key: t.target - before <= after - t.target ? 'hint-place-on' : 'hint-place-back', vars: { target: t.target, before, after } };
|
|
46
|
+
},
|
|
47
|
+
note: sideNote,
|
|
48
|
+
},
|
|
49
|
+
// The goal draws the line: a step, a left end that is a multiple of it, and 10 gaps that end at 100 or below. Two
|
|
50
|
+
// marks next to each other carry labels, and the point starts on one of them. The target is a mark at least three
|
|
51
|
+
// steps from both, so the reader reads the step and counts jumps. Once the goal holds every mark shows its label.
|
|
52
|
+
'place-two-labels': {
|
|
53
|
+
fields: ['step', 'from'],
|
|
54
|
+
draws: true,
|
|
55
|
+
problem(c) {
|
|
56
|
+
if (!Array.isArray(c.step) || !c.step.length || !c.step.every(v => TWO_STEPS.includes(v))) return `step is ${JSON.stringify(c.step ?? null)}, write a list of steps from ${TWO_STEPS.join(', ')}, such as [2, 5, 10]`;
|
|
57
|
+
if (!range(c.from) || c.from[0] < 0) return `from is ${JSON.stringify(c.from ?? null)}, write the range of the left end as [low, high] from 0, such as [0, 50]`;
|
|
58
|
+
return null;
|
|
59
|
+
},
|
|
60
|
+
// lines gives every line the page's ranges allow: each step with each left end that is a multiple of it.
|
|
61
|
+
noLine: c => `step [${c.step}] and from [${c.from}] give no line of 10 gaps that ends at 100 or below`,
|
|
62
|
+
lines: c => c.step.flatMap(step => span(c.from[0], c.from[1]).filter(from => from % step === 0 && from + TWO_GAPS * step <= TWO_TOP).map(from => ({ step, from }))),
|
|
63
|
+
draw(c, spec, dice) {
|
|
64
|
+
// The step comes first, each step that has a line as likely as the others, and then a left end of that step, so
|
|
65
|
+
// the steps with many left ends do not crowd out the others.
|
|
66
|
+
const lines = GOALS['place-two-labels'].lines(c), steps = [...new Set(lines.map(l => l.step))];
|
|
67
|
+
if (!lines.length) return null;
|
|
68
|
+
const pickStep = dice.pick(steps), { step, from } = dice.pick(lines.filter(l => l.step === pickStep)), k = dice.int(0, TWO_GAPS - 1), at = k2 => from + k2 * step;
|
|
69
|
+
const marks = span(0, TWO_GAPS).filter(j => Math.abs(j - k) >= TWO_APART && Math.abs(j - k - 1) >= TWO_APART);
|
|
70
|
+
return { step, from, to: at(TWO_GAPS), labels: [at(k), at(k + 1)], start: at(dice.pick([k, k + 1])), target: at(dice.pick(marks)) };
|
|
71
|
+
},
|
|
72
|
+
// The page's line as the goal drew it. Its ends are marks like the others, and reveal shows every label once the
|
|
73
|
+
// goal holds.
|
|
74
|
+
page: t => ({ from: t.from, to: t.to, step: t.step, labels: t.labels, point: t.start, reveal: true }),
|
|
75
|
+
holds: (state, spec, c, t) => judge(state, t.target),
|
|
76
|
+
// The hint reads the step from the two labels and counts on from the right one, or back from the left one.
|
|
77
|
+
hint: t => ({ key: t.target > t.labels[1] ? 'hint-place-two-labels-on' : 'hint-place-two-labels-back', vars: { a: t.labels[0], b: t.labels[1], target: t.target } }),
|
|
78
|
+
note: sideNote,
|
|
79
|
+
reach: (spec, c, t) => t.target < t.from || t.target > t.to || (t.target - t.from) % t.step ? `the target ${t.target} is no mark of the line from ${t.from} to ${t.to} in steps of ${t.step}` : null,
|
|
80
|
+
},
|
|
81
|
+
// The goal draws an unmarked line between two tens whose length is one of UNMARKED_LENGTHS, and a whole number more
|
|
82
|
+
// than a tenth of the line from each end and from its middle, so neither the start nor the Middle button holds the
|
|
83
|
+
// goal. The point starts at the left end and moves freely. Check holds within a tenth of the line either side of
|
|
84
|
+
// the number. Once the goal holds, a flag shows where the number is.
|
|
85
|
+
'place-unmarked': {
|
|
86
|
+
fields: ['from', 'to'],
|
|
87
|
+
draws: true,
|
|
88
|
+
takes: ['middle'],
|
|
89
|
+
flags: true,
|
|
90
|
+
problem(c) {
|
|
91
|
+
for (const f of ['from', 'to']) if (!range(c[f]) || c[f][0] < 0 || c[f][1] > 100) return `${f} is ${JSON.stringify(c[f] ?? null)}, write the range of the ${f === 'from' ? 'left' : 'right'} end as [low, high] from 0 to 100, such as ${f === 'from' ? '[0, 30]' : '[40, 100]'}`;
|
|
92
|
+
return null;
|
|
93
|
+
},
|
|
94
|
+
noLine: c => `from [${c.from}] and to [${c.to}] give no two tens ${lengths().slice(0, -1).join(', ')} or ${lengths().at(-1)} apart`,
|
|
95
|
+
lines: c => span(c.from[0], c.from[1]).filter(a => a % 10 === 0).flatMap(a => span(c.to[0], c.to[1]).filter(b => b % 10 === 0 && lengths().includes(b - a)).map(b => ({ from: a, to: b }))),
|
|
96
|
+
// targets gives the whole numbers of a line more than a tenth of it from its ends and its middle.
|
|
97
|
+
targets: (from, to) => { const far = (to - from) / 10, mid = (from + to) / 2; return span(from, to).filter(n => n - from > far && to - n > far && Math.abs(n - mid) > far); },
|
|
98
|
+
draw(c, spec, dice) {
|
|
99
|
+
// The length comes first, each length that has a line as likely as the others, and then a line of that length.
|
|
100
|
+
const lines = GOALS['place-unmarked'].lines(c), lens = [...new Set(lines.map(l => l.to - l.from))];
|
|
101
|
+
if (!lines.length) return null;
|
|
102
|
+
const len = dice.pick(lens), { from, to } = dice.pick(lines.filter(l => l.to - l.from === len));
|
|
103
|
+
return { from, to, start: from, target: dice.pick(GOALS['place-unmarked'].targets(from, to)) };
|
|
104
|
+
},
|
|
105
|
+
page: t => ({ from: t.from, to: t.to, step: 1, marks: 'ends', labels: 'ends', point: t.start }),
|
|
106
|
+
holds(state, spec, c, t) {
|
|
107
|
+
if (!state.checked) return { done: false };
|
|
108
|
+
const off = state.point - t.target;
|
|
109
|
+
return Math.abs(off) <= (t.to - t.from) / 10 ? { done: true } : { done: false, note: off < 0 ? 'left' : 'right' };
|
|
110
|
+
},
|
|
111
|
+
reach: (spec, c, t) => t.target < t.from || t.target > t.to ? `the target ${t.target} is off the line from ${t.from} to ${t.to}` : null,
|
|
112
|
+
// The hint marks the middle, names the half the number lies in, and the guide it lies closer to.
|
|
113
|
+
hint(t) {
|
|
114
|
+
const mid = (t.from + t.to) / 2, end = t.target > mid ? t.to : t.from;
|
|
115
|
+
return { key: 'hint-place-unmarked', vars: { mid, target: t.target, lo: Math.min(mid, end), hi: Math.max(mid, end), near: Math.abs(t.target - mid) <= Math.abs(t.target - end) ? mid : end } };
|
|
116
|
+
},
|
|
117
|
+
note: sideNote,
|
|
118
|
+
},
|
|
119
|
+
// The goal draws a start and a number to add or to subtract, each sign as likely as the other where both draw, with
|
|
120
|
+
// the answer on the line. The point opens on the start, whose ring stays put, and the reader jumps it to the answer
|
|
121
|
+
// and presses Check. A wrong Check says the point went the wrong way, or made too few or too many jumps. Once the
|
|
122
|
+
// goal holds, the written line shows.
|
|
123
|
+
'jump-to': {
|
|
124
|
+
fields: ['start', 'add', 'subtract'],
|
|
125
|
+
labels: true,
|
|
126
|
+
problem(c, spec) {
|
|
127
|
+
if (!range(c.start) || c.start[0] < spec.from || c.start[1] > spec.to) return `start is ${JSON.stringify(c.start ?? null)}, write the range of the start as [low, high] inside the line from ${spec.from} to ${spec.to}, such as [2, 18]`;
|
|
128
|
+
for (const f of ['add', 'subtract']) if (c[f] !== undefined && (!range(c[f]) || c[f][0] < 1)) return `${f} is ${JSON.stringify(c[f])}, write the numbers to ${f} as [low, high] from 1, such as [2, 4]`;
|
|
129
|
+
if (c.add === undefined && c.subtract === undefined) return 'add and subtract are missing, write the numbers to add, to subtract, or both, such as add: [2, 4]';
|
|
130
|
+
return null;
|
|
131
|
+
},
|
|
132
|
+
// sums gives every start and number of one sign whose answer is a mark of the line.
|
|
133
|
+
sums(c, spec, sign) {
|
|
134
|
+
const r = sign === PLUS ? c.add : c.subtract;
|
|
135
|
+
if (!r) return [];
|
|
136
|
+
return span(c.start[0], c.start[1]).filter(n => (n - spec.from) % spec.step === 0).flatMap(start => span(r[0], r[1]).map(n => ({ start, sign, n, target: sign === PLUS ? start + n * spec.step : start - n * spec.step })))
|
|
137
|
+
.filter(d => d.target >= spec.from && d.target <= spec.to);
|
|
138
|
+
},
|
|
139
|
+
draw(c, spec, dice) {
|
|
140
|
+
const signs = [PLUS, MINUS].filter(sign => GOALS['jump-to'].sums(c, spec, sign).length);
|
|
141
|
+
return signs.length ? dice.pick(GOALS['jump-to'].sums(c, spec, dice.pick(signs))) : null;
|
|
142
|
+
},
|
|
143
|
+
page: t => ({ start: t.start, point: t.start }),
|
|
144
|
+
holds(state, spec, c, t) {
|
|
145
|
+
if (!state.checked) return { done: false };
|
|
146
|
+
if (state.point === t.target) return { done: true };
|
|
147
|
+
const way = Math.sign(t.target - t.start), went = Math.sign(state.point - t.start);
|
|
148
|
+
return { done: false, note: went === -way ? 'way' : Math.abs(state.point - t.start) < Math.abs(t.target - t.start) ? 'few' : 'many' };
|
|
149
|
+
},
|
|
150
|
+
reach: () => null,
|
|
151
|
+
// The hint says the start, the button and the numbers said at the first jumps. The calculation is written as the
|
|
152
|
+
// kit writes it, so the scene passes calc in.
|
|
153
|
+
hint(t) {
|
|
154
|
+
const dir = t.sign === PLUS ? 1 : -1, sign = t.sign === PLUS ? 'plus' : 'minus';
|
|
155
|
+
return { key: t.n === 1 ? `hint-jump-${sign}-one` : `hint-jump-${sign}`, vars: { start: t.start, n: t.n, next: t.start + dir, then: t.start + 2 * dir } };
|
|
156
|
+
},
|
|
157
|
+
// A note says which way the calculation goes, or how many jumps the point made against the number it needs.
|
|
158
|
+
note(t, note, state) {
|
|
159
|
+
const done = Math.abs(state.point - t.start);
|
|
160
|
+
if (note === 'way') return { key: `note-jump-way-${t.sign === PLUS ? 'plus' : 'minus'}`, vars: { start: t.start } };
|
|
161
|
+
if (note === 'few') return { key: done ? 'note-jump-few' : 'note-jump-few-none', vars: { start: t.start, done, n: t.n } };
|
|
162
|
+
return { key: 'note-jump-many', vars: { done, n: t.n } };
|
|
163
|
+
},
|
|
164
|
+
},
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
// The reader's state as a challenge opens: the point on its start and nothing checked.
|
|
168
|
+
export const challengeStart = (spec, t) => ({ checked: false, point: t?.start ?? spec.point ?? spec.from });
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
line_lead: "Move the point along the line and read the number at its mark."
|
|
2
|
+
line_jump-left: Jump left
|
|
3
|
+
line_jump-right: Jump right
|
|
4
|
+
line_point: Number at the point
|
|
5
|
+
line_point-short: Point
|
|
6
|
+
line_second: Number at the second point
|
|
7
|
+
line_second-short: Second point
|
|
8
|
+
line_jumps: Jumps
|
|
9
|
+
line_step: Step
|
|
10
|
+
line_from: Left end
|
|
11
|
+
line_to: Right end
|
|
12
|
+
line_point-name: Point
|
|
13
|
+
line_second-name: Second point
|
|
14
|
+
line_reading-later: "{a} is greater than {b}"
|
|
15
|
+
line_reading-both: "Both points are on {a}"
|
|
16
|
+
line_goal-place: "Put the point on {target}, then press Check."
|
|
17
|
+
line_goal-place-done: "The point is on {target}."
|
|
18
|
+
line_note-place-left: "The point is to the left of {target}. Move it to the right."
|
|
19
|
+
line_note-place-right: "The point is to the right of {target}. Move it to the left."
|
|
20
|
+
line_ten-before: Ten before
|
|
21
|
+
line_ten-after: Ten after
|
|
22
|
+
line_placed: Cards placed
|
|
23
|
+
line_placed-short: Placed
|
|
24
|
+
line_placed-of: "{n} of {all}"
|
|
25
|
+
line_open-gap: "Gap from {a} to {b}"
|
|
26
|
+
line_card: "Card {x}"
|
|
27
|
+
line_find: Number to find
|
|
28
|
+
line_show: Show
|
|
29
|
+
line_next: Next number
|
|
30
|
+
line_middle: Middle
|
|
31
|
+
line_van: Van
|
|
32
|
+
line_estimate: Estimate
|
|
33
|
+
line_open-book: Open the book
|
|
34
|
+
line_bookmark: Bookmark
|
|
35
|
+
line_hint-place-unmarked: "Press Middle to mark {mid}. {target} is between {lo} and {hi}, and closer to {near}. Put the point there."
|
|
36
|
+
line_goal-place-unmarked-done: "The point is close to {target}."
|
|
37
|
+
line_between: "between {a} and {b}"
|
|
38
|
+
line_gaps-unequal: Some gaps are longer than others.
|
|
39
|
+
line_gaps-equal: "All the gaps are the same length."
|
|
40
|
+
line_mark-name: "Mark {x}"
|
|
41
|
+
line_mark-left: The gap on its left is longer
|
|
42
|
+
line_mark-right: The gap on its right is longer
|
|
43
|
+
line_mark-even: "The gaps on both sides of it are equal"
|
|
44
|
+
line_start: Start
|
|
45
|
+
line_goal-jump: "Jump from {start} to find {calc}, then press Check."
|
|
46
|
+
line_note-jump-few: "The point has made {done} of the {n} jumps that {calc} needs. Keep jumping."
|
|
47
|
+
line_note-jump-many: "The point has made {done} jumps, but {calc} needs only {n}. Jump back."
|
|
48
|
+
line_new-line: New line
|
|
49
|
+
line_goal-place-unmarked: "Put the point close to {target}, then press Check."
|
|
50
|
+
line_find-short: Find
|
|
51
|
+
line_hint-place-on: "{target} is between the long marks for {before} and {after}. Start at {before} and count on one mark at a time until you get to {target}."
|
|
52
|
+
line_hint-place-back: "{target} is between the long marks for {before} and {after}. Start at {after} and count back one mark at a time until you get to {target}."
|
|
53
|
+
line_hint-place-two-labels-on: "The labels {a} and {b} are on marks next to each other, so the step from one mark to the next is {b} − {a}. Count on from {b} in steps of that size until you get to {target}."
|
|
54
|
+
line_hint-place-two-labels-back: "The labels {a} and {b} are on marks next to each other, so the step from one mark to the next is {b} − {a}. Count back from {a} in steps of that size until you get to {target}."
|
|
55
|
+
line_hint-jump-plus: "Start at {start} and press Jump right {n} times. At each jump, say the next number. The first two are {next} and {then}."
|
|
56
|
+
line_hint-jump-minus: "Start at {start} and press Jump left {n} times. At each jump, say the number before. The first two are {next} and {then}."
|
|
57
|
+
line_hint-jump-plus-one: "Start at {start}. Press Jump right once and say the next number, {next}."
|
|
58
|
+
line_hint-jump-minus-one: "Start at {start}. Press Jump left once and say the number before, {next}."
|
|
59
|
+
line_note-jump-way-plus: "{calc} is an addition, so the jumps go to the right from {start}."
|
|
60
|
+
line_note-jump-way-minus: "{calc} is a subtraction, so the jumps go to the left from {start}."
|
|
61
|
+
line_note-jump-few-none: "The point is still on {start}. Make the jumps for {calc} from there."
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
line_lead: "Noktayı doğru boyunca hareket ettirin ve çizgisindeki sayıyı okuyun."
|
|
2
|
+
line_jump-left: Sola zıpla
|
|
3
|
+
line_jump-right: Sağa zıpla
|
|
4
|
+
line_point: Noktadaki sayı
|
|
5
|
+
line_point-short: Nokta
|
|
6
|
+
line_second: İkinci noktadaki sayı
|
|
7
|
+
line_second-short: İkinci nokta
|
|
8
|
+
line_jumps: Zıplamalar
|
|
9
|
+
line_step: Adım
|
|
10
|
+
line_from: Sol uç
|
|
11
|
+
line_to: Sağ uç
|
|
12
|
+
line_point-name: Nokta
|
|
13
|
+
line_second-name: İkinci nokta
|
|
14
|
+
line_reading-later: "{a}, {b} sayısından büyüktür"
|
|
15
|
+
line_reading-both: "İki nokta da {a} üzerinde"
|
|
16
|
+
line_goal-place: "Noktayı {target} üzerine koyun, sonra Kontrol et düğmesine basın."
|
|
17
|
+
line_goal-place-done: "Nokta {target} üzerinde."
|
|
18
|
+
line_note-place-left: Nokta sayının solunda.
|
|
19
|
+
line_note-place-right: Nokta sayının sağında.
|
|
20
|
+
line_ten-before: Önceki onluk
|
|
21
|
+
line_ten-after: Sonraki onluk
|
|
22
|
+
line_placed: Yerleşen kartlar
|
|
23
|
+
line_placed-short: Yerleşen
|
|
24
|
+
line_placed-of: "{n} / {all}"
|
|
25
|
+
line_open-gap: "{a} ile {b} arasındaki aralık"
|
|
26
|
+
line_card: "Kart {x}"
|
|
27
|
+
line_find: Bul
|
|
28
|
+
line_show: Göster
|
|
29
|
+
line_next: Sonraki
|
|
30
|
+
line_middle: Orta
|
|
31
|
+
line_van: Kamyonet
|
|
32
|
+
line_estimate: Tahmin
|
|
33
|
+
line_open-book: Kitabı aç
|
|
34
|
+
line_bookmark: Ayraç
|
|
35
|
+
line_hint-place-unmarked: "Orta düğmesine basın. Sayı ortadan önce mi sonra mı? Sonra ortaya ve yakın uca ne kadar uzak olduğunu kestirin."
|
|
36
|
+
line_goal-place-unmarked-done: "Nokta {target} sayısına yakın."
|
|
37
|
+
line_between: "{a} ile {b} arasında"
|
|
38
|
+
line_gaps-unequal: Bazı aralıklar ötekilerden uzun.
|
|
39
|
+
line_gaps-equal: Bütün aralıklar eşit.
|
|
40
|
+
line_mark-name: "Çizgi {x}"
|
|
41
|
+
line_mark-left: Solundaki aralık daha uzun
|
|
42
|
+
line_mark-right: Sağındaki aralık daha uzun
|
|
43
|
+
line_mark-even: İki aralığı eşit
|
|
44
|
+
line_start: Başlangıç
|
|
45
|
+
line_goal-jump: "{start} sayısından zıplayarak {calc} işlemini bulun, sonra Kontrol et düğmesine basın."
|
|
46
|
+
line_note-jump-few: Zıplamalar az.
|
|
47
|
+
line_note-jump-many: Zıplamalar çok.
|
|
48
|
+
line_new-line: Yeni doğru
|
|
49
|
+
line_goal-place-unmarked: "Noktayı {target} sayısına yakın koyun, sonra Kontrol et düğmesine basın."
|
|
50
|
+
line_find-short: Bul
|
|
51
|
+
line_hint-place-on: "Sayının arasında durduğu iki uzun çizgiyi bulun. Soldakinden ileri ya da sağdakinden geri zıplayarak sayın."
|
|
52
|
+
line_hint-place-back: "Sayının arasında durduğu iki uzun çizgiyi bulun. Soldakinden ileri ya da sağdakinden geri zıplayarak sayın."
|
|
53
|
+
line_hint-place-two-labels-on: "Yan yana iki etiket adımı verir. Bir etiketten sayıya kadar zıplamaları sayın."
|
|
54
|
+
line_hint-place-two-labels-back: "Yan yana iki etiket adımı verir. Bir etiketten sayıya kadar zıplamaları sayın."
|
|
55
|
+
line_hint-jump-plus: "Başlangıçtaki sayıyı söyleyin, sonra her zıplamada bir sayı sayın. + için sağa, − için sola zıplayın."
|
|
56
|
+
line_hint-jump-minus: "Başlangıçtaki sayıyı söyleyin, sonra her zıplamada bir sayı sayın. + için sağa, − için sola zıplayın."
|
|
57
|
+
line_hint-jump-plus-one: "Başlangıçtaki sayıyı söyleyin, sonra her zıplamada bir sayı sayın. + için sağa, − için sola zıplayın."
|
|
58
|
+
line_hint-jump-minus-one: "Başlangıçtaki sayıyı söyleyin, sonra her zıplamada bir sayı sayın. + için sağa, − için sola zıplayın."
|
|
59
|
+
line_note-jump-way-plus: Nokta yanlış yöne zıpladı.
|
|
60
|
+
line_note-jump-way-minus: Nokta yanlış yöne zıpladı.
|
|
61
|
+
line_note-jump-few-none: Zıplamalar az.
|