def __init__(self,_playerNum): pygame.Surface.__init__(self,(settingsManager.getSetting('windowWidth')//2, settingsManager.getSetting('windowHeight')//2)) self.keys = settingsManager.getControls(_playerNum) self.player_num = _playerNum self.wheel = FighterWheel(_playerNum) self.active = False self.ready = False self.active_object = self.wheel self.chosen_fighter = None self.myBots = [] self.wheel_increment = 0 self.hold_time = 0 self.hold_distance = 0 self.wheel_offset = [(self.get_width() - 256) // 2, (self.get_height() - 32)] self.bg_surface = None self.current_color = _playerNum self.current_costume = 0 self.icon = spriteManager.ImageSprite(settingsManager.createPath('sprites/default_franchise_icon.png')) self.icon.rect.center = self.get_rect().center self.icon_color = pygame.Color('#cccccc') self.fill_color = '#000000' self.wheel.setFillColor(self.fill_color) self.recolorIcon()
def update(self): for entity in self.entity_list: entity.update() if self.preferred_zoomLevel != self.zoomLevel: diff = self.zoomLevel - self.preferred_zoomLevel #If the camera is too narrow if diff > 0: self.zoomLevel -= min([0.1,diff]) #If the camera is too wide else: self.zoomLevel += min([0.1,-diff]) self.camera_position.width = round(float(settingsManager.getSetting('windowWidth')) * self.zoomLevel) self.camera_position.height = round(float(settingsManager.getSetting('windowHeight')) * self.zoomLevel) if self.camera_position.x != self.camera_preferred_position.x: diff = self.camera_position.x - self.camera_preferred_position.x #If the camera is too far to the right if diff > 0: self.camera_position.x -= min([10,diff]) #otherwise, move 10 pixels closer #If the camera is too far to the left else: self.camera_position.x += min([10,-diff]) if self.camera_position.y != self.camera_preferred_position.y: diff = self.camera_position.y - self.camera_preferred_position.y #If the camera is too far to the bottom if diff > 0: self.camera_position.y -= min([20,diff]) #If the camera is too far to the top else: self.camera_position.y += min([20,-diff])
def endBattle(self,_exitStatus): if not (_exitStatus == 1 or _exitStatus == 2 or _exitStatus == 3): print("An error occured that caused TUSSLE to stop working. If you can replicate this error, please file a bug report so the relevant developers can fix it. Post-mortem debugging coming soon. ") result_sprites = [] width = settingsManager.getSetting('windowWidth') height = settingsManager.getSetting('windowHeight') for i in range(0,len(self.players)): print(self.players) print("player"+str(i)) fighter = self.players[i] result_sprite = spriteManager.RectSprite(pygame.Rect((width / 4) * i,0,(width / 4),height), pygame.Color(settingsManager.getSetting('playerColor'+str(i)))) result_sprite.image.set_alpha(255) name_sprite = spriteManager.TextSprite(fighter.name,_size=24) name_sprite.rect.midtop = (result_sprite.rect.width / 2,0) result_sprite.image.blit(name_sprite.image,name_sprite.rect.topleft) score = fighter.data_log.getData('KOs') - fighter.data_log.getData('Falls') text = spriteManager.TextSprite('Score: ' + str(score)) result_sprite.image.blit(text.image,(0,32)) dist = 48 print(fighter.data_log.data) for item,val in fighter.data_log.data.items(): text = spriteManager.TextSprite(str(item) + ': ' + str(val)) result_sprite.image.blit(text.image,(0,dist)) dist += 16 result_sprites.append(result_sprite) confirmed_list = [False] * len(result_sprites) #This pythonic hacking will make a list of falses equal to the result panels while 1: for event in pygame.event.get(): if event.type == pygame.QUIT: os._exit(1) return -1 for i in range(0,len(self.players)): controls = settingsManager.getControls(i) k = controls.getInputs(event) if k == 'attack': result_sprites[i].image.set_alpha(0) confirmed_list[i] = True elif k == 'special': result_sprites[i].image.set_alpha(255) confirmed_list[i] = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: print("Saving screenshot") pygame.image.save(self.screen,settingsManager.createPath('screenshot.jpg')) if event.key == pygame.K_ESCAPE: return self.screen.fill((0,0,0)) for sprite in result_sprites: sprite.draw(self.screen, sprite.rect.topleft, 1.0) if all(confirmed_list): return pygame.display.flip() return
def centerCamera(self,center): # First, build the rect, then center it self.camera_preferred_position.width = round(settingsManager.getSetting('windowWidth') * self.preferred_zoomLevel) self.camera_preferred_position.height = round(settingsManager.getSetting('windowHeight') * self.preferred_zoomLevel) self.camera_preferred_position.center = center # If it's too far to one side, fix it. if self.camera_preferred_position.left < self.camera_maximum.left: self.camera_preferred_position.left = self.camera_maximum.left if self.camera_preferred_position.right > self.camera_maximum.right: self.camera_preferred_position.right = self.camera_maximum.right if self.camera_preferred_position.top < self.camera_maximum.top: self.camera_preferred_position.top = self.camera_maximum.top if self.camera_preferred_position.bottom > self.camera_maximum.bottom: self.camera_preferred_position.bottom = self.camera_maximum.bottom
def initializeCamera(self): self.camera_position = pygame.Rect(24,16,settingsManager.getSetting('windowWidth'),settingsManager.getSetting('windowHeight')) self.camera_position.midtop = self.size.midtop self.camera_preferred_position = pygame.Rect(24,16,settingsManager.getSetting('windowWidth'),settingsManager.getSetting('windowHeight')) self.camera_preferred_position.midtop = self.size.midtop self.dead_zone = [64,32] self.cameraUpdate() self.camera_position = self.camera_preferred_position
def initializeCamera(self): self.camera_position = pygame.Rect(24,16,settingsManager.getSetting('windowWidth'),settingsManager.getSetting('windowHeight')) self.camera_position.midtop = self.size.midtop self.camera_preferred_position = pygame.Rect(24,16,settingsManager.getSetting('windowWidth'),settingsManager.getSetting('windowHeight')) self.camera_preferred_position.midtop = self.size.midtop #self.centerSprite = spriteObject.RectSprite([0,0],[32,32]) self.deadZone = [64,32] self.cameraUpdate() self.camera_position = self.camera_preferred_position
def getScale(self): h = round(float(settingsManager.getSetting('windowHeight')) / self.camera_position.height,5) w = round(float(settingsManager.getSetting('windowWidth')) / self.camera_position.width,5) # If they match, the math is good and we can just pick one if h == w: return h # If they don't match, something might have gone wrong. else: if abs(h - w) <= 0.02: # F**k it, close enough. return h print("Scaling Error", h, w, abs(h-w)) return w
def zoomCamera(self,zoomVal): self.zoom_level += zoomVal self.zoom_level = max(self.zoom_level,0.25) self.zoom_level = min(self.zoom_level,4) oldWidth = self.camera_position.width oldHeight = self.camera_position.height self.camera_position.width = round(float(settingsManager.getSetting('windowWidth')) * self.zoom_level) self.camera_position.height = round(float(settingsManager.getSetting('windowHeight')) * self.zoom_level) diffW = (oldWidth - self.camera_position.width) diffH = (oldHeight - self.camera_position.height) self.camera_position.x += diffW // 2 self.camera_position.y += diffH // 2
def cameraUpdate(self): # Initialize our corner objects leftmost = self.follows[0] rightmost = self.follows[0] topmost = self.follows[0] bottommost = self.follows[0] # Iterate through all of the objects to get the cornermost objects for obj in self.follows: if obj.left < leftmost.left: leftmost = obj if obj.right > rightmost.right: rightmost = obj if obj.top < topmost.top: topmost = obj if obj.bottom > bottommost.bottom: bottommost = obj # Calculate the width and height between the two farthest sidewas objects (plus deadzone) xdist = (rightmost.right - leftmost.left) + (2*self.deadZone[0]) ydist = (bottommost.bottom - topmost.top) + (2*self.deadZone[1]) # Compare that distance with the window size to get the scale xZoom = xdist / float(settingsManager.getSetting('windowWidth')) yZoom = ydist / float(settingsManager.getSetting('windowHeight')) # Minimum Zoom level if xZoom < 1.0: xZoom = 1.0 if yZoom < 1.0: yZoom = 1.0 # If our new zoomed value is too big, we need to cut it down to size if xZoom * settingsManager.getSetting('windowWidth') > self.camera_maximum.width: xZoom = self.camera_maximum.width / float(settingsManager.getSetting('windowWidth')) if yZoom * settingsManager.getSetting('windowHeight') > self.camera_maximum.height: yZoom = self.camera_maximum.height / float(settingsManager.getSetting('windowHeight')) # Set the preferred zoom level and camera position to be centered on later self.preferred_zoomLevel = max([xZoom,yZoom]) if self.preferred_zoomLevel > (self.camera_maximum.width/float(settingsManager.getSetting('windowWidth'))): self.preferred_zoomLevel = self.camera_maximum.width/float(settingsManager.getSetting('windowWidth')) if self.preferred_zoomLevel > (self.camera_maximum.height/float(settingsManager.getSetting('windowHeight'))): self.preferred_zoomLevel = self.camera_maximum.height/float(settingsManager.getSetting('windowHeight')) # Now that everything is set, we create the boundingBox around the cornermost objects, then get the center of it boundingBox = pygame.Rect(leftmost.left-self.deadZone[0],topmost.top-self.deadZone[1],xdist,ydist) center = boundingBox.center # And finally, move the camera. self.centerCamera(center)
def __init__(self,plat,side): pygame.sprite.Sprite.__init__(self) self.rect = pygame.Rect([0,0],settingsManager.getSetting('ledgeSweetspotSize')) self.side = side if side == 'left': self.rect.midtop = plat.leftPoint else: self.rect.midtop = plat.rightPoint self.fightersGrabbed = [] # this is a list in case "Ledge Conflict" is set to "share"
def filterHits(self, _hitbox, _subactions, _forward): if self.damage_threshold > 0 and self.knockback_threshold > 0 and isinstance(_hitbox, hitbox.DamageHitbox) and not _hitbox.ignore_armor: # Calculate knockback percent_portion = (self.owner.damage/10.0) + (self.owner.damage*_hitbox.damage)/20.0 weight_portion = 200.0/(self.owner.stats['weight']*settingsManager.getSetting('weight')*_hitbox.weight_influence+100) total_kb = (((percent_portion * weight_portion *1.4) + 5) * _hitbox.knockback_growth) + _hitbox.base_knockback self.damage_threshold -= _hitbox.damage self.knockback_threshold -= total_kb from engine.subactions import behavior if self.damage_threshold > _hitbox.damage and self.knockback_threshold > total_kb: _subactions = filter(lambda k: not isinstance(k, behavior.applyHitstop.applyHitstop) and not isinstance(k, behavior.dealDamage.dealDamage) and not isinstance(k, behavior.applyScaledKnockback.applyScaledKnockback) and not isinstance(k, behavior.compensateResistance.compensateResistance), _subactions) for subact in _subactions: if isinstance(subact, behavior.dealDamage.dealDamage): subact.damage *= self.armor_damage_multiplier if isinstance(subact, behavior.applyScaledKnockback.applyScaledKnockback): subact.base_knockback *= self.armor_knockback_multiplier subact.knockback_growth *= self.armor_knockback_multiplier if isinstance(subact, behavior.compensateResistance.compensateResistance): subact.frames *= self.armor_knockback_multiplier else: for subact in _subactions: if isinstance(subact, behavior.dealDamage.dealDamage): subact.damage *= self.overflow_damage_multiplier if isinstance(subact, behavior.applyScaledKnockback.applyScaledKnockback): subact.base_knockback *= self.overflow_knockback_multiplier subact.knockback_growth *= self.overflow_knockback_multiplier if isinstance(subact, behavior.compensateResistance.compensateResistance): subact.frames *= self.overflow_knockback_multiplier if isinstance(subact, behavior.applyHitstun.applyHitstun): subact.base_knockback *= self.overflow_knockback_multiplier subact.knockback_growth *= self.overflow_knockback_multiplier return _forward(_hitbox, _subactions)
def __init__(self, _rules, _players, _stage, _randomSeed=None): self.settings = settingsManager.getSetting().setting if _rules is None: _rules = Rules() self.rules = _rules self.players = _players self.controllers = [] for player in _players: player.initialize() player.key_bindings.linkObject(player) self.controllers.append(player.key_bindings) self.stage = _stage self.input_buffer = None self.data_logs = [] random.seed(_randomSeed) self.active_hitboxes = pygame.sprite.Group() self.active_hurtboxes = pygame.sprite.Group() self.track_stocks = True self.track_time = True if self.rules.stocks == 0: self.track_stocks = False if self.rules.time == 0: self.track_time = False
def draw(self,screen,offset,scale): if (settingsManager.getSetting('showSpriteArea')): spriteManager.RectSprite(self.rect).draw(screen, offset, scale) self.sprite.draw(screen,offset,scale) if self.mask: self.mask.draw(screen,offset,scale) for art in self.articles: art.draw(screen,offset,scale)
def __init__(self, _fighter): spriteManager.Sprite.__init__(self) self.fighter = _fighter self.percent = int(_fighter.damage) self.bg_sprite = _fighter.franchise_icon self.bg_sprite.recolor( self.bg_sprite.image, pygame.Color('#cccccc'), pygame.Color( settingsManager.getSetting('playerColor' + str(_fighter.player_num)))) self.bg_sprite.alpha(128) self.image = self.bg_sprite.image self.rect = self.bg_sprite.image.get_rect() #Until I can figure out the percentage sprites self.percent_sprites = spriteManager.SheetSprite( settingsManager.createPath('sprites/guisheet.png'), 64) self.kerning_values = [ 49, 33, 44, 47, 48, 43, 43, 44, 49, 43, 48 ] #This is the width of each sprite, for kerning purposes self.percent_sprite = spriteManager.Sprite() self.percent_sprite.image = pygame.Surface((196, 64), pygame.SRCALPHA, 32).convert_alpha() self.redness = 0 self.updateDamage() self.percent_sprite.rect = self.percent_sprite.image.get_rect() self.percent_sprite.rect.center = self.rect.center
def __init__(self, _rules, _players, _stage, _randomSeed=None): self.settings = settingsManager.getSetting().setting if _rules is None: _rules = Rules() self.rules = _rules self.players = _players self.controllers = [] for player in _players: player.game_state = _stage player.initialize() player.key_bindings.linkObject(player) self.controllers.append(player.key_bindings) self.stage = _stage self.input_buffer = None self.data_logs = [] random.seed(_randomSeed) self.active_hitboxes = pygame.sprite.Group() self.active_hurtboxes = pygame.sprite.Group() self.track_stocks = True self.track_time = True if self.rules.stocks == 0: self.track_stocks = False if self.rules.time == 0: self.track_time = False
def __init__(self, _stages): self.stage_grid = [] self.selected_stage = (0, 0) self.stages_striked = [] x = 0 y = 0 max_x = settingsManager.getSetting( 'windowWidth' ) / 32 #the number of icons that'll fit on the screen horizontally print(max_x) stage_row = [] striking_row = [] _stages.append('random') for stage in _stages: if x < max_x: stage_row.append(stage) #Put it in the row striking_row.append(False) x += 1 else: self.stage_grid.append(stage_row) #Add the row to the grid self.stages_striked.append(striking_row) stage_row = [] #Clear the row striking_row = [] y += 1 stage_row.append(stage) striking_row.append(False) x = 1 #End of stages self.stage_grid.append(stage_row) #Put the last row onto the grid self.stages_striked.append(striking_row)
def __init__(self,stages): self.stageGrid = [] self.selectedStage = (0,0) self.stagesStriked = [] x = 0 y = 0 maxX = settingsManager.getSetting('windowWidth') / 32 #the number of icons that'll fit on the screen horizontally print(maxX) stageRow = [] strikingRow = [] stages.append('random') for stage in stages: if x < maxX: stageRow.append(stage) #Put it in the row strikingRow.append(False) x += 1 else: self.stageGrid.append(stageRow) #Add the row to the grid self.stagesStriked.append(strikingRow) stageRow = [] #Clear the row strikingRow = [] y += 1 stageRow.append(stage) strikingRow.append(False) x = 1 #End of stages self.stageGrid.append(stageRow) #Put the last row onto the grid self.stagesStriked.append(strikingRow) print(self.stageGrid)
def getKeysForAction(self, _action): list_of_bindings = [] for binding, name in self.key_bindings.items(): if name == _action: list_of_bindings.append( settingsManager.getSetting().key_id_map[binding]) return list_of_bindings
def __init__(self, port=9009): self.settings = settingsManager.getSetting().setting port = self.settings['networkServerPort'] self.MESSAGE_SIZE = 96 self.SOCKET_MODE_UDP = "udp" self.SOCKET_MODE_TCP = "tcp" #not implemented yet self.connect_mode = self.settings['networkProtocol'] if (self.connect_mode == self.SOCKET_MODE_UDP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.conn.bind(("", port)) #bind to everything. if (self.connect_mode == self.SOCKET_MODE_TCP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.conn.setblocking(0) self.conn.bind(('', port)) self.conn.listen(5) self.message_queues = {} self.read_list = [self.conn] self.write_list = [] self.players = {} self.DEBUG_ENABLED = False #quick and dirty way of testing artificial latency #cycles through this list and sleeps for that amount of time (in seconds) self.sleep_intervals = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
def onCollision(self, _other): if 'AbstractFighter' in list(map(lambda x :x.__name__,_other.__class__.__bases__)) + [_other.__class__.__name__]: if _other.lockHitbox(self): if self.article is None: self.owner.applyPushback(self.base_knockback/5.0, self.getTrajectory()+180, (self.damage / 3.0 + 3.0)*self.hitlag_multiplier) p = float(_other.damage) d = float(self.damage) w = float(_other.var['weight']) * settingsManager.getSetting('weight') s = float(self.knockback_growth) b = float(self.base_knockback) total_kb = (((((p/10) + (p*d)/20) * (200/(w*self.weight_influence+100))*1.4) + 5) * s) + b angle = 0 if (self.base_knockback > 0): # Calculate the resulting angle knockback_ratio = total_kb*self.velocity_multiplier/self.base_knockback x_val = math.sqrt(knockback_ratio**2+1)/math.sqrt(2) y_val = math.sqrt(knockback_ratio**2-1)/math.sqrt(2) angle = math.atan2(y_val*math.sin(float(self.trajectory)/180*math.pi),x_val*math.cos(float(self.trajectory)/180*math.pi))/math.pi*180 self.owner.data_log.addToData('Damage Dealt',self.damage) _other.applyKnockback(self.damage, self.base_knockback, self.knockback_growth, angle, self.weight_influence, self.hitstun_multiplier, self.base_hitstun, self.hitlag_multiplier, self.ignore_armor) _other.trail_color = self.trail_color offset = random.randrange(0, 359) hit_intersection = self.rect.clip(_other.sprite.rect).center hitlag = (self.damage/3.0+3.0)*self.hitlag_multiplier from article import HitArticle for i in range(int(hitlag)): art = HitArticle(self.owner, hit_intersection, 0.5, offset+i*360/int(hitlag), 0.5*hitlag, .4, self.trail_color) self.owner.articles.add(art) Hitbox.onCollision(self, _other) if self.article and hasattr(self.article, 'onCollision'): self.article.onCollision(_other)
def __init__(self,_plat,_side): pygame.sprite.Sprite.__init__(self) self.rect = pygame.Rect([0,0],settingsManager.getSetting('ledgeSweetspotSize')) self.side = _side if _side == 'left': self.rect.midtop = _plat.left_point else: self.rect.midtop = [_plat.right_point[0], _plat.left_point[1]] self.fighters_grabbed = [] # this is a list in case "Ledge Conflict" is set to "share" self.platform = _plat
def __init__(self,playerNum): pygame.Surface.__init__(self,(settingsManager.getSetting('windowWidth')/2, settingsManager.getSetting('windowHeight')/2)) self.keys = settingsManager.getControls(playerNum) self.playerNum = playerNum self.wheel = FighterWheel() self.active = False self.activeObject = self.wheel self.chosenFighter = None self.wheelIncrement = 0 self.holdtime = 0 self.holdDistance = 0 self.wheelOffset = [(self.get_width() - 256) / 2, (self.get_height() - 32)] self.bgSurface = None
def drawFG(self,screen): if settingsManager.getSetting('showPlatformLines'): for plat in self.platform_list: platSprite = spriteObject.RectSprite(plat.rect.topleft,plat.rect.size) platSprite.draw(screen,self.stageToScreen(platSprite.rect),self.getScale()) #for ledge in self.platform_ledges: #ledgeSprite = spriteObject.RectSprite(ledge.rect.topleft,ledge.rect.size,[0,0,255]) #ledgeSprite.draw(screen,self.stageToScreen(ledge.rect),self.getScale()) for sprite in self.foregroundSprites: sprite.draw(screen,self.stageToScreen(sprite.rect),self.getScale())
def onPrevail(self, _actor, _hitbox, _other): if _hitbox == self.main_hitbox and self.frame > 2 and (isinstance( _other, hitbox.DamageHitbox) and not _other.ignore_shields): _actor.doAction('SheildStun') _actor.shield_integrity -= (_other.damage + _other.charge_damage * _other.charge ) * _other.shield_multiplier _actor.hitstop = math.floor( ((_other.damage + _other.charge_damage * _other.charge) / 3.0 + 3.0) * _other.hitlag_multiplier * settingsManager.getSetting('hitlag')) _actor.change_x = ( _other.base_knockback + _other.charge_base_knockback * _other.charge) / 5.0 * math.cos( math.radians(_other.trajectory)) _actor.current_action.last_frame = math.floor( ((_other.damage + _other.charge_damage * _other.charge) * _other.shield_multiplier * 0.375 * _other.hitstun_multiplier + _other.base_hitstun / 3.0) * settingsManager.getSetting('shieldStun'))
def rollMusic(self,setName): musicList = self.musicDict[setName] roll = random.randint(0,self.getTotalChance(setName)) print(roll, self.getTotalChance(setName)) for path, chance, name in musicList: roll -= chance if roll <= 0: pygame.mixer.music.set_volume(settingsManager.getSetting('musicVolume')) self.currentMusic = (path,chance,name) pygame.mixer.music.load(path) pygame.mixer.music.play(-1) return
def __init__(self, playerNum, sprite, name, var): self.var = var self.playerNum = playerNum #Initialize engine variables self.keyBindings = settingsManager.getSetting('controls_' + str(playerNum)) self.currentKeys = [] self.inputBuffer = InputBuffer() self.keysHeld = [] self.sprite = sprite self.mask = None self.active_hitboxes = pygame.sprite.Group() self.articles = pygame.sprite.Group() self.shield = False self.shieldIntegrity = 100 # HitboxLock is a list of hitboxes that will not hit the fighter again for a given amount of time. # Each entry in the list is in the form of (frames remaining, owner, hitbox ID) self.hitboxLock = [] # When a fighter lets go of a ledge, he can't grab another one until he gets out of the area. self.ledgeLock = False #initialize the action self.current_action = None self.hurtbox = spriteManager.RectSprite(self.sprite.boundingRect,[255,255,0]) #state variables and flags self.angle = 0 self.grounded = False self.rect = self.sprite.rect self.jumps = self.var['jumps'] self.damage = 0 self.landingLag = 6 self.change_x = 0 self.change_y = 0 self.preferred_xspeed = 0 self.preferred_yspeed = 0 #facing right = 1, left = -1 self.facing = 1 #list of all of the other things to worry about self.gameState = None
def filterHits(self, _hitbox, _subactions, _forward): if self.damage_threshold > 0 and self.knockback_threshold > 0 and isinstance( _hitbox, hitbox.DamageHitbox) and not _hitbox.ignore_armor: # Calculate knockback percent_portion = (self.owner.damage / 10.0 ) + (self.owner.damage * _hitbox.damage) / 20.0 weight_portion = 200.0 / (self.owner.stats['weight'] * settingsManager.getSetting('weight') * _hitbox.weight_influence + 100) total_kb = (((percent_portion * weight_portion * 1.4) + 5) * _hitbox.knockback_growth) + _hitbox.base_knockback self.damage_threshold -= _hitbox.damage self.knockback_threshold -= total_kb from engine.subactions import behavior if self.damage_threshold > _hitbox.damage and self.knockback_threshold > total_kb: _subactions = filter( lambda k: not isinstance( k, behavior.applyHitstop.applyHitstop ) and not isinstance(k, behavior.dealDamage.dealDamage) and not isinstance( k, behavior.applyScaledKnockback.applyScaledKnockback ) and not isinstance( k, behavior.compensateResistance.compensateResistance), _subactions) for subact in _subactions: if isinstance(subact, behavior.dealDamage.dealDamage): subact.damage *= self.armor_damage_multiplier if isinstance( subact, behavior.applyScaledKnockback. applyScaledKnockback): subact.base_knockback *= self.armor_knockback_multiplier subact.knockback_growth *= self.armor_knockback_multiplier if isinstance( subact, behavior.compensateResistance. compensateResistance): subact.frames *= self.armor_knockback_multiplier else: for subact in _subactions: if isinstance(subact, behavior.dealDamage.dealDamage): subact.damage *= self.overflow_damage_multiplier if isinstance( subact, behavior.applyScaledKnockback. applyScaledKnockback): subact.base_knockback *= self.overflow_knockback_multiplier subact.knockback_growth *= self.overflow_knockback_multiplier if isinstance( subact, behavior.compensateResistance. compensateResistance): subact.frames *= self.overflow_knockback_multiplier if isinstance(subact, behavior.applyHitstun.applyHitstun): subact.base_knockback *= self.overflow_knockback_multiplier subact.knockback_growth *= self.overflow_knockback_multiplier return _forward(_hitbox, _subactions)
def __init__(self,rules,players,stage): self.settings = settingsManager.getSetting().setting if rules == None: rules = Rules() self.rules = rules self.players = players self.stage = stage self.inputBuffer = None #TODO bring over InputBuffer from fighter. random.seed self.randomstate = random.getstate
def drawFG(self,_screen): rects = [] if settingsManager.getSetting('showPlatformLines'): for plat in self.platform_list: platSprite = spriteManager.RectSprite(pygame.Rect(plat.rect.topleft,plat.rect.size)) rect = platSprite.draw(_screen,self.stageToScreen(platSprite.rect),self.getScale()) if rect: rects.append(rect) #for ledge in self.platform_ledges: #ledgeSprite = spriteObject.RectSprite(ledge.rect.topleft,ledge.rect.size,[0,0,255]) #ledgeSprite.draw(_screen,self.stageToScreen(ledge.rect),self.getScale()) for sprite in self.foreground_sprites: rect = sprite.draw(_screen,self.stageToScreen(sprite.rect),self.getScale()) if rect: rects.append(rect) return rects
def draw(self,screen): if self.active: self.fill((0,0,0)) if self.bgSurface: self.blit(self.bgSurface,[0,0]) else: self.wheel.draw(self,self.wheelOffset) else: self.fill(pygame.Color(settingsManager.getSetting('playerColor' + str(self.playerNum)))) #draw closed shutter offset = [0,0] if self.playerNum == 1 or self.playerNum == 3: offset[0] = self.get_width() if self.playerNum == 2 or self.playerNum == 3: offset[1] = self.get_height() screen.blit(self,offset)
def draw(self,_screen): if self.active: self.fill(pygame.Color(self.fill_color)) if self.bg_surface: self.blit(self.bg_surface,[0,0]) else: self.wheel.draw(self,self.wheel_offset) self.icon.draw(self, self.icon.rect.topleft,1.0) else: self.fill(pygame.Color(settingsManager.getSetting('playerColor' + str(self.player_num)))) #draw closed shutter offset = [0,0] if self.player_num == 1 or self.player_num == 3: offset[0] = self.get_width() if self.player_num == 2 or self.player_num == 3: offset[1] = self.get_height() _screen.blit(self,offset)
def fighterGrabs(self,fighter): if len(self.fightersGrabbed) == 0: # if no one's on the ledge, we don't care about conflict resolution self.fightersGrabbed.append(fighter) fighter.doLedgeGrab(self) else: # someone's already here conflict = settingsManager.getSetting('ledgeConflict') if conflict == 'share': self.fightersGrabbed.append(fighter) fighter.doLedgeGrab(self) elif conflict == 'hog': return elif conflict == 'trump': for other in self.fightersGrabbed: self.fighterLeaves(other) other.doGetTrumped() self.fightersGrabbed.append(fighter) fighter.doLedgeGrab(self)
def getOnHitSubactions(self, _other): import engine.subactions as subactions p = float(_other.owner.damage) d = float(self.damage + self.charge_damage * self.charge) w = float(_other.owner.stats['weight']) * settingsManager.getSetting( 'weight') s = float(self.knockback_growth + self.charge_knockback_growth * self.charge) b = float(self.base_knockback + self.charge_base_knockback * self.charge) total_kb = (((((p / 10) + (p * d) / 20) * (200 / (w * self.weight_influence + 100)) * 1.4) + 5) * s) + b angle = 0 if (self.base_knockback > 0): # Calculate the resulting angle knockback_ratio = total_kb * self.velocity_multiplier / self.base_knockback x_val = math.sqrt(knockback_ratio**2 + 1) / math.sqrt(2) y_val = math.sqrt(knockback_ratio**2 - 1) / math.sqrt(2) angle = math.atan2( y_val * math.sin(float(self.trajectory) / 180 * math.pi), x_val * math.cos( float(self.trajectory) / 180 * math.pi)) / math.pi * 180 hitstun_subaction = subactions.behavior.applyHitstun.applyHitstun( self.damage + self.charge_damage * self.charge, self.base_knockback + self.charge_base_knockback * self.charge, self.knockback_growth + self.charge_knockback_growth * self.charge, angle, self.weight_influence, self.base_hitstun, self.hitstun_multiplier) knockback_subaction = subactions.behavior.applyScaledKnockback.applyScaledKnockback( self.damage + self.charge_damage * self.charge, self.base_knockback + self.charge_base_knockback * self.charge, self.knockback_growth + self.charge_knockback_growth * self.charge, angle, self.weight_influence) damage_subaction = subactions.behavior.dealDamage.dealDamage( self.damage + self.charge_damage * self.charge) compensation_subaction = subactions.behavior.compensateResistance.compensateResistance( self.base_hitstun / 2.0) hitstop_subaction = subactions.behavior.applyHitstop.applyHitstop( ((self.damage + self.charge_damage * self.charge) / 3.0 + 3.0) * self.hitlag_multiplier, 0.0, 0.0) return [ hitstun_subaction, damage_subaction, knockback_subaction, compensation_subaction, hitstop_subaction ] + self.other_on_hit_actions
def __init__(self): self.settings = settingsManager.getSetting().setting #set to false to disable all networking and just run locally self.enabled = self.settings['networkEnabled'] if (self.enabled): self.MESSAGE_SIZE = 96 self.SOCKET_MODE_UDP = "udp" self.SOCKET_MODE_TCP = "tcp" self.connect_mode = self.settings['networkProtocol'] self.serveraddr = self.settings['networkServerIP'] self.serverport = self.settings['networkServerPort'] if (self.connect_mode == self.SOCKET_MODE_UDP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.conn.setblocking(0) self.clientport = random.randrange( self.settings['networkUDPClientPortMin'], self.settings['networkUDPClientPortMax']) self.conn.bind(("", self.clientport)) #bind to everything. if (self.connect_mode == self.SOCKET_MODE_TCP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.conn.connect((self.serveraddr, self.serverport)) self.conn.setblocking(0) self.read_list = [self.conn] self.write_list = [] self.send("c", (self.serveraddr, self.serverport)) #count each frame with an id so that it can be identified when sent over the wire self.tick_count = 0 self.buffer_size = self.settings[ 'networkBufferSize'] #number of frames of latency to introduce locally (should be greater than the network latency) self.max_frame = self.buffer_size self.buffer = [ NetworkBufferEntry() for x in range(self.buffer_size) ] for x in self.buffer: x.receivedFrom['local'] = [] self.fighter_buffer = [[] for x in range(self.buffer_size)] self.STATE_WAITING_FOR_OPPONENT = 0 self.STATE_PLAYING = 1 self.current_state = self.STATE_WAITING_FOR_OPPONENT self.playerno = 0
def rollMusic(self,setName): music_list = self.music_dict[setName] roll = random.randint(0,self.getTotalChance(setName)) print(roll, self.getTotalChance(setName)) for path, chance, name in music_list: roll -= chance if roll <= 0: pygame.mixer.music.set_volume(settingsManager.getSetting('music_volume')) self.current_music = (path,chance,name) if isinstance(path, list): self.path_index = 0 pygame.mixer.music.load(path[0]) pygame.mixer.music.play(0) else: self.path_index = -1 pygame.mixer.music.load(path) pygame.mixer.music.play(-1) return
def rollMusic(self, setName): music_list = self.music_dict[setName] roll = random.randint(0, self.getTotalChance(setName)) print(roll, self.getTotalChance(setName)) for path, chance, name in music_list: roll -= chance if roll <= 0: pygame.mixer.music.set_volume( settingsManager.getSetting('music_volume')) self.current_music = (path, chance, name) if isinstance(path, list): self.path_index = 0 pygame.mixer.music.load(path[0]) pygame.mixer.music.play(0) else: self.path_index = -1 pygame.mixer.music.load(path) pygame.mixer.music.play(-1) return
def __init__(self): self.settings = settingsManager.getSetting().setting #set to false to disable all networking and just run locally self.enabled = self.settings['networkEnabled'] if(self.enabled): self.MESSAGE_SIZE = 96 self.SOCKET_MODE_UDP = "udp" self.SOCKET_MODE_TCP = "tcp" self.connect_mode = self.settings['networkProtocol'] self.serveraddr = self.settings['networkServerIP'] self.serverport = self.settings['networkServerPort'] if(self.connect_mode == self.SOCKET_MODE_UDP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.conn.setblocking(0) self.clientport = random.randrange(self.settings['networkUDPClientPortMin'], self.settings['networkUDPClientPortMax']) self.conn.bind(("", self.clientport))#bind to everything. if(self.connect_mode == self.SOCKET_MODE_TCP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.conn.connect((self.serveraddr,self.serverport)) self.conn.setblocking(0) self.read_list = [self.conn] self.write_list = [] self.send("c", (self.serveraddr, self.serverport)) #count each frame with an id so that it can be identified when sent over the wire self.tick_count = 0 self.buffer_size = self.settings['networkBufferSize']#number of frames of latency to introduce locally (should be greater than the network latency) self.max_frame = self.buffer_size self.buffer = [NetworkBufferEntry() for x in range(self.buffer_size)] for x in self.buffer: x.receivedFrom['local']=[] self.fighter_buffer = [[] for x in range(self.buffer_size)] self.STATE_WAITING_FOR_OPPONENT = 0 self.STATE_PLAYING = 1 self.current_state = self.STATE_WAITING_FOR_OPPONENT self.playerno = 0
def getOnHitSubactions(self, _other): import engine.subactions as subactions p = float(_other.owner.damage) d = float(self.damage+self.charge_damage*self.charge) w = float(_other.owner.stats['weight']) * settingsManager.getSetting('weight') s = float(self.knockback_growth+self.charge_knockback_growth*self.charge) b = float(self.base_knockback+self.charge_base_knockback*self.charge) total_kb = (((((p/10) + (p*d)/20) * (200/(w*self.weight_influence+100))*1.4) + 5) * s) + b angle = 0 if (self.base_knockback > 0): # Calculate the resulting angle knockback_ratio = total_kb*self.velocity_multiplier/self.base_knockback x_val = math.sqrt(knockback_ratio**2+1)/math.sqrt(2) y_val = math.sqrt(knockback_ratio**2-1)/math.sqrt(2) angle = math.atan2(y_val*math.sin(float(self.trajectory)/180*math.pi),x_val*math.cos(float(self.trajectory)/180*math.pi))/math.pi*180 hitstun_subaction = subactions.behavior.applyHitstun.applyHitstun(self.damage+self.charge_damage*self.charge, self.base_knockback+self.charge_base_knockback*self.charge, self.knockback_growth+self.charge_knockback_growth*self.charge, angle, self.weight_influence, self.base_hitstun, self.hitstun_multiplier) knockback_subaction = subactions.behavior.applyScaledKnockback.applyScaledKnockback(self.damage+self.charge_damage*self.charge, self.base_knockback+self.charge_base_knockback*self.charge, self.knockback_growth+self.charge_knockback_growth*self.charge, angle, self.weight_influence) damage_subaction = subactions.behavior.dealDamage.dealDamage(self.damage+self.charge_damage*self.charge) compensation_subaction = subactions.behavior.compensateResistance.compensateResistance(self.base_hitstun/2.0) hitstop_subaction = subactions.behavior.applyHitstop.applyHitstop(((self.damage+self.charge_damage*self.charge) / 3.0 + 3.0)*self.hitlag_multiplier, 0.0, 0.0) return [hitstun_subaction,damage_subaction,knockback_subaction,compensation_subaction,hitstop_subaction]+self.other_on_hit_actions
def __init__(self, _fighter): spriteManager.Sprite.__init__(self) self.fighter = _fighter self.percent = int(_fighter.damage) self.bg_sprite = _fighter.franchise_icon self.bg_sprite.recolor( self.bg_sprite.image, pygame.Color("#cccccc"), pygame.Color(settingsManager.getSetting("playerColor" + str(_fighter.player_num))), ) self.bg_sprite.alpha(128) self.image = self.bg_sprite.image self.rect = self.bg_sprite.image.get_rect() # Until I can figure out the percentage sprites self.percent_sprites = spriteManager.SheetSprite(settingsManager.createPath("sprites/guisheet.png"), 64) self.kerning_values = [ 49, 33, 44, 47, 48, 43, 43, 44, 49, 43, 48, ] # This is the width of each sprite, for kerning purposes self.percent_sprite = spriteManager.Sprite() self.percent_sprite.image = pygame.Surface((196, 64), pygame.SRCALPHA, 32).convert_alpha() self.redness = 0 self.updateDamage() self.percent_sprite.rect = self.percent_sprite.image.get_rect() self.percent_sprite.rect.center = self.rect.center
def __init__(self, port=9009): self.settings = settingsManager.getSetting().setting port =self.settings['networkServerPort'] self.MESSAGE_SIZE = 96 self.SOCKET_MODE_UDP = "udp" self.SOCKET_MODE_TCP = "tcp"#not implemented yet self.connect_mode = self.settings['networkProtocol'] if(self.connect_mode == self.SOCKET_MODE_UDP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.conn.bind(("", port))#bind to everything. if(self.connect_mode == self.SOCKET_MODE_TCP): self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.conn.setblocking(0) self.conn.bind(('', port)) self.conn.listen(5) self.message_queues = {} self.read_list = [self.conn] self.write_list = [] self.players = {} self.DEBUG_ENABLED = False #quick and dirty way of testing artificial latency #cycles through this list and sleeps for that amount of time (in seconds) self.sleep_intervals = [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
def draw(self,_screen,_offset,_scale): if settingsManager.getSetting('showECB'): self.ecb.draw(_screen,_offset,_scale) return self.sprite.draw(_screen, _offset, _scale)
def endBattle(self, _exitStatus): if not (_exitStatus == 1 or _exitStatus == 2 or _exitStatus == 3): print( "An error occured that caused TUSSLE to stop working. If you can replicate this error, please file a bug report so the relevant developers can fix it. Post-mortem debugging coming soon. " ) result_sprites = [] width = settingsManager.getSetting('windowWidth') height = settingsManager.getSetting('windowHeight') for i in range(0, len(self.players)): print(self.players) print("player" + str(i)) fighter = self.players[i] result_sprite = spriteManager.RectSprite( pygame.Rect((width / 4) * i, 0, (width / 4), height), pygame.Color(settingsManager.getSetting('playerColor' + str(i)))) result_sprite.image.set_alpha(255) name_sprite = spriteManager.TextSprite(fighter.name, _size=24) name_sprite.rect.midtop = (result_sprite.rect.width / 2, 0) result_sprite.image.blit(name_sprite.image, name_sprite.rect.topleft) score = fighter.data_log.getData('KOs') - fighter.data_log.getData( 'Falls') text = spriteManager.TextSprite('Score: ' + str(score)) result_sprite.image.blit(text.image, (0, 32)) dist = 48 print(fighter.data_log.data) for item, val in fighter.data_log.data.items(): text = spriteManager.TextSprite(str(item) + ': ' + str(val)) result_sprite.image.blit(text.image, (0, dist)) dist += 16 result_sprites.append(result_sprite) confirmed_list = [False] * len( result_sprites ) #This pythonic hacking will make a list of falses equal to the result panels while 1: for event in pygame.event.get(): if event.type == pygame.QUIT: os._exit(1) return -1 for i in range(0, len(self.players)): controls = settingsManager.getControls(i) k = controls.getInputs(event) if k == 'attack': result_sprites[i].image.set_alpha(0) confirmed_list[i] = True elif k == 'special': result_sprites[i].image.set_alpha(255) confirmed_list[i] = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_RETURN: print("Saving screenshot") pygame.image.save( self.screen, settingsManager.createPath('screenshot.jpg')) if event.key == pygame.K_ESCAPE: return self.screen.fill((0, 0, 0)) for sprite in result_sprites: sprite.draw(self.screen, sprite.rect.topleft, 1.0) if all(confirmed_list): return pygame.display.flip() return
def __init__(self, _rules=None): settings = settingsManager.getSetting().setting self.rules = _rules self.height = settings['windowHeight'] self.width = settings['windowWidth'] pygame.init() screen = pygame.display.get_surface() background = pygame.Surface(screen.get_size()) background = background.convert() clock = pygame.time.Clock() self.player_controls = [] self.player_panels = [] for i in range(0, 4): self.player_controls.append(settingsManager.getControls(i)) self.player_panels.append(PlayerPanel(i)) self.player_controls[i].linkObject( self.player_panels[i]) #So playerPanel will take the inputs self.player_controls[i].flushInputs() status = 0 musicManager.getMusicManager().stopMusic(100) while status == 0: music = musicManager.getMusicManager() music.doMusicEvent() if not musicManager.getMusicManager().isPlaying(): musicManager.getMusicManager().rollMusic('css') #Start event loop for bindings in self.player_controls: bindings.passInputs() for event in pygame.event.get(): for bindings in self.player_controls: k = bindings.getInputs(event) if k == 'attack': if self.checkForSelections(): sss.StageScreen(self.rules, self.getFightersFromPanels()) for panel in self.player_panels: panel.active_object = panel.wheel panel.chosen_fighter = None panel.bg_surface = None for i in range(0, 4): self.player_controls[i].linkObject( self.player_panels[i] ) #So playerPanel will take the inputs self.player_controls[i].flushInputs() if event.type == pygame.QUIT: status = -1 elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: status = 1 #End event loop screen.fill((128, 128, 128)) for panel in self.player_panels: panel.update() panel.draw(screen) pygame.display.flip() clock.tick(60)
def __init__(self, _rules, _characters): settings = settingsManager.getSetting().setting self.rules = _rules self.fighters = _characters self.stages = [] self.getStages() self.grid = StageGrid(self.stages) self.height = settings['windowHeight'] self.width = settings['windowWidth'] pygame.init() screen = pygame.display.get_surface() background = pygame.Surface(screen.get_size()) background = background.convert() clock = pygame.time.Clock() self.player_controls = [] self.player_panels = [] x = 0 y = 0 for i in range(0, 4): self.player_controls.append(settingsManager.getControls(i)) status = 0 while status == 0: music = musicManager.getMusicManager() music.doMusicEvent() #Start event loop for event in pygame.event.get(): for bindings in self.player_controls: k = bindings.getInputs(event, False, False) if k == 'left': self.grid.updateSelection(-1, 0) elif k == 'right': self.grid.updateSelection(1, 0) elif k == 'up': self.grid.updateSelection(0, -1) elif k == 'down': self.grid.updateSelection(0, 1) elif k == 'attack': if not self.grid.isStageStruckAt( self.grid.getXY()[0], self.grid.getXY()[1]): #choose if self.grid.getSelectedStage() == 'random': stage = self.grid.getRandomStage() else: stage = self.grid.getSelectedStage() musicManager.getMusicManager().stopMusic(500) #This will wait until the music fades out for cool effect while musicManager.getMusicManager().isPlaying(): pass music_list = stage.getMusicList() musicManager.getMusicManager().createMusicSet( 'stage', music_list) musicManager.getMusicManager().rollMusic('stage') bindings.flushInputs() current_battle = battle.Battle( self.rules, self.fighters, stage.getStage()) current_battle.startBattle(screen) status = 1 #do something with battle result elif k == 'jump': x, y = self.grid.getXY() self.grid.changeStageStruckAt(x, y) if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: status = 1 #End event loop screen.fill((0, 0, 0)) self.grid.drawScreen(screen) pygame.display.flip() clock.tick(60)
def __init__(self, _owner, _lock, _variables=dict()): import engine.article as article if hasattr(_owner, 'owner'): self.owner = _owner.owner self.article = _owner else: self.owner = _owner self.article = None self.hitbox_type = 'hitbox' self.variable_dict = { 'center': (0, 0), 'size': (0, 0), 'damage': 0, 'base_knockback': 0, 'knockback_growth': 0, 'trajectory': 0, 'hitstun_multiplier': 2, 'charge_damage': 0, 'charge_base_knockback': 0, 'charge_knockback_growth': 0, 'weight_influence': 1, 'shield_multiplier': 1, 'transcendence': 0, 'priority': 0, 'base_hitstun': 10, 'hitlag_multiplier': 1, 'damage_multiplier': 1, 'velocity_multiplier': 1, 'x_bias': 0, 'y_bias': 0, 'x_multiplier': 1, 'y_multiplier': 1, 'hp': 50, 'ignore_shields': False, 'ignore_armor': False, 'trail_color': None, 'charge_source': 'charge' } self.newVariables = _variables self.variable_dict.update(self.newVariables) #set the variables from the dict, so that we don't lose the initial value of the dict when modifying them #also lets us not have to go update all the old references. Score! for key, value in self.variable_dict.iteritems(): setattr(self, key, value) #Flip the distance from center if the fighter is facing the _other way #if owner.facing == -1: # self.center = (-self.center[0],self.center[1]) #offset the trajectory based on facing self.trajectory = self.owner.getForwardWithOffset(self.trajectory) self.hitbox_lock = _lock spriteManager.RectSprite.__init__(self, pygame.Rect([0, 0], self.size), [255, 0, 0]) if self.article is None: self.rect.center = [ self.owner.posx + self.center[0] * self.owner.facing, self.owner.posy + self.center[1] ] elif hasattr(self.article, "facing"): self.rect.center = [ self.article.posx + self.center[0] * self.article.facing, self.article.posy + self.center[1] ] else: self.rect.center = [ self.article.posx + self.center[0], self.article.posy + self.center[1] ] if self.trail_color is None: self.trail_color = settingsManager.getSetting( 'playerColor' + str(self.owner.player_num)) self.owner_on_hit_actions = [] self.other_on_hit_actions = [] self.charge = 0