def sniffing(self):
self.positionVector.x += self.movementSpeed
if self.positionVector.x > 300:
Sound.play(Sounds.SzczekTwo)
self.dogState = DogState.JUMPING
self.currentImageSet = self.spriteMap[DogAnimationState.JUMP]
return None
def tick(self):
super().tick()
if self.start:
Sound.play(Sounds.DogSniff)
self.start = False
if self.dogState == DogState.SNIFFING:
self.sniffing()
return None
if self.dogState == DogState.JUMPING:
self.jumping()
return None
if self.dogState == DogState.HIDDEN:
self.hidden()
return None
if self.dogState == DogState.HOLD_ONE:
self.holdone()
return None
if self.dogState == DogState.HOLD_TWO:
self.holdtwo()
return None
if self.dogState == DogState.LAUGHING:
self.laughing()
return None
def shot(self):
if self.stoper.getCurrentTicks() - self.lastStateChanged > 500:
self.duckState = DuckState.FALLING
self.currentImageSet = self.spriteMap[DuckAnimationState.FALLING]
self.setDirectionFromAngle(90)
self.movementSpeed = 0.15
Sound.play(Sounds.Falling)
return None
def flying(self):
self.performTimeSynchronizedMove()
self.checkForCollisionWithWall()
# make duck flying pattern more random
if self.stoper.getCurrentTicks(
) - self.lastDirectionChange > self.flyingDirectionChangeThreshold:
self.setRandomAngle()
self.lastDirectionChange = self.stoper.getCurrentTicks()
self.flyingDirectionChangeThreshold = randint(1000, 5000)
if self.stoper.getCurrentTicks(
) - self.lastQuacked > self.quackingThreshold:
Sound.play(Sounds.Quack)
self.quackingThreshold = randint(1000, 8000)
self.lastQuacked = self.stoper.getCurrentTicks()
class Grenade(object):
def __init__(self,damage=4):
self.name="Grenade"
self.damage=damage
self.boomSound=Sound().weaponSounds("Grenade")
#*************************************
#RETURN CLASS VARIABLES
#*************************************
def playSound(self):
return self.boomSound.play()
def explode(self):
return self.damage
def getName(self):
return self.name
class Key(Image):
def __init__(self, fileName, x, y, polygon, game):
"""
Initialize a Key
@param self -- the key
@param fileName -- a string that contains the image name
@param x -- a horizontal position of key
@param y -- a vertical position of key
@param polygon -- a list of (x,y) pairs
@param game -- the game
"""
self.image = pygame.image.load("image/key/" + fileName + ".png")
self.image.set_alpha(None) # disable alpha.
self.image.convert()
self.image.set_colorkey((255, 0, 255)) # magenta
self.imageHover = pygame.image.load("image/keyHover/" + fileName +
".png")
self.imageHover.set_alpha(None) # disable alpha.
self.imageHover.convert()
self.imageHover.set_colorkey((255, 0, 255)) # magenta
self.imageDown = pygame.image.load("image/keyDown/" + fileName +
".png")
self.imageDown.set_alpha(None) # disable alpha.
self.imageDown.convert()
self.imageDown.set_colorkey((255, 0, 255)) # magenta
self.id = int(fileName)
self.fileName = fileName
self.sound = Sound()
self.sound.setFileName("sound/notes/T" + str(int(fileName) + 3))
self.x = x
self.y = y
self.polygon = polygon
self.isHover = False
self.isDown = False
self.isVisible = True
self.mouseInside = False
self.game = game
def mouseHover(self):
"""
When the mouse is hover on the Key
@param self -- the key
"""
self.isHover = True
if os.path.exists("sound/notes/T" + str(self.id + 3) + ".ogg"):
self.sound.play()
def mouseDown(self):
"""
When the mouse is down the Key
@param self -- the key
"""
self.isDown = True
if os.path.exists("sound/notes/T" + str(self.id + 3) + ".ogg"):
self.sound.play()
self.game.attempt(self.id)
class Game(object):
def __init__(self):
pygame.init()
self.SCREEN_WIDTH = 800
self.SCREEN_HEIGHT = 600
self.display = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
pygame.display.set_caption("DoocHunt")
pygame.mouse.set_visible(False)
self.stoper = Stoper()
self.sound = Sound()
self.ui = UserInterface(self.display)
self.run = True
self.crosshair = Crosshair(self.display, self.SCREEN_WIDTH, self.SCREEN_HEIGHT)
self.ducks = []
self.groundImage = pygame.image.load("images/ground.png")
self.tree = pygame.image.load("images/tree.png")
self.duckSpriteRepository = DuckSpriteSetRepository()
self.dogSpriteSetRepository = DogSpriteSetRepository()
self.gameState = GameState.GAME_STARTING
self.dog = Dog(self.display, self.stoper, self.dogSpriteSetRepository.getCollection())
self.level = 0
self.ammoCount = self.level + 2
self.duckCount = self.level + 1
def __handle_event(self, event):
if event.type == pygame.QUIT:
self.run = False
if event.type == pygame.MOUSEBUTTONDOWN:
if self.gameState == GameState.ACTIVE_GAME:
mx, my = pygame.mouse.get_pos()
self.sound.play(Sounds.GunShot)
self.ammoCount -= 1
self.ui.set_value(self.ammoCount, UIValues.AMMO)
for duck in self.ducks:
if duck.checkIfShot(mx, my):
self.ui.add_to_value(1, UIValues.DUCKS_SHOT)
self.ui.add_to_value(500*self.level, UIValues.SCORE)
def main_loop(self):
while self.run:
self.stoper.newTick()
self.crosshair.move(pygame.mouse.get_pos())
if self.gameState == GameState.GAME_STARTING:
self.game_starting()
if self.gameState == GameState.ROUND_STARTING:
self.round_starting()
if self.gameState == GameState.ACTIVE_GAME:
self.active_game()
if self.gameState == GameState.ROUND_END:
self.round_end()
if self.gameState == GameState.GAME_END:
self.game_end()
if self.gameState == GameState.DOG_ANIMATION:
self.dog_animation()
self.render_and_display_frame()
for event in pygame.event.get():
self.__handle_event(event)
return None
def render_and_display_frame(self):
self.render_background()
self.render_ducks()
self.render_bush()
self.dog.render()
self.crosshair.render()
self.ui.render_ui()
pygame.display.update()
def spawn_duck(self, level):
color = random.choice(list(DuckColor))
x = randint(self.SCREEN_WIDTH * 0.1, self.SCREEN_WIDTH * 0.9)
y = randint(self.SCREEN_HEIGHT * 0.1, self.SCREEN_HEIGHT * 0.6)
self.ducks.append(Duck(self.display, self.stoper, pygame.Vector2(x, y), self.duckSpriteRepository.getCollectionForColor(color), level))
def render_ducks(self):
for duck in self.ducks:
duck.render()
def render_background(self):
blue = (60, 80, 150) #TODO: background
self.display.fill(blue)
return None
def render_bush(self):
rect = self.groundImage.get_rect()
self.display.blit(self.groundImage, (0, self.SCREEN_HEIGHT - rect.height))
def setup_round(self, level):
self.ducks.clear()
self.ammoCount = level + 2
self.duckCount = level + 1
self.ui.set_value(self.ammoCount, UIValues.AMMO)
self.ui.set_value(0, UIValues.DUCKS_SHOT)
self.ui.set_value(self.duckCount, UIValues.DUCKS_IN_ROUND)
self.ui.set_value(self.level, UIValues.ROUND)
for i in range(self.duckCount):
self.spawn_duck(level)
return None
# state impementations
def game_starting(self):
self.dog.tick()
if self.dog.finishedMovement:
self.gameState = GameState.ACTIVE_GAME
pass
def round_starting(self):
self.setup_round(self.level)
self.gameState = GameState.ACTIVE_GAME
pass
def active_game(self):
for duck in self.ducks:
duck.tick()
if (self.ammoCount == 0) or (self.ui.ducks_shot == self.ui.ducks_in_round):
self.gameState = GameState.ROUND_END
pass
def round_end(self):
# Dog laughing/happy animation
for duck in self.ducks:
if duck.duckState == DuckState.FLYING:
duck.flyAway()
self.ui.add_to_value(1, UIValues.DUCKS_FLEW)
duck.tick()
if all(duck.duckState == DuckState.ESCAPED or duck.duckState == DuckState.DEAD for duck in self.ducks):
if self.level == 0:
self.gameState = GameState.ROUND_STARTING
else:
escaped_ducks = 0
for duck in self.ducks:
if duck.duckState == DuckState.ESCAPED:
escaped_ducks += 1
if escaped_ducks > 0:
self.dog.dogState = DogState.LAUGHING
self.gameState = GameState.DOG_ANIMATION
else:
self.dog.dogState = DogState.HOLD_TWO
self.gameState = GameState.DOG_ANIMATION
self.level += 1
pass
def game_end(self):
assert False
def dog_animation(self):
self.dog.tick()
if self.dog.have_finished_movement():
self.gameState = GameState.ROUND_STARTING
class Stone(Image):
def __init__(self, fileName, x, y, polygon, game):
"""
Initialize a Stone
@param self -- the stone
@param fileName -- a string that contains the image name
@param x -- a horizontal position of stone
@param y -- a vertical position of stone
@param polygon -- a list of (x,y) pairs
@param game -- the game
"""
self.image = pygame.image.load("image/" + fileName + ".png")
self.image.set_alpha(None) # disable alpha.
self.image.convert()
self.image.set_colorkey((255, 0, 255)) # magenta
self.fileName = fileName
self.x = x
self.y = y
self.polygon = polygon
self.game = game
self.isHover = False
self.isDown = False
self.isVisible = False
self.mouseInside = False
def setSound(self, id):
"""
Set a stone sound
@param self -- the stone
@param id -- a number that represents the ball note
"""
self.id = id
self.sound = Sound()
self.sound.setFileName("sound/notes/T" + str(self.id + 3))
def mouseHover(self):
"""
When the mouse is hover on the stone
@param self -- the stone
"""
self.isHover = True
self.game.setEarCursorVisible(True)
self.game.setHelp()
if self.game.lampIsSelected():
self.game.setLampCursorVisible(False)
self.button.mouseHover()
self.help.setVisible(True)
else:
if os.path.exists("sound/notes/T" + str(self.id + 3) + ".ogg"):
self.sound.play()
def mouseLeave(self):
"""
When the mouse leaves the stone
@param self -- the stone
"""
self.isHover = False
self.game.setEarCursorVisible(False)
if self.game.lampIsSelected():
self.game.setLampCursorVisible(True)
self.button.mouseLeave()
self.help.setVisible(False)
def draw(self, screen):
"""
Draw the stone on the screen
@param self -- the stone
@param screen -- the screen where the images will be showed
"""
if self.isVisible:
screen.blit(self.image, (self.x, self.y))
def setButton(self, button):
"""
Set a related button
@param self -- the stone
@param button -- it relates a button with the stone
"""
self.button = button
def setHelp(self, help):
"""
Set a related help
@param self -- the stone
@param help -- it relates a help with the stone
"""
self.help = help
class Sectoid(object):
def __init__(self,name,hp=8,taunt=0,defense=10,cover=0,aimPen=0):
self.name=name
self.hp=hp
self.playerTaunt=taunt
self.alive=1
self.defense=defense
self.cover=cover
self.aimPenalty=aimPen
self.coverPosition=0
self.wepSound=Sound().weaponSounds("Laser")
self.deathSound=Sound().deathSounds("Sectoid")
self.tauntSound=Sound().abilitySounds("Taunt")
self.uponHit=Sound().enemyPainSounds("Sectoid")
#***********************************************************************
#ACTIONS ALIEN CAN TAKE
#***********************************************************************
def action(self):
action=0
tRNG=random.randint(1,5)
if tRNG==1:
action="taunt"
else:
action="shoot"
return action
def taunt(self):
self.tauntSound.play()
print ('{name} taunts you! \n It yells, "Gleep gloop!\n"'.format(name=self.name))
pissOff=1
return pissOff
def takeCover(self,alienBattleMap,pod,whichAlien):
alienChooseCover=Sectoid.randomSample(alienBattleMap,pod,whichAlien)
self.cover=alienBattleMap[alienChooseCover].getCovValue()
self.aimPenalty=alienBattleMap[alienChooseCover].getAimPen()
self.coverPosition=alienChooseCover
return self.cover, self.aimPenalty,self.coverPosition
def shoot(self,playerDef):
targetHit=0
print ("{NAME} shoots!\n".format(NAME=self.name))
self.wepSound.play()
adjustedHitChance=Sectoid.calcHitChance(self,playerDef)
hitCoverRNG=random.randint(1,2)
RNG=random.randint(1,100)
if RNG <= adjustedHitChance:
print ("Alien Chance to Hit: ", adjustedHitChance)
print ("Alien's Roll: ", RNG,"\n")
print ("Ouch! You're hit!\n")
targetHit=1
else:
if hitCoverRNG==1:
print ("Alien Chance to Hit: ", adjustedHitChance)
print ("Alien's Roll: ", RNG,"\n")
targetHit=3
else:
print ("Alien Chance to Hit: ", adjustedHitChance)
print ("Alien's Roll: ", RNG,"\n")
print ("It misses!\n")
targetHit=2
return targetHit
#******************************************************
#RNG FOR COVER SELECTION
#***************************************************
def randomCoverType(alienBattleMap):
typeRNG=random.randrange(len(alienBattleMap))
x=typeRNG
return x
def randomSample(alienBattleMap,pod,whichAlien):
mapRNG=random.randrange(len(alienBattleMap))
answer=mapRNG
return answer
#************************************************
#ALIEN STAT CALCULATION
#*************************************************
def getDefense(self):
defense=self.defense+self.cover
return defense
def damage(self,DMGval):
if self.hp > self.hp-DMGval:
self.uponHit.play()
self.hp-=DMGval
if self.hp <=0:
self.hp=0;
if self.hp > 0:
self.action
if self.hp==0:
print ("You killed it!")
return self.hp
def calcHitChance(self,playerDef):
baseHitChance=80
adjustedHitChance=baseHitChance-playerDef-self.aimPenalty
if adjustedHitChance<0:
adjustedHitChance=0
if adjustedHitChance>100:
adjustedHitChance=100
return adjustedHitChance
#************************************************************
#RETURN CLASS VARIABLES
#************************************************************
def __repr__(self):
return self.name
def __str__(self):
return self.name
def getName(self):
return self.name
def getHP(self):
return self.hp
def returnCoverPosition(self):
return self.coverPosition
def returnCoverValue(self):
if self.cover==40:
cover="High cover"
elif self.cover==20:
cover="Low cover"
else:
cover="No cover"
return cover
def playAlienDeath(self):
self.deathSound.play()
def playHitSound(self):
self.uponHit.play()
from Sound import Sound
s = Sound('sounds/symphony.wav')
s.play()
while True:
pass
class Player(object):
def __init__(self,weapons=[],hp=20,imparement=0,defense=30,buff=0):
self.name="Trooper"
self.hp=hp
self.imparement=imparement
self.inventory=[Grenade(),Grenade(),Grenade(),Grenade(),Healing("Medkit",10),Healing("Medkit",10)]
self.ammoBelt=None
self.seconaryAmmoBelt=None
self.defense=defense
self.aimPenalty=0
self.coverPosition=0
self.buff=buff
self.weapons=weapons
self.cover=0
self.currentWeapon=None
self.deathSound=Sound().deathSounds("Player")
#************************************************************************************
#ACTIONS PLAYER CAN TAKE
#************************************************************************************
def changeCover(self,playerBattleMap):
coverSet=0
while coverSet==0:
for each in playerBattleMap:
print (each+1,": Cover Value:",playerBattleMap[each].getCovValue()," Aim Penalty:",playerBattleMap[each].getAimPen()," Cover HP:",playerBattleMap[each].getHP())
try:
chooseCover=(int(input("Which cover do you take?"))-1)
except:
print ("That's not a valid option, try again.\n\n")
continue
if chooseCover in playerBattleMap:
playerCover=playerBattleMap[chooseCover].getCovValue()
playerAimPen=playerBattleMap[chooseCover].getAimPen()
self.cover=playerCover
playerCovPos=chooseCover
self.defense=30
self.defense=self.defense+playerCover
self.aimPenalty=playerAimPen
self.coverPosition=playerCovPos
coverSet=1
else:
print ("That's not a valid cover option")
continue
def gunshotAccuracy(self,enemyDef,alienBattleMap,coverPosition):
#taunted/pissed off is 1. # calculates shot%, factoring in cover and any status ailments
targetHit=0
pissedOff=0
takingAim=0
#print ("DEBUG*** This is the status element= ",self.imparement)
#print ("DEBUG*** this is your buff number: ",self.buff)
if self.imparement==1:
pissedOff=20
if self.buff==1:
takingAim=-50
print ("BANG!")
baseHitChance=self.currentWeapon.getAcc()
#print (baseHitChance,enemyDef,self.aimPenalty,pissedOff,takingAim," ",baseHitChance-enemyDef-self.aimPenalty-pissedOff-takingAim)
adjustedHitChance=baseHitChance-enemyDef-self.aimPenalty-pissedOff
if adjustedHitChance<0:
adjustedHitChance=0
if adjustedHitChance>100:
adjustedHitChance=100
adjustedHitChance-=takingAim
print ("Chance to hit: ", adjustedHitChance)
hitCoverRNG=random.randint(1,2)
RNG=random.randint(1,100)
if RNG <= adjustedHitChance:
print ("Hit Roll: ", RNG,"\n")
print ("That's a hit!")
targetHit=1
else:
if hitCoverRNG==1:
print ("Hit Roll: ", RNG,"\n")
targetHit=3
else:
print ("Hit Roll: ", RNG,"\n")
#print ("Damn, you missed!")"
targetHit=2
return targetHit
#this is some of the oldest code in the program, likely a shitshow.
def useItem(self):
for idx,item in enumerate(self.inventory):
idx+=1
print(idx,item)
item=(input("Which item do you want to use?"))
if item=="B" or item=="b":
print ("Nope")
os.system('cls' if os.name=='nt' else 'clear')
return
else:
try:
item=(int(item))
except:
print ("not a number")
os.system('cls' if os.name=='nt' else 'clear')
return
if item >=1:
item-=1
if item not in range(len(self.inventory)):
print ("Not a valid item number, pick another or hit B to go back:")
os.system('cls' if os.name=='nt' else 'clear')
return
sendItem=self.inventory[item]
return sendItem,item
def switchWeapons(self):
if self.currentWeapon==self.weapons[0]:
self.currentWeapon=self.weapons[1]
print (self.currentWeapon)
elif self.currentWeapon==self.weapons[1]:
self.currentWeapon=self.weapons[0]
print(self.currentWeapon)
#make this adaptable to more than 2 weapons later on
def hunkerDown(self):
self.defense+=30
def takeAim(self,playerBuff):
self.buff+=playerBuff
def getSpecificAmmoBelt(self):
if self.currentWeapon==self.weapons[0]:
return 0
elif self.currentWeapon==self.weapons[1]:
return 1
def reloadGun(self,pick):
x=0
if self.currentWeapon==self.weapons[1]:
x=1
newMag=self.ammoBelt[x].removeMag(pick)
oldMag=self.currentWeapon.reload(newMag)
self.ammoBelt[x].changeMag(oldMag)
#**************************************************
#ALTER YOUR STATS (HP/DEF/AIM/STATUS)
#**************************************************
def setDefense(self,playerCoverBonus):
self.defense=30
self.defense=self.defense+playerCoverBonus
def setAimPen(self,playerAimPen):
self.aimPenalty=0
self.aimPenalty=self.aimPenalty+playerAimPen
def status(self,ailment):
#status aliments, good and ill, will check here to see if they pass or fail
#taunt is 1, resisted is 0
inflicted=0
checking=ailment
baseResist=70
rRNG=random.randint(1,100)
if rRNG <= baseResist:
if checking==1:
self.imparement=1
return self.imparement
def healing(self,amount):
self.hp+=amount
if self.hp >= 20:
self.hp = 20
return self.hp
def damage(self,damage):
self.hp-=damage
if self.hp <=0:
self.hp=0
return self.hp
def turnPass(self,turn):
if self.imparement!=0:
self.imparement=0
return self.imparement
def tickAimTimerDown(self,timeTick):
self.buff=self.buff-timeTick
if self.buff<0:
self.buff=0
#ticks down aiming so it only lasts a certain number of turns.
#*********************************************
# EQUIPS PLAYER ITEMS AND WEAPONS
#*********************************************
def playerWeapons(self,selectedWeapons):
self.weapons=selectedWeapons
self.currentWeapon=self.weapons[0]
def equipAmmoBelt(self,belts):
self.ammoBelt=belts
def removeItem(self,item):
self.inventory.pop(item)
#***********************************
#RETURN CLASS VARIABLES
#***********************************
def getName(self):
return self.name
def getCoverPosition(self):
return self.coverPosition
def getHP(self):
return self.hp
def returnDef(self):
return self.defense
def playDeathSound(self):
self.deathSound.play()
def returnPlayerWeapons(self):
return self.weapons
#***********************************
#RETURN WEAPON VARIABLES
#***********************************
def returnWepDamage(self):
return self.weapons[0].getDamage()
def returnWeaponNames(self):
return self.weapons[0].getName(), self.weapons[1].getName()
def getCurrentPlayerWeapon(self):
return self.currentWeapon
#***********************************
#RETURN AMMO BELT VARIABLES
#***********************************
def getBackupMags(self):
return self.ammoBelt[0].getMags(), self.ammoBelt[1].getMags()
#gets how many magazines there are in each belt
def getBackupMagAmount(self):
return self.ammoBelt[0].getMagNumber(), self.ammoBelt[1].getMagNumber()
#gets number of bullets in each magazine in the ammo belt
def getBackupMagsName(self):
primMagName=self.ammoBelt[0].getMags()
primMagName=(str(primMagName)[2:-2])
secMagName=self.ammoBelt[1].getMags()
secMagName=(str(secMagName)[2:-2])
return primMagName,secMagName
#Gets the names of the ammo belts and cuts off list brackets
#***********************************
#RETURN STATUS VARIABLES
#***********************************
def getCoverValue(self):
if self.cover==40:
cover="High cover"
elif self.cover==20:
cover="Low cover"
else:
cover="No cover"
return cover
def getTauntStatus(self):
if self.imparement==1:
returnPrint=("taunted")
else:
returnPrint=("not taunted")
return returnPrint
def getAimStatus(self):
if self.buff==1:
returnAim=("taking aim")
else:
returnAim=("not taking aim")
return returnAim
def getHitChance(self,targetInfo):
#largely copied code. Consolidate gunshot acc and this somehow
targetHit=0
pissedOff=0
takingAim=0
#print ("DEBUG*** This is the status element= ",self.imparement)
#print ("DEBUG*** this is your buff number: ",self.buff)
if self.imparement==1:
pissedOff=20
if self.buff==1:
takingAim=-50
baseHitChance=self.currentWeapon.getAcc()
adjustedHitChance=baseHitChance-targetInfo-self.aimPenalty-pissedOff
adjustedHitChance-=takingAim
if adjustedHitChance<0:
adjustedHitChance=0
if adjustedHitChance>100:
adjustedHitChance=100
return adjustedHitChance
#***********************************
#RETURN ITEM OBJECT VARIABLES
#***********************************
def getInventory(self):
return self.inventory
def getSpecificInventoryItem(self,item):
print (self.inventory[item])
return self.inventory[item]
def getItemNames(self,itemNum):
return self.inventory[itemNum].getName()
def userPainSound():
painRNG=random.randrange(1,9)
pain=Sound().userPainSounds(painRNG)
pain.play()
def play_sound(self, sound_name):
sound = Sound(sound_name)
sound.play()
class Prospecting():
def __init__(self):
self.connected = False
self.gui_init = False
self.msg_send = False
self.run = True
self.parent = None
self.total_msg = 0
self.messages = []
self.hashlist = []
self.colors = []
self.total_msg_display = 6
self.mw_status = [None] * self.total_msg_display
self.status = [None] * self.total_msg_display
self.buffer = 1024
self.ore = 0
self.qty_cargo = 0
self.sound = Sound()
self.load_config()
def load_config(self, change=False):
self.ip = config.get("EP_server_ip") or "37.59.36.212"
self.port = int(config.get("EP_server_port") or 44988)
self.session = config.get("EP_session") or "default"
self.track_LTD = config.getint("EP_track_LTD")
self.track_Painite = config.getint("EP_track_Painite")
self.new_win = config.getint("EP_use_new_window")
self.win_trans = config.getint("EP_win_trans")
self.miss = config.getint("EP_miss")
self.track_cargo = config.getint("EP_track_cargo")
self.play_sound = config.getint("EP_sound")
self.ltd_threshold = int(config.get("EP_LTD_t") or 18)
self.painite_threshold = int(config.get("EP_Painite_t") or 25)
self.font_size = int(config.get("EP_font_size") or 14)
self.my_color = config.get("EP_my_color") or "Red"
self.color = config.get("EP_color") or "Blue"
self.pos_x = config.getint("EP_pos_x") or 200
self.pos_y = config.getint("EP_pos_y") or 200
# sanity check
if len(self.session) > 15:
self.session = "default"
if change:
self.change_session()
self.update_gui()
self.refresh_display()
self.refresh_cargo()
def init_gui(self, parent):
self.parent = parent
self.frame = tk.Frame(self.parent, borderwidth=2)
self.frame.grid(sticky=tk.NSEW, columnspan=2)
row = 0
self.connection = tk.Button(self.frame,
text="Connect to server",
command=self.connect)
self.connection.grid(row=row, padx=0)
row += 1
self.mw_cargo = tk.Label(self.frame, text="Cargo : ")
self.mw_cargo.config(font=("Courier", int(self.font_size)))
self.mw_cargo.grid(row=row, pady=5, sticky=tk.W)
for i in range(self.total_msg_display):
self.mw_status[i] = tk.Label(self.frame,
text="",
foreground="yellow")
self.mw_status[i].config(font=("Courier", int(self.font_size)))
row += 1
self.mw_status[i].grid(row=row, pady=5, sticky=tk.W)
self.win_x = tk.Scale(self.frame,
from_=1,
to=6000,
orient=tk.HORIZONTAL,
label="x position",
command=self.update_new_win)
self.win_x.grid(row=row + 3, columnspan=2)
self.win_x.set(self.pos_x)
row += 1
self.win_y = tk.Scale(self.frame,
from_=1,
to=3000,
orient=tk.HORIZONTAL,
label="y position",
command=self.update_new_win)
self.win_y.grid(row=row + 6, columnspan=2)
self.win_y.set(self.pos_y)
self.update_gui()
self.gui_init = True
return self.frame
def update_gui(self):
try:
self.window.destroy()
except AttributeError as e:
print("window not created ", e)
if self.new_win == 1:
self.win_x.grid()
self.win_y.grid()
self.mw_cargo.grid_remove()
for i in range(self.total_msg_display):
self.mw_status[i].grid_remove()
self.window = tk.Toplevel()
if sys.platform == 'win32' and self.win_trans == 1:
self.window.attributes("-transparentcolor", 'black')
self.window.wm_attributes("-topmost", True)
self.window.overrideredirect(True)
self.window.configure(background='black')
self.cargo = tk.Label(self.window, text="Cargo : ")
self.cargo.config(font=("Courier", int(self.font_size)),
background='black')
self.cargo.pack(side="top",
fill="both",
expand=True,
padx=10,
pady=10)
for i in range(self.total_msg_display):
self.status[i] = tk.Label(self.window)
self.status[i].config(font=("Courier", int(self.font_size)),
background='black')
self.status[i].pack(side="top",
fill="both",
expand=True,
padx=10,
pady=10)
if i == 0:
self.status[i]['text'] = "Waiting..."
self.window.wm_geometry('+' + str(self.pos_x) + '+' +
str(self.pos_y))
if self.track_cargo == 0:
self.cargo.pack_forget()
else:
if self.track_cargo == 1:
self.mw_cargo.grid()
else:
self.mw_cargo.grid_remove()
self.win_x.grid_remove()
self.win_y.grid_remove()
for i in range(self.total_msg_display):
self.mw_status[i].grid()
def update_new_win(self, val):
self.pos_x = self.win_x.get()
self.pos_y = self.win_y.get()
if self.new_win == 1:
self.window.wm_geometry('+' + str(self.win_x.get()) + '+' +
str(self.win_y.get()))
def display_msg(self, msg, mine=True):
if mine:
color = "mine"
else:
color = "other"
self.colors.append(color)
self.messages.append(msg)
self.total_msg += 1
if self.total_msg > self.total_msg_display:
self.messages.pop(0)
self.colors.pop(0)
self.total_msg -= 1
self.refresh_display()
def refresh_display(self):
for i in range(len(self.messages)):
if self.colors[i] == "mine":
color = self.my_color
else:
color = self.color
if self.new_win == 1:
self.status[i].config(foreground=color)
self.status[i]['text'] = self.messages[i]
else:
self.mw_status[i].config(foreground=color)
self.mw_status[i]['text'] = self.messages[i]
def process_msg(self, json_data):
msg_hash = json_data['hash']
msg = json_data['cmdr']
if msg_hash in self.hashlist:
# duplicate !
if self.miss == 1:
msg += " duplicate"
self.display_msg(msg, False)
return # stop here
else:
self.hashlist.append(msg_hash)
if self.play_sound == 1:
self.sound.play()
msg += " " + json_data['data']
self.display_msg(msg, False)
def refresh_cargo(self):
if self.track_cargo == 1:
if self.new_win == 1:
self.cargo['text'] = "Cargo : " + str(
self.qty_cargo) + " Ore : " + str(self.ore)
else:
self.mw_cargo['text'] = "Cargo : " + str(
self.qty_cargo) + " Ore : " + str(self.ore)
def sendMsg(self, message):
try:
self.sock.sendall(message.encode())
except socket.error as e:
print("error sending")
print("Caught exception socket.error : %s" % e)
self.stop()
self.msg_send = True
def connect(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.connection["text"] = "Connecting..."
print("connecting to ", self.ip)
self.sock.connect((self.ip, int(self.port)))
except socket.error as e:
print("Caught exception socket.error : %s" % e)
print("Error connecting")
self.connection["text"] = "Error connecting check configuration"
return
con_succes = {"act": "connexion", "data": "Player join"}
self.connected = True
self.change_session()
time.sleep(1)
self.sendMsg(json.dumps(con_succes).encode())
threading.Thread(target=self.recvs).start()
threading.Thread(target=self.heart_beat).start()
self.connection["text"] = "Connected"
time.sleep(2)
self.connection.grid_remove()
def change_session(self):
to_send = {"act": "session", "data": self.session}
if self.connected:
self.sendMsg(json.dumps(to_send))
def stop(self):
config.set("EP_pos_x", self.pos_x)
config.set("EP_pos_y", self.pos_y)
if not self.connected:
return
self.run = False
self.connected = False
quit_msg = {"act": "quit"}
self.sendMsg(json.dumps(quit_msg))
time.sleep(1)
try:
self.sock.close()
except socket.error as e:
print("socket.error : %s" % e)
self.connection.grid()
def recvMsg(self):
data = self.sock.recv(self.buffer)
return data.decode()
def heart_beat(self):
hb = {"act": "keep_alive", "data": "ping"}
hb = json.dumps(hb)
while self.run:
if not self.msg_send:
self.sendMsg(hb)
else:
self.msg_send = False
time.sleep(10)
def recvs(self):
while self.run:
try:
msg = self.recvMsg()
except socket.error as e:
print("error receiving")
print("Caught exception socket.error : %s" % e)
self.stop()
try:
decoded = json.loads(msg)
if decoded['act'] == "quit":
self.stop()
break
elif decoded['act'] == "event":
self.process_msg(decoded)
elif decoded['act'] == "connexion":
self.display_msg(decoded['data'], True)
except ValueError as e:
print("Bad formating ", e)
def publish(self, cmdr, name, prop, hash, duplicate):
data = name + " {:.2f}%"
data = data.format(prop)
message = {"act": "event", "cmdr": cmdr, "data": data, "hash": hash}
if self.connected:
self.sendMsg(json.dumps(message))
if not duplicate:
if self.play_sound == 1:
self.sound.play()
to_display = cmdr + " " + name + " {:.2f}%"
self.display_msg(to_display.format(prop), True)
def cargo_event(self, entry):
if "Count" in entry:
self.qty_cargo = entry['Count']
if self.qty_cargo == 0:
self.ore = 0
try:
self.hashlist.clear()
except AttributeError:
del self.hashlist[:]
self.refresh_cargo()
def refined_event(self):
self.ore += 1
self.refresh_cargo()
def event(self, cmdr, entry):
# received a ProspectedAsteroid event
empty = True
below_t = False
duplicate = False
mat_hash = hashlib.md5(json.dumps(
entry["Materials"]).encode()).hexdigest()
if mat_hash in self.hashlist:
duplicate = True
else:
self.hashlist.append(mat_hash)
# check for materials
for mat in entry['Materials']:
if mat['Name'] == "LowTemperatureDiamond" and self.track_LTD == 1:
if mat['Proportion'] > float(self.ltd_threshold):
self.publish(cmdr, mat['Name_Localised'],
mat['Proportion'], mat_hash, duplicate)
else:
below_t = True
empty = False
elif mat['Name'] == "Painite" and self.track_Painite == 1:
if mat['Proportion'] > float(self.painite_threshold):
self.publish(cmdr, "Painite", mat['Proportion'], mat_hash,
duplicate)
else:
below_t = True
empty = False
if self.miss == 1:
if duplicate:
self.display_msg("Asteroid already prospected", True)
return
if empty and not below_t:
self.display_msg("Asteroid without materials", True)
if below_t:
self.display_msg("Threshold not met", True)
def combat(self,pod,user,playerBattleMap,alienBattleMap,playerEquipment,ranAway=0,playerDead=0):
#taunt and shoot are shorthand for alien action options
if ranAway !=0:
done=1
if playerDead!=0:
done=1
taunt="taunt"
shoot="shoot"
battleTurn=1 #1=Player,2=Alien.
shotMissed=Sound().weaponSounds("Shot Miss")
shotMissed.set_volume(1)
turn=0 #turn ticks when turn passes, allowing for status aliments to fade after turns
Combat.setCombatMusic()
shotMissed.play()
pygame.mixer.music.set_volume(1)
pygame.mixer.music.play(-1,0)
#*****************************************
#lists holding combat actions/reactions
#--------------------------------------
actions=[] #actions holds enemy action choices.
#totalHealth=[] #pulls hp from enemies in pod for ui purposes
alienCoverStats=[] #pulls cover stats from enemiesi n pod for ui purposes
playerCopyAlienCover=[] #copy of aliencoverstats made after they are cleared each turn. For long-term ui storage
#*****************************************
#main combat loop
done=0
while done==0:
#At the start of combat, player chooses which cover they'll take.
print ("You've touched down and found the enemies. Press the coorisponding number key to get into that over point.")
os.system('cls' if os.name=='nt' else 'clear')
user.changeCover(playerBattleMap)
os.system('cls' if os.name=='nt' else 'clear')
#show pod, make action selection, turn passed and it switches to alien.
while battleTurn==1:
ranAway=Combat.playerTurn(self,pod,user,alienBattleMap,playerBattleMap,shotMissed,playerEquipment)
if ranAway==1:
done=1
os.system('cls' if os.name=='nt' else 'clear')
break
done=Combat.checkIfVictory(pod,user)
time.sleep(0.5)
battleTurn=2
#if player chooses to run away, it returns runAway as 1. if 1, then done=1 and loop breaks, running funct again. ranAway, despite being an intitalized variable, stayed 1 and thus done
#also stayed 1. So with done=1, then there's no game loop and it's back to the main screen. Easy-peasy.
#gets player position,then each alien in pod takes an action and cover. either taunt or shoot. clear results each time but store in sep list 1st
while battleTurn==2:
Combat.alienTurn(user,pod,actions,alienCoverStats,playerCopyAlienCover,alienBattleMap,playerBattleMap,shotMissed)
playerDead=Combat.checkIfVictory(pod,user)
if playerDead==1:
done=1
break
input("Enter any key then hit enter to progress to your turn")
battleTurn=1
class Challenge:
def __init__(self, fileName, keys, stick, stones, helps, ball, bar, rightBall, level, game):
"""
Initialize a challenge
@param self -- the challenge
@param fileName -- a string that contains the sound name
@param keys -- the key vector
@param stick -- the stick
@param stones -- the stones
@param helps -- the helps
@param ball -- the left ball that it is used in the animation
@param bar -- the grey bar that it is used in the animation
@param rightBall -- the right ball that it is used in the animation
@param level -- the challenge level
@param game -- the game
"""
self.fileName = fileName
self.music = Sound()
self.music.setFileName("sound/music/" + fileName)
self.section = Section()
self.section.setFileName("sound/section/" + fileName)
self.section.setKeys(keys)
self.stick = stick
self.animation = Animation(stones, keys, helps, ball, rightBall, bar, game)
self.ball = ball
self.level = level
self.attempts = 0
self.game = game
def start(self):
"""
Start a challenge
@param self -- the challenge
"""
if os.path.exists("sound/section/" + self.fileName + ".wav"):
self.section.play()
self.game.statusBar.setText(_("Discover the next musical note"))
self.animation.playIntroduction()
self.ball.setSound(self.fileName)
def change(self):
"""
Change a challenge
@param self -- the challenge
"""
if os.path.exists("sound/section/" + self.fileName + ".wav"):
self.section.play()
self.game.statusBar.setText(_("Discover the next musical note"))
self.animation.playIntroduction()
self.ball.setSound(self.fileName)
def finish(self):
"""
Finish a challenge
@param self -- the challenge
"""
if os.path.exists("sound/music/" + self.fileName + ".ogg"):
self.music.play()
self.game.currentChallenge = None
self.game.statusBar.setText(_("Congratulations!!! You completed the challenge! Choose other to continue playing."))
self.stick.setVisible(False)
self.animation.playClosing()
self.game.setPoints(self.level, self.attempts)
def attempt(self, id):
"""
Verify a attempt
@param self -- the challenge
@param id -- the key index
"""
if self.section.isCurrentKey(id):
self.game.setBufferPoints(self.level, self.attempts)
self.attempts = 0
if self.section.isLastKey():
self.finish()
else:
self.animation.lowStone(self.section.currentKey)
self.section.currentKey = self.section.currentKey + 1
self.game.statusBar.setText(_("Discover the next musical note"))
else:
self.attempts = self.attempts + 1
if self.section.moreThan(id):
self.game.statusBar.setText(_("Try a lower note"))
else:
self.game.statusBar.setText(_("Try a higher note"))
def getBall(self):
"""
Get the ball
@param self -- the challenge
"""
return self.ball
class Game:
def __init__(self):
pygame.init()
pygame.mixer.init()
pygame.display.set_caption("Sokoben")
self.asset = Asset()
self.background = self.asset.createBackground()
self.sound = Sound(self.asset)
self.asset.loadImages()
self.asset.loadLevels()
self.asset.loadSounds()
self.asset.loadFonts()
self.asset.loadControls()
self.levelIndex = 0
self.level = None
Controls.add('sound_enabled', self.asset.controls['sound_enabled'],
(const.MAPWIDTH * const.TILEWIDTH) - ((1 * 64) + 64), 10,
self.sound.enabled)
Controls.add('sound_disabled', self.asset.controls['sound_disabled'],
(const.MAPWIDTH * const.TILEWIDTH) - ((1 * 64) + 64), 10,
not self.sound.enabled)
Controls.add('reset', self.asset.controls['reset'],
(const.MAPWIDTH * const.TILEWIDTH) - ((2 * 64) + 64), 10,
True)
Controls.add('undo', self.asset.controls['undo'],
(const.MAPWIDTH * const.TILEWIDTH) - ((3 * 64) + 64), 10,
True)
Controls.add('next', self.asset.controls['next'],
(const.MAPWIDTH * const.TILEWIDTH) - ((4 * 64) + 64), 10,
True)
Controls.add('back', self.asset.controls['back'],
(const.MAPWIDTH * const.TILEWIDTH) - ((5 * 64) + 64), 10,
True)
Controls.add('solution', self.asset.controls['solution'],
(const.MAPWIDTH * const.TILEWIDTH) - ((6 * 64) + 64), 10,
False)
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(
(const.MAPWIDTH * const.TILEWIDTH,
(const.MAPHEIGHT - 1) * const.TILEANGLEHEIGHT + const.TILEHEIGHT))
def play(self, useSolution):
self.level = Level(self.asset, self.levelIndex, self.background)
gameState = copy.deepcopy(self.level.data['startState'])
gameStateHistory = []
solution = self.level.data['solution']
if len(solution) > 0:
Controls.controls['solution'].enabled = True
else:
Controls.controls['solution'].enabled = False
mapNeedsRedraw = True
i = 0
while True:
playerMoveTo = None
moveBySolution = False
skipSolutionDelay = False
key = pygame.key.get_pressed()
if key[pygame.K_LSHIFT] or key[pygame.K_RSHIFT]:
skipSolutionDelay = True
for event in pygame.event.get():
# Player clicked the "X" at the corner of the window.
if event.type == pygame.QUIT:
return 'exit'
# Player clicked somewhere on the screen
if event.type == pygame.MOUSEBUTTONUP:
# Sound toggle
if Controls.controls['sound_enabled'].isClicked(
pygame.mouse.get_pos()
) or Controls.controls['sound_disabled'].isClicked(
pygame.mouse.get_pos()):
Controls.controls['sound_enabled'].toggle()
Controls.controls['sound_disabled'].toggle()
self.sound.toggle()
mapNeedsRedraw = True
if Controls.controls['reset'].isClicked(
pygame.mouse.get_pos()):
return 'reset'
if Controls.controls['next'].isClicked(
pygame.mouse.get_pos()):
return 'next'
if Controls.controls['back'].isClicked(
pygame.mouse.get_pos()):
return 'back'
if Controls.controls['solution'].isClicked(
pygame.mouse.get_pos()):
return 'solution'
if Controls.controls['undo'].isClicked(
pygame.mouse.get_pos()):
i = len(solution) + 1
if gameState['stepCounter'] > 0:
gameState = gameStateHistory.pop()
mapNeedsRedraw = True
elif event.type == pygame.KEYDOWN:
if event.key in (pygame.K_LEFT, pygame.K_a):
playerMoveTo = const.LEFT
elif event.key in (pygame.K_RIGHT, pygame.K_d):
playerMoveTo = const.RIGHT
elif event.key in (pygame.K_UP, pygame.K_w):
playerMoveTo = const.UP
elif event.key in (pygame.K_DOWN, pygame.K_s):
playerMoveTo = const.DOWN
elif event.key == K_n:
return 'next'
elif event.key == K_b:
return 'back'
elif event.key == pygame.K_u:
i = len(solution) + 1
if gameState['stepCounter'] > 0:
gameState = gameStateHistory.pop()
mapNeedsRedraw = True
elif event.key == pygame.K_ESCAPE:
return 'exit'
elif event.key == pygame.K_BACKSPACE:
return 'reset'
# Disable automatic solution play when user pressed a direction key.
if playerMoveTo != None:
useSolution = False
i = len(solution) + 1
if useSolution and i < len(solution):
direction = solution[i]
if direction in ('l', 'L'):
playerMoveTo = const.LEFT
elif direction in ('u', 'U'):
playerMoveTo = const.UP
elif direction in ('r', 'R'):
playerMoveTo = const.RIGHT
elif direction in ('d', 'D'):
playerMoveTo = const.DOWN
moveBySolution = True
i = i + 1
if playerMoveTo != None:
moved = self.level.makeMove(gameState, gameStateHistory,
playerMoveTo)
if moved in (1, 2):
gameState['stepCounter'] += 1
mapNeedsRedraw = True
if gameState['stepCounter'] % 2 == 0:
self.sound.play('step1')
else:
self.sound.play('step2')
if moved == 2:
self.sound.play('move block')
if mapNeedsRedraw:
self.screen.fill(const.BGCOLOR)
# draw level based on gameState
mapSurface = self.level.draw(gameState)
self.screen.blit(mapSurface, mapSurface.get_rect())
# draw all controls
for key in Controls.controls:
controlSurface = Controls.controls[key].draw()
if controlSurface != None:
self.screen.blit(controlSurface,
(Controls.controls[key].x,
Controls.controls[key].y))
pygame.display.update()
mapNeedsRedraw = False
if self.level.isFinished(gameState):
print(''.join(gameState['steps']))
return 'solved'
# wait some time to care about CPU.
if moveBySolution:
if not skipSolutionDelay:
pygame.time.wait(const.SOLUTIONDELAY)
self.clock.tick(const.FPS)
def nextLevel(self):
self.levelIndex += 1
if self.levelIndex >= len(self.asset.levels):
self.levelIndex = 0
def previousLevel(self):
self.levelIndex -= 1
if self.levelIndex < 0:
self.levelIndex = len(self.asset.levels) - 1
def intro(self):
print('intro')
return 'level_play'
def solved(self):
print('solved')
tile = self.asset.images['solved']
tileWidth = tile.get_width()
tileHeight = tile.get_height()
screenWidth = (const.MAPWIDTH * const.TILEWIDTH)
screenHeight = (const.MAPHEIGHT * const.TILEHEIGHT)
print(screenWidth, screenHeight, tileWidth, tileHeight)
print((int((screenWidth - tileWidth) / 2 * const.ZOOMFACTOR),
int((screenHeight - tileHeight) / 2 * const.ZOOMFACTOR)))
surface = pygame.Surface((tileWidth, tileHeight), pygame.SRCALPHA, 32)
surface = surface.convert_alpha()
surface.blit(tile, (0, 0))
self.screen.blit(
surface, (int((screenWidth - tileWidth) / 2 * const.ZOOMFACTOR),
int((screenHeight - tileHeight) / 2 * const.ZOOMFACTOR)))
pygame.display.update()
while True:
for event in pygame.event.get():
# Player clicked the "X" at the corner of the window.
if event.type == QUIT:
return 'exit'
elif event.type in (KEYDOWN, MOUSEBUTTONUP):
return 'continue'
self.clock.tick(const.FPS)
return 'exit'
def outro(self):
print('outro')
def exit(self):
pygame.quit()
class TeletextApp(GuizeroApp):
# __________________________________________________________________
def __init__(self, argv, client, debugging_mqtt=False):
super().__init__(argv, client, debugging_mqtt)
self.logger.info(_("Props started"))
if platform.system() != 'Windows':
if self.logger.level != logging.DEBUG:
self._gui.full_screen = True # exit fullscreen with Esc (so for props without a keyboard)
else:
self._gui.width = 592
self._gui.height = 333
self._gui.bg = 'black'
self._gui.tk.config(cursor="none")
self._texte = Text(
self._gui,
"") # "" value is translated to "-" for MQTT_DISPLAY_TOPIC
self._texte.height = 1080
self._texte.text_color = 'green'
self._texte.font = "Helvetica"
if platform.system() != 'Windows':
self._texte.size = "90"
else:
self._texte.size = "28"
self._sound = Sound(self._logger)
if platform.system() != 'Windows':
os.system("amixer cset numid=3 1") # audio jack
os.system("amixer set 'PCM' -- -1000")
if self._mqttConnected:
try:
(result, mid) = self._mqttClient.publish(MQTT_DISPLAY_TOPIC,
"-",
qos=MQTT_DEFAULT_QoS,
retain=True)
except Exception as e:
self._logger.error("{0} '{1}' on {2}".format(
_("MQTT API : failed to call publish() for"), "-",
MQTT_DISPLAY_TOPIC))
self._logger.debug(e)
# __________________________________________________________________
def onConnect(self, client, userdata, flags, rc):
# extend as a virtual method
# display message will '-' for black screen
if hasattr(self, '_texte'):
text = self._texte.value
if not text:
text = "-"
try:
(result, mid) = self._mqttClient.publish(MQTT_DISPLAY_TOPIC,
text,
qos=MQTT_DEFAULT_QoS,
retain=True)
except Exception as e:
self._logger.error("{0} '{1}' on {2}".format(
_("MQTT API : failed to call publish() for"), text,
MQTT_DISPLAY_TOPIC))
self._logger.debug(e)
# __________________________________________________________________
def onMessage(self, topic, message):
# extend as a virtual method
print(topic, message)
if message in ["app:startup", "app:quit"]:
super().onMessage(topic, message)
elif message.startswith("display:"):
text = message[8:]
self._texte.value = text
if self._mqttConnected:
try:
(result,
mid) = self._mqttClient.publish(MQTT_DISPLAY_TOPIC,
text,
qos=MQTT_DEFAULT_QoS,
retain=True)
self._logger.info("{0} '{1}' (mid={2}) on {3}".format(
_("Program sending message"), message, mid,
MQTT_DISPLAY_TOPIC))
except Exception as e:
self._logger.error("{0} '{1}' on {2}".format(
_("MQTT API : failed to call publish() for"), message,
MQTT_DISPLAY_TOPIC))
self._logger.debug(e)
self.publishMessage(self._mqttOutbox, "DONE " + message)
self.publishDataChanges()
self._sound.play('media/bell.wav')
elif message.startswith("erase"):
self._texte.value = ""
if self._mqttConnected:
try:
(result,
mid) = self._mqttClient.publish(MQTT_DISPLAY_TOPIC,
"-",
qos=MQTT_DEFAULT_QoS,
retain=True)
self._logger.info("{0} '{1}' (mid={2}) on {3}".format(
_("Program sending message"), message, mid,
MQTT_DISPLAY_TOPIC))
except Exception as e:
self._logger.error("{0} '{1}' on {2}".format(
_("MQTT API : failed to call publish() for"), message,
MQTT_DISPLAY_TOPIC))
self._logger.debug(e)
self.publishMessage(self._mqttOutbox, "DONE " + message)
self.publishDataChanges()
else:
self.publishMessage(self._mqttOutbox, "OMIT " + message)
# __________________________________________________________________
def publishAllData(self):
super().publishAllData()
# __________________________________________________________________
def publishDataChanges(self):
super().publishDataChanges()
# __________________________________________________________________
def quit(self):
self._gui.exit_full_screen()
self._gui.destroy()
try:
self._mqttClient.disconnect()
self._mqttClient.loop_stop()
except:
pass
self.logger.info(_("Props stopped"))
sys.exit(0)
from Sound import Sound
s = Sound('../song.wav')
s.play()
while True:
pass
