Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-04 22:58:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Started porting Phantasmal World to Kotlin.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-10-10 23:48:38 +02:00
parent bbfc4403ff
commit 36a32018ca
2715 changed files with 5247 additions and 73485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.env.dev
View File

@ -1,2 +0,0 @@
LOG_LEVEL=Debug
PUBLIC_URL=/assets

2
.env.prod
View File

@ -1,2 +0,0 @@
LOG_LEVEL=Info
PUBLIC_URL=/assets

2
.env.test
View File

@ -1,2 +0,0 @@
LOG_LEVEL=Warning
RUN_ALL_TESTS=false

38
.eslintrc.json
View File

@ -1,38 +0,0 @@
{
"extends": [
"eslint:recommended",
"plugin:@typescript-eslint/recommended",
"prettier",
"prettier/@typescript-eslint",
"plugin:prettier/recommended"
],
"plugins": ["@typescript-eslint", "prettier"],
"root": true,
"env": {
"browser": true,
"es6": true,
"jest": true,
"node": true
},
"ignorePatterns": ["webpack.*.js"],
"rules": {
"@typescript-eslint/array-type": ["warn", { "default": "array", "readonly": "array" }],
"@typescript-eslint/ban-ts-ignore": "off",
"@typescript-eslint/camelcase": "off",
"@typescript-eslint/explicit-function-return-type": ["warn", { "allowExpressions": true }],
"@typescript-eslint/explicit-member-accessibility": "off",
"@typescript-eslint/no-explicit-any": "off",
"@typescript-eslint/no-inferrable-types": "off",
"@typescript-eslint/no-non-null-assertion": "off",
"@typescript-eslint/no-parameter-properties": "off",
"@typescript-eslint/no-use-before-define": "off",
"@typescript-eslint/prefer-interface": "off",
"no-console": "warn",
"no-constant-condition": ["warn", { "checkLoops": false }],
"no-empty": "warn",
"no-useless-escape": "warn",
"prefer-const": "warn",
"prettier/prettier": "warn"
},
"parser": "@typescript-eslint/parser"
}

45
.github/workflows/deploy.yml vendored
View File

@ -1,45 +0,0 @@
name: Deploy
on:
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
with:
persist-credentials: false
- name: Yarn cache
uses: actions/cache@v2
env:
cache-name: yarn-cache
with:
path: .yarn/cache
key: ${{ runner.os }}-deploy-${{ env.cache-name }}
- name: Install dependencies
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: install
- name: Test
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: test
- name: Build
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: build
- name: Deploy
uses: JamesIves/github-pages-deploy-action@3.6.2
with:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
BRANCH: gh-pages
FOLDER: dist
CLEAN: true

43
.github/workflows/tests.yml vendored
View File

@ -1,43 +0,0 @@
name: Tests
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Yarn cache
uses: actions/cache@v2
env:
cache-name: yarn-cache
with:
path: .yarn/cache
key: ${{ runner.os }}-tests-${{ env.cache-name }}
- name: Install dependencies
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: install
- name: Lint
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: lint
- name: Check formatting
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: check_formatting
- name: Test
uses: CultureHQ/actions-yarn@v1.0.1
with:
args: test

43
.gitignore vendored
View File

@ -1,42 +1,11 @@
# editors
# Editors
.idea
.vscode
# dependencies
/node_modules
.yarn/*
!.yarn/releases
!.yarn/plugins
!.yarn/sdks
!.yarn/versions
.pnp.*
# Gradle
.gradle
build
# testing
/coverage
# production
/build
/dist
/deployment
# misc
# Misc.
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local
# log files
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# node error reports
report.*.json
# binary files
*.wasm
# rust output
target/
# wasm-pack output
pkg/*
!pkg/package.json
*.log

8
.prettierrc.json
View File

@ -1,8 +0,0 @@
{
"endOfLine": "auto",
"printWidth": 100,
"tabWidth": 4,
"singleQuote": false,
"trailingComma": "all",
"arrowParens": "avoid"
}

55
.yarn/releases/yarn-berry.cjs vendored
View File

File diff suppressed because one or more lines are too long

1
.yarnrc.yml
View File

@ -1 +0,0 @@
yarnPath: ".yarn/releases/yarn-berry.cjs"

2
README.md
View File

@ -4,6 +4,8 @@
## Developers
TODO: This entire section is out of date since porting PW to Kotlin.
<a href="https://github.com/DaanVandenBosch/phantasmal-world/actions?query=workflow%3ATests">
<img alt="Tests status" src="https://github.com/DaanVandenBosch/phantasmal-world/workflows/Tests/badge.svg">
</a>

14
assets_generation/index.ts
View File

@ -1,14 +0,0 @@
/**
* Used by static asset generation scripts.
*/
export const RESOURCE_DIR = "./assets_generation/resources";
/**
* Static assets directory used by runtime code.
*/
export const ASSETS_DIR = "./assets";
/**
* Source directory of runtime code.
*/
export const SRC_DIR = "./src";

388
assets_generation/quest_stats.ts
View File

@ -1,388 +0,0 @@
import { walk_quests } from "./walk_quests";
import { RESOURCE_DIR } from "./index";
import { NpcType } from "../src/core/data_formats/parsing/quest/npc_types";
import { QuestNpc } from "../src/core/data_formats/parsing/quest/QuestNpc";
import { EntityProp, EntityPropType } from "../src/core/data_formats/parsing/quest/properties";
import {
entity_data,
EntityType,
get_entity_prop_value,
get_entity_type,
is_npc_type,
Quest,
QuestEntity,
} from "../src/core/data_formats/parsing/quest/Quest";
import { ObjectType } from "../src/core/data_formats/parsing/quest/object_types";
import { QuestObject } from "../src/core/data_formats/parsing/quest/QuestObject";
const prop_cache = new Map<EntityType, EntityProp[]>();
print_quest_entity_stats({ npcs: true, objects: true, print: "stats" });
function print_quest_entity_stats(config: {
npcs?: boolean;
objects?: boolean;
print?: "stats" | "code";
}): void {
const npcs_by_type: Map<
NpcType,
{ entity: QuestNpc; quest: string; count: number }[]
> = new Map();
const objects_by_type: Map<
ObjectType,
{ entity: QuestObject; quest: string; count: number }[]
> = new Map();
walk_quests(
{
path: `${RESOURCE_DIR}/tethealla_v0.143_quests`,
exclude: ["/battle", "/chl/ep1", "/chl/ep4", "/shop"],
},
({ quest }) => {
if (config.npcs) {
process_entities(quest, quest.npcs, npcs_by_type);
}
if (config.objects) {
process_entities(quest, quest.objects, objects_by_type);
}
},
);
if (config.npcs) {
if (config.print === "code") {
print_entity_code(npcs_by_type);
} else {
print_entity_property_stats(npcs_by_type);
}
}
if (config.objects) {
if (config.print === "code") {
print_entity_code(objects_by_type);
} else {
print_entity_property_stats(objects_by_type);
}
}
}
function print_entity_property_stats(
entities_by_type: Map<EntityType, { entity: QuestEntity; quest: string; count: number }[]>,
): void {
const sorted = [...entities_by_type.entries()].sort(([a_type], [b_type]) => a_type - b_type);
for (const [type, entities] of sorted) {
const props = get_properties(type);
/* eslint-disable no-console */
console.log(ObjectType[type] ?? NpcType[type]);
console.log(" cnt " + props.map(col_print_name).join(" "));
const sorted = entities.sort((a, b) => b.count - a.count).slice(0, 5);
for (const { entity, quest, count } of sorted) {
console.log(
` ${count.toString().padStart(3, " ")} ` +
props.map(p => col_print_value(entity, p)).join(" ") +
` ${quest}`,
);
}
/* eslint-enable no-console */
}
}
/**
* Used to populate the switch in set_npc_default_data or set_object_default_data.
* Prints code of the following form (view is assumed to be a DataView).
*
* ```ts
* case EntityType.$ENTITY_TYPE:
* view.set$PROP_TYPE($OFFSET, $VALUE, true); // $PROP_NAME
* break;
* ```
*/
function print_entity_code(
entities_by_type: Map<EntityType, { entity: QuestEntity; quest: string; count: number }[]>,
): void {
for (const [type, entities] of [...entities_by_type.entries()].sort(
([a_type], [b_type]) => a_type - b_type,
)) {
const is_npc = is_npc_type(type);
const { entity } = entities.sort((a, b) => b.count - a.count)[0];
const props = get_properties(type)
.map(prop => {
const value =
prop.type === EntityPropType.Angle
? entity.view.getInt32(prop.offset, true)
: get_entity_prop_value(entity, prop);
return [prop, value] as const;
})
.filter(([prop, value]) => {
if (!is_npc && prop.offset >= 40 && prop.offset < 52) {
return value !== 1;
} else {
return value !== 0;
}
});
if (props.length === 0) continue;
/* eslint-disable no-console */
if (is_npc) {
console.log(`case NpcType.${NpcType[type]}:`);
} else {
console.log(`case ObjectType.${ObjectType[type]}:`);
}
for (const [prop, value] of props) {
let prop_type: string;
switch (prop.type) {
case EntityPropType.U8:
prop_type = "Uint8";
break;
case EntityPropType.U16:
prop_type = "Uint16";
break;
case EntityPropType.U32:
prop_type = "Uint32";
break;
case EntityPropType.I8:
prop_type = "Int8";
break;
case EntityPropType.I16:
prop_type = "Int16";
break;
case EntityPropType.I32:
prop_type = "Int32";
break;
case EntityPropType.F32:
prop_type = "Float32";
break;
case EntityPropType.Angle:
prop_type = "Int32";
break;
default:
throw new Error(`EntityPropType.${EntityPropType[prop.type]} not supported.`);
}
const offset = prop.offset;
const comment = prop.name === "Unknown" ? "" : ` // ${prop.name}`;
console.log(` view.set${prop_type}(${offset}, ${value}, true);${comment}`);
}
console.log(" break;");
/* eslint-enable no-console */
}
}
function process_entities(
quest: Quest,
entities: readonly QuestEntity[],
entities_by_type: Map<EntityType, { entity: QuestEntity; quest: string; count: number }[]>,
): void {
for (const entity of entities) {
const type = get_entity_type(entity);
const existing_entities = entities_by_type.get(type);
if (existing_entities == undefined) {
entities_by_type.set(type, [{ entity, quest: quest.name, count: 1 }]);
} else {
const found = existing_entities.find(({ entity: entity_2 }) =>
entities_equal(entity, entity_2, type),
);
if (found) {
found.count++;
} else {
existing_entities.push({ entity, quest: quest.name, count: 1 });
}
}
}
}
/**
* @returns the entity's properties enriched with many default properties.
*/
function get_properties(type: EntityType): EntityProp[] {
let props = prop_cache.get(type);
if (props) {
return props;
}
if (is_npc_type(type)) {
props = [
{
name: "Unknown",
offset: 2,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 4,
type: EntityPropType.I16,
},
{
name: "Clone count",
offset: 6,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 8,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 10,
type: EntityPropType.I16,
},
{
name: "Scale x",
offset: 44,
type: EntityPropType.F32,
},
{
name: "Scale y",
offset: 48,
type: EntityPropType.F32,
},
{
name: "Scale z",
offset: 52,
type: EntityPropType.F32,
},
{
name: "Unknown",
offset: 68,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 70,
type: EntityPropType.I16,
},
];
} else {
props = [
{
name: "Unknown",
offset: 2,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 4,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 6,
type: EntityPropType.I16,
},
{
name: "Unknown",
offset: 14,
type: EntityPropType.I16,
},
{
name: "Scale x",
offset: 40,
type: EntityPropType.F32,
},
{
name: "Scale y",
offset: 44,
type: EntityPropType.F32,
},
{
name: "Scale z",
offset: 48,
type: EntityPropType.F32,
},
{
name: "Unknown",
offset: 56,
type: EntityPropType.I32,
},
{
name: "Unknown",
offset: 60,
type: EntityPropType.I32,
},
{
name: "Unknown",
offset: 64,
type: EntityPropType.I32,
},
];
}
outer: for (const entity_prop of entity_data(type).properties) {
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (entity_prop.offset === prop.offset) {
props.splice(i, 1, entity_prop);
continue outer;
} else if (entity_prop.offset < prop.offset) {
props.splice(i, 0, entity_prop);
continue outer;
}
}
props.push(entity_prop);
}
return props;
}
function col_print_name(prop: EntityProp): string {
const width = col_width(prop);
return prop.name.slice(0, width).padStart(width, " ");
}
function col_print_value(entity: QuestEntity, prop: EntityProp): string {
const value = get_entity_prop_value(entity, prop);
const str =
prop.type === EntityPropType.F32 || prop.type === EntityPropType.Angle
? value.toFixed(3)
: value.toString();
return str.padStart(col_width(prop), " ");
}
function col_width(prop: EntityProp): number {
switch (prop.type) {
case EntityPropType.U8:
return 3;
case EntityPropType.U16:
return 5;
case EntityPropType.U32:
return 10;
case EntityPropType.I8:
return 4;
case EntityPropType.I16:
return 6;
case EntityPropType.I32:
return 11;
case EntityPropType.F32:
return 10;
case EntityPropType.Angle:
return 4;
default:
throw new Error(`EntityPropType.${EntityPropType[prop.type]} not supported.`);
}
}
function entities_equal(a: QuestEntity, b: QuestEntity, type: EntityType): boolean {
for (const prop of get_properties(type)) {
if (get_entity_prop_value(a, prop) !== get_entity_prop_value(b, prop)) {
return false;
}
}
return true;
}

183
assets_generation/update_drops_ephinea.ts
View File

@ -1,183 +0,0 @@
import * as cheerio from "cheerio";
import { writeFileSync } from "fs";
import fetch from "node-fetch";
import { ASSETS_DIR } from ".";
import { Difficulty, SectionId, SectionIds } from "../src/core/model";
import {
name_and_episode_to_npc_type,
NpcType,
} from "../src/core/data_formats/parsing/quest/npc_types";
import { ItemTypeDto } from "../src/core/dto/ItemTypeDto";
import { BoxDropDto, EnemyDropDto } from "../src/hunt_optimizer/dto/drops";
import { LogManager } from "../src/core/logging";
const logger = LogManager.get("assets_generation/update_drops_ephinea");
export async function update_drops_from_website(item_types: ItemTypeDto[]): Promise<void> {
logger.info("Updating item drops.");
const normal = await download(item_types, Difficulty.Normal);
const hard = await download(item_types, Difficulty.Hard);
const vhard = await download(item_types, Difficulty.VHard, "very-hard");
const ultimate = await download(item_types, Difficulty.Ultimate);
const enemy_json = JSON.stringify(
[...normal.enemy_drops, ...hard.enemy_drops, ...vhard.enemy_drops, ...ultimate.enemy_drops],
null,
4,
);
writeFileSync(`${ASSETS_DIR}/enemy_drops.ephinea.json`, enemy_json);
const box_json = JSON.stringify(
[...normal.box_drops, ...hard.box_drops, ...vhard.box_drops, ...ultimate.box_drops],
null,
4,
);
writeFileSync(`${ASSETS_DIR}/box_drops.ephinea.json`, box_json);
logger.info("Done updating item drops.");
}
async function download(
item_types: ItemTypeDto[],
difficulty: Difficulty,
difficulty_url: string = Difficulty[difficulty].toLowerCase(),
): Promise<{ enemy_drops: EnemyDropDto[]; box_drops: BoxDropDto[]; items: Set<string> }> {
const response = await fetch(`https://ephinea.pioneer2.net/drop-charts/${difficulty_url}/`);
const body = await response.text();
const $ = cheerio.load(body);
let episode = 1;
const data: {
enemy_drops: EnemyDropDto[];
box_drops: BoxDropDto[];
items: Set<string>;
} = {
enemy_drops: [],
box_drops: [],
items: new Set(),
};
$("table").each((table_i, table) => {
const is_box = table_i >= 3;
$("tr", table).each((_, tr) => {
const enemy_or_box_text = $(tr.firstChild).text();
if (enemy_or_box_text.trim() === "") {
return;
} else if (enemy_or_box_text.startsWith("EPISODE ")) {
episode = parseInt(enemy_or_box_text.slice(-1), 10);
return;
}
try {
let enemy_or_box =
enemy_or_box_text.split("/")[difficulty === Difficulty.Ultimate ? 1 : 0] ||
enemy_or_box_text;
if (enemy_or_box === "Halo Rappy") {
enemy_or_box = "Hallo Rappy";
} else if (enemy_or_box === "Dal Ral Lie") {
enemy_or_box = "Dal Ra Lie";
} else if (enemy_or_box === "Vol Opt ver. 2") {
enemy_or_box = "Vol Opt ver.2";
} else if (enemy_or_box === "Za Boota") {
enemy_or_box = "Ze Boota";
} else if (enemy_or_box === "Saint Million") {
enemy_or_box = "Saint-Milion";
}
$("td", tr).each((td_i, td) => {
if (td_i === 0) {
return;
}
const section_id = SectionIds[td_i - 1];
if (is_box) {
// TODO:
// $('font font', td).each((_, font) => {
// const item = $('b', font).text();
// const rateNum = parseFloat($('sup', font).text());
// const rateDenom = parseFloat($('sub', font).text());
// data.boxDrops.push({
// difficulty: Difficulty[difficulty],
// episode,
// sectionId: SectionId[sectionId],
// box: enemyOrBox,
// item,
// dropRate: rateNum / rateDenom
// });
// data.items.add(item);
// });
return;
} else {
const item = $("font b", td).text();
if (item.trim() === "") {
return;
}
try {
const item_type = item_types.find(i => i.name === item);
if (!item_type) {
throw new Error(`No item type found with name "${item}".`);
}
const npc_type = name_and_episode_to_npc_type(enemy_or_box, episode);
if (!npc_type) {
throw new Error(`Couldn't retrieve NpcType.`);
}
const title = ($("font abbr", td).attr("title") ?? "").replace(
"\r",
"",
);
const [
,
drop_rate_num,
drop_rate_denom,
] = /Drop Rate: (\d+)\/(\d+(\.\d+)?)/g.exec(title)!.map(parseFloat);
const [
,
rare_rate_num,
rare_rate_denom,
] = /Rare Rate: (\d+)\/(\d+(\.\d+)?)/g.exec(title)!.map(parseFloat);
data.enemy_drops.push({
difficulty: Difficulty[difficulty],
episode,
section_id: SectionId[section_id],
enemy: NpcType[npc_type],
item_type_id: item_type.id,
drop_rate: drop_rate_num / drop_rate_denom,
rare_rate: rare_rate_num / rare_rate_denom,
});
data.items.add(item);
} catch (e) {
logger.error(
`Error while processing item ${item} of ${enemy_or_box} in episode ${episode} ${Difficulty[difficulty]}.`,
e,
);
}
}
});
} catch (e) {
logger.error(
`Error while processing ${enemy_or_box_text} in episode ${episode} ${difficulty}.`,
e,
);
}
});
});
return data;
}

1143
assets_generation/update_ephinea_data.ts
View File

File diff suppressed because it is too large Load Diff

227
assets_generation/update_generic_data.ts
View File

@ -1,227 +0,0 @@
import { readFileSync, writeFileSync } from "fs";
import { ASSETS_DIR, RESOURCE_DIR, SRC_DIR } from ".";
import { BufferCursor } from "../src/core/data_formats/block/cursor/BufferCursor";
import { parse_rlc } from "../src/core/data_formats/parsing/rlc";
import * as yaml from "yaml";
import { Endianness } from "../src/core/data_formats/block/Endianness";
import { LogManager } from "../src/core/logging";
import { Severity } from "../src/core/Severity";
import { unwrap } from "../src/core/Result";
const logger = LogManager.get("assets_generation/update_generic_data");
LogManager.default_severity = Severity.Trace;
const OPCODES_YML_FILE = `${RESOURCE_DIR}/asm/opcodes.yml`;
const OPCODES_SRC_FILE = `${SRC_DIR}/core/data_formats/asm/opcodes.ts`;
update();
function update(): void {
logger.info("Updating generic static data.");
update_opcodes();
extract_player_animations();
logger.info("Done updating generic static data.");
}
function extract_player_animations(): void {
logger.info("Extracting player animations.");
const buf = readFileSync(`${RESOURCE_DIR}/plymotiondata.rlc`);
let i = 0;
for (const file of unwrap(parse_rlc(new BufferCursor(buf, Endianness.Big)))) {
writeFileSync(
`${ASSETS_DIR}/player/animation/animation_${(i++).toString().padStart(3, "0")}.njm`,
new Uint8Array(file.array_buffer()),
);
}
logger.info("Done extracting player animations.");
}
function update_opcodes(): void {
logger.info("Generating opcodes.");
// Add manual code.
const opcodes_src = readFileSync(OPCODES_SRC_FILE, {
encoding: "utf-8",
});
const file_lines: string[] = [];
let in_manual_code = true;
let generated_lines_insert_point = 0;
opcodes_src.split("\n").forEach((line, i) => {
if (in_manual_code) {
if (line.includes("!!! GENERATED_CODE_START !!!")) {
in_manual_code = false;
generated_lines_insert_point = i + 1;
}
file_lines.push(line);
} else {
if (line.includes("!!! GENERATED_CODE_END !!!")) {
in_manual_code = true;
file_lines.push(line);
}
}
});
// Add generated code.
const yml = readFileSync(OPCODES_YML_FILE, { encoding: "utf-8" });
const input = yaml.parse(yml);
const generated_lines: string[] = [];
let i = 0;
for (let code = 0; code <= 0xff; code++) {
const opcode = input.opcodes[i];
if (opcode && opcode.code === code) {
opcode_to_code(generated_lines, code, opcode);
i++;
} else {
opcode_to_code(generated_lines, code);
}
}
for (let code = 0xf800; code <= 0xf9ff; code++) {
const opcode = input.opcodes[i];
if (opcode && opcode.code === code) {
opcode_to_code(generated_lines, code, opcode);
i++;
} else {
opcode_to_code(generated_lines, code);
}
}
// Write final file.
file_lines.splice(generated_lines_insert_point, 0, ...generated_lines);
writeFileSync(OPCODES_SRC_FILE, file_lines.join("\n"));
logger.info("Done generating opcodes.");
}
function opcode_to_code(output: string[], code: number, opcode?: any): void {
const code_str = code.toString(16).padStart(code < 256 ? 2 : 4, "0");
const mnemonic: string = (opcode && opcode.mnemonic) || `unknown_${code_str}`;
const var_name =
"OP_" +
mnemonic
.replace("!=", "ne")
.replace("<=", "le")
.replace(">=", "ge")
.replace("<", "l")
.replace(">", "g")
.replace("=", "e")
.toUpperCase();
if (opcode) {
const stack_interaction =
opcode.stack === "push"
? "StackInteraction.Push"
: opcode.stack === "pop"
? "StackInteraction.Pop"
: "undefined";
const params = params_to_code(opcode.params);
output.push(`export const ${var_name} = (OPCODES[0x${code_str}] = new_opcode(
0x${code_str},
"${mnemonic}",
${(opcode.doc && JSON.stringify(opcode.doc)) || "undefined"},
[${params}],
${stack_interaction}
));`);
} else {
output.push(`export const ${var_name} = (OPCODES[0x${code_str}] = new_opcode(
0x${code_str},
"${mnemonic}",
undefined,
[],
undefined
));`);
}
}
function params_to_code(params: any[]): string {
return params
.map((param: any) => {
let type: string;
switch (param.type) {
case "any":
type = "TYPE_ANY";
break;
case "byte":
type = "TYPE_BYTE";
break;
case "word":
type = "TYPE_WORD";
break;
case "dword":
type = "TYPE_DWORD";
break;
case "float":
type = "TYPE_FLOAT";
break;
case "label":
type = "TYPE_LABEL";
break;
case "instruction_label":
type = "TYPE_I_LABEL";
break;
case "data_label":
type = "TYPE_D_LABEL";
break;
case "string_label":
type = "TYPE_S_LABEL";
break;
case "string":
type = "TYPE_STRING";
break;
case "instruction_label_var":
type = "TYPE_I_LABEL_VAR";
break;
case "reg_ref":
type = "TYPE_REG_REF";
break;
case "reg_tup_ref":
type = `{ kind: Kind.RegTupRef, register_tuples: [${params_to_code(
param.reg_tup,
)}] }`;
break;
case "reg_ref_var":
type = "TYPE_REG_REF_VAR";
break;
case "pointer":
type = "TYPE_POINTER";
break;
default:
throw new Error(`Type ${param.type} not implemented.`);
}
const doc = (param.doc && JSON.stringify(param.doc)) || "undefined";
let access: string;
switch (param.access) {
case "read":
access = "ParamAccess.Read";
break;
case "write":
access = "ParamAccess.Write";
break;
case "read_write":
access = "ParamAccess.ReadWrite";
break;
default:
access = "undefined";
break;
}
return `new_param(${type}, ${doc}, ${access})`;
})
.join(", ");
}

114
assets_generation/walk_quests.ts
View File

@ -1,114 +0,0 @@
import { readdirSync, readFileSync, statSync } from "fs";
import { parse_qst_to_quest, QuestData } from "../src/core/data_formats/parsing/quest";
import { BufferCursor } from "../src/core/data_formats/block/cursor/BufferCursor";
import { Endianness } from "../src/core/data_formats/block/Endianness";
import { LogManager } from "../src/core/logging";
import { Severity } from "../src/core/Severity";
const logger = LogManager.get("assets_generation/walk_quests");
/**
* Applies process to all QST files in a directory. Uses the 106 QST files
* provided with Tethealla version 0.143 by default.
*/
export function walk_quests(
config: { path: string; suppress_parser_log?: boolean; exclude?: readonly string[] },
process: (quest: QuestData) => void,
): void {
const loggers = (config.suppress_parser_log !== false
? [
"core/data_formats/asm/data_flow_analysis/register_value",
"core/data_formats/parsing/quest",
"core/data_formats/parsing/quest/bin",
"core/data_formats/parsing/quest/object_code",
"core/data_formats/parsing/quest/qst",
]
: []
).map(logger_name => {
const logger = LogManager.get(logger_name);
const old = logger.severity;
logger.severity = Severity.Error;
return [logger, old] as const;
});
try {
walk_qst_files(config, (p, _, contents) => {
try {
const result = parse_qst_to_quest(
new BufferCursor(contents, Endianness.Little),
true,
);
if (result.success) {
process(result.value);
} else {
logger.error(`Couldn't process ${p}.`);
}
} catch (e) {
logger.error(`Couldn't parse ${p}.`, e);
}
});
} finally {
for (const [logger, severity] of loggers) {
logger.severity = severity;
}
}
}
/**
* Applies f to all 106 QST files provided with Tethealla version 0.143.
* f is called with the path to the file, the file name and the content of the file.
*/
export function walk_qst_files(
config: { path?: string; exclude?: readonly string[] },
f: (path: string, file_name: string, contents: Buffer) => void,
): void {
const path = config.path ?? "assets_generation/resources/tethealla_v0.143_quests";
// BUG: Battle quests are not always parsed in the same way.
// Could be a bug in Jest or Node as the quest parsing code has no randomness or dependency on mutable state.
// TODO: Some quests can not yet be parsed correctly.
let exclude: readonly string[];
if (config.exclude) {
exclude = config.exclude;
} else if (config.path == undefined) {
exclude = [
"/battle", // Battle mode quests.
"/ep2/event/ma4-a.qst", // .qst seems corrupt, doesn't work in qedit either.
];
} else {
exclude = [];
}
const idx = path.lastIndexOf("/");
walk_qst_files_internal(
f,
path,
idx === -1 || idx >= path.length - 1 ? path : path.slice(idx + 1),
exclude,
);
}
function walk_qst_files_internal(
f: (path: string, file_name: string, contents: Buffer) => void,
path: string,
name: string,
exclude: readonly string[],
): void {
if (exclude.some(e => path.includes(e))) {
return;
}
const stat = statSync(path);
if (stat.isFile()) {
if (path.endsWith(".qst")) {
f(path, name, readFileSync(path));
}
} else if (stat.isDirectory()) {
for (const file of readdirSync(path)) {
walk_qst_files_internal(f, `${path}/${file}`, file, exclude);
}
}
}

25
build.gradle.kts Normal file
View File

@ -0,0 +1,25 @@
import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
plugins {
kotlin("multiplatform") version "1.4.10" apply false
kotlin("js") version "1.4.10" apply false
}
tasks.wrapper {
gradleVersion = "6.6.1"
}
subprojects {
project.extra["kotlinLoggingVersion"] = "2.0.2"
repositories {
jcenter()
}
tasks.withType<Kotlin2JsCompile> {
kotlinOptions.freeCompilerArgs += listOf(
"-Xopt-in=kotlin.ExperimentalUnsignedTypes",
"-Xopt-in=kotlin.time.ExperimentalTime"
)
}
}

36
core/build.gradle.kts Normal file
View File

@ -0,0 +1,36 @@
plugins {
kotlin("multiplatform")
}
val kotlinLoggingVersion: String by project.extra
kotlin {
js {
browser {}
}
sourceSets {
commonMain {
dependencies {
api("io.github.microutils:kotlin-logging:$kotlinLoggingVersion")
}
}
commonTest {
dependencies {
implementation(kotlin("test-common"))
implementation(kotlin("test-annotations-common"))
}
}
val jsTest by getting {
dependencies {
implementation(kotlin("test-js"))
}
}
}
}
tasks.register("test") {
dependsOn("allTests")
}

3
core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt Normal file
View File

@ -0,0 +1,3 @@
package world.phantasmal.core
expect fun <T> Any?.fastCast(): T

73
core/src/commonMain/kotlin/world/phantasmal/core/PwResult.kt Normal file
View File

@ -0,0 +1,73 @@
package world.phantasmal.core
import mu.KLogger
sealed class PwResult<out T>(val problems: List<Problem>) {
fun unwrap(): T = when (this) {
is Success -> value
is Failure -> error(problems.joinToString("\n") { "[${it.severity}] ${it.uiMessage}" })
}
companion object {
fun <T> build(logger: KLogger): PwResultBuilder<T> =
PwResultBuilder(logger)
}
}
class Success<T>(val value: T, problems: List<Problem>) : PwResult<T>(problems)
class Failure(problems: List<Problem>) : PwResult<Nothing>(problems)
class Problem(
val severity: Severity,
/**
* Readable message meant for users.
*/
val uiMessage: String,
)
enum class Severity {
Info,
Warning,
Error,
}
/**
* Useful for building up a [PwResult] and logging problems at the same time.
*/
class PwResultBuilder<T>(private val logger: KLogger) {
private val problems: MutableList<Problem> = mutableListOf()
/**
* Add a problem to the problems list and log it with [logger].
*/
fun addProblem(
severity: Severity,
uiMessage: String,
message: String? = null,
cause: Throwable? = null,
): PwResultBuilder<T> {
when (severity) {
Severity.Info -> logger.info(cause) { message ?: uiMessage }
Severity.Warning -> logger.warn(cause) { message ?: uiMessage }
Severity.Error -> logger.error(cause) { message ?: uiMessage }
}
problems.add(Problem(severity, uiMessage));
return this;
}
/**
* Add the given result's problems.
*/
fun addResult(result: PwResult<*>): PwResultBuilder<T> {
problems.addAll(result.problems)
return this;
}
fun success(value: T): Success<T> =
Success(value, problems)
fun failure(): Failure =
Failure(problems)
}

3
core/src/commonMain/kotlin/world/phantasmal/core/disposable/Creation.kt Normal file
View File

@ -0,0 +1,3 @@
package world.phantasmal.core.disposable
fun disposable(dispose: () -> Unit): Disposable = SimpleDisposable(dispose)

27
core/src/commonMain/kotlin/world/phantasmal/core/disposable/Disposable.kt Normal file
View File

@ -0,0 +1,27 @@
package world.phantasmal.core.disposable
/**
* Objects implementing this interface should be disposed when they're not used anymore. This is to
* avoid resource leaks.
*/
interface Disposable {
/**
* Releases any held resources.
*/
fun dispose()
}
/**
* Executes the given function on this disposable and then disposes it whether an exception is
* thrown or not.
*
* @param block a function to process this [Disposable] resource.
* @return the result of [block] invoked on this resource.
*/
inline fun <D : Disposable, R> D.use(block: (D) -> R): R {
try {
return block(this)
} finally {
dispose()
}
}

23
core/src/commonMain/kotlin/world/phantasmal/core/disposable/DisposableContainer.kt Normal file
View File

@ -0,0 +1,23 @@
package world.phantasmal.core.disposable
/**
* Abstract utility class for classes that need to keep track of many disposables.
*/
abstract class DisposableContainer : TrackedDisposable() {
private val disposer = Disposer()
override fun internalDispose() {
disposer.dispose()
}
protected fun <T : Disposable> addDisposable(disposable: T): T {
return disposer.add(disposable);
}
protected fun addDisposables(vararg disposables: Disposable) {
disposer.addAll(*disposables);
}
protected fun removeDisposable(disposable: Disposable) =
disposer.remove(disposable)
}

80
core/src/commonMain/kotlin/world/phantasmal/core/disposable/Disposer.kt Normal file
View File

@ -0,0 +1,80 @@
package world.phantasmal.core.disposable
/**
* Container for disposables. Takes ownership of all held disposables and automatically disposes
* them when the Disposer is disposed.
*/
class Disposer : TrackedDisposable() {
private val disposables = mutableListOf<Disposable>()
/**
* The amount of held disposables.
*/
val size: Int get() = disposables.size
/**
* Add a single disposable and return the given disposable.
*/
fun <T : Disposable> add(disposable: T): T {
if (disposed) {
disposable.dispose()
} else {
disposables.add(disposable)
}
return disposable
}
/**
* Add 0 or more disposables.
*/
fun addAll(disposables: Iterable<Disposable>) {
if (disposed) {
disposables.forEach { it.dispose() }
} else {
this.disposables.addAll(disposables)
}
}
/**
* Add 0 or more disposables.
*/
fun addAll(vararg disposables: Disposable) {
if (disposed) {
disposables.forEach { it.dispose() }
} else {
this.disposables.addAll(disposables)
}
}
fun isEmpty(): Boolean = disposables.isEmpty()
/**
* Removes and disposes the given [disposable].
*/
fun remove(disposable: Disposable) {
disposables.remove(disposable)
disposable.dispose()
}
/**
* Removes and disposes [amount] disposables at the given [index].
*/
fun removeAt(index: Int, amount: Int = 1) {
repeat(amount) {
disposables.removeAt(index).dispose()
}
}
/**
* Disposes all held disposables.
*/
fun disposeAll() {
disposables.forEach { it.dispose() }
disposables.clear()
}
override fun internalDispose() {
disposeAll()
}
}

8
core/src/commonMain/kotlin/world/phantasmal/core/disposable/SimpleDisposable.kt Normal file
View File

@ -0,0 +1,8 @@
package world.phantasmal.core.disposable
class SimpleDisposable(private val dispose: () -> Unit) : TrackedDisposable() {
override fun internalDispose() {
// Use invoke to avoid calling the dispose method instead of the dispose property.
dispose.invoke()
}
}

39
core/src/commonMain/kotlin/world/phantasmal/core/disposable/TrackedDisposable.kt Normal file
View File

@ -0,0 +1,39 @@
package world.phantasmal.core.disposable
/**
* A global count is kept of all undisposed instances of this class.
* This count can be used to find memory leaks.
*/
abstract class TrackedDisposable : Disposable {
var disposed = false
private set
init {
disposableCount++
}
final override fun dispose() {
if (!disposed) {
disposed = true
disposableCount--
internalDispose()
}
}
protected abstract fun internalDispose()
companion object {
var disposableCount: Int = 0
private set
fun checkNoLeaks(block: () -> Unit) {
val count = disposableCount
try {
block()
} finally {
check(count == disposableCount) { "TrackedDisposables were leaked." }
}
}
}
}

133
core/src/commonTest/kotlin/world/phantasmal/core/disposable/DisposerTests.kt Normal file
View File

@ -0,0 +1,133 @@
package world.phantasmal.core.disposable
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
class DisposerTests {
@Test
fun calling_add_or_add_all_should_increase_size_correctly() {
TrackedDisposable.checkNoLeaks {
val disposer = Disposer()
assertEquals(disposer.size, 0)
disposer.add(dummy())
assertEquals(disposer.size, 1)
disposer.addAll(dummy(), dummy())
assertEquals(disposer.size, 3)
disposer.add(dummy())
assertEquals(disposer.size, 4)
disposer.addAll(dummy(), dummy())
assertEquals(disposer.size, 6)
disposer.dispose()
}
}
@Test
fun a_disposer_should_dispose_all_its_disposables_when_disposed() {
TrackedDisposable.checkNoLeaks {
val disposer = Disposer()
var disposablesDisposed = 0
for (i in 1..5) {
disposer.add(object : Disposable {
override fun dispose() {
disposablesDisposed++
}
})
}
disposer.addAll((1..5).map {
object : Disposable {
override fun dispose() {
disposablesDisposed++
}
}
})
disposer.dispose()
assertEquals(10, disposablesDisposed)
}
}
@Test
fun dispose_all_should_dispose_all_disposables() {
TrackedDisposable.checkNoLeaks {
val disposer = Disposer()
var disposablesDisposed = 0
for (i in 1..5) {
disposer.add(object : Disposable {
override fun dispose() {
disposablesDisposed++
}
})
}
disposer.disposeAll()
assertEquals(5, disposablesDisposed)
disposer.dispose()
}
}
@Test
fun size_and_is_empty_should_correctly_reflect_the_contained_disposables() {
TrackedDisposable.checkNoLeaks {
val disposer = Disposer()
assertEquals(disposer.size, 0)
assertTrue(disposer.isEmpty())
for (i in 1..5) {
disposer.add(dummy())
assertEquals(disposer.size, i)
assertFalse(disposer.isEmpty())
}
disposer.dispose()
assertEquals(disposer.size, 0)
assertTrue(disposer.isEmpty())
}
}
@Test
fun a_disposer_should_dispose_added_disposables_after_being_disposed() {
TrackedDisposable.checkNoLeaks {
val disposer = Disposer()
disposer.dispose()
var disposedCount = 0
for (i in 1..3) {
disposer.add(object : Disposable {
override fun dispose() {
disposedCount++
}
})
}
disposer.addAll((1..3).map {
object : Disposable {
override fun dispose() {
disposedCount++
}
}
})
assertEquals(6, disposedCount)
}
}
private fun dummy(): Disposable = disposable {}
}

51
core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt Normal file
View File

@ -0,0 +1,51 @@
package world.phantasmal.core.disposable
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
class TrackedDisposableTests {
@Test
fun count_should_go_up_when_created_and_down_when_disposed() {
val initialCount = TrackedDisposable.disposableCount
val disposable = object : TrackedDisposable() {
override fun internalDispose() {}
}
assertEquals(initialCount + 1, TrackedDisposable.disposableCount)
disposable.dispose()
assertEquals(initialCount, TrackedDisposable.disposableCount)
}
@Test
fun double_dispose_should_not_increase_count() {
val initialCount = TrackedDisposable.disposableCount
val disposable = object : TrackedDisposable() {
override fun internalDispose() {}
}
for (i in 1..5) {
disposable.dispose()
}
assertEquals(initialCount, TrackedDisposable.disposableCount)
}
@Test
fun disposed_property_should_be_set_correctly() {
val disposable = object : TrackedDisposable() {
override fun internalDispose() {}
}
assertFalse(disposable.disposed)
disposable.dispose()
assertTrue(disposable.disposed)
}
}

3
core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt Normal file
View File

@ -0,0 +1,3 @@
package world.phantasmal.core
actual fun <T> Any?.fastCast(): T = unsafeCast<T>()

39
deploy.ps1
View File

@ -1,39 +0,0 @@
# Script for deploying to gh-pages.
# Requires a git ./deployment directory which tracks a gh-pages branch.
Write-Output "Running tests."
yarn test
if ($LastExitCode -ne 0) { throw "Tests failed." }
Write-Output "Generating production build."
yarn build
if ($LastExitCode -ne 0) { throw "Build failed." }
Write-Output "Deleting ./deployment contents."
Remove-Item -Recurse ./deployment/*
Write-Output "Copying dist to ./deployment."
Copy-Item -Recurse ./dist/* ./deployment
Write-Output "www.phantasmal.world" > deployment/CNAME
Write-Output "Bumping version."
$version = Get-Content -Path version.txt
$version = $version / 1 + 1
Write-Output $version > version.txt
Write-Output "Committing and pushing to gh-pages."
Set-Location ./deployment
git pull
if ($LastExitCode -ne 0) { throw "Git pull failed." }
git add .
if ($LastExitCode -ne 0) { throw "Git add failed." }
git commit -m "Release $version."
if ($LastExitCode -ne 0) { throw "Git commit failed." }
git push
if ($LastExitCode -ne 0) { throw "Git push failed." }
Set-Location ..
Write-Output ""
Write-Output "Deployed release $version successfully."
Write-Output ""

2
gradle.properties Normal file
View File

@ -0,0 +1,2 @@
kotlin.code.style=official
kotlin.mpp.stability.nowarn=true

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

5
gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@ -0,0 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

185
gradlew vendored Normal file
View File

@ -0,0 +1,185 @@
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
exec "$JAVACMD" "$@"

104
gradlew.bat vendored Normal file
View File

@ -0,0 +1,104 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

21
jest.config.js
View File

@ -1,21 +0,0 @@
module.exports = {
preset: "ts-jest",
moduleDirectories: ["node_modules"],
setupFiles: ["./test/src/setup.js", "jest-canvas-mock"],
roots: ["./src", "./test"],
modulePathIgnorePatterns: [
"/node_modules/",
// Ignore prs-rs browser package and only use testing package.
"/src/core/data_formats/compression/prs/pkg",
],
moduleNameMapper: {
"\\.(css|gif|jpg|png|svg|ttf)$": "<rootDir>/src/__mocks__/static_files.js",
"^monaco-editor$": "<rootDir>/node_modules/monaco-editor/esm/vs/editor/editor.main.js",
"^worker-loader!": "<rootDir>/src/__mocks__/webworkers.js",
},
globals: {
"ts-jest": {
isolatedModules: true,
},
},
};

41
lib/build.gradle.kts Normal file
View File

@ -0,0 +1,41 @@
plugins {
kotlin("multiplatform")
}
val kotlinLoggingVersion: String by project.extra
kotlin {
js {
browser()
}
sourceSets {
all {
languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
}
commonMain {
dependencies {
api(project(":core"))
api("io.github.microutils:kotlin-logging:$kotlinLoggingVersion")
}
}
commonTest {
dependencies {
implementation(kotlin("test-common"))
implementation(kotlin("test-annotations-common"))
}
}
val jsTest by getting {
dependencies {
implementation(kotlin("test-js"))
}
}
}
}
tasks.register("test") {
dependsOn("allTests")
}

122
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt Normal file
View File

@ -0,0 +1,122 @@
package world.phantasmal.lib.cursor
/**
* A cursor for reading binary data.
*/
interface Cursor {
val size: UInt
/**
* The position from where bytes will be read or written.
*/
val position: UInt
/**
* Byte order mode.
*/
var endianness: Endianness
val bytesLeft: UInt
/**
* Seek forward or backward by a number of bytes.
*
* @param offset if positive, seeks forward by offset bytes, otherwise seeks backward by -offset bytes.
*/
fun seek(offset: Int): Cursor
/**
* Seek forward from the start of the cursor by a number of bytes.
*
* @param offset smaller than size
*/
fun seekStart(offset: UInt): Cursor
/**
* Seek backward from the end of the cursor by a number of bytes.
*
* @param offset smaller than size
*/
fun seekEnd(offset: UInt): Cursor
/**
* Reads an unsigned 8-bit integer and increments position by 1.
*/
fun u8(): UByte
/**
* Reads an unsigned 16-bit integer and increments position by 2.
*/
fun u16(): UShort
/**
* Reads an unsigned 32-bit integer and increments position by 4.
*/
fun u32(): UInt
/**
* Reads an signed 8-bit integer and increments position by 1.
*/
fun i8(): Byte
/**
* Reads a signed 16-bit integer and increments position by 2.
*/
fun i16(): Short
/**
* Reads a signed 32-bit integer and increments position by 4.
*/
fun i32(): Int
/**
* Reads a 32-bit floating point number and increments position by 4.
*/
fun f32(): Float
/**
* Reads [n] unsigned 8-bit integers and increments position by [n].
*/
fun u8Array(n: UInt): UByteArray
/**
* Reads [n] unsigned 16-bit integers and increments position by 2[n].
*/
fun u16Array(n: UInt): UShortArray
/**
* Reads [n] unsigned 32-bit integers and increments position by 4[n].
*/
fun u32Array(n: UInt): UIntArray
/**
* Reads [n] signed 32-bit integers and increments position by 4[n].
*/
fun i32Array(n: UInt): IntArray
/**
* Consumes a variable number of bytes.
*
* @param size the amount bytes to consume.
* @return a write-through view containing size bytes.
*/
fun take(size: UInt): Cursor
/**
* Consumes up to [maxByteLength] bytes.
*/
fun stringAscii(
maxByteLength: UInt,
nullTerminated: Boolean,
dropRemaining: Boolean,
): String
/**
* Consumes up to [maxByteLength] bytes.
*/
fun stringUtf16(
maxByteLength: UInt,
nullTerminated: Boolean,
dropRemaining: Boolean,
): String
}

6
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Endianness.kt Normal file
View File

@ -0,0 +1,6 @@
package world.phantasmal.lib.cursor
enum class Endianness {
Little,
Big
}

60
lib/src/commonMain/kotlin/world/phantasmal/lib/fileformats/Iff.kt Normal file
View File

@ -0,0 +1,60 @@
package world.phantasmal.lib.fileformats
import mu.KotlinLogging
import world.phantasmal.core.PwResult
import world.phantasmal.core.Severity
import world.phantasmal.lib.cursor.Cursor
private val logger = KotlinLogging.logger {}
class IffChunk(val type: UInt, val data: Cursor)
class IffChunkHeader(val type: UInt, val size: UInt)
/**
* PSO uses a little endian variant of the IFF format.
* IFF files contain chunks preceded by an 8-byte header.
* The header consists of 4 ASCII characters for the "Type ID" and a 32-bit integer specifying the chunk size.
*/
fun parseIff(cursor: Cursor): PwResult<List<IffChunk>> =
parse(cursor) { chunkCursor, type, size -> IffChunk(type, chunkCursor.take(size)) }
/**
* Parses just the chunk headers.
*/
fun parseIffHeaders(cursor: Cursor): PwResult<List<IffChunkHeader>> =
parse(cursor) { _, type, size -> IffChunkHeader(type, size) }
private fun <T> parse(
cursor: Cursor,
getChunk: (Cursor, type: UInt, size: UInt) -> T,
): PwResult<List<T>> {
val result = PwResult.build<List<T>>(logger)
val chunks = mutableListOf<T>()
var corrupted = false
while (cursor.bytesLeft >= 8u) {
val type = cursor.u32()
val sizePos = cursor.position
val size = cursor.u32()
if (size > cursor.bytesLeft) {
corrupted = true
result.addProblem(
if (chunks.isEmpty()) Severity.Error else Severity.Warning,
"IFF file corrupted.",
"Size $size was too large (only ${cursor.bytesLeft} bytes left) at position $sizePos."
)
break
}
chunks.add(getChunk(cursor, type, size))
}
return if (corrupted && chunks.isEmpty()) {
result.failure()
} else {
result.success(chunks)
}
}

15
src/core/data_formats/parsing/quest/properties.ts → lib/src/commonMain/kotlin/world/phantasmal/lib/fileformats/quest/EntityProp.kt
View File

@ -1,14 +1,16 @@
package world.phantasmal.lib.fileformats.quest
/**
* Represents a configurable property for accessing parts of entity data of which the use is not
* fully understood or ambiguous.
*/
export type EntityProp = {
readonly name: string;
readonly offset: number;
readonly type: EntityPropType;
};
class EntityProp(
val name: String,
val offset: Int,
val type: EntityPropType,
)
export enum EntityPropType {
enum class EntityPropType {
U8,
U16,
U32,
@ -16,6 +18,7 @@ export enum EntityPropType {
I16,
I32,
F32,
/**
* Signed 32-bit integer that represents an angle. 0x10000 is 360°.
*/

13
lib/src/commonMain/kotlin/world/phantasmal/lib/fileformats/quest/EntityType.kt Normal file
View File

@ -0,0 +1,13 @@
package world.phantasmal.lib.fileformats.quest
interface EntityType {
/**
* Unique name. E.g. an episode II Delsaber would have (Ep. II) appended to its name.
*/
val uniqueName: String
/**
* Name used in the game.
* Might conflict with other NPC names (e.g. Delsaber from ep. I and ep. II).
*/
val simpleName: String
}

7
lib/src/commonMain/kotlin/world/phantasmal/lib/fileformats/quest/Episode.kt Normal file
View File

@ -0,0 +1,7 @@
package world.phantasmal.lib.fileformats.quest
enum class Episode {
I,
II,
IV,
}

1481
lib/src/commonMain/kotlin/world/phantasmal/lib/fileformats/quest/NpcType.kt Normal file
View File

File diff suppressed because it is too large Load Diff

30
observable/build.gradle.kts Normal file
View File

@ -0,0 +1,30 @@
plugins {
kotlin("multiplatform")
}
kotlin {
js {
browser {}
}
sourceSets {
commonMain {
dependencies {
implementation(project(":core"))
}
}
commonTest {
dependencies {
implementation(kotlin("test-common"))
implementation(kotlin("test-annotations-common"))
}
}
val jsTest by getting {
dependencies {
implementation(kotlin("test-js"))
}
}
}
}

5
observable/src/commonMain/kotlin/world/phantasmal/observable/Emitter.kt Normal file
View File

@ -0,0 +1,5 @@
package world.phantasmal.observable
interface Emitter<T> : Observable<T> {
fun emit(event: ChangeEvent<T>)
}

7
observable/src/commonMain/kotlin/world/phantasmal/observable/Observable.kt Normal file
View File

@ -0,0 +1,7 @@
package world.phantasmal.observable
import world.phantasmal.core.disposable.Disposable
interface Observable<out T> {
fun observe(observer: Observer<T>): Disposable
}

7
observable/src/commonMain/kotlin/world/phantasmal/observable/Observer.kt Normal file
View File

@ -0,0 +1,7 @@
package world.phantasmal.observable
open class ChangeEvent<out T>(val value: T) {
operator fun component1() = value
}
typealias Observer<T> = (event: ChangeEvent<T>) -> Unit

20
observable/src/commonMain/kotlin/world/phantasmal/observable/SimpleEmitter.kt Normal file
View File

@ -0,0 +1,20 @@
package world.phantasmal.observable
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
class SimpleEmitter<T> : Emitter<T> {
private val observers = mutableListOf<Observer<T>>()
override fun observe(observer: Observer<T>): Disposable {
observers.add(observer)
return disposable {
observers.remove(observer)
}
}
override fun emit(event: ChangeEvent<T>) {
observers.forEach { it(event) }
}
}

29
observable/src/commonMain/kotlin/world/phantasmal/observable/value/AbstractVal.kt Normal file
View File

@ -0,0 +1,29 @@
package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.observable.Observer
abstract class AbstractVal<T> : Val<T> {
protected val observers: MutableList<ValObserver<T>> = mutableListOf()
final override fun observe(observer: Observer<T>): Disposable =
observe(callNow = false, observer)
override fun observe(callNow: Boolean, observer: ValObserver<T>): Disposable {
observers.add(observer)
if (callNow) {
observer(ValChangeEvent(value, value))
}
return disposable {
observers.remove(observer)
}
}
protected fun emit(oldValue: T) {
val event = ValChangeEvent(value, oldValue)
observers.forEach { it(event) }
}
}

17
observable/src/commonMain/kotlin/world/phantasmal/observable/value/DelegatingVal.kt Normal file
View File

@ -0,0 +1,17 @@
package world.phantasmal.observable.value
class DelegatingVal<T>(
private val getter: () -> T,
private val setter: (T) -> Unit,
) : AbstractVal<T>(), MutableVal<T> {
override var value: T
get() = getter()
set(value) {
val oldValue = getter()
if (value != oldValue) {
setter(value)
emit(oldValue)
}
}
}

47
observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt Normal file
View File

@ -0,0 +1,47 @@
package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.fastCast
class DependentVal<T>(
private val dependencies: Iterable<Val<*>>,
private val operation: () -> T,
) : AbstractVal<T>() {
private var dependencyDisposables: MutableList<Disposable> = mutableListOf()
private var internalValue: T? = null
override val value: T
get() {
return if (dependencyDisposables.isEmpty()) {
operation()
} else {
internalValue.fastCast()
}
}
override fun observe(callNow: Boolean, observer: ValObserver<T>): Disposable {
if (dependencyDisposables.isEmpty()) {
internalValue = operation()
dependencyDisposables.addAll(dependencies.map { dependency ->
dependency.observe {
val oldValue = internalValue
internalValue = operation()
emit(oldValue.fastCast())
}
})
}
val superDisposable = super.observe(callNow, observer)
return disposable {
superDisposable.dispose()
if (observers.isEmpty()) {
dependencyDisposables.forEach { it.dispose() }
dependencyDisposables.clear()
}
}
}
}

11
observable/src/commonMain/kotlin/world/phantasmal/observable/value/MutableVal.kt Normal file
View File

@ -0,0 +1,11 @@
package world.phantasmal.observable.value
import kotlin.reflect.KProperty
interface MutableVal<T> : Val<T> {
override var value: T
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
this.value = value
}
}

12
observable/src/commonMain/kotlin/world/phantasmal/observable/value/SimpleVal.kt Normal file
View File

@ -0,0 +1,12 @@
package world.phantasmal.observable.value
class SimpleVal<T>(value: T) : AbstractVal<T>(), MutableVal<T> {
override var value: T = value
set(value) {
if (value != field) {
val oldValue = field
field = value
emit(oldValue)
}
}
}

22
observable/src/commonMain/kotlin/world/phantasmal/observable/value/StaticVal.kt Normal file
View File

@ -0,0 +1,22 @@
package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.observable.Observer
class StaticVal<T>(override val value: T) : Val<T> {
override fun observe(callNow: Boolean, observer: ValObserver<T>): Disposable {
if (callNow) {
observer(ValChangeEvent(value, value))
}
return StaticValDisposable
}
override fun observe(observer: Observer<T>): Disposable = StaticValDisposable
private object StaticValDisposable : Disposable {
override fun dispose() {
// Do nothing.
}
}
}

28
observable/src/commonMain/kotlin/world/phantasmal/observable/value/Val.kt Normal file
View File

@ -0,0 +1,28 @@
package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.observable.Observable
import kotlin.reflect.KProperty
/**
* An observable with the notion of a current [value].
*/
interface Val<out T> : Observable<T> {
val value: T
operator fun getValue(thisRef: Any?, property: KProperty<*>): T = value
/**
* @param callNow Call [observer] immediately with the current [mutableVal].
*/
fun observe(callNow: Boolean = false, observer: ValObserver<T>): Disposable
fun <R> transform(transform: (T) -> R): Val<R> =
DependentVal(listOf(this)) { transform(value) }
fun <T2, R> transform(v2: Val<T2>, transform: (T, T2) -> R): Val<R> =
DependentVal(listOf(this, v2)) { transform(value, v2.value) }
fun <R> flatTransform(transform: (T) -> Val<R>): Val<R> =
TODO()
}

25
observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValCreation.kt Normal file
View File

@ -0,0 +1,25 @@
package world.phantasmal.observable.value
private val TRUE_VAL: Val<Boolean> = StaticVal(true)
private val FALSE_VAL: Val<Boolean> = StaticVal(false)
private val NULL_VALL: Val<Nothing?> = StaticVal(null)
fun <T> value(value: T): Val<T> = StaticVal(value)
fun trueVal(): Val<Boolean> = TRUE_VAL
fun falseVal(): Val<Boolean> = FALSE_VAL
fun nullVal(): Val<Nothing?> = NULL_VALL
/**
* Creates a [MutableVal] with initial value [value].
*/
fun <T> mutableVal(value: T): MutableVal<T> = SimpleVal(value)
/**
* Creates a [MutableVal] which calls [getter] or [setter] when its value is being read or written
* to, respectively.
*/
fun <T> mutableVal(getter: () -> T, setter: (T) -> Unit): MutableVal<T> =
DelegatingVal(getter, setter)

13
observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValExtensions.kt Normal file
View File

@ -0,0 +1,13 @@
package world.phantasmal.observable.value
infix fun Val<Boolean>.and(other: Val<Boolean>): Val<Boolean> =
transform(other) { a, b -> a && b }
infix fun Val<Boolean>.or(other: Val<Boolean>): Val<Boolean> =
transform(other) { a, b -> a || b }
// Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
infix fun Val<Boolean>.xor(other: Val<Boolean>): Val<Boolean> =
transform(other) { a, b -> a != b }
operator fun Val<Boolean>.not(): Val<Boolean> = transform { !it }

9
observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValObserver.kt Normal file
View File

@ -0,0 +1,9 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.ChangeEvent
class ValChangeEvent<out T>(value: T, val oldValue: T) : ChangeEvent<T>(value) {
operator fun component2() = oldValue
}
typealias ValObserver<T> = (event: ValChangeEvent<T>) -> Unit

50
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt Normal file
View File

@ -0,0 +1,50 @@
package world.phantasmal.observable.value.list
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.fastCast
import world.phantasmal.observable.value.AbstractVal
import world.phantasmal.observable.value.ValObserver
class FoldedVal<T, R>(
private val dependency: ListVal<T>,
private val initial: R,
private val operation: (R, T) -> R,
) : AbstractVal<R>() {
private var dependencyDisposable: Disposable? = null
private var internalValue: R? = null
override val value: R
get() {
return if (dependencyDisposable == null) {
computeValue()
} else {
internalValue.fastCast()
}
}
override fun observe(callNow: Boolean, observer: ValObserver<R>): Disposable {
val superDisposable = super.observe(callNow, observer)
if (dependencyDisposable == null) {
internalValue = computeValue()
dependencyDisposable = dependency.observe {
val oldValue = internalValue
internalValue = computeValue()
emit(oldValue.fastCast())
}
}
return disposable {
superDisposable.dispose()
if (observers.isEmpty()) {
dependencyDisposable?.dispose()
dependencyDisposable = null
}
}
}
private fun computeValue(): R = dependency.value.fold(initial, operation)
}

17
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/ListVal.kt Normal file
View File

@ -0,0 +1,17 @@
package world.phantasmal.observable.value.list
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.observable.value.Val
import kotlin.reflect.KProperty
interface ListVal<E> : Val<List<E>>, List<E> {
val sizeVal: Val<Int>
fun observeList(observer: ListValObserver<E>): Disposable
fun sumBy(selector: (E) -> Int): Val<Int> =
fold(0) { acc, el -> acc + selector(el) }
fun <R> fold(initialValue: R, operation: (R, E) -> R): Val<R> =
FoldedVal(this, initialValue, operation)
}

6
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/ListValCreation.kt Normal file
View File

@ -0,0 +1,6 @@
package world.phantasmal.observable.value.list
fun <E> mutableListVal(
elements: MutableList<E> = mutableListOf(),
extractObservables: ObservablesExtractor<E>? = null
): MutableListVal<E> = SimpleListVal(elements, extractObservables)

16
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/ListValObserver.kt Normal file
View File

@ -0,0 +1,16 @@
package world.phantasmal.observable.value.list
sealed class ListValChangeEvent<E> {
class Change<E>(
val index: Int,
val removed: List<E>,
val inserted: List<E>
) : ListValChangeEvent<E>()
class ElementChange<E>(
val index: Int,
val updated: List<E>
) : ListValChangeEvent<E>()
}
typealias ListValObserver<E> = (change: ListValChangeEvent<E>) -> Unit

8
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/MutableListVal.kt Normal file
View File

@ -0,0 +1,8 @@
package world.phantasmal.observable.value.list
import world.phantasmal.observable.value.MutableVal
import kotlin.reflect.KProperty
interface MutableListVal<E> : ListVal<E>, MutableVal<List<E>>, MutableList<E> {
override operator fun getValue(thisRef: Any?, property: KProperty<*>): MutableList<E> = this
}

212
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/SimpleListVal.kt Normal file
View File

@ -0,0 +1,212 @@
package world.phantasmal.observable.value.list
import mu.KotlinLogging
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.observable.Observable
import world.phantasmal.observable.Observer
import world.phantasmal.observable.value.*
typealias ObservablesExtractor<E> = (element: E) -> Array<Observable<*>>
class SimpleListVal<E>(
private val elements: MutableList<E>,
/**
* Extractor function called on each element in this list. Changes to the returned observables
* will be propagated via ElementChange events.
*/
private val extractObservables: ObservablesExtractor<E>? = null,
) : AbstractMutableList<E>(), MutableListVal<E> {
companion object {
private val logger = KotlinLogging.logger {}
}
override var value: List<E> = elements
set(value) {
val removed = ArrayList(elements)
elements.clear()
elements.addAll(value)
finalizeUpdate(
ListValChangeEvent.Change(
index = 0,
removed = removed,
inserted = value
)
)
}
private val mutableSizeVal: MutableVal<Int> = mutableVal(elements.size)
override val sizeVal: Val<Int> = mutableSizeVal
override val size: Int by sizeVal
/**
* Internal observers which observe observables related to this list's elements so that their
* changes can be propagated via ElementChange events.
*/
private val elementObservers = mutableListOf<ElementObserver>()
/**
* External list observers which are observing this list.
*/
private val listObservers = mutableListOf<ListValObserver<E>>()
/**
* External regular observers which are observing this list.
*/
private val observers = mutableListOf<ValObserver<List<E>>>()
override fun get(index: Int): E = elements[index]
override fun set(index: Int, element: E): E {
val removed = elements.set(index, element)
finalizeUpdate(ListValChangeEvent.Change(index, listOf(removed), listOf(element)))
return removed
}
override fun add(index: Int, element: E) {
elements.add(index, element)
finalizeUpdate(ListValChangeEvent.Change(index, emptyList(), listOf(element)))
}
override fun removeAt(index: Int): E {
val removed = elements.removeAt(index)
finalizeUpdate(ListValChangeEvent.Change(index, listOf(removed), emptyList()))
return removed
}
override fun observe(observer: Observer<List<E>>): Disposable =
observe(callNow = false, observer)
override fun observe(callNow: Boolean, observer: ValObserver<List<E>>): Disposable {
if (elementObservers.isEmpty() && extractObservables != null) {
replaceElementObservers(0, elementObservers.size, elements)
}
observers.add(observer)
if (callNow) {
observer(ValChangeEvent(value, value))
}
return disposable {
observers.remove(observer)
disposeElementObserversIfNecessary()
}
}
override fun observeList(observer: ListValObserver<E>): Disposable {
if (elementObservers.isEmpty() && extractObservables != null) {
replaceElementObservers(0, elementObservers.size, elements)
}
listObservers.add(observer)
return disposable {
listObservers.remove(observer)
disposeElementObserversIfNecessary()
}
}
/**
* Does the following in the given order:
* - Updates element observers
* - Emits size ValChangeEvent if necessary
* - Emits ListValChangeEvent
* - Emits ValChangeEvent
*/
private fun finalizeUpdate(event: ListValChangeEvent<E>) {
if (
(listObservers.isNotEmpty() || observers.isNotEmpty()) &&
extractObservables != null &&
event is ListValChangeEvent.Change
) {
replaceElementObservers(event.index, event.removed.size, event.inserted)
}
mutableSizeVal.value = elements.size
listObservers.forEach { observer: ListValObserver<E> ->
try {
observer(event)
} catch (e: Throwable) {
logger.error(e) { "List observer threw exception." }
}
}
val regularEvent = ValChangeEvent(value, value)
observers.forEach { observer: ValObserver<List<E>> ->
try {
observer(regularEvent)
} catch (e: Throwable) {
logger.error(e) { "Observer threw exception." }
}
}
}
private fun replaceElementObservers(from: Int, amountRemoved: Int, insertedElements: List<E>) {
for (i in 1..amountRemoved) {
elementObservers.removeAt(from).observers.forEach { observer ->
try {
observer.dispose()
} catch (e: Throwable) {
logger.error(e) { "Observer threw exception during disposal." }
}
}
}
var index = from
elementObservers.addAll(
from,
insertedElements.map { element ->
ElementObserver(
index++,
element,
extractObservables!!(element)
)
}
)
val shift = insertedElements.size - amountRemoved
while (index < elementObservers.size) {
elementObservers[index++].index += shift
}
}
private fun disposeElementObserversIfNecessary() {
if (listObservers.isEmpty() && observers.isEmpty()) {
elementObservers.forEach { elementObserver: ElementObserver ->
elementObserver.observers.forEach { observer ->
try {
observer.dispose()
} catch (e: Throwable) {
logger.error(e) { "Observer threw exception during disposal." }
}
}
}
elementObservers.clear()
}
}
private inner class ElementObserver(
var index: Int,
element: E,
observables: Array<Observable<*>>,
) {
val observers = Array(observables.size) {
observables[it].observe {
finalizeUpdate(
ListValChangeEvent.ElementChange(
index,
listOf(element)
)
)
}
}
}
}

14
observable/src/commonTest/kotlin/world/phantasmal/observable/SimpleEmitterTests.kt Normal file
View File

@ -0,0 +1,14 @@
package world.phantasmal.observable
import world.phantasmal.observable.test.TestSuite
import kotlin.test.Test
class SimpleEmitterTests : TestSuite() {
@Test
fun observable_tests() {
observableTests {
val observable = SimpleEmitter<Any>()
ObservableAndEmit(observable) { observable.emit(ChangeEvent(Any())) }
}
}
}

52
observable/src/commonTest/kotlin/world/phantasmal/observable/TestObservable.kt Normal file
View File

@ -0,0 +1,52 @@
package world.phantasmal.observable
// Test suite for all Observable implementations.
// These functions are called from type-specific unit tests.
import world.phantasmal.core.disposable.use
import kotlin.test.assertEquals
typealias ObservableAndEmit = Pair<Observable<*>, () -> Unit>
fun observableTests(create: () -> ObservableAndEmit) {
observableShouldCallObserversWhenEventsAreEmitted(create)
observableShouldNotCallObserversAfterTheyAreDisposed(create)
}
private fun observableShouldCallObserversWhenEventsAreEmitted(create: () -> ObservableAndEmit) {
val (observable, emit) = create()
val changes = mutableListOf<ChangeEvent<*>>()
observable.observe { c ->
changes.add(c)
}.use {
emit()
assertEquals(1, changes.size)
emit()
emit()
emit()
assertEquals(4, changes.size)
}
}
private fun observableShouldNotCallObserversAfterTheyAreDisposed(create: () -> ObservableAndEmit) {
val (observable, emit) = create()
val changes = mutableListOf<ChangeEvent<*>>()
observable.observe { c ->
changes.add(c)
}.use {
emit()
assertEquals(1, changes.size)
emit()
emit()
emit()
assertEquals(4, changes.size)
}
}

24
observable/src/commonTest/kotlin/world/phantasmal/observable/test/TestSuite.kt Normal file
View File

@ -0,0 +1,24 @@
package world.phantasmal.observable.test
import world.phantasmal.core.disposable.TrackedDisposable
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.assertEquals
abstract class TestSuite {
private var initialDisposableCount: Int = 0
@BeforeTest
fun before() {
initialDisposableCount = TrackedDisposable.disposableCount
}
@AfterTest
fun after() {
assertEquals(
initialDisposableCount,
TrackedDisposable.disposableCount,
"TrackedDisposables were leaked"
)
}
}

29
observable/src/commonTest/kotlin/world/phantasmal/observable/value/DelegatingValTests.kt Normal file
View File

@ -0,0 +1,29 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.observableTests
import world.phantasmal.observable.test.TestSuite
import kotlin.test.Test
class DelegatingValTests : TestSuite() {
@Test
fun observable_tests() {
observableTests(::create)
}
@Test
fun val_tests() {
valTests(::create, ::createBoolean)
}
private fun create(): ValAndEmit<*> {
var v = 0
val value = DelegatingVal({ v }, { v = it })
return ValAndEmit(value) { value.value += 2 }
}
private fun createBoolean(bool: Boolean): ValAndEmit<Boolean> {
var v = bool
val value = DelegatingVal({ v }, { v = it })
return ValAndEmit(value) { value.value = !value.value }
}
}

29
observable/src/commonTest/kotlin/world/phantasmal/observable/value/DependentValTests.kt Normal file
View File

@ -0,0 +1,29 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.observableTests
import world.phantasmal.observable.test.TestSuite
import kotlin.test.Test
class DependentValTests : TestSuite() {
@Test
fun observable_tests() {
observableTests(::create)
}
@Test
fun val_tests() {
valTests(::create, ::createBoolean)
}
private fun create(): ValAndEmit<*> {
val v = SimpleVal(0)
val value = DependentVal(listOf(v)) { 2 * v.value }
return ValAndEmit(value) { v.value += 2 }
}
private fun createBoolean(bool: Boolean): ValAndEmit<Boolean> {
val v = SimpleVal(bool)
val value = DependentVal(listOf(v)) { v.value }
return ValAndEmit(value) { v.value = !v.value }
}
}

27
observable/src/commonTest/kotlin/world/phantasmal/observable/value/SimpleValTests.kt Normal file
View File

@ -0,0 +1,27 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.observableTests
import world.phantasmal.observable.test.TestSuite
import kotlin.test.Test
class SimpleValTests : TestSuite() {
@Test
fun observable_tests() {
observableTests(::create)
}
@Test
fun val_tests() {
valTests(::create, ::createBoolean)
}
private fun create(): ValAndEmit<*> {
val value = SimpleVal(1)
return ValAndEmit(value) { value.value += 2 }
}
private fun createBoolean(bool: Boolean): ValAndEmit<Boolean> {
val value = SimpleVal(bool)
return ValAndEmit(value) { value.value = !value.value }
}
}

15
observable/src/commonTest/kotlin/world/phantasmal/observable/value/StaticValTests.kt Normal file
View File

@ -0,0 +1,15 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.test.TestSuite
import kotlin.test.Test
class StaticValTests : TestSuite() {
@Test
fun observing_StaticVal_should_never_create_leaks() {
val static = StaticVal("test value")
static.observe {}
static.observe(callNow = false) {}
static.observe(callNow = true) {}
}
}

76
observable/src/commonTest/kotlin/world/phantasmal/observable/value/TestVal.kt Normal file
View File

@ -0,0 +1,76 @@
package world.phantasmal.observable.value
// Test suite for all Val implementations.
// These functions are called from type-specific unit tests.
import world.phantasmal.core.disposable.use
import world.phantasmal.observable.ChangeEvent
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
typealias ValAndEmit<T> = Pair<Val<T>, () -> Unit>
fun valTests(
create: () -> ValAndEmit<*>,
createBoolean: ((Boolean) -> ValAndEmit<Boolean>)?,
) {
valShouldRespectCallNowArgument(create)
if (createBoolean != null) {
testValBooleanExtensions(createBoolean)
}
}
/**
* When Val::observe is called with callNow = true, it should call the observer immediately.
* Otherwise it should only call the observer when it changes.
*/
private fun valShouldRespectCallNowArgument(create: () -> ValAndEmit<*>) {
val (value, emit) = create()
val changes = mutableListOf<ChangeEvent<*>>()
// Test callNow = true
value.observe(callNow = false) { c ->
changes.add(c)
}.use {
emit()
assertEquals(1, changes.size)
}
// Test callNow = false
changes.clear()
value.observe(callNow = true) { c ->
changes.add(c)
}.use {
emit()
assertEquals(2, changes.size)
}
}
private fun testValBooleanExtensions(create: (Boolean) -> ValAndEmit<Boolean>) {
listOf(true, false).forEach { bool ->
val (value) = create(bool)
// Test the test setup first.
assertEquals(bool, value.value)
// Test `and`.
assertEquals(bool, (value and trueVal()).value)
assertFalse((value and falseVal()).value)
// Test `or`.
assertTrue((value or trueVal()).value)
assertEquals(bool, (value or falseVal()).value)
// Test `xor`.
assertEquals(!bool, (value xor trueVal()).value)
assertEquals(bool, (value xor falseVal()).value)
// Test `!` (unary not).
assertEquals(!bool, (!value).value)
}
}

49
observable/src/commonTest/kotlin/world/phantasmal/observable/value/ValCreationTests.kt Normal file
View File

@ -0,0 +1,49 @@
package world.phantasmal.observable.value
import world.phantasmal.observable.test.TestSuite
import kotlin.test.*
class ValCreationTests : TestSuite() {
@Test
fun test_value() {
assertEquals(7, value(7).value)
}
@Test
fun test_trueVal() {
assertTrue(trueVal().value)
}
@Test
fun test_falseVal() {
assertFalse(falseVal().value)
}
@Test
fun test_nullVal() {
assertNull(nullVal().value)
}
@Test
fun test_mutableVal_with_initial_value() {
val v = mutableVal(17)
assertEquals(17, v.value)
v.value = 201
assertEquals(201, v.value)
}
@Test
fun test_mutableVal_with_getter_and_setter() {
var x = 17
val v = mutableVal({ x }, { x = it })
assertEquals(17, v.value)
v.value = 201
assertEquals(201, v.value)
}
}

28
observable/src/commonTest/kotlin/world/phantasmal/observable/value/list/SimpleListValTests.kt Normal file
View File

@ -0,0 +1,28 @@
package world.phantasmal.observable.value.list
import world.phantasmal.observable.observableTests
import world.phantasmal.observable.test.TestSuite
import world.phantasmal.observable.value.valTests
import kotlin.test.Test
class SimpleListValTests : TestSuite() {
@Test
fun observable_tests() {
observableTests(::create)
}
@Test
fun val_tests() {
valTests(::create, createBoolean = null)
}
@Test
fun list_val_tests() {
listValTests(::create)
}
private fun create(): ListValAndAdd {
val value = SimpleListVal(mutableListOf<Int>())
return ListValAndAdd(value) { value.add(7) }
}
}

30
observable/src/commonTest/kotlin/world/phantasmal/observable/value/list/TestListVal.kt Normal file
View File

@ -0,0 +1,30 @@
package world.phantasmal.observable.value.list
// Test suite for all ListVal implementations.
// These functions are called from type-specific unit tests.
import world.phantasmal.core.disposable.use
import kotlin.test.assertEquals
typealias ListValAndAdd = Pair<ListVal<*>, () -> Unit>
fun listValTests(create: () -> ListValAndAdd) {
listValShouldUpdateSizeValCorrectly(create)
}
private fun listValShouldUpdateSizeValCorrectly(create: () -> ListValAndAdd) {
val (list: List<*>, add) = create()
assertEquals(0, list.sizeVal.value)
var observedSize = 0
list.sizeVal.observe { observedSize = it.value }.use {
for (i in 1..3) {
add()
assertEquals(i, list.sizeVal.value)
assertEquals(i, observedSize)
}
}
}

76
package.json
View File

@ -1,76 +0,0 @@
{
"name": "phantasmal-world",
"version": "0.1.0",
"private": true,
"license": "MIT",
"dependencies": {
"camera-controls": "^1.22.1",
"core-js": "^3.6.5",
"golden-layout": "^1.5.9",
"javascript-lp-solver": "0.4.17",
"lodash": "^4.17.19",
"luxon": "^1.24.1",
"monaco-editor": "^0.20.0",
"three": "^0.118.3"
},
"optionalDependencies": {
"prs-rs": "file:src/core/data_formats/compression/prs/pkg"
},
"scripts": {
"start": "webpack-dev-server --config webpack.dev.js",
"check": "yarn lint && yarn check_formatting",
"lint": "echo 'Linting...' && eslint \"{src,assets_generation,test}/**/*.{ts,tsx}\" && echo 'No linting issues.'",
"check_formatting": "prettier --check \"{src,assets_generation,test}/**/*.{ts,tsx}\"",
"test": "jest",
"build": "yarn build_bundle",
"build_bundle": "webpack --config webpack.prod.js",
"build_prs_rs": "wasm-pack build src/core/data_formats/compression/prs",
"build_prs_rs_browser": "yarn build_prs_rs -t bundler && yarn upgrade prs-rs",
"build_prs_rs_testing": "yarn build_prs_rs -t nodejs -d 'test/pkg'",
"update_generic_data": "ts-node --project=tsconfig-scripts.json assets_generation/update_generic_data.ts",
"update_ephinea_data": "ts-node --project=tsconfig-scripts.json assets_generation/update_ephinea_data.ts",
"quest_stats": "ts-node --project=tsconfig-scripts.json assets_generation/quest_stats.ts"
},
"devDependencies": {
"@fortawesome/fontawesome-free": "^5.13.1",
"@types/cheerio": "^0.22.21",
"@types/jest": "^26.0.4",
"@types/lodash": "^4.14.157",
"@types/luxon": "^1.24.1",
"@types/node-fetch": "^2.5.7",
"@typescript-eslint/eslint-plugin": "^4.2.0",
"@typescript-eslint/parser": "^4.2.0",
"cheerio": "^1.0.0-rc.3",
"clean-webpack-plugin": "^3.0.0",
"copy-webpack-plugin": "^6.0.3",
"css-loader": "^3.6.0",
"dotenv": "^8.2.0",
"dotenv-webpack": "^2.0.0",
"eslint": "^7.9.0",
"eslint-config-prettier": "^6.12.0",
"eslint-plugin-prettier": "^3.1.4",
"file-loader": "^6.0.0",
"fork-ts-checker-webpack-plugin": "^5.2.0",
"html-webpack-plugin": "^4.3.0",
"jest": "^26.4.2",
"jest-canvas-mock": "^2.2.0",
"jquery": "^3.5.1",
"mini-css-extract-plugin": "^0.9.0",
"monaco-editor-webpack-plugin": "^1.9.0",
"node-fetch": "^2.6.0",
"optimize-css-assets-webpack-plugin": "^5.0.3",
"pnp-webpack-plugin": "^1.6.4",
"prettier": "^2.0.5",
"terser-webpack-plugin": "^2.3.7",
"ts-jest": "^26.4.0",
"ts-loader": "^8.0.4",
"ts-node": "^9.0.0",
"typescript": "^4.0.3",
"webpack": "^4.43.0",
"webpack-cli": "^3.3.12",
"webpack-dev-server": "^3.11.0",
"webpack-merge": "^5.0.9",
"worker-loader": "^2.0.0",
"yaml": "^1.10.0"
}
}

3
settings.gradle.kts Normal file
View File

@ -0,0 +1,3 @@
rootProject.name = "phantasmal-world"
include("core", "lib", "observable", "web", "webui")

91
src/__mocks__/monaco-editor.js
View File

@ -1,91 +0,0 @@
/* eslint-disable @typescript-eslint/no-empty-function,@typescript-eslint/explicit-function-return-type */
class Editor {
addCommand() {}
getAction() {}
addAction() {
return { dispose() {} };
}
trigger() {}
updateOptions() {}
setModel() {}
setPosition() {}
getLineDecorations() {}
deltaDecorations() {}
revealLineInCenterIfOutsideViewport() {}
revealPositionInCenterIfOutsideViewport() {}
onDidFocusEditorWidget() {
return { dispose() {} };
}
onMouseDown() {
return { dispose() {} };
}
onMouseUp() {
return { dispose() {} };
}
focus() {}
layout() {}
onDidChangeCursorPosition() {
return { dispose() {} };
}
dispose() {}
}
exports.editor = {
defineTheme() {},
createModel() {},
create() {
return new Editor();
},
};
exports.languages = {
CompletionItemKind: {
Method: 0,
Function: 1,
Constructor: 2,
Field: 3,
Variable: 4,
Class: 5,
Struct: 6,
Interface: 7,
Module: 8,
Property: 9,
Event: 10,
Operator: 11,
Unit: 12,
Value: 13,
Constant: 14,
Enum: 15,
EnumMember: 16,
Keyword: 17,
Text: 18,
Color: 19,
File: 20,
Reference: 21,
Customcolor: 22,
Folder: 23,
TypeParameter: 24,
Snippet: 25,
},
register() {},
setMonarchTokensProvider() {},
registerCompletionItemProvider() {},
registerSignatureHelpProvider() {},
setLanguageConfiguration() {},
registerDefinitionProvider() {},
registerHoverProvider() {},
};
exports.KeyMod = {
CtrlCmd: 0,
Shift: 1,
Alt: 2,
WinCtrl: 3,
};
exports.KeyCode = {
LeftArrow: 15,
UpArrow: 16,
RightArrow: 17,
DownArrow: 18,
};

1
src/__mocks__/static_files.js
View File

@ -1 +0,0 @@
module.exports = {};

6
src/__mocks__/webworkers.js
View File

@ -1,6 +0,0 @@
class Worker {
onmessage() {}
postMessage() {}
}
module.exports = Worker;

20
src/application/controllers/NavigationController.test.ts
View File

@ -1,20 +0,0 @@
import { NavigationController } from "./NavigationController";
import { GuiStore } from "../../core/stores/GuiStore";
import { StubClock } from "../../../test/src/core/StubClock";
test("Internet time should be calculated correctly.", () => {
for (const [time, beats] of [
["00:00:00", 41],
["13:10:12", 590],
["22:59:59", 999],
["23:00:00", 0],
["23:59:59", 41],
]) {
const ctrl = new NavigationController(
new GuiStore(),
new StubClock(new Date(`2020-01-01T${time}Z`)),
);
expect(ctrl.internet_time.val).toBe(`@${beats}`);
}
});

38
src/application/controllers/NavigationController.ts
View File

@ -1,38 +0,0 @@
import { Controller } from "../../core/controllers/Controller";
import { Property } from "../../core/observable/property/Property";
import { GuiStore, GuiTool } from "../../core/stores/GuiStore";
import { property } from "../../core/observable";
import { Clock } from "../../core/Clock";
export class NavigationController extends Controller {
private readonly _internet_time = property("@");
private readonly internet_time_interval: any;
readonly tool: Property<GuiTool>;
readonly internet_time: Property<string> = this._internet_time;
constructor(private readonly gui_store: GuiStore, private readonly clock: Clock) {
super();
this.tool = gui_store.tool;
this.internet_time_interval = setInterval(this.set_internet_time, 1000);
this.set_internet_time();
}
dispose(): void {
super.dispose();
clearInterval(this.internet_time_interval);
}
set_tool(tool: GuiTool): void {
this.gui_store.set_tool(tool);
}
private set_internet_time = (): void => {
const now = this.clock.now();
const s = now.getUTCSeconds();
const m = now.getUTCMinutes();
const h = (now.getUTCHours() + 1) % 24; // Internet time is calculated from UTC+01:00.
this._internet_time.val = `@${Math.floor((s + 60 * (m + 60 * h)) / 86.4)}`;
};
}

5
src/application/gui/ApplicationView.css
View File

@ -1,5 +0,0 @@
.application_ApplicationView {
position: fixed;
top: 0;
left: 0;
}

37
src/application/gui/ApplicationView.ts
View File

@ -1,37 +0,0 @@
import { NavigationView } from "./NavigationView";
import { MainContentView } from "./MainContentView";
import { div } from "../../core/gui/dom";
import "./ApplicationView.css";
import { ResizableView } from "../../core/gui/ResizableView";
/**
* The top-level view which contains all other views.
*/
export class ApplicationView extends ResizableView {
readonly element: HTMLElement;
constructor(
private readonly navigation_view: NavigationView,
private readonly main_content_view: MainContentView,
) {
super();
this.element = div(
{ className: "application_ApplicationView" },
this.navigation_view.element,
this.main_content_view.element,
);
this.element.id = "root";
this.add(navigation_view);
this.add(main_content_view);
this.finalize_construction(ApplicationView);
}
resize(width: number, height: number): this {
super.resize(width, height);
this.main_content_view.resize(width, height - this.navigation_view.height);
return this;
}
}

55
src/application/gui/MainContentView.ts
View File

@ -1,55 +0,0 @@
import { GuiStore, GuiTool } from "../../core/stores/GuiStore";
import { LazyWidget } from "../../core/gui/LazyWidget";
import { div } from "../../core/gui/dom";
import { ResizableView } from "../../core/gui/ResizableView";
import { Widget } from "../../core/gui/Widget";
import { Resizable } from "../../core/gui/Resizable";
export class MainContentView extends ResizableView {
private tool_views: Map<GuiTool, LazyWidget>;
private current_tool_view?: LazyWidget;
readonly element = div({ className: "application_MainContentView" });
constructor(gui_store: GuiStore, tool_views: [GuiTool, () => Promise<Widget & Resizable>][]) {
super();
this.tool_views = new Map(
tool_views.map(([tool, create_view]) => [tool, this.add(new LazyWidget(create_view))]),
);
for (const tool_view of this.tool_views.values()) {
this.element.append(tool_view.element);
}
this.disposables(
gui_store.tool.observe(({ value }) => this.set_current_tool(value), { call_now: true }),
);
this.finalize_construction(MainContentView);
}
resize(width: number, height: number): this {
super.resize(width, height);
for (const tool_view of this.tool_views.values()) {
tool_view.resize(width, height);
}
return this;
}
private set_current_tool(tool: GuiTool): void {
if (this.current_tool_view) {
this.current_tool_view.visible.val = false;
this.current_tool_view.deactivate();
}
this.current_tool_view = this.tool_views.get(tool);
if (this.current_tool_view) {
this.current_tool_view.visible.val = true;
this.current_tool_view.activate();
}
}
}

24
src/application/gui/NavigationButton.css
View File

@ -1,24 +0,0 @@
.application_NavigationButton input {
display: none;
}
.application_NavigationButton label {
box-sizing: border-box;
display: inline-flex;
flex-direction: row;
align-items: center;
font-size: 13px;
height: 100%;
padding: 0 20px;
color: hsl(0, 0%, 65%);
}
.application_NavigationButton label:hover {
color: hsl(0, 0%, 85%);
background-color: hsl(0, 0%, 12%);
}
.application_NavigationButton input:checked + label {
color: hsl(0, 0%, 85%);
background-color: var(--bg-color);
}

33
src/application/gui/NavigationButton.ts
View File

@ -1,33 +0,0 @@
import { GuiTool } from "../../core/stores/GuiStore";
import "./NavigationButton.css";
import { input, label, span } from "../../core/gui/dom";
import { Control } from "../../core/gui/Control";
export class NavigationButton extends Control {
readonly element = span({ className: "application_NavigationButton" });
private input: HTMLInputElement = input();
private label: HTMLLabelElement = label();
constructor(tool: GuiTool, text: string) {
super();
const tool_str = GuiTool[tool];
this.input.type = "radio";
this.input.name = "application_NavigationButton";
this.input.value = tool_str;
this.input.id = `application_NavigationButton_${tool_str}`;
this.label.append(text);
this.label.htmlFor = `application_NavigationButton_${tool_str}`;
this.element.append(this.input, this.label);
this.finalize_construction(NavigationButton);
}
set checked(checked: boolean) {
this.input.checked = checked;
}
}

40
src/application/gui/NavigationView.css
View File

@ -1,40 +0,0 @@
.application_NavigationView {
box-sizing: border-box;
display: flex;
flex-direction: row;
align-items: stretch;
background-color: hsl(0, 0%, 10%);
border-bottom: solid 2px var(--bg-color);
}
.application_NavigationView_spacer {
flex: 1;
}
.application_NavigationView_server {
display: flex;
align-items: center;
}
.application_NavigationView_server > * {
margin: 0 2px;
}
.application_NavigationView_time {
display: flex;
align-items: center;
}
.application_NavigationView_github {
display: flex;
flex-direction: row;
align-items: center;
justify-content: center;
width: 30px;
font-size: 16px;
color: var(--control-text-color);
}
.application_NavigationView_github:hover {
color: var(--control-text-color-hover);
}

14
src/application/gui/NavigationView.test.ts
View File

@ -1,14 +0,0 @@
import { NavigationView } from "./NavigationView";
import { NavigationController } from "../controllers/NavigationController";
import { GuiStore } from "../../core/stores/GuiStore";
import { StubClock } from "../../../test/src/core/StubClock";
test("Should render correctly.", () => {
const view = new NavigationView(
new NavigationController(new GuiStore(), new StubClock(new Date("2020-01-01T00:30:01Z"))),
);
expect(view.element).toMatchSnapshot(
"It should render a button per tool, the selected server, internet time and a github link icon.",
);
});

88
src/application/gui/NavigationView.ts
View File

@ -1,88 +0,0 @@
import { a, div, icon, Icon, span } from "../../core/gui/dom";
import "./NavigationView.css";
import { GuiTool } from "../../core/stores/GuiStore";
import { NavigationButton } from "./NavigationButton";
import { Select } from "../../core/gui/Select";
import { View } from "../../core/gui/View";
import { NavigationController } from "../controllers/NavigationController";
const TOOLS: [GuiTool, string][] = [
[GuiTool.Viewer, "Viewer"],
[GuiTool.QuestEditor, "Quest Editor"],
[GuiTool.HuntOptimizer, "Hunt Optimizer"],
];
export class NavigationView extends View {
private readonly buttons = new Map<GuiTool, NavigationButton>(
TOOLS.map(([value, text]) => [value, this.add(new NavigationButton(value, text))]),
);
private readonly server_select = this.add(
new Select({
label: "Server:",
items: ["Ephinea"],
to_label: server => server,
enabled: false,
selected: "Ephinea",
tooltip: "Only Ephinea is supported at the moment",
}),
);
private readonly time_element = span({
className: "application_NavigationView_time",
title: "Internet time in beats",
});
readonly element = div(
{ className: "application_NavigationView" },
...[...this.buttons.values()].map(button => button.element),
div({ className: "application_NavigationView_spacer" }),
span(
{ className: "application_NavigationView_server" },
this.server_select.label!.element,
this.server_select.element,
),
this.time_element,
a(
{
className: "application_NavigationView_github",
href: "https://github.com/DaanVandenBosch/phantasmal-world",
title: "Phantasmal World is open source, code available on GitHub",
},
icon(Icon.GitHub),
),
);
readonly height = 30;
constructor(private readonly ctrl: NavigationController) {
super();
this.element.style.height = `${this.height}px`;
this.element.addEventListener("mousedown", this.mousedown);
this.disposables(
ctrl.tool.observe(({ value }) => this.mark_tool_button(value), { call_now: true }),
ctrl.internet_time.observe(({ value }) => (this.time_element.textContent = value), {
call_now: true,
}),
);
this.finalize_construction(NavigationView);
}
private mousedown = (e: MouseEvent): void => {
if (e.target instanceof HTMLLabelElement && e.target.control instanceof HTMLInputElement) {
this.ctrl.set_tool((GuiTool as any)[e.target.control.value]);
}
};
private mark_tool_button = (tool: GuiTool): void => {
const button = this.buttons.get(tool);
if (button) button.checked = true;
};
}

131
src/application/gui/__snapshots__/NavigationView.test.ts.snap
View File

@ -1,131 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`Should render correctly.: It should render a button per tool, the selected server, internet time and a github link icon. 1`] = `
<div
class="application_NavigationView"
style="height: 30px;"
>
<span
class="application_NavigationButton"
>
<input
id="application_NavigationButton_Viewer"
name="application_NavigationButton"
type="radio"
value="Viewer"
/>
<label
for="application_NavigationButton_Viewer"
>
Viewer
</label>
</span>
<span
class="application_NavigationButton"
>
<input
id="application_NavigationButton_QuestEditor"
name="application_NavigationButton"
type="radio"
value="QuestEditor"
/>
<label
for="application_NavigationButton_QuestEditor"
>
Quest Editor
</label>
</span>
<span
class="application_NavigationButton"
>
<input
id="application_NavigationButton_HuntOptimizer"
name="application_NavigationButton"
type="radio"
value="HuntOptimizer"
/>
<label
for="application_NavigationButton_HuntOptimizer"
>
Hunt Optimizer
</label>
</span>
<div
class="application_NavigationView_spacer"
/>
<span
class="application_NavigationView_server"
>
<label
class="core_Label disabled"
for="core_LabelledControl_id_0"
title="Only Ephinea is supported at the moment"
>
Server:
</label>
<div
class="core_Select disabled"
id="core_LabelledControl_id_0"
title="Only Ephinea is supported at the moment"
>
<button
class="core_Button disabled"
disabled=""
>
<span
class="core_Button_inner"
>
<span
class="core_Button_center"
>
Ephinea
</span>
<span
class="core_Button_right"
>
<span>
<span
class="fas fa-caret-down"
/>
</span>
</span>
</span>
</button>
<div
class="core_Menu disabled"
hidden=""
tabindex="-1"
>
<div
class="core_Menu_inner"
>
<div
data-index="0"
>
Ephinea
</div>
</div>
</div>
</div>
</span>
<span
class="application_NavigationView_time"
title="Internet time in beats"
>
@62
</span>
<a
class="application_NavigationView_github"
href="https://github.com/DaanVandenBosch/phantasmal-world"
rel="noopener noreferrer"
target="_blank"
title="Phantasmal World is open source, code available on GitHub"
>
<span>
<span
class="fab fa-github"
/>
</span>
</a>
</div>
`;

33
src/application/index.test.ts
View File

@ -1,33 +0,0 @@
import { initialize_application } from "./index";
import { FileSystemHttpClient } from "../../test/src/core/FileSystemHttpClient";
import { pw_test, timeout } from "../../test/src/utils";
import { Random } from "../core/Random";
import { Severity } from "../core/Severity";
import { StubClock } from "../../test/src/core/StubClock";
import { STUB_RENDERER } from "../../test/src/core/rendering/StubRenderer";
for (const path of [undefined, "/viewer", "/quest_editor", "/hunt_optimizer"]) {
const with_path = path == undefined ? "without specific path" : `with path ${path}`;
test(
`Initialization and shutdown ${with_path} should succeed without throwing or logging errors.`,
pw_test({ max_log_severity: Severity.Warning }, async disposer => {
if (path != undefined) {
window.location.hash = path;
}
const app = disposer.add(
initialize_application(
new FileSystemHttpClient(),
new Random(() => 0.27),
new StubClock(new Date("2020-01-01T15:40:20Z")),
() => STUB_RENDERER,
),
);
expect(app).toBeDefined();
await timeout(1000);
}),
);
}

152
src/application/index.ts
View File

@ -1,152 +0,0 @@
import { HttpClient } from "../core/HttpClient";
import { Disposable } from "../core/observable/Disposable";
import { GuiStore, GuiTool } from "../core/stores/GuiStore";
import { create_item_type_stores } from "../core/stores/ItemTypeStore";
import { create_item_drop_stores } from "../hunt_optimizer/stores/ItemDropStore";
import { ApplicationView } from "./gui/ApplicationView";
import { throttle } from "lodash";
import { DisposableThreeRenderer } from "../core/rendering/Renderer";
import { Disposer } from "../core/observable/Disposer";
import { disposable_custom_listener, disposable_listener } from "../core/gui/dom";
import { Random } from "../core/Random";
import { NavigationController } from "./controllers/NavigationController";
import { NavigationView } from "./gui/NavigationView";
import { MainContentView } from "./gui/MainContentView";
import { Clock } from "../core/Clock";
export function initialize_application(
http_client: HttpClient,
random: Random,
clock: Clock,
create_three_renderer: () => DisposableThreeRenderer,
): Disposable {
const disposer = new Disposer();
// Disable native undo/redo.
disposer.add(disposable_custom_listener(document, "beforeinput", before_input));
// Work-around for FireFox:
disposer.add(disposable_listener(document, "keydown", keydown));
// Disable native drag-and-drop to avoid users dragging in unsupported file formats and leaving
// the application unexpectedly.
disposer.add_all(
disposable_listener(document, "dragenter", dragenter),
disposable_listener(document, "dragover", dragover),
disposable_listener(document, "drop", drop),
);
// Initialize core stores shared by several submodules.
const gui_store = disposer.add(new GuiStore());
const item_type_stores = disposer.add(create_item_type_stores(http_client, gui_store));
const item_drop_stores = disposer.add(
create_item_drop_stores(http_client, gui_store, item_type_stores),
);
// Controllers.
const navigation_controller = disposer.add(new NavigationController(gui_store, clock));
// Initialize application view.
const application_view = disposer.add(
new ApplicationView(
new NavigationView(navigation_controller),
new MainContentView(gui_store, [
[
GuiTool.Viewer,
async () => {
const { initialize_viewer } = await import("../viewer");
const viewer = disposer.add(
initialize_viewer(
http_client,
random,
gui_store,
create_three_renderer,
),
);
return viewer.view;
},
],
[
GuiTool.QuestEditor,
async () => {
const { initialize_quest_editor } = await import("../quest_editor");
const quest_editor = disposer.add(
initialize_quest_editor(http_client, gui_store, create_three_renderer),
);
return quest_editor.view;
},
],
[
GuiTool.HuntOptimizer,
async () => {
const { initialize_hunt_optimizer } = await import("../hunt_optimizer");
const hunt_optimizer = disposer.add(
initialize_hunt_optimizer(
http_client,
gui_store,
item_type_stores,
item_drop_stores,
),
);
return hunt_optimizer.view;
},
],
]),
),
);
// Resize the view on window resize.
const resize = throttle(
() => {
application_view.resize(window.innerWidth, window.innerHeight);
},
100,
{ leading: true, trailing: true },
);
resize();
document.body.append(application_view.element);
application_view.activate();
disposer.add(disposable_listener(window, "resize", resize));
return {
dispose(): void {
disposer.dispose();
},
};
}
function before_input(e: Event): void {
const ie = e as any;
if (ie.inputType === "historyUndo" || ie.inputType === "historyRedo") {
e.preventDefault();
}
}
function keydown(e: Event): void {
const kbe = e as KeyboardEvent;
if (kbe.ctrlKey && !kbe.altKey && kbe.key.toUpperCase() === "Z") {
kbe.preventDefault();
}
}
function dragenter(e: DragEvent): void {
e.preventDefault();
if (e.dataTransfer) {
e.dataTransfer.dropEffect = "none";
}
}
function dragover(e: DragEvent): void {
dragenter(e);
}
function drop(e: DragEvent): void {
dragenter(e);
}

9
src/core/Clock.ts
View File

@ -1,9 +0,0 @@
export interface Clock {
now(): Date;
}
export class DateClock implements Clock {
now(): Date {
return new Date();
}
}

73
src/core/DisposablePromise.test.ts
View File

@ -1,73 +0,0 @@
import { DisposablePromise } from "./DisposablePromise";
import { timeout } from "../../test/src/utils";
test("It should resolve correctly.", () => {
return new DisposablePromise((resolve, reject) => {
resolve(700);
resolve(800);
reject(new Error());
resolve(900);
reject(new Error());
}).then(
x => {
expect(x).toBe(700);
},
() => {
throw new Error("Should never be called.");
},
);
});
test("It should reject correctly.", () => {
return new DisposablePromise((resolve, reject) => {
reject(new Error("ERROR"));
resolve(700);
resolve(800);
reject(new Error());
resolve(900);
reject(new Error());
}).then(
() => {
throw new Error("Should never be called.");
},
err => {
expect((err as Error).message).toBe("ERROR");
},
);
});
test("It should dispose correctly.", async () => {
let resolve: (value: number) => void;
let value = 7;
let cancel_called = false;
const promise = new DisposablePromise<number>(
r => {
resolve = r;
},
() => {
cancel_called = true;
},
);
await timeout(0);
promise.dispose();
expect(cancel_called).toBe(true);
resolve!(13);
promise.then(
v => {
value = v;
},
() => {
throw new Error("Should never be called.");
},
);
await timeout(0);
expect(value).toBe(7);
});

253
src/core/DisposablePromise.ts
View File

@ -1,253 +0,0 @@
import { Disposable } from "./observable/Disposable";
import { is_promise_like } from "./util";
enum State {
Pending,
Fulfilled,
Rejected,
Disposed,
}
export class DisposablePromise<T> implements Promise<T>, Disposable {
static all<T>(values: Iterable<T | PromiseLike<T>>): DisposablePromise<T[]> {
return new DisposablePromise(
(resolve, reject) => {
const results: T[] = [];
let len = 0;
function add_result(r: T): void {
results.push(r);
if (results.length === len) {
resolve(results);
}
}
for (const value of values) {
len++;
if (is_promise_like(value)) {
value.then(add_result, reject);
} else {
add_result(value);
}
}
},
() => {
for (const value of values) {
if (value instanceof DisposablePromise) {
value.dispose();
}
}
},
);
}
static resolve<T>(value: T | PromiseLike<T>, dispose?: () => void): DisposablePromise<T> {
if (is_promise_like(value)) {
return new DisposablePromise((resolve, reject) => {
value.then(resolve, reject);
}, dispose);
} else {
return new DisposablePromise(resolve => {
resolve(value);
}, dispose);
}
}
private state: State = State.Pending;
private value?: T;
private reason?: any;
private readonly fulfillment_listeners: ((value: T) => unknown)[] = [];
private readonly rejection_listeners: ((reason: any) => unknown)[] = [];
private readonly disposal_handler?: () => void;
[Symbol.toStringTag] = "DisposablePromise";
constructor(
executor: (
resolve: (value: T | PromiseLike<T>) => void,
reject: (reason?: any) => void,
) => void,
dispose?: () => void,
) {
this.disposal_handler = dispose;
executor(this.executor_resolve, this.executor_reject);
}
private executor_resolve = (value: T | PromiseLike<T>): void => {
if (is_promise_like(value)) {
if (this.state !== State.Pending) return;
value.then(
p_value => {
this.fulfilled(p_value);
},
p_reason => {
this.rejected(p_reason);
},
);
} else {
this.fulfilled(value);
}
};
private executor_reject = (reason?: any): void => {
this.rejected(reason);
};
private fulfilled(value: T): void {
if (this.state !== State.Pending) return;
this.state = State.Fulfilled;
this.value = value;
for (const listener of this.fulfillment_listeners) {
listener(value);
}
this.fulfillment_listeners.splice(0);
this.rejection_listeners.splice(0);
}
private rejected(reason?: any): void {
if (this.state !== State.Pending) return;
this.state = State.Rejected;
this.reason = reason;
for (const listener of this.rejection_listeners) {
listener(reason);
}
this.fulfillment_listeners.splice(0);
this.rejection_listeners.splice(0);
}
then<TResult1 = T, TResult2 = never>(
onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
): DisposablePromise<TResult1 | TResult2> {
return new DisposablePromise(
(resolve, reject) => {
if (onfulfilled == undefined) {
this.add_fulfillment_listener(resolve as any);
} else {
this.add_fulfillment_listener(value => {
try {
resolve(onfulfilled(value));
} catch (e) {
reject(e);
}
});
}
if (onrejected == undefined) {
this.add_rejection_listener(reject);
} else {
this.add_rejection_listener(reason => {
try {
resolve(onrejected(reason));
} catch (e) {
reject(e);
}
});
}
},
() => this.dispose(),
);
}
catch<TResult = never>(
onrejected?: ((reason: any) => PromiseLike<TResult> | TResult) | undefined | null,
): DisposablePromise<T | TResult> {
return new DisposablePromise(
(resolve, reject) => {
this.add_fulfillment_listener(resolve as any);
if (onrejected == undefined) {
this.add_rejection_listener(reject);
} else {
this.add_rejection_listener(reason => {
try {
resolve(onrejected(reason));
} catch (e) {
reject(e);
}
});
}
},
() => this.dispose(),
);
}
finally(onfinally?: (() => void) | undefined | null): DisposablePromise<T> {
if (onfinally == undefined) {
return this;
} else {
return new DisposablePromise(
(resolve, reject) => {
this.add_fulfillment_listener(value => {
try {
onfinally();
resolve(value);
} catch (e) {
reject(e);
}
});
this.add_rejection_listener(value => {
try {
onfinally();
reject(value);
} catch (e) {
reject(e);
}
});
},
() => this.dispose(),
);
}
}
/**
* Cancels the promise. After calling this method, any then, catch or finally handlers will not
* be called.
*/
dispose(): void {
if (this.state !== State.Disposed) {
this.state = State.Disposed;
this.disposal_handler?.();
}
}
private add_fulfillment_listener(listener: (value: T) => unknown): void {
switch (this.state) {
case State.Pending:
this.fulfillment_listeners.push(listener);
break;
case State.Fulfilled:
listener(this.value!);
break;
case State.Rejected:
case State.Disposed:
break;
}
}
private add_rejection_listener(listener: (reason: any) => unknown): void {
switch (this.state) {
case State.Pending:
this.rejection_listeners.push(listener);
break;
case State.Rejected:
listener(this.reason);
break;
case State.Fulfilled:
case State.Disposed:
break;
}
}
}

69
src/core/HttpClient.ts
View File

@ -1,69 +0,0 @@
import { DisposablePromise } from "./DisposablePromise";
export interface HttpClient {
get(url: string): HttpResponse;
}
export interface HttpResponse {
json<T>(): DisposablePromise<T>;
array_buffer(): DisposablePromise<ArrayBuffer>;
}
/**
* This client uses {@link fetch}.
*/
export class FetchClient implements HttpClient {
get(url: string): HttpResponse {
const aborter = new AbortController();
const response = fetch(process.env.PUBLIC_URL + url, { signal: aborter.signal });
return {
json<T>(): DisposablePromise<T> {
return new DisposablePromise(
(resolve, reject) => {
response
.then(r => r.json())
.then(
json => resolve(json),
error => reject(error),
);
},
() => aborter.abort(),
);
},
array_buffer(): DisposablePromise<ArrayBuffer> {
return new DisposablePromise(
(resolve, reject) => {
response
.then(r => r.arrayBuffer())
.then(
buf => resolve(buf),
error => reject(error),
);
},
() => aborter.abort(),
);
},
};
}
}
/**
* This client simple throws an error when used.
*/
export class StubHttpClient implements HttpClient {
get(url: string): HttpResponse {
return {
json<T>(): DisposablePromise<T> {
throw new Error(`Stub client's json method invoked for get request to "${url}".`);
},
array_buffer(): DisposablePromise<ArrayBuffer> {
throw new Error(
`Stub client's array_buffer method invoked for get request to "${url}".`,
);
},
};
}
}

18
src/core/Random.ts
View File

@ -1,18 +0,0 @@
export class Random {
constructor(private readonly random_number: () => number = Math.random) {}
/**
* @param min - The minimum value, inclusive.
* @param max - The maximum value, exclusive.
* @returns A random integer between `min` and `max`.
*/
integer(min: number, max: number): number {
return min + Math.floor(this.random_number() * (max - min));
}
/**
* @returns A random element from `array`.
*/
sample_array<T>(array: readonly T[]): T {
return array[this.integer(0, array.length)];
}
}

Some files were not shown because too many files have changed in this diff Show More