#------------------------------------------------------------------------
#
# This file is part of Ardentryst.
#
# Ardentryst is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ardentryst is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ardentryst. If not, see .
#
# Copyright 2007, 2008, 2009 Jordan Trudgett
#
#------------------------------------------------------------------------
import pygame, math, random
from pygame.locals import *
def ground_at(LEVEL, x, f=False):
"Finds the y co-ordinate of the ground at position x."
ysense = 479
sensing = True
while sensing:
sensetile = LEVEL.map[x//40][ysense//40]
if not sensetile or "NONE" in sensetile.collidetype: break
if sensetile.collidetype == "RIGHT_INCLINATION":
if x%40 < 40-(ysense%40):
break
elif sensetile.collidetype == "RIGHT_HINCLINATION1":
if x%40 < 2*(40-(ysense%40)):
break
elif sensetile.collidetype == "RIGHT_HINCLINATION2":
if (x%40)+40 < 2*(40-(ysense%40)):
break
elif sensetile.collidetype == "LEFT_INCLINATION":
if x%40 > ysense%40:
break
elif sensetile.collidetype == "LEFT_HINCLINATION1":
if x%40 + 40 > 2*(ysense%40):
break
elif sensetile.collidetype == "LEFT_HINCLINATION2":
if (x%40) > 2*(ysense%40):
break
ysense -= [1,10][f]
if ysense <= 0: return 479
return ysense
def m_init_data(data):
global DATA
DATA = data
class Spell: # Spell is a class that (basically) all spells are based on
def __init__(self, caster, x, y):
self.cost = 0
self.x = x
self.y = y
self.caster = caster
self.a_step = 0
self.ticker = 0
self.LEVELSTATE = None
self.MONSTERSTATE = None
self.RAIN_H = False
self.finished = False
self.SOUND = ""
self.fvm = None # Faceview monster
self.fvd = 0 # faceview damage
self.s_init()
def s_init(self):
pass
def blit(self, surf, ALT_X = 0, ALT_Y = 0):
if not self.finished: self.s_blit(surf, ALT_X, ALT_Y)
def tick(self, LEVEL, MONSTERS, CASTER, RAIN = False):
if self.finished: return
self.RAIN_H = RAIN
self.LEVELSTATE = LEVEL
self.MONSTERSTATE = MONSTERS
self.ticker += 1
self.caster = CASTER
self.stick()
class Fire_1(Spell):
def s_init(self):
self.cost = 4
if self.caster.mp[0] < self.cost: self.finished = True; return
self.frames = ["m_fire1_" + str(x) + ".png" for x in range(1,6)]
self.flame_entities = []
self.caster.mbreaktime = 16
self.caster.mp[0] -= self.cost
self.mydir = self.caster.direction * 2 - 1
self.unchdir = self.caster.direction
self.x += self.mydir * 10
self.rise = 0
def s_blit(self, surf, ALT_X, ALT_Y):
c = 0
for flame in self.flame_entities:
if flame == -40: continue
gimg, grect = DATA.mag_images["m_fire1_glow.png"]
img, rect = DATA.mag_images[self.frames[flame%5]]
rect.midbottom = (self.x + flame*8, self.y-math.sin(flame/2.0)*5.0+c*self.rise+((c+0.001)**(abs(self.rise)+1))*[1,-1][self.rise<0])
rect.move_ip(ALT_X, ALT_Y)
grect.midbottom = (self.x + flame*8, self.y-math.sin(flame/2.0)*5.0+c*self.rise+((c+0.001)**(abs(self.rise)+1))*[1,-1][self.rise<0])
grect.move_ip(ALT_X, ALT_Y+3)
surf.blit(img, rect)
surf.blit(gimg, grect)
c += 1
def stick(self):
self.y = self.caster.y - 25
self.x = self.caster.x
self.caster.jumping = False
if len(self.flame_entities) < 8:
self.caster.direction = self.unchdir
if not self.ticker % 2:
if len(self.flame_entities) < 8:
self.flame_entities = [0] + self.flame_entities
self.flame_entities = [[x + self.mydir,-40][[x<-35 or x>0,x>35 or x<0][self.unchdir]] for x in self.flame_entities]
if self.caster.up_held: self.rise -= 0.05
if self.caster.down_held: self.rise += 0.05
# Collision detections
c = 0
for flame in self.flame_entities:
if flame == -40: continue
img, rect = DATA.mag_images[self.frames[flame%5]]
rect.midbottom = (self.x + flame*8, self.y-math.sin(flame/2.0)*5.0+c*self.rise+((c+0.001)**(abs(self.rise)+1))*[1,-1][self.rise<0])
if self.check_collide(rect):
self.flame_entities[c] = -40
c += 1
if sum(self.flame_entities) == 8 * -40:
self.finished = True
def check_collide(self, crect):
for monster in self.MONSTERSTATE:
monsterrect = pygame.rect.Rect((0,0,monster.collision_dist*2,monster.collision_hdist*2))
monsterrect.center = monster.x, monster.y
if crect.colliderect(monsterrect):
damage = (self.caster.magic[0] * 3)/15.0
self.caster.combodamage += min(damage, monster.hp)
monster.react_to_magic(damage)
self.fvm = monster
self.fvd = damage
self.caster.combo += 1
return True
return False
class Summon(Spell):
def s_init(self):
self.caster.mbreaktime = 20
self.rays = []
self.alphamod = 0.0
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
alphamult = self.alphamod / 100.0
if alphamult > 0:
for width, phase, magnitude in self.rays:
rayrect = Rect(0, 0, width, 480)
variance = math.sin(phase) * magnitude
rayrect.midbottom = self.caster.x + variance, self.caster.y
raysurf = pygame.Surface(rayrect.size)
colour = (int(20 + magnitude * 2.5), 50 + width * 3, int(220 - phase * 10))
raysurf.fill(colour)
relalpha = max(0, min(255, 255 - (abs(variance)) * (255/100.0))) * 0.3
raysurf.set_alpha(alphamult * relalpha)
surf.blit(raysurf, rayrect.move(ALT_X, ALT_Y))
def stick(self):
ri = random.randint
if self.alphamod and self.caster.mbreaktime:
self.caster.animation = "Stopped"
self.caster.torso_animation = "Cast"
if self.ticker < 25:
# Creation of rays phase
if not self.ticker % 3:
self.rays.append([ri(5,35), ri(-30,30)/10.0, ri(5, 30)]) # Width, phase, magntd
self.alphamod = min(self.alphamod + 7.5, 100)
if self.ticker > 25:
self.alphamod -= 10
if self.alphamod < 0: self.alphamod = 0; self.finished = True
for r in range(len(self.rays)):
ray = self.rays[r]
self.rays[r][1] += ray[2]/300.0
class Burst(Spell):
def s_init(self):
global DATA
self.caster.mbreaktime = 30
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
self.mticker = -abs(self.ticker-15)+15
pic = DATA.mag_images["Burst.png"][0]
msurf = pygame.transform.scale(pic, (max(5, min(185, self.mticker**3))+15, max(5, min(185, self.mticker**3))+15))
msurf = pygame.transform.rotate(msurf, self.ticker**1.8)
rect = msurf.get_rect()
rect.center = (self.x + ALT_X, self.y + ALT_Y)
surf.blit(msurf, rect)
if self.ticker >= 30:
self.finished = True
def stick(self):
self.x, self.y = self.caster.x, self.caster.y - 40
if self.ticker%3: return
for monster in self.MONSTERSTATE:
dist = abs(monster.x - self.x) + abs(monster.y - self.y)
if dist > 110:
continue
monster.react_to_magic(0)
class Ice_1(Spell):
def s_init(self):
global DATA
self.affected = []
self.cant = self.caster.mp[0] < 4
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
if not self.affected:
if self.ticker >= 0: self.finished = True
return
self.mticker = -abs(self.ticker-15)+15
msurf = pygame.transform.scale(DATA.mag_images["ice.png"][0], (max(5, min(125, self.mticker**2))+15, max(5, min(125, self.mticker**2))+15))
msurf = pygame.transform.rotate(msurf, self.ticker**1.7)
rect = msurf.get_rect()
for mon in self.affected:
rect.center = (mon.x + ALT_X, mon.y-40 + ALT_Y)
surf.blit(msurf, rect)
if self.ticker == 10:
dmg = int(random.randint(80,120)/100.0 * self.caster.magic[0] * 0.6)
self.caster.combodamage += min(dmg, mon.hp)
mon.react_to_magic(dmg)
self.fvm = mon
self.fvd = dmg
self.caster.combo += 1
if self.ticker >= 30:
self.finished = True
def stick(self):
if self.affected == []:
for monster in self.MONSTERSTATE:
xdist = abs(monster.x-self.caster.x)
if xdist < 300 and not monster.isdead:
if self.caster.mp[0] >= 4:
self.affected.append(monster)
self.caster.mp[0] -= 4
if len(self.affected):
self.SOUND = "Ice.ogg"
self.caster.animation = "Stopped"
self.caster.torso_animation = "Cast"
self.caster.frame = 0
self.caster.tframe = 0
self.caster.casting = True
self.caster.mbreaktime = 30
class Ice_2(Ice_1):
def s_init(self):
global DATA
self.affected = []
self.cant = self.caster.mp[0] < 8
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
if not self.affected:
if self.ticker >= 0: self.finished = True
return
self.mticker = -abs(self.ticker-15)+15
msurf = pygame.transform.scale(DATA.mag_images["ice2.png"][0], (max(5, min(125, self.mticker**2))+15, max(5, min(125, self.mticker**2))+15))
msurf = pygame.transform.rotate(msurf, self.ticker**1.7)
rect = msurf.get_rect()
for mon in self.affected:
rect.center = (mon.x + ALT_X, mon.y-40 + ALT_Y)
surf.blit(msurf, rect)
if self.ticker == 10:
dmg = int(random.randint(80,120)/100.0 * self.caster.magic[0] * 1.1)
self.caster.combodamage += min(dmg, mon.hp)
mon.react_to_magic(dmg)
self.fvm = mon
self.fvd = dmg
self.caster.combo += 1
if self.ticker >= 30:
self.finished = True
def stick(self):
if self.affected == []:
for monster in self.MONSTERSTATE:
xdist = abs(monster.x-self.caster.x)
if xdist < 300 and not monster.isdead:
if self.caster.mp[0] >= 8:
self.affected.append(monster)
self.caster.mp[0] -= 8
if len(self.affected):
# self.affected = reduce(lambda m1,m2:[m1,m2][abs(m2.x-self.caster.x)0,x>65 or x<0][self.unchdir]] for x in self.flame_entities]
if self.caster.up_held: self.rise -= 0.05
if self.caster.down_held: self.rise += 0.05
# Collision detections
c = 0
for flame in self.flame_entities:
if flame == -666: continue
img, rect = DATA.mag_images[self.frames[flame%5]]
rect.midbottom = (self.x + flame*4, self.y-math.sin(flame/2.0)*5.0+c*self.rise+((c+0.001)**(abs(self.rise)+1))*[1,-1][self.rise<0])
for y in range(-1,2):
if self.check_collide(rect.move(0, y*flame)):
self.flame_entities[c] = -666
c += 1
if sum(self.flame_entities) == 8 * -666:
self.finished = True
def check_collide(self, crect):
for monster in self.MONSTERSTATE:
monsterrect = pygame.rect.Rect((0,0,monster.collision_dist*2,monster.collision_hdist*2))
monsterrect.center = monster.x, monster.y
if crect.colliderect(monsterrect):
damage = (self.caster.magic[0] * 8)/60.0
self.caster.combodamage += min(monster.hp, damage)
monster.react_to_magic(damage)
self.fvm = monster
self.fvd = damage
self.caster.combo += 1
return True
return False
class Quake(Spell):
def s_init(self):
self.cost = 15
if self.caster.mp[0] < self.cost: self.finished = True; return
self.caster.mbreaktime = 26
self.caster.mp[0] -= self.cost
self.ticker = 0
self.px = 0
self.py = 0
def s_blit(self, surf, ALT_X, ALT_Y):
self.caster.quaking = True
def stick(self):
self.ticker += 1
hitlist = []
if not self.ticker%20:
for mon in self.MONSTERSTATE:
if mon.x > self.caster.x - 350 and mon.x < self.caster.x + 350:
if mon.affected["quake"]:
hitlist.append(mon)
for monster in hitlist:
damage = self.caster.magic[0] * 0.8
damage *= random.randint(75, 125)/100.0
self.caster.combodamage += min(damage, monster.hp)
monster.react_to_damage(int(damage))
self.caster.combo += 1
if self.ticker == 100:
self.finished = True
self.caster.quaking = False
class Implosion_1(Spell):
def s_init(self):
global DATA
self.affected = []
self.cant = self.caster.mp[0] < 15
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
pic = DATA.mag_images["bubble.png"][0]
if not self.affected:
if self.ticker >= 0: self.finished = True
return
for mon in self.affected:
moncentre = (mon.x + ALT_X, mon.y-40 + ALT_Y)
eachang = (math.pi/4)
r = max(0, 300 - self.ticker*15)
turn = self.ticker / 5.0
sp = max(4, 20-self.ticker/2)
for x in range(8):
for c in range(10):
xp = math.cos(x * eachang + turn + (c * 0.15)*(-1**c)) * (r + c * sp)
yp = math.sin(x * eachang + turn + (c * 0.15)*(-1**c)) * (r + c * sp)
rect = pic.get_rect()
rect.center = moncentre
rect.move_ip(xp, yp)
surf.blit(pic, rect)
def stick(self):
if self.affected == []:
for monster in self.MONSTERSTATE:
xdist = abs(monster.x-self.caster.x)
if xdist < 400 and not monster.isdead:
if self.caster.mp[0] >= 15:
self.affected.append(monster)
self.affected.sort(key=lambda x: -x.maxhp)
if len(self.affected):
self.affected = self.affected[:1]
self.caster.mp[0] -= 15
self.SOUND = "Implosion.ogg"
self.caster.animation = "Stopped"
self.caster.torso_animation = "Cast"
self.caster.frame = 0
self.caster.tframe = 0
self.caster.casting = True
self.caster.mbreaktime = 25
for mon in self.affected:
if self.ticker >= 20 and not self.ticker%5:
dmg = int(random.randint(90,155)/100.0 * self.caster.magic[0] * 0.8)
self.caster.combodamage += min(dmg, mon.hp)
mon.react_to_magic(dmg)
self.fvm = mon
self.fvd = dmg
self.caster.combo += 1
if self.ticker >= 31:
self.finished = True
class Summon_Maea(Spell):
def s_init(self):
global DATA
self.cost = 80
if self.caster.mp[0] < self.cost: self.finished = True; return
self.caster.mbreaktime = 50
self.caster.mp[0] -= self.cost
self.dir = self.caster.direction
self.x = [640, -262][self.dir]
self.inertia = [-10, 10][self.dir]
self.bubbles = []
self.bombs = []
self.y = 50
self.inertia2 = 0
self.mouthpos = (130, 50)
def s_blit(self, surf, ALT_X, ALT_Y):
global DATA
darkness = pygame.Surface((640, 480))
if self.ticker < 120:
darkness.set_alpha(7 * min(30, self.ticker))
else:
darkness.set_alpha(max(0, 1050 - self.ticker*7))
surf.blit(darkness, (0,0))
if self.dir:
surf.blit(DATA.images["Summon1.png"][0], (self.x, self.y))
else:
surf.blit(pygame.transform.flip(DATA.images["Summon1.png"][0], True, False), (self.x, self.y))
for x, y, p in self.bombs:
bfs, bfr = DATA.images["bluefire.png"]
nbfs = pygame.transform.scale(bfs, (int(math.cos(-p/2) * 240), int(math.sin(p) * 250)))
nbfr = nbfs.get_rect()
nbfr.midbottom = (x, y + 5)
nbfr.move_ip(ALT_X, ALT_Y)
surf.blit(nbfs, nbfr)
for x, y, a in self.bubbles:
bs, br = DATA.mag_images["bubble.png"]
surf.blit(bs, br.move(self.mouthpos).move(x,y))
def stick(self):
self.x += self.inertia
if self.dir:
self.inertia -= 0.1
else:
self.inertia += 0.1
self.inertia2 += 0.01
self.y += self.inertia2
if self.x < -280 or self.x > 658: self.finished = True
if self.ticker <= 100 and not self.ticker%9:
if self.dir:
sp = int(self.caster.x - 300)
else:
sp = int(self.caster.x + 300)
cx = [sp - self.ticker * 8, sp + self.ticker * 8][self.dir]
self.bombs.append([cx, ground_at(self.LEVELSTATE, cx, True), 0])
# We want angle to swing like a pendulum between 45 and 135 degrees
degree_variance = math.sin(self.ticker/6.0) * 80
bdv = -degree_variance
degree = degree_variance + 90
angle = math.radians(degree)
self.bubbles.append([self.x, self.y, angle])
degree = bdv + 90
angle = math.radians(degree)
self.bubbles.append([self.x, self.y, angle])
for b in range(len(self.bubbles)):
self.bubbles[b][0] += math.cos(self.bubbles[b][2]) * 10
self.bubbles[b][1] += math.sin(self.bubbles[b][2]) * 10
for z in range(len(self.bombs)):
self.bombs[z][2] += 0.1
if self.bombs[z][2] > 3:
self.bombs[z] = None
continue
hitlist = []
if abs(self.bombs[z][2] - 1.1) < 0.0000001:
for monster in self.MONSTERSTATE:
if abs(monster.x - self.bombs[z][0]) < 100:
if monster.y > self.bombs[z][1] - 220:
hitlist.append(monster)
for monster in hitlist:
damage = self.caster.magic[0] * random.randint(8, 12) / 20.0
monster.react_to_damage(int(damage))
self.fvm = monster
self.fvd = damage
self.caster.Take_Damage(-1)
biggerhitlist = []
for monster in self.MONSTERSTATE:
if abs(monster.x - self.x) < 400:
if monster not in biggerhitlist:
biggerhitlist.append(monster)
for monster in biggerhitlist:
damage = 1
monster.react_to_damage(int(damage))
self.fvm = monster
self.fvd = damage
while None in self.bombs:
self.bombs.remove(None)