"""
Player: Represents a player's state within a metagame.  Everything that CHANGES about
a map during the course of the game is tracked in the player.
"""
import os
import sys
import time
import types
import struct
import GameItem
import GameMap
import Global
import Utils
from Global import Log
import NecroQuest

# Cache some sizes, for reading/writing binary files.
IntSize = struct.calcsize("i")
FloatSize = struct.calcsize("f")
IIFSize = struct.calcsize("iif")
IISize = struct.calcsize("ii")
QuestRecordSize = struct.calcsize("<iifiiiii")

class MapInfoClass:
    """
    The player's door and room state information for one map.
    - Doors are open or closed
    - Rooms are cleared or uncleared.  Most dungeon rooms are un-cleared when
    re-visiting the dungeon.
    """
    def __init__(self):
        # A room is "clear" if the quest has been won,
        # or if the treasure has been collected, or
        # if the plot-point has been triggered.
        # ("treasure" rooms are un-cleared when the dungeon
        # is visited again, but "uniquetreasure" rooms are
        # cleared once and only once)
        self.RoomClearFlags = {}
        self.DoorOpenFlags = {}
    def RestartDungeon(self, Map):
        self.RoomClearFlags = {}
        self.DoorOpenFlags = {}
        
class QuestInfoClass:
    """
    The player's records for one quest.  Includes whether they have visited the quest before,
    whether they've gotten a medal, and what their high scores are.
    """
    EBAWeightOld = 0.8
    EBAWeightNew = 0.2
    def __init__(self, Quest):
        self.Quest = Quest
        self.TotalPlays = {}
        self.TotalTicks = 0
        self.TriesToComplete = {}
        self.TicksToComplete = {}
        self.EBA = {}
        self.RecentRecords = []
        self.TopRecords = []
        # If VisitFlag is 0, then the player has not yet been to the room featuring this quest,
        # and so the quest doesn't (yet) show up in the ala-carte list, or in the browse-list of
        # high scores.
        self.VisitFlag = 0
        # The player can rate how well they like the quest, assigning it
        # from 1 to 5 stars.  (Similar to iTunes or YTMND ratings).
        # If Stars is 0, the quest isn't rated yet.
        self.Stars = 0
    def HasMedal(self):
        if self.TotalPlays.get(NecroQuest.QuestState.Gold, 0):
            return NecroQuest.QuestState.Gold
        if self.TotalPlays.get(NecroQuest.QuestState.Silver, 0):
            return NecroQuest.QuestState.Silver
        if self.TotalPlays.get(NecroQuest.QuestState.Bronze, 0):
            return NecroQuest.QuestState.Bronze
        if self.TotalPlays.get(NecroQuest.QuestState.Failure, 0):
            return NecroQuest.QuestState.Failure
        return None
    def UpdateOverallStats(self, Record):
        """
        Register this quest result.  Return a list of three flags
        for bronze, silver, and gold completion.
        """
        # Count plays:
        TotalPlays = self.TotalPlays.get(None, 0) + 1
        self.TotalPlays[None] = TotalPlays
        self.TotalPlays[Record.Result] = self.TotalPlays.get(Record.Result, 0) + 1
        # Use flags to track whether we beat gold, silver-or-better, bronze-or-better:
        GoldFlag = 0
        SilverFlag = 0
        BronzeFlag = 0
        if Record.Result == NecroQuest.QuestState.Gold:
            GoldFlag = 1
            SilverFlag = 1
            BronzeFlag = 1
        if Record.Result == NecroQuest.QuestState.Silver:
            SilverFlag = 1
            BronzeFlag = 1
        if Record.Result == NecroQuest.QuestState.Bronze:
            BronzeFlag = 1
        # compute EXPONENTIAL BATTING AVERAGES:
        if not self.EBA.has_key(NecroQuest.QuestState.Gold):
            self.EBA[NecroQuest.QuestState.Gold] = GoldFlag
        else:
            self.EBA[NecroQuest.QuestState.Gold] = self.EBA[NecroQuest.QuestState.Gold] * self.EBAWeightOld + GoldFlag * self.EBAWeightNew
        if not self.EBA.has_key(NecroQuest.QuestState.Silver):
            self.EBA[NecroQuest.QuestState.Silver] = SilverFlag
        else:
            self.EBA[NecroQuest.QuestState.Silver] = self.EBA[NecroQuest.QuestState.Silver] * self.EBAWeightOld + SilverFlag * self.EBAWeightNew
        if not self.EBA.has_key(NecroQuest.QuestState.Bronze):
            self.EBA[NecroQuest.QuestState.Bronze] = BronzeFlag
        else:
            self.EBA[NecroQuest.QuestState.Bronze] = self.EBA[NecroQuest.QuestState.Bronze] * self.EBAWeightOld + BronzeFlag * self.EBAWeightNew
        # Count ticks:
        self.TotalTicks += Record.Ticks
        # Remember the number of plays/ticks required to get first completion:
        if not self.TriesToComplete.has_key(NecroQuest.QuestState.Gold):
            if GoldFlag:
                self.TriesToComplete[NecroQuest.QuestState.Gold] = TotalPlays
                self.TicksToComplete[NecroQuest.QuestState.Gold] = self.TotalTicks
        if not self.TriesToComplete.has_key(NecroQuest.QuestState.Silver):
            if SilverFlag:
                self.TriesToComplete[NecroQuest.QuestState.Silver] = TotalPlays
                self.TicksToComplete[NecroQuest.QuestState.Silver] = self.TotalTicks
        if not self.TriesToComplete.has_key(NecroQuest.QuestState.Bronze):
            if BronzeFlag:
                self.TriesToComplete[NecroQuest.QuestState.Bronze] = TotalPlays
                self.TicksToComplete[NecroQuest.QuestState.Bronze] = self.TotalTicks
        return [BronzeFlag, SilverFlag, GoldFlag]
    def Update(self, Record):
        """
        Update, using a QuestRecordClass instance
        """
        # Note new high scores:
        MedalFlags = self.UpdateOverallStats(Record)
        # Note the record as one of the recent records:
        self.RecentRecords.insert(0, Record)
        self.RecentRecords = self.RecentRecords[:Player.MAX_RECENT_RECORDS]
        # Note the record as one of the top records:
        self.TopRecords.append(Record)
        self.SortTopRecords()
        self.TopRecords = self.TopRecords[:Player.MAX_TOP_RECORDS]
        return MedalFlags
    def SortTopRecords(self):
        """
        Sort self.TopRecords, by whatever criterion (high score, quick completion)
        """
        SortedList = []
        for Record in self.TopRecords:
            Entry = []
            # First, sort gold/silver/bronze/fail:
            Entry.append(NecroQuest.QuestState.TopScoreOrdering[Record.Result])
            # Then, sort by particular quest stats:
            for StatIndex in range(len(self.Quest.Stats)):
                Stat = self.Quest.Stats[StatIndex]
                Value = Record.StatValues[StatIndex]
                if Stat.HighFlag:
                    Entry.append(-Value)
                else:
                    Entry.append(Value)
            Entry.append(Record)
            SortedList.append(Entry)
        SortedList.sort()
        self.TopRecords = []
        for List in SortedList:
            self.TopRecords.append(List[-1])

class Bag:
    pass

class Player:
    # These constants reflect the number of records that are written
    # to the savefile.  If any of them change, then the SaveFileVersion
    # must be bumped up:
    MAX_EQUIP_SIZE = 5
    MAX_INVENTORY_SIZE = 25
    MAX_ROOM_SIZE = 100
    MAX_DOOR_SIZE = 50
    MAX_RECENT_RECORDS = 10
    MAX_TOP_RECORDS = 10
    RECENT_QUEST_COUNT = 20
    # Save file version.  If this increases, then old saves can no longer
    # be loaded...unless a converter is written.  This will NOT increase
    # with every retromancer release!
    SaveFileVersion = 2
    def __init__(self):
        self.PlayStartTime = time.time()
        self.Name = "Player"
        self.Initials = "AAA"
        self.CurrentMap = 0
        self.CurrentRoom = 0
        self.PreviousRoom = -1
        self.CurrentLives = 3
        self.CurrentTime = 20 * 60.0
        # MapID to MapInfo instance:
        self.MapInfoDict = {}
        self.QuestInfoDict = {} 
        self.Equipment = []
        self.Inventory = []
        self.Money = 0
        self.MedalCountBronze = 0
        self.MedalCountSilver = 0
        self.MedalCountGold = 0
        self.ItemSlots = 0
        # Scoring multipliers:
        self.MedalMoneyMultiplier = 1.0
        self.ClearMoneyMultiplier = 1.0
        self.ResearchCostMultiplier = 1.0
        self.ResearchSpeedMultiplier = 1.0
        # Stats before starting a dungeon, which are rolled back on failure:
        self.PreDungeonMap = 0
        self.PreDungeonRoom = 0
        self.PreDungeonMoney = 0
        self.PreDungeonItemSlots = 0
        self.PreDungeonEquipment = []
        self.PreDungeonInventory = []
        # list of recently-cleared QuestIDs:
        self.LastVisits = [-1] * self.RECENT_QUEST_COUNT
        Log("Player.LastVisits: %s"%str(self.LastVisits))
        # Track file positions:
        self.FilePosBody = 0
        self.FilePosMap = 0
        self.FilePosQuest = 0
    def GetCompletionRate(self):
        """
        Get a completion-percentage.  It's computed as follows:
        -For each quest, add 10 to the possible.  To our total add 10 for gold, 8 for silver, 5 for bronze
        -Dungeons will add 100 each
        -Data mining will add 1 each
        """
        MyPoints = 0
        PossiblePoints = 0
        for (QuestID, Info) in self.QuestInfoDict.items():
            Medal = Info.HasMedal()
            PossiblePoints += 10
            if Medal == NecroQuest.QuestState.Gold:
                MyPoints += 10
            elif Medal == NecroQuest.QuestState.Silver:
                MyPoints += 8
            elif Medal == NecroQuest.QuestState.Bronze:
                MyPoints += 5
        CompletionPercent = int((100 * MyPoints) / PossiblePoints)
        return CompletionPercent
    def GetQuestTriedCount(self):
        QuestsTried = 0
        for (QuestID, Info) in self.QuestInfoDict.items():
            PlayCount = 0
            for Count in Info.TotalPlays.values():
                PlayCount += Count
            if PlayCount:
                QuestsTried += 1
        return QuestsTried
    def UpdateMedalCounts(self):
        self.MedalCountBronze = 0
        self.MedalCountSilver = 0
        self.MedalCountGold = 0
        for (QuestID, Info) in self.QuestInfoDict.items():
            Medal = Info.HasMedal()
            if Medal == NecroQuest.QuestState.Gold:
                self.MedalCountGold += 1
            elif Medal == NecroQuest.QuestState.Silver:
                self.MedalCountSilver += 1
            elif Medal == NecroQuest.QuestState.Bronze:
                self.MedalCountBronze += 1
    def DebugClearQuest(self, QuestID):
        Quest = Global.Metagame.Quests[QuestID]
        Record = NecroQuest.QuestRecordClass()
        Record.Result = NecroQuest.QuestState.Gold
        Record.Ticks = 666
        Record.Timestamp = time.time()
        Record.MasterLivesLeft = self.CurrentLives
        Record.MasterTimeLeft = self.CurrentTime
        Record.StatValues = [0, 0, 0, 0, 0]
        RecordList = [Record]
        return RecordList
    def GetQuestReward(self, Quest, RecordList):
        """
        Figure out how much money and what other perks you get
        for clearing this quest.
        """
        Reward = Bag()
        Reward.MedalMoney = 0
        Reward.ClearMoney = 0
        Reward.Medal = None
        Reward.RepeatFlag = 0
        Info = self.QuestInfoDict.get(Quest.ID, None)
        if not Info:
            Info = QuestInfoClass(Quest)
            self.QuestInfoDict[Quest.ID] = Info
        OldMedal = Info.HasMedal()
        if OldMedal == None:
            OldMedal = NecroQuest.QuestState.Failure
        BestMedal = OldMedal
        TempVisitList = self.LastVisits[:]
        for Record in RecordList:
            if Record.Result not in (NecroQuest.QuestState.Bronze, NecroQuest.QuestState.Silver, NecroQuest.QuestState.Gold):
                continue
            if Record.Result == NecroQuest.QuestState.Bronze:
                if BestMedal == NecroQuest.QuestState.Failure:
                    Reward.MedalMoney += int(100 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
            elif Record.Result == NecroQuest.QuestState.Silver:
                if BestMedal == NecroQuest.QuestState.Failure:
                    Reward.MedalMoney += int(300 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
                elif BestMedal == NecroQuest.QuestState.Bronze:
                    Reward.MedalMoney += int(200 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
            elif Record.Result == NecroQuest.QuestState.Gold:
                if BestMedal == NecroQuest.QuestState.Failure:
                    Reward.MedalMoney += int(600 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
                elif BestMedal == NecroQuest.QuestState.Bronze:
                    Reward.MedalMoney += int(500 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
                elif BestMedal == NecroQuest.QuestState.Silver:
                    Reward.MedalMoney += int(300 * self.MedalMoneyMultiplier)
                    BestMedal = Record.Result
            ClearMoney = 100
            for Visit in self.LastVisits:
                if Visit == Quest.ID:
                    ClearMoney = max(20, ClearMoney - 50)
                else:
                    ClearMoney = min(100, ClearMoney + 10)
            Reward.ClearMoney += int(ClearMoney * self.ClearMoneyMultiplier)
            if (ClearMoney < 100):
                Reward.RepeatFlag = 1
            if (TempVisitList[-1] != Quest.ID or TempVisitList[-2] != Quest.ID):
                TempVisitList.append(Quest.ID)
        if BestMedal != OldMedal:
            Reward.Medal = BestMedal
        Reward.Money = Reward.MedalMoney + Reward.ClearMoney
        return Reward
    def StartDungeon(self, Map):
        # Save our "pre-dungeon state", which will be restored if we fail to complete the dungeon:
        self.PreDungeonMap = self.CurrentMap
        self.PreDungeonRoom = self.CurrentRoom
        self.PreDungeonEquipment = self.Equipment[:]
        self.PreDungeonInventory = self.Inventory[:]
        self.PreDungeonMoney = self.Money
        # Set our lives and time for the dungeon:
        self.CurrentLives = Map.Lives
        self.CurrentTime = Map.Time
        # %%% apply dungeon equipment here
        # Reset the door and room clearance flags for the map:
        MapInfo = self.MapInfoDict[Map.ID]
        MapInfo.RestartDungeon(Map)
    def FailDungeon(self):
        self.CurrentLives = 3
        self.CurrentTime = 20 * 60
        self.CurrentMap = self.PreDungeonMap
        self.CurrentRoom = self.PreDungeonRoom
        self.CurrentMoney = self.PreDungeonMoney
        self.Equipment = self.PreDungeonEquipment
        self.Inventory = self.PreDungeonInventory
        Global.UIMap.EnterMap(self.CurrentMap, self.CurrentRoom)
        #self.UpdateSavefilePlayer()
    def NoteQuestRecords(self, Quest, RecordList):
        """
        Note the completion of this quest:
        - Update the QuestInfo for the quest
        - Update overall MedalCount
        - Update LastVisits
        """
        Info = self.QuestInfoDict.get(Quest.ID, None)
        if not Info:
            Info = QuestInfoClass(Quest)
            self.QuestInfoDict[Quest.ID] = Info
        for Record in RecordList:
            Medals = Info.Update(Record)
        self.UpdateMedalCounts()
        # Change the map.  If it's overworld, clear the room provided the quest has ever been cleared.
        # If it's a dungeon, clear the room only if the player just actually cleared it.
        ClearFlag = 0
        Map = Global.Metagame.Maps[self.CurrentMap]
        if Info.HasMedal() and Map.Type == GameMap.MapType.Overworld:
            ClearFlag = 1
        if Medals[0] or Medals[1] or Medals[2]:
            ClearFlag = 1
        Log("ClearFlag is %s"%ClearFlag)
        Log("Medal counts: %s"%str(Medals))
        Log("HasMedal: %s"%Info.HasMedal())
        MapChangedFlag = 0
        DungeonFailFlag = 0
        MapInfo = self.MapInfoDict[self.CurrentMap]
        LastRecord = RecordList[-1]
        Log(">>>Current lives: %s"%LastRecord.MasterLivesLeft)
        if Map.Type == GameMap.MapType.LifeDungeon:
            self.CurrentLives = LastRecord.MasterLivesLeft
            if self.CurrentLives <= 0:
                DungeonFailFlag = 1
                self.FailDungeon()
        elif Map.Type == GameMap.MapType.TimeDungeon:
            self.CurrentTime = LastRecord.MasterTicksLeft
            if self.CurrentTime <= 0:
                DungeonFailFlag = 1
                self.FailDungeon()
        for Room in Map.Rooms:
            if not hasattr(Room, "QuestID") or Room.QuestID != Quest.ID:
                continue
            OldRoomClearFlag = MapInfo.RoomClearFlags.get(Room.ID, 0)
            Log(">>> Room %s quest %s clear flag: Old %s new %s"%(Room.ID, Quest.ID, OldRoomClearFlag, ClearFlag))
            if ClearFlag and not OldRoomClearFlag:
                MapChangedFlag = 1
                MapInfo.RoomClearFlags[Room.ID] = 1
        self.UpdateSavefilePlayer()
        # Save the quest stuff:
        self.UpdateSavefileQuest(Quest.ID)
        # Save the map change:
        if MapChangedFlag:
            self.UpdateSavefileMap(self.CurrentMap)
        # Move to different map, if necessary:
        # Update images:
        Global.UIMap.UpdateRoomImages()
        # Update info panel:
        Global.UIInfo.BuildPlayerWidgets()
        for Record in RecordList:
            if Record.Result > NecroQuest.QuestState.Failure:
                # Add a visit, probably:
                if (self.LastVisits[-1] != Quest.ID or self.LastVisits[-2] != Quest.ID):
                    self.LastVisits.append(Quest.ID)
        self.LastVisits = self.LastVisits[-self.RECENT_QUEST_COUNT:]
        return DungeonFailFlag
    def GetFilePath(self):
        return "%s.sav"%self.Name
    def Load(self, FilePath = None):
        """
        Load a saved game!
        """
        if FilePath == None:
            FilePath = self.GetFilePath()
        File = open(FilePath, "rb")
        # skip magic-number:
        File.read(8) 
        Version = struct.unpack("<i", File.read(IntSize))[0]
        if Version != self.SaveFileVersion:
            raise ValueError, "Unable to load savegame - our save version is %s, save version is %s.  Check whether a converter exists!"%(self.SaveFileVersion, Version)
        self.FilePosBody = File.tell()
        self.LoadPlayer(File)
        self.FilePosMap = File.tell()
        self.LoadMapInfo(File)
        self.FilePosQuest = File.tell()
        self.LoadQuestInfo(File)
        Log("File positions: Body %s, map %s, quest %s"%(self.FilePosBody, self.FilePosMap, self.FilePosQuest))
        self.UpdateMedalCounts()
    def LoadQuestInfo(self, File):
        QuestCount = struct.unpack("<i", File.read(IntSize))[0]
        for QuestID in range(QuestCount):
            Quest = Global.Metagame.Quests[QuestID]
            Info = QuestInfoClass(Quest)
            self.QuestInfoDict[QuestID] = Info
            Info.Stars = struct.unpack("<i", File.read(IntSize))[0]
            Info.VisitFlag = struct.unpack("<i", File.read(IntSize))[0]
            Info.TotalTicks = struct.unpack("<i", File.read(IntSize))[0]
            Info.TotalPlays[0] = struct.unpack("<i", File.read(IntSize))[0]
            Info.TotalPlays[1] = struct.unpack("<i", File.read(IntSize))[0]
            Info.TotalPlays[2] = struct.unpack("<i", File.read(IntSize))[0]
            Info.TotalPlays[3] = struct.unpack("<i", File.read(IntSize))[0]
            # Ticks to complete:
            Ticks = struct.unpack("<i", File.read(IntSize))[0]
            if Ticks > 0:
                Info.TicksToComplete[1] = Ticks
            Ticks = struct.unpack("<i", File.read(IntSize))[0]
            if Ticks > 0:
                Info.TicksToComplete[2] = Ticks 
            Ticks = struct.unpack("<i", File.read(IntSize))[0]
            if Ticks > 0:
                Info.TicksToComplete[3] = Ticks
            # Tries to complete:
            Tries = struct.unpack("<i", File.read(IntSize))[0]
            if Tries > 0:
                Info.TriesToComplete[1] = Tries
            Tries = struct.unpack("<i", File.read(IntSize))[0]
            if Tries > 0:
                Info.TriesToComplete[2] = Tries
            Tries = struct.unpack("<i", File.read(IntSize))[0]
            if Tries > 0:
                Info.TriesToComplete[3] = Tries
            EBA = struct.unpack("<f", File.read(FloatSize))[0]
            if (EBA >= 0):
                Info.EBA[1] = EBA
            EBA = struct.unpack("<f", File.read(FloatSize))[0]
            if (EBA >= 0):
                Info.EBA[2] = EBA
            EBA = struct.unpack("<f", File.read(FloatSize))[0]
            if (EBA >= 0):
                Info.EBA[3] = EBA
            
            # Recent records:
            for Index in range(self.MAX_RECENT_RECORDS):
                String = File.read(QuestRecordSize)
                Record = self.UnpackQuestRecord(String)
                if Record:
                    Info.RecentRecords.append(Record)
            # Top records:
            for Index in range(self.MAX_TOP_RECORDS):
                String = File.read(QuestRecordSize)
                Record = self.UnpackQuestRecord(String)
                if Record:
                    Info.TopRecords.append(Record)
            
    def LoadMapInfo(self, File):
        "Helper for Load: Load map info (clear-flags and open doors)"
        #Log("Maps start at %s"%File.tell())
        MapCount = struct.unpack("<i", File.read(IntSize))[0]
        for MapID in range(MapCount):
            #Log("Map %s starts at %s"%(MapID, File.tell()))
            MapInfo = MapInfoClass()
            self.MapInfoDict[MapID] = MapInfo
            for RoomID in range(self.MAX_ROOM_SIZE):
                Flag = struct.unpack("<i", File.read(IntSize))[0]
                MapInfo.RoomClearFlags[RoomID] = Flag
                #Log("LoadMapInfo: (%s, %s) clear %s"%(MapID, RoomID, Flag))
            for DoorID in range(self.MAX_DOOR_SIZE):
                (RoomIDA, RoomIDB, Flag) = struct.unpack("<iii", File.read(3 * IntSize))
                if RoomIDA < 0 or RoomIDB < 0:
                    continue # ignore dummy entry
                MapInfo.DoorOpenFlags[(RoomIDA, RoomIDB)] = Flag
                MapInfo.DoorOpenFlags[(RoomIDB, RoomIDA)] = Flag
    def Save(self, FilePath = None):
        """
        Write a BRAND NEW save.  (Note that we normally just UPDATE a save!)
        """
        if FilePath == None:
            FilePath = self.GetFilePath()
        Log("Player save to FilePath: '%s' %s %s"%(FilePath, type(FilePath), len(FilePath)))
        File = open(FilePath, "wb")
        # Write a HEADER:
        File.write("Nekofami")
        File.write(struct.pack("<i", self.SaveFileVersion))
        # Write the PLAYER info:
        self.FilePosBody = File.tell()
        self.SavePlayer(File)
        # Write the MAP info:
        self.FilePosMap = File.tell()
        self.SaveMapInfo(File)
        # Write the QUEST info:
        self.FilePosQuest = File.tell()
        self.SaveQuestInfo(File)
        File.close()
    def GetTimeLeftString(self):
        if self.CurrentTime < 60:
            return "%.1f seconds"%self.CurrentTime
        else:
            return "%s min %d sec"%(int(self.CurrentTime / 60), self.CurrentTime % 60)
    def InitQuestMapInfo(self):
        """
        Build quest info and map info for the meta-game.
        """
        Game = Global.Metagame
        for QuestID in range(Game.QuestCount):
            Quest = Game.Quests[QuestID]
            QuestInfo = self.QuestInfoDict.get(QuestID, None)
            if not QuestInfo:
                QuestInfo = QuestInfoClass(Quest)
                self.QuestInfoDict[QuestID] = QuestInfo
        for MapID in range(Game.MapCount):
            MapInfo = self.MapInfoDict.get(MapID, None)
            if not MapInfo:
                MapInfo = MapInfoClass()
                self.MapInfoDict[MapID] = MapInfo
    def SaveOneQuestInfo(self, Info, File):
        # Save overall info:
        File.write(struct.pack("<i", Info.Stars))
        File.write(struct.pack("<i", Info.VisitFlag))
        File.write(struct.pack("<i", Info.TotalTicks))
        File.write(struct.pack("<iiii", Info.TotalPlays.get(0, 0), Info.TotalPlays.get(1, 0),
                               Info.TotalPlays.get(2, 0), Info.TotalPlays.get(3, 0)))
        File.write(struct.pack("<iii", Info.TicksToComplete.get(1, -1),
                               Info.TicksToComplete.get(2, -1),
                               Info.TicksToComplete.get(3, -1)))
        File.write(struct.pack("<iii", Info.TriesToComplete.get(1, -1),
                               Info.TriesToComplete.get(2, -1),
                               Info.TriesToComplete.get(3, -1)))
        File.write(struct.pack("<fff", Info.EBA.get(1, -1),
                               Info.EBA.get(2, -1),
                               Info.EBA.get(3, -1)))
        # Save recent records:
        NullRecordStruct = struct.pack("<iifiiiii", -1, 0, 0, 0, 0, 0, 0, 0)
        for RecordIndex in range(self.MAX_RECENT_RECORDS):
            if RecordIndex < len(Info.RecentRecords):
                RecordString = self.PackQuestRecord(Info.RecentRecords[RecordIndex])
                File.write(RecordString)
            else:
                File.write(NullRecordStruct)
        # Save top records:
        for RecordIndex in range(self.MAX_TOP_RECORDS):
            if RecordIndex < len(Info.TopRecords):
                RecordString = self.PackQuestRecord(Info.TopRecords[RecordIndex])
                File.write(RecordString)
            else:
                File.write(NullRecordStruct)
    def SaveQuestInfo(self, File):
        "Save ALL quest info"
        Game = Global.Metagame
        File.write(struct.pack("<i", Game.QuestCount))
        for QuestID in range(Game.QuestCount):
            Info = self.QuestInfoDict[QuestID]
            self.SaveOneQuestInfo(Info, File)
    def PackQuestRecord(self, Record):
        Str = struct.pack("<iif", Record.Result, Record.Ticks, Record.Timestamp)
        for StatIndex in range(5):
            if StatIndex < len(Record.StatValues):
                Str += struct.pack("<i", Record.StatValues[StatIndex])
            else:
                Str += struct.pack("<i", 0)
        return Str
    def UnpackQuestRecord(self, String):
        (Result, Ticks, Timestamp) = struct.unpack("<iif", String[:IIFSize])
        if Result < 0:
            # This is a NULL record.
            return None
        Record = NecroQuest.QuestRecordClass()
        Record.Result = Result
        Record.Ticks = Ticks
        Record.Timestamp = Timestamp
        Record.StatValues = struct.unpack("<iiiii", String[IIFSize:])
        return Record
    def SaveMapInfo(self, File):
        "Save ALL map info"
        Game = Global.Metagame
        # ASSUME: Map IDs range from 0 up to MapCount
        File.write(struct.pack("<i", Game.MapCount))
        for MapID in range(Game.MapCount):
            MapInfo = self.MapInfoDict[MapID]
            for RoomID in range(self.MAX_ROOM_SIZE):
                ClearFlag = MapInfo.RoomClearFlags.get(RoomID, 0)
                #Log("Map %s room %s clear %s"%(MapID, RoomID, ClearFlag))
                File.write(struct.pack("<i", ClearFlag))
            DoorCount = 0
            for (Key, OpenFlag) in MapInfo.DoorOpenFlags.items():
                if (Key[0] > Key[1]):
                    continue
                File.write(struct.pack("<iii", Key[0], Key[1], OpenFlag))
                DoorCount += 1
            while DoorCount < self.MAX_DOOR_SIZE:
                File.write(struct.pack("<iii", -1, -1, -1))
                DoorCount += 1
    def LoadPlayer(self, File):
        self.Name = Utils.UnpackString(struct.unpack("<255s", File.read(255))[0])
        self.Initials = Utils.UnpackString(struct.unpack("<3s", File.read(3))[0])
        self.CurrentMap = struct.unpack("<i", File.read(IntSize))[0]
        Log("Current map: %s"%(self.CurrentMap))
        self.CurrentRoom = struct.unpack("<i", File.read(IntSize))[0]
        Log("Current room loaded: %s"%self.CurrentRoom)
        self.PreviousRoom = struct.unpack("<i", File.read(IntSize))[0]
        self.CurrentLives = struct.unpack("<i", File.read(IntSize))[0]
        Log("Current lives: %s"%self.CurrentLives)
        self.CurrentTime = struct.unpack("<f", File.read(FloatSize))[0]
        Log("Current time: %s"%self.CurrentTime)
        self.Money = struct.unpack("<i", File.read(IntSize))[0]
        self.MedalCountBronze = struct.unpack("<i", File.read(IntSize))[0]
        self.MedalCountSilver = struct.unpack("<i", File.read(IntSize))[0]
        self.MedalCountGold = struct.unpack("<i", File.read(IntSize))[0]
        self.ItemSlots = struct.unpack("<i", File.read(IntSize))[0]
        self.PlayStartTime = struct.unpack("<i", File.read(IntSize))[0]
        Log("Play start time: %s"%(self.PlayStartTime))
        # Recent quest IDs:
        self.LastVisits = []
        for Index in range(self.RECENT_QUEST_COUNT):
            QuestID = struct.unpack("<i", File.read(IntSize))[0]
            self.LastVisits.append(QuestID)
        self.PreDungeonMap = struct.unpack("<i", File.read(IntSize))[0]
        self.PreDungeonRoom = struct.unpack("<i", File.read(IntSize))[0]
        self.PreDungeonMoney = struct.unpack("<i", File.read(IntSize))[0]
        self.PreDungeonItemSlots = struct.unpack("<i", File.read(IntSize))[0]
        for Index in range(self.MAX_EQUIP_SIZE):
            (ItemType, Uses) = struct.unpack("<ii", File.read(IISize))
            if ItemType >= 0:
                Item = GameItem.ItemClass(ItemType, Uses)
                self.Equipment.append(Item)
        for Index in range(self.MAX_INVENTORY_SIZE):
            (ItemType, Uses) = struct.unpack("<ii", File.read(IISize))
            if ItemType >= 0:
                Item = GameItem.ItemClass(ItemType, Uses)
                self.Inventory.append(Item)
        for Index in range(self.MAX_EQUIP_SIZE):
            (ItemType, Uses) = struct.unpack("<ii", File.read(IISize))
            if ItemType >= 0:
                Item = GameItem.ItemClass(ItemType, Uses)
                self.PreDungeonEquipment.append(Item)
        for Index in range(self.MAX_INVENTORY_SIZE):
            (ItemType, Uses) = struct.unpack("<ii", File.read(IISize))
            if ItemType >= 0:
                Item = GameItem.ItemClass(ItemType, Uses)
                self.PreDungeonInventory.append(Item)
    def SavePlayer(self, File):
        """
        Helper for Save: Write the core player-character state.
        We call SavePlayer once, then we call SaveMap and SaveQuest.
        """
        File.write(struct.pack("<255s", self.Name))
        File.write(struct.pack("<3s", self.Initials))
        Log("Save location: %s, %s, %s"%(self.CurrentMap, self.CurrentRoom, self.PreviousRoom))
        File.write(struct.pack("<iii", self.CurrentMap, self.CurrentRoom, self.PreviousRoom))
        File.write(struct.pack("<if", self.CurrentLives, self.CurrentTime))
        File.write(struct.pack("<iiii", self.Money, self.MedalCountBronze, self.MedalCountSilver, self.MedalCountGold))
        File.write(struct.pack("<i", self.ItemSlots))
        File.write(struct.pack("<i", self.PlayStartTime))
        # Save recently-played quest IDs:
        for VisitIndex in range(self.RECENT_QUEST_COUNT):
            QuestID = self.LastVisits[VisitIndex]
            File.write(struct.pack("<i", QuestID))
        # Write PRE-DUNGEON stats:
        File.write(struct.pack("<ii", self.PreDungeonMap, self.PreDungeonRoom))
        File.write(struct.pack("<ii", self.PreDungeonMoney, self.PreDungeonItemSlots))
        # Write the EQUIPMENT info:
        NullItemRecord = struct.pack("<ii", -1, 0)
        for Index in range(self.MAX_EQUIP_SIZE):
            if Index < len(self.Equipment):
                Item = self.Equipment[Index]
                Record = struct.pack("<ii", Item.Type, Item.UsesLeft)
            else:
                Record = NullItemRecord
            File.write(Record)
        # Write the INVENTORY info:
        for Index in range(self.MAX_INVENTORY_SIZE):
            if Index < len(self.Inventory):
                Item = self.Inventory[Index]
                Record = struct.pack("<ii", Item.Type, Item.UsesLeft)
            else:
                Record = NullItemRecord
            File.write(Record)
        ####################################################
        # Write the PRE-DUNGEON equipment info:
        for Index in range(self.MAX_EQUIP_SIZE):
            if Index < len(self.PreDungeonEquipment):
                Item = self.PreDungeonEquipment[Index]
                Record = struct.pack("<ii", Item.Type, Item.UsesLeft)
            else:
                Record = NullItemRecord
            File.write(Record)
        for Index in range(self.MAX_INVENTORY_SIZE):
            if Index < len(self.PreDungeonInventory):
                Item = self.Inventory[Index]
                Record = struct.pack("<ii", Item.Type, Item.UsesLeft)
            else:
                Record = NullItemRecord
            File.write(Record)
    def UpdateSavefileMap(self, MapID):
        # Save map info for ONE map to our savefile.
        File = open(self.GetFilePath(), "r+b")
        MapRecordSize = (self.MAX_ROOM_SIZE * IntSize) + (self.MAX_DOOR_SIZE * IntSize * 3)
        File.seek(self.FilePosMap + 4 + MapID * MapRecordSize)
        Log("UpdateSavefileMap: Maps start at %s, seek to %s for map %s"%(self.FilePosMap, self.FilePosMap + 4 + MapID * MapRecordSize, MapID))
        MapInfo = self.MapInfoDict[MapID]
        for RoomID in range(self.MAX_ROOM_SIZE):
            ClearFlag = MapInfo.RoomClearFlags.get(RoomID, 0)
            #Log("Map %s room %s clear %s"%(MapID, RoomID, ClearFlag))
            File.write(struct.pack("<i", ClearFlag))
        DoorCount = 0
        for (Key, OpenFlag) in MapInfo.DoorOpenFlags.items():
            if (Key[0] > Key[1]):
                continue
            File.write(struct.pack("<iii", Key[0], Key[1], OpenFlag))
            DoorCount += 1
        while DoorCount < self.MAX_DOOR_SIZE:
            File.write(struct.pack("<iii", -1, -1, -1))
            DoorCount += 1
        File.close()
    def GetQuestInfo(self, Quest):
        if type(Quest) == types.IntType:
            Quest = Global.Metagame.Quests[Quest]
        Info = self.QuestInfoDict.get(Quest.ID, None)
        if not Info:
            Info = QuestInfoClass(Quest)
            self.QuestInfoDict[Quest.ID] = Info
        return self.QuestInfoDict[Quest.ID]
    def UpdateSavefilePlayer(self):
        File = open(self.GetFilePath(), "r+b")
        File.seek(self.FilePosBody)
        self.SavePlayer(File)
        File.close()
    def UpdateSavefileQuest(self, QuestID):
        Log(">>>Update savefile for quest %s"%QuestID)
        # Save quest info for ONE quest to our savefile.
        File = open(self.GetFilePath(), "r+b")
        QuestDataSize = (IntSize * 13) + (FloatSize * 3) + (QuestRecordSize * (self.MAX_RECENT_RECORDS + self.MAX_TOP_RECORDS))
        Log("QuestDataSize is %s"%QuestDataSize)
        File.seek(self.FilePosQuest + 4 + QuestID * QuestDataSize)
        Log("Seek: %s + 4 + %s * %s"%(self.FilePosQuest, QuestID, QuestDataSize))
        QuestInfo = self.QuestInfoDict[QuestID]
        self.SaveOneQuestInfo(QuestInfo, File)
        File.close()
    def GetRoomClearFlag(self, RoomID, MapID = None):
        if MapID == None:
            MapID = self.CurrentMap
        return self.MapInfoDict[MapID].RoomClearFlags.get(RoomID, 0)
    def GetPathClearFlag(self, RoomIDA, RoomIDB, MapID = None):
        if MapID == None:
            MapID = self.CurrentMap
        return self.MapInfoDict[MapID].DoorOpenFlags.get((RoomIDA, RoomIDB), 0)
    def GetBestCompletionString(self, QuestID):
        """
        Return our best completion as a string.
        """
        QuestInfo = self.QuestInfoDict.get(QuestID, None)
        if not QuestInfo:
            return ""
        if QuestInfo.TotalPlays.get(NecroQuest.QuestState.Gold, 0):
            return "Gold"
        if QuestInfo.TotalPlays.get(NecroQuest.QuestState.Silver, 0):
            return "Silver"
        if QuestInfo.TotalPlays.get(NecroQuest.QuestState.Bronze, 0):
            return "Bronze"
        if QuestInfo.TotalPlays.get(NecroQuest.QuestState.Failure, 0):
            return "Failure"
        return ""
    def DebugPrint(self):
        print "Player: %s (%s)"%(self.Name, self.Initials)
        print "Location: Map %s room %s"%(self.CurrentMap, self.CurrentRoom)
    def GetMapInfo(self, MapID = None):
        if not MapID:
            MapID = self.CurrentMap
        return self.MapInfoDict[MapID]
if __name__ == "__main__":
    import GameInfo
    import GameMap
    FileName = os.path.join("Quests", "Games.xml")
    GameInfo.ParseGameInfoFromFile(FileName)
    Metagame = GameMap.MetagameClass()
    Metagame.Load(r"Quests\Dot\Dot.qst")
    Global.Metagame = Metagame
    # Unit test:
    SaveFileName = sys.argv[1]
    TestPlayer = Player()
    
    TestPlayer.Load(SaveFileName)
    TestPlayer.Name = "swt"
    TestPlayer.DebugPrint()
    TestPlayer.CurrentRoom = 4
    TestPlayer.Save(SaveFileName)