Strilanc/Tinker

Tinker is a Warcraft III game hosting bot that manages Battle.net connectivity, game session creation, and LAN advertising. It provides infrastructure for hosting games, recording replays, and handling map transfers, while supporting extensibility through a plugin system and structured command interface.

27 changes.

The project was rebranded from HostBot to Tinker and upgraded to .NET 4.5, enabling a comprehensive shift to asynchronous programming patterns. This period involved a major architectural overhaul, replacing monolithic classes with modular components, typed interfaces, and a structured command system to improve maintainability and testability.

5 changes.

This period focused on restructuring the Bnet and Warcraft 3 protocol layers by introducing definition-driven serialization and explicit packet definitions. The team also rebuilt the replay recording and parsing engine to handle .w3g files and refactored map download logic into modular, dependency-injected components. Additionally, a new LAN game advertising system was implemented using UDP broadcasting.

This change introduces the core user interface for the Tinker bot, including the main ClientForm for application lifecycle and plugin loading, the ExceptionForm for logging unexpected errors, the LoggerControl for displaying and saving bot messages, the CommandControl with up/down history navigation, and the SettingsForm for managing profiles, plugins, and network ports. It also removes the legacy BnetClientControl, indicating a shift in how the Battle.net client is integrated into the new component-based architecture.

Interface · high confidence

A new Components folder has been introduced, containing the core infrastructure for managing bot plugins. This includes the IBotComponent interface defining the contract for extensibility, a ComponentSet class for asynchronous component lifecycle management, and UI controls (TabControl, TabManager, GenericBotComponentControl) that display components in tabs and handle command invocation. The UI controls are wired to observe component additions and removals, automatically updating the interface as plugins are loaded or unloaded.

Components · high confidence

The application now includes a new LAN advertising feature that broadcasts Warcraft 3 games to the local network using UDP on port 6112. This change introduces a new \UDPAdvertiser\ component, a corresponding bot component (\UDPAdvertiserComponent\), and a user interface control (\UDPAdvertiserControl\) that displays the list of advertised games and logs activity. Users can now manually add or remove advertised games via bot commands (Add, Remove, Host) or enable automatic advertising of all hosted games. The underlying implementation has been refactored to use dependency injection for the clock and utilizes the \IRist\ collection type.

Lan · high confidence

The Warcraft3 module introduces a new Pinger class for measuring network latency using an IClock-based timer and a task-based call queue, replacing previous timing mechanisms. Additionally, the lobby slot system has been refactored: the Slot structure is now immutable with a new With method for property updates, SlotContents is split into a hierarchy of classes (Open, Closed, Computer, Player) to manage slot states, and a new SlotSet class provides immutable collection operations for managing multiple slots.

Warcraft3 · high confidence

The Library now includes an \ObservableCollection(Of T)\ that supports asynchronously observing item additions and removals via an action queue, replacing the previous synchronous \AsyncViewableCollection\ model. Additionally, a new \Common Async\ module provides extension methods for asynchronous stream reading (\ReadExactAsync\, \ReadBestEffortAsync\), task disposal (\DisposeAsync\, \DisposeAllAsync\, \DisposeControlAsync\), and exception handling (\ConsiderExceptionsHandled\), alongside a \FirstMatchAsync\ method for filtering sequences of futures.

Library · high confidence

The Commands module has been refactored to introduce a structured command system. This includes a new ICommand interface and BaseCommand class for defining commands with permissions and help topics, a CommandArgument class for parsing raw, named, and optional arguments, and a CommandTemplate class for validating arguments against expected formats. Additionally, a CommandSet class allows for subcommand routing, and a TemplatedCommand base class simplifies the creation of commands that require strict argument validation.

Commands · high confidence

The Warcraft 3 protocol layer now includes explicit definitions for game actions (GameActionId), object types (ObjectType), and order IDs (OrderId), along with corresponding serialization jars (GameActionJar, GameObjectIdJar, ObjectTypeJar, OrderIdJar, PlayerActionSetJar) and game statistics handling (GameStatsJar). This change formalizes the binary encoding/decoding of game state, player actions, and map statistics, replacing previous ad-hoc or less structured approaches with a typed, definition-driven pickling system.

Warcraft3/Protocol · high confidence

The Warcraft 3 replay system has been rebuilt to support recording and parsing of .w3g replay files. This change introduces a new ReplayManager that automatically records game events (player joins/leaves, chat, ticks) to a file, and a ReplayReader that parses existing replays by validating headers, checksums, and block data. The underlying format is defined in Replay Format.vb with specific entry types (StartOfReplay, PlayerJoined, LobbyState, Tick, etc.) and packers in Replay Entry Packers.vb handle serialization.

Warcraft3/Replay · high confidence

The Warcraft 3 server component now provides the core infrastructure for hosting and managing game sessions. This includes the GameServer class for handling incoming player connections and the GameSet class for managing individual game instances, including automatic instance creation and disposal. Game settings are now configurable via a dedicated GameSettings class, supporting options such as map selection, team sizes, player reservations, and replay recording. A new 'Add' command allows administrators to create and configure game sets through the bot interface, and the server UI control has been updated to display active games and server status.

Warcraft3/Server · high confidence

The RecyclingBin folder has been completely emptied by deleting all its contents, including the BotCommander, BotStats, RelayServer, Settings, and various UI controls (FrmLogger, TimeGraphControl, W3SlotControl, W3StatsControl). This removes the associated bot command logic, statistics tracking, network relay infrastructure, and settings UI components from the project.

RecyclingBin · high confidence

The CKL Server widget (Bot/Widgets/CKL Server.vb) has been removed, eliminating the ability to host a local CD Key Library server for authenticating Battle.net logins. Additionally, the legacy widget framework files (Bot/Widgets/Hookable.vb), including the IBotWidget interface and the TabControlIHookableSet UI helper, have been deleted, indicating a shift away from the previous component-based widget architecture.

Bot/Widgets · high confidence

The Libraries area has removed several foundational components, including the ArrayView, BigNum, BitBuffer, and MStack data structures, as well as the Functional module containing Futures, call queues, and common utilities. This deletion eliminates the ability to use these specific data types and asynchronous execution patterns within the application.

Libraries · high confidence

Deleted the legacy BnetClient, BnetCrypt, BnetPacket, and BnetSocket classes from the Battlenet module. This removes the old direct socket-based implementation for connecting to the Battle.net service, including its custom packet parsing, cryptographic key generation, and socket handling logic.

Battlenet · high confidence

The Bnet client logic has been restructured to improve modularity and testability. The core client is now exposed as a \ClientComponent\ that implements \IBotComponent\, managing its own command set and lifecycle. Client commands (such as Disconnect, AddUser, Promote, Demote, Auto, and LogOn) have been extracted into individual, strongly-typed classes within the \Bnet.Commands\ namespace, replacing the previous monolithic command handling. This change also introduces a dedicated \BnetClientControl\ UI component that binds to the \ClientComponent\, ensuring that UI interactions are properly queued and synchronized with the client's asynchronous state machine.

Bnet · high confidence

The Warcraft 3 game hosting logic has been restructured to improve maintainability and testability. The core game state and timing are now managed by a new GameKernel class, which centralizes the game clock, player collection, and internal queues. Lobby management, including slot handling, player visibility, and team setup, has been extracted into a dedicated GameLobby class. Additionally, game commands (such as boot, cancel, color, and CPU) are now defined in a separate GameCommands file, organized by user role (host vs. guest) and context (lobby vs. in-game). This separation isolates the game's internal mechanics from its command interface and lobby state, making the system easier to extend and debug.

Warcraft3/Game · high confidence

The bot's command system has been refactored from a monolithic class into distinct, class-based commands (e.g., CommandConnect, CommandCreateAdminGame) that support asynchronous execution. These commands now accept an IClock dependency to manage time-dependent operations explicitly, replacing implicit system clocks. The MainBotManager now exposes a CommandSet for registering and invoking these commands, and the command syntax has been updated to use named arguments (e.g., name=game map=map) instead of positional arguments.

Bot · high confidence

The command system in Bot/Commands has been completely rewritten. The old interface-based command structure (ICommand, BaseCommand) and the monolithic command files (Base Commands, Bot Commands, Client Commands, etc.) have been removed. This change introduces a new command syntax where arguments are parsed using named parameters (e.g., \host name=\<game name\> map=map\) instead of positional arguments, and commands now use a new \Command\<T\>\ class with \CommandArgument\ and \CommandTemplate\ for validation. This affects how users interact with bot commands, requiring updated syntax for argument passing.

Bot/Commands · high confidence

The Bnet protocol logic has been reorganized into the Bnet.Protocol namespace, introducing a new Packet class and a BnetPacketHandler factory for logging. This change adds comprehensive serialization support (Jars) for Bnet packets, including authentication, chat, and game listing, alongside specific data type jars for IP addresses, endpoints, file times, and product credentials. The Packet class now relies on Definition-based factories for packing values, and the handler uses a raw packet handler with header extraction.

Bnet/Protocol · high confidence

The Warden module now includes a new \Warden.Socket\ class and a \BNLS Protocol\ file that define the low-level communication with the Battle.net Login Server (BNLS). The \Warden.Socket\ handles asynchronous connection, packet sending, and receiving using the newly defined \BNLSPacketId\ and \WardenPacketId\ enums, replacing the previous implementation. This change introduces a dedicated socket layer for warden-related network traffic, separating it from the higher-level client logic.

Warden · high confidence

The plugin architecture has been restructured to support asynchronous command registration and improved lifecycle management. The \IPlugin\ interface now includes an \IncludeCommand\ method that returns a \Task(Of IDisposable)\, allowing plugins to register commands asynchronously. A new \PluginManager\ class implements \IBotComponent\ to manage plugin instances, delegating command invocations and disposal to the underlying plugin socket. The \PluginSocket\ handles assembly loading via \TinkerPluginFactory\ and ensures proper disposal of plugin resources. Contract invariants and preconditions have been added to enforce non-null requirements for plugins, commands, and bot references.

Plugins · high confidence

The application has been renamed from HostBot to Tinker, reflected in the project files, settings namespace, and default in-game name. The runtime target has been upgraded from .NET Framework 2.0 to 4.5, and the configuration file has been reset to default values, removing previously hardcoded paths and version numbers while adding new settings for BNLS server address, default game greetings, and replay build numbers.

(repo-wide) · high confidence

The application has been rebranded from HostBot to Tinker, reflected in the assembly title, product name, and the main form reference (ClientForm). Default settings have been updated: the in-game name is now "Tinkr" with a green color code, the default game greeting is "Hosted by Tinker", and the port pool has shifted to 6114-6119. Several legacy settings (exeVersion, exeInformation, debugMode) were removed, while new settings for BNLS server address, default game greeting, and replay build number were added. The default map and Warcraft III paths were cleared to empty strings.

My Project · high confidence

The Pickling module has been restructured to introduce a new set of framing jars (FixedSizeFramingJar, LimitedSizeFramingJar, SizePrefixedFramingJar, NullTerminatedFramingJar, and OptionalFramingJar) and specialized jars like DataJar, EmptyJar, KeyPrefixedJar, and NamedJar. This refactoring simplifies the serialization of complex data structures by providing explicit framing logic and improves the user experience by adding robust UI controls (IValueEditor) for editing these values, including support for hex display in numeric jars and flag-based selection in enum jars.

Pickling · high confidence

The Warcraft 3 player system now uses a dedicated \PlayerId\ structure (range 1–12) instead of raw byte indices or integers. This change introduces a new \PlayerId.vb\ file containing the structure and its associated \PlayerIdJar\ for serialization, and updates \W3Player\ to store and expose this typed ID via the \Id\ property. This provides stronger type safety and clearer semantics for player indexing within the game protocol.

Warcraft3/Player · high confidence

The Warcraft 3 hosting bot has undergone a significant structural refactoring. The \W3DummyPlayer\ class, used for simulating players and handling map downloads, has been removed entirely. Additionally, the \IW3Game\ interface and its associated sub-interfaces (\IW3GameLobby\, \IW3GameLoadScreen\, \IW3GamePlay\) have been deleted, with their implementations folded directly into the \W3Game\ class and its internal nested classes. This change simplifies the codebase by removing unnecessary abstraction layers and consolidating game state management.

Battlenet/Warcraft3 · high confidence

The map download functionality has been restructured from a monolithic class into distinct components: \TransferClient\, \Transfer\, and \Manager\, along with the \IPlayerDownloadAspect\ interface. This change introduces dependency injection for the \IClock\ service into the download logic, enabling more precise control over timing and state management during map transfers. The new architecture separates concerns by handling client state (\TransferClient\), the active data stream (\Transfer\), and orchestration (\Manager\), while enforcing strict contract invariants to improve reliability.

Warcraft3/Download · high confidence

The CKL (CD Key Lending) functionality has been refactored into a set of dedicated classes within the CKL namespace: a Client for authenticating with the CKL server, a Server for managing and lending keys to BNet clients, a ServerManager for bot integration, and specific command classes for adding and removing keys. This change organizes the key-lending logic into distinct, asynchronous components, improving maintainability and separating concerns between the server-side key management and the client-side authentication flow.

CKL · high confidence

Added unit tests for BNet protocol and client connectivity; New test utilities for pickling, streams, and shared test fixtures; Removal of obsolete test utilities.

The application has been rebranded from HostBot to Tinker, including the project name, assembly name, and root namespace. The build system has been upgraded from Visual Studio 2008 (.NET Framework 3.5) to Visual Studio 2010 (.NET Framework 4.5). This change introduces support for modern language features such as async/await and Task-based asynchronous patterns, and updates the project to use Code Contracts with runtime checking enabled.

(dependencies) · high confidence

The HostBotTests project now includes an AssemblyInfo file that defines standard assembly metadata, including the title, company (Microsoft), product name, copyright year (2009), and version numbers (1.0.0.0). This ensures the test assembly is properly identified and compliant with COM visibility and CLS standards.

HostBotTests/My Project · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 43 (+5.8)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 90 (new)
• Architecture 65 (new)
• Maturity 27 → 39 (+12.9)
• Readiness 26 → 26 (+0.0)
• Security 95 → 95 (+0.0)

• Dependency hygiene not measured — no supported dependency manifest was read
• Dimension evaluation failed
• No exposed public API
• Test reliability not included
• complexity unreadable for .vb — churn × complexity hotspots could not be measured
• dormant codebase — no living knowledge left to concentrate

• ClassTooLong: Client (Bnet/Bnet Client.vb)
• ClassTooLong: GameCommands (Warcraft3/Game/Game Commands.vb)
• ClassTooLong: GameSettings (Warcraft3/Server/GameSettings.vb)
• ClassTooLong: PicklingTest (HostBotTests/PicklingTest.vb)
• CommandArgument.New.ctor (cognitive 26) (Commands/CommandArgument.vb)
• CommandArgument.Tokenize (cognitive 26) (Commands/CommandArgument.vb)
• CommandTemplate.TryFindMismatch (cognitive 22) (Commands/CommandTemplate.vb)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (Warcraft3/W3Map.vb)
• Duplicated block (11 lines × 2) (Library/Stream Extensions.vb)
• Duplicated block (11 lines × 3) (Warcraft3/Game/Game Commands.vb)
• Duplicated block (24 lines × 2) (Bot/MainBot.vb)
• Duplicated block (5 lines × 2) (Warcraft3/Server/GameServer.vb)
• Duplicated block (6 lines × 2) (Bnet/ClientCredentials.vb)
• Duplicated block (6 lines × 2) (Pickling/Pickling Base.vb)
• Duplicated block (6 lines × 3) (Warcraft3/W3GameDescription.vb)
• Duplicated block (7 lines × 2) (Warcraft3/W3GameDescription.vb)
• EmptyCatchBlock (Bot/MainBot.vb)
• EmptyCatchBlock (HostBotTests/Utilities/Common.vb)
• …and 43 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Strilanc/Tinker was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.