@amxts/semiclip 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kukson777
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,141 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<img src="assets/logo.svg" width="96" alt="Semiclip">
+
+# Semiclip
+
+*Who walks through whom, as a rule over two players*
+
+[![amxts module](https://img.shields.io/badge/amxts-module-3178c6?style=flat-square)](https://amxts.github.io/)
+[![License](https://img.shields.io/badge/License-MIT-blue?style=flat-square)](LICENSE)
+
+[Features](#features) • [Installation](#installation) • [Usage](#usage) • [API](#api)
+
+**English** | [Русский](README.ru.md)
+
+</div>
+
+Semiclip lets players walk through each other. amxts does it on the server itself, as [pairs of players](https://amxts.github.io/docs/game/players#walking-through-each-other) (`player.walksThrough`); this module lets a plugin say who walks through whom as a rule over two players, `(player, target) => boolean`, and keeps the pairs up to date with it.
+
+## Features
+
+- **Works as soon as it is installed.** Teammates walk through each other, see-through up close and not drawn right against you, before any plugin says a word.
+- **A rule, not pairs by hand.** One function says whether one player walks through another; the module works every pair out.
+- **Kept up to date by itself.** A spawn, a death, a team change, a player coming in, and a change of any field plugins add to `Player` work the pairs out again - only the pairs of the player it happened to.
+- **Nothing else on the server.** No AMX Mod X module is needed: the pairs are amxts's own.
+- **One instance per server.** Every plugin that uses it sets the same rule.
+
+## Installation
+
+The project needs `@amxts/core` 0.3.3 or later.
+
+```bash
+npx amxts module add semiclip
+```
+
+It installs the package and adds it to your project's `amxts.config.ts`:
+
+```ts
+export default defineConfig({
+	modules: ["@amxts/semiclip"],
+});
+```
+
+## Usage
+
+A plugin uses the module as `semiclip`, without an import line: the build adds the import to the plugins that use it, and builds the module only when some plugin does.
+
+Installed, the module needs no plugin: teammates walk through each other, and a partner is see-through closer than 250 units and not drawn closer than 48 (the core's [`server.walkThroughLook`](#how-a-partner-looks)). A plugin changes who walks through whom with a rule - everyone through everyone, on a KZ server:
+
+```ts
+semiclip.rule = () => true;
+```
+
+Setting the rule is all it takes: the module works every pair out, and works a player's pairs out again when he spawns, dies, changes sides or comes in. `semiclip.rule = null` makes everyone solid; when the plugin that set the rule stops - unloaded or reloaded - teammates walk through each other again, until a rule is set again.
+
+### A rule that changes in play
+
+`spawnProtected` below is the plugin's own [field on `Player`](https://amxts.github.io/docs/game/players#shared-player-fields), declared with `declare module`: it starts `false`, every plugin on the server reads and writes it, and it is cleared when the player leaves. A player who has just spawned walks through everyone alive for 3 seconds, and teammates walk through each other:
+
+```ts
+declare module "@amxts/core" {
+	interface Player {
+		spawnProtected: boolean;
+	}
+}
+
+semiclip.rule = (player, target) =>
+	player.isAlive && target.isAlive && (player.spawnProtected || player.team == target.team);
+
+game.addEventListener("spawn", ({ player }) => {
+	player.spawnProtected = true;                        // walks through everyone for 3 seconds
+	setTimeout(() => (player.spawnProtected = false), 3000);
+});
+```
+
+The module works the pairs out again by itself when the field changes - on the spawn, and when the timer clears it - with no `update()` call.
+
+### When the pairs are worked out
+
+| When | Which pairs |
+| --- | --- |
+| `rule` is set | every pair |
+| a player comes into the game | his |
+| a player spawns, dies or changes sides | his |
+| a field plugins add to `Player` changes on a player - any plugin's, or Pawn's | his |
+| a player leaves | his pairs go with him |
+| `semiclip.update(player)` | `player`'s |
+| `semiclip.update()` | every pair |
+
+`update()` is for what the rule reads that the module does not hear - a round's mode kept in a variable, a plugin's own record of a player:
+
+```ts
+let everyone = false;
+
+semiclip.rule = (player, target) => everyone || player.team == target.team;
+
+server.addCommand("/party", () => {
+	everyone = !everyone;
+	semiclip.update();
+});
+```
+
+### Either way lets a pair through
+
+`rule(player, target)` says whether `player` walks through `target`, but a pair is one: two players walk through each other, or neither does. The pair walks through when the rule lets either one - `rule(a, b) || rule(b, a)`. A rule that says yes for a protected player lets him through everyone, and everyone through him, with no `|| target.spawnProtected` needed.
+
+### Who walks through whom now
+
+The pairs are the core's: `player.walksThrough` is the players he walks through, as a `Set`:
+
+```ts
+player.walksThrough.has(other);                  // whether the two walk through each other
+for (const partner of player.walksThrough) { }   // each of them
+const partners = [...player.walksThrough];
+```
+
+### How a partner looks
+
+A player one walks through can be see-through up close, or not drawn at all, so he does not block the view. That is the core's `server.walkThroughLook`, for every player: off in the core, and the module turns it on as below. A plugin sets its own, or `{ fadeDistance: 0, hideDistance: 0 }` to turn it off:
+
+```ts
+server.walkThroughLook = {
+	fadeDistance: 250,  // closer than 250 units a partner is see-through
+	opacity: 0.4,       // 40% opaque right up close, whole at 250
+	hideDistance: 48,   // closer than 48 units he is not drawn at all, and no target of your aim
+};
+```
+
+> [!WARNING]
+> On a server without ReGameDLL a partner standing between a player and a flash blocks its light as anyone does. Walking through and the look work on every server; a grenade bounces off a partner.
+
+### One rule
+
+The rule is one for the server. A plugin that sets it over another plugin's replaces it, and the console warns: the last one set is used. Plugins that each have a say write it into fields (`player.spawnProtected`) that one rule reads.
+
+## API
+
+| Member | What it is |
+| --- | --- |
+| `semiclip.rule` | `(player, target) => boolean` - whether `player` walks through `target`; a pair walks through when either way says so. Setting it works every pair out; `null` makes everyone solid again. |
+| `semiclip.update(player?)` | Works `player`'s pairs out again, or everyone's, after something the rule reads changed that the module does not hear. |

package/README.ru.md

@@ -0,0 +1,141 @@
+<div align="center">
+
+<img src="assets/logo.svg" width="96" alt="Semiclip">
+
+# Semiclip
+
+*Кто сквозь кого проходит — правилом над двумя игроками*
+
+[![amxts module](https://img.shields.io/badge/amxts-module-3178c6?style=flat-square)](https://amxts.github.io/)
+[![License](https://img.shields.io/badge/License-MIT-blue?style=flat-square)](LICENSE)
+
+[Возможности](#возможности) • [Установка](#установка) • [Использование](#использование) • [API](#api)
+
+[English](README.md) | **Русский**
+
+</div>
+
+Семиклип позволяет игрокам проходить сквозь друг друга. amxts делает это на сервере сам, [парами игроков](https://amxts.github.io/ru/docs/game/players#проход-сквозь-друг-друга) (`player.walksThrough`); этот модуль даёт плагину сказать, кто сквозь кого проходит, правилом над двумя игроками, `(player, target) => boolean`, и держит пары в курсе.
+
+## Возможности
+
+- **Работает сразу после установки.** Союзники проходят друг сквозь друга, вблизи полупрозрачны, а вплотную не рисуются — ещё до того, как какой-то плагин что-то сказал.
+- **Правило, а не пары вручную.** Одна функция говорит, проходит ли один игрок сквозь другого; модуль рассчитывает каждую пару.
+- **Держится в курсе сам.** Появление, смерть, смена команды, вход игрока и изменение любого поля, которое плагины добавили в `Player`, заново рассчитывают пары — только пары того игрока, с которым это случилось.
+- **Больше ничего на сервере.** Модуль AMX Mod X не нужен: пары — собственные у amxts.
+- **Один экземпляр на сервер.** Все плагины, которые им пользуются, задают одно и то же правило.
+
+## Установка
+
+Проекту нужен `@amxts/core` 0.3.3 или новее.
+
+```bash
+npx amxts module add semiclip
+```
+
+Команда ставит пакет и добавляет его в `amxts.config.ts` проекта:
+
+```ts
+export default defineConfig({
+	modules: ["@amxts/semiclip"],
+});
+```
+
+## Использование
+
+Плагин пользуется модулем как `semiclip`, без строки импорта: сборка добавляет импорт в те плагины, которые им пользуются, и собирает модуль, только когда им пользуется хоть один.
+
+Установленному модулю плагин не нужен: союзники проходят друг сквозь друга, а партнёр полупрозрачен ближе 250 юнитов и не рисуется ближе 48 (`server.walkThroughLook` ядра, [ниже](#как-выглядит-партнёр)). Кто сквозь кого проходит, плагин меняет правилом — например, все сквозь всех на KZ-сервере:
+
+```ts
+semiclip.rule = () => true;
+```
+
+Больше ничего не нужно: модуль рассчитывает каждую пару и заново рассчитывает пары игрока, когда тот появляется, умирает, меняет команду или входит. `semiclip.rule = null` делает всех твёрдыми; когда плагин, который задал правило, останавливается (его выгрузили или перезагрузили), снова проходят союзники — пока правило не задано снова.
+
+### Правило, которое меняется в игре
+
+`spawnProtected` ниже — собственное [поле плагина в `Player`](https://amxts.github.io/ru/docs/game/players#общие-поля-игрока), объявленное через `declare module`: сначала оно `false`, его читают и пишут все плагины сервера, а когда игрок уходит, оно сбрасывается. Только что появившийся игрок 3 секунды проходит сквозь всех живых, а союзники — сквозь друг друга:
+
+```ts
+declare module "@amxts/core" {
+	interface Player {
+		spawnProtected: boolean;
+	}
+}
+
+semiclip.rule = (player, target) =>
+	player.isAlive && target.isAlive && (player.spawnProtected || player.team == target.team);
+
+game.addEventListener("spawn", ({ player }) => {
+	player.spawnProtected = true;                        // 3 секунды проходит сквозь всех
+	setTimeout(() => (player.spawnProtected = false), 3000);
+});
+```
+
+Модуль сам заново рассчитывает пары, когда поле меняется, — при появлении и когда таймер его снимает, — без вызова `update()`.
+
+### Когда пары рассчитываются
+
+| Когда | Какие пары |
+| --- | --- |
+| задано `rule` | все пары |
+| игрок вошёл в игру | его |
+| игрок появился, умер или сменил команду | его |
+| у игрока изменилось поле, которое плагины добавили в `Player`, — любым плагином или Pawn | его |
+| игрок ушёл | его пары уходят вместе с ним |
+| `semiclip.update(player)` | пары `player` |
+| `semiclip.update()` | все пары |
+
+`update()` — для того, что читает правило, но чего модуль не слышит: режим раунда в переменной, собственная запись плагина об игроке:
+
+```ts
+let everyone = false;
+
+semiclip.rule = (player, target) => everyone || player.team == target.team;
+
+server.addCommand("/party", () => {
+	everyone = !everyone;
+	semiclip.update();
+});
+```
+
+### Пару пропускает любая сторона
+
+`rule(player, target)` говорит, проходит ли `player` сквозь `target`, но пара одна: двое либо проходят сквозь друг друга, либо нет. Пара проходит, когда правило разрешает хотя бы одному — `rule(a, b) || rule(b, a)`. Правило, которое говорит да для защищённого игрока, пропускает его сквозь всех и всех сквозь него, без `|| target.spawnProtected`.
+
+### Кто сквозь кого проходит сейчас
+
+Пары — это пары ядра: `player.walksThrough` — игроки, сквозь которых он проходит, как `Set`:
+
+```ts
+player.walksThrough.has(other);                  // проходят ли двое сквозь друг друга
+for (const partner of player.walksThrough) { }   // каждый из них
+const partners = [...player.walksThrough];
+```
+
+### Как выглядит партнёр
+
+Игрок, сквозь которого проходишь, вблизи может быть полупрозрачным или не рисоваться совсем, чтобы не закрывать обзор. Это `server.walkThroughLook` ядра — для всех игроков: в ядре выключено, а модуль включает его, как ниже. Плагин задаёт свой или выключает его через `{ fadeDistance: 0, hideDistance: 0 }`:
+
+```ts
+server.walkThroughLook = {
+	fadeDistance: 250,  // ближе 250 юнитов партнёр полупрозрачный
+	opacity: 0.4,       // вплотную непрозрачен на 40%, целиком — на 250
+	hideDistance: 48,   // ближе 48 юнитов его не видно совсем, и прицел сквозь него
+};
+```
+
+> [!WARNING]
+> На сервере без ReGameDLL партнёр, который стоит между игроком и флешкой, закрывает её свет, как любой другой. Проход сквозь и вид работают на любом сервере; граната от партнёра отскакивает.
+
+### Одно правило
+
+Правило на сервере одно. Плагин, который задаёт его поверх правила другого плагина, заменяет его, а консоль предупреждает: действует последнее заданное. Плагины, у каждого из которых есть своё слово, пишут его в поля (`player.spawnProtected`), которые читает одно правило.
+
+## API
+
+| Член | Что это |
+| --- | --- |
+| `semiclip.rule` | `(player, target) => boolean` — проходит ли `player` сквозь `target`; пара проходит, когда разрешает любая сторона. Присваивание рассчитывает каждую пару; `null` снова делает всех твёрдыми. |
+| `semiclip.update(player?)` | Заново рассчитывает пары `player` или всех, после того как изменилось то, что читает правило и чего модуль не слышит. |

package/package.json

@@ -1,6 +1,64 @@
 {
-  "name": "@amxts/semiclip",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@amxts/semiclip",
+	"type": "module",
+	"version": "0.2.0",
+	"description": "Who walks through whom, for amxts plugins: semiclip as a rule over two players, on the core's own pairs.",
+	"author": {
+		"name": "kukson777",
+		"url": "https://github.com/kukson777"
+	},
+	"license": "MIT",
+	"homepage": "https://github.com/amxts/semiclip#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/amxts/semiclip.git"
+	},
+	"keywords": [
+		"amxts-module",
+		"amxts-semiclip",
+		"amxmodx",
+		"counter-strike"
+	],
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"types": "./src/index.ts",
+	"files": [
+		"README.md",
+		"README.ru.md",
+		"scripts/docs",
+		"src",
+		"prebuilt"
+	],
+	"amxts": {
+		"core": "^0.3.3",
+		"module": "src/index.ts"
+	},
+	"scripts": {
+		"test": "vitest run",
+		"check": "amxts check",
+		"lint": "oxlint && oxfmt --check",
+		"lint:fix": "oxfmt && oxlint --fix --silent || oxlint --fix --silent || oxlint --fix"
+	},
+	"peerDependencies": {
+		"@amxts/core": "^0.3.3"
+	},
+	"devDependencies": {
+		"@e18e/eslint-plugin": "^0.8.1",
+		"@eslint-community/eslint-plugin-eslint-comments": "^4.8.1",
+		"@stylistic/eslint-plugin": "^5.10.0",
+		"@types/node": "^24.0.0",
+		"eslint-plugin-antfu": "^3.2.3",
+		"eslint-plugin-command": "^4.0.0",
+		"eslint-plugin-n": "^18.4.0",
+		"eslint-plugin-perfectionist": "^5.12.1",
+		"eslint-plugin-regexp": "^3.3.1",
+		"oxfmt": "^0.70.0",
+		"oxlint": "^1.85.0",
+		"typescript": "^6.0.3",
+		"vitest": "^5.0.3"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/prebuilt/manifest.json

@@ -0,0 +1,64 @@
+{
+	"format": 2,
+	"module": "@amxts/semiclip",
+	"version": "0.2.0",
+	"from": {
+		"@amxts/core": {
+			"version": "0.3.3",
+			"hash": "dd6ff1554558754384eb03d07c4a688d1d696b91",
+			"abi": "0.3.3+abi.1ff73017\nabort (iiii)\namxts_rpc (iiii)i\namxts_rpc_reply (ii)\namxts_rpc_result (i)\namxts_rpc_take (i)\namxts_serve (ii)\narg (i)i\narg_text (iii)i\nconsole.error (i)\nconsole.warn (i)\ncreate_cvar (iiiiiiii)i s,s,v,s,v,v,v,v\ncvar_hook (ii)i\ngame_api ()i\nget_cvar_pointer (i)i s leaf\nget_maxplayers ()i\nget_players (iiii)i [32>,[1>,s,s\nget_user_msgid (i)i s leaf\nham (iiii)i\nhook (iii)i\nhook_direct (iiii)\nhook_on (ii)\nmember_get (iii)i\nmember_slot (ii)i\nmsg_argc ()i\nmsg_hook (ii)i\nmsg_number (i)F\non (iii)\non_direct (iiiiii)\nperformance.now ()F\nplayer_change_get (i)F\nplayer_change_get_text (iii)i\nplayer_change_listen (ii)\nplayer_data_set (iiF)\nplayer_names (i)\nplayer_slots (i)\nplugin (iiii)\nprecache_generic (i)i s\nprecache_model (i)i s\nprecache_sound (i)i s\nstack_frames (ii)i\ntag (i)\nwalk_look (iF)\nwalk_through (iii)\nwalk_through_get (i)i"
+		},
+		"@amxts/semiclip": {
+			"version": "0.2.0",
+			"hash": "9eb0fb0c9aa7785a7e0bbefa716eb6dff46ce7a7"
+		}
+	},
+	"options": {
+		"@amxts/semiclip": {}
+	},
+	"forwards": {},
+	"places": [
+		"constants.ts",
+		"database.ts",
+		"effects.ts",
+		"entities.ts",
+		"events.ts",
+		"facade.ts",
+		"fetch.ts",
+		"flags.ts",
+		"fs.ts",
+		"hlds.ts",
+		"hooks.ts",
+		"jobs.ts",
+		"kit.ts",
+		"modules/semiclip.ts",
+		"natives.ts",
+		"promise.ts",
+		"semiclip.ts",
+		"sql.ts",
+		"vector.ts"
+	],
+	"natives": [],
+	"beside": {
+		"enums": [],
+		"contract": null,
+		"author": null
+	},
+	"systems": {
+		"windows": {
+			"file": "prebuilt/windows/semiclip.aot",
+			"size": 479672,
+			"sha256": "c0fc85a9fc3e242fe522521b8c32e6d2bee818f07e19c0d41987e5fbf87a3f0c"
+		},
+		"linux": {
+			"file": "prebuilt/linux/semiclip.aot",
+			"size": 484848,
+			"sha256": "681b91517feef63531201bf4279897997432defb4dd9faa28eacbf6273632df2"
+		}
+	},
+	"surface": {
+		"proxy": "// GENERATED by scripts/shared-modules.ts: ~/modules/semiclip in a plugin that does not own it.\n// Each function runs in semiclip.aot, the one instance on the server.\nimport { Reader as __Reader, Writer as __Writer, beginCallback as __beginCallback, callBack as __callBack, receiveFunction as __receiveFunction, remoteTarget as __remoteTarget, sendFunction as __sendFunction, Service as __Service } from \"~/remote\";\nimport { Player as __Player } from \"~/facade\";\nimport { Player } from \"~/facade\";\n\nexport type SemiclipRule = (player: Player, target: Player) => boolean;\n\n/** Semiclip in semiclip's plugin: each field is read and written there, each method runs there. */\nexport class Semiclip {\n\tconstructor(public __handle: i32) {}\n\n\tget rule(): ((a0: __Player, a1: __Player) => bool) | null {\n\t\tconst w = __service.begin(0);\n\t\tw.i32(this.__handle);\n\t\treturn __r0(__service.call(w));\n\t}\n\tset rule(value: ((a0: __Player, a1: __Player) => bool) | null) {\n\t\tconst w = __service.begin(1);\n\t\tw.i32(this.__handle);\n\t\t__w0(w, value);\n\t\t__service.call(w);\n\t}\n\n\tupdate(player?: Player): void {\n\t\tconst __w = __service.begin(2);\n\t\t__w.i32(this.__handle);\n\t\t__w2(__w, player);\n\t\tconst __r = __service.call(__w);\n\t}\n}\n\nexport const semiclip = new Semiclip(1);\n\nconst __service = new __Service(\"semiclip\", 1612802220);\n\nfunction __w1(w: __Writer, v: (a0: __Player, a1: __Player) => bool): void { w.i32(__sendFunction(changetype<usize>(v), 0, __invoke)); }\n\nfunction __r1(r: __Reader): (a0: __Player, a1: __Player) => bool { return changetype<(a0: __Player, a1: __Player) => bool>(__receiveFunction(r, changetype<usize>(__stub0))); }\n\nfunction __w0(w: __Writer, v: ((a0: __Player, a1: __Player) => bool) | null): void {\n\tif (v == null) {\n\t\tw.bool(false);\n\t\treturn;\n\t}\n\tw.bool(true);\n\t__w1(w, v!);\n}\n\nfunction __r0(r: __Reader): ((a0: __Player, a1: __Player) => bool) | null {\n\tif (!r.bool()) return null;\n\treturn __r1(r);\n}\n\nfunction __w3(w: __Writer, v: __Player): void { w.i32(<i32>v.id); }\n\nfunction __r3(r: __Reader): __Player { return new __Player(r.i32()); }\n\nfunction __w2(w: __Writer, v: __Player | null): void {\n\tif (v == null) {\n\t\tw.bool(false);\n\t\treturn;\n\t}\n\tw.bool(true);\n\t__w3(w, v!);\n}\n\nfunction __r2(r: __Reader): __Player | null {\n\tif (!r.bool()) return null;\n\treturn __r3(r);\n}\n\nfunction __w4(w: __Writer, v: bool): void { w.bool(v); }\n\nfunction __r4(r: __Reader): bool { return r.bool(); }\n\nfunction __stub0(a0: __Player, a1: __Player): bool {\n\tconst target = __remoteTarget();\n\tconst w = __beginCallback(target);\n\t__w3(w, a0);\n\t__w3(w, a1);\n\tconst r = __callBack(target, w);\n\treturn __r4(r);\n}\n\nfunction __invoke(fn: usize, sig: i32, r: __Reader, w: __Writer): void {\n\tswitch (sig) {\n\t\tcase 0: {\n\t\t\tconst a0 = __r3(r);\n\t\t\tconst a1 = __r3(r);\n\t\t\tconst f = changetype<(a0: __Player, a1: __Player) => bool>(fn);\n\t\t\tconst result = f(a0, a1);\n\t\t\t__w4(w, result);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\n\n",
+		"serve": "// GENERATED by scripts/shared-modules.ts: ~/modules/semiclip, run by this plugin for every other.\nimport { Reader as __Reader, Writer as __Writer, beginCallback as __beginCallback, callBack as __callBack, receiveFunction as __receiveFunction, remoteTarget as __remoteTarget, sendFunction as __sendFunction, Handles as __Handles, serve as __serve } from \"~/remote\";\nimport * as __m from \"~/modules/semiclip\";\nimport { Player as __Player } from \"~/facade\";\nimport { Semiclip as __M_Semiclip } from \"~/modules/semiclip\";\n\nconst __handles = new __Handles();\n// The exported objects are handles 1, 2, ... - the numbers the proxies have.\n__handles.id(changetype<usize>(__m.semiclip));\n\nfunction __dispatch(op: i32, r: __Reader, w: __Writer): void {\n\tswitch (op) {\n\t\tcase 0: {\n\t\t\tconst o = __r0(r);\n\t\t\t__w1(w, o.rule);\n\t\t\tbreak;\n\t\t}\n\t\tcase 1: {\n\t\t\tconst o = __r0(r);\n\t\t\to.rule = __r1(r);\n\t\t\tbreak;\n\t\t}\n\t\tcase 2: {\n\t\t\tconst o = __r0(r);\n\t\t\tconst a0 = __r3(r);\n\t\t\to.update(a0);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction __stub0(a0: __Player, a1: __Player): bool {\n\tconst target = __remoteTarget();\n\tconst w = __beginCallback(target);\n\t__w4(w, a0);\n\t__w4(w, a1);\n\tconst r = __callBack(target, w);\n\treturn __r5(r);\n}\n\nfunction __invoke(fn: usize, sig: i32, r: __Reader, w: __Writer): void {\n\tswitch (sig) {\n\t\tcase 0: {\n\t\t\tconst a0 = __r4(r);\n\t\t\tconst a1 = __r4(r);\n\t\t\tconst f = changetype<(a0: __Player, a1: __Player) => bool>(fn);\n\t\t\tconst result = f(a0, a1);\n\t\t\t__w5(w, result);\n\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction __w0(w: __Writer, v: __M_Semiclip): void { w.i32(__handles.id(changetype<usize>(v))); }\n\nfunction __r0(r: __Reader): __M_Semiclip { return changetype<__M_Semiclip>(__handles.at(r.i32())); }\n\nfunction __w2(w: __Writer, v: (a0: __Player, a1: __Player) => bool): void { w.i32(__sendFunction(changetype<usize>(v), 0, __invoke)); }\n\nfunction __r2(r: __Reader): (a0: __Player, a1: __Player) => bool { return changetype<(a0: __Player, a1: __Player) => bool>(__receiveFunction(r, changetype<usize>(__stub0))); }\n\nfunction __w1(w: __Writer, v: ((a0: __Player, a1: __Player) => bool) | null): void {\n\tif (v == null) {\n\t\tw.bool(false);\n\t\treturn;\n\t}\n\tw.bool(true);\n\t__w2(w, v!);\n}\n\nfunction __r1(r: __Reader): ((a0: __Player, a1: __Player) => bool) | null {\n\tif (!r.bool()) return null;\n\treturn __r2(r);\n}\n\nfunction __w4(w: __Writer, v: __Player): void { w.i32(<i32>v.id); }\n\nfunction __r4(r: __Reader): __Player { return new __Player(r.i32()); }\n\nfunction __w3(w: __Writer, v: __Player | null): void {\n\tif (v == null) {\n\t\tw.bool(false);\n\t\treturn;\n\t}\n\tw.bool(true);\n\t__w4(w, v!);\n}\n\nfunction __r3(r: __Reader): __Player | null {\n\tif (!r.bool()) return null;\n\treturn __r4(r);\n}\n\nfunction __w5(w: __Writer, v: bool): void { w.bool(v); }\n\nfunction __r5(r: __Reader): bool { return r.bool(); }\n\n__serve(\"semiclip\", 1612802220, __dispatch);\n",
+		"callbacks": true
+	}
+}

package/scripts/docs/src/index.ts

@@ -0,0 +1,66 @@
+// The tooltips of src/index.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'SemiclipRule': {
+		en: `
+			Whether \`player\` walks through \`target\`. Two players walk through each
+			other when the rule lets either one: \`rule(a, b) || rule(b, a)\`.
+		`,
+		ru: `
+			Проходит ли \`player\` сквозь \`target\`. Два игрока проходят друг сквозь
+			друга, когда правило разрешает это хотя бы в одну сторону:
+			\`rule(a, b) || rule(b, a)\`.
+		`,
+	},
+	'Semiclip': {
+		en: `
+			Who walks through whom, set as a rule over two players - \`semiclip\`, which
+			plugins use without an import:
+
+			\`\`\`ts
+			semiclip.rule = (player, target) => player.isAlive && target.isAlive && player.team == target.team;
+			\`\`\`
+		`,
+		ru: `
+			Кто сквозь кого проходит, заданное правилом над двумя игроками, — \`semiclip\`,
+			которым плагины пользуются без импорта:
+
+			\`\`\`ts
+			semiclip.rule = (player, target) => player.isAlive && target.isAlive && player.team == target.team;
+			\`\`\`
+		`,
+	},
+	'Semiclip.rule': {
+		en: `
+			Whether \`player\` walks through \`target\`; a pair walks through when either
+			way says so. Until a plugin sets it, teammates walk through each other.
+			Setting it works every pair out; \`null\` makes everyone solid again, and the
+			rule of a plugin that stops goes back to teammates. The pairs are worked out again when a player comes, spawns, dies or
+			changes sides, and when a field plugins added to \`Player\` changes.
+		`,
+		ru: `
+			Проходит ли \`player\` сквозь \`target\`; пара проходит, когда это разрешает
+			хотя бы одна сторона. Пока плагин его не задал, друг сквозь друга проходят
+			союзники. Присваивание рассчитывает каждую пару; \`null\` снова делает всех
+			твёрдыми, а правило остановленного плагина снова сменяется союзниками. Пары рассчитываются заново, когда игрок заходит,
+			появляется, умирает или меняет команду и когда меняется поле, которое плагины
+			добавили в \`Player\`.
+		`,
+	},
+	'Semiclip.update': {
+		en: `
+			Works the pairs out again - \`player\`'s, or everyone's - after something
+			the rule reads changed that the module does not hear: a round's mode, a
+			plugin's own record.
+		`,
+		ru: `
+			Рассчитывает пары заново — пары \`player\` или всех — после того, как
+			изменилось то, что читает правило и чего модуль не слышит: режим раунда,
+			собственная запись плагина.
+		`,
+	},
+	'semiclip': {
+		en: `Who walks through whom: the rule, and the pairs worked out again.`,
+		ru: `Кто сквозь кого проходит: правило и повторный расчёт пар.`,
+	},
+};

package/src/index.ts

@@ -0,0 +1,146 @@
+/**
+ * Semiclip for amxts plugins: who walks through whom, as a rule over two
+ * players. The core keeps the pairs (`player.walksThrough`); this module asks
+ * the rule and sets them, again whenever what the rule reads may have changed.
+ * How to use it: README.md.
+ */
+import { ClientPutinserverEvent, Player, TeamInfoMessage, game, server } from "@amxts/core";
+import { callingPlugin, onPluginStop } from "@amxts/core/kit";
+
+export default defineModule({
+	meta: { name: "semiclip" },
+	imports: [{ from: "@amxts/semiclip", name: "semiclip" }],
+	setup() {
+		// The look until a plugin sets its own: see-through up close, not drawn right against him.
+		server.walkThroughLook = { fadeDistance: 250, opacity: 0.4, hideDistance: 48 };
+		server.addEventListener("init", start);
+		server.addEventListener("putInServer", joined);
+		server.addMessageListener("team", teamChanged);
+		server.addEventListener("playerChange", event => changed(event.player));
+		game.addEventListener("spawn", event => changed(event.player), true);
+		game.addEventListener("killed", event => changed(event.player), true);
+		onPluginStop(stopped);
+	},
+});
+
+/**
+ * Whether `player` walks through `target`. Two players walk through each
+ * other when the rule lets either one: `rule(a, b) || rule(b, a)`.
+ */
+export type SemiclipRule = (player: Player, target: Player) => boolean;
+
+/** The rule until a plugin sets one: teammates walk through each other. */
+const teammates: SemiclipRule = (player, target) => player.team == target.team;
+
+let current: SemiclipRule | null = teammates;
+/** The plugin that set the rule, as `callingPlugin()` numbers it; 0 for the module's own. */
+let currentFrom = 0;
+
+/** The server is up. A rule set while the plugins are still loading waits for it. */
+let started = false;
+
+/**
+ * Who walks through whom, set as a rule over two players - `semiclip`, which
+ * plugins use without an import:
+ *
+ * ```ts
+ * semiclip.rule = (player, target) => player.isAlive && target.isAlive && player.team == target.team;
+ * ```
+ */
+export class Semiclip {
+	/**
+	 * Whether `player` walks through `target`; a pair walks through when either
+	 * way says so. Until a plugin sets it, teammates walk through each other.
+	 * Setting it works every pair out; `null` makes everyone solid again, and the
+	 * rule of a plugin that stops goes back to teammates. The pairs are worked out again when a player comes, spawns, dies or
+	 * changes sides, and when a field plugins added to `Player` changes.
+	 */
+	get rule() {
+		return current;
+	}
+
+	set rule(rule: SemiclipRule | null) {
+		if (rule != null && currentFrom != 0 && current != null && rule != current) console.warn("[semiclip] a rule was set over another one: the last one set is used");
+		const had = current != null;
+		current = rule;
+		currentFrom = callingPlugin();
+		if (!started) return;
+		if (rule != null) updateAll(rule);
+		else if (had) clearAll();
+	}
+
+	/**
+	 * Works the pairs out again - `player`'s, or everyone's - after something
+	 * the rule reads changed that the module does not hear: a round's mode, a
+	 * plugin's own record.
+	 */
+	update(player?: Player) {
+		const rule = activeRule();
+		if (rule == null) return;
+		if (player) updatePlayer(player, rule);
+		else updateAll(rule);
+	}
+}
+
+/** Who walks through whom: the rule, and the pairs worked out again. */
+export const semiclip = new Semiclip();
+
+/** The plugin that set the rule stopped: its rule goes, and the module's own, teammates, comes back. */
+function stopped(plugin: number) {
+	if (currentFrom == 0 || currentFrom != plugin) return;
+	current = teammates;
+	currentFrom = 0;
+	if (started) updateAll(teammates);
+}
+
+function start() {
+	started = true;
+	const rule = current;
+	if (rule != null) updateAll(rule);
+}
+
+/** The rule, while the module sets the pairs: the server is up and a rule is set. */
+function activeRule() {
+	return started ? current : null;
+}
+
+function joined(event: ClientPutinserverEvent) {
+	const player = new Player(event.player.id);
+	changed(player);
+}
+
+/** A team change is sent to everyone; a TeamInfo to one player only brings him up to date. */
+function teamChanged(event: TeamInfoMessage) {
+	const target = event.target;
+	if (event.player == null && target != null) changed(target);
+}
+
+/** Something the rule may read changed on `player`: his pairs. */
+function changed(player: Player) {
+	const rule = activeRule();
+	if (rule != null) updatePlayer(player, rule);
+}
+
+function updateAll(rule: SemiclipRule) {
+	const players = server.players;
+	for (let i = 0; i < players.length; i++) {
+		for (let j = i + 1; j < players.length; j++) pair(players[i], players[j], rule);
+	}
+}
+
+function updatePlayer(player: Player, rule: SemiclipRule) {
+	for (const other of server.players) {
+		if (other.id != player.id) pair(player, other, rule);
+	}
+}
+
+/** Sets whether `a` and `b` walk through each other: when the rule lets either one. */
+function pair(a: Player, b: Player, rule: SemiclipRule) {
+	if (rule(a, b) || rule(b, a)) a.walksThrough.add(b);
+	else a.walksThrough.delete(b);
+}
+
+/** No rule any more: everyone is solid again. */
+function clearAll() {
+	for (const player of server.players) player.walksThrough.clear();
+}