Crea Anomaly - base.py

import math

from core.helper import enum, select

from siege import Tuning, game
from siege.io import DataStream
from siege.log import Log
from siege.network import Message
from siege.util import Random, RegionVector, Sizes, TileRect, TileVector, Timer
from siege.world import World

AnomalyState = enum("Unstarted", "Starting", "Middle", "Ending", "Finished")


class BaseAnomaly(object):
    TUNING = Tuning.anomaly.BASE
    VERSION = 2

    def __init__(self):
        self.name = "base"
        self.timeRange = self.TUNING.TIME_RANGE
        self.chance = self.TUNING.CHANCE
        self.duration = self.TUNING.DURATION
        self.active = False
        self.mapPosition = None
        self.markerPath = "mods/core/cartography/anomaly.png"

        self.markerUid = None
        self.warnNoMarkerUpdateFlag = True

        self.timer = Timer()
        self.setTimer()

    @property
    def markerName(self):
        return "{}AnomalyMarker".format(self.name.capitalize())

    def shouldOccur(self, frametime):
        if not self.active:
            self.timer.update(frametime)
            if self.timer.expired():
                self.setTimer()
                if Random.getFloat() < self.chance:
                    return True
                else:
                    return False

    def update(self, frametime):
        self.durationTimer.update(frametime)
        if self.durationTimer.expired():
            self.__init__()

    def clientUpdate(self, frametime):
        pass

    def addMarker(self, realm, name):
        if self.mapPosition is not None:
            self.markerUid = realm.addMapMarker("Anomaly", name, self.markerPath, self.mapPosition)
            Log.debug("New uid: {}".format(self.markerUid))
        else:
            Log.error("Tried to add Anomaly Marker '{}' without a map position.".format(name))

    def updateMarker(self, realm):
        if self.markerUid is not None:
            if self.mapPosition is not None:
                realm.updateMapMarker(self.markerUid, position=self.mapPosition)
            else:
                self.removeMarker(realm)
        elif self.warnNoMarkerUpdateFlag:
            # Only do this once so we don't spam the logs
            self.warnNoMarkerUpdateFlag = False
            Log.warn("markerUid of Anomaly {} was None.".format(self.name))

    def removeMarker(self, realm):
        if self.markerUid is not None:
            realm.removeMapMarker(self.markerUid)
            self.markerUid = None
        else:
            Log.warn("markerUid of Anomaly {} was None.".format(self.name))

    def purgeMarkers(self, realm, name):
        Log.debug("purging markers of name: {}".format(name))
        if realm is None:
            realm = World.get().realm
        realm.purgeMapMarkers(name)

    def notifyBegin(self, anomalyName, extraInfo=""):
        game.notification.announceAnomaly(anomalyName, True, self.mapPosition, extraInfo)

    def notifyEnd(self, anomalyName, extraInfo=""):
        game.notification.announceAnomaly(anomalyName, False, self.mapPosition, extraInfo)

    def occur(self):
        self.durationTimer = Timer(self.duration.getRandom())
        self.active = True
        self.mapPosition = None

    def clientOccur(self):
        pass

    def setTimer(self):
        self.timer.reset(self.timeRange.getRandom())

    def getRandomConflictRegion(self, forceOnSurface=True, minLevel=None):
        realm = World.get().realm
        regionUids = range(realm.size.regionCount)
        if minLevel is not None:
            for regionID in regionUids:
                if realm.conflict.getRegion(regionID).levels.max < minLevel:
                    regionUids.remove(regionID)
            if regionUids == []:
                return None
        regionUid = select(regionUids)
        position = realm.size.getRegionTilePosition(regionUid)
        if forceOnSurface:
            while position.y < realm.biomeTracker.undergroundThreshold[int(position.x)] or position.y > math.fabs(realm.biomeTracker.undergroundThreshold[int(position.x)] + int(RegionVector(0, realm.size.regionHeight).asTile().y / 15)):  # This could be a little longer if I tried, don't ya think?
                regionUid = select(regionUids)
                position = realm.size.getRegionTilePosition(regionUid)
        return realm.conflict.getRegion(regionUid)

    def getRandomRegionArea(self, forceOnSurface=True, minLevel=None):
        realm = World.get().realm
        regionUids = range(realm.size.regionCount)
        if minLevel is not None:
            for regionID in regionUids:
                if realm.conflict.getRegion(regionID).levels.max < minLevel:
                    regionUids.remove(regionID)
            if regionUids == []:
                return None
        regionUid = select(regionUids)
        position = realm.size.getRegionTilePosition(regionUid)
        area = TileRect(position, TileVector(Sizes.REGION_TILE, Sizes.REGION_TILE))
        if forceOnSurface:
            while position.y < realm.biomeTracker.undergroundThreshold[int(position.x)] or position.y > math.fabs(realm.biomeTracker.undergroundThreshold[int(position.x)] + int(RegionVector(0, realm.size.regionHeight).asTile().y / 15)):  # This could be a little longer if I tried, don't ya think?
                regionUid = select(regionUids)
                position = realm.size.getRegionTilePosition(regionUid)
                area = TileRect(position, TileVector(Sizes.REGION_TILE, Sizes.REGION_TILE))
        return area

    def netSync(self):
        packet = DataStream(Message.ANOMALY)
        # Write Anomaly Key
        packet.writeString(self.name)
        # Write active
        packet.writeBool(self.active)
        for networkId in [player.networkId for player in World.get().getPlayers()]:
            game.network.getServer().send(networkId, packet)

    def recieveSync(self, client, packet):
        # Anomaly key is already read
        # Read active
        active = packet.readBool()
        if active != self.active:
            if active:
                self.clientOccur()
            self.active = active

    def save(self, stream):
        # Timer
        stream.writeUint32(self.timer.remaining())
        # Map Marker
        stream.writeUint16(self.markerUid)

    def load(self, stream, version):
        # Timer
        self.timer.reset(stream.readUint32())
        # Map Marker
        self.markerUid = stream.readUint16()

    def loadFailed(self):
        self.__init__()