ВЕРСИИ (4)

# Changelog ## 2.2.1 **Repairs take time** A smith no longer fixes everything the moment the money changes hands. Once paid for, an item stays with the smith - it leaves the player's inventory - and the player comes back to the same shop to collect it when it is done. The bottom row of the repair menu is now the smith's bench: everything the player left there, counting down, with a click to take back what is finished. Owners are told in chat when an item is ready, and on login if any are waiting. How long a repair takes is set per tier - by default 30 seconds for a broken wooden tool up to 15 minutes for netherite - and, like the price, scales with how worn the item is. Gear priced above its tier (tridents, custom items valued by their stats) takes its time from the same value ladder. Each shop has a `repair-time-multiplier`: a slow village smith, a fast city forge, or `0` for repairs on the spot. A player may leave up to `bench-size` items (5) at one shop. Items on the bench are saved in `orders.yml` as soon as they are handed over and survive restarts; the timer is real time and keeps running while the server is off. The file is written atomically, and is never overwritten if it could not be read - timed repairs are suspended instead. **This is on by default.** `/repairshop time off` (or `repair-time.enabled: false`) brings back instant repairs exactly as before. **Opening hours** Each shop can keep hours, on the Minecraft day (`game`, the default - 06:00 is sunrise) or on the server's own clock (`real`). A closed shop turns customers away with when it opens next, and a player in the menu at closing time is sent out. Hours are off for every shop until set. **Set up in game or in the files** - `/repairshop time` - the tier table, the master switch, `minimum`, `bench`, `scale`, and `time shop <shop> <multiplier>`. Writes `config.yml`. - `/repairshop hours [shop] [06:00-18:00 [game|real] | always | on | clock ...]`. Writes the shop file. - `/repairshop orders [player] [finish|return]` - every item on every bench, and an admin way to finish them or hand them straight back. Players can run `/repairshop orders` to see their own. - The shop editor has two new buttons: **Repair time** (clock) and **Opening hours** (daylight sensor). - `/repairshop quote` now also says how long the repair would take. - The repair log records where each timed item went (`> on the bench until 14:35:10`) and when it was collected (`< collected`). **Minecraft 26.3 support** The supported range is now **1.9 through 26.3** ("Wilderness Bound", the newest release). No gameplay change: the same jar was booted on Paper 26.3 (build 181) and a test player repaired a diamond axe for cash (319.51, exactly as on 1.21.11) and an iron chestplate with iron ingots. Every feature takes its modern route there: Adventure text, per-item max durability, the work-penalty counter, namespaced enchantments, stat-based custom-item pricing and Paper's chat event. Paper 26.3 removed a large batch of long-deprecated API. None of it is anything RepairShop calls, and every method the plugin looks up by name at runtime was checked against the 26.3 API as well, since compiling cannot catch those. **Clearer startup message when Citizens is switched off** If Citizens is installed but disabled - which is what an older Citizens build does on a Minecraft version it does not support yet, 26.3 included - RepairShop used to log `Failed to hook into Citizens: net/citizensnpcs/api/CitizensAPI`. It now says that Citizens is installed but disabled, and that `/repairshop open` still works. Update Citizens to a build that supports your Minecraft version to get NPC shops back.

# RepairShop 2.2.0 Released 27/09/2026. Built and verified against Paper 1.21.11, runs on Minecraft 1.9 → 26.2. **Pay with materials when money runs short** A player who cannot afford a repair used to be told so and that was the end of it. Now clicking the item opens a **Pay with Materials** screen with two ways to settle the bill, each showing exactly what it would take: - **Cash + Materials** - every coin they have, materials for the rest. A player with 600 facing a 950 repair pays the 600 and hands over materials worth the other 350. - **Materials Only** - no money at all. Materials are drawn cheapest first, so a player keeps their diamonds if copper and iron will do, and any of them can be kept out of the payment with one click. When the last item overshoots, the overshoot comes off the cash; in materials-only there is no cash to take it from and the smith keeps it (giving change in money would make every blacksmith a place to sell materials). Nothing is taken until the player confirms, and if their money or inventory changed in the meantime the screen redraws instead of charging. **Only plain items count.** Anything renamed, carrying lore, custom model data or a plugin tag is never offered and never taken, even if it is a diamond underneath. Right-clicking an item opens the screen even when cash would cover it, and right-clicking **Repair Everything** pays for the whole lot the same way. **Material price groups** What each material covers is set in `material-groups.yml`, in named groups. `default` ships with 27 materials from charcoal (2) through iron (25), emerald (30) and diamond (120) up to netherite blocks; a worn-out diamond axe takes 9 diamonds to pay for, three times what the axe cost to craft. A new group starts as a copy of `default` and is then adjusted independently. Each shop can use its own group, follow the group assigned to its world, or take money only. Everything is managed in game with `/repairshop materials` (group list, per-material price editor, per-world assignment, and a new button in the shop editor) or by command. The default group, cheapest first. "Covers" is what one item takes off a repair bill: | Material | Covers | | Material | Covers | |---|---:|---|---|---:| | Charcoal | 2 | | Iron Ingot | 25 | | Gold Nugget | 2 | | Emerald | 30 | | Iron Nugget | 2.5 | | Phantom Membrane | 30 | | Coal | 3 | | Turtle Scute | 40 | | Flint | 3 | | Breeze Rod | 60 | | Redstone | 3 | | Copper Block | 90 | | Lapis Lazuli | 5 | | Diamond | 120 | | Quartz | 5 | | Gold Block | 180 | | Amethyst Shard | 8 | | Iron Block | 225 | | Leather | 8 | | Netherite Scrap | 250 | | Copper Ingot | 10 | | Emerald Block | 270 | | Gold Ingot | 20 | | Netherite Ingot | 1,000 | | Armadillo Scute | 25 | | Diamond Block | 1,080 | | | | | Netherite Block | 9,000 | Blocks are worth exactly nine of their item. Materials a server version does not have (copper before 1.17, say) are skipped, and every value can be changed in game or in the file. **Update notifications** RepairShop now asks Modrinth, where it is published, whether a newer version is out: a few seconds after startup and then every 12 hours, entirely off the main thread. When there is one, the console is told once and admins are told when they join, with a clickable link. `/repairshop version` shows the running and latest versions; `/repairshop version check` asks again now. Configured under `update-check` in config.yml; any network failure logs one warning per session and is otherwise silent. **Fixed** - Repair log lines could be written out of order. Each line was appended by its own async task and the scheduler does not run those in sequence, so a "Repair All" line could land between the items it covered. Lines are now queued and written strictly in order. - Chat prompts used a plain `HashMap` shared with the async chat thread; it is now concurrent. **Upgrading from 2.1.0** Delete the old jar. `material-groups.yml` is created on first start. The new `config.yml` sections (`material-payment`, `update-check`) work from the bundled defaults without editing your file, but add them by hand if you want to tune them. Existing shops follow their world's group until you pick one; a shop's file gains a `material-group:` key the next time it is saved.

# RepairShop 2.1.0 Released 15/09/2026. Built and verified against Paper 1.21.11, runs on Minecraft 1.9 → 26.2. --- ## Custom items are priced by what they do, not what they are made of A datapack "Ender Chestplate" is a leather chestplate carrying 7 armour points, 1 toughness and 598 durability better than diamond, and more durable than netherite. RepairShop priced it as leather, so repairing it cost **less than a diamond helmet**. Anything built on a cheap base material had the same problem: the Armor Upgrades sets, infinity-cave's weapons, MythicMobs gear. Items that carry their own stats are now compared against the vanilla ladder **of their own shape**. For a chestplate that ladder is the leather, gold, chainmail, iron, diamond and netherite chestplates, each rung is scored from its real attributes and durability, and paired with the price already configured for it in `tiers:`. The custom item is scored the same way and its value read off the ladder, then adjusted for rarity. Two things follow from building the ladder that way. The rungs are read from the running server, so no vanilla numbers are hard-coded and nothing needs updating when a material is added or rebalanced. And the values come from your own `tiers:` table, so the result stays anchored to your economy rather than to some absolute idea of what an item is worth. ### What it costs now (As an example) | Item | Before | After | For reference | | --- | --- | --- | --- | | Ender Chestplate (datapack) | 33 | **1,321** | diamond chestplate 1,188 · netherite 2,375 | | Steel Battleaxe (infinity-cave) | 1,995 | **2,712** | netherite axe 1,995 | Worked example, with the shipped weights: | Rung | Score | Value | | --- | --- | --- | | leather chestplate | 3.80 | 26 | | golden chestplate | 6.12 | 115 | | chainmail chestplate | 7.40 | 170 | | iron chestplate | 8.40 | 265 | | **Ender Chestplate** | **15.08** | interpolated → **846** | | diamond chestplate | 16.28 | 950 | | netherite chestplate | 19.42 | 1,900 | 846 × 1.25 (epic) = 1,057 base, × 1.25 (chestplate shape) = **1,321** for a full repair. ### Vanilla gear is untouched An item that declares no stats of its own keeps exactly the tier price it had in 2.0.0. The default `mode: highest` also means a custom item can never be priced *below* its material tier. Set `mode: auto` to let weak custom items fall below it. Configured under `pricing.auto-value` in config.yml: weights per attribute, a value per point of durability, rarity multipliers, and a cap on how far an item better than anything vanilla can extrapolate. `enabled: false` restores 2.0.0 pricing exactly. --- ## New: `/repairshop items` hand-written prices for the rest Automatic valuation only works on items that have stats to read. For the rest a MythicMobs reward with no attributes, or an item whose automatic price you want to pin hold it and press one button. The item is captured by whatever identifies it, in order of preference: its MythicMobs id, its `item_model`, its custom model number, or its name. The price is seeded with what the item is worth today, so you are editing a real number rather than starting from zero and briefly making it free. Rules live in `custom-items.yml` and are **global**: an item is worth what it is worth, and each shop's own `price-multiplier` still applies on top, so one item needs one entry however many shops you run. A rule always beats the automatic price. `base-value` replaces the price outright, `multiplier` scales whatever the price would otherwise have been, including the automatic one. When several rules match, the most specific wins. --- ## Also - `/repairshop quote` now says where the base value came from the tier table, the item's own stats (with its score and rarity), or which `custom-items.yml` rule so a surprising price can be traced without guesswork. - `/repairshop ladder <shape>` prints the vanilla ladder the server actually computed. It is the only way to see what the server reported, and the fastest way to check what a weight change did. - `/repairshop compat` and the startup line report whether item stats can be read at all. - MythicMobs is detected reflectively. There is no compile or runtime dependency on it, and nothing changes if it is absent. ## On servers older than 1.13 Attributes cannot be read, so automatic valuation switches itself off and pricing behaves exactly as it did in 2.0.0. The console says so at startup. Manual rules still work for anything matched by material, name or custom model data. --- ## Fixed - **The vanilla ladder is now forced to rise monotonically.** Stats and material value disagree in vanilla a golden axe scores 0.32 and is priced 115, a stone axe scores 2.91 and is priced 42 which made one segment of the axe ladder slope *downwards*, so a better custom axe would have been quoted a *lower* price. Found while checking the arithmetic, before release. - **Ladder rungs are deduplicated.** `GOLD_` and `GOLDEN_` both resolve to the same material on a modern server, which put it on the ladder twice and created a zero-width segment. - **`build.ps1` no longer aborts when javac writes a warning to stderr.** Windows PowerShell 5.1 turns native stderr into an ErrorRecord, which `$ErrorActionPreference = 'Stop'` treated as fatal, it meant `-Verify` could never run. --- ## Upgrading from 2.0.0 Drop in the new jar and delete `RepairShop-2.0.0.jar`, or the server will refuse to load two plugins with the same name. `build.ps1 -Deploy` does that for you. `custom-items.yml` is created on first start. `config.yml` gains a `pricing.auto-value` section but note that **Bukkit does not add new keys to an existing config.yml**. The feature works on its built-in defaults either way, but to tune it you have to write the section in by hand, it is in `src/main/resources/config.yml` in this folder, ready to paste into the `pricing:` block. ## Rolling back to 2.0.0 ``` # stop the server first Remove version 2.1.0, replace it with 2.0.0 version. ``` 2.0.0 ignores the `pricing.auto-value` keys and leaves `custom-items.yml` alone, so both can stay where they are. Prices return to being based on material tier only. --- ## Verification at release - Compiled against all 6 supported API targets: Spigot 1.9, 1.12.2, 1.13.2 and Paper 1.21.11, 26.2, and 26.2 with Adventure 5. `build.ps1 -Verify`. - MiniLegacy text-translator checks all pass. - Booted against the live server three times: no exceptions, clean shutdowns, and `/repairshop ladder` reproduced the hand-calculated scores exactly, confirming the ladder is read from the server rather than falling back to built-in defaults.

# Changelog ## 2.0.0 **One jar for Minecraft 1.9 through 26.2** RepairShop used to require Paper 1.21 and refuse to load on anything else. It now runs on any server from 1.9 to 26.2 Spigot or Paper from a single jar, with Paper 1.21.11 still the version it is developed and tuned against. Nothing about pricing, the GUI, the shop editor or the logs has changed. Existing `config.yml`, `messages.yml` and `shops/*.yml` files are read exactly as before, and items already carrying a repair count keep it. **How it works.** Everything the Bukkit API moved over the years now sits behind a small interface in `net.repairshop.compat`, and the implementation is chosen at startup by asking whether a class or method *exists* never by comparing version numbers, which is precisely the thing that broke when Minecraft's version scheme changed to `26.x`. The implementations that need modern APIs live in `compat.modern` and are loaded reflectively, so an old server never touches them. - **Text.** Full MiniMessage on Paper 1.16.5+; everywhere else a built-in translator renders the same source into legacy `§` codes. Colours, hex and the five decorations survive; gradients collapse to their first colour and hover/click text is dropped, keeping its contents. - **Item damage.** `Damageable` item meta on 1.13+, the `ItemStack` durability short below it, and per-item maximum durability where 1.20.5+ supports it. - **Material names.** Config files are read in both the pre- and post-flattening vocabularies, so the same file prices `GOLDEN_AXE` and `GOLD_AXE` as one thing. GUI buttons resolve through a preference list per button, so a menu still draws on a version where the icon does not exist. - **Enchantment names.** Pre-1.13 Bukkit constants (`DIG_SPEED`, `DURABILITY`) are mapped onto modern keys, so one `config.yml` prices enchantments identically everywhere. - **Chat prompts.** Paper's `AsyncChatEvent` where it exists, `AsyncPlayerChatEvent` otherwise. - **Adventure 5.** Paper 26.2 ships Adventure 5, which dropped previously deprecated API. The Adventure bridge self-checks at startup and falls back to legacy text rather than failing if a future release moves something it needs. **The one real loss on old servers:** the work penalty needs somewhere on the item to keep a repair count, and that is the persistent data container, which arrived in 1.14. On 1.9–1.13 the penalty is **inactive** and every repair is priced as a first repair. The console says so at startup and `/repairshop quote` says so per item. Everything else degrades cosmetically or not at all. **New:** `/repairshop compat` prints which route the running server took, so a support question does not need the startup log. **Build changes** - `maven.compiler.release` is now **8** rather than 21. Java 8 bytecode loads on every later JVM, so the jar needs nothing of the server that the server did not already need. - `api-version` is now **`1.13`**, not `1.21`. It is the oldest value any server accepts, and versions before 1.13 ignore the key entirely which is what lets one jar cover the range. Raising it to match your own server would break every older one. - `build.ps1 -Verify` compiles the version-agnostic core against Spigot 1.9, 1.12.2 and 1.13.2 and Paper 1.21.11 and 26.2, then runs the legacy text translator's checks. That is what keeps the range honest; run it after touching anything in `compat/`. **Upgrading:** delete the old `RepairShop-1.3.0.jar` before starting, or the server will refuse to load two plugins with the same name. `build.ps1 -Deploy` does that for you. ## 1.3.0 **Per-shop repair logs** Every paid repair is now written to `shops/<id>/logs/<date>.log`, one file per shop per day the same idea as the dtlTradersPlus shop logs, in a format meant to be read. ``` # RepairShop repair log # Shop : city_smith City Smith # Date : 2026-08-21 # # One line per paid repair. "worn" is how damaged the item was when it was handed # in; "nth" counts how many times this plugin had already repaired that same item, # which is what the work penalty charges for. Amounts are plain numbers. # #time | player | item | tier | worn | nth | cost #---------+------------------+----------------------------------+-----------+------+------+------------- 00:12:04 | Player A | Netherite Axe | NETHERITE | 82% | 3rd | 1,742.50 00:12:44 | Player B | Diamond Pickaxe | DIAMOND | 31% | 1st | 298.00 00:12:46 | Player C | * Repair All (4 items) | - | - | - | 1,204.00 ``` What it does differently from the logs it is modelled on: - **Fixed, pipe-separated columns** instead of a sentence, so a day's trade can be scanned down the page and still `grep`-ed or pulled into a spreadsheet. - **No leftover colour codes.** Names and item names are written as plain text; a `§r` never reaches the file. - **No repetition.** The date and the shop name are in the path, so they are not on every line. - **A header that explains the columns**, written once per file. - **Repair-specific detail**: how worn the item was, its tier, and how many times this plugin had repaired that same item before which is the number the work penalty charges for, and the one to look at when a price seems too high. - A `Repair Everything` click writes its items individually and then one `*` summary line, so a batch can be read as a group. A one-item batch skips the summary. **Nothing is created until it is needed.** A shop nobody has repaired at has no `logs` folder; the day's file appears with the first repair of that day. **Configuration** new `logging:` section in `config.yml`: | Key | Default | Meaning | |---|---|---| | `enabled` | `true` | Turn logging off entirely. | | `include-uuid` | `false` | Add a UUID column, for auditing across name changes. | | `keep-days` | `0` | Delete logs older than this on startup. `0` keeps them forever. | Writes happen off the main thread, and a failure is reported once rather than every repair. ## 1.2.0 **Shops can be created and edited in-game** Until now a new shop meant stopping to copy `shops/default.yml` by hand, editing YAML, and running `/repairshop reload`. The whole cycle is now a GUI, and the file it writes keeps the same comments a hand-written one has. - **`/repairshop shops`** a browser listing every shop with its title, multiplier, permission, tiers, refusal count and how many NPCs are running it. Click a shop to edit it, shift-click to see it as a customer would, or press **New Shop** to make another. - **`/repairshop create <id>`** straight into the editor for a new shop. - **`/repairshop edit <id>`** the editor for an existing one. With no id it opens the browser. - **`/repairshop delete <id> confirm`** deletes a shop and its file from chat. The editor has the same thing as a two-click button. The editor holds every field of a shop file on one screen: | Button | Does | |---|---| | Menu title | Type a MiniMessage title in chat; the button shows it rendered. Right-click reverts to the global default. | | Price multiplier | Left/right-click ±0.05, shift for ±0.25, middle-click resets. Shows what a worn-out diamond pickaxe would cost at that rate. | | Accepted tiers | Sub-screen with every tier from `config.yml`, click to toggle, shift-click for "only this one". | | Refused materials | Sub-screen: add the item in your hand, type names in chat, or click an entry to drop it. | | Assign to selected NPC | Gives your `/npc select`-ed NPC this shop, saving it first if needed. | | Preview | Opens the shop as a customer sees it, unsaved changes and all; closing it returns to the editor. | | Duplicate | Copies the settings into a new shop id. | | Save / Discard / Delete | Nothing is written until Save. Delete needs two clicks. | Nothing is written to disk until Save, and a saved shop is live immediately no reload. Closing the editor with unsaved changes says so in chat rather than silently dropping them. **Details** - Shop ids are validated before a file is created: lowercase letters, digits, `-` and `_`, up to 32 characters, not already taken, and not a name Windows reserves (`con`, `aux`, `lpt1`, …). - An empty `allowed-tiers` list means "every tier", so the editor refuses to leave it at zero selected tiers that would otherwise silently mean the opposite of what was intended. - Deleting the last remaining shop re-creates the in-memory `default`, so `getOrDefault` always has something to hand back. - `messages.yml` gained an `editor:` section about 130 new keys, all MiniMessage. Existing files keep working; missing keys fall back to the copy bundled in the jar. - `build.ps1` added: builds with `javac`/`jar` from JDK 21 directly, for machines with no Maven. It reads the version from `pom.xml` and filters `plugin.yml` the same way the pom does. ## 1.1.0 **Help and price discovery** - `/repairshop help` rewritten as a real help page: an explanation of what the plugin does, then commands split into "Everyone" and "Admin" sections. Only shows what the sender has permission to run. Also shown when `/repairshop` is run with no arguments. - New `/repairshop prices` cost of a full repair for every material tier. - `/repairshop quote` and `/repairshop prices` are now player-facing under the new `repairshop.quote` permission (default true) instead of being admin-only. - Help entries and tab completion are generated from the same arrays, so they cannot drift apart. **Price rebalance** The tier ladder was scaled by roughly 1.9x, anchored so that a diamond axe with 500 of 1561 durability damaged costs ~320. Enchantment surcharges were deliberately left unchanged. | Tier | 1.0.0 | 1.1.0 | | Tier | 1.0.0 | 1.1.0 | |---|---|---|---|---|---|---| | Wood | 12 | 24 | | Turtle | 270 | 515 | | Leather | 14 | 26 | | Diamond | 500 | 950 | | Stone | 22 | 42 | | Netherite | 1000 | 1900 | | Gold | 60 | 115 | | Elytra | 750 | 1425 | | Chainmail | 90 | 170 | | Trident | 600 | 1140 | | Iron | 140 | 265 | | Mace | 700 | 1330 | `item-values` for bows, crossbows, shields, fishing rods, shears, flint and steel, carrot on a stick and brushes were scaled by the same factor. **Fixes** - `messages.yml` now falls back to the copy bundled in the jar for any key it is missing. Previously, message keys added by an update rendered as `<missing message: ...>` until the user deleted their file. ## 1.0.0 Initial release. - Citizens `repairshop` trait; right-clicking an NPC opens the repair menu. - Dynamic pricing from material tier, item shape, enchantments and damage ratio, shaped by a configurable curve. - Paginated 54-slot GUI scanning main inventory, hotbar, armour slots and offhand. - Per-item repair and "Repair Everything", the latter with optional confirmation and cheapest-first partial repair when funds are short. - Multiple shops with individual price multipliers, permissions and allowed tiers. - Permission-based rank discounts. - Compounding work penalty replacing vanilla's "Too Expensive" cap, tracked per item in its persistent data container. - Slot-and-snapshot verification on every purchase, with withdraw-before-repair and refund on failure. - MiniMessage-formatted `messages.yml`.