414 lines
15 KiB
PHP
414 lines
15 KiB
PHP
<?php
|
|
|
|
namespace App\Leagues;
|
|
|
|
use Illuminate\Database\Eloquent\Model;
|
|
|
|
use App\Season;
|
|
use App\Round;
|
|
use App\User;
|
|
|
|
use DB;
|
|
use Log;
|
|
|
|
class League extends Model
|
|
{
|
|
|
|
const RANK_LEAGUE1 = 1;
|
|
const RANK_LEAGUE2 = 2;
|
|
const RANK_LEAGUE3 = 3;
|
|
const RANK_QUALIFICATION = 4;
|
|
|
|
protected $table ='leagues';
|
|
protected $fillable = [
|
|
'id','season_id','is_qualification','rank','subrank','start_round_id','round_count','name'
|
|
];
|
|
//
|
|
public static function neededLeagues($member_count, $round_count) {
|
|
$max_members_per_league=22;
|
|
if ( $round_count < $max_members_per_league-1 ) { $max_members_per_league = $round_count+1; }
|
|
if ($member_count <= $max_members_per_league) return $member_count;
|
|
|
|
$neededLeagues = intdiv($member_count, $max_members_per_league);
|
|
|
|
if ( $member_count - $max_members_per_league * $neededLeagues ) {
|
|
$neededLeagues+=1;
|
|
}
|
|
return $neededLeagues;
|
|
}
|
|
|
|
public static function getMemberCount($league_id) {
|
|
$members = DB::table('leagues_members')->where('league_id','=',$league_id)->get();
|
|
return sizeof($members);
|
|
}
|
|
|
|
|
|
public static function getNames() {
|
|
$season = Season::getCurrent();
|
|
|
|
$leagues = League::where('season_id','=',$season->id)->orderBy('rank')->orderBy('name')->get();
|
|
|
|
$leagueNames = array();
|
|
foreach($leagues as $league) {
|
|
$leagueNames[$league->id] = $league->name;
|
|
}
|
|
return $leagueNames;
|
|
}
|
|
|
|
public static function getStartRoundId($leagueId)
|
|
{
|
|
$league = League::where('id','=',$leagueId)->first();
|
|
return $league->start_round_id;
|
|
}
|
|
|
|
|
|
public static function cmpScore($score1, $score2) {
|
|
// [0] = user-id
|
|
$_score1 = $score1[1];
|
|
$goals1 = $score1[2];
|
|
$cGoals1 = $score1[3];
|
|
|
|
$_score2 = $score2[1];
|
|
$goals2 = $score2[2];
|
|
$cGoals2 = $score2[3];
|
|
|
|
$diff1 = $goals1-$cGoals1;
|
|
$diff2 = $goals2-$cGoals2;
|
|
|
|
if ($_score1 == $_score2) {
|
|
if ($diff1==$diff2) {
|
|
if ($goals1 == $goals2) {
|
|
return $cGoals1 > $cGoals2;
|
|
}
|
|
return ( $goals1 < $goals2 );
|
|
}
|
|
return ($diff1<$diff2);
|
|
}
|
|
|
|
return ($_score1 < $_score2);
|
|
}
|
|
|
|
|
|
public static function getRanking($rank, $seasonId=-1) {
|
|
$season = Season::getCurrent();
|
|
if ($seasonId > -1) { $season=Season::where('id','=',$seasonId)->first(); };
|
|
$leagues = League::where('rank','=',$rank)->where('season_id','=', $season->id)->orderBy('id')->get();
|
|
|
|
error_log("LeagueCount:".sizeof($leagues));
|
|
|
|
$leagueScores=array();
|
|
foreach($leagues as $league) {
|
|
$memberIds = LeagueMember::getMembers($league->id);
|
|
|
|
$memberScores =array();
|
|
foreach($memberIds as $memberId) {
|
|
$tpl=array();
|
|
$tpl[0]=$memberId;
|
|
$tpl[1]=0; // league_score
|
|
$tpl[2]=0; // goals
|
|
$tpl[3]=0; // countergoals
|
|
$memberScores[$memberId] = $tpl;
|
|
}
|
|
|
|
$matches=Match::getMatchResults($league->id,-1);
|
|
foreach ($matches as $match) {
|
|
if (Round::isCompleted($match->round_id)) {
|
|
$memberScores[$match->user1_id][1] += $match->user1_league_score;
|
|
$memberScores[$match->user1_id][2] += $match->user1_rankscore; // goals
|
|
$memberScores[$match->user1_id][3] += $match->user2_rankscore; // countergoals
|
|
$memberScores[$match->user2_id][1] += $match->user2_league_score;
|
|
$memberScores[$match->user2_id][2] += $match->user2_rankscore; // goals
|
|
$memberScores[$match->user2_id][3] += $match->user1_rankscore; // countergoals
|
|
}
|
|
}
|
|
usort($memberScores, array('App\Leagues\League','cmpScore'));
|
|
|
|
$leagueScores[$league->id]=$memberScores;
|
|
|
|
}
|
|
return $leagueScores;
|
|
}
|
|
|
|
|
|
// Für Auf/Abstiegsberechnung - wird auf previous Season angewendet.
|
|
public static function getUnifiedRanking($rank, $seasonId=-1) {
|
|
$leagueScores = League::getRanking($rank, $seasonId);
|
|
$unifiedScores = array();
|
|
foreach($leagueScores as $leagueId => $singleLeagueScores) {
|
|
foreach ($singleLeagueScores as $placeNr => $singleLeagueScore) {
|
|
$userId=$singleLeagueScores[$placeNr][0];
|
|
$unifiedScores[$userId]=$singleLeagueScores[$placeNr];
|
|
}
|
|
}
|
|
usort($unifiedScores,array('App\Leagues\League','cmpScore'));
|
|
return $unifiedScores;
|
|
}
|
|
|
|
// ausfaktoriert aus LeaguesController::createLeagues()
|
|
// TODO: $round_count ist nur im Quali-Modus relevant und steuert, wieviele Quali-Gruppen benötigt werden.
|
|
// TODO: Sobald es Liga1 und Liga2 gibt, wird der round_count immer 21 sein, da Liga1 und Liga2 auf
|
|
// TODO: 22 Mitspieler festgelegt sind.
|
|
|
|
public static function createLeagues($start_round_id, $round_count) {
|
|
$currentSeason=Season::getCurrent();
|
|
|
|
// Eventuell vorhandene Ligen loeschen
|
|
$leagues=League::where('season_id','=',$currentSeason->id)->get();
|
|
if ($leagues) {
|
|
foreach ($leagues as $league) {
|
|
DB::table('leagues_matches')->where('league_id', '=', $league->id)->delete();
|
|
DB::table('leagues_members')->where('league_id', '=', $league->id)->delete();
|
|
DB::table('leagues')->where('id', '=', $league->id)->delete();
|
|
}
|
|
}
|
|
|
|
$active_member_count=sizeof(User::getActives());
|
|
Log::info("Aktive Spieler: ".$active_member_count);
|
|
$neededLeagues = League::neededLeagues($active_member_count, $round_count);
|
|
Log::info("Benötigte Quali-Gruppen: ".$neededLeagues);
|
|
|
|
$league_ids=array();
|
|
|
|
//TODO: Den Leaguemode kann die Methode selbst rausfinden.
|
|
//TODO: Wenn es keine Vorsaison gibt -> Qualifikation
|
|
//TODO: Ansonsten: Ligen erzeugen.
|
|
$league_mode="Qualifikation";
|
|
|
|
if ($league_mode=="Qualifikation") {
|
|
for ($league_nr=1; $league_nr<=$neededLeagues; $league_nr+=1) {
|
|
$league = League::create([
|
|
'is_qualification' => true,
|
|
'name' => 'Qualifikationsgruppe '.$league_nr,
|
|
'rank' => '4',
|
|
'subrank' => $league_nr,
|
|
'round_count' => $round_count,
|
|
'season_id' => $currentSeason->id,
|
|
'start_round_id' => $start_round_id
|
|
]);
|
|
$league->save();
|
|
$league_ids[$league_nr-1] = $league->id;
|
|
}
|
|
|
|
// Distribute members
|
|
$users = User::getActives();
|
|
shuffle($users);
|
|
$league_index=0;
|
|
Log::info("Distributing Members between groups");
|
|
while(sizeof($users)>0) {
|
|
$user = array_pop($users);
|
|
|
|
$leagueMember = LeagueMember::create([
|
|
'user_id' => $user->id,
|
|
'league_id' => $league_ids[$league_index]
|
|
]);
|
|
$leagueMember->save();
|
|
|
|
$league_index+=1;
|
|
if (sizeof($league_ids)==$league_index) { $league_index=0; }
|
|
}
|
|
|
|
} else {
|
|
|
|
// ToDo: Branch Qualifikation/Liga entfällt in Zukunft, da Quali der Fallback für den Fall ist, dass keine vorherige Saison existiert.
|
|
// Pokal und Play-Off findet hier nicht statt, da diese Wettbewerbe die Matches abgängig von existierenden Vorrunden-Ergebnissen erzeugen,
|
|
// und daher zwangsläufig inkrementell sein müssen.
|
|
|
|
$league_size1= min(22,$active_member_count);
|
|
$league1 = League::create([
|
|
'is_qualification' => false,
|
|
'name' => 'Spielerliga 1',
|
|
'rank' => '1',
|
|
'subrank' => '1',
|
|
'round_count' => $round_count,
|
|
'season_id' => $currentSeason->id,
|
|
'start_round_id' => $start_round_id
|
|
]);
|
|
|
|
$league_size2=min(22,$active_member_count - $league_size1);
|
|
|
|
if ($league_size2>0) {
|
|
$league2 = League::create([
|
|
'is_qualification' => false,
|
|
'name' => 'Spielerliga 2',
|
|
'rank' => '2',
|
|
'subrank' => '1',
|
|
'round_count' => $round_count,
|
|
'season_id' => $currentSeason->id,
|
|
'start_round_id' => $start_round_id
|
|
]);
|
|
|
|
$league_size3 = $active_member_count - $league_size1 - $league_size2;
|
|
|
|
if ($league_size3>0) {
|
|
$neededLeagues = League::neededLeagues($league_size3, $round_count);
|
|
for ($league_nr=1; $league_nr<=$neededLeagues; $league_nr+=1) {
|
|
$league = League::create([
|
|
'is_qualification' => false,
|
|
'name' => 'Spielerliga 3, Gruppe '.$league_nr,
|
|
'rank' => '3',
|
|
'subrank' => $league_nr,
|
|
'round_count' => $round_count,
|
|
'season_id' => $currentSeason->id,
|
|
'start_round_id' => $start_round_id
|
|
]);
|
|
$league->save();
|
|
|
|
}
|
|
}
|
|
|
|
// TODO: LeagueMembers zu den Leagues hinzufügen, abhängig vom zuzuordnenden Platz
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Aktuelle Liga-Zuordnung auf Basis des Rangs in der letzten Liga
|
|
// Oder des Rangs in der Qualifikation
|
|
// oder erstellung des Quali Rangs wenn es keine previous Season gibt.
|
|
|
|
|
|
// Liga-Zugehörigkeit festlegen. Setzt voraus, dass die Ligen bereits erzeugt wurden.
|
|
public static function setLeagueForPlayers()
|
|
/*
|
|
* setLeagueForPlayers__NEW_QUALIFICATION case1
|
|
* setLeagueForPlayers__FROM_QUALIFICATION case2
|
|
* setLeagueForPlayers__FROM_LEAGUES case3
|
|
*/
|
|
{
|
|
$previousSeason = Season::getPrevious();
|
|
$currentSeason = Season::getCurrent();
|
|
$users = User::getActives();
|
|
|
|
if (!$previousSeason) {
|
|
// case 1: first season ever, no previous season exists, qualification (league-rank=4)
|
|
} elseif (Season::hasQualification($previousSeason->id)){
|
|
// case 2: previous season was qualification season (rank 4)
|
|
} else { /*case 3 - default: determine league-ranks 1,2,3 from previous Season rank verwenden*/
|
|
}
|
|
|
|
|
|
// 2 Möglichkeiten:
|
|
// 1.) previousSeason hat rank=4 => Qualification Round
|
|
// 2.) sonst aus .
|
|
|
|
|
|
$usersLastSeason = User::getActives($previousSeason->id);
|
|
|
|
$league1 = League::getUnifiedRanking(1, $previousSeason->id);
|
|
$league2 = League::getUnifiedRanking( 2, $previousSeason->id);
|
|
$league3 = League::getUnifiedRanking( 3, $previousSeason->id);
|
|
//$lastLeagues = League::where('season_id','=',$previousSeason->id)->get();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
foreach ($users as $index => $user) {
|
|
|
|
$found = false;
|
|
foreach ($usersLastSeason as $userLastSeason) {
|
|
if ($userLastSeason->id == $user->id) $found = true;
|
|
}
|
|
|
|
if (!$found) {
|
|
$users[$index]['rank']=League::RANK_LEAGUE3; // In der letzten Season unter den Actives nicht gefunden
|
|
$leagueMember = LeagueMember::create([
|
|
'user_id' => $user->id,
|
|
'league_id' => $league3->id
|
|
]);
|
|
$leagueMember->save();
|
|
} else {
|
|
|
|
// League1, 1-16: RANK_LEAGUE1
|
|
// League1, 17-22: RANK_LEAGUE2
|
|
// League2, 1-6: RANK_LEAGUE1
|
|
// League2, 7-16: RANK_LEAGUE2
|
|
// League2, 17-22: RANK_LEAGUE3
|
|
// League3, best6: RANK_LEAGUE2
|
|
// League3, 7-end: RANK_LEAGUE3
|
|
//
|
|
|
|
//alte Ligen durchsuchen und entsprechend einordnen
|
|
foreach($league1 as $index => $entry) {
|
|
$userId = $entry[0];
|
|
$score = $entry[1];
|
|
$goals = $entry[2];
|
|
$cGoals = $entry[3];
|
|
$leagueId = -1;
|
|
if ($user->id == $userId) {
|
|
$rank=-1;
|
|
if ($index<16) {
|
|
$rank=1;
|
|
$leagueId=$league1->id;
|
|
} else {
|
|
$rank=2;
|
|
$leagueId=$league2->id;
|
|
}
|
|
$leagueMember = LeagueMember::create([
|
|
'user_id' => $userId,
|
|
'league_id' => $leagueId
|
|
]);
|
|
$leagueMember->save();
|
|
}
|
|
}
|
|
|
|
foreach($league2 as $index => $entry) {
|
|
$userId = $entry[0];
|
|
$score = $entry[1];
|
|
$goals = $entry[2];
|
|
$cGoals = $entry[3];
|
|
$leagueId = -1;
|
|
if ($user->id == $userId) {
|
|
$rank=-1;
|
|
$leagueId=$league1->id;
|
|
if ($index<6) {
|
|
$rank=1;
|
|
} elseif ($index<16) {
|
|
$rank=2;
|
|
$leagueId=$league2->id;
|
|
} else {
|
|
$rank=3;
|
|
$leagueId=$league3->id;
|
|
}
|
|
$leagueMember = LeagueMember::create([
|
|
'user_id' => $userId,
|
|
'league_id' => $leagueId
|
|
]);
|
|
$leagueMember->save();
|
|
}
|
|
}
|
|
|
|
foreach($league3 as $index => $entry) {
|
|
$userId = $entry[0];
|
|
$score = $entry[1];
|
|
$goals = $entry[2];
|
|
$cGoals = $entry[3];
|
|
if ($user->id == $userId) {
|
|
$rank=-1;
|
|
if ($index<6) {
|
|
$rank=2;
|
|
$leagueId=$league2->id;
|
|
} else {
|
|
$rank=3;
|
|
$leagueId=$league3->id;
|
|
}
|
|
$leagueMember = LeagueMember::create([
|
|
'user_id' => $userId,
|
|
'league_id' => $leagueId
|
|
]);
|
|
$leagueMember->save();
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
*/
|
|
}
|
|
|
|
}
|