//-----------------------------------------------------------------------------
// Game_Unit
//
// The superclass of Game_Party and Game_Troop.
/**
 * The superclass of Game_Party and Game_Troop.
 *
 * @class
 */
function Game_Unit() {
    this.initialize(...arguments);
}

/**
 * Initialize the unit
 */
Game_Unit.prototype.initialize = function() {
    this._inBattle = false;
};

/**
 * Check if the unit is in battle
 *
 * @return {boolean} True if in battle
 */
Game_Unit.prototype.inBattle = function() {
    return this._inBattle;
};

/**
 * Get unit members
 *
 * @return {Array} Unit members
 */
Game_Unit.prototype.members = function() {
    return [];
};

/**
 * Get unit members who are alive
 *
 * @return {Array} Unit members who are alive
 */
Game_Unit.prototype.aliveMembers = function() {
    return this.members().filter(member => member.isAlive());
};

/**
 * Get unit members who are dead
 *
 * @return {Array} Unit members who are dead
 */
Game_Unit.prototype.deadMembers = function() {
    return this.members().filter(member => member.isDead());
};

/**
 * Get unit members who can move
 *
 * @return {Array} Unit members who can move
 */
Game_Unit.prototype.movableMembers = function() {
    return this.members().filter(member => member.canMove());
};

/**
 * Clear all member actions
 */
Game_Unit.prototype.clearActions = function() {
    for (const member of this.members()) {
        member.clearActions();
    }
};

/**
 * Get the unit's agility
 *
 * @return {number} The unit's agility
 */
Game_Unit.prototype.agility = function() {
    const members = this.members();
    const sum = members.reduce((r, member) => r + member.agi, 0);
    return Math.max(1, sum / Math.max(1, members.length));
};

/**
 * Sum the unit's target rate
 *
 * @return {number} Unit target rate sum
 */
Game_Unit.prototype.tgrSum = function() {
    return this.aliveMembers().reduce((r, member) => r + member.tgr, 0);
};

/**
 * Pick a random target in the unit
 *
 * @return {Game_Enemy|Game_Actor} The target that was chosen
 */
Game_Unit.prototype.randomTarget = function() {
    let tgrRand = Math.random() * this.tgrSum();
    let target = null;
    for (const member of this.aliveMembers()) {
        tgrRand -= member.tgr;
        if (tgrRand <= 0 && !target) {
            target = member;
        }
    }
    return target;
};

/**
 * Pick a random dead target in the unit
 *
 * @return {Game_Enemy|Game_Actor} The dead target that was chosen
 */
Game_Unit.prototype.randomDeadTarget = function() {
    const members = this.deadMembers();
    return members.length ? members[Math.randomInt(members.length)] : null;
};

/**
 * Choose a target by id
 *
 * @param {number} index - The index of the target
 * @return {Game_Enemy|Game_Actor} The target that was chosen
 */
Game_Unit.prototype.smoothTarget = function(index) {
    const member = this.members()[Math.max(0, index)];
    return member && member.isAlive() ? member : this.aliveMembers()[0];
};

/**
 * Choose a dead target by id
 *
 * @param {number} index - The index of the target
 * @return {Game_Enemy|Game_Actor} The target that was chosen
 */
Game_Unit.prototype.smoothDeadTarget = function(index) {
    const member = this.members()[Math.max(0, index)];
    return member && member.isDead() ? member : this.deadMembers()[0];
};

/**
 * Clear results for all members
 */
Game_Unit.prototype.clearResults = function() {
    for (const member of this.members()) {
        member.clearResult();
    }
};

/**
 * Processing when battle starts
 *
 * @param {boolean} advantageous - If the unit has the advantage
 */
Game_Unit.prototype.onBattleStart = function(advantageous) {
    for (const member of this.members()) {
        member.onBattleStart(advantageous);
    }
    this._inBattle = true;
};

/**
 * Processing when battle ends
 */
Game_Unit.prototype.onBattleEnd = function() {
    this._inBattle = false;
    for (const member of this.members()) {
        member.onBattleEnd();
    }
};

/**
 * Make member's actions
 */
Game_Unit.prototype.makeActions = function() {
    for (const member of this.members()) {
        member.makeActions();
    }
};

/**
 * Select a member of the unit
 *
 * @param {Game_Actor|Game_Enemy} member - The member to select
 */
Game_Unit.prototype.select = function(activeMember) {
    for (const member of this.members()) {
        if (member === activeMember) {
            member.select();
        } else {
            member.deselect();
        }
    }
};

/**
 * Check if all members are dead
 *
 * @return {boolean} True if all members are dead
 */
Game_Unit.prototype.isAllDead = function() {
    return this.aliveMembers().length === 0;
};

/**
 * Get the substitute battler
 *
 * @param {Game_Battler} target - The original target
 * @return {Game_Actor|Game_Enemy|null} The substitute battler, may be null if none found
 */
Game_Unit.prototype.substituteBattler = function(target) {
    for (const member of this.members()) {
        if (member.isSubstitute() && member !== target) {
            return member;
        }
    }
    return null;
};

/**
 * Get the TPB base speed
 *
 * @return {number} TPB base speed
 */
Game_Unit.prototype.tpbBaseSpeed = function() {
    const members = this.members();
    return Math.max(...members.map(member => member.tpbBaseSpeed()));
};

/**
 * Get the TPB reference time
 *
 * @return {number} TPB reference time
 */
Game_Unit.prototype.tpbReferenceTime = function() {
    return BattleManager.isActiveTpb() ? 240 : 60;
};

/**
 * Update TPB
 */
Game_Unit.prototype.updateTpb = function() {
    for (const member of this.members()) {
        member.updateTpb();
    }
};