/** 編隊的基類 */
import { _decorator, Component, Node, Vec3, v3 } from 'cc';
const { ccclass, property } = _decorator;
@ccclass('BaseFormation')
export class BaseFormation extends Component {
    @property
    noise: number = 0;
    @property
    Spread: number = 1;
    offsetPos:Vec3 = v3();
    EvaluatePoints(): Vec3[] {
        return null;
    }
    GetNoise(pos: Vec3): Vec3 {
        const noise = this.noise;
        const x = pos.x + Math.random() * noise - noise / 2;
        const z = pos.z + Math.random() * noise - noise / 2;
        pos.x = x;
        pos.z = z;
        return pos;
    }
}

/** 方形編隊組件腳本程式碼 */
import { _decorator, Component, Node, Vec3, v3 } from 'cc';
import { BaseFormation } from './BaseFormation';
const { ccclass, property } = _decorator;
@ccclass('BoxFormation')
export class BoxFormation extends BaseFormation {
    @property
    unitWidth: number = 5;
    @property
    unitDepth: number = 5;
    @property
    hollow: boolean = false;
    @property
    nthOffset: number = 0;
    EvaluatePoints(): Vec3[] {
        const ret: Vec3[] = [];
        const middleOffset = v3((this.unitWidth - 1) * 0.5, 0, (this.unitDepth - 1) * 0.5);
        for (let x = 0; x < this.unitWidth; x++) {
            for (let z = 0; z < this.unitDepth; z++) {
                if (this.hollow && x != 0 && x != this.unitWidth - 1 && z != 0 && z != this.unitDepth - 1) continue;
                let pos = v3(x + (z % 2 == 0 ? 0 : this.nthOffset), 0, z);

                pos = pos.subtract(middleOffset);

                pos = this.GetNoise(pos);

                pos = pos.multiplyScalar(this.Spread);
                pos.add(this.offsetPos);
                ret.push(pos);
            }
        }
        return ret;
    }
}

/** 放射編隊組件腳本程式碼 */
import { _decorator, Component, Node, Vec3, v3 } from 'cc';
import { BaseFormation } from './BaseFormation';
const { ccclass, property } = _decorator;
@ccclass('RadialFormation')
export class RadialFormation extends BaseFormation {
    @property
    amount: number = 10;
    @property
    radius: number = 1;
    @property
    radiusGrowthMultiplier: number = 0;
    @property
    rotations: number = 1;
    @property
    rings: number = 1;
    @property
    ringOffset: number = 1;
    @property
    nthOffset: number = 1;
    EvaluatePoints(): Vec3[] {
        const ret: Vec3[] = [];
        let amountPerRing = this.amount / this.rings;
        let ringOffset = 0;
        for (var i = 0; i < this.rings; i++) {
            for (var j = 0; j < amountPerRing; j++) {
                let angle = j * Math.PI * (2 * this.rotations) / amountPerRing + (i % 2 != 0 ? this.nthOffset : 0);

                let radius = this.radius + ringOffset + j * this.radiusGrowthMultiplier;
                let x = Math.cos(angle) * radius;
                let z = Math.sin(angle) * radius;

                let pos = new Vec3(x, 0, z);

                pos = this.GetNoise(pos);

                pos = pos.multiplyScalar(this.Spread);

                pos.add(this.offsetPos);
                ret.push(pos);
            }
            ringOffset += this.ringOffset;
        }
        return ret;
    }
}

/**
 * 編隊渲染展示的程式碼，掛在到你想展示的節點容器上，配合對應的Formation組件
 * 請自行構建Actor角色組件用於處理人物邏輯，實現removeSelf和moveTo
 * 在合適的時機處理編隊的刷新，比如編隊參數變化、隊伍移動的時候
 */
import { _decorator, Component, Node, Prefab, instantiate, director } from 'cc';
import { Actor } from '../actors/Actor';
import { BaseFormation } from '../formations/BaseFormation';
const { ccclass, property } = _decorator;
 
@ccclass('FormationShow')
export class FormationShow extends Component {
    @property(Prefab)
    actor: Prefab = null;
    start() {
        this.FormationUpdate();
    }
    FormationUpdate(prop?: string, value?: number) {
        const formation = this.getComponent(BaseFormation);
        if (formation) {
            if (prop) {
                const old = formation[prop];
                formation[prop] = value;
                if (old == formation[prop]) {
                    return;
                }
            }
            const points = formation.EvaluatePoints();
            for (let i = this.node.children.length - 1; i >= points.length; i--) {
                this.node.children[i].getComponent(Actor).removeSelf();
            }
            const len = this.node.children.length;
            for (let i = 0; i < points.length; i++) {
                if (i < points.length && i >= len) {
                    let actor = null;
                    if (len > 0) {
                        actor = this.node.children[len - 1];
                    } else {
                        actor = this.actor;
                    }
                    const a = instantiate(actor);
                    this.node.addChild(a);
                }
                this.node.children[i].getComponent(Actor).moveTo(points[i]);
            }
        }
    }
}