Round

Introduction

Round stores all groups that should play roughly at the same time.

Creating a new round class

Basic construction

include_once 'vendor/autoload.php';

$tournament = new TournamentGenerator\Tournament('Tournament name');

$round = new TournamentGenerator\Round('Round name');

$tournament->addRound($round);

From a round class

Recomended
This automatically assigns the round to the round.

include_once 'vendor/autoload.php';

$tournament = new TournamentGenerator\Tournament('Tournament name');

$round = $tournament->round('Round name');

Tournament class can be also replaced by a Category

include_once 'vendor/autoload.php';

$tournament = new TournamentGenerator\Tournament('Tournament name');

$category = $tournament->category('Category name');

$round = $category->round('Round name');

Properties

Scope	Name	Type	Default	Description
protected	`$name`	`string`	`''`	Name of the round
protected	`$id`	`string\|int`	`null`	Id of the round
private	`$groups`	`array`	`[]`	List of round groups
private	`$games`	`array`	`[]`	List of round games
private	`$teams`	`array`	`[]`	List of teams
private	`$allowSkip`	`bool`	`false`	If `true`, generator will skip unplayed games without throwing exception

Methods

Method list

Scope	Name	Return	Description
public	`__construct`	`$this`	Construct method
public	`__toString`	`string`	Returns the name of the round
public	`setName`	`$this`	Sets name of the round.
public	`getName`	`string`	Gets name of the round.
public	`setId`	`$this`	Sets id of the round.
public	`getId`	`string\|int`	Gets id of the round.
public	`allowSkip`	`$this`	Allow skipping of unplayed games while progressing.
public	`disallowSkip`	`$this`	Disllow skipping of unplayed games while progressing.
public	`setSkip`	`$this`	Sets whether to skip unplayed games while progressing or not.
public	`getSkip`	`bool`	Gets whether to skip unplayed games while progressing or not.
public	`addGroup`	`$this`	Adds created Group to Round.
public	`group`	`TournamentGenerator\Round`	Creates and adds new Group to Round.
public	`getGroups`	`array`	Gets an array of all Groups from Round.
public	`getGroupsIds`	`array`	Gets an array of all Group ids from Round.
public	`orderGroups`	`array`	Sorts all Groups from Round.
public	`addTeam`	`$this`	Adds created Team to Round.
public	`team`	`new TournamentGenerator\Team`	Creates and adds new Team to Round.
public	`getTeams`	`array`	Gets an array of all Teams from Round.
public	`sortTeams`	`array`	Sorts all Teams from Round and returns them.
public	`genGames`	`array`	Generates all the Games of the Round.
public	`getGames`	`array`	Gets an array of all Games from Round.
public	`isPlayed`	`bool`	Returns `true` if all Games have been played.
public	`splitTeams`	`$this`	Splits all Teams from Round to given Groups (or all Groups from a Round).
public	`progress`	`$this`	Progresses all the Teams.
public	`simulate`	`$this`	Simulate all Games from this Round just like it was really played.
public	`resetGames`	`$this`	Resets the results of all Games in Round.

Round __construct(string $name, string|int $id = null)

Creates a new Round class

Parameters

Name	Type	Default	Description
`$name`	`string`	`''`	Name of the round
`$id`	`string\|int`	`''`	Name of the round

Return value

new TournamentGenerator\Round();

Code

public function __construct(string $name = '', $id = null) {
    $this->setName($name);
    $this->setId(isset($id) ? $id : uniqid());
}

public string __toString()

Returns round name

Return value

string $this->name;

Code

public function __toString() {
    return $this->name;
}

public Round setName(string $name)

Sets the name of the round.

Parameters

Name	Type	Default	Description
`$name`	`string`		Name of the round

Return value

TournamentGenerator\Round $this

Code

public function setName(string $name) {
    $this->name = $name;
    return $this;
}

public string getName()

Gets the name of the round.

Return value

string $this->name;

Code

public function getName() {
    return $this->name;
}

public Round setId(string|int $id)

Sets the name of the round.

Parameters

Id	Type	Default	Description
`$id`	`string\|int`		Id of the round

Return value

TournamentGenerator\Round $this

Code

public function setId($id) {
    if (!is_string($id) && !is_int($id)) {
        $this->id = uniqid();
        throw new \Exception('Unsupported id type ('.gettype($id).') - expected type of string or int');
    }
    $this->id = $id;
}

public string|int getId()

Gets the name of the round.

Return value

string|int $this->id;

Code

public function getId() {
    return $this->id;
}

public Round allowSkip()

Allow skipping of unplayed games while progressing.

Return value

TournamentGenerator\Round $this

Code

public function allowSkip(){
    $this->allowSkip = true;
    return $this;
}

public Round disallowSkip()

Disallow skipping of unplayed games while progressing.

Return value

TournamentGenerator\Round $this

Code

public function disallowSkip(){
    $this->allowSkip = false;
    return $this;
}

public Round setSkip(bool $skip)

Sets whether an unplayed games should be skipped while progressing or not.

Parameters

Name	Type	Default	Description
`$skip`	`bool`		Skip or not

Return value

TournamentGenerator\Round $this

Code

public function setSkip(bool $skip) {
    $this->allowSkip = $skip;
    return $this;
}

public bool getSkip()

Gets whether an unplayed games should be skipped while progressing or not.

Return value

bool $this->allowSkip

Code

public function getSkip(bool $skip) {
    return $this->allowSkip;
}

public Round addGroup(TournamentGenerator\Group ...$groups)

Adds created Group to Round.

Parameters

Name	Type	Default	Description
`$groups`	`TournamentGenerator\Group`	`[]`	One or more instances of Group class.

Return value

$this

Code

public function addGroup(Group ...$groups){
    foreach ($groups as $group) {
        $this->groups[] = $group;
    }
    return $this;
}

public Group group(string $name)

Creates and adds new Group to Round.

Parameters

Name	Type	Default	Description
`$name`	`string`	`''`	Name of the new Group.
`$id`	`string\|int`	`null`	Id of the new Group.

Return value

new TournamentGenerator\Group

Code

public function group(string $name, $id = null) {
    $g = new Group($name, $id);
    $this->groups[] = $g->setSkip($this->allowSkip);
    return $g;
}

public array getGroups()

Gets an array of all Groups from Round.

Return value

array of TournamentGenerator\Group

Code

public function getGroups(){
    $this->orderGroups();
    return $this->groups;
}

public array getGroupsIds()

Gets an array of all Group ids from Round.

Return value

array of TournamentGenerator\Group::$id

Code

public function getGroupsIds() {
    $this->orderGroups();
    return array_map(function($a) { return $a->getId(); }, $this->groups);
}

public array orderGroups()

Sorts all Groups from Round.

Return value

array of TournamentGenerator\Group

Code

public function orderGroups() {
    usort($this->groups, function($a, $b){
        return $a->getOrder() - $b->getOrder();
    });
    return $this->groups;
}

public Round addTeam(TournamentGenerator\Team ...$teams)

Adds created Team to Round.

Parameters

Name	Type	Default	Description
`$teams`	`TournamentGenerator\Team`	`[]`	One or more instances of Team class.

Return value

$this

Code

public function addTeam(Team ...$teams) {
    foreach ($teams as $team) {
        $this->teams[] = $team;
    }
    return $this;
}

public Team team(string $name)

Creates and adds new Team to Round.

Parameters

Name	Type	Default	Description
`$name`	`string`	`''`	Name of the new Team.
`$id`	`string\|int`	`null`	Id of the new Team.

Return value

new TournamentGenerator\Team

Code

public function team(string $name = '', $id = null) {
    $t = new Team($name, $id);
    $this->teams[] = $t;
    return $t;
}

public array getTeams(bool $ordered = false, $ordering = POINTS)

Gets an array of all Teams from Round. If passed true as the first argument, teams will be ordered.

Parameters

Name	Type	Default	Description
`$ordered`	`bool`	`false`	If teams should be ordered.
`$ordering`	`\TournamentGenerator\Constants::POINTS \| \TournamentGenerator\Constants::SCORE`	`\TournamentGenerator\Constants::POINTS`	What to order the teams by.
`$filters`	`array`	`[]`	Filters to filter the teams.

Return value

array of TournamentGenerator\Team

Code

public function getTeams(bool $ordered = false, $ordering = \TournamentGenerator\Constants::POINTS, array $filters = []) {
    $teams = $this->teams;
    foreach ($this->rounds as $round) {
        $teams = \array_merge($teams, $round->getTeams());
    }
    $teams = \array_unique($teams);
    $this->teams = $teams;
    if ($ordered) $teams = $this->sortTeams($ordering);

    // APPLY FILTERS
    $filter = new Filter($this->getGroups(), $filters);
    $filter->filter($teams);

    return $teams;
}

public array sortTeams($ordering = POINTS)

Sorts all Teams from Round and returns them.

Parameters

Name	Type	Default	Description
`$ordering`	`\TournamentGenerator\Constants::POINTS \| \TournamentGenerator\Constants::SCORE`	`\TournamentGenerator\Constants::POINTS`	What to order the teams by.
`$filters`	`array`	`[]`	Filters to filter the teams.

Return value

array of TournamentGenerator\Team

Code

public function sortTeams($ordering = \TournamentGenerator\Constants::POINTS, array $filters = []) {
    $teams = Utilis\Sorter\Teams::sortRound($this->teams, $this, $ordering);

    // APPLY FILTERS
    $filter = new Filter($this->getGroups(), $filters);
    $filter->filter($teams);

    return $teams;
}

public array genGames()

Generates all Games from Round.

Return value

array of TournamentGenerator\Game

Code

public function genGames(){
    foreach ($this->groups as $group) {
        $group->genGames();
        $this->games = array_merge($this->games, $group->orderGames());
    }
    return $this->games;
}

public array getGames()

Gets an array of all Games from Round.

Return value

array of TournamentGenerator\Game

Code

public function getGames() {
    return $this->games;
}

public bool isPlayed()

Returns true if all Games have been played.

Return value

bool

Code

public function isPlayed(){
    if (count($this->games) === 0) return false;
    foreach ($this->groups as $group) {
        if (!$group->isPlayed()) return false;
    }
    return true;
}

public bool splitTeams(TournamentGenerator\Round ...$wheres)

Split all Teams from Round into given Rounds. If no argument is given, method will split into all available Rounds in Round.

Parameters

Name	Type	Default	Description
`$wheres`	`TournamentGenerator\Round`	`[]`	One or more instances of Round class to split the teams into.

Return value

$this

Code

public function splitTeams(Group ...$groups) {

    if (count($groups) === 0) $groups = $this->getGroups();

    $teams = $this->getTeams();
    shuffle($teams);

    while (count($teams) > 0) {
        foreach ($groups as $group) {
            if (count($teams) > 0) $group->addTeam(array_shift($teams));
        }
    }
    return $this;
}

public Round progress(bool $returnTime)

Progresses all the Teams.

Return value

$this

Code

public function progress(bool $blank = false){
    foreach ($this->groups as $group) {
        $group->progress($blank);
    }
    return $this;
}

public Round simulate(bool $returnTime)

Simulate all Games from this Round just like it was really played.

Return value

$this

Code

public function simulate() {
    Utilis\Simulator::simulateRound($this);
    return $this;
}

public Round resetGames(bool $returnTime)

Resets the results of all Games in Round.

Return value

$this

Code

public function resetGames() {
    foreach ($this->groups as $group) {
        $group->resetGames();
    }
    return $this;
}