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 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
