toaimin-indie-engine 1.0.1 → 1.0.4

package/README.md

@@ -1,55 +1,139 @@
-# FrameworkGame
+# toaimin-indie-engine 🚀
 
-A production-grade, modular 2D game framework in TypeScript for Web/HTML5 tailored for indie game developers.
+A production-grade, highly scalable, and developer-friendly **2D Game Engine** built purely in TypeScript. Designed specifically for Indie Developers who want maximum performance with minimum boilerplate.
 
-## Features
+![NPM Version](https://img.shields.io/npm/v/toaimin-indie-engine)
+![License](https://img.shields.io/npm/l/toaimin-indie-engine)
 
-- **Zero Heavy Runtime Dependencies**: Pure TypeScript, minimal footprint, maximum performance.
-- **Fixed-Timestep Simulation**: 60Hz deterministic game loop with render interpolation (`alpha`) and spiral-of-death protection.
-- **Robust Math & Affine Transforms**:
-  - `Vector2`: High-performance 2D vector with mutable in-place chaining, immutable helpers, and zero-division guards.
-  - `Matrix2D`: 3x3 Canvas-compatible affine transformation matrix with determinant, inversion, point/direction transform.
-  - `Transform2D`: Hierarchical scene-graph transform with parent-child propagation and lazy dirty-flag caching.
-  - `Rect` & `Circle`: 2D spatial primitives with comprehensive intersection and containment algorithms.
-  - `MathUtils`: Frame-rate independent exponential damping (`damp`), angle wrapping, clamp, lerp, and RNG helpers.
-  - `Color`: High-precision RGBA color with Hex, RGB, RGBA, HSL parsing and string formatting.
-- **Core Engine Lifecycle**:
-  - `GameLoop`: Accumulator-based loop separating `update(dt)`, `fixedUpdate(fixedDt)`, and `render(alpha)`.
-  - `Time`: Scaled and unscaled delta time tracking with rolling average FPS counter.
-  - `EventEmitter`: Type-safe pub/sub event bus with snapshot iteration and unbind helpers.
+## 🌟 Key Features
 
-## Installation & Build
+* **Fluent API (Builder Pattern):** Create complex game entities without classes. Chain `.withSprite().withPhysics()` seamlessly.
+* **CLI Tool (`indie-engine`):** Generate a complete game project with `init`, run with `dev`, and package with `build` in one click.
+* **Tiled Map Integration (v1.0.1):** Load `.json` tilemaps exported from the popular *Tiled Editor*. Automatically generates static physics colliders for your map layers!
+* **Real-time Multiplayer (v1.0.2):** Built-in Native WebSocket client and `NetworkIdentity` component. Sync player positions globally with zero extra libraries.
+* **Tweening & Easing (v1.0.3):** Butter-smooth animations for UI and sprites. 12+ Easing curves included (Bounce, Elastic, Quad, etc).
+* **Robust Physics 2D:** Rigid bodies, Box/Circle colliders, and contact solvers built-in.
+* **Zero Heavy Dependencies:** Extremely lightweight and fast.
+
+---
+
+## 📦 Quick Start (CLI)
+
+No need to configure Webpack or Vite. Just use our global CLI!
 
 ```bash
-# Build library (ESM, CJS, and TypeScript typings)
-npm run build
+# 1. Create a new game project
+npx toaimin-indie-engine init my-awesome-game
 
-# Run unit test suite
-npm run test
+# 2. Go to your folder
+cd my-awesome-game
 
-# Run interactive demo
+# 3. Start the dev server
 npm run dev
 
-# Build demo for production
-npm run build:demo
+# 4. Build for Android/iOS (Auto-installs Capacitor & SDK wrappers)
+npm run build:android
+npm run build:ios
+
+# 5. Build for Desktop PC/Mac (Auto-installs Electron)
+npm run build:desktop
+```
+
+---
+
+## 🎮 Writing Code the "Indie" Way
+
+Forget messy boilerplate. Here is how you create a moving player:
+
+```typescript
+import { createIndieGame, createEntity, Scene } from 'toaimin-indie-engine';
+
+class MainScene extends Scene {
+  override onStart() {
+    // Spawn a player with Physics and Sprite!
+    createEntity('Player')
+      .withPosition(400, 300)
+      .withSprite('assets/ninja.png')
+      .withPhysics({ type: 'dynamic', mass: 10 })
+      .withBoxCollider(64, 64)
+      .onUpdate((dt, entity) => {
+        // Your logic here (e.g. Move right)
+        entity.transform.position.x += 100 * dt;
+      })
+      .build()
+      .setParent(this.root);
+  }
+}
+
+// Bootstrap the game!
+createIndieGame()
+  .setSize(800, 600)
+  .setBackground('#222')
+  .addScene('Main', MainScene)
+  .start();
+```
+
+---
+
+## 🗺️ Tiled Map Support (Auto Collisions)
+
+Draw your map in *Tiled*, export as JSON, and load it into your game. If you name your collision layer `"Collisions"`, the engine will automatically generate invisible walls for you!
+
+```typescript
+import { createTilemap } from 'toaimin-indie-engine';
+
+const map = createTilemap('assets/level1.json', 'Collisions');
+map.setParent(this.root);
 ```
 
-## Architecture
+---
+
+## 🌐 Real-time Multiplayer Plugin
+
+Make your game online in literally 2 steps:
 
+```typescript
+import { MultiplayerPlugin, createEntity } from 'toaimin-indie-engine';
+
+// 1. Enable Plugin
+createIndieGame()
+  .use(new MultiplayerPlugin({ url: 'wss://your-server.com' }))
+  .start();
+
+// 2. Add NetworkIdentity to sync position globally
+createEntity('OnlinePlayer')
+  .withPosition(100, 100)
+  .withNetworkIdentity('player_123', true) // true = Local Player
+  .build();
 ```
-src/
-├── index.ts              # Framework public entry point
-├── core/                 # GameLoop, Time, EventEmitter
-├── math/                 # Vector2, Matrix2D, Transform2D, Rect, Circle, MathUtils, Color
-├── rendering/            # Canvas2D renderer, camera, sprites, particles (M2)
-├── physics/              # Rigid bodies, colliders, contact solver (M3)
-├── input/                # Keyboard, pointer, touch, virtual joystick (M2)
-├── audio/                # Web Audio bus, voice pool, synth (M4)
-├── scene/                # Scene lifecycle, modal stack, transitions (M4)
-├── ui/                   # Retained-mode UI hierarchy, widgets (M4)
-└── entity/               # Entity-component model (M5)
+
+---
+
+## 🎬 Tweening Animations
+
+Animate UI buttons, coins, or anything smoothly!
+
+```typescript
+import { tween } from 'toaimin-indie-engine';
+
+// Make a coin bounce up
+tween(coin.transform.position)
+  .to({ y: coin.transform.position.y - 50 }, 1000)
+  .easing('BounceOut')
+  .start();
 ```
 
+---
+
+## 🏛️ Architecture
+
+If you prefer the hardcore OOP way, the engine fully supports ECS (Entity Component System):
+
+* `Game`: Core Orchestrator
+* `Entity`: The Node/GameObject
+* `Component`: Behavior logic (e.g., `ScriptComponent`, `SpriteComponent`)
+* `System`: PhysicsWorld2D, SceneManager, InputManager
+
 ## License
 
-MIT
+MIT © Toaimin

package/cli/bin.cjs

@@ -1,17 +1,22 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 
 const args = process.argv.slice(2);
 const command = args[0];
 
 if (!command) {
   console.log('Usage: indie-engine <command>');
-  console.log('Commands: init, dev, build');
+  console.log('Commands: init, dev, build, build:android, build:ios, build:desktop');
   process.exit(1);
 }
 
+const runCommand = (cmd, cwd = process.cwd()) => {
+  console.log(`> ${cmd}`);
+  execSync(cmd, { stdio: 'inherit', cwd });
+};
+
 if (command === 'init') {
   const projectName = args[1] || 'my-game';
   const targetDir = path.resolve(process.cwd(), projectName);
@@ -31,19 +36,19 @@ if (command === 'init') {
     private: true,
     scripts: {
       dev: "indie-engine dev",
-      build: "indie-engine build"
+      build: "indie-engine build",
+      "build:android": "indie-engine build:android",
+      "build:ios": "indie-engine build:ios",
+      "build:desktop": "indie-engine build:desktop"
     },
     dependencies: {
-      "framework-game": "latest"
+      "toaimin-indie-engine": "latest"
     }
   };
 
-  fs.writeFileSync(
-    path.join(targetDir, 'package.json'),
-    JSON.stringify(pkgJson, null, 2)
-  );
+  fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
 
-  const mainTs = `import { createIndieGame, createEntity, Scene } from 'framework-game';
+  const mainTs = `import { createIndieGame, createEntity, Scene } from 'toaimin-indie-engine';
 
 class MainScene extends Scene {
   override onStart() {
@@ -51,9 +56,6 @@ class MainScene extends Scene {
       .withPosition(400, 300)
       .withSprite({ texture: 'assets/player.png', width: 64, height: 64 })
       .withPhysics({ type: 'dynamic', mass: 10 })
-      .onUpdate((dt, entity) => {
-        // Player logic here
-      })
       .build()
       .setParent(this.root);
   }
@@ -73,10 +75,7 @@ createIndieGame()
 <head>
   <meta charset="UTF-8">
   <title>${projectName}</title>
-  <style>
-    body { margin: 0; background: #000; display: flex; justify-content: center; align-items: center; height: 100vh; }
-    canvas { display: block; }
-  </style>
+  <style>body { margin: 0; background: #000; display: flex; justify-content: center; align-items: center; height: 100vh; }</style>
 </head>
 <body>
   <script type="module" src="/src/main.ts"></script>
@@ -86,13 +85,70 @@ createIndieGame()
   fs.writeFileSync(path.join(targetDir, 'index.html'), html);
 
   console.log(`Created project ${projectName}`);
-  console.log(`cd ${projectName}`);
-  console.log(`npm install`);
-  console.log(`npm run dev`);
+  console.log(`cd ${projectName} && npm install`);
 } else if (command === 'dev' || command === 'build') {
   const viteRunnerPath = path.join(__dirname, 'vite-runner.cjs');
   const child = spawn('node', [viteRunnerPath, command], { stdio: 'inherit' });
   child.on('exit', (code) => process.exit(code));
+} else if (command === 'build:android' || command === 'build:ios') {
+  const platform = command.split(':')[1];
+  console.log(`🚀 Building for ${platform.toUpperCase()}...`);
+  
+  // 1. Build web first
+  const viteRunnerPath = path.join(__dirname, 'vite-runner.cjs');
+  runCommand(`node "${viteRunnerPath}" build`);
+
+  // 2. Init capacitor if missing
+  if (!fs.existsSync(path.join(process.cwd(), 'capacitor.config.json'))) {
+    console.log('Installing Capacitor CLI...');
+    runCommand('npm install @capacitor/cli @capacitor/core');
+    runCommand(`npx cap init mygame com.indie.game --web-dir dist`);
+  }
+
+  // 3. Add platform if missing
+  if (!fs.existsSync(path.join(process.cwd(), platform))) {
+    console.log(`Installing Capacitor ${platform}...`);
+    runCommand(`npm install @capacitor/${platform}`);
+    runCommand(`npx cap add ${platform}`);
+  }
+
+  // 4. Sync and open
+  runCommand(`npx cap sync ${platform}`);
+  console.log(`✅ Ready! Run 'npx cap open ${platform}' to build the binary.`);
+} else if (command === 'build:desktop') {
+  console.log(`🚀 Building for DESKTOP (Electron)...`);
+  
+  // 1. Build web
+  const viteRunnerPath = path.join(__dirname, 'vite-runner.cjs');
+  runCommand(`node "${viteRunnerPath}" build`);
+
+  // 2. Setup Electron
+  if (!fs.existsSync(path.join(process.cwd(), 'electron'))) {
+    fs.mkdirSync(path.join(process.cwd(), 'electron'));
+    const mainJs = `
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+function createWindow() {
+  const win = new BrowserWindow({ width: 800, height: 600 });
+  win.loadFile(path.join(__dirname, '../dist/index.html'));
+}
+app.whenReady().then(createWindow);
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'electron', 'main.js'), mainJs);
+    
+    // Modify package.json to point to main
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    pkg.main = "electron/main.js";
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+
+    console.log('Installing Electron dependencies...');
+    runCommand('npm install electron electron-builder --save-dev');
+  }
+
+  console.log(`✅ Desktop structure ready!`);
+  console.log(`Test: npx electron .`);
+  console.log(`Build: npx electron-builder --mac --win --linux`);
 } else {
   console.error(`Unknown command: ${command}`);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toaimin-indie-engine",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Production-grade 2D Game Framework in TypeScript for Web/HTML5 designed for indie game developers",
   "type": "module",
   "bin": {