Implement a feature random split players into two team with nearest position.

[lifei]

I want to implement a feature: random assign players into two team with nearest position.

For example, in the map big game hunter, there are eight positions, 1,3,5,6,7,9,11,12. If there're eight players, the teams should be 11,12,1,3 vs 5,6,7,9. the team center poiter can be at 12.5 vs 6.5. if there're six/four players, it should be following the rules above.

I have got some code from AI. I want to know if this code can be implement using the software?

// Define the list of player positions
const playerPositions = [1, 3, 5, 6, 7, 9, 11, 12];

// Define the two cluster centers
const clusterCenter1 = 12.5;
const clusterCenter2 = 6.5;

// Initialize the two groups
const group1 = [];
const group2 = [];

// Define the function to calculate circular distance
function circularDistance(point1, point2) {
    let directDistance = Math.abs(point1 - point2);
    return Math.min(directDistance, 12 - directDistance);
}

// Iterate through each player's position
for (let i = 0; i < playerPositions.length; i++) {
    const position = playerPositions[i];

    // Calculate the circular distances from the player to both cluster centers
    const distance1 = circularDistance(position, clusterCenter1);
    const distance2 = circularDistance(position, clusterCenter2);

    // Assign the player to the group with the closer cluster center
    if (distance1 < distance2) {
        group1.push(position);
    } else {
        group2.push(position);
    }
}

// Ensure the two groups have equal number of players
while (group1.length > group2.length) {
    let minDistance = Infinity;
    let moveIndex = -1;
    for (let i = 0; i < group1.length; i++) {
        const position = group1[i];
        const newDistance = circularDistance(position, clusterCenter2);
        if (newDistance < minDistance) {
            minDistance = newDistance;
            moveIndex = i;
        }
    }
    if (moveIndex !== -1) {
        const movedPosition = group1.splice(moveIndex, 1)[0];
        group2.push(movedPosition);
    }
}

while (group2.length > group1.length) {
    let minDistance = Infinity;
    let moveIndex = -1;
    for (let i = 0; i < group2.length; i++) {
        const position = group2[i];
        const newDistance = circularDistance(position, clusterCenter1);
        if (newDistance < minDistance) {
            minDistance = newDistance;
            moveIndex = i;
        }
    }
    if (moveIndex !== -1) {
        const movedPosition = group2.splice(moveIndex, 1)[0];
        group1.push(movedPosition);
    }
}

// Output the grouping results
console.log("Group 1:", group1);
console.log("Group 2:", group2);

[armoha]

What I would write:
(1) There're 8 positions: [1, 1, 1, 1, 1, 1, 1, 1]
(2) Randomly choose empty positions (when there're less than 8 players): [0, 1, 1, 0, 1, 1, 1, 1]
(3) Give second half non-empty positions to team 2: [0, 1, 1, 0, 1, 2, 2, 2]
(4) Randomly rotate the positions: [2, 2, 0, 1, 1, 0, 1, 2]
(5) Result: team1=(6,7,11) vs team2=(1,3,12) (empty=5,9)
(6) Give each positions to random team members.

(Step (1) and (2) can be reversed: instead of choosing empty positions, you can choose which positions to use)

// epScript example

const Player2Team = EUDArray(8);  // P2T[p] = 1~2 (team id) or 0 (no player)
const Player2Pos = EUDArray(8);  // P2Pos[p] =  0~7 (position id) or -1 (no player)
const Pos2Team = EUDArray(8);  // Pos2T[pos] = 1~2 (team id) or 0 (empty position)
const Pos2Player = EUDArray(8);  // Pos2P[pos] = 0~7 (player id) or -1 (empty position)
const Team1Players = EUDArray(4);  // T1P[0~3] = 0~7 (player id) or -1 (no player)
const Team2Players = EUDArray(4);  // T2P[0~3] = 0~7 (player id) or -1 (no player)

// 0~7 position id <-> 1,3,5,6,7,9,11,12
// position id 0 = 1'o clock start location
// position id 1 = 3'o clock start location
// .......
// position id 7 = 12'o clock start location

function randomizePositions() {
    const positions = Pos2Team;  // name alias
    for(var i = 0 ; i < 8 ; i += 1) {
        positions[i] = 1;
        Player2Team[i] = 0;
    }

    // Pick X random numbers from 0 to 7 with no duplicate
    // where X = the number of empty position
    var numberCount = 8;
    const numbers = [0, 1, 2, 3, 4, 5, 6, 7];
    for(var p: TrgPlayer = 0 ; p < 7 ; p += 1) {
        if (playerexist(p)) continue;
        Player2Team[p] = -1;
        Player2Pos[p] = -1;
        const randomIndex = dwrand() % numberCount;
        const randomNumber = numbers[randomIndex];
        numberCount -= 1;
        numbers[randomIndex] = numbers[numberCount];
        // Mark randomly chosen empty position
        positions[randomNumber] = 0;
    }

    // numberCount = The number of players
    // Get the number of players in 2 teams
    const team1Count = numberCount / 2;
    const team2Count = numberCount - team1Count;

    // Give second half of non-empty positions to team 2
    for(var index = 0 ; index < 7 ; index += 1) {
        if (positions[index] == 0) continue;
        if (numberCount <= team2Count) {
            positions[index] = 2;
        }
        numberCount -= 1;
    }

    // Randomly rotate the positions
    const rotate = dwrand() % 8;
    const temp = EUDArray(7);
    // Copy first X elements to temp
    for (var i = 0 ; i < rotate ; i += 1) {
        temp[i] = positions[i];
    }
    // Shift the remaining (8 - X) elements to left
    for (var i = 0 ; i < 8 - rotate ; i += 1) {
        positions[i] = positions[i + rotate];
    }
    // Put X elements at the end
    for (var i = 0 ; i < rotate ; i += 1) {
        positions[8 - rotate + i] = temp[i];
    }

    // (wip)
}

[lifei]

Thank you for your kind and quick reply.

If we need to re-assign positions to players, we need to move the base and farmers, even including the zerg's eggs.
So my idea is to let the system randomly assign positions to players first, then we assign the players into two teams according to their positions. I think it might be easier than re-assigning positions.

In StarCraft II, it's common sense when assigning players. In Big Game Hunter, position 11/12 and position 6/7 are very close, players in such positions should be assigned to the same team. This rule can make the fight last longer, teammates can defend together.

[armoha]

When I made 'Produce & Control' map, I preplace hatcheries on every start locations, and remove zerg creep for Terran and Protoss by creating and removing Zerg Extractor with enlarged building dimensions. (detail: https://cafe.naver.com/edac/32156 )

[armoha]

I want to implement a feature: random assign players into two team with nearest position.

For example, in the map big game hunter, there are eight positions, 1,3,5,6,7,9,11,12. If there're eight players, the teams should be 11,12,1,3 vs 5,6,7,9.

For 4 vs 4, not only (11, 12, 1, 3) vs (5, 6, 7, 9) but isn't (9, 11, 12, 1) vs (3, 5, 6, 7) also a valid option?

If we need to re-assign positions to players, we need to move the base and farmers, even including the zerg's eggs. So my idea is to let the system randomly assign positions to players first, then we assign the players into two teams according to their positions. I think it might be easier than re-assigning positions.

In that case, we should first collect the players' positions and then assign them to two teams.

const P2Pos = EUDArray(8);
const Pos2P = EUDArray(8);
const P2Team = EUDArray(8);

const Team1Players = EUDArray(4);
var Team1PlayerCount = 0;
const Team2Players = EUDArray(4);
var Team2PlayerCount = 0;

function randomizeTeams() {
    // Location names for start locations
    // (the order of locations is significant)
    const locations = "loc1", "loc3", "loc5", "loc6", "loc7", "loc9", "loc11", "loc12";
    const locArr = EUDArray(py_list(py_map(EncodeLocation, locations)));
    static var totalPlayerCount = 0;

    // Collect positions of players
    static var i = 0;
    for(i, totalPlayerCount = 0, 8 ; i < 8 ; i += 1) {
        Pos2P[i] = -1;
        if (!playerexist(i)) {
            totalPlayerCount -= 1;
            P2Team[i] = 0;
            P2Pos[i] = -1;
        }
        const loc = locArr[i];
        foreach(p : EUDLoopPlayer(None)) {
            if (Bring(p, AtMost, 0, "(buildings)", loc)) continue;
            Pos2P[i] = p;
            P2Pos[p] = i;
            break;
        }
    }

    // Choose one of 6 team dividers:
    // { | 1 | 3 | 5 | 6 7 | 9 | 11 12 }
    const halfPlayerCount = totalPlayerCount / 2;
    var teamDivider;
    while (true) {
        teamDivider = dwrand() % 6;
        if (teamDivider >= 4) teamDivider += 1;

        // Assign team 2 for players beyond the team divider
        
        const runOneMore = EUDLightBool();
        DoActions(
            Team2PlayerCount.SetNumber(0),
            runOneMore.Clear(),
        );
        while (Team2PlayerCount < halfPlayerCount || runOneMore) {
            const player = Pos2P[teamDivider];
            if (player != -1) {
                P2Team[player] = 2;
                Team2Players[Team2PlayerCount] = player;
                Team2PlayerCount += 1;
             }
             DoActions(
                 teamDivider.AddNumberX(1, 7),
                 runOneMore.Clear(),
             );
             if (teamDivider == 2 || teamDivider == 6) DoActions(runOneMore.Set());
        }
        if (Team2PlayerCount <= halfPlayerCount + totalPlayerCount % 2) break;
    }

    // Get players of team 1
    Team1PlayerCount = 0;
    while (Team1PlayerCount < totalPlayerCount - Team2PlayerCount) {
        const player = Pos2P[teamDivider];
        if (player != -1) {
            P2Team[player] = 1;
            Team1Players[Team1PlayerCount] = player;
            Team1PlayerCount += 1;
        }
        DoActions(teamDivider.AddNumberX(1, 7));
    }
}