LeaderBoard.php

Go to the documentation of this file.

<?php

namespace Combu;

class LeaderBoard extends DataClass {

    const TABLE_NAME = "LeaderBoard";
    
    const VALUE_INT = 0;
    const VALUE_FLOAT = 1;

    const ORDER_DESC = 0;
    const ORDER_ASC = 1;

    const SCORE_UNIQUE_NONE = 0;
    const SCORE_UNIQUE_INCREASE = 1;
    const SCORE_UNIQUE_REPLACE_HIGHER = 2;
    const SCORE_UNIQUE_REPLACE_ANY = 3;
    
    const HIGHSCORE_TOTAL = 0;
    const HIGHSCORE_MONTH = 1;
    const HIGHSCORE_WEEK = 2;
    const HIGHSCORE_TODAY = 3;
    
    const USERSCOPE_GLOBAL = 0;
    const USERSCOPE_FRIENDS = 1;

    public $Id = 0;
    public $IdApp = 0;
    public $Code = "";
    public $Title = "";
    public $Description = "";
    public $UniqueRecords = self::SCORE_UNIQUE_INCREASE;
    public $ValueType = self::VALUE_INT;
    public $OrderType = self::ORDER_DESC;
    public $AllowAnonymous = 0;

    public function __construct($src = null, $stripSlashes = false) {
        global $Database;
        if (empty($src)) {
            return;
        }
        if (is_array($src)) {
            // Load by array
            $this->_loadByRow($src, $stripSlashes);
        } else if (is_numeric($src)) {
            // Load by Id
            if (intval($src) > 0) {
                $this->_loadFilter(self::GetTableName(__CLASS__), "Id = " . intval($src));
            }
        } else {
            // Load by Code
            $this->_loadFilter(self::GetTableName(__CLASS__), sprintf("Code = '%s'", $Database->Escape($src)));
        }
    }

    public function ExistsCode() {
        global $Database;
        $sql = "SELECT Id FROM " . self::GetTableName(__CLASS__) . " WHERE Code = '" . $Database->Escape($this->Code) . "'";
        if ($this->Id > 0) {
            $sql .= " AND Id <> " . $this->Id;
        }
        $res = $Database->Query($sql);
        if ($res) {
            $row = $Database->FetchAssoc($res);
            if ($row) {
                return TRUE;
            }
        }
        return FALSE;
    }
    
    public static function GetScoreTypes() {
        return array(
            self::SCORE_UNIQUE_NONE => "Create new score per match",
            self::SCORE_UNIQUE_INCREASE => "Increase the same score per user",
            self::SCORE_UNIQUE_REPLACE_HIGHER => "Replace the best score per user",
            self::SCORE_UNIQUE_REPLACE_ANY => "Replace the same score per user"
        );
    }

    public static function Load ($idApp = 0, $limit = null, $offset = null, &$count = null, $returnArray = false) {
        $where = "";
        if ($idApp > 0) {
            $where = sprintf("(IdApp = 0 OR IdApp = %d)", $idApp);
        }
        return self::_load(self::GetTableName(__CLASS__), ($returnArray ? "" : __CLASS__), $where, "IdApp, Id", $limit, $offset, $count);
    }

    public function Save() {
        global $Database;
        if ($this->Id > 0) {
            $query = sprintf("UPDATE %s SET Code = '%s', Title = '%s', Description = '%s', ValueType = %d, OrderType = %d, AllowAnonymous = %d WHERE Id = %d",
                    self::GetTableName(__CLASS__),
                    $Database->Escape($this->Code),
                    $Database->Escape($this->Title),
                    $Database->Escape($this->Description),
                    $this->ValueType,
                    $this->OrderType,
                    $this->AllowAnonymous,
                    $this->Id);
        } else {
            $query = sprintf("INSERT INTO %s (IdApp, Code, Title, Description, UniqueRecords, ValueType, OrderType, AllowAnonymous) VALUES (%d, '%s', '%s', '%s', %d, %d, %d, %d)",
                    self::GetTableName(__CLASS__),
                    $this->IdApp,
                    $Database->Escape($this->Code),
                    $Database->Escape($this->Title),
                    $Database->Escape($this->Description),
                    $this->UniqueRecords,
                    $this->ValueType,
                    $this->OrderType,
                    $this->AllowAnonymous);
        }
        if ($Database->Query($query)) {
            if ($this->Id <= 0) {
                $this->Id = $Database->InsertedId();
            }
            return TRUE;
        }
        return FALSE;
    }

    public function Delete() {
        if ($this->Id > 0) {
            if ($this->_Delete(self::GetTableName(__CLASS__), "Id = " . $this->Id)) {
                // Delete all the associated resources
                $this->_Delete(self::GetTableName(LeaderBoard_User::class), "IdLeaderboard = " . $this->Id);
                return TRUE;
            }
        }
        return FALSE;
    }
    
    public static function Prune() {
        self::TruncateClass(__CLASS__);
        LeaderBoard_User::Prune();
    }
    
    public function LoadHighscore ($timeInterval, $userScope, $groupPlayer = FALSE, $sumPlayer = FALSE, $limit = NULL, $offset = NULL, &$count = NULL) {
        global $LoggedAccount;
        // Set the first filter on the current leaderboard
        $where = sprintf("(IdLeaderboard = %d)", $this->Id);
        // Filter Last Updated datetime to reflect the time interval desired
        switch ($timeInterval) {
            case self::HIGHSCORE_TODAY:
                $where .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d"),
                        date("Y-m-d"));
                break;
            case self::HIGHSCORE_WEEK:
                $where .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d", mktime(0, 0, 0, date("m"), date("d") - 7, date("Y"))),
                        date("Y-m-d"));
                break;
            case self::HIGHSCORE_MONTH:
                $where .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d", mktime(0, 0, 0, date("m"), 1, date("Y"))),
                        date("Y-m-t", mktime(0, 0, 0, date("m"), 1, date("Y"))));
                break;
            case self::HIGHSCORE_TOTAL:
            default:
                // No filter on date by default and for TOTAL interval
                break;
        }
        switch ($userScope) {
            case self::USERSCOPE_FRIENDS:
                $filterId = array($LoggedAccount->Id);
                $friends = Friend::Load($LoggedAccount->Id, FRIEND_STATE_ACCEPTED);
                foreach ($friends as $friend) {
                    $filterId[] = $friend->IdFriend;
                }
                $where = sprintf("(IdAccount IN (%s))", implode(",", $filterId));
                break;
        }
        // Build ORDER BY statement and get the field to update
        $order = "";
        $field = "";
        $this->GetOrderBy($order, $field);
        // Load the records from users in the leaderboard
        if ($this->UniqueRecords == self::SCORE_UNIQUE_NONE && ($groupPlayer || $sumPlayer)) {
            // Leaderboards with multiple scores can be grouped to load only the highest score per player
            $where .= " GROUP BY IdAccount";
            if ($sumPlayer) {
                $select = "*, SUM(ValueInt) AS ValueInt, SUM(ValueFloat) AS ValueFloat";
            } else {
                $select = "*, MAX(ValueInt) AS ValueInt, MAX(ValueFloat) AS ValueFloat";
            }
            $records = self::_loadEx($select, self::GetTableName(LeaderBoard_User::class), LeaderBoard_User::class, $where, $order, $limit, $offset);
            $recordCount = self::_loadQuery("SELECT COUNT(Id) AS CountScores FROM (SELECT Id FROM " . self::GetTableName(LeaderBoard_User::class) . " WHERE " . $where . ") T");
            if (count($recordCount) > 0) {
                $count = $recordCount[0]["CountScores"];
            }
        } else {
            // Load all the records filtered in the time interval
            $records = self::_load(self::GetTableName(LeaderBoard_User::class), LeaderBoard_User::class, $where, $order, $limit, $offset, $count);
        }
        // Finally build the highscore custom list!
        $highscore = array();
        $rank = $offset + 1;
        foreach ($records as $record) {
            if ($record->IdAccount > 0) {
                $user = new Account($record->IdAccount);
            } else {
                $user = new Account();
                $user->Username = $record->Username;
            }
            $highscore[] = array(
                "Id" => $record->Id,
                "IdLeaderboard" => $this->Id,
                "Rank" => $rank++,
                "User" => $user->ToJson(),
                "Score" => $record->$field
            );
        }
        return $highscore;
    }
    
    public function GetOrderBy (&$order, &$field) {
        // Build ORDER BY statement and get the field to update
        switch ($this->ValueType) {
            case self::VALUE_FLOAT:
                $order = $field = "ValueFloat";
                break;
            case self::VALUE_INT:
            default:
                $order = $field = "ValueInt";
                break;
        }
        // Apply Descending or Ascending to ORDER BY
        if ($this->OrderType == self::ORDER_ASC) {
            $order .= " ASC, IdAccount ASC";
        } else {
            $order .= " DESC, IdAccount ASC";
        }
    }
    
    public function LoadHighscoreForAccount ($timeInterval, $groupPlayer, $sumPlayer, $idAccount) {
        // Set the time interval statement
        $where_time = "";
        switch ($timeInterval) {
            case self::HIGHSCORE_TODAY:
                $where_time .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d"),
                        date("Y-m-d"));
                break;
            case self::HIGHSCORE_WEEK:
                $where_time .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d", mktime(0, 0, 0, date("m"), date("d") - 7, date("Y"))),
                        date("Y-m-d"));
                break;
            case self::HIGHSCORE_MONTH:
                $where_time .= sprintf(" AND (LastUpdated BETWEEN '%s 00:00:00' AND '%s 23:59:59')",
                        date("Y-m-d", mktime(0, 0, 0, date("m"), 1, date("Y"))),
                        date("Y-m-t", mktime(0, 0, 0, date("m"), 1, date("Y"))));
                break;
            case self::HIGHSCORE_TOTAL:
            default:
                // No filter on date by default and for TOTAL interval
                break;
        }
        // Get the current score for this user
        $where = sprintf("(IdLeaderboard = %d AND IdAccount = %d)", $this->Id, $idAccount) . $where_time;
        $order = "";
        $field = "";
        $this->GetOrderBy($order, $field);
        $records = self::_load(self::GetTableName(LeaderBoard_User::class), LeaderBoard_User::class, $where);
        $userScore = 0;
        if (count($records) > 0) {
            if ($this->UniqueRecords == self::SCORE_UNIQUE_NONE && ($groupPlayer || $sumPlayer)) {
                foreach ($records as $record) {
                    if ($sumPlayer) {
                        $userScore += $record->$field;
                    } else if ($record->$field > $userScore) {
                        $userScore = $record->$field;
                    }
                }
            } else {
                $userScore = $records[0]->$field;
            }
        }
        // Now count how many players with higher score
        $where = sprintf("(IdLeaderboard = %d AND $field " . ($this->OrderType == self::ORDER_ASC ? "<" : ">") . " %f)", $this->Id, $userScore) . $where_time;
        if ($this->UniqueRecords == self::SCORE_UNIQUE_NONE && ($groupPlayer || $sumPlayer)) {
            $where .= " GROUP BY IdAccount";
            if ($sumPlayer) {
                $select = "*, SUM(ValueInt) AS ValueInt, SUM(ValueFloat) AS ValueFloat";
            } else {
                $select = "*, MAX(ValueInt) AS ValueInt, MAX(ValueFloat) AS ValueFloat";
            }
            $recordCount = self::_loadQuery("SELECT COUNT(Id) AS CountScores FROM (SELECT Id FROM " . self::GetTableName(LeaderBoard_User::class) . " WHERE " . $where . ") T");
            if (count($recordCount) > 0) {
                $rank = $recordCount[0]["CountScores"];
            }
        } else {
            $rank = self::_count(self::GetTableName(LeaderBoard_User::class), $where);
        }
        $rank++; // Add "1" to the count, because the first rank is "1" and not "0"
        // Finally count how many players have equal score
        $where = sprintf("(IdLeaderboard = %d AND $field = %f AND IdAccount < %d)", $this->Id, $userScore, $idAccount);
        $rank += count(self::_load(self::GetTableName(LeaderBoard_User::class), LeaderBoard_User::class, $where));
        return array( "IdLeaderboard" => $this->Id, "CodeLeaderboard" => $this->Code, "Score" => $userScore, "Rank" => $rank );
    }
    
    public function PostScore ($account, $scoreValue) {
        // Check the value type of the leaderboard
        // to get the field name to update and adjust score value
        switch ($this->ValueType) {
            case self::VALUE_FLOAT:
                $field = "ValueFloat";
                $scoreValue = floatval($scoreValue);
                break;
            case self::VALUE_INT:
            default:
                $field = "ValueInt";
                $scoreValue = intval($scoreValue);
                break;
        }
        // Load the current saved records for this user
        $records = array();
        if ($account->Id > 0) {
            $records = LeaderBoard_User::LoadAccount($account->Id, $this->Id);
        }
        if (count($records) == 0) {
            // We still haven't records, create new one
            $newRecord = new LeaderBoard_User();
            $newRecord->IdLeaderboard = $this->Id;
            $newRecord->IdAccount = $account->Id;
            $newRecord->Username = $account->Username;
            $newRecord->$field = $scoreValue;
            return $newRecord->Save();
        }
        // Ok! So we have at least one record for this user in the leaderboard...
        // Check to see if the leaderboard requires unique records per user
        if ($this->UniqueRecords != self::SCORE_UNIQUE_NONE) {
            // It requires unique records, so update the current saved
            $records[0]->Username = $account->Username;
            switch ($this->UniqueRecords) {
                case self::SCORE_UNIQUE_INCREASE:
                    // Increase score
                    $records[0]->$field += $scoreValue;
                    break;
                case self::SCORE_UNIQUE_REPLACE_HIGHER:
                    // Replace score if it is highest
                    if (($this->OrderType == self::ORDER_DESC && $records[0]->$field >= $scoreValue) || ($this->OrderType == self::ORDER_ASC && $records[0]->$field <= $scoreValue)) {
                        return TRUE;
                    }
                    $records[0]->$field = $scoreValue;
                    break;
                case self::SCORE_UNIQUE_REPLACE_ANY:
                    $records[0]->$field = $scoreValue;
                    break;
            }
            return $records[0]->Save();
        }
        // It doesn't require unique records, so create new one
        $newRecord = new LeaderBoard_User();
        $newRecord->IdLeaderboard = $this->Id;
        $newRecord->IdAccount = $account->Id;
        $newRecord->Username = $account->Username;
        $newRecord->$field = $scoreValue;
        return $newRecord->Save();
    }
}