Engine.GameProfile

class GameProfile extends Object
    native;

var()   string    PackageName;
var()   int      ManifestIndex;


enum EPlayerPos         
{
    POS_Auto,
    POS_Defense,
    POS_Offense,
    POS_Roam,
    /*POS_Captain,  Not handy for dropdown display */
    POS_Supporting
};
const NUM_POSITIONS = 5;
var localized string PositionName[5];       // text names of these positions

var EPlayerPos PlayerPositions[7];          // only need positions for AI team, so 7 max
const TEAM_SIZE = 7;
var()   array<string> PlayerTeam;          // Player team members
var     int         PlayerLineup[4];        // Lineup for current match.  Stores index into PlayerTeam array.
const LINEUP_SIZE = 4;
var     string      EnemyTeam;              // Opponent team name for pending/current match
var     string      TeamName;               // Player team name
var     string      TeamSymbolName;         // name of team symbol

var()   float       BaseDifficulty;     // configured at start of single player
var()   float      Difficulty;

var     int         SalaryCap;          // allowable salary cap for team roster

// stored here, but also passed separately on URL
var     string      PlayerName;
var     string      PlayerCharacter;

// player's stats - individual experience
var()  int          Kills;
var()  int          Goals;
var()  int          Deaths;
var()  int          Wins;
var()  int          Matches;

// Ladders:  -1 = Locked
var int LadderRung[6];
const NUM_LADDERS = 6;

var string SpecialEvent;
var string GameLadderName;
var class<LadderInfo> GameLadder;

// current match
var int CurrentLadder;
var transient int CurrentMenuRung;      // set by menu system, used for starting a match, in LadderInfo.  if -1, use next match in order
var transient Object NextMatchObject;   // Used by GUI SP Pages for holding the Button for Next Match
var transient Object ChampBorderObject; // Used by GUI SP Pages for holding the border for Championship.  
                                        // Sad hack, but easiest way to communicate GUI objects between Ladder and Qual tabs
var bool bInLadderGame;     // Used to see if we should return to the SP menu after the match has finished, 
                                                    // also used to check if we should use the LoadingClass vignette
var bool bWonMatch;


// constructor:  set up the GameLadder
function Initialize(GameInfo currentGame, string pn)
{
    local Controller C;

    if (GameLadder == none) 
    {
        GameLadder = class<LadderInfo>(DynamicLoadObject(GameLadderName, class'Class'));
    }
    PackageName=pn;
    PlayerName=pn;

    // set character, player in current game
    for ( C=currentGame.Level.ControllerList; C!=None; C=C.NextController ) 
    {
        if ( PlayerController(C) != None ) 
        {
            currentGame.ChangeName (PlayerController(C), PlayerName, false);    
            break;      
        }
    }
    NextMatchObject=None;
    ChampBorderObject=None;
}

// skip this rung of the ladder without saving
function CheatSkipMatch(GameInfo CurrentGame)
{
    SpecialEvent = GameLadder.static.UpdateLadders(self,CurrentLadder); // updates LadderRungs appropriately
    ContinueSinglePlayerGame(CurrentGame.Level);
}

// skip directly to a certain ladder/rung
// takes a single number (54) and splits into ladder 5, match 4
function CheatJumpMatch(GameInfo currentGame, int param) {
    local Controller C;
    local int newladder, newrung;

    newladder = param/10;
    newrung = param-(newladder*10);
    if (newladder < 0 || newladder >= NUM_LADDERS || newrung < 0) 
        return;
    bInLadderGame=true;
    CurrentLadder = newladder;
    LadderRung[CurrentLadder] = newrung;
    CurrentMenuRung=newrung;

    // open game
    for ( C=currentGame.Level.ControllerList; C!=None; C=C.NextController ) 
    {
        if ( PlayerController(C) != None ) 
        {
            PlayerController(C).ConsoleCommand("START"@GameLadder.static.MakeURLFor(self));
            break;      
        }
    }
}

// robust checks are in LadderInfo, returns none if not found
function MatchInfo GetMatchInfo(int ladder, int rung) {
    if ( GameLadder != none ) 
    {
        return GameLadder.static.GetMatchInfo(ladder,rung);
    } 
    else 
    {
        return none;
    }
}

// After a game is completed, this function should be called to 
// record the player's statistics and update the ladder.
// Currently called from Deathmatch 'MatchOver' state
function RegisterGame(GameInfo currentGame, PlayerReplicationInfo PRI)
{
    Log("SINGLEPLAYER GameProfile::RegisterGame for profile"@self.packagename);
    Kills += PRI.Kills;
    Goals += PRI.GoalsScored;
    Deaths += PRI.Deaths;
    Matches++;
    if ( bWonMatch ) {
        //Log("SINGLEPLAYER GameProfile::RegisterGame player won the match.");	
        SpecialEvent = GameLadder.static.UpdateLadders(self,CurrentLadder); // updates LadderRungs appropriately
        Wins++;
    }
    bWonMatch = false;
}

// Send the player to the next match in the given ladder
function StartNewMatch(int PickedLadder, LevelInfo CurrentLevel)
{
    local Controller C;

    bWonMatch = false;
    bInLadderGame=true;
    CurrentLadder = PickedLadder;
    CurrentLevel.Game.SavePackage(PackageName);
    
    // open game
    for ( C=currentLevel.ControllerList; C!=None; C=C.NextController ) 
    {
        if ( PlayerController(C) != None ) 
        {
            PlayerController(C).ConsoleCommand("START"@GameLadder.static.MakeURLFor(self));
            break;      
        }
    }
}

// Handy helper function to find the player's first unfinished ladder
// If no ladders are unfinished, return 0 for DM ladder
function int FindFirstUnfinishedLadder() {
    local int i;
    
    for (i=0; i<6; i++) 
    {       
        // 6 is magic from number of ladders, declared above
        if (LadderRung[i] < GameLadder.static.LengthOfLadder(i)) {
            return i;       
        }
    }
    return 0;
}

// override in subclasses!
function ContinueSinglePlayerGame(LevelInfo level, optional bool bReplace)
{
    Level.Game.SavePackage(PackageName);

    // the direct call to startnewmatch is to avoid using a game-specific menu system
    StartNewMatch(FindFirstUnfinishedLadder(), level);
}

// Used in menus:  this is the gametype info for the next match
function string GetMatchDescription()
{
    return GameLadder.static.GetMatchDescription(self);
}

// accessor
function static int GetNumPositions()
{
    return NUM_POSITIONS;
}

// return number of teammates needed for currently selected match
// assumes player team always gets an odd player
function int GetNumTeammatesForMatch()
{
    local MatchInfo M;

    M = GameLadder.static.GetCurrentMatchInfo(self);

    if ( M.GameType ~= "xGame.xDeathmatch" || M.GameType ~= "xGame.BossDM" ) 
        return 0;
    else
        return M.NumBots / 2;
}


function static string TextPositionDescription(int posnval) 
{
    local string retval;

    if (posnval < 0 || posnval > NUM_POSITIONS) // magic number based on team size of 7
        return "Error";

    switch (posnval) {
        case EPlayerPos.POS_Auto:
            retval = default.PositionName[0];
            break;
        case EPlayerPos.POS_Defense:
            retval = default.PositionName[1];
            break;
        case EPlayerPos.POS_Offense:
            retval = default.PositionName[2];
            break;
        case EPlayerPos.POS_Roam:
            retval = default.PositionName[3];
            break;
/*      case EPlayerPos.POS_Captain:
            retval = "CAPTAIN";
            break;*/
        case EPlayerPos.POS_Supporting:
            retval = default.PositionName[4];
            break;
    }

    return retval;
}

function static EPlayerPos EnumPositionDescription(string posnval) 
{   
    local EPlayerPos retval;

    if (posnval == default.PositionName[0]) {
        retval = EPlayerPos.POS_Auto;
    } else if (posnval == default.PositionName[1]) {
        retval = EPlayerPos.POS_Defense;
    } else if (posnval == default.PositionName[2]) {
        retval = EPlayerPos.POS_Offense;
    } else if (posnval == default.PositionName[3]) {
        retval = EPlayerPos.POS_Roam;
    } else if (posnval == default.PositionName[4]) {
        retval = EPlayerPos.POS_Supporting;
    } else 
        retval = EPlayerPos.POS_Auto;

    return retval;
}

function string GetPositionDescription(int playernum) 
{
    if (playernum < 0 || playernum >= TEAM_SIZE)    
        return "Error";
    return TextPositionDescription(PlayerPositions[playernum]);
}

// takes a lineup position (1-4) and sets that player's game position
function SetPosition (int lineupnum, string posn)
{
    if ((lineupnum >= 0) && (lineupnum < 4))
        PlayerPositions[PlayerLineup[lineupnum]] = EnumPositionDescription(posn);
}

// called when adjusting the lineup
// takes lineup position (1-4) and team position (1-7) and makes it all work
function SetLineup (int lineuppos, int teampos)
{
    local int oldlineuppos, oldteammate, i;

    // check bounds
    if ( lineuppos < 0 || lineuppos > LINEUP_SIZE ) 
        return;
    if ( teampos < 0 || teampos >= TEAM_SIZE )
        return;
    if ( PlayerLineup[lineuppos] == teampos )   // no-op
        return;

    // check to see if player 'teampos' was already in the lineup 
    oldlineuppos=-1;
    for ( i=0; i<LINEUP_SIZE; i++ )
    {
        if ( PlayerLineup[i] == teampos ) 
        {
            oldlineuppos = i;
            break;
        }
    }
    if ( oldlineuppos >= 0 ) {
        oldteammate = PlayerLineup[lineuppos];
    }
    PlayerLineup[lineuppos] = teampos;
    if ( oldlineuppos >= 0 ) {
        PlayerLineup[oldlineuppos] = oldteammate;
    }
}

// add teammate to the next available position on the team
// return false if not added because already on team or no room
// assumes it's a legal player record
function bool AddTeammate(string botname) 
{
    local int i;
    
    if ( botname == "" ) 
    {
        return false;
    }

    for ( i=0; i<TEAM_SIZE; i++ ) 
    {
        if ( i >= PlayerTeam.Length || PlayerTeam[i] == "" ) 
        {
            Playerteam[i] = botname;
            return true;
        }
        if ( PlayerTeam[i] ~= botname ) 
        {
            // already on team
            return false;
        }
    }

    return false;  // never found space
}

// remove teammate from the team
// return false if not removed because not on team 
function bool ReleaseTeammate(string botname) 
{
    local int i, j;
    
    if ( botname == "" ) 
    {
        return false;
    }

    for ( i=0; i<PlayerTeam.Length; i++ ) 
    {
        if ( PlayerTeam[i] ~= botname ) 
        {
            // player is on team, shuffle list 
            for ( j=i; j<PlayerTeam.Length-1; j++ ) 
            {
                PlayerTeam[j] = PlayerTeam[j+1];
            }
            PlayerTeam[PlayerTeam.Length-1] = "";
            return true;
        }
    }

    return false;  // never found botname
}

function ClearTeammates() 
{
    local int i;
    for ( i=0; i<PlayerTeam.Length; i++ ) 
    {
        PlayerTeam[i] = "";
    }
}

function ReportCheat(PlayerController Cheater, string cheat);

function bool CanChangeTeam(Controller Other, int NewTeam)
{
    return true;
}

defaultproperties
{
     PackageName="Default"
     PositionName(0)="AUTO-ASSIGN"
     PositionName(1)="DEFENSE"
     PositionName(2)="OFFENSE"
     PositionName(3)="ROAM"
     PositionName(4)="SUPPORT"
     PlayerLineup(1)=1
     PlayerLineup(2)=2
     PlayerLineup(3)=3
     BaseDifficulty=1.000000
     PlayerName="Name"
     PlayerCharacter="Roc"
     ladderrung(1)=-1
     ladderrung(2)=-1
     ladderrung(3)=-1
     ladderrung(4)=-1
     ladderrung(5)=-1
     GameLadderName="Engine.LadderInfo"
}