def process(entry, result, mode="Num"):
Event.process(entry, result)
margin = Auction.process(entry, result)
Auction_Site.process(entry, result)
Auction_BidRequests.process(margin, entry, result, mode)
# Response
result.append(entry["response"])
def start(self):
"""
Start the game engine.
"""
lasttime = time()
curtime = 0
frames = 0
# Start the main event loop
while 1:
# Process the internal event queue
Event.handle_events()
# Process the SDL event queue
for event in SDL.event.get():
if event.type == SDL.QUIT:
self.shutdown()
elif event.type == SDL.VIDEORESIZE:
self.resize(event.w, event.h)
elif event.type == SDL.KEYDOWN:
StateManager.current.key_pressed(event.key)
self.queue_flip()
elif event.type == SDL.KEYUP:
StateManager.current.key_released(event.key)
# Update and draw the current state
StateManager.update()
self.draw()
frames += 1
curtime = time()
if curtime - lasttime >= 1:
Log.info("FPS: " + str(frames / (curtime - lasttime)))
frames = 0
lasttime = curtime
def received_message(self, m):
# self.clients is set from within the server
# and holds the list of all connected servers
# we can dispatch to
import json
msg = json.loads(str(m))
Event.broadcast(msg['event'], msg['msg'])
pass
def createSocket(addr, port):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((addr, port))
rudpSocket = RudpSocket(sock)
rudpSocket.addr_src = sock.getsockname()
rudpSockets.append(rudpSocket)
Event.eventFd(sock.fileno(), handleDataAvailable, rudpSocket, "DataReceived")
return rudpSocket
def __handleTimeoutSYN(self, packetSequenceNumber):
logger.log(Level.DEBUG, "Handling SYN timeout of:" + str(packetSequenceNumber))
Event.eventTimeoutDelete(self.__handleTimeoutSYN, packetSequenceNumber)
if self.__incrementRetries():
packet = self.rudpSocket.generateSynPacket()
self.nextAckSeqNumber = packet.seqnum + 1
logger.log(Level.INFO, "Retransmitting SYN")
self.rudpSocket.sendPacketControl(self.addr, packet)
Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutSYN, packet.seqnum, "SYN timeout")
def __handleTimeoutFIN(self, packetSequenceNumber):
logger.log(Level.DEBUG, "Handling FIN timeout of:" + str(packetSequenceNumber))
if self.__incrementRetries():
Event.eventTimeoutDelete(self.__handleTimeoutFIN, packetSequenceNumber)
packet = RudpPacket()
packet.type = RudpPacket.TYPE_FIN
packet.seqnum = packetSequenceNumber
self.rudpSocket.sendPacketControl(self.addr, packet)
Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutFIN, packet.seqnum, "DATA Timeout")
def __emptyBuffer(self):
logger.log(Level.TRACE, "Sending packets, window:" + str(self.window) + " index:" + str(self.nextSendingPacketSeqNumber))
if len(self.dataBuffer) > self.nextSendingPacketSeqNumber:
while self.window > 0 and len(self.dataBuffer) > 0 and len(self.dataBuffer) > self.nextSendingPacketSeqNumber:
packet = self.dataBuffer[self.nextSendingPacketSeqNumber]
self.rudpSocket.sendPacketData(self.addr, packet)
self.nextSendingPacketSeqNumber = self.nextSendingPacketSeqNumber + 1
self.window = self.window - 1
Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutData, packet.seqnum, "DATA Timeout")
def fill_insert(classe, i): classe.name = "C"+str(i) classe.planning = Planning() # XXX fill planning with normal events ? #classe.planning.cb_fill(number) # XXX fill planning with course events cursus = db.session.query(Cursus).get(i+1) if cursus: periods = cursus.periods import Event Event.fill_date = cursus.start else: periods = [] for period in periods: for course in period.courses: from Event import Event # XXX move fill event in class event = Event() event.planning = classe.planning event.course = course course.c_elearning_rest = course.c_elearning course.c_classroom_rest = course.c_classroom course.c_practice_rest = course.c_practice course.e_oral_rest = course.e_oral course.e_practice_rest = course.e_practice hours = course.c_elearning hours += course.c_classroom hours += course.c_practice hours += course.e_oral hours += course.e_practice event.cb_fill(hours / 2) if len(period.classes) == 0: for course in period.courses: event = Event() event.planning = period.planning event.course = course event.cb_fill(event.course.e_exam / 2 + 1) import Event Event.fill_date = period.end classe.periods = periods user = User() user.manager_class = [classe] user.cb_fill(randint(1, number), classe.campus.name + '_' + classe.name + '_manager_user' + str(i)) user = User() user.student_class = classe user.cb_fill(randint(10, 30), classe.campus.name+'_'+classe.name+'_student_user'+str(i)) db.session.add(classe)
def __handleTimeoutData(self, rudpSecNum):
logger.log(Level.DEBUG, "Handling packet timeout DATA packet seq:" + str(rudpSecNum))
''' Here we need to remove all other DATA packet timeouts'''
for seq in range(rudpSecNum, self.nextSendingPacketSeqNumber):
Event.eventTimeoutDelete(self.__handleTimeoutData, seq)
if self.__incrementRetries():
''' Decrease window size, reset packet index to the one we lost'''
self.window = 1 if self.window - 1 < 1 else self.window - 1
self.nextSendingPacketSeqNumber = rudpSecNum
self.__emptyBuffer()
self.retries = self.retries + 1
def createEvents(self): nextDate = next_weekday(datetime.datetime.now().date(),self.day) created = [] skipped = [] while(nextDate < self.endDate): if not Event.getByDate(nextDate): Event.create(self.name,self.place,datetime.datetime.combine(nextDate, self.time),self.key) created.append(nextDate) else: skipped.append(nextDate) nextDate += datetime.timedelta(days=7) return [created,skipped]
def __checkClose(self):
''' Send FIN if all packet have been sent - last packet in a buffer was sent and all have been ACK'ed'''
if self.closePending is True:
logger.log(Level.DEBUG, str(self.nextBufferPacketSeqNumber) + ">" + str(self.nextSendingPacketSeqNumber) + " >" + str(self.nextAckSeqNumber))
if self.nextBufferPacketSeqNumber == self.nextSendingPacketSeqNumber == (self.nextAckSeqNumber - 1):
logger.log(Level.DEBUG, "Closing peer socket:" + str(self))
packet = RudpPacket()
packet.type = RudpPacket.TYPE_FIN
packet.seqnum = self.dataBuffer[self.nextSendingPacketSeqNumber - 1].seqnum + 1
self.rudpSocket.sendPacketControl(self.addr, packet)
Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutFIN, packet.seqnum, "DATA Timeout")
self.state = RudpSocket.STATE_CLOSED
else:
logger.log(Level.DEBUG, "Could not close peer socket yet !!!!")
def old_main():
for line in sys.stdin:
event = Event.decode_event(line)
# Common handling
Global.UpdateThreadState(event)
# Event-specific handling
event_handler_map[event.event](event)
def main():
print("Handler Chain #1")
pipeline = key_handler(mouse_handler(timer_handler()))
while True:
event = Event.next()
if event.kind == Event.TERMINATE:
break
pipeline.send(event)
print("\nHandler Chain #2 (debugging)")
pipeline = debug_handler(pipeline)
while True:
event = Event.next()
if event.kind == Event.TERMINATE:
break
pipeline.send(event)
def process(entry, result, mode="Num"):
"""
Given a JSON object formatted by Extractor.py, parse each key-value pair in the object.
:param entry: the JSON object that represents one impression
:param result: the buffer to store the parsed variables
:param mode: "Num" or "Bin"; a flag indicating whether to parse bid bloor into binary variables or just keep the numerical value
:return: a list containing parsed variables of an impression
"""
Event.process(entry, result)
margin = Auction.process(entry, result)
Auction_Site.process(entry, result)
Auction_BidRequests.process(margin, entry, result, mode)
# Response
result.append(entry["response"])
def main():
print("Handler Chain #1")
handler1 = TimerHandler(KeyHandler(MouseHandler(NullHandler())))
# Could pass None or nothing instead of the NullHandler
while True:
event = Event.next()
if event.kind == Event.TERMINATE:
break
handler1.handle(event)
print("\nHandler Chain #2 (debugging)")
handler2 = DebugHandler(handler1)
while True:
event = Event.next()
if event.kind == Event.TERMINATE:
break
handler2.handle(event)
def receiveHandler(self, rudpSocket, senderAddress, data):
packet = VsPacket().unpack(data)
print ">> " + str(packet)
''' Get or create file info object'''
fileInfo = None
for fInfoTmp in self.files:
if fInfoTmp.sender == senderAddress:
fileInfo = fInfoTmp
if fileInfo is None:
fileInfo = FileInfo()
fileInfo.sender = senderAddress
self.files.append(fileInfo)
''' Handle different VSFTP pacekt types'''
if packet.type == VsPacket.TYPE_BEGIN:
if fileInfo.filename is not None:
print "File already open !!!!"
sys.exit(1)
filename = packet.data
print "GOT PACKET BEGIN, openning fileToWrite for writing:" + filename
fileInfo.filename = filename
fileInfo.filehandle = open(filename,'w')
fileInfo.sendStarted = Event.getCurrentMills()
pass
elif packet.type == VsPacket.TYPE_DATA:
fileInfo.filehandle.write(packet.data)
pass
elif packet.type == VsPacket.TYPE_END:
print "GOT PACKET END, closing file"
fileInfo.filehandle.close()
self.files.remove(fileInfo)
print "Socket closed event received on " + str(rudpSocket)
print "Lost Packets:" + str(rudpSocket.packetloss)
print "Sent Data packets:" + str(rudpSocket.packetsSentData)
print "Sent Control packets:" + str(rudpSocket.packetsSentControl)
print "Received packets(total):" + str(rudpSocket.packetsReceived)
print "Received data packets:" + str(rudpSocket.packetsReceivedData)
print "Received and skipped packets:" + str(rudpSocket.packetsReceivedIgnored)
print "Fake loss:" + str(rudpSocket.packetFakeLoss)
print "Time taken: " + str((Event.getCurrentMills() - fileInfo.sendStarted))
pass
pass
def send(self):
self.rudpSocket = Rudp.createSocket(UDP_IP, UDP_PORT)
Rudp.registerEventHandler(self.rudpSocket, fileSender.handleEvent)
for desination in self.addresses:
self.rudpSocket.addPeer(desination)
fileToSend = open(self.fileName)
Event.eventFd(fileToSend.fileno(), self.handleFileDataAvailable, fileToSend, "FileDataAvailable")
print "Openned fileToSend DF:" + str(fileToSend.fileno()) + " name: " + str(self.fileName)
''' Send BEGIN packet'''
vsFtpPacket = VsPacket()
vsFtpPacket.type = VsPacket.TYPE_BEGIN
vsFtpPacket.data = FileSender.processFileName(self.fileName)
if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False:
print "Transmission error, quiting"
sys.exit()
def get_header():
header = []
header.extend(Event.get_header())
header.extend(Auction.get_header())
header.extend(Auction_Site.get_hearder())
header.extend(Auction_BidRequests.get_hearder())
header.append(("response", 1))
return header
def __init__(self, filename):
self.filename = filename
self.fd = os.open(filename, os.O_RDWR | os.O_NONBLOCK)
Controller.__init__(self, LinuxInput.iocGetName(self.fd))
Event.attach(self, "onDisconnect")
# Store all the bitfields in a dictionary of lists
self.evdevBits = {}
for name in LinuxInput.iocGetBitNames(self.fd, None):
try:
self.evdevBits[name] = LinuxInput.iocGetBitNames(self.fd, name)
except KeyError:
pass
# Store info on each absolute axis
self.absAxisInfo = {}
for name in self.evdevBits['EV_ABS']:
self.absAxisInfo[name] = LinuxInput.iocGetAbs(self.fd, name)
# Create actuators
for bitName, cls in (
('EV_ABS', Axis),
('EV_REL', Axis),
('EV_KEY', Button),
):
if bitName in self.evdevBits:
for itemName in self.evdevBits[bitName]:
self.addActuator(cls(itemName))
# Join pairs of axes into joysticks where appropriate
for jsName, axisPrefix in (
('JS_ABS', 'ABS_'),
('JS_ABS_RIGHT', 'ABS_R'),
('JS_ABS_HAT0', 'ABS_HAT0'),
('JS_ABS_HAT1', 'ABS_HAT1'),
('JS_ABS_HAT2', 'ABS_HAT2'),
('JS_ABS_HAT3', 'ABS_HAT3'),
('JS_REL', 'REL_'),
):
x, y = axisPrefix + 'X', axisPrefix + 'Y'
if x in self.actuators and y in self.actuators:
self.addActuator(Joystick(jsName, self.actuators[x], self.actuators[y]))
def handleACK(self, ackPacket):
if ackPacket.seqnum != self.nextAckSeqNumber:
logger.log(Level.ERROR, "ACK with wrong sequence number, probably arrived too late, ignoring")
return
if self.state == RudpSocket.STATE_INITING:
''' Must be ACK in response to SYN'''
logger.log(Level.DEBUG, "Handling ACK for SYN")
self.state = RudpSocket.STATE_ESTABLISHED
self.nextAckSeqNumber = 1
Event.eventTimeoutDelete(self.__handleTimeoutSYN, ackPacket.seqnum - 1)
self.__emptyBuffer()
self.__resetRetries()
elif self.state == RudpSocket.STATE_ESTABLISHED:
''' Must be ACK in response to DATA'''
logger.log(Level.DEBUG, "Handling ACK for DATA")
logger.log(Level.DEBUG, "ACK CORRECT")
Event.eventTimeoutDelete(self.__handleTimeoutData, ackPacket.seqnum - 1)
self.nextAckSeqNumber = ackPacket.seqnum + 1
self.window = self.window + 1
self.__emptyBuffer()
self.__resetRetries()
self.__checkClose()
elif self.state == RudpSocket.STATE_CLOSED:
''' This must be the final ACK'''
logger.log(Level.DEBUG, "Final ACK received:" + str(self.rudpSocket))
Event.eventTimeoutDelete(self.__handleTimeoutFIN, ackPacket.seqnum - 1)
self.finished = True
self.rudpSocket._peerFinished()
def handleFileDataAvailable(self, fd, fileToSend):
data = fileToSend.read(800)
if data:
vsFtpPacket = VsPacket()
vsFtpPacket.type = VsPacket.TYPE_DATA
vsFtpPacket.data = data
if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False:
print "Transmission error, quiting"
sys.exit()
self.packetcount = self.packetcount + 1
print "### " + str(self.packetcount)
#time.sleep(0)
else:
''' Send END packet'''
vsFtpPacket = VsPacket()
vsFtpPacket.type = VsPacket.TYPE_END
vsFtpPacket.data = data
if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False:
print "Transmission error, quiting"
Event.eventFdDelete(self.handleFileDataAvailable, fileToSend)
print "File " + self.fileName + " sent"
Rudp.closeSocket(self.rudpSocket)
def handleEvent(self, rudpSocket, eventType):
if eventType == Event.TYPE_TIMEOUT:
sys.exit("TimeOut event received")
if eventType == Event.TYPE_CLOSED:
print "Socket closed event received on " + str(rudpSocket)
print "Lost Packets:" + str(rudpSocket.packetloss)
print "Sent Data packets:" + str(rudpSocket.packetsSentData)
print "Sent Control packets:" + str(rudpSocket.packetsSentControl)
print "Received packets(total):" + str(rudpSocket.packetsReceived)
print "Received data packets:" + str(rudpSocket.packetsReceivedData)
print "Received and skipped packets:" + str(rudpSocket.packetsReceivedIgnored)
print "Fake loss:" + str(rudpSocket.packetFakeLoss)
print "Time taken: " + str((Event.getCurrentMills() - self.timeStarted))
def update(self, level):
if not self.exploding:
return Item.update(self, level)
else:
size_diff = (self.radius - self.current_size)
self.current_size += Interface.tdiff * (size_diff + 0.5) * 2
if self.current_size >= self.radius:
if not self.hit_bomb:
level.explosion_links[self.explosion_index] = 0
return False
for pos in range(len(level.players) - 1, -1, -1):
player = level.players[pos]
xdiff = player.x - self.x
ydiff = player.y - self.y
if xdiff * xdiff + ydiff * ydiff <= self.current_size * self.current_size:
player.life -= 1
if player.life == 0:
Log.info("Killed " + player.name)
del level.players[pos]
if len(level.players) == 1:
Log.info(level.players[0].name + " wins the match!")
Event.post(Event.EVENT_MATCH_WON)
else:
Log.info("Damaged " + player.name)
for pos in range(len(level.items) - 1, -1, -1):
item = level.items[pos]
xdiff = item.x - self.x
ydiff = item.y - self.y
if xdiff * xdiff + ydiff * ydiff <= self.current_size * self.current_size:
if item.type == "Bomb":
if item is not self and not item.exploding:
self.hit_bomb = True
item.timeout(level, self.explosion_index)
else:
Log.info("Destroyed " + item.type)
del level.items[pos]
return True
def map(self): import User User.init_db() import Campus Campus.init() import Class Class.init() import ClassRoom ClassRoom.init() import Course Course.init() import Cursus Cursus.init() import Event Event.init() import Period Period.init() import Planning Planning.init() import Settings Settings.init() import University University.init()
def get_header():
"""
Get the names of the features in the list returned by process().
Each item is a tuple where the first element is the feature name and the second element is the number of variables that feature contains.
:return: a list of tuples containing the feature names and the lengths of the corresponding features
"""
header = []
header.extend(Event.get_header())
header.extend(Auction.get_header())
header.extend(Auction_Site.get_hearder())
header.extend(Auction_BidRequests.get_hearder())
header.append(("response", 1))
return header
def timeout(self, level, linkindex = -1): self.exploding = True old_time = level.explosion_last level.explosion_last = time() if level.explosion_last - old_time <= .15: level.explosion_counter += 1 else: level.explosion_counter = 1 if level.explosion_counter > 4: Event.post(Event.EVENT_CAMERA_SHAKE) #self.radius *= 2.0 self.explosion_index = linkindex if linkindex == -1: for links in range(len(level.explosion_links)): if level.explosion_links[links] == 0: level.explosion_links[links] = 1 self.explosion_index = links break if self.explosion_index == -1: level.explosion_links.append(1) self.explosion_index = len(level.explosion_links) - 1 else: for pos in range(len(level.items) - 1, -1, -1): item = level.items[pos] xdiff = item.x - self.x ydiff = item.y - self.y if xdiff * xdiff + ydiff * ydiff <= self.radius * self.radius: if item.type == "Bomb": if item is not self and not item.exploding: self.hit_bomb = True level.explosion_links[self.explosion_index] += 1 if level.explosion_links[self.explosion_index] > 4 and not self.hit_bomb: Event.post(Event.EVENT_CAMERA_SHAKE) self.radius *= 1.5 return True
def sendToAll(self, data):
if self.state == RudpSocket.STATE_LISTEN:
print str(self) + " not ESTABLISHED, sending SYN"
packet = self.rudpSocket.generateSynPacket()
self.nextAckSeqNumber = packet.seqnum + 1
self.rudpSocket.sendPacketControl(self.addr, packet)
self.state = RudpSocket.STATE_INITING
Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutSYN, packet.seqnum, "SYN timeout")
elif self.state == RudpSocket.STATE_INITING:
logger.log(Level.DEBUG, str(self) + " STATE_INITING, adding data to buffer")
elif self.state == RudpSocket.STATE_ESTABLISHED:
logger.log(Level.DEBUG, str(self) + " STATE_ESTABLISHED, adding data to buffer")
elif self.state == RudpSocket.STATE_CLOSED:
logger.log(Level.ERROR, str(self) + " STATE_CLOSED, adding data to buffer")
return False
# Build packet and add to buffer
packet = RudpPacket()
packet.type = RudpPacket.TYPE_DATA
packet.data = data
packet.seqnum = self.nextBufferPacketSeqNumber
self.dataBuffer.append(packet)
self.nextBufferPacketSeqNumber = self.nextBufferPacketSeqNumber + 1
logger.log(Level.TRACE, "Buffer has packets:" + str(len(self.dataBuffer)))
return True
def new_main():
event_list = []
current_time = None
for line in sys.stdin:
event = Event.decode_event(line)
if current_time != event.timestamp:
ReorderAndHandleEvents(event_list)
del event_list
event_list = []
event_list.append(event)
current_time = event.timestamp
if Global.Graph().number_of_nodes() > 1000000:
Global.PrintMemoryUsage()
Global.TryCleanupGraph(event.timestamp)
Global.PrintMemoryUsage()
sys.stderr.flush()
sys.stdout.flush()
ReorderAndHandleEvents(event_list)
del event_list
class InterfaceScaleManager(object):
onScaleChanged = Event.Event()
def __init__(self, settingsCore):
self.proxy = weakref.proxy(settingsCore)
self.__index = None
self.__scaleValue = None
return
def init(self):
g_guiResetters.add(self.scaleChanged)
connectionManager.onConnected += self.scaleChanged
connectionManager.onDisconnected += self.scaleChanged
self.proxy.onSettingsChanged += self.onSettingsChanged
self.scaleChanged()
def fini(self):
connectionManager.onDisconnected -= self.scaleChanged
connectionManager.onConnected -= self.scaleChanged
self.proxy.onSettingsChanged -= self.onSettingsChanged
g_guiResetters.discard(self.scaleChanged)
def get(self):
return self.__scaleValue
def getIndex(self):
return self.__index
def onSettingsChanged(self, diff):
if settings_constants.GRAPHICS.INTERFACE_SCALE in diff:
self.__index = diff[settings_constants.GRAPHICS.INTERFACE_SCALE]
self.__scaleValue = self.getScaleByIndex(self.__index)
self.onScaleChanged(self.__scaleValue)
def scaleChanged(self):
self.__index = self.proxy.getSetting(
settings_constants.GRAPHICS.INTERFACE_SCALE)
self.__scaleValue = self.getScaleByIndex(self.__index)
self.onScaleChanged(self.__scaleValue)
def getScaleOptions(self):
options = self._getOptions()
currMonitor = g_monitorSettings.activeMonitor
if self.proxy.getSetting(settings_constants.GRAPHICS.FULLSCREEN):
resolutionInd = self.proxy.getSetting(
settings_constants.GRAPHICS.RESOLUTION)
return options[1][currMonitor][resolutionInd]
else:
return options[0][currMonitor][self.proxy.getSetting(
settings_constants.GRAPHICS.WINDOW_SIZE)]
def getScaleByIndex(self, ind, powerOfTwo=True):
scaleLength = len(self.getScaleOptions())
if powerOfTwo:
if ind == 0:
return 2.0**(scaleLength - 2)
else:
return 2.0**(ind - 1)
else:
if ind == 0:
return scaleLength - 1
return ind
def _getOptions(self):
return [
self.__getScales(graphics.getSuitableWindowSizes(),
BigWorld.wg_getCurrentResolution(True)),
self.__getScales(graphics.getSuitableVideoModes())
]
def __getScales(self, modesVariety, additionalSize=None):
result = []
for i in xrange(len(modesVariety)):
modes = sorted(
set([(mode.width, mode.height) for mode in modesVariety[i]]))
if additionalSize is not None:
modes.append(additionalSize[0:2])
result.append(map(graphics.getInterfaceScalesList, modes))
return result
def make_gold_set():
'''
handcrafted set of events from testing data
empty if n.A. (better for comaprison with results)
:return: list of gold-standard Event objects
'''
gold_standard = []
p3s11 = Event.Event(
component1="Bartonella tribocorum",
component2=["the blood of wild rats", "fleas obtained from wild rats"])
p3s12 = Event.Event(component1="Bartonella elizabethae",
component2="a case of endocarditis in a human")
p3s14 = Event.Event(component1="This organism",
component2="the blood of wild rats")
p6s4 = Event.Event(component1="This species",
component2="the feces of a breast-fed infant")
p7s5 = Event.Event(
component1="Most of the ~30 known species of bifidobacteria",
component2=["the mammalian GIT", "the vaginal and oral cavity"])
p8s6 = Event.Event(
component1="Most of the ~30 known species of bifidobacteria",
component2=["the mammalian GIT", "the vaginal and oral cavity"])
p8s13 = Event.Event(component1="This strain",
component2="human infant feces")
p11s3 = Event.Event(component1=" ", component2=" ")
p11s4 = Event.Event(
component1="Burkholderia ambifaria AMMD",
component2=
"the rhizosphere of pea -LRB- Pisum sativum L. -RRB- near Arlington, Wisconsin, USA"
)
p12s3 = Event.Event(
component1="the reference strain, CH34",
component2=
"the sludge of a zinc decantation tank in Belgium that was polluted with high concentrations of several heavy metals"
)
p13s12 = Event.Event(
component1="Dehalococcoides sp. strain BAV1",
component2=
"PCE-to-ethene-dechlorinating microcosms established with aquifer material collected at the contaminated Bachman Road site in Oscoda, Michigan -LRB- 6-8, 13 -RRB-"
)
p14s1 = Event.Event(
component1="Desulfococcus oleovorans Hxd3",
component2=
"the saline water phase of an oil-water separator from a northern German oil field -LRB- 1,2 -RRB-"
)
p16s8 = Event.Event(component1="D. deserti",
component2="the Sahara desert")
p17s3 = Event.Event(component1="the first strain of Tropheryma whipplei",
component2=" ")
p18s14 = Event.Event(component1="the genes", component2="in eukaryotes")
p19s1 = Event.Event(
component1="Thermoanaerobacter tengcongensis",
component2="a freshwater hot spring in Tengchong, China")
p21s3 = Event.Event(component1="The sequenced strain",
component2="Beppu hot spring in Japan")
p22s1 = Event.Event(
component1="Thermotoga maritima",
component2="geothermal heated marine sediment at Vulcano, Italy")
p23s2 = Event.Event(component1="The organism, strain HB27",
component2="a natural thermal environment in Japan")
p25s3 = Event.Event(component1="D. aromatica strain RCB",
component2="Potomic River sediment, Maryland, USA")
p25s31 = Event.Event(component1="Dechloromonas aromatica", component2=" ")
p25s32 = Event.Event(component1="two unrelated strains, RCB and JJ,",
component2="two very diverse environments")
p26s2 = Event.Event(
component1="It",
component2="soil contaminated with chlorinated industrial products")
p26s5 = Event.Event(
component1="D. restrictus",
component2=
"a laboratory system that was being fed with tetrachloroethene")
p27s11 = Event.Event(
component1="The S. meliloti genome",
component2=
"nodules and soil primarily from host plants such as the Medicago -LRB- alfalfa and perennial and annual medics -RRB-, Melilotus -LRB- sweet clover -RRB-, and Trigonella -LRB- fenugreek -RRB- species -LRB- 11 -RRB-"
)
p27s62 = Event.Event(component1=" ", component2=" ")
gold_standard.append(p3s11)
gold_standard.append(p3s12)
gold_standard.append(p3s14)
gold_standard.append(p6s4)
gold_standard.append(p7s5)
gold_standard.append(p8s6)
gold_standard.append(p8s13)
gold_standard.append(p11s3)
gold_standard.append(p11s4)
gold_standard.append(p12s3)
gold_standard.append(p13s12)
gold_standard.append(p14s1)
gold_standard.append(p16s8)
gold_standard.append(p17s3)
gold_standard.append(p18s14)
gold_standard.append(p19s1)
gold_standard.append(p21s3)
gold_standard.append(p22s1)
gold_standard.append(p23s2)
gold_standard.append(p25s3)
gold_standard.append(p25s31)
gold_standard.append(p25s32)
gold_standard.append(p26s2)
gold_standard.append(p26s5)
gold_standard.append(p27s11)
gold_standard.append(p27s62)
return gold_standard
def __init__(self):
super(AvatarStatsController, self).__init__()
self.__stats = {}
self.__eManager = Event.EventManager()
self.onUpdated = Event.Event(self.__eManager)
def __init__(self):
self.onUpdated = Event.Event()
self.__newOffers = set()
def proceed(self):
# 결과를 제출할 이벤트 인스턴스 생성
myEvent = Event()
myEvent.setStartTime(self.startTime.text())
myEvent.setEndTime(self.endTime.text())
# 상품을 사전에 등록
dic = {}
selectedNum = int(self.prizeComboBox.currentText())
for i in range(0, selectedNum):
dic[self.prizeEdit[i].text()] = self.prizeSpinBox[i].value()
myEvent.setPrize(dic)
print("당첨자 엑셀을 생성합니다")
# 체리피커 필터링
if (self.checkBox_Cherry.isChecked() is True):
myEvent.setOpt_Cherry(["초대", "함께해", "함께해요"])
print("체리피커 필터링이 활성화 되었습니다")
# URL 체크
if (self.checkBox_URL.isChecked() is True):
myEvent.setOpt_URL(["www", "facebook"])
print("URL 체크가 활성화 되었습니다")
# 이벤트 키워드 체크
if (self.checkBox_Keyword.isChecked() is True):
if not (self.keywordEdit1.text() is None):
myEvent.setOpt_Keywords([self.keywordEdit1.text()])
if not (self.keywordEdit2.text() is None):
myEvent.setOpt_Keywords([self.keywordEdit2.text()])
if not (self.keywordEdit3.text() is None):
myEvent.setOpt_Keywords([self.keywordEdit3.text()])
if not (self.keywordEdit4.text() is None):
myEvent.setOpt_Keywords([self.keywordEdit4.text()])
print("키워드 체크가 활성화 되었습니다")
print("체리필터 키워드 : " + str(myEvent.getOpt_Cherry()))
print("URL 체크 키워드 : " + str(myEvent.getOpt_URL()))
print("이벤트 당첨 키워드 : " + str(myEvent.getOpt_Keywords()))
generateExcel(myEvent)
self.progressBar.setValue(self.progressBar.maximum())
popup = QtWidgets.QMessageBox(self)
popup.setGeometry(100, 200, 100, 100)
popup.information(self, "Complete", "당첨자 엑셀이 생성되었습니다.",
QtWidgets.QMessageBox.Yes)
def notify(self, message):
self.emit(Event.Event(details={'notification': message}))
def __init__(self):
super(RentalsController, self).__init__()
self.onRentChangeNotify = Event.Event()
self.__rentNotifyTimeCallback = None
self.__vehiclesForUpdate = []
return
#!/usr/bin/python
# -*- encoding: utf-8 -*-
import matplotlib.pyplot as plt
import Event
import MyConf
import numpy as np
event = Event.Event()
attackFile = "./ex_attack.txt"
noiseFile = "./ex_noise.txt"
event.loadAttack(attackFile)
event.loadNoiseWithLearning(noiseFile, 600)
event.calcTotal()
event.calcTotalScore(useLearningData = True)
total = event.total
score = event.totalScore
fig = plt.figure(figsize=(16,9)) # aspect ratio
plt.rcParams['font.size'] = 30 # default font size
plt.rcParams['font.family'] = 'serif' # default font family
plt.rcParams['legend.fontsize'] = 30 # default font size of legend
plt.tick_params(pad=15) # pad: Distance in points between tick and label.
ax = fig.add_subplot(1, 1, 1) # 1 * 1 grid, and 1st subplot
ax2 = ax.twinx()
ax.set_xlabel('$t$') # X tick label
ax.set_ylabel('Number of traceroute packets $x_t$') # Y tick label
ax2.set_ylabel('Abnormality $a_i$')
ax2.yaxis.set_label_coords(1.08, 0.5)
import string import Interface import Event import App from chat import * #Chat manager from Interface import * from Event import * from App import * import feedparser ########################################################### ######Global variables I = Interface.get() #Interface manager A = App.get() #Application E = Event.get() #Event manager ########################################################## #####Counter, returns new value every time def counter(): static_counter = 0 while True: static_counter += 1 yield static_counter count = counter().next ######################################################################### #####Function creates simple message box with specified title and name #####Message box has one button - ok and is destroyed by interface manager #####after pressing this button. #####Every new popup window has unique id. def createPopupWindow(title,text): name = 'PopupWindow' + str(count())
def fill_insert(classe, i):
classe.name = "C" + str(i)
classe.planning = Planning()
# XXX fill planning with normal events ?
#classe.planning.cb_fill(number)
# XXX fill planning with course events
cursus = db.session.query(Cursus).get(i + 1)
if cursus:
periods = cursus.periods
import Event
Event.fill_date = cursus.start
else:
periods = []
for period in periods:
for course in period.courses:
from Event import Event
# XXX move fill event in class
event = Event()
event.planning = classe.planning
event.course = course
course.c_elearning_rest = course.c_elearning
course.c_classroom_rest = course.c_classroom
course.c_practice_rest = course.c_practice
course.e_oral_rest = course.e_oral
course.e_practice_rest = course.e_practice
hours = course.c_elearning
hours += course.c_classroom
hours += course.c_practice
hours += course.e_oral
hours += course.e_practice
event.cb_fill(hours / 2)
if len(period.classes) == 0:
for course in period.courses:
event = Event()
event.planning = period.planning
event.course = course
event.cb_fill(event.course.e_exam / 2 + 1)
import Event
Event.fill_date = period.end
classe.periods = periods
user = User()
user.manager_class = [classe]
user.cb_fill(
randint(1, number), classe.campus.name + '_' + classe.name +
'_manager_user' + str(i))
user = User()
user.student_class = classe
user.cb_fill(
randint(10, 30), classe.campus.name + '_' + classe.name +
'_student_user' + str(i))
db.session.add(classe)
def __init__(self, cppObject=None):
super(WindowsManager, self).__init__(cppObject)
self.__eManager = Event.EventManager()
self.onWindowStatusChanged = Event.Event(self.__eManager)
self.onViewStatusChanged = Event.Event(self.__eManager)
class _SettingsCore(object):
onSettingsChanged = Event.Event()
def init(self):
from account_helpers.settings_core import options, settings_storages, settings_constants
from gui.shared.utils import graphics
GAME = settings_constants.GAME
TUTORIAL = settings_constants.TUTORIAL
GRAPHICS = settings_constants.GRAPHICS
SOUND = settings_constants.SOUND
CONTROLS = settings_constants.CONTROLS
AIM = settings_constants.AIM
MARKERS = settings_constants.MARKERS
OTHER = settings_constants.OTHER
self.__serverSettings = ServerSettingsManager(self)
self.interfaceScale = InterfaceScaleManager(self)
VIDEO_SETTINGS_STORAGE = settings_storages.VideoSettingsStorage(self.serverSettings, self)
GAME_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAME)
EXTENDED_GAME_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAME_EXTENDED)
TUTORIAL_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.TUTORIAL)
GAMEPLAY_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAMEPLAY)
GRAPHICS_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GRAPHICS)
SOUND_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.SOUND)
KEYBOARD_SETTINGS_STORAGE = settings_storages.KeyboardSettingsStorage(self.serverSettings, self)
CONTROLS_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.CONTROLS)
AIM_SETTINGS_STORAGE = settings_storages.AimSettingsStorage(self.serverSettings, self)
MARKERS_SETTINGS_STORAGE = settings_storages.MarkersSettingsStorage(self.serverSettings, self)
MARK_ON_GUN_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.MARKS_ON_GUN)
FOV_SETTINGS_STORAGE = settings_storages.FOVSettingsStorage(self.serverSettings, self)
MESSENGER_SETTINGS_STORAGE = settings_storages.MessengerSettingsStorage(GAME_SETTINGS_STORAGE)
EXTENDED_MESSENGER_SETTINGS_STORAGE = settings_storages.MessengerSettingsStorage(EXTENDED_GAME_SETTINGS_STORAGE)
self.__storages = {'game': GAME_SETTINGS_STORAGE,
'extendedGame': EXTENDED_GAME_SETTINGS_STORAGE,
'gameplay': GAMEPLAY_SETTINGS_STORAGE,
'sound': SOUND_SETTINGS_STORAGE,
'keyboard': KEYBOARD_SETTINGS_STORAGE,
'controls': CONTROLS_SETTINGS_STORAGE,
'aim': AIM_SETTINGS_STORAGE,
'markers': MARKERS_SETTINGS_STORAGE,
'graphics': GRAPHICS_SETTINGS_STORAGE,
'video': VIDEO_SETTINGS_STORAGE,
'messenger': MESSENGER_SETTINGS_STORAGE,
'extendedMessenger': EXTENDED_MESSENGER_SETTINGS_STORAGE,
'marksOnGun': MARK_ON_GUN_SETTINGS_STORAGE,
'FOV': FOV_SETTINGS_STORAGE,
'tutorial': TUTORIAL_SETTINGS_STORAGE}
self.isDeviseRecreated = False
self.isChangesConfirmed = True
self.__options = options.SettingsContainer(((GAME.REPLAY_ENABLED, options.ReplaySetting(GAME.REPLAY_ENABLED, storage=GAME_SETTINGS_STORAGE)),
(GAME.ENABLE_SERVER_AIM, options.StorageAccountSetting(GAME.ENABLE_SERVER_AIM, storage=GAME_SETTINGS_STORAGE)),
(GAME.MINIMAP_ALPHA, options.StorageAccountSetting(GAME.MINIMAP_ALPHA, storage=GAME_SETTINGS_STORAGE)),
(GAME.ENABLE_POSTMORTEM, options.PostProcessingSetting(GAME.ENABLE_POSTMORTEM, 'mortem_post_effect', storage=GAME_SETTINGS_STORAGE)),
(GAME.ENABLE_POSTMORTEM_DELAY, options.PostMortemDelaySetting(GAME.ENABLE_POSTMORTEM_DELAY, storage=GAME_SETTINGS_STORAGE)),
(GAME.SHOW_VEHICLES_COUNTER, options.StorageAccountSetting(GAME.SHOW_VEHICLES_COUNTER, storage=GAME_SETTINGS_STORAGE)),
(GAME.SHOW_BATTLE_EFFICIENCY_RIBBONS, options.ExcludeInReplayAccountSetting(GAME.SHOW_BATTLE_EFFICIENCY_RIBBONS, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.BATTLE_LOADING_INFO, options.BattleLoadingTipSetting(GAME.BATTLE_LOADING_INFO, GAME.BATTLE_LOADING_INFO)),
(GAME.SIMPLIFIED_TTC, options.StorageAccountSetting(GAME.SIMPLIFIED_TTC, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.SHOW_MARKS_ON_GUN, options.ShowMarksOnGunSetting(GAME.SHOW_MARKS_ON_GUN, storage=MARK_ON_GUN_SETTINGS_STORAGE)),
(GAME.DYNAMIC_CAMERA, options.DynamicCamera(GAME.DYNAMIC_CAMERA, storage=GAME_SETTINGS_STORAGE)),
(GAME.INCREASED_ZOOM, options.IncreasedZoomSetting(GAME.INCREASED_ZOOM, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.SNIPER_MODE_BY_SHIFT, options.SnipereModeByShiftSetting(GAME.SNIPER_MODE_BY_SHIFT, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.SNIPER_MODE_STABILIZATION, options.SniperModeStabilization(GAME.SNIPER_MODE_STABILIZATION, storage=GAME_SETTINGS_STORAGE)),
(GAME.ENABLE_OL_FILTER, options.MessengerSetting(GAME.ENABLE_OL_FILTER, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.ENABLE_SPAM_FILTER, options.MessengerSetting(GAME.ENABLE_SPAM_FILTER, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.SHOW_DATE_MESSAGE, options.MessengerDateTimeSetting(1, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.SHOW_TIME_MESSAGE, options.MessengerDateTimeSetting(2, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.INVITES_FROM_FRIENDS, options.MessengerSetting(GAME.INVITES_FROM_FRIENDS, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.RECEIVE_CLAN_INVITES_NOTIFICATIONS, options.ClansSetting(GAME.RECEIVE_CLAN_INVITES_NOTIFICATIONS, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.RECEIVE_FRIENDSHIP_REQUEST, options.MessengerSetting(GAME.RECEIVE_FRIENDSHIP_REQUEST, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.RECEIVE_INVITES_IN_BATTLE, options.MessengerSetting(GAME.RECEIVE_INVITES_IN_BATTLE, storage=EXTENDED_MESSENGER_SETTINGS_STORAGE)),
(GAME.DISABLE_BATTLE_CHAT, options.MessengerSetting(GAME.DISABLE_BATTLE_CHAT, storage=MESSENGER_SETTINGS_STORAGE)),
(GAME.CHAT_CONTACTS_LIST_ONLY, options.MessengerSetting(GAME.CHAT_CONTACTS_LIST_ONLY, storage=EXTENDED_MESSENGER_SETTINGS_STORAGE)),
(GAME.PLAYERS_PANELS_SHOW_LEVELS, options.PlayersPanelSetting(GAME.PLAYERS_PANELS_SHOW_LEVELS, 'players_panel', 'showLevels', storage=GAME_SETTINGS_STORAGE)),
(GAME.PLAYERS_PANELS_SHOW_TYPES, options.AccountDumpSetting(GAME.PLAYERS_PANELS_SHOW_TYPES, 'players_panel', 'showTypes')),
(GAME.PLAYERS_PANELS_STATE, options.AccountDumpSetting(GAME.PLAYERS_PANELS_STATE, 'players_panel', 'state')),
(GAME.SNIPER_MODE_SWINGING_ENABLED, options.SniperModeSwingingSetting()),
(GAME.GAMEPLAY_CTF, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'ctf', storage=GAMEPLAY_SETTINGS_STORAGE)),
(GAME.GAMEPLAY_DOMINATION, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'domination', storage=GAMEPLAY_SETTINGS_STORAGE)),
(GAME.GAMEPLAY_ASSAULT, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'assault', storage=GAMEPLAY_SETTINGS_STORAGE)),
(GAME.GAMEPLAY_NATIONS, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'nations', storage=GAMEPLAY_SETTINGS_STORAGE)),
(GAME.LENS_EFFECT, options.LensEffectSetting(GAME.LENS_EFFECT, storage=GRAPHICS_SETTINGS_STORAGE)),
(GAME.SHOW_VECTOR_ON_MAP, options.MinimapSetting(GAME.SHOW_VECTOR_ON_MAP, storage=GAME_SETTINGS_STORAGE)),
(GAME.SHOW_SECTOR_ON_MAP, options.MinimapSetting(GAME.SHOW_SECTOR_ON_MAP, storage=GAME_SETTINGS_STORAGE)),
(GAME.SHOW_VEH_MODELS_ON_MAP, options.MinimapVehModelsSetting(GAME.SHOW_VEH_MODELS_ON_MAP, storage=GAME_SETTINGS_STORAGE)),
(GAME.MINIMAP_VIEW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_VIEW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.MINIMAP_MAX_VIEW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_MAX_VIEW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GAME.MINIMAP_DRAW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_DRAW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)),
(GRAPHICS.MONITOR, options.MonitorSetting(storage=VIDEO_SETTINGS_STORAGE)),
(GRAPHICS.WINDOW_SIZE, options.WindowSizeSetting(storage=VIDEO_SETTINGS_STORAGE)),
(GRAPHICS.RESOLUTION, options.ResolutionSetting(storage=VIDEO_SETTINGS_STORAGE)),
(GRAPHICS.REFRESH_RATE, options.RefreshRateSetting(storage=VIDEO_SETTINGS_STORAGE)),
(GRAPHICS.FULLSCREEN, options.FullscreenSetting(storage=VIDEO_SETTINGS_STORAGE)),
(GRAPHICS.COLOR_BLIND, options.AccountDumpSetting(GRAPHICS.COLOR_BLIND, GRAPHICS.COLOR_BLIND)),
(GRAPHICS.GRAPHICS_QUALITY_HD_SD, options.GraphicsQualityNote()),
(GRAPHICS.GAMMA, options.GammaSetting()),
(GRAPHICS.TRIPLE_BUFFERED, options.TripleBufferedSetting()),
(GRAPHICS.VERTICAL_SYNC, options.VerticalSyncSetting()),
(GRAPHICS.MULTISAMPLING, options.MultisamplingSetting()),
(GRAPHICS.CUSTOM_AA, options.CustomAASetting()),
(GRAPHICS.ASPECT_RATIO, options.AspectRatioSetting()),
(GRAPHICS.FPS_PERFOMANCER, options.FPSPerfomancerSetting(GRAPHICS.FPS_PERFOMANCER, storage=GRAPHICS_SETTINGS_STORAGE)),
(GRAPHICS.DRR_AUTOSCALER_ENABLED, options.GraphicSetting(GRAPHICS.DRR_AUTOSCALER_ENABLED)),
(GRAPHICS.DYNAMIC_RENDERER, options.DynamicRendererSetting()),
(GRAPHICS.COLOR_FILTER_INTENSITY, options.ColorFilterIntensitySetting()),
(GRAPHICS.COLOR_FILTER_IMAGES, options.ReadOnlySetting(lambda : graphics.getGraphicSettingImages(GRAPHICS.COLOR_GRADING_TECHNIQUE))),
(GRAPHICS.FOV, options.FOVSetting(GRAPHICS.FOV, storage=FOV_SETTINGS_STORAGE)),
(GRAPHICS.DYNAMIC_FOV_ENABLED, options.DynamicFOVEnabledSetting(storage=FOV_SETTINGS_STORAGE)),
(GRAPHICS.PRESETS, options.GraphicsPresetSetting()),
(GRAPHICS.RENDER_PIPELINE, options.GraphicSetting(GRAPHICS.RENDER_PIPELINE)),
(GRAPHICS.TEXTURE_QUALITY, options.TextureQualitySetting()),
(GRAPHICS.DECALS_QUALITY, options.GraphicSetting(GRAPHICS.DECALS_QUALITY)),
(GRAPHICS.OBJECT_LOD, options.GraphicSetting(GRAPHICS.OBJECT_LOD)),
(GRAPHICS.FAR_PLANE, options.GraphicSetting(GRAPHICS.FAR_PLANE)),
(GRAPHICS.TERRAIN_QUALITY, options.TerrainQualitySetting()),
(GRAPHICS.SHADOWS_QUALITY, options.GraphicSetting(GRAPHICS.SHADOWS_QUALITY)),
(GRAPHICS.LIGHTING_QUALITY, options.GraphicSetting(GRAPHICS.LIGHTING_QUALITY)),
(GRAPHICS.SPEEDTREE_QUALITY, options.GraphicSetting(GRAPHICS.SPEEDTREE_QUALITY)),
(GRAPHICS.FLORA_QUALITY, options.FloraQualitySetting()),
(GRAPHICS.WATER_QUALITY, options.GraphicSetting(GRAPHICS.WATER_QUALITY)),
(GRAPHICS.EFFECTS_QUALITY, options.GraphicSetting(GRAPHICS.EFFECTS_QUALITY)),
(GRAPHICS.POST_PROCESSING_QUALITY, options.GraphicSetting(GRAPHICS.POST_PROCESSING_QUALITY)),
(GRAPHICS.MOTION_BLUR_QUALITY, options.GraphicSetting(GRAPHICS.MOTION_BLUR_QUALITY)),
(GRAPHICS.SNIPER_MODE_EFFECTS_QUALITY, options.GraphicSetting(GRAPHICS.SNIPER_MODE_EFFECTS_QUALITY)),
(GRAPHICS.VEHICLE_DUST_ENABLED, options.GraphicSetting(GRAPHICS.VEHICLE_DUST_ENABLED)),
(GRAPHICS.SNIPER_MODE_GRASS_ENABLED, options.GraphicSetting(GRAPHICS.SNIPER_MODE_GRASS_ENABLED)),
(GRAPHICS.VEHICLE_TRACES_ENABLED, options.GraphicSetting(GRAPHICS.VEHICLE_TRACES_ENABLED)),
(GRAPHICS.COLOR_GRADING_TECHNIQUE, options.GraphicSetting(GRAPHICS.COLOR_GRADING_TECHNIQUE)),
(GRAPHICS.SEMITRANSPARENT_LEAVES_ENABLED, options.GraphicSetting(GRAPHICS.SEMITRANSPARENT_LEAVES_ENABLED)),
(GRAPHICS.GRAPHICS_SETTINGS_LIST, options.ReadOnlySetting(lambda : graphics.GRAPHICS_SETTINGS.ALL())),
(GRAPHICS.INTERFACE_SCALE, options.InterfaceScaleSetting(GRAPHICS.INTERFACE_SCALE)),
(SOUND.MASTER_TOGGLE, options.SoundEnableSetting()),
(SOUND.SOUND_QUALITY, options.SoundQualitySetting()),
(SOUND.SOUND_QUALITY_VISIBLE, options.ReadOnlySetting(options.SoundQualitySetting.isAvailable)),
(SOUND.MASTER, options.SoundSetting('master')),
(SOUND.MUSIC, options.SoundSetting('music')),
(SOUND.VEHICLES, options.SoundSetting('vehicles')),
(SOUND.EFFECTS, options.SoundSetting('effects')),
(SOUND.GUI, options.SoundSetting('gui')),
(SOUND.AMBIENT, options.SoundSetting('ambient')),
(SOUND.NATIONS_VOICES, options.AccountSetting('nationalVoices')),
(SOUND.VOIP_MASTER_FADE, options.SoundSetting('masterFadeVivox')),
(SOUND.VOIP_ENABLE, options.VOIPSetting(True)),
(SOUND.VOIP_MASTER, options.VOIPMasterSoundSetting()),
(SOUND.VOIP_MIC, options.VOIPMicSoundSetting(True)),
(SOUND.CAPTURE_DEVICES, options.VOIPCaptureDevicesSetting()),
(SOUND.VOIP_SUPPORTED, options.VOIPSupportSetting()),
(SOUND.BASS_BOOST, options.BassBoostSetting()),
(SOUND.DYNAMIC_RANGE, options.DynamicSoundPresetSetting(SOUND.DYNAMIC_RANGE, SOUND.DYNAMIC_RANGE)),
(SOUND.SOUND_DEVICE, options.SoundDevicePresetSetting(SOUND.SOUND_DEVICE, SOUND.SOUND_DEVICE)),
(SOUND.ALT_VOICES, options.AltVoicesSetting(SOUND.ALT_VOICES, storage=SOUND_SETTINGS_STORAGE)),
(CONTROLS.MOUSE_ARCADE_SENS, options.MouseSensitivitySetting('arcade')),
(CONTROLS.MOUSE_SNIPER_SENS, options.MouseSensitivitySetting('sniper')),
(CONTROLS.MOUSE_STRATEGIC_SENS, options.MouseSensitivitySetting('strategic')),
(CONTROLS.MOUSE_HORZ_INVERSION, options.MouseInversionSetting(CONTROLS.MOUSE_HORZ_INVERSION, 'horzInvert', storage=CONTROLS_SETTINGS_STORAGE)),
(CONTROLS.MOUSE_VERT_INVERSION, options.MouseInversionSetting(CONTROLS.MOUSE_VERT_INVERSION, 'vertInvert', storage=CONTROLS_SETTINGS_STORAGE)),
(CONTROLS.BACK_DRAFT_INVERSION, options.BackDraftInversionSetting(storage=CONTROLS_SETTINGS_STORAGE)),
(CONTROLS.KEYBOARD, options.KeyboardSettings(storage=KEYBOARD_SETTINGS_STORAGE)),
(CONTROLS.KEYBOARD_IMPORTANT_BINDS, options.ReadOnlySetting(lambda : options.KeyboardSettings.getKeyboardImportantBinds())),
(AIM.ARCADE, options.AimSetting('arcade', storage=AIM_SETTINGS_STORAGE)),
(AIM.SNIPER, options.AimSetting('sniper', storage=AIM_SETTINGS_STORAGE)),
(MARKERS.ENEMY, options.VehicleMarkerSetting(MARKERS.ENEMY, storage=MARKERS_SETTINGS_STORAGE)),
(MARKERS.DEAD, options.VehicleMarkerSetting(MARKERS.DEAD, storage=MARKERS_SETTINGS_STORAGE)),
(MARKERS.ALLY, options.VehicleMarkerSetting(MARKERS.ALLY, storage=MARKERS_SETTINGS_STORAGE)),
(OTHER.VIBRO_CONNECTED, options.ReadOnlySetting(lambda : VibroManager.g_instance.connect())),
(OTHER.VIBRO_GAIN, options.VibroSetting('master')),
(OTHER.VIBRO_ENGINE, options.VibroSetting('engine')),
(OTHER.VIBRO_ACCELERATION, options.VibroSetting('acceleration')),
(OTHER.VIBRO_SHOTS, options.VibroSetting('shots')),
(OTHER.VIBRO_HITS, options.VibroSetting('hits')),
(OTHER.VIBRO_COLLISIONS, options.VibroSetting('collisions')),
(OTHER.VIBRO_DAMAGE, options.VibroSetting('damage')),
(OTHER.VIBRO_GUI, options.VibroSetting('gui')),
(TUTORIAL.CUSTOMIZATION, options.TutorialSetting(TUTORIAL.CUSTOMIZATION, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.TECHNICAL_MAINTENANCE, options.TutorialSetting(TUTORIAL.TECHNICAL_MAINTENANCE, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.PERSONAL_CASE, options.TutorialSetting(TUTORIAL.PERSONAL_CASE, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.RESEARCH, options.TutorialSetting(TUTORIAL.RESEARCH, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.RESEARCH_TREE, options.TutorialSetting(TUTORIAL.RESEARCH_TREE, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.MEDKIT_USED, options.TutorialSetting(TUTORIAL.MEDKIT_USED, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.REPAIRKIT_USED, options.TutorialSetting(TUTORIAL.REPAIRKIT_USED, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.FIRE_EXTINGUISHER_USED, options.TutorialSetting(TUTORIAL.FIRE_EXTINGUISHER_USED, storage=TUTORIAL_SETTINGS_STORAGE)),
(TUTORIAL.WAS_QUESTS_TUTORIAL_STARTED, options.TutorialSetting(TUTORIAL.WAS_QUESTS_TUTORIAL_STARTED, storage=TUTORIAL_SETTINGS_STORAGE))))
self.__options.init()
AccountSettings.onSettingsChanging += self.__onAccountSettingsChanging
self.interfaceScale.init()
def fini(self):
self.options.dump()
self.__storages = None
if self.__options is not None:
self.__options.fini()
self.__options = None
self.__serverSettings = None
self.interfaceScale.fini()
AccountSettings.onSettingsChanging -= self.__onAccountSettingsChanging
AccountSettings.clearCache()
LOG_DEBUG('SettingsCore is destroyed')
return
@property
def options(self):
return self.__options
@property
def storages(self):
return self.__storages
@property
def serverSettings(self):
return self.__serverSettings
def packSettings(self, names):
return self.__options.pack(names)
def getSetting(self, name):
return self.__options.getSetting(name).get()
def getApplyMethod(self, diff):
return self.__options.getApplyMethod(diff)
def applySetting(self, key, value):
if self.isSettingChanged(key, value):
result = self.__options.getSetting(key).apply(value)
from account_helpers.settings_core import settings_constants
if key in settings_constants.GRAPHICS.ALL():
LOG_DEBUG('Apply graphic settings: ', {key: value})
self.onSettingsChanged({key: value})
return result
else:
return None
def previewSetting(self, name, value):
if self.isSettingChanged(name, value):
self.__options.getSetting(name).preview(value)
def applySettings(self, diff):
self.__options.apply(diff)
from account_helpers.settings_core import settings_constants
graphicsSettings = {k:v for k, v in diff.iteritems() if k in settings_constants.GRAPHICS.ALL()}
if graphicsSettings:
LOG_DEBUG('Apply graphic settings: ', graphicsSettings)
self.onSettingsChanged(graphicsSettings)
def revertSettings(self):
self.__options.revert()
def isSettingChanged(self, name, value):
return not self.__options.getSetting(name).isEqual(value)
def applyStorages(self, restartApproved):
confirmators = []
for storage in self.__storages.values():
confirmators.append(storage.apply(restartApproved))
return confirmators
@process
def confirmChanges(self, confirmators):
yield lambda callback: callback(None)
for confirmation, revert in confirmators:
if confirmation is not None:
isConfirmed = yield confirmation()
if not isConfirmed:
self.isChangesConfirmed = False
revert()
return
def clearStorages(self):
for storage in self.__storages.values():
storage.clear()
def __onAccountSettingsChanging(self, key, value):
LOG_DEBUG('Apply account setting: ', {key: value})
self.onSettingsChanged({key: value})
class ServerStats(Controller):
STATS_REQUEST_TIMEOUT = 5.0
class TOOLTIP_TYPE:
TYPE_UNAVAILABLE = ('unavailable', )
TYPE_CLUSTER = ('clusterCCU', )
TYPE_FULL = 'regionCCU/clusterCCU'
onStatsReceived = Event.Event()
def __init__(self, proxy):
super(ServerStats, self).__init__(proxy)
self.__statsCallbackID = None
self.__stats = {}
def onLobbyStarted(self, ctx):
g_playerEvents.onServerStatsReceived += self.__onStatsReceived
self.__loadStatsCallback(0.0)
def onAvatarBecomePlayer(self):
self.__stop()
def onDisconnected(self):
self.__stop()
def getStats(self):
return self.__stats
def getFormattedStats(self):
clusterCCU = self.__stats.get('clusterCCU', 0)
regionCCU = self.__stats.get('regionCCU', 0)
if regionCCU:
clusterUsers = makeHtmlString(
'html_templates:lobby/serverStats', 'clusterName',
{'count': BigWorld.wg_getIntegralFormat(clusterCCU)})
if clusterCCU == regionCCU:
tooltipType = self.TOOLTIP_TYPE.TYPE_CLUSTER
statsStr = clusterUsers
else:
tooltipType = self.TOOLTIP_TYPE.TYPE_FULL
statsStr = '%s / %s' % (
clusterUsers, BigWorld.wg_getIntegralFormat(regionCCU))
else:
tooltipType = self.TOOLTIP_TYPE.TYPE_UNAVAILABLE
statsStr = '- / -'
return (statsStr, tooltipType)
def __stop(self):
g_playerEvents.onServerStatsReceived -= self.__onStatsReceived
self.__clearStatsCallback()
def __onStatsReceived(self, stats):
self.__stats = dict(stats)
self.onStatsReceived(self.__stats)
self.__loadStatsCallback()
def __requestServerStats(self):
self.__clearStatsCallback()
if hasattr(BigWorld.player(), 'requestServerStats'):
BigWorld.player().requestServerStats()
def __loadStatsCallback(self, timeout=None):
if constants.IS_SHOW_SERVER_STATS:
self.__statsCallbackID = BigWorld.callback(
timeout if timeout is not None else self.STATS_REQUEST_TIMEOUT,
self.__requestServerStats)
def __clearStatsCallback(self):
if self.__statsCallbackID is not None:
BigWorld.cancelCallback(self.__statsCallbackID)
self.__statsCallbackID = None
def __init__(self, id, room):
Entity.__init__(self, TYPE_MUC, id)
self.room_jid = room
self.eventMessage = Event.Event()
self.eventUserOnline = Event.Event()
self.eventUserOffline = Event.Event()
def run(self):
event = Event.E_Init().Gen_Event()
scheduler.enter(*event)
while True:
scheduler.run()
print 'run out\n'
def __init__(self, width = 640, height = 480): self.init_sdl(width, height) BaseInterface.__init__(self) Event.register(Event.EVENT_QUIT, self.shutdown)
def __init__(self):
self.onFocalPlaneChanged = Event.Event()
def __init__(self):
super(MarathonEventsController, self).__init__()
self.__eventManager = Event.EventManager()
self.onFlagUpdateNotify = Event.Event(self.__eventManager)
self.__marathons = [MarathonEvent(data) for data in MARATHONS_DATA]
def __init__(self):
super(EventsNotificationsController, self).__init__()
self.__eventMgr = Event.EventManager()
self.onEventNotificationsChanged = Event.Event(self.__eventMgr)
class GameSessionController(IGameSessionController, Notifiable):
NOTIFY_PERIOD = time_utils.ONE_HOUR
TIME_RESERVE = 59
PLAY_TIME_LEFT_NOTIFY = time_utils.QUARTER_HOUR + TIME_RESERVE
onClientNotify = Event.Event()
onTimeTillBan = Event.Event()
onNewDayNotify = Event.Event()
onPremiumNotify = Event.Event()
itemsCache = dependency.descriptor(IItemsCache)
lobbyContext = dependency.descriptor(ILobbyContext)
def init(self):
self.addNotificators(
PeriodicNotifier(self.__getClosestPremiumNotification,
self.__notifyPremiumTime),
PeriodicNotifier(lambda: self.NOTIFY_PERIOD, self.__notifyClient),
PeriodicNotifier(self.__getClosestNewDayNotification,
self.__notifyNewDay))
self.__sessionStartedAt = -1
self.__banCallback = None
self.__lastBanMsg = None
self.__curfewBlockTime = None
self.__curfewUnblockTime = None
self.__doNotifyInStart = False
self.__battles = 0
LOG_DEBUG('GameSessionController::init')
return
def fini(self):
LOG_DEBUG('GameSessionController::fini')
self._stop()
self.onClientNotify.clear()
self.onTimeTillBan.clear()
self.onNewDayNotify.clear()
self.onPremiumNotify.clear()
self.clearNotification()
super(GameSessionController, self).fini()
def onLobbyStarted(self, ctx):
LOG_DEBUG('GameSessionController::start', self.__sessionStartedAt)
self.__sessionStartedAt = ctx.get('sessionStartedAt', -1)
self.__curfewBlockTime, self.__curfewUnblockTime = self.__getCurfewBlockTime(
self._stats.restrictions)
if self.__doNotifyInStart:
self.__notifyClient()
self.startNotification()
self.__loadBanCallback()
g_clientUpdateManager.addCallbacks({
'account':
self.__onAccountChanged,
'stats.restrictions':
self.__onRestrictionsChanged,
'stats.playLimits':
self.__onPlayLimitsChanged
})
def onAvatarBecomePlayer(self):
self._stop(doNotifyInStart=True)
def onDisconnected(self):
self._stop()
def isSessionStartedThisDay(self):
svrDaysCount = int(_getSvrLocal()) / time_utils.ONE_DAY
clientDaysCount = int(
self.__sessionStartedAt +
self.__regionals().getDayStartingTime()) / time_utils.ONE_DAY
return svrDaysCount == clientDaysCount
def getDailyPlayTimeLeft(self):
return self._stats.getDailyTimeLimits() - self._getDailyPlayHours()
def getWeeklyPlayTimeLeft(self):
return self._stats.getWeeklyTimeLimits() - self._getWeeklyPlayHours()
@property
def isParentControlEnabled(self):
d, w = self._stats.getPlayTimeLimits()
return d < time_utils.ONE_DAY or w < 7 * time_utils.ONE_DAY
@property
def isParentControlActive(self):
playTimeLeft = min(
[self.getDailyPlayTimeLeft(),
self.getWeeklyPlayTimeLeft()])
parentControl = self.isParentControlEnabled and playTimeLeft <= self.PLAY_TIME_LEFT_NOTIFY
notifyTime, _ = self.getCurfewBlockTime()
banTimeLeft = min(*self.__getBlockTimeLeft())
curfewControl = self.__curfewBlockTime is not None and banTimeLeft <= self.PLAY_TIME_LEFT_NOTIFY
return parentControl or curfewControl
@property
def sessionDuration(self):
return _getSevUtc() - self.__sessionStartedAt
@property
def lastBanMsg(self):
return self.__lastBanMsg
@property
def battlesCount(self):
return self.__battles
@property
def isAdult(self):
return self.__curfewBlockTime is None
@property
def isPlayTimeBlock(self):
playTimeLeft, curfewTimeLeft = self.__getBlockTimeLeft()
return playTimeLeft < curfewTimeLeft
def incBattlesCounter(self):
self.__battles += 1
def getCurfewBlockTime(self):
if self.__curfewBlockTime is not None:
blockTime = self.__curfewBlockTime - self.__regionals(
).getDayStartingTime()
notifyStart = blockTime - self.PLAY_TIME_LEFT_NOTIFY
else:
notifyStart = blockTime = 0
return (_checkForNegative(notifyStart), _checkForNegative(blockTime))
def getParentControlNotificationMeta(self):
from gui.Scaleform.daapi.view.dialogs import I18nInfoDialogMeta
if self.isPlayTimeBlock:
return I18nInfoDialogMeta('koreaPlayTimeNotification')
else:
notifyStartTime, blockTime = self.getCurfewBlockTime()
def formatter(t):
return time.strftime('%H:%M', time.localtime(t))
return I18nInfoDialogMeta('koreaParentNotification',
messageCtx={
'preBlockTime':
formatter(notifyStartTime),
'blockTime':
formatter(blockTime)
})
@property
def _stats(self):
return self.itemsCache.items.stats
def _stop(self, doNotifyInStart=False):
LOG_DEBUG('GameSessionController::stop')
self.stopNotification()
self.__curfewBlockTime = None
self.__curfewUnblockTime = None
self.__sessionStartedAt = -1
self.__doNotifyInStart = doNotifyInStart
self.__clearBanCallback()
g_clientUpdateManager.removeObjectCallbacks(self)
return
def _getDailyPlayHours(self):
if self.isSessionStartedThisDay():
offset = _getSevUtc() - self.__sessionStartedAt
else:
offset = _getSvrLocal() % time_utils.ONE_DAY
return self._stats.todayPlayHours + offset
def _getWeeklyPlayHours(self):
regionals = self.__regionals()
weekDaysCount = account_shared.currentWeekPlayDaysCount(
_getSevUtc(), regionals.getDayStartingTime(),
regionals.getWeekStartingDay())
return self._getDailyPlayHours() + sum(
self._stats.dailyPlayHours[1:weekDaysCount])
def __regionals(self):
return self.lobbyContext.getServerSettings().regionals
@classmethod
def __getClosestNewDayNotification(cls):
return time_utils.ONE_DAY - _getSvrLocalToday()
def __getClosestPremiumNotification(self):
return time_utils.getTimeDeltaFromNow(
time_utils.makeLocalServerTime(self._stats.premiumExpiryTime))
def __getBlockTimeLeft(self):
playTimeLeft = min(self.getDailyPlayTimeLeft(),
self.getWeeklyPlayTimeLeft())
if self.__curfewBlockTime is not None:
curfewTimeLeft = self.__curfewBlockTime - _getSvrLocalToday()
else:
curfewTimeLeft = sys.maxint
return (playTimeLeft, _checkForNegative(curfewTimeLeft))
def __loadBanCallback(self, banTimeLeft=0):
self.__clearBanCallback()
if not banTimeLeft:
banTimeLeft = min(
*self.__getBlockTimeLeft()) - self.PLAY_TIME_LEFT_NOTIFY
banTimeLeft = max(banTimeLeft, 0)
LOG_DEBUG('Game session block callback', banTimeLeft)
if banTimeLeft:
self.__banCallback = BigWorld.callback(banTimeLeft,
self.__onBanNotifyHandler)
def __clearBanCallback(self):
if self.__banCallback is not None:
BigWorld.cancelCallback(self.__banCallback)
self.__banCallback = None
return
def __notifyClient(self):
if self.isParentControlEnabled:
playTimeLeft = min(
[self.getDailyPlayTimeLeft(),
self.getWeeklyPlayTimeLeft()])
playTimeLeft = max(playTimeLeft, 0)
else:
playTimeLeft = None
self.onClientNotify(self.sessionDuration,
time_utils.ONE_DAY - _getSvrLocalToday(),
playTimeLeft)
return
def __notifyNewDay(self):
self.onNewDayNotify(time_utils.ONE_DAY - _getSvrLocalToday())
def __notifyPremiumTime(self):
stats = self._stats
self.onPremiumNotify(stats.isPremium, stats.attributes,
stats.premiumExpiryTime)
def __onBanNotifyHandler(self):
LOG_DEBUG('GameSessionController:__onBanNotifyHandler')
banTime = time.strftime(
'%H:%M', time.localtime(time.time() + self.PLAY_TIME_LEFT_NOTIFY))
self.__lastBanMsg = (self.isPlayTimeBlock, banTime)
self.onTimeTillBan(*self.__lastBanMsg)
self.__loadBanCallback()
def __onAccountChanged(self, diff):
if 'attrs' in diff or 'premiumExpiryTime' in diff:
self.startNotification()
stats = self._stats
self.onPremiumNotify(stats.isPremium, stats.attributes,
stats.premiumExpiryTime)
def __onRestrictionsChanged(self, _):
self.__curfewBlockTime, self.__curfewUnblockTime = self.__getCurfewBlockTime(
self._stats.restrictions)
self.__loadBanCallback()
def __onPlayLimitsChanged(self, _):
self.__loadBanCallback()
@classmethod
def __getCurfewBlockTime(cls, restrictions):
if _BAN_RESTR in restrictions and len(restrictions[_BAN_RESTR]):
_, ban = max(restrictions[_BAN_RESTR].items(),
key=operator.itemgetter(0))
if ban.get(
'reason') == '#ban_reason:curfew_ban' and 'curfew' in ban:
return (ban['curfew'].get('from', time_utils.ONE_DAY) +
cls.TIME_RESERVE,
ban['curfew'].get('to', time_utils.ONE_DAY))
return (None, None)
def __init__(self, setup):
super(BattleFeedbackAdaptor, self).__init__()
self.__arenaDP = weakref.proxy(setup.arenaDP)
self.__arenaVisitor = weakref.proxy(setup.arenaVisitor)
self.__visible = set()
self.__pending = {}
self.__attrs = {}
self.__devInfo = {}
self.__eventsCache = {}
self.onPlayerFeedbackReceived = Event.Event()
self.onPlayerSummaryFeedbackReceived = Event.Event()
self.onPostmortemSummaryReceived = Event.Event()
self.onVehicleMarkerAdded = Event.Event()
self.onVehicleMarkerRemoved = Event.Event()
self.onVehicleFeedbackReceived = Event.Event()
self.onMinimapVehicleAdded = Event.Event()
self.onMinimapVehicleRemoved = Event.Event()
self.onMinimapFeedbackReceived = Event.Event()
self.onDevelopmentInfoSet = Event.Event()
self.onStaticMarkerAdded = Event.Event()
self.onStaticMarkerRemoved = Event.Event()
self.onRoundFinished = Event.Event()
self.onShotDone = Event.Event()
def __init__(self):
super(UserListModel, self).__init__()
self.onUserSelectionChanged = Event.Event()
self.onUserItemClicked = Event.Event()
def __init__(self):
super(ContactsTreeComponent, self).__init__()
self._mainDP = ContactsDataProvider()
self.onListStateChanged = Event.Event()
self.onGroupToggled = Event.Event()
def __init__(self):
self.__flagModelFile = None
self.__flagCircleModelFile = None
self.__flagAnimAction = None
self.__flags = {}
self.__flagTeams = []
self.__resourcePoints = {}
self.__rpGuids = {}
self.__resourcePointsLock = None
self.__delayedFlags = []
self.__evtManager = Event.EventManager()
self.onFlagSpawning = Event.Event(self.__evtManager)
self.onFlagSpawnedAtBase = Event.Event(self.__evtManager)
self.onFlagCapturedByVehicle = Event.Event(self.__evtManager)
self.onFlagDroppedToGround = Event.Event(self.__evtManager)
self.onFlagAbsorbed = Event.Event(self.__evtManager)
self.onFlagRemoved = Event.Event(self.__evtManager)
self.onCarriedFlagsPositionUpdated = Event.Event(self.__evtManager)
self.onFlagTeamsUpdated = Event.Event(self.__evtManager)
self.onResPointIsFree = Event.Event(self.__evtManager)
self.onResPointCooldown = Event.Event(self.__evtManager)
self.onResPointCaptured = Event.Event(self.__evtManager)
self.onResPointCapturedLocked = Event.Event(self.__evtManager)
self.onResPointBlocked = Event.Event(self.__evtManager)
self.onOwnVehicleInsideResPoint = Event.Event(self.__evtManager)
self.onOwnVehicleLockedForResPoint = Event.Event(self.__evtManager)
self.onResPointAmountChanged = Event.Event(self.__evtManager)
self.onHideAll = Event.Event(self.__evtManager)
self.__needHideAll = False
flagModelParams = _g_ctfConfig.readModelParams(_FLAG_MODEL_NAME)
if flagModelParams is not None:
self.__flagModelFile = flagModelParams.get('file')
self.__flagAnimAction = flagModelParams.get('action')
flagCircleModelParams = _g_ctfConfig.readModelParams(_FLAG_CIRCLE_MODEL_NAME)
if flagCircleModelParams is not None:
self.__flagCircleModelFile = flagCircleModelParams.get('file')
return
def __init__(self, account=None):
self.__account = account
self.__eManager = Event.EventManager()
GlobalMapBase.__init__(self)
self.__requestID = 0
class VoiceChatManager(VoiceChatManagerMeta):
class PROVIDERS(CONST_CONTAINER):
UNKNOWN = 'unknown'
VIVOX = 'vivox'
YY = 'YY'
onPlayerSpeaking = Event.Event()
onStateToggled = Event.Event()
def __init__(self, app):
super(VoiceChatManager, self).__init__()
self.__app = app
self.__failedEventRaised = False
self.__callbacks = []
self.__captureDevicesCallbacks = []
self.__pendingMessage = None
self.__enterToLobby = False
return
def __initResponse(self, _):
self.__showChatInitSuccessMessage()
while len(self.__callbacks):
self.__callbacks.pop(0)(self.ready)
def __captureDevicesResponse(self):
devices = getVOIPManager().getCaptureDevices()
while len(self.__captureDevicesCallbacks):
self.__captureDevicesCallbacks.pop(0)(devices)
def __showChatInitSuccessMessage(self):
if GUI_SETTINGS.voiceChat and not BattleReplay.isPlaying():
if self.__failedEventRaised and self.ready:
self.__failedEventRaised = False
self.__pendingMessage = None
if self.__enterToLobby:
self.__showDialog('voiceChatInitSucceded')
return
def __showChatInitErrorMessage(self):
if GUI_SETTINGS.voiceChat and not BattleReplay.isPlaying():
if not self.__failedEventRaised and not self.ready:
self.__failedEventRaised = True
if self.__enterToLobby:
self.__showDialog('voiceChatInitFailed')
else:
self.__pendingMessage = 'voiceChatInitFailed'
def _populate(self):
super(VoiceChatManager, self)._populate()
g_playerEvents.onAccountBecomePlayer += self.onAccountBecomePlayer
self.__app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
voipMgr = getVOIPManager()
voipMgr.onInitialized += self.__initResponse
voipMgr.onFailedToConnect += self.checkForInitialization
voipMgr.OnCaptureDevicesUpdated += self.__captureDevicesResponse
voipMgr.onPlayerSpeaking += self.__onPlayerSpeaking
voipMgr.onStateToggled += self.__onStateToggled
def _dispose(self):
self.__callbacks = None
self.__captureDevicesCallbacks = None
containerMgr = self.__app.containerManager
if containerMgr:
containerMgr.onViewAddedToContainer -= self.__onViewAddedToContainer
voipMgr = getVOIPManager()
voipMgr.onFailedToConnect -= self.checkForInitialization
voipMgr.onPlayerSpeaking -= self.__onPlayerSpeaking
voipMgr.onInitialized -= self.__initResponse
voipMgr.OnCaptureDevicesUpdated -= self.__captureDevicesResponse
voipMgr.onStateToggled -= self.__onStateToggled
g_playerEvents.onAccountBecomePlayer -= self.onAccountBecomePlayer
super(VoiceChatManager, self)._dispose()
self.__app = None
return
def checkForInitialization(self, *args):
self.__showChatInitErrorMessage()
@property
def state(self):
return getVOIPManager().getState()
@property
def ready(self):
return getVOIPManager().isInitialized()
@process
def onAccountBecomePlayer(self):
yield self.initialize(BigWorld.player().serverSettings['voipDomain'])
yield self.requestCaptureDevices(True)
@async
def initialize(self, domain, callback):
if self.ready:
vOIPSetting = g_settingsCore.options.getSetting('enableVoIP')
vOIPSetting.initFromPref()
callback(True)
return
if domain == '':
LOG_WARNING('Initialize. Vivox is not supported')
return
self.__callbacks.append(callback)
voipMgr = getVOIPManager()
if voipMgr.isNotInitialized():
voipMgr.initialize(domain)
vOIPSetting = g_settingsCore.options.getSetting('enableVoIP')
vOIPSetting.initFromPref()
@async
def requestCaptureDevices(self, firstTime=False, callback=None):
if getVOIPManager().getVOIPDomain() == '':
LOG_WARNING('RequestCaptureDevices. Vivox is not supported')
callback([])
return
if not self.ready:
LOG_WARNING(
'RequestCaptureDevices. Vivox has not been initialized')
callback([])
return
def resetCapturedDevice(devices, firstTime=firstTime):
if firstTime:
option = g_settingsCore.options.getSetting(
SOUND.CAPTURE_DEVICES)
option.apply(option.get(), firstTime)
callback(devices)
self.__captureDevicesCallbacks.append(resetCapturedDevice)
getVOIPManager().requestCaptureDevices()
def getPlayerDBID(self):
p = BigWorld.player()
if isPlayerAccount():
return p.databaseID
elif isPlayerAvatar() and hasattr(p, 'playerVehicleID'):
return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None)
else:
return None
def __onPlayerSpeaking(self, accountDBID, isSpeak):
if not GUI_SETTINGS.voiceChat:
return
self.onPlayerSpeaking(accountDBID, bool(isSpeak))
self.as_onPlayerSpeakS(accountDBID, isSpeak,
accountDBID == self.getPlayerDBID())
def __onStateToggled(self, isEnabled, _):
if not GUI_SETTINGS.voiceChat:
return
self.onStateToggled(isEnabled)
def isPlayerSpeaking(self, accountDBID):
if GUI_SETTINGS.voiceChat:
return bool(getVOIPManager().isParticipantTalking(accountDBID))
return False
def isVivox(self):
return getVOIPManager().getAPI() == VOIP_SUPPORTED_API.VIVOX
def isYY(self):
return getVOIPManager().getAPI() == VOIP_SUPPORTED_API.YY
@property
def provider(self):
if self.isVivox():
return self.PROVIDERS.VIVOX
if self.isYY():
return self.PROVIDERS.YY
return self.PROVIDERS.UNKNOWN
def isVOIPEnabled(self):
return GUI_SETTINGS.voiceChat
def __onViewAddedToContainer(self, _, pyView):
settings = pyView.settings
viewType = settings.type
if viewType == ViewTypes.DEFAULT:
viewAlias = settings.alias
if viewAlias == VIEW_ALIAS.LOBBY:
self.__enterToLobby = True
if self.__pendingMessage is not None:
self.__showDialog(self.__pendingMessage)
self.__pendingMessage = None
else:
self.__enterToLobby = False
return
def __showDialog(self, key):
DialogsInterface.showI18nInfoDialog(key, lambda result: None)
def __init__(self):
super(ServerStats, self).__init__()
self.__statsCallbackID = None
self.__stats = {}
self.onStatsReceived = Event.Event()
return
elif cmd[0] == 'u' or cmd[0] == 'urgent':
if scheduler.urgent(cmd[1]):
print 'event ', cmd[1], 'is elevated to urgent.\n'
else:
print 'failed to elevated event ', cmd[1], ' to urgent.\n'
elif cmd[0] == 'p' or cmd[0] == 'print':
print 'Previous queue status:\n'
i = 0
while i < len(scheduler._queue):
print scheduler._queue[i]
i += 1
elif cmd[0] == 'test':
print 'Add a test event to queue\n'
event = Event.E_Test().Gen_Event()
scheduler.enter(*event)
elif cmd[0] == 'oav1':
print 'Add an offav event with default args to queue\n'
event = Event.E_StartOffAV().Gen_Event()
scheduler.enter(*event)
elif cmd[0] == 'oav2':
print 'Add an offav event with different args to queue\n'
vm_profile = VM_Profile('instance-00000001', 'user-0002',
'host-0003')
event = Event.E_StartOffAV([[
vm_profile,
], {
'avSoft': 'ClamAV',
class LoaderManager(LoaderManagerMeta):
eManager = Event.EventManager()
onViewLoadInit = Event.Event(eManager)
onViewLoaded = Event.Event(eManager)
onViewLoadError = Event.Event(eManager)
def __init__(self, app):
super(LoaderManager, self).__init__()
self.__app = app
self.__nameToLoadingItem = {}
def loadView(self, alias, name, *args, **kwargs):
return self.__doLoadView(alias, name, *args, **kwargs)
def isViewLoading(self, viewAlias):
result = False
for item in self.__nameToLoadingItem.itervalues():
pyEntity = item.pyEntity
if pyEntity and pyEntity.settings.alias == viewAlias:
result = True
break
return result
def viewLoaded(self, name, gfxEntity):
if name in self.__nameToLoadingItem:
item = self.__nameToLoadingItem.pop(name)
pyEntity = g_entitiesFactories.initialize(
item.pyEntity,
gfxEntity,
item.factoryIdx,
extra={'name': item.name})
if pyEntity is not None:
self.onViewLoaded(pyEntity)
else:
LOG_ERROR('Error during until DAAPI initializing.')
else:
LOG_ERROR('View load for name has no associated data', name)
def viewLoadError(self, alias, name, errorTxt):
msg = 'Error during view {0} load. Name: {1}, error:{2}'
msg = msg.format(alias, name, errorTxt)
LOG_ERROR(msg)
item = None
if name in self.__nameToLoadingItem:
item = self.__nameToLoadingItem.pop(name)
self.onViewLoadError(name, msg, item)
if item is not None:
settings = item.pyEntity.settings
if constants.IS_DEVELOPMENT and settings.url != NO_IMPL_URL:
g_entitiesFactories.addSettings(
ViewSettings(NO_IMPL_ALIAS, View, NO_IMPL_URL,
settings.type, None,
ScopeTemplates.DEFAULT_SCOPE))
LOG_WARNING('Try to load noImpl swf...')
self.__doLoadView(NO_IMPL_ALIAS, item.name)
def cancelLoadingByName(self, name):
if name in self.__nameToLoadingItem:
self.__nameToLoadingItem.pop(name)
def viewInitializationError(self, config, alias, name):
msg = "View '{0}' does not implement net.wg.infrastructure.interfaces.IView"
msg = msg.format(alias)
LOG_ERROR(msg)
item = None
if name in self.__nameToLoadingItem:
item = self.__nameToLoadingItem.pop(name)
pyEntity = item.pyEntity
pyEntity.destroy()
self.onViewLoadError(name, msg, item)
def _dispose(self):
self.__app = None
self.__nameToLoadingItem.clear()
self.eManager.clear()
super(LoaderManager, self)._dispose()
def __doLoadView(self, alias, name, *args, **kwargs):
viewTutorialID = self.__app.tutorialManager.getViewTutorialID(alias)
if name in self.__nameToLoadingItem:
item = self.__nameToLoadingItem[name]
self.as_loadViewS(item.pyEntity.settings._asdict(), alias, name,
viewTutorialID)
return item.pyEntity
else:
pyEntity, factoryIdx = g_entitiesFactories.factory(
alias, *args, **kwargs)
if pyEntity is not None:
pyEntity.setUniqueName(name)
pyEntity.seEnvironment(self.__app)
self.__nameToLoadingItem[name] = _LoadingItem(
name, pyEntity, factoryIdx, args, kwargs)
self.onViewLoadInit(pyEntity)
self.as_loadViewS(pyEntity.settings._asdict(), alias, name,
viewTutorialID)
return pyEntity
LOG_WARNING('PyEntity for alias %s is None' % alias)
return
def __init__(self, connection, clan_conference):
Entity.__init__(self, connection, TYPE_SESSION)
self.clan_conference = clan_conference
self.eventMessage = Event.Event()
self.eventFriendOnline = Event.Event()
self.eventFriendOffline = Event.Event()
def __init__(self):
self.onTimeWarpStart = Event.Event()
self.onTimeWarpFinish = Event.Event()
self.onPause = Event.Event()
self.onMuteSound = Event.Event()
self.onWatcherNotify = Event.Event()
def __init__(self):
self.__space = None
self.__videoCameraController = HangarVideoCameraController()
self.__inited = False
self.__spaceInited = False
self.__isModelLoaded = False
self.__isSpacePremium = False
self.__igrSpaceType = constants.IGR_TYPE.NONE
self.__delayedIsPremium = False
self.__delayedForceRefresh = False
self.__delayedRefreshCallback = None
self.__spaceDestroyedDuringLoad = False
self.__lastUpdatedVehicle = None
self.onSpaceRefresh = Event.Event()
self.onSpaceRefreshCompleted = Event.Event()
self.onSpaceCreating = Event.Event()
self.onSpaceCreate = Event.Event()
self.onSpaceDestroy = Event.Event()
self.onSpaceChanged = Event.Event()
self.onMouseEnter = Event.Event()
self.onMouseExit = Event.Event()
self.onMouseDown = Event.Event()
self.onMouseUp = Event.Event()
self.onHeroTankReady = Event.Event()
self.onVehicleChanged = Event.Event()
self.onVehicleChangeStarted = Event.Event()
self.onSpaceChangedByAction = Event.Event()
self.onNotifyCursorOver3dScene = Event.Event()
self.__isCursorOver3DScene = False
return
