import * as THREE from 'three';
import { AABB, Vector3 } from 'yuka';

// Three.jsでBoxGeometryを用意
const boxGeometry = new THREE.BoxGeometry(1, 1, 1);
const boxMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial);

// シーンやカメラ、レンダラーの初期化を省略

// YukaのAABBを作成
const aabb = new AABB(
  new Vector3(-0.5, -0.5, -0.5),
  new Vector3( 0.5,  0.5,  0.5)
);

// 毎フレーム更新でAABBをオブジェクト位置に合わせる例
function update() {
  // Three.js上のオブジェクトワールド行列などを取得
  const worldPos = new THREE.Vector3();
  boxMesh.getWorldPosition(worldPos);

  // AABBの中心を移動させたい場合、
  // AABB自体をMatrix4で変換するメソッド： aabb.applyMatrix4(threeMatrix) も利用可
  // ここでは簡易的に min/max を移動させる
  const offset = worldPos; // Vector3として扱う
  aabb.min.set(-0.5 + offset.x, -0.5 + offset.y, -0.5 + offset.z);
  aabb.max.set( 0.5 + offset.x,  0.5 + offset.y,  0.5 + offset.z);

  // 他のAABBとの衝突判定
  // if ( aabb.intersectsAABB(otherAABB) ) { ... }

  requestAnimationFrame(update);
  renderer.render(scene, camera);
}

update();

import * as THREE from 'three';
import { Vehicle, SteeringManager, AlignmentBehavior } from 'yuka';

const scene = new THREE.Scene();

//  YukaのVehicleを定義 
const vehicle = new Vehicle();
vehicle.position.set(0, 0, 0);

// 周辺の仲間を想定する配列
const neighbors = [ /* 他のVehicleの配列 */ ];

// ステアリング行動を管理するSteeringManager
const steeringManager = new SteeringManager(vehicle);

// AlignmentBehaviorを追加
const alignment = new AlignmentBehavior();
// このビヘイビアは「仲間のVehicleリスト」を参照して向きを合わせる
// neighborsをVehicle内のneighborsに設定するか、もしくはクラス拡張で参照させるケース多し

steeringManager.add(alignment);

//  Three.jsの描画用メッシュ 
const geometry = new THREE.SphereGeometry(0.2, 16, 16);
const material = new THREE.MeshNormalMaterial();
const mesh = new THREE.Mesh(geometry, material);
scene.add(mesh);

// 毎フレーム更新でYukaのステアリングを計算→Three.jsに反映
function update() {
  const delta = 0.016; // 仮に1/60秒
  steeringManager.calculate(delta);

  // vehicle.update()すると、Vehicleのpositionやvelocityが更新される
  vehicle.update(delta);

  // Three.jsのメッシュに位置と向きを反映
  mesh.position.copy(vehicle.position);

  requestAnimationFrame(update);
  renderer.render(scene, camera);
}

update();

import * as THREE from 'three';
import { Vehicle, SteeringManager, ArriveBehavior, Vector3 } from 'yuka';

const scene = new THREE.Scene();

// 目的地
const target = new Vector3(5, 0, 0);

// Vehicle
const vehicle = new Vehicle();
vehicle.position.set(0, 0, 0);

// Arriveビヘイビア
const arrive = new ArriveBehavior(target);
arrive.deceleration = 3; // 減速の度合い（大きいほど早く減速）

// SteeringManagerに追加
const steeringManager = new SteeringManager(vehicle);
steeringManager.add(arrive);

// Three.jsメッシュ作成
const geometry = new THREE.SphereGeometry(0.2, 16, 16);
const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
const mesh = new THREE.Mesh(geometry, material);
scene.add(mesh);

function update() {
  const delta = 0.016;
  
  steeringManager.calculate(delta);
  vehicle.update(delta);
  
  mesh.position.copy(vehicle.position);

  requestAnimationFrame(update);
  renderer.render(scene, camera);
}

update();

import { AStar, Graph, HeuristicPolicyEuclid } from 'yuka';

// グラフを用意（ノードとエッジを設定）
const graph = new Graph(/* 無向 or 有向, ノード数など */);
// ...ノード追加、エッジ追加など

const startNodeIndex = 0;
const targetNodeIndex = 5;

// AStarインスタンスを生成
const aStar = new AStar(graph, startNodeIndex, targetNodeIndex);
aStar.heuristic = HeuristicPolicyEuclid; // ユークリッド距離をヒューリスティックに設定

// 検索実行
aStar.search();

// 最短経路を取得（ノードのインデックス列）
if (aStar.found) {
  const path = aStar.getPath();
  console.log('最短経路:', path);
} else {
  console.log('道が見つかりませんでした');
}

import { BFS, Graph } from 'yuka';

// グラフ構築（例として小規模）
const graph = new Graph();
const nodeA = graph.addNode(/* index=0 */);
const nodeB = graph.addNode(/* index=1 */);
// ... node追加
// エッジを設定 graph.addEdge(0, 1, 1), etc.

const startIndex = 0;
const goalIndex = 3;

// BFSインスタンス
const bfs = new BFS(graph, startIndex, goalIndex);

// 検索
bfs.search();
if (bfs.found) {
  const path = bfs.getPath();
  console.log('BFSで見つかったパス:', path);
}

import * as THREE from 'three';
import { BoundingSphere, Vector3 } from 'yuka';

const sphereMesh = new THREE.Mesh(
  new THREE.SphereGeometry(1, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0x0000ff, wireframe: true })
);
scene.add(sphereMesh);

const boundingSphere = new BoundingSphere(
  new Vector3(0, 0, 0), // 中心
  1 // 半径
);

// 毎フレームで更新する場合
function update() {
  // Meshのワールド座標を取得
  const worldPos = new THREE.Vector3();
  sphereMesh.getWorldPosition(worldPos);

  boundingSphere.center.copy(worldPos);
  // 大きさが変わるなら boundingSphere.radius = <someValue>;

  // 他のBoundingSphereとの衝突判定
  // if ( boundingSphere.intersectsBoundingSphere(otherSphere) ) { ... }

  requestAnimationFrame(update);
  renderer.render(scene, camera);
}

update();

import { BVH, BVHNode, AABB, Vector3 } from 'yuka';

// シーン中の複数オブジェクトのAABBをBVHに登録
const bvh = new BVH();

// ダミーでオブジェクト10個分
for (let i = 0; i < 10; i++) {
  const min = new Vector3(i, i, i);
  const max = new Vector3(i+1, i+1, i+1);
  const aabb = new AABB(min, max);

  // BVHNodeを作成
  const node = new BVHNode();
  node.aabb.copy(aabb);

  bvh.insert(node);
}

// BVHを構築
bvh.build();

// レイなどによるヒット判定
// bvh.intersectRay(ray, callback) みたいにヒットチェックをする

import { Cell } from 'yuka';

// 1つのセルを作る（通常はCellSpacePartitioningで自動生成される）
const cell = new Cell();

// セルに含まれるエンティティを追加
cell.addEntity(someEntity);

// セルから削除
cell.removeEntity(someEntity);

// セル内のエンティティ一覧
console.log(cell.entities); // Array of entities

import { CellSpacePartitioning, Vector3, GameEntity } from 'yuka';

// ワールドを X, Y, Z方向に区切る大きさを決める
const width = 100;
const height = 1; // 2D的に使うなら高さを1にするなど
const depth = 100;

// セルの数(例として10x10)を指定
const cellsX = 10;
const cellsY = 1; 
const cellsZ = 10;

// CellSpacePartitioningを初期化
const partition = new CellSpacePartitioning(width, height, depth, cellsX, cellsY, cellsZ);

// エンティティをシーンに追加＆パーティションにも登録
for (let i = 0; i < 50; i++) {
  const entity = new GameEntity();
  entity.position.set(Math.random() * 100, 0, Math.random() * 100);

  // パーティションに登録
  partition.addEntity(entity);
}

// 毎フレーム、エンティティが動いたら位置に応じてパーティションを更新
function updateEntities() {
  for (const entity of partition.entities) {
    // 動いたと仮定して適当な移動
    entity.position.x += (Math.random() - 0.5) * 0.1;
    entity.position.z += (Math.random() - 0.5) * 0.1;

    // パーティション上のセル情報を再計算
    partition.updateEntity(entity);
  }
}

// 近くのエンティティを探したい時
function findNeighbors(entity, queryRadius) {
  const neighbors = [];
  partition.querySphere(entity.position, queryRadius, neighbors);
  return neighbors;
}

import * as THREE from 'three';
import {
  Vehicle, SteeringManager, CohesionBehavior
} from 'yuka';

const scene = new THREE.Scene();

// エージェント（Vehicle）たちを用意
const vehicles = [];
for (let i = 0; i < 5; i++) {
  const vehicle = new Vehicle();
  vehicle.position.set(Math.random() * 10, 0, Math.random() * 10);
  vehicles.push(vehicle);

  // Three.js表示用
  const mesh = new THREE.Mesh(
    new THREE.SphereGeometry(0.2, 16, 16),
    new THREE.MeshBasicMaterial({ color: 0x00ff00 })
  );
  mesh.position.copy(vehicle.position);
  scene.add(mesh);

  // SteeringManagerを設定
  const steeringManager = new SteeringManager(vehicle);

  // CohesionBehaviorを追加
  // この挙動では周囲の仲間（neighbors）を参照する必要があるため、Vehicleのneighborsが設定されている想定
  const cohesion = new CohesionBehavior();
  steeringManager.add(cohesion);

  // Vehicleにメッシュを紐づけておく (あくまでサンプル的)
  vehicle.userData = { mesh, steeringManager };
}

// 毎フレーム更新
function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  // 近隣の仲間リストを更新（簡易版）
  for (const v1 of vehicles) {
    v1.neighbors.length = 0; // クリア
    for (const v2 of vehicles) {
      if (v1 !== v2) {
        const dist = v1.position.distanceTo(v2.position);
        if (dist < 5) {
          v1.neighbors.push(v2);
        }
      }
    }
  }

  // ステアリング計算→Vehicleを更新
  for (const v of vehicles) {
    const { steeringManager } = v.userData;
    steeringManager.calculate(delta);
    v.update(delta);

    // Three.jsメッシュに反映
    v.userData.mesh.position.copy(v.position);
  }

  renderer.render(scene, camera);
}
animate();

import {
  CompositeGoal, Goal, GoalEvaluator, GameEntity
} from 'yuka';

// 自作のサブゴール例
class MoveToGoal extends Goal {
  constructor(owner, target) {
    super(owner);
    this.target = target;
  }
  activate() {
    this.status = Goal.STATUS.ACTIVE;
    // 実際にはArriveBehaviorやSeekBehaviorなどをセットアップ
  }
  execute() {
    // 目標地点に移動しているかどうかを確認
    if (this.owner.position.distanceTo(this.target) < 0.1) {
      this.status = Goal.STATUS.COMPLETED;
    }
  }
  terminate() {
    // 終了処理（例: SteeringManagerからArriveBehaviorを外すなど）
  }
}

// 複合ゴール
class MyCompositeGoal extends CompositeGoal {
  constructor(owner) {
    super(owner);
  }
  activate() {
    this.status = Goal.STATUS.ACTIVE;
    // サブゴールを追加
    this.addSubgoal(new MoveToGoal(this.owner, { x: 10, y: 0, z: 10 }));
    this.addSubgoal(new MoveToGoal(this.owner, { x: 5, y: 0, z: -5 }));
  }
  execute() {
    // subgoalsを順番に実行する
    const status = this.executeSubgoals();
    this.status = status;
  }
}

// 使い方イメージ
const entity = new GameEntity();
const mainGoal = new MyCompositeGoal(entity);

// 毎フレーム
function update() {
  // goalがINACTIVEならactivate
  mainGoal.activateIfInactive();
  // 実行
  mainGoal.execute();

  // ...Three.js描画など
}

import { ConvexHull, Vector3 } from 'yuka';

// 点群データを用意
const points = [
  new Vector3(0, 0, 0),
  new Vector3(1, 0, 0),
  new Vector3(1, 1, 0),
  new Vector3(0, 1, 1),
  new Vector3(0.5, 0.5, 2)
];

// ConvexHullを生成
const hull = new ConvexHull().fromPoints(points);

// hull.facesに凸包を構成する面（Polygon）が登録される
console.log('Convex Hull face count:', hull.faces.length);

// Three.jsで可視化するなら hull.faces から頂点を取り出し、Wireframeなどで表示可能

import { Corridor, Vector3 } from 'yuka';

// Corridorインスタンス
const corridor = new Corridor();

// ポータルの左頂点(left)と右頂点(right)をpushしていく
corridor.push(new Vector3(0,0,0), new Vector3(1,0,0));
corridor.push(new Vector3(1,0,2), new Vector3(2,0,2));
corridor.push(new Vector3(2,0,3), new Vector3(3,0,3));

// corridor内の最適な経路(waypoints)を生成
const waypoints = corridor.generate(); 
console.log('Waypoints:', waypoints);

import { CostTable } from 'yuka';

// CostTableを生成
const costTable = new CostTable();

// navmeshの全ノード数に合わせてinitするなど
// costTable.init(navMesh);

// 個別にコストを設定 (from, to, cost)
costTable.set(0, 1, 1.0); // ノード0->1のコストを1
costTable.set(1, 2, 2.5); // ノード1->2のコストを2.5

// 取得
const cost = costTable.get(1, 2);
console.log('Cost from 1->2:', cost);

// クリア
// costTable.clear();

import { Graph, DFS } from 'yuka';

// グラフ準備
const graph = new Graph();
// ノード追加
const nodeA = graph.addNode(); // index 0
const nodeB = graph.addNode(); // index 1
const nodeC = graph.addNode(); // index 2
// エッジ追加
graph.addEdge(0, 1, 1);
graph.addEdge(0, 2, 1);
graph.addEdge(1, 2, 1);

const source = 0;
const target = 2;

// DFS
const dfs = new DFS(graph, source, target);
dfs.search();

if (dfs.found) {
  const path = dfs.getPath(); // ノードインデックスの配列
  console.log('Found path by DFS:', path);
} else {
  console.log('No path found');
}

import { Graph, Dijkstra } from 'yuka';

// グラフ定義
const graph = new Graph();
for (let i = 0; i < 4; i++) {
  graph.addNode();
}
// エッジ (from, to, cost)
graph.addEdge(0, 1, 2);
graph.addEdge(1, 2, 5);
graph.addEdge(2, 3, 1);
graph.addEdge(0, 2, 10);

const source = 0;
const target = 3;

// Dijkstra
const dijkstra = new Dijkstra(graph, source, target);
dijkstra.search();

if (dijkstra.found) {
  const path = dijkstra.getPath();
  console.log('Dijkstra path:', path);
}

import { Graph, Edge } from 'yuka';

// Graphを作成
const graph = new Graph();

// ノード追加
graph.addNode(); // index=0
graph.addNode(); // index=1

// Edgeを作成
const edge = new Edge(0, 1, 2); // ノード0->1, コスト=2
// グラフに手動で追加する場合
graph.addEdgeInstance(edge);

// 取得
const edgesFrom0 = graph.getEdgesOfNode(0);
edgesFrom0.forEach(e => {
  console.log(`Edge from ${e.from} to ${e.to}, cost=${e.cost}`);
});

import { EntityManager, GameEntity } from 'yuka';

// EntityManager
const entityManager = new EntityManager();

// Entity作成
class NPC extends GameEntity {
  update(delta) {
    super.update(delta);
    // 自分なりのAIロジック
  }
}

const npc1 = new NPC();
const npc2 = new NPC();
entityManager.add(npc1);
entityManager.add(npc2);

// 毎フレーム
function update() {
  const delta = 0.016;
  // 全エンティティを更新
  entityManager.update(delta);
  
  // ...
}

import * as THREE from 'three';
import {
  Vehicle, SteeringManager, EvadeBehavior
} from 'yuka';

// 追跡者
const pursuer = new Vehicle();
pursuer.position.set(5, 0, 0);

// 逃げる側
const evader = new Vehicle();
evader.position.set(0, 0, 0);

// EvadeBehavior
const evade = new EvadeBehavior(pursuer);
const steeringManager = new SteeringManager(evader);
steeringManager.add(evade);

// Three.jsメッシュ
const pursuerMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.2, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0xff0000 })
);
scene.add(pursuerMesh);

const evaderMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.2, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0x00ff00 })
);
scene.add(evaderMesh);

function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  // pursuerに適当な移動
  pursuer.position.x += 0.01;

  // evaderの逃げステアリング
  steeringManager.calculate(delta);
  evader.update(delta);

  pursuerMesh.position.copy(pursuer.position);
  evaderMesh.position.copy(evader.position);

  renderer.render(scene, camera);
}
animate();

import { EventDispatcher } from 'yuka';

// イベントディスパッチャ
const dispatcher = new EventDispatcher();

// リスナー登録
dispatcher.addEventListener('testEvent', (event) => {
  console.log('Received testEvent with data:', event.data);
});

// イベント発行
dispatcher.dispatch({ type: 'testEvent', data: { msg: 'Hello' } });

// リスナー削除
const callback = (event) => {};
dispatcher.addEventListener('something', callback);
dispatcher.removeEventListener('something', callback);

import * as THREE from 'three';
import {
  Vehicle, SteeringManager, FleeBehavior, Vector3
} from 'yuka';

// 逃げる側
const fleeVehicle = new Vehicle();
fleeVehicle.position.set(0, 0, 0);

// 相手（追跡者）
const pursuer = new Vehicle();
pursuer.position.set(5, 0, 0);

// FleeBehaviorを作成(ターゲットをpursuerに設定)
const flee = new FleeBehavior(pursuer.position);

// SteeringManagerに登録
const steeringManager = new SteeringManager(fleeVehicle);
steeringManager.add(flee);

// Three.jsで描画
const fleeMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.2, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0x00ff00 })
);
scene.add(fleeMesh);

const pursuerMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.2, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0xff0000 })
);
scene.add(pursuerMesh);

function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  // 追跡者が何らかの移動をする想定
  pursuer.position.x -= 0.01; // 例: 近づいてくる

  // fleeVehicleのステアリング計算
  steeringManager.calculate(delta);
  fleeVehicle.update(delta);

  // Three.jsメッシュ位置更新
  fleeMesh.position.copy(fleeVehicle.position);
  pursuerMesh.position.copy(pursuer.position);

  renderer.render(scene, camera);
}
animate();

import * as THREE from 'three';
import {
  Vehicle, SteeringManager, FollowPathBehavior, Path, Vector3
} from 'yuka';

// Pathの定義
const path = new Path();
path.add(new Vector3(0, 0, 0));
path.add(new Vector3(5, 0, 2));
path.add(new Vector3(10, 0, 0));
path.loop = true; // 最後まで行ったら最初に戻る

// Vehicle
const vehicle = new Vehicle();
vehicle.position.set(0, 0, 0);

// FollowPathBehavior
const followPathBehavior = new FollowPathBehavior(path);
followPathBehavior.nextWaypointDistance = 0.5; // ウェイポイント切り替え距離

// SteeringManager
const steeringManager = new SteeringManager(vehicle);
steeringManager.add(followPathBehavior);

// Three.jsで表示
const vehicleMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.2, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0x00ff00 })
);
scene.add(vehicleMesh);

// Path可視化
const pathLineGeom = new THREE.BufferGeometry().setFromPoints(path._waypoints);
const pathLineMat = new THREE.LineBasicMaterial({ color: 0xffff00 });
const pathLine = new THREE.Line(pathLineGeom, pathLineMat);
scene.add(pathLine);

function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  steeringManager.calculate(delta);
  vehicle.update(delta);

  vehicleMesh.position.copy(vehicle.position);

  renderer.render(scene, camera);
}
animate();

import {
  FuzzySet, FuzzyTerm, FuzzyAND, FuzzyModule, FuzzyRule
} from 'yuka';

// 適当なFuzzyTerm（例: 左肩セットや三角形セットなど）
const termA = /* FuzzyTerm for "Near" */;
const termB = /* FuzzyTerm for "LowHP" */;

// FuzzyAND(複数Term)
const fuzzyAnd = new FuzzyAND(termA, termB);

// fuzzyAnd.getDegreeOfMembership() で
// termAとtermBのメンバーシップ値の最小値が取得される
console.log('AND membership:', fuzzyAnd.getDegreeOfMembership());

import {
  FuzzyCompositeTerm, FuzzyTerm
} from 'yuka';

// 自作のFuzzyCompositeTerm例(AND)
class MyFuzzyAND extends FuzzyCompositeTerm {
  getDegreeOfMembership() {
    let minValue = 1;
    for (const term of this.terms) {
      const val = term.getDegreeOfMembership();
      if (val < minValue) {
        minValue = val;
      }
    }
    return minValue;
  }
}

// 使い方
const term1 = /* あるFuzzyTerm */;
const term2 = /* あるFuzzyTerm */;
const myAnd = new MyFuzzyAND([term1, term2]);
console.log('result membership:', myAnd.getDegreeOfMembership());

import {
  FuzzyTerm, FuzzyFAIRLY, SingletonFuzzySet
} from 'yuka';

// 'Near'セット(メンバーシップ1の範囲が狭い)
const nearSet = new SingletonFuzzySet(50); // 例: 中心50

// そのセットをFAIRLYで包む
const fairlyNear = new FuzzyFAIRLY(nearSet);

// メンバーシップ値を取得
console.log('Fairly near membership:', fairlyNear.getDegreeOfMembership());

import {
  FuzzyModule, FuzzyVariable, FuzzySet, LeftShoulderFuzzySet, FuzzyRule,
  FuzzyAND, FuzzyOR, FuzzyVERY
} from 'yuka';

const module = new FuzzyModule();

// ファジィ変数を追加
const distanceVar = new FuzzyVariable();
distanceVar.add(new LeftShoulderFuzzySet(0, 0, 50), 'CLOSE');
distanceVar.add(new LeftShoulderFuzzySet(0, 50, 100), 'MEDIUM');
// ...他のセット追加

// モジュールに登録
module.addFLV('Distance', distanceVar);

// ファジィルールを作成 (例: IF Distance is CLOSE THEN "Danger" のような)
const closeTerm = distanceVar.flvs['CLOSE']; // 取得例
// Consequent部のファジィ用語(危険度など)を別のFuzzyVariableに設定したりする

// ルール例 (IF distance=CLOSE THEN ...)
const rule = new FuzzyRule(closeTerm, /* 何らかのConsequentTerm */);
module.addRule(rule);

// fuzzify
module.fuzzify('Distance', 30);

// defuzzify (Centroid法 or MaxAv法など)
const result = module.defuzzify('SomeOutputVar', 'MAXAV'); 
console.log('Defuzzified result:', result);

import {
  FuzzySet, FuzzyOR
} from 'yuka';

// あるFuzzyTerm2つ
const closeTerm = /* FuzzySet for 'Close' */;
const mediumTerm = /* FuzzySet for 'Medium' */;

// FuzzyOR
const closeOrMedium = new FuzzyOR(closeTerm, mediumTerm);

// メンバーシップ = どちらか高い方
console.log('OR membership:', closeOrMedium.getDegreeOfMembership());

import {
  FuzzyModule, FuzzyRule, FuzzyAND, FuzzyTerm
} from 'yuka';

// FuzzyModuleを用意
const fuzzyModule = new FuzzyModule();

// 例: 2つのFuzzyTermをANDしたもの
const nearAndLowHP = new FuzzyAND(/* nearTerm */, /* lowHPTerm */);

// 後件 (例: 'Escape'というFuzzyTerm)
const escapeTerm = /* FuzzyTerm for 'Escape' */;

// ルール
const rule = new FuzzyRule(nearAndLowHP, escapeTerm);

// モジュールに登録
fuzzyModule.addRule(rule);

// 以降、fuzzify/defuzzifyによってルールの結果が反映される

import {
  FuzzySet, TriangularFuzzySet
} from 'yuka';

// TriangularFuzzySet(左端=0, 中央=50, 右端=100)
const nearSet = new TriangularFuzzySet(0, 50, 100);

// 入力値 x=25 についてメンバーシップを計算
const membership = nearSet.computeDegreeOfMembership(25);
console.log('membership:', membership); // 0.5 くらいになる

import {
  FuzzyTerm, TriangularFuzzySet
} from 'yuka';

// TriangularFuzzySetをFuzzyTermとして扱う例
const nearTerm = new TriangularFuzzySet(0, 50, 100);

// nearTermはFuzzyTermのインスタンス扱いができる
console.log(nearTerm.getDegreeOfMembership()); // 0(初期)
nearTerm.computeDegreeOfMembership(25);

import {
  FuzzyVariable, LeftShoulderFuzzySet, RightShoulderFuzzySet, TriangularFuzzySet
} from 'yuka';

const distanceVar = new FuzzyVariable();

// Near(0～0～20)
distanceVar.add(new LeftShoulderFuzzySet(0, 0, 20), 'Near');
// Medium(0～20～40)
distanceVar.add(new TriangularFuzzySet(0, 20, 40), 'Medium');
// Far(20～100～100)
distanceVar.add(new RightShoulderFuzzySet(20, 100, 100), 'Far');

// fuzzify(入力: 10)
distanceVar.fuzzify(10); 
console.log(distanceVar.flvs['Near'].degreeOfMembership);   // ~0.5
console.log(distanceVar.flvs['Medium'].degreeOfMembership); // ~0.5
console.log(distanceVar.flvs['Far'].degreeOfMembership);    // 0

import { FuzzyTerm, FuzzyVERY, TriangularFuzzySet } from 'yuka';

// TriangularFuzzySet
const closeSet = new TriangularFuzzySet(0, 25, 50);
// VERYをかける
const veryClose = new FuzzyVERY(closeSet);

// 入力値(10)に対するメンバーシップ計算
closeSet.computeDegreeOfMembership(10); // ~0.4 と仮定
veryClose.getDegreeOfMembership(); // ~0.16 (二乗で小さくなる)

import * as THREE from 'three';
import { GameEntity } from 'yuka';

class MyNPC extends GameEntity {
  constructor() {
    super();
    this.name = 'MyNPC';
  }

  // 毎フレーム呼ばれる更新処理
  update(delta) {
    super.update(delta);
    // 例: 自己位置を少し動かす
    this.position.x += 0.01 * delta;
    // AIステートマシンやステアリング行動があればここに処理を追加
  }

  // メッセージ受信時の処理
  handleMessage(telegram) {
    console.log('Received message:', telegram.message);
    return true; // メッセージを処理した場合
  }
}

// Three.jsで表示するメッシュ
const npcMesh = new THREE.Mesh(
  new THREE.BoxGeometry(1,1,1),
  new THREE.MeshBasicMaterial({color: 0xff0000})
);
scene.add(npcMesh);

// MyNPCインスタンス生成
const myNPC = new MyNPC();
myNPC.position.set(0, 0, 0); // Yukaの座標

function animate() {
  requestAnimationFrame(animate);

  const delta = 0.016;
  myNPC.update(delta);

  // Three.jsメッシュにGameEntityのpositionを反映
  npcMesh.position.copy(myNPC.position);

  renderer.render(scene, camera);
}
animate();

import { Goal, GameEntity } from 'yuka';

class AttackGoal extends Goal {
  constructor(owner) {
    super(owner);
  }

  activate() {
    this.status = Goal.STATUS.ACTIVE;
    console.log('AttackGoal activated');
  }

  execute() {
    // 攻撃動作をする
    console.log('Attacking...');
    // 攻撃完了とみなしたらCOMPLETEDに
    this.status = Goal.STATUS.COMPLETED;
  }

  terminate() {
    console.log('AttackGoal terminated');
  }
}

const myEntity = new GameEntity();
const myAttackGoal = new AttackGoal(myEntity);

// 毎フレーム
function update() {
  // ゴールがINACTIVEならactivate
  myAttackGoal.activateIfInactive();
  // 毎フレーム execute
  myAttackGoal.execute();
  // COMPLETED or FAILED なら terminate が呼ばれる場合あり
}

import { GoalEvaluator, Goal } from 'yuka';

class AttackGoalEvaluator extends GoalEvaluator {
  constructor(characterBias) {
    super(characterBias);
  }

  calculateDesirability(owner) {
    // 例: HPが低いほど攻撃を避ける、敵が近いほど攻撃したいなど
    const distanceToEnemy = owner.position.distanceTo(owner.enemy.position);
    let desirability = 1 / distanceToEnemy;
    desirability *= this.characterBias; // キャラ好み補正

    return desirability;
  }

  setGoal(owner) {
    // AttackGoalを設定
    owner.brain.addSubgoal(new AttackGoal(owner));
  }
}

import { Graph } from 'yuka';

const graph = new Graph();

// ノード追加
for (let i = 0; i < 4; i++) {
  graph.addNode();
}
// エッジ追加 (from, to, cost)
graph.addEdge(0, 1, 1);
graph.addEdge(1, 2, 2);
graph.addEdge(2, 3, 1);
graph.addEdge(0, 2, 4);

console.log('Nodes:', graph.nodes.length);
console.log('Edges from node0:', graph.getEdgesOfNode(0));

import { Graph, GraphUtils } from 'yuka';

// 例えば2Dグリッド 3x3をGraphに変換するユーティリティ関数があると想定
const width = 3, height = 3;
const graph = new Graph();
GraphUtils.buildGridGraph(graph, width, height);
// これで width*heightのノードが追加され、隣接するマス同士にエッジを張る

console.log('Created grid graph', graph.nodes.length, 'nodes');

import { HalfEdge, Vector3 } from 'yuka';

// HalfEdgeを直接生成する例（通常はPolygon.fromContour()で自動生成される）
const he1 = new HalfEdge(new Vector3(0,0,0));
const he2 = new HalfEdge(new Vector3(1,0,0));
const he3 = new HalfEdge(new Vector3(1,1,0));

// next/prevのリンク
he1.next = he2;
he2.next = he3;
he3.next = he1;

he2.prev = he1;
he3.prev = he2;
he1.prev = he3;

import { AStar, HeuristicPolicyDijkstra, Graph } from 'yuka';

// Graph定義など省略
const graph = new Graph();

// AStar
const source = 0;
const target = 5;
const aStar = new AStar(graph, source, target);

// ヒューリスティックをDijkstraにする (常に0を返す)
aStar.heuristic = HeuristicPolicyDijkstra;

aStar.search();
if (aStar.found) {
  const path = aStar.getPath();
  console.log('Dijkstra-like path:', path);
}

import { AStar, HeuristicPolicyEuclid, Graph } from 'yuka';

// Graph定義
const graph = new Graph();
// ...ノード/エッジ追加

const aStar = new AStar(graph, 0, 5);
aStar.heuristic = HeuristicPolicyEuclid; // ユークリッド距離

aStar.search();
if (aStar.found) {
  console.log('AStar path with Euclid heuristic:', aStar.getPath());
}

import { AStar, HeuristicPolicyEuclidSquared, Graph } from 'yuka';

const aStar = new AStar(graph, 0, 5);
aStar.heuristic = HeuristicPolicyEuclidSquared; 
// sqrtを計算しない分高速かもしれない

aStar.search();
if (aStar.found) {
  const path = aStar.getPath();
  console.log('EuclidSquared path:', path);
}

import { AStar, HeuristicPolicyManhattan, Graph } from 'yuka';

const aStar = new AStar(graph, 0, 5);
aStar.heuristic = HeuristicPolicyManhattan;

aStar.search();
if (aStar.found) {
  console.log('Manhattan path:', aStar.getPath());
}

import * as THREE from 'three';
import {
  Vehicle, SteeringManager, InterposeBehavior
} from 'yuka';

// 2つのターゲット
const agent1 = new Vehicle();
agent1.position.set(5, 0, 0);

const agent2 = new Vehicle();
agent2.position.set(-5, 0, 0);

// 間に入るVehicle
const interposer = new Vehicle();
interposer.position.set(0, 0, 0);

// InterposeBehaviorを設定
// decelerationは減速度合い(ArriveBehaviorと似たパラメータ)
const interposeBehavior = new InterposeBehavior(agent1, agent2, 3);

// SteeringManagerに追加
const steeringManager = new SteeringManager(interposer);
steeringManager.add(interposeBehavior);

// Three.jsメッシュ
const agent1Mesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.3),
  new THREE.MeshBasicMaterial({ color: 0xff0000 })
);
scene.add(agent1Mesh);

const agent2Mesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.3),
  new THREE.MeshBasicMaterial({ color: 0x0000ff })
);
scene.add(agent2Mesh);

const interposerMesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.3),
  new THREE.MeshBasicMaterial({ color: 0x00ff00 })
);
scene.add(interposerMesh);

function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  // agent1/2を適当に動かす例
  agent1.position.x += 0.01;
  agent2.position.x -= 0.01;

  // InterposeBehavior計算
  steeringManager.calculate(delta);
  interposer.update(delta);

  // Three.jsに反映
  agent1Mesh.position.copy(agent1.position);
  agent2Mesh.position.copy(agent2.position);
  interposerMesh.position.copy(interposer.position);

  renderer.render(scene, camera);
}
animate();

import {
  LeftSCurveFuzzySet
} from 'yuka';

// left=0, midpoint=50, right=100 の例
// 0付近ではメンバーシップ0, だんだんS字で1に近づく
const leftSCurve = new LeftSCurveFuzzySet(0, 50, 100);

// 任意の入力値 x=25 に対するメンバーシップを計算
const membership = leftSCurve.computeDegreeOfMembership(25);
console.log('Membership for x=25:', membership);

import {
  LeftShoulderFuzzySet
} from 'yuka';

// LeftShoulderFuzzySet(left, midpoint, right)
const coldSet = new LeftShoulderFuzzySet(0, 10, 20); 
// => 0～10はメンバーシップ1, 20以降は0, 10-20で段階的に下がる

console.log(coldSet.computeDegreeOfMembership(5));  // ~1
console.log(coldSet.computeDegreeOfMembership(15)); // ~0.5
console.log(coldSet.computeDegreeOfMembership(25)); // 0

import { LineSegment, Vector3 } from 'yuka';

// Start/End
const seg = new LineSegment(
  new Vector3(0, 0, 0), 
  new Vector3(5, 0, 0)
);

// ある点との最近接点
const point = new Vector3(2, 3, 0);
const closest = new Vector3();
seg.closestPointToPoint(point, true, closest);
console.log('Closest point on segment to (2,3,0):', closest);

import { Logger } from 'yuka';

Logger.setLevel(Logger.LEVEL.LOG); // LOG, WARN, ERROR, SILENT

Logger.log('This is a log message');   // 通常ログ
Logger.warn('This is a warning');      // 警告
Logger.error('This is an error');      // エラー

import { MathUtils } from 'yuka';

// 乱数
const randomFloat = MathUtils.randFloat(-1, 1);
const randomInt = MathUtils.randInt(0, 10);

// クランプ
let value = 15;
value = MathUtils.clamp(value, 0, 10); // => 10

// UUID
const uuid = MathUtils.generateUUID();
console.log('UUID:', uuid);

import { Matrix3, Vector3 } from 'yuka';

// 単位行列
const m = new Matrix3();
m.identity();

// 90度回転(Z軸基準)を手動で設定する例
m.set(
  0, -1,  0,
  1,  0,  0,
  0,  0,  1
);

// ベクトルを回転させる
const v = new Vector3(1, 0, 0);
v.applyMatrix3(m); // => (0,1,0)
console.log(v);

import { Matrix4, Vector3 } from 'yuka';

// 単位行列
const m = new Matrix4();
m.identity();

// 例: 平行移動を設定
m.elements[12] = 5;  // x方向に5
m.elements[13] = 2;  // y方向に2
m.elements[14] = -3; // z方向に-3

// ベクトルに適用
const v = new Vector3(1, 1, 1);
v.applyMatrix4(m); // => (6, 3, -2)
console.log(v);

import { MemoryRecord, Vector3 } from 'yuka';

const record = new MemoryRecord();

// 例: 対象となるGameEntityの参照を保存
record.entity = /* someEntity */;

// 最終目撃場所
record.lastSensedPosition = new Vector3(10, 0, 5);

// いつ最後に見たか(秒単位)
record.timeLastSensed = performance.now() / 1000; // 例

console.log('MemoryRecord:', record);

import { MemorySystem, GameEntity, Vector3 } from 'yuka';

class MyNPC extends GameEntity {
  constructor() {
    super();
    this.memorySystem = new MemorySystem(this);
  }

  update(delta) {
    super.update(delta);
    // MemorySystemの更新
    this.memorySystem.update(delta);
  }
}

// NPC生成
const npc = new MyNPC();

// 何かのきっかけ(視線判定)で別のエンティティを「目撃」した場合
function onEntitySpotted(spottedEntity) {
  // MemorySystemに記録
  npc.memorySystem.updateRecord(spottedEntity, /* some position */, /* time */);
}

// MemorySystemは内部にMemoryRecordを作成し、最後に見た時間や位置を保存

import * as THREE from 'three';
import { MeshGeometry, Vector3 } from 'yuka';

// YukaのMeshGeometryを作成
const meshGeo = new MeshGeometry();

// 頂点を追加(例：三角形)
meshGeo.vertices.push(
  new Vector3(0, 0, 0),
  new Vector3(1, 0, 0),
  new Vector3(0, 1, 0)
);

// インデックス(三角形の場合 [0,1,2] )
meshGeo.indices.push(0, 1, 2);

// Three.jsで同じ頂点を使ってみる
const threeGeometry = new THREE.BufferGeometry();
const positions = new Float32Array([
  0, 0, 0,
  1, 0, 0,
  0, 1, 0
]);
threeGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
threeGeometry.setIndex([0, 1, 2]);

const material = new THREE.MeshBasicMaterial({ color: 0xff0000 });
const mesh = new THREE.Mesh(threeGeometry, material);
scene.add(mesh);

import { MessageDispatcher, Telegram, GameEntity } from 'yuka';

const dispatcher = new MessageDispatcher();

class MyEntity extends GameEntity {
  handleMessage(telegram) {
    console.log(`Entity ${this.name} received message:`, telegram.message);
    return true;
  }
}

const sender = new MyEntity();
sender.name = 'Sender';

const receiver = new MyEntity();
receiver.name = 'Receiver';

// 送信
dispatcher.dispatch(new Telegram(
  sender,        // 送信元
  receiver,      // 送信先
  'HelloWorld',  // メッセージ本文
  0,             // 遅延(ミリ秒)
  { someData: 123 } // 任意のカスタムデータ
));

import * as THREE from 'three';
import { MovingEntity, SteeringManager, SeekBehavior, Vector3 } from 'yuka';

class MyMovingEntity extends MovingEntity {
  update(delta) {
    super.update(delta);
    // 追加ロジックがあればここに
  }
}

// 移動するターゲット位置
const targetPosition = new Vector3(5, 0, 0);

// MovingEntityインスタンス
const entity = new MyMovingEntity();
entity.position.set(0, 0, 0);
entity.maxSpeed = 2; // 最高速度

// ステアリング行動
const seek = new SeekBehavior(targetPosition);
const steeringManager = new SteeringManager(entity);
steeringManager.add(seek);

// Three.jsメッシュ
const mesh = new THREE.Mesh(
  new THREE.SphereGeometry(0.3, 16, 16),
  new THREE.MeshBasicMaterial({ color: 0x00ff00 })
);
scene.add(mesh);

function animate() {
  requestAnimationFrame(animate);
  const delta = 0.016;

  steeringManager.calculate(delta);
  entity.update(delta);

  mesh.position.copy(entity.position);

  renderer.render(scene, camera);
}
animate();

import { NavEdge } from 'yuka';

// NavMesh生成時にポリゴン間の接続としてNavEdgeが使用される
const edge = new NavEdge();
edge.from = 0; // ナビゲーションノード(ポリゴン)ID
edge.to = 1;   // 接続先ノードID
edge.cost = 1.5; // 移動コストなど

console.log(edge);

import { NavMesh, Polygon, Vector3 } from 'yuka';

// ナビメッシュインスタンス
const navMesh = new NavMesh();

// ポリゴン(凸形状)を追加
const poly1 = new Polygon().fromContour([
  new Vector3(0,0,0), new Vector3(5,0,0), new Vector3(5,0,5), new Vector3(0,0,5)
]);
const poly2 = new Polygon().fromContour([
  new Vector3(5,0,0), new Vector3(10,0,0), new Vector3(10,0,5), new Vector3(5,0,5)
]);
// ...

// NavMeshに設定
navMesh.fromPolygons([poly1, poly2 /* ... */]);

// 経路探索
const from = new Vector3(1, 0, 1);
const to   = new Vector3(9, 0, 4);
const path = navMesh.findPath(from, to);

console.log('Found path:', path); // Vector3[] の配列

import { NavMeshLoader } from 'yuka';

const loader = new NavMeshLoader();
loader.load('path/to/navmesh.glb').then((navMesh) => {
  console.log('NavMesh loaded:', navMesh);

  // 例：経路探索
  const from = new Vector3(1,0,1);
  const to   = new Vector3(9,0,4);
  const path = navMesh.findPath(from, to);
  console.log('Path:', path);
}).catch((err) => {
  console.error('Failed to load navmesh:', err);
});

import { NavNode, Vector3 } from 'yuka';

// NavNode(index, position, userData)
const node = new NavNode(0, new Vector3(5,0,5), { regionID: 2 });

console.log('Node index:', node.index);
console.log('Position:', node.position);
console.log('UserData:', node.userData);