1.1.0 update

Author: dvnxvll

.gitignore

@@ -1,4 +1,6 @@
 node_modules
 **/*/test.ts
 **/*/test.js
-bun.lockb
+bun.lockb
+*.txt
+bench.ts

documentations/binary_operator.md

@@ -0,0 +1,116 @@
+## Binary Operator
+
+BlockCore provides a `Binary` class that implements basic arithmetic operations using bitwise operations. These implementations are useful for understanding binary arithmetic or in scenarios where traditional arithmetic operations aren't preferred.
+
+### Available Operations
+
+#### Addition (ADDER)
+
+Adds two numbers using binary operations.
+
+```typescript
+import { Binary } from "./block-core";
+
+const sum = Binary.ADDER(5, 3); // Returns 8
+```
+
+How it works:
+
+1. Uses bitwise AND (&) to find carry bits
+2. Uses bitwise XOR (^) for addition without carry
+3. Shifts carry left by 1 position
+4. Repeats until no carry remains
+
+#### Subtraction (SUBTRACTER)
+
+Subtracts one number from another using binary operations.
+
+```typescript
+import { Binary } from "./block-core";
+
+const difference = Binary.SUBTRACTER(10, 3); // Returns 7
+```
+
+How it works:
+
+1. Uses bitwise NOT (~) and AND (&) to find borrow bits
+2. Uses bitwise XOR (^) for subtraction without borrow
+3. Shifts borrow left by 1 position
+4. Repeats until no borrow remains
+
+#### Division (DIVIDER)
+
+Performs integer division using binary operations.
+
+```typescript
+import { Binary } from "./block-core";
+
+const quotient = Binary.DIVIDER(15, 3); // Returns 5
+```
+
+How it works:
+
+1. Implements long division algorithm in binary
+2. Uses 31-bit precision
+3. Processes bits from most significant to least significant
+4. Builds quotient bit by bit
+
+#### Multiplication (MULTIPLER)
+
+Multiplies two numbers using binary operations.
+
+```typescript
+import { Binary } from "./block-core";
+
+const product = Binary.MULTIPLER(4, 3); // Returns 12
+```
+
+How it works:
+
+1. Optimizes by swapping operands if needed
+2. Uses Russian Peasant multiplication algorithm
+3. Repeatedly shifts and adds based on bits
+4. Accumulates partial products
+
+### Usage Examples
+
+```typescript
+import { Binary } from "./block-core";
+
+// Addition
+const sum = Binary.ADDER(25, 17);
+console.log(sum); // 42
+
+// Subtraction
+const difference = Binary.SUBTRACTER(100, 45);
+console.log(difference); // 55
+
+// Division
+const quotient = Binary.DIVIDER(156, 12);
+console.log(quotient); // 13
+
+// Multiplication
+const product = Binary.MULTIPLER(23, 7);
+console.log(product); // 161
+```
+
+### Notes
+
+- All operations work with integer values
+- Division returns only the quotient (no remainder)
+- Operations may have different performance characteristics compared to native arithmetic
+- Best used for educational purposes or specific binary arithmetic needs
+- All methods are static and can be called directly from the Binary class
+
+### Implementation Details
+
+Each operation is implemented using only bitwise operators:
+
+- `&` (AND)
+- `|` (OR)
+- `^` (XOR)
+- `~` (NOT)
+- `<<` (Left shift)
+- `>>` (Right shift)
+
+This makes them interesting examples of how arithmetic can be performed at the binary level without using traditional arithmetic operators.

documentations/chunk_manager.md

@@ -0,0 +1,137 @@
+## Managing Chunk Zones
+
+BlockCore provides two classes for managing chunk zones: `Chunker` for 3D chunks and `ChunkerXZ` for 2D chunks in the XZ plane. These classes help you define and manage areas in your world.
+
+### 3D Chunks (Chunker)
+
+The `Chunker` class manages three-dimensional zones defined by start and end positions.
+
+#### Basic Usage
+
+```typescript
+import { Chunker } from "./block-core";
+
+// Create a new 3D chunk
+const chunk = new Chunker(
+  { x: 0, y: 0, z: 0 }, // Start position
+  { x: 16, y: 256, z: 16 }, // End position
+);
+
+// Check if a position is inside the chunk
+const isInside = chunk.isInsideOfChunk({ x: 8, y: 64, z: 8 }); // true
+
+// Check if chunks overlap
+const otherChunk = new Chunker(
+  { x: 10, y: 0, z: 10 },
+  { x: 26, y: 256, z: 26 },
+);
+const isOverlapping = chunk.isOverlapping(otherChunk); // true
+```
+
+#### Methods
+
+- `isInsideOfChunk(pos: ChunkerPos): boolean`
+
+  - Checks if a position is within the chunk boundaries
+  - Position must have x, y, and z coordinates
+
+- `isOverlapping(other: Chunker): boolean`
+
+  - Checks if this chunk overlaps with another chunk
+  - Returns true if any part of the chunks intersect
+
+- `getData: { s_pos: ChunkerPos, e_pos: ChunkerPos }`
+  - Gets the chunk's start and end positions
+
+### 2D Chunks (ChunkerXZ)
+
+The `ChunkerXZ` class manages two-dimensional zones in the XZ plane, useful for defining areas regardless of height.
+
+#### Basic Usage
+
+```typescript
+import { ChunkerXZ } from "./block-core";
+
+// Create a new 2D chunk
+const chunk = new ChunkerXZ(
+  { x: 0, z: 0 }, // Start position
+  { x: 16, z: 16 }, // End position
+);
+
+// Check if a position is inside the chunk
+const isInside = chunk.isInsideOfChunk({ x: 8, z: 8 }); // true
+
+// Check if chunks overlap
+const otherChunk = new ChunkerXZ({ x: 10, z: 10 }, { x: 26, z: 26 });
+const isOverlapping = chunk.isOverlapping(otherChunk); // true
+```
+
+#### Methods
+
+- `isInsideOfChunk(pos: ChunkerPosXZ): boolean`
+
+  - Checks if a position is within the chunk boundaries
+  - Position only needs x and z coordinates
+
+- `isOverlapping(other: ChunkerXZ): boolean`
+
+  - Checks if this chunk overlaps with another chunk
+  - Returns true if any part of the chunks intersect
+
+- `getData: { s_pos: ChunkerPosXZ, e_pos: ChunkerPosXZ }`
+  - Gets the chunk's start and end positions
+
+### Type Definitions
+
+```typescript
+interface ChunkerPos {
+  x: number;
+  y: number;
+  z: number;
+}
+
+interface ChunkerPosXZ {
+  x: number;
+  z: number;
+}
+```
+
+### Common Use Cases
+
+1. Defining Protected Areas
+
+```typescript
+const spawnProtection = new ChunkerXZ({ x: -100, z: -100 }, { x: 100, z: 100 });
+
+// Check if player is in protected area
+const isProtected = spawnProtection.isInsideOfChunk(playerPosition);
+```
+
+2. Creating Building Zones
+
+```typescript
+const buildingZone = new Chunker(
+  { x: 0, y: 0, z: 0 },
+  { x: 100, y: 256, z: 100 },
+);
+
+// Check if block placement is allowed
+const canBuild = buildingZone.isInsideOfChunk(blockPosition);
+```
+
+3. Detecting Zone Conflicts
+
+```typescript
+const zone1 = new ChunkerXZ({ x: 0, z: 0 }, { x: 50, z: 50 });
+const zone2 = new ChunkerXZ({ x: 40, z: 40 }, { x: 90, z: 90 });
+
+// Check if zones overlap
+const hasConflict = zone1.isOverlapping(zone2);
+```
+
+### Notes
+
+- Coordinates can be provided in any order - the system automatically determines min/max values
+- Both classes handle coordinate calculations efficiently
+- Useful for defining protection zones, build areas, or any other spatial boundaries
+- ChunkerXZ is more performant when Y-axis checks aren't needed

documentations/custom_commands.md

@@ -0,0 +1,92 @@
+## Creating Custom Commands
+
+BlockCore provides a powerful command builder and register system that allows you to create custom commands with ease. This guide will walk you through the process of creating a custom command using BlockCore.
+
+### CommandBuilder
+
+The main class for building and managing custom commands.
+
+#### Methods
+
+- `Build(command: CommandBuilder): void`
+
+  Builds and registers a new command.
+
+  | Parameter           | Type              | Description                                    |
+  | ------------------- | ----------------- | ---------------------------------------------- |
+  | `options.register`  | `CommandRegister` | The command registration configuration         |
+  | `options.onExecute` | `Function`        | Callback function executed when command is run |
+
+### CommandRegister
+
+Class for configuring command properties.
+
+#### Methods
+
+- `setName(name: string): CommandRegister`
+
+  Sets the command name.
+
+- `setDescription(desc: string): CommandRegister`
+
+  Sets the command description. Defaults to "No Description."
+
+- `setCategory(cname: string): CommandRegister`
+
+  Sets the command category. Defaults to "Global"
+
+- `setPerms(perms: string[]): CommandRegister`
+
+  Sets required permissions tags.
+
+- `setAliases(alias: string[]): CommandRegister`
+
+  Sets alternative command names.
+
+- `setUsage(usage: string[]): CommandRegister`
+
+  Sets command usage instructions.
+
+- `setExample(eg: string[]): CommandRegister`
+
+  Sets example command usages.
+
+- `setInputs(inputs: InputTypes): CommandRegister`
+
+  Sets expected input types for command arguments.
+
+  ```typescript
+  type InputTypes = {
+    [argumentIndex: number]: ("string" | "boolean" | "number" | "playername")[];
+  };
+  ```
+
+  Input type `playername` is a special type that only accepts player names starting with "@".
+
+#### `onExecute` Callback Properties
+
+The callback function receives an object with these properties:
+
+| Property      | Type          | Description                          |
+| ------------- | ------------- | ------------------------------------ |
+| `sender`      | `PlayerActor` | The player who executed the command  |
+| `getInput`    | `Function`    | Gets parsed input at specified index |
+| `core_config` | `Object`      | Access to core configuration         |
+| `logger`      | `Logger`      | Logger instance for debugging        |
+
+Example usage:
+
+```typescript
+CommandBuilder.Build({
+  register: new CommandRegister()
+    .setName("example")
+    .setInputs({ 0: ["string"] }),
+  onExecute: ({ sender, getInput }) => {
+    const first_input = getInput(0); // Get first argument
+    const player = sender.unwrap();
+    player.sendMessage(`Got input: ${first_input}`);
+  },
+});
+```
+
+Note: The `CommandBuilder` class provides a convenient way to create and register custom commands, while the `CommandRegister` class allows you to configure the command properties.