## Unit Plot List Utilities
##
## Holds the information used to display the unit plot list
##
## Copyright (c) 2007-2009 The BUG Mod.
##
## Author: Ruff_Hi

from CvPythonExtensions import *
import MonkeyTools as mt
import BugUtil
import UnitUtil

import BugCore
PleOpt = BugCore.game.PLE

# globals
gc = CyGlobalContext()
ArtFileMgr = CyArtFileMgr()
localText = CyTranslator()

sBupStringBase = "BUGUnitPlotString"
cBupCellSize = 34
cBupCellSpacing = 3

class BupPanel:
    def __init__(self, screen, xRes, yRes, iMulti, iVanCols, iVanRows):
        self.CellSpacing = cBupCellSpacing
        self.MaxCells = iVanCols * iVanRows
        self.Rows = iVanRows
        self.Cols = iVanCols

#       BugUtil.debug("BupPanel %i %i %i", yRes, iVanCols, iVanRows)

        self.screen = screen

        # we scrapped the panel concept
        # initially, the thought was to put everything on a single panel and then just show / hide
        # the panel for quick showing and hiding
        # however, some of the graphics aren't attached to anything so we just went with throwing them
        # straight onto the main interface screen

        # however, the panel location values are still used to help locate the cells
        # SO DON'T DELETE THEM!
        self.xPanel = 315 - cBupCellSpacing
        self.yPanel = yRes - 169 + (1 - iVanRows) * cBupCellSize - cBupCellSpacing
        self.wPanel = iVanCols * cBupCellSize + cBupCellSpacing
        self.hPanel = iVanRows * cBupCellSize + cBupCellSpacing

#       BugUtil.debug("BupPanel %i %i %i %i", self.xPanel, self.yPanel, self.wPanel, self.hPanel)

        sTexture = getArt("INTERFACE_BUTTONS_GOVERNOR")
        sHiLiteTexture = getArt("BUTTON_HILITE_SQUARE")
        sPromoFrame = getArt("OVERLAY_PROMOTION_FRAME")

        self.BupCell_Displayed = []

        for iIndex in range(self.MaxCells):
            szBupCell = self._getCellWidget(iIndex)
            iX = self._getX(self._getCol(iIndex))
            iY = self._getY(self._getRow(iIndex))

#           BugUtil.debug("BupPanel MaxCells %i %i %i %i %i", iIndex, self._getCol(iIndex), self._getRow(iIndex), self._getX(self._getCol(iIndex)), self._getY(self._getRow(iIndex)))

            # place/init the promotion frame.
            # Important to have it at first place within the for loop
            # so that it sits behind the unit icon button
            szStringPromoFrame = szBupCell + "PromoFrame"
            screen.addDDSGFC(szStringPromoFrame, sPromoFrame, iX, iY, 32, 32, WidgetTypes.WIDGET_GENERAL, iIndex, -1 )
            screen.hide(szStringPromoFrame)


            # unit icon
            screen.addCheckBoxGFC(szBupCell, sTexture, sHiLiteTexture, iX, iY, 32, 32, WidgetTypes.WIDGET_PLOT_LIST, iIndex, -1, ButtonStyles.BUTTON_STYLE_LABEL)
            screen.hide(szBupCell)

            # health bar
            szStringHealth = szBupCell + "Health"
            screen.addStackedBarGFC(szStringHealth, iX, iY + 23, 32, 11, InfoBarTypes.NUM_INFOBAR_TYPES, WidgetTypes.WIDGET_GENERAL, iIndex, -1 )
            screen.hide(szStringHealth)

            self.BupCell_Displayed.append(False)


#VOID addDDSGFC(STRING szName, STRING szTexture, INT iX, INT iY, INT iWidth, INT iHeight, WidgetType eWidgetType, INT iData1, INT iData2)
#VOID addDDSGFCAt(STRING szName, STRING szAttachTo, STRING szTexture, INT iX, INT iY, INT iWidth, INT iHeight, WidgetType eWidgetType, INT iData1, INT iData2, BOOL bOption)
#VOID addCheckBoxGFC(STRING szName, STRING szTexture, STRING szHiliteTexture, INT iX, INT iY, INT iWidth, INT iHeight, WidgetType eWidgetType, INT iData1, INT iData2, ButtonStyle eStyle)
#VOID addCheckBoxGFCAt(STRING szName, STRING szTexture, STRING szHiliteTexture, INT iX, INT iY, INT iWidth, INT iHeight, WidgetType eWidgetType, INT iData1, INT iData2, ButtonStyle eStyle)
#VOID attachCheckBoxGFC(STRING szAttachTo, STRING szName, STRING szTexture, STRING szHiliteTexture, INT iWidth, INT iHeight, WidgetType eWidgetType, INT iData1, INT iData2, ButtonStyle eStyle)
#VOID addStackedBarGFC(STRING szName, INT iX, INT iY, INT iWidth, INT iHeight, INT iNumBars, WidgetType eWidgetType, INT iData1, INT iData2)



        # the little white arrows?
        screen.setButtonGFC(sBupStringBase + "Minus", u"", "", 315 + (xRes - (iMulti) - 68), yRes - 171, 32, 32, WidgetTypes.WIDGET_PLOT_LIST_SHIFT, -1, -1, ButtonStyles.BUTTON_STYLE_ARROW_LEFT)
        screen.setButtonGFC(sBupStringBase + "Plus", u"", "",  298 + (xRes - (iMulti) - 34), yRes - 171, 32, 32, WidgetTypes.WIDGET_PLOT_LIST_SHIFT, 1, -1, ButtonStyles.BUTTON_STYLE_ARROW_RIGHT)
        screen.hide(sBupStringBase + "Minus")
        screen.hide(sBupStringBase + "Plus")

        self.BupUnits = []
        self.BupUnits_Prior = []

        self.PlotListOffset = 0
        self.PlotListOffset_Prior = 0
        self.PlotListColumn_Prior = 0

        self.PlotX_Prior = 0
        self.PlotY_Prior = 0
        self.PlotX = 0
        self.PlotY = 0

        self.CityUp_Prior = False

    def Draw(self):

        BugUtil.debug("BupPanel Draw")

        # set L+R arrows to 'off'
        bLeftArrow = False
        bRightArrow = False
        self.screen.hide(sBupStringBase + "Minus")
        self.screen.hide(sBupStringBase + "Plus")

        # kill off the prior units and delete all of the unit plot list if the plot has changed
        if (self._hasPlotChanged()
        or CyInterface().isCityScreenUp() != self.CityUp_Prior):
#           BugUtil.debug("BupPanel plot has changed or CityScreenUp status has changed - %s %s", CyInterface().isCityScreenUp(), self.CityUp_Prior)
            self.BupUnits_Prior = []
            self.PlotListOffset_Prior = 0
            self.PlotListColumn_Prior = 0
            self.Hide()

        # store the unit plot offset
        self.PlotListOffset = CyInterface().getPlotListOffset()

# todo: still need to put in something to handle the column value (ie when you have more units that can fit on the screen)

        iVisibleUnits = CyInterface().getNumVisibleUnits()
        iIndex = -(CyInterface().getPlotListColumn())

        if (CyInterface().isCityScreenUp()):
            iMaxRows = 1
            iSkippedCells = (self._getMaxRows() - 1) * self._getMaxCols()
            iIndex += iSkippedCells
            iFirstPlot = iSkippedCells
            iLastPlot = iFirstPlot + self._getMaxCols() - 1
        else:
            iMaxRows = self._getMaxRows()
            iSkippedCells = 0
            iIndex += self.PlotListOffset
            iFirstPlot = 0
            iLastPlot = self._getMaxRows() * self._getMaxCols() - 1

        iMaxUnits = max(len(self.BupUnits), \
                        len(self.BupUnits_Prior))

#       iMaxUnits = min(iMaxUnits, \
#                       iMaxRows * self._getMaxCols())

        BugUtil.debug("BupPanel rows(%i), cols(%i), cells(%i)", self._getMaxRows(), self._getMaxCols(), iMaxRows * self._getMaxCols())
        BugUtil.debug("BupPanel units_c(%i) units_p(%i), units max(%i)", len(self.BupUnits), len(self.BupUnits_Prior), iMaxUnits)
        BugUtil.debug("BupPanel max rows(%i), skipped(%i), index(%i)", iMaxRows, iSkippedCells, iIndex)
        BugUtil.debug("BupPanel plotlistoffset, current(%i), prior(%i)", self.PlotListOffset, self.PlotListOffset_Prior)
        BugUtil.debug("BupPanel plotlistcolumn, current(%i), prior(%i)", CyInterface().getPlotListColumn(), self.PlotListColumn_Prior)
        BugUtil.debug("BupPanel first(%i), last(%i)", iFirstPlot, iLastPlot)




# put in an override if the number of units exceeds the screen maximum
# or if the city screen is up (max = units per row)
# also need some code to control those pesky little arrows

        for iUnit in range(iMaxUnits):
            iUnit_Prior = iUnit - (CyInterface().getPlotListColumn() - self.PlotListColumn_Prior)
            BugUtil.debug("BupPanel index(%i), iUnit(%i), iUnit_Prior(%i)", iIndex, iUnit, iUnit_Prior)

            # check if the unit we have is within the display bounds
            if (iIndex < iFirstPlot
            or iIndex > iLastPlot):
                iIndex += 1
                continue

            szBupCell = self._getCellWidget(iIndex)

            if iUnit < len(self.BupUnits):
                BupUnit = self.BupUnits[iUnit]
            else:
                # current unit is blank!
                self._hideCell(iIndex, szBupCell)
                iIndex += 1
                continue

            # do we have to turn the arrows on?
            if iIndex == iFirstPlot: # looking at the top left cell
                if CyInterface().getPlotListColumn() > 0: # still have units to show
                    bLeftArrow = True
            elif iIndex == iLastPlot: # the bottom right cell
                if (iVisibleUnits - iIndex - CyInterface().getPlotListColumn() + iSkippedCells) > 1: # more units to show to right
                    bRightArrow = True

            # prior unit doesn't exist - just need to draw the new unit
            # this is handled below in the '_update*' functions
            if (len(self.BupUnits_Prior) != 0
            and iUnit_Prior >= 0
            and iUnit_Prior < len(self.BupUnits_Prior)):
#           or  iUnit_Prior < len(self.BupUnits_Prior))):
                BupUnit_Prior = self.BupUnits_Prior[iUnit_Prior]
            else:
                BupUnit_Prior = None

            self._updateUnitIcon(BupUnit, BupUnit_Prior, iIndex, szBupCell)

            iX = self._getX(self._getCol(iIndex))
            iY = self._getY(self._getRow(iIndex))

            BugUtil.debug("BupPanel unit(%i), index(%i), col(%i), row(%i), x(%i), y(%i)", iUnit, iIndex, self._getCol(iIndex), self._getRow(iIndex), iX, iY)

            if BupUnit.Owner == gc.getGame().getActivePlayer():
                self._updatePromo(BupUnit, BupUnit_Prior, szBupCell)
                self._updateUpgrade(BupUnit, BupUnit_Prior, szBupCell, iIndex, iX, iY)
                self._updateMission(BupUnit, BupUnit_Prior, szBupCell, iIndex, iX, iY)

            # the health bar and dot are shown for all units
            # not just the current player's units
            self._updateDot(BupUnit, BupUnit_Prior, szBupCell, iIndex, iX, iY + 4)
            self._updateHealthBar(BupUnit, BupUnit_Prior, szBupCell)

            iIndex += 1


        # phew, finally finished all the units
        # do we have to show the arrows?
        # only if there are more visible units than there are cells
        if iVisibleUnits > iMaxRows * self._getMaxCols():
            self.screen.enable(sBupStringBase + "Minus", bLeftArrow)
            self.screen.enable(sBupStringBase + "Plus", bRightArrow)
            self.screen.show(sBupStringBase + "Minus")
            self.screen.show(sBupStringBase + "Plus")

        # save the current units for next time
#       self.BupUnits_Prior = self.BupUnits
        self.BupUnits_Prior = []
        for iUnit in range(len(self.BupUnits)):
            self.BupUnits_Prior.append(self.BupUnits[iUnit])

        # empty the current units
        # maininterface will reload them prior to calling .Draw()
        self.BupUnits = []

        # save prior stuff
        self.CityUp_Prior = CyInterface().isCityScreenUp()
        self.PlotListOffset_Prior = CyInterface().getPlotListOffset()
        self.PlotListColumn_Prior = CyInterface().getPlotListColumn()


############## plot ##############

    def addPlot(self, X, Y):
#       BugUtil.debug("BupPanel addPlot 1) %i %i %i %i", self.PlotX, self.PlotY, self.PlotX_Prior, self.PlotY_Prior)
        self.PlotX_Prior = self.PlotX
        self.PlotY_Prior = self.PlotY
        self.PlotX = X
        self.PlotY = Y
#       BugUtil.debug("BupPanel addPlot 2) %i %i %i %i", self.PlotX, self.PlotY, self.PlotX_Prior, self.PlotY_Prior)

    def _hasPlotChanged(self):
#       BugUtil.debug("BupPanel _hasPlotChanged %i %i %i %i %s", self.PlotX, self.PlotY, self.PlotX_Prior, self.PlotY_Prior, not (self.PlotX == self.PlotX_Prior and self.PlotY == self.PlotY_Prior))
        return not (self.PlotX == self.PlotX_Prior and self.PlotY == self.PlotY_Prior)


############## hide ##############

    def Hide(self):
#       BugUtil.debug("BupPanel Hide!")
        iIndex = 0
        while iIndex < self.MaxCells:
            self._hideCell(iIndex, self._getCellWidget(iIndex))
            iIndex += 1

    def _hideCell(self, iIndex, szCell):
        if self.BupCell_Displayed[iIndex]:
#           BugUtil.debug("BupPanel hiding %i", iIndex)

            self.screen.hide(szCell)
            self.screen.hide(szCell + "Dot")
            self.screen.hide(szCell + "PromoFrame")
            self.screen.hide(szCell + "Upgrade")
            self.screen.hide(szCell + "Mission")
            self.screen.hide(szCell + "Health")

            self.BupCell_Displayed[iIndex] = False


############## add and clear units ##############

    def addUnit(self, pUnit):
        self.BupUnits.append(BupUnit(pUnit))

    def clearUnits(self):
        self.BupUnits = []
        self.BupUnits_Prior = []



############## unit icon ##############

    def _updateUnitIcon(self, BupUnit, BupUnit_Prior, iIndex, szCell):
        # note that 'State' is always updated as the unit icon is a check box
        # and clicking on a check box changes the display state, even if the unit state is unchanged
        # ie ctrl-click on a selected unit should highlight all of that type of unit
        # but if we don't update the state, then the highlighted unit would show as unselected (turned off by the click)
        if BupUnit_Prior is None:
            self._drawUnitIcon(BupUnit, iIndex, szCell)
            self.screen.setState(szCell, BupUnit.isSelected)
            return

#       BugUtil.debug("BupPanel _updateUnitIcon %s %s", BupUnit.isSelected, BupUnit_Prior.isSelected)

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if (BupUnit.UnitType    != BupUnit_Prior.UnitType
        or BupUnit.Owner        != BupUnit_Prior.Owner):
            self._drawUnitIcon(BupUnit, iIndex, szCell)

        if self.BupCell_Displayed[iIndex]:
            self.screen.setState(szCell, BupUnit.isSelected)

    def _drawUnitIcon(self, BupUnit, iIndex, szCell):
        self.screen.changeImageButton(szCell, gc.getUnitInfo(BupUnit.UnitType).getButton())
        self.screen.enable(szCell, BupUnit.Owner == gc.getGame().getActivePlayer())
        self.screen.show(szCell)
#       self.screen.setState(szCell, BupUnit.isSelected)

        self.BupCell_Displayed[iIndex] = True


############## dot (or star for GG) ##############

    def _updateDot(self, BupUnit, BupUnit_Prior, szCell, iCount, x, y):
        if BupUnit_Prior is None:
            self._drawDot(BupUnit, szCell, iCount, x, y)
            return

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if BupUnit.DotStatus != BupUnit_Prior.DotStatus:
            self._drawDot(BupUnit, szCell, iCount, x, y)

    def _drawDot(self, BupUnit, szCell, iCount, x, y):
        # handles the display of the colored buttons in the upper left corner of each unit icon.
        # Units lead by a GG will get a star instead of a dot - and the location and size of star differs
        if (PleOpt.isShowGreatGeneralIndicator()
        and BupUnit.isLeadByGreatGeneral):
            xSize = 16
            ySize = 16
            xOffset = -3
            yOffset = -3
        else:
            xSize = 12
            ySize = 12
            xOffset = 0
            yOffset = 0

        # display the colored spot icon
        self.screen.addDDSGFC(szCell + "Dot", getArt(BupUnit.DotStatus), x-3+xOffset, y-7+yOffset, xSize, ySize, WidgetTypes.WIDGET_GENERAL, iCount, -1 )


############## promotion available ##############

    def _updatePromo(self, BupUnit, BupUnit_Prior, szCell):
        if BupUnit_Prior is None:
            self._drawPromo(BupUnit, szCell)
            return

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if BupUnit.isPromotionReady != BupUnit_Prior.isPromotionReady:
            self._drawPromo(BupUnit, szCell)

    def _drawPromo(self, BupUnit, szCell):
        if PleOpt.isShowPromotionIndicator():
            if BupUnit.isPromotionReady:
                self.screen.show(szCell + "PromoFrame")
            else:
                self.screen.hide(szCell + "PromoFrame")


############## upgrade ##############

    def _updateUpgrade(self, BupUnit, BupUnit_Prior, szCell, iCount, x, y):
        if BupUnit_Prior is None:
            self._drawUpgrade(BupUnit, szCell, iCount, x, y)
            return

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if BupUnit.isCanUpgrade != BupUnit_Prior.isCanUpgrade:
            self._drawUpgrade(BupUnit, szCell, iCount, x, y)

    def _drawUpgrade(self, BupUnit, szCell, iCount, x, y):
        if (BupUnit.isCanUpgrade):
            # place the upgrade arrow
            self.screen.addDDSGFC(szCell + "Upgrade", getArt("OVERLAY_UPGRADE"), x+2, y+14, 8, 16, WidgetTypes.WIDGET_GENERAL, iCount, -1 )
        else:
            self.screen.hide(szCell + "Upgrade")


############## mission ##############

    def _updateMission(self, BupUnit, BupUnit_Prior, szCell, iCount, x, y):
        if BupUnit_Prior is None:
            self._drawMission(BupUnit, szCell, iCount, x, y)
            return

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if BupUnit.Mission != BupUnit_Prior.Mission:
            self._drawMission(BupUnit, szCell, iCount, x, y)

    def _drawMission(self, BupUnit, szCell, iCount, x, y):
        if PleOpt.isShowMissionInfo():
            if BupUnit.Mission != "":
                self.screen.addDDSGFC(szCell + "Mission", getArt(BupUnit.Mission), x+20, y+20, 12, 12, WidgetTypes.WIDGET_GENERAL, iCount, -1)
            else:
                self.screen.hide(szCell + "Mission")


############## health bar ##############

    def _updateHealthBar(self, BupUnit, BupUnit_Prior, szCell):
        if BupUnit_Prior is None:
            self._drawHealthBar(BupUnit, szCell)
            return

        # if we get to here, then we have a unit in BupUnit and BupUnit_Prior
        if (BupUnit.currHitPoints != BupUnit_Prior.currHitPoints
        or not BupUnit_Prior.isShowHealth):
            self._drawHealthBar(BupUnit, szCell)

    def _drawHealthBar(self, BupUnit, szCell):
        if (PleOpt.isShowHealthBar()
        and BupUnit.isShowHealth):
            if BupUnit.currHitPoints < (BupUnit.maxHitPoints * 2) / 3:
                sColor = "COLOR_RED"
            elif BupUnit.currHitPoints < BupUnit.maxHitPoints / 3:
                sColor = "COLOR_YELLOW"
            elif BupUnit.currHitPoints < BupUnit.maxHitPoints:
                sColor = "COLOR_PLAYER_LIGHT_GREEN"
            else:
                sColor = "COLOR_GREEN"

            szStringHealth = szCell + "Health"
            self.screen.setBarPercentage(szStringHealth, InfoBarTypes.INFOBAR_STORED, float(BupUnit.currHitPoints) / float(BupUnit.maxHitPoints))
            self.screen.setStackedBarColors(szStringHealth, InfoBarTypes.INFOBAR_STORED, gc.getInfoTypeForString(sColor))
            self.screen.show(szStringHealth)







    def _getMaxCols(self):
        return self.Cols

    def _getMaxRows(self):
        return self.Rows

    def _getMaxCells(self):
        return self.Rows

    def _getRow(self, i):
#       return self._getMaxRows() - i / self._getMaxCols() - 1
        return i / self._getMaxCols()

    def _getCol(self, i):
        return i % self._getMaxCols()

    def _getX(self, nCol): # measures from the top left of screen!
        return nCol * cBupCellSize + self.xPanel

    def _getY(self, nRow): # measures from the top left of screen!
        return nRow * cBupCellSize + self.yPanel

    def _getCellWidget(self, index):
        return sBupStringBase + "Cell" + str(index)

#   def _getIndex(self, nRow, nCol):
#       return ( nRow * self.getMaxCol() ) + ( nCol % self.getMaxCol() )

############## functions for visual objects (show and hide) ######################
        
    # PLE Grouping Mode Switcher 




class BupUnit:
    def __init__(self, pUnit):
        self.pUnit = pUnit

        # unit type
        self.UnitType = pUnit.getUnitType()
        self.Owner = pUnit.getOwner()
        self.isSelected = pUnit.IsSelected()
        self.isFortified = pUnit.getTeam() != gc.getGame().getActiveTeam() or pUnit.isWaiting()
        self.isMoved = pUnit.canMove() and pUnit.hasMoved()
        self.isMove = pUnit.canMove() and not pUnit.hasMoved()
        self.isNotMove = not pUnit.canMove()
        self.isHurt = pUnit.isHurt()
        self.isPromotionReady = pUnit.isPromotionReady()

        iLeaderPromo = gc.getInfoTypeForString('PROMOTION_LEADER')
        self.isLeadByGreatGeneral = iLeaderPromo != -1 and pUnit.isHasPromotion(iLeaderPromo)

        self.DotStatus = self._getDotStatus()
        self.Mission = self._getMission(pUnit)

        if PleOpt.isShowUpgradeIndicator():
            self.isCanUpgrade = mt.checkAnyUpgrade(pUnit)
        else:
            self.isCanUpgrade = False

        # health
        self.currHitPoints = pUnit.currHitPoints()
        self.maxHitPoints = pUnit.maxHitPoints()
        if (pUnit.isFighting()):
            self.isShowHealth = False
        elif (pUnit.getDomainType() == DomainTypes.DOMAIN_AIR):
            self.isShowHealth = pUnit.canAirAttack()
        else:
            self.isShowHealth = pUnit.canFight()



#       self.isCanUpgrade = PleOpt.isShowUpgradeIndicator() or mt.checkAnyUpgrade(pUnit)

    def _getDotStatus(self):
        sDotStatus = ""
        if self.isFortified:  # fortified
            sDotStatus = "OVERLAY_FORTIFY"
        elif self.isMoved:  # unit moved, but some movement points are left
            sDotStatus = "OVERLAY_HASMOVED"
        elif self.isMove:  # unit did not move yet
            sDotStatus = "OVERLAY_MOVE"
        else: # unit has no movement points left
            sDotStatus = "OVERLAY_NOMOVE"

        # Wounded units will get a darker colored button.
        if (PleOpt.isShowWoundedIndicator()
        and self.isHurt):
            sDotStatus += "_INJURED"

        # Units lead by a GG will get a star instead of a dot.
        if (PleOpt.isShowGreatGeneralIndicator()
        and self.isLeadByGreatGeneral):
            sDotStatus += "_GG"

        return sDotStatus

    def _getMission(self, pUnit):
        eActivityType = pUnit.getGroup().getActivityType()
        eAutomationType = pUnit.getGroup().getAutomateType()

        # is unit on air intercept mission
        if (eActivityType == ActivityTypes.ACTIVITY_INTERCEPT):
            return "OVERLAY_ACTION_INTERCEPT"
        # is unit on boat patrol coast mission
        elif (eActivityType == ActivityTypes.ACTIVITY_PATROL):
            return "OVERLAY_ACTION_PATROL"
        # is unit on boat blockade mission
        elif (eActivityType == ActivityTypes.ACTIVITY_PLUNDER):
            return "OVERLAY_ACTION_PLUNDER"
        # is unit fortified for healing (wake up when healed)
        elif (eActivityType == ActivityTypes.ACTIVITY_HEAL):
            return "OVERLAY_ACTION_HEAL"
        # is unit sentry (wake up when enemy in sight)
        elif (eActivityType == ActivityTypes.ACTIVITY_SENTRY):
            return "OVERLAY_ACTION_SENTRY"
        # is the turn for this unit skipped (wake up next turn)
        elif (eActivityType == ActivityTypes.ACTIVITY_HOLD):
            return "OVERLAY_ACTION_SKIP"
        # has unit exploration mission
        elif (eAutomationType == AutomateTypes.AUTOMATE_EXPLORE):
            return "OVERLAY_ACTION_EXPLORE"
        # is unit automated generally (only worker units)
        elif (eAutomationType == AutomateTypes.AUTOMATE_BUILD):
            return "OVERLAY_ACTION_AUTO_BUILD"
        # is unit automated for nearest city (only worker units)
        elif (eAutomationType == AutomateTypes.AUTOMATE_CITY):
            return "OVERLAY_ACTION_AUTO_CITY"
        # is unit automated for network (only worker units)
        elif (eAutomationType == AutomateTypes.AUTOMATE_NETWORK):
            return "OVERLAY_ACTION_AUTO_NETWORK"
        # is unit automated spread religion (only missionary units)
        elif (eAutomationType == AutomateTypes.AUTOMATE_RELIGION):
            return "OVERLAY_ACTION_AUTO_RELIGION"
        # has unit a mission
        elif (pUnit.getGroup().getLengthMissionQueue() > 0):
            eMissionType = pUnit.getGroup().getMissionType(0)
            # is the mission to build an improvement
            if (eMissionType == MissionTypes.MISSION_BUILD):
                return "OVERLAY_ACTION_BUILD"
            # is the mission a "move to" mission
            elif (eMissionType in UnitUtil.MOVE_TO_MISSIONS):
                return "OVERLAY_ACTION_GOTO"
        # if nothing of above, but unit is waiting -> unit is fortified
        elif (pUnit.isWaiting()):
            if (pUnit.isFortifyable()):
                return "OVERLAY_ACTION_FORTIFY"
            else:
                return "OVERLAY_ACTION_SLEEP"

        return ""



#       self.bSelected = pUnit.IsSelected()
#       self.eUnit = pUnit.getUnitType()
#       self.sDotState, self.iDotxSize, self.iDotySize, self.iDotxOffset, self.iDotyOffset = _getDOTInfo(pUnit)
#       self.sMission = _getMission(pUnit)
#       self.bPromo = pUnit.isPromotionReady()
#       self.bGG = iLeaderPromo != -1 and pUnit.isHasPromotion(iLeaderPromo)
#       self.bUpgrade = mt.checkAnyUpgrade(pUnit)
#       self.icurrHitPoints = pUnit.currHitPoints()
#       self.imaxHitPoints = pUnit.maxHitPoints()
#       self.iMovesLeft = pUnit.movesLeft()
#       self.iMoves = pUnit.getMoves()








def getArt(sArt):
    return ArtFileMgr.getInterfaceArtInfo(sArt).getPath()




