import { Engine, Component, World, Entity, EntityEvent, PrefabData, Query } from 'geotic'; // Assuming Query is exported for type usage if needed.

// Define some simple components
class Position extends Component {
    static properties: { x: number; y: number } = {
        x: 0,
        y: 0,
    };
    x!: number; // Definite assignment assertion
    y!: number;
}

class Velocity extends Component {
    static properties: { x: number; y: number } = {
        x: 0,
        y: 0,
    };
    x!: number;
    y!: number;
}

class IsFrozen extends Component {}

const engine: Engine = new Engine();

// All Components and Prefabs must be `registered` by the engine
engine.registerComponent(Position);
engine.registerComponent(Velocity);
engine.registerComponent(IsFrozen);

// ...
// Create a world to hold and create entities and queries
const world: World = engine.createWorld();

// Create an empty entity. Call `entity.id` to get the unique ID.
const entity: Entity = world.createEntity();

// Add some components to the entity
entity.add(Position, { x: 4, y: 10 });
entity.add(Velocity, { x: 1, y: 0.25 });

// Create a query that tracks all components that have both a `Position`
// and `Velocity` component but not a `IsFrozen` component. A query can
// have any combination of `all`, `none` and `any`
const kinematics: Query = world.createQuery({
    all: [Position, Velocity], // Pass component classes directly
    none: [IsFrozen]
});

// ...

// Geotic does not dictate how your game loop should behave
const loop = (dt: number): void => {
    // Loop over the result set to update the position for all entities
    // in the query. The query will always return an up-to-date array
    // containing entities that match
    kinematics.get().forEach((entity: Entity) => {
        // Assuming Position and Velocity components add properties to the entity directly
        // For type safety, you might need entity.get(Position).x or cast entity to an extended type.
        const pos = entity.get(Position); // Example of safer access
        const vel = entity.get(Velocity);
        if (pos && vel) {
            pos.x += vel.x * dt;
            pos.y += vel.y * dt;
        }
    });
};

// ...

// Serialize all world entities into a JS object
const data = world.serialize();

// ...

// Convert the serialized data back into entities and components
world.deserialize(data);

import { Engine, World, Component, PrefabData } from 'geotic';

const engine: Engine = new Engine();

// Example Component class
class MyComponent extends Component {
    static properties = { value: 10 };
    value!: number;
}

// Example Prefab data structure
const myPrefab: PrefabData = {
    name: 'MyPrefab',
    components: [{ type: 'MyComponent', properties: { value: 100 } }]
};

engine.registerComponent(MyComponent);
engine.registerPrefab(myPrefab);

const worldInstance: World = engine.createWorld(); // From previous example
engine.destroyWorld(worldInstance);

import { Engine, World, Entity, PrefabData, Query } from 'geotic';

const engine: Engine = new Engine(); // Assume engine is initialized
const world: World = engine.createWorld();

// Create/destroy entities
const newEntity: Entity = world.createEntity();
const entityId: string = newEntity.id;
const retrievedEntity: Entity | undefined = world.getEntity(entityId);
const allEntities: IterableIterator<Entity> = world.getEntities(); // Note: this is an iterator
world.destroyEntity(entityId); // or world.destroyEntity(newEntity)
world.destroyEntities();

// Create queries
// Assuming Position is a registered Component class
const query: Query = world.createQuery({ all: [Position] });

// Create entity from prefab
// Assuming 'MyPrefab' is registered and MyComponent is part of it
const prefabEntity: Entity | undefined = world.createPrefab('MyPrefab', { MyComponent: { value: 200 } });

// Serialize/deserialize entities
const serializedData = world.serialize();
const entitiesToSerialize: Entity[] = [prefabEntity!]; // Example: specific entities
const partialSerializedData = world.serialize(entitiesToSerialize);
world.deserialize(serializedData);

// Create an entity with a new ID and identical components & properties
if (prefabEntity) {
    const clonedEntity: Entity = world.cloneEntity(prefabEntity);
}

// Generate unique entity id
const uniqueId: string = world.createId();

// Destroy all entities and queries
world.destroy();

import { Entity, World, Component, EntityEvent } from 'geotic'; // Assuming these are available

// Define example components for context
class Name extends Component { static properties = { value: "" }; value!: string; }
class Position extends Component { static properties = { x:0, y:0, z:0 }; x!:number; y!:number; z!:number; }
class Velocity extends Component { static properties = { x:0, y:0, z:0 }; x!:number; y!:number; z!:number; }
class Health extends Component { static properties = { value: 0 }; value!: number; }
class Enemy extends Component {}

// Assume world and components are registered
declare const world: World; // From a previous setup
world.engine.registerComponent(Name);
world.engine.registerComponent(Position);
world.engine.registerComponent(Velocity);
world.engine.registerComponent(Health);
world.engine.registerComponent(Enemy);


const zombie: Entity = world.createEntity();

zombie.add(Name, { value: 'Donnie' });
zombie.add(Position, { x: 2, y: 0, z: 3 });
zombie.add(Velocity, { x: 0, y: 0, z: 1 });
zombie.add(Health, { value: 200 });
zombie.add(Enemy);

// Assuming direct property access for components; type safety may require entity.get(Name)
(zombie.get(Name) as Name).value = 'George';
(zombie.get(Velocity) as Velocity).x += 12;

// Firing an event with specific data
zombie.fireEvent('hit', { damage: 12 });

const zombieHealth = zombie.get(Health) as Health;
if (zombieHealth && zombieHealth.value <= 0) {
    zombie.destroy();
}

import { Component, Entity, EntityEvent, World } from 'geotic';

interface HealthProperties {
    current: number;
    maximum: number;
}

class Health extends Component {
    // These define the default values and the serializable shape of the component.
    static properties: HealthProperties = {
        current: 10,
        maximum: 10,
    };

    // Declare instance properties for type safety
    current!: number;
    maximum!: number;

    // Arbitrary helper methods and properties can be declared on components.
    // Note that these will NOT be serialized.
    get isAlive(): boolean {
        return this.current > 0;
    }

    reduce(amount: number): void {
        this.current = Math.max(this.current - amount, 0);
    }

    heal(amount: number): void {
        this.current = Math.min(this.current + amount, this.maximum);
    }

    // This is automatically invoked when a `damage-taken` event is fired
    // on the entity: `entity.fireEvent('damage-taken', { damage: 12 })`
    // The `camelcase` library is used to map event names to methods.
    onDamageTaken(evt: EntityEvent<{ damage: number }>): void {
        // Event `data` is an arbitrary object passed as the second parameter
        // to entity.fireEvent(...)
        this.reduce(evt.data.damage);

        // Handling the event will prevent it from continuing
        // to any other components on the entity.
        evt.handle();
    }

    // Example of a generic event handler
    onEvent(evt: EntityEvent): void {
        console.log(`Health component received event: ${evt.name}`);
    }
    
    // Example lifecycle method
    onAttached(entity: Entity): void {
        console.log(`Health component attached to entity ${entity.id}`);
        // Useful for initialization logic, such as setting up subscriptions or initial calculations.
    }

    // Example lifecycle method
    onDestroyed(): void {
        console.log(`Health component on entity ${this.entity.id} destroyed`);
        // Useful for cleanup logic, like clearing timers or releasing resources.
    }
}

import { Engine, Component, Entity, World } from 'geotic'; // Assume these are available
declare const engine: Engine; // From a previous setup
declare const world: World; // From a previous setup


class Impulse extends Component {
    static properties: { x: number; y: number } = {
        x: 0,
        y: 0,
    };
    x!: number;
    y!: number;
    static allowMultiple: boolean = true;
}

engine.registerComponent(Impulse);

// ...
const player: Entity = world.createEntity();

// Add multiple `Impulse` components to the player
player.add(Impulse, { x: 3, y: 2 });
player.add(Impulse, { x: 1, y: 0 });
player.add(Impulse, { x: 5, y: 6 });

// ...

// Access the array of Impulse components (type assertion for clarity)
const impulses = player.get(Impulse) as Impulse[]; // Or a more specific accessor if available
if (impulses) {
    // Returns the Impulse at position `2`
    console.log(impulses[2]);
    
    impulses.forEach((impulse: Impulse) => {
        console.log(impulse.x, impulse.y);
    });
    // Remove and destroy the first impulse
    impulses[0].destroy();
}
// Returns `true` if the entity has any `Impulse` component
console.log(player.has(Impulse));


// ...

class EquipmentSlot extends Component {
    static properties: { name: string; itemId: string | null } = { // Assuming itemId is string (entity.id) or null
        name: 'hand',
        itemId: null,
    };
    name!: string;
    itemId!: string | null;

    static allowMultiple: boolean = true;
    static keyProperty: string = 'name';

    get item(): Entity | undefined {
        return this.itemId ? this.world.getEntity(this.itemId) : undefined;
    }

    set item(entity: Entity | undefined) {
        this.itemId = entity ? entity.id : null;
    }
}

engine.registerComponent(EquipmentSlot);

// ...

const helmet: Entity = world.createEntity();
const sword: Entity = world.createEntity();

// Add multiple equipment slot components to the player
player.add(EquipmentSlot, { name: 'rightHand' });
player.add(EquipmentSlot, { name: 'leftHand', itemId: sword.id });
player.add(EquipmentSlot, { name: 'head', itemId: helmet.id });

// ...

// Since `EquipmentSlot` had `keyProperty='name'`, access them via the key
// (Type assertion or specific getter needed for type safety)
const headSlot = player.get(EquipmentSlot, 'head') as EquipmentSlot; 
const rightHandSlot = player.get(EquipmentSlot, 'rightHand') as EquipmentSlot;

if (headSlot) console.log(headSlot.name);
if (rightHandSlot) console.log(rightHandSlot.name);


// Example: Clearing an item (assuming direct property access for example, use setter for safety)
if (rightHandSlot) {
    // This would `destroy` the `sword` entity if it was assigned to rightHandSlot
    // and if it's the only reference.
    // If `rightHandSlot.item` holds the sword entity:
    // rightHandSlot.item?.destroy(); // This destroys the sword entity itself.
    // To just clear the slot:
    rightHandSlot.item = undefined; 
}


// Remove and destroy the `rightHand` equipment slot component itself
rightHandSlot?.destroy();

import { World, Entity, Component, Query } from 'geotic'; // Assume these are available
declare const world: World; // From a previous setup

// Define example components
class A extends Component {}
class B extends Component {}
class C extends Component {}
class D extends Component {}
class E extends Component {}
class F extends Component {}


const query: Query = world.createQuery({
    any: [A, B],  // Exclude any entity that does not have at least one of A OR B.
    all: [C, D],  // Exclude entities that don't have both C AND D.
    none: [E, F], // Exclude entities that have E OR F.
});

query.get().forEach((entity: Entity) => { /* ... */ }); // Loop over the latest set (array) of entities that match

// Alternatively, listen for when an individual entity is created/updated that matches
query.onEntityAdded((entity: Entity) => {
    console.log('An entity was updated or created that matches the query!', entity.id);
});

query.onEntityRemoved((entity: Entity) => {
    console.log('An entity was updated or destroyed that previously matched the query!', entity.id);
});

// Assuming A and B are registered Component classes
declare const A: typeof Component;
declare const B: typeof Component;

const query: Query = world.createQuery({
    all: [A, B],
    immutableResult: false, // Defaults to true
});

const results: Entity[] = query.get();

// results.splice(0, 1); // DANGER! Do not modify results if immutableResult is false!

import { World } from 'geotic'; // Assume World is available
declare const world: World;   // From a previous setup

const saveGame = (): void => {
    const data = world.serialize(); // Returns SerializedWorldData
    // Note: JSON.stringify can't directly serialize BigInt, Map, Set etc.
    // The library's serialize method should produce plain JS objects.
    localStorage.setItem('savegame', JSON.stringify(data));
};

const loadGame = (): void => {
    const rawData = localStorage.getItem('savegame');
    if (rawData) {
        const data = JSON.parse(rawData); // data should be SerializedWorldData
        world.deserialize(data);
    }
};

import { Component, Entity, EntityEvent } from 'geotic'; // Assume these are available

// A `Health` component which listens for a `take-damage` event
class Health extends Component {
    static properties = { value: 10 };
    value!: number;

    // Event names are mapped to methods using the `camelcase` library.
    // e.g., 'take-damage' maps to 'onTakeDamage'
    onTakeDamage(evt: EntityEvent<{ amount: number }>): void {
        console.log(evt);
        this.value -= evt.data.amount;

        // The event gets passed to all components on the `entity` unless a component
        // invokes `evt.prevent()` or `evt.handle()`.
        evt.handle();
    }

    // Watch ALL events coming to this component
    onEvent(evt: EntityEvent): void {
        console.log(`Event received by Health component: ${evt.name}`);
        if (evt.is('take-damage')) {
            console.log('It was a take-damage event.');
        }
    }
}

declare const entity: Entity; // Assume an entity is created and Health component is added
// entity.add(Health);

// Fire the event
const eventResult: EntityEvent = entity.fireEvent('take-damage', { amount: 12 });

console.log(eventResult.name);     // "take-damage"
console.log(eventResult.data);     // { amount: 12 }
console.log(eventResult.handled);  // true, because onTakeDamage called evt.handle()
console.log(eventResult.prevented); // true, because evt.handle() also prevents
// evt.handle(); // No need to call again here
// evt.prevent(); 
console.log(eventResult.is('take-damage')); // true

import { Engine, World, PrefabData } from 'geotic'; // Assume these are available
declare const engine: Engine; // From a previous setup
declare const world: World;   // From a previous setup

// Example components (ensure they are registered with the engine)
class Position extends Component { static properties = { x:0, y:0 }; x!:number; y!:number; }
class Material extends Component { static properties = { name: "" }; name!:string; }
class EquipmentSlot extends Component { static properties = { name:"", itemId: null as string|null }; name!:string; itemId!:string|null; }
class WarriorSkills extends Component {} // Example, assuming registered

engine.registerComponent(Position);
engine.registerComponent(Material);
engine.registerComponent(EquipmentSlot);
engine.registerComponent(WarriorSkills);


// Prefabs must be registered before they can be instantiated
const beingPrefab: PrefabData = {
    name: 'Being',
    components: [
        {
            type: 'Position', // Corresponds to registered component class name
            properties: {
                x: 4,
                y: 10,
            },
        },
        {
            type: 'Material',
            properties: {
                name: 'flesh',
            },
        },
    ],
};
engine.registerPrefab(beingPrefab);

const warriorPrefab: PrefabData = {
    name: 'Warrior',
    components: [{ type: 'WarriorSkills' }]
};
engine.registerPrefab(warriorPrefab);


const humanWarriorPrefab: PrefabData = {
    name: 'HumanWarrior',
    // An array of other registered prefab names from which this one inherits.
    // The order of prefab names in the `inherit` array matters for how properties are overridden.
    // Child prefabs can overwrite components and properties from parent prefabs.
    inherit: ['Being', 'Warrior'],
    components: [
        {
            type: 'EquipmentSlot',
            properties: { name: 'head' },
        },
        {
            type: 'EquipmentSlot',
            properties: { name: 'legs' },
        },
        {
            type: 'Material',
            // If a parent prefab (e.g., 'Being') already defines a `Material` component,
            // this flag says how to treat it. Defaults to overwrite=true.
            // If `overwrite: false` and Material is not `allowMultiple`, this component might be ignored.
            overwrite: true, 
            properties: { name: 'silver' },
        },
    ],
};
engine.registerPrefab(humanWarriorPrefab);

// ...

const warrior1: Entity | undefined = world.createPrefab('HumanWarrior');

// Property overrides can be provided as the second argument
const helmetEntity: Entity = world.createEntity(); // Assuming a helmet entity is created
const warrior2: Entity | undefined = world.createPrefab('HumanWarrior', {
    // Component data overrides. 'EquipmentSlot' should match the component's ckey.
    // The structure for overriding keyed/multiple components depends on library implementation.
    // This example assumes component type name (or ckey) as top-level key.
    EquipmentSlot: { // This might be 'equipmentSlot' (camelCase ckey)
        head: { // If EquipmentSlot.keyProperty is 'name'
            itemId: helmetEntity.id
        },
    },
    Position: { // This might be 'position'
        x: 12,
        y: 24,
    },
});