class Event_TitleLevel:
Camera = Property.Cog()
Player = Property.Cog()
CurrentFunction = None
E1ToE2Delay = 2
def Initialize(self, initializer):
self.Space.SoundSpace.PlayMusic("Cave")
self.Player.PlayerController.Active = False
Zero.Connect(self.Space, Events.LevelStarted, self.OnLevelStart)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
if self.CurrentFunction == None: return
self.CurrentFunction()
def OnLevelStart(self, LevelStartEvent):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 1),
Vec4(0, 0, 0, 0), 0.01, 0)
self.CurrentFunction = self.E1_ActivateLogo
self.Player.PlayerController.Active = True
def E1_ActivateLogo(self):
if self.Camera.CameraFunction.FadeDone:
self.CurrentFunction = None
class PairManager:
GoldPair = Property.Cog()
HugeGoldPair = Property.Cog()
SecretPair = Property.Cog()
OriginalPlace = Property.Vector3(Vec3(-8,3,0))
NewPlace = Property.Vector3(Vec3(-5,3,0))
def Initialize(self, initializer):
self.target = None
self.childlist = (self.GoldPair,self.HugeGoldPair,self.SecretPair)
self.seq = Action.Sequence(self.Owner.Actions)
self.ResetAllPosition()
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def ResetAllPosition(self):
self.target = None
for child in self.childlist:
child.Transform.WorldTranslation = self.OriginalPlace
def OnLogicUpdate(self, UpdateEvent):
for child in self.childlist:
t = child.Transform.WorldTranslation
place = self.OriginalPlace if not child is self.target else self.NewPlace
child.Transform.WorldTranslation = 0.95 * t + 0.05 * place
def ShowTarget(self, select):
self.target = self.childlist[select] if not select is None else None
def ShowOnce(self, select):
self.ShowTarget(select)
self.seq.Cancel()
self.seq = Action.Sequence(self.Owner.Actions)
Action.Delay(self.seq,2)
Action.Call(self.seq, lambda:self.ShowTarget(None))
def OnUpdateScore(self, score, type):
self.ShowOnce(type)
for child in self.childlist[type].Hierarchy.Children:
if child.ValuePresenter:
child.ValuePresenter.OnUpdateScore(score)
def UpdateMax(self):
for child in self.childlist:
for c in child.Hierarchy.Children:
if c.ValuePresenter:
c.ValuePresenter.UpdateMax()
class HotfixTeleporter:
ActivateWhenTargetDestroy = Property.Cog()
NextLevel = Property.Level()
def Initialize(self, initializer):
self.teleporting = False
if self.ActivateWhenTargetDestroy:
self.ActivateWhenTargetDestroy.DestroyInterface.RegisterObserver(
self.Teleport)
def Teleport(self):
if not self.teleporting:
if self.NextLevel.Name != "DefaultLevel":
self.Space.FindObjectByName(
"Camera").CameraFunction.SetCameraFade(
Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1), .03, 0)
ls = self.Space.FindObjectByName("LevelSettings").LevelStart
if ls:
ls.HUDManager.HideBoxes()
hm = ls.HUDManager
hm.CacheSkills()
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, 1.5)
Action.Call(sequence,
lambda: self.Space.LoadLevel(self.NextLevel))
self.teleporting = True
class KeyHoleDoor:
KeyHole = Property.String("")
DoorTable = Property.ResourceTable()
NextLevel = Property.Level()
Teleport = Property.Cog()
SimpleTeleport = Property.Bool(False)
def Initialize(self, initializer):
Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision)
self.TryKeyEvent = Zero.ScriptEvent()
self.TryKeyEvent.Callback = lambda: self.OpenDoor()
self.TryKeyEvent.KeyHole = self.KeyHole
self.Opened = True if not self.KeyHole else False
self.observer_list = []
def OnCollision(self, CollisionEvent):
CollisionEvent.OtherObject.DispatchEvent("TryKeyEvent",
self.TryKeyEvent)
def TeleportThis(self, target):
if self.NextLevel.Name != "DefaultLevel":
self.Space.FindObjectByName("Camera").CameraFunction.SetCameraFade(
Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1), .03, 0)
sequence = Action.Sequence(self.Owner.Actions)
ls = self.Space.FindObjectByName("LevelSettings").LevelStart
if ls:
hm = ls.HUDManager
hm.CacheSkills()
Action.Delay(sequence, 1.5)
Action.Call(sequence, lambda: self.Space.LoadLevel(self.NextLevel))
elif self.Teleport:
camera = self.Space.FindObjectByName("Camera")
dest = self.Teleport.Transform.Translation
ct = camera.Transform.Translation
pt = target.Transform.Translation
#camera.CameraFunction.SetCameraFade(Vec4(0,0,0,1),Vec4(0,0,0,0),.03,0)
#camera.Transform.Translation = VectorMath.Vec3(dest.x, dest.y,ct.z)
target.Transform.Translation = VectorMath.Vec3(
dest.x, dest.y, pt.z)
def RegisterObserver(self, observer):
self.observer_list.append(observer)
def OpenDoor(self):
self.Owner.Sprite.SpriteSource = self.DoorTable.FindResource("Black")
self.Opened = True
for callback in self.observer_list:
callback()
self.observer_list = []
def IsOpened(self):
return self.Opened
class MultiObserverDelegate:
Target = Property.Cog()
def Initialize(self, initializer):
self.EnsureObservers()
self.counter = 0
def Activated():
self.counter -= 1
if self.counter == 0:
for callback in self.observers:
callback()
self.observers = None
if self.Owner.Hierarchy:
for child in self.Owner.Hierarchy.Children:
if child.MultiObserverDelegate and child.MultiObserverDelegate.Target:
self.counter += 1
child.MultiObserverDelegate.RegisterObserver(Activated)
self.counter += 1
if self.Target:
self.Target.DestroyInterface.RegisterObserver(Activated)
def EnsureObservers(self):
self.observers = []
def Null():
pass
self.EnsureObservers = Null
def RegisterObserver(self, callback):
self.EnsureObservers()
self.observers.append(callback)
class TitleLevelEvent:
Camera = Property.Cog()
Player = Property.Cog()
CurrentFunction = None
E1ToE2Delay = 2.5
def Initialize(self, initializer):
self.Space.SoundSpace.PlayMusic("Rain")
Zero.Connect(self.Space, Events.LevelStarted, self.OnLevelStart)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
if self.CurrentFunction == None: return
self.CurrentFunction()
def OnLevelStart(self, LevelStartEvent):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 1), Vec4(0, 0, 0, 0), 0.005, 0)
self.CurrentFunction = self.E1_ActivateLogo
def E1_ActivateLogo(self):
if self.Camera.CameraFunction.FadeDone :
self.CurrentFunction = None
self.Camera.ThunderGenerator.ActivateThunder()
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, self.E1ToE2Delay)
Action.Call(sequence, self.GoToE2)
def GoToE2(self):
self.Camera.CameraFunction.SetChase(0.01)
self.CurrentFunction = self.E2_CheckAnimatorEnd
def E2_CheckAnimatorEnd(self):
pass
def GoToE3(self):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 1), 0.005, 0)
self.CurrentFunction = self.E3_Done
def E3_Done(self):
if self.Camera.CameraFunction.FadeDone :
self.Space.LoadLevel("TitleScreen")
class CameraLogic:
FollowSpeed = Property.Float(0.05)
Tracker = Property.Cog()
MouseIndicator = Property.Cog()
def Initialize(self, initializer):
self.Tracker = self.Space.FindObjectByName("Player")
#self.MouseIndicator = self.Space.FindObjectByName("MouseIndicator")
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
tracked_vec = self.Tracker.Transform.Translation
self_x = self.Owner.Transform.Translation.x
self_y = self.Owner.Transform.Translation.y
self_z = self.Owner.Transform.Translation.z
self.Owner.Transform.Translation = Vec3(
tracked_vec.x * self.FollowSpeed + self_x * (1 - self.FollowSpeed),
tracked_vec.y * self.FollowSpeed + self_y * (1 - self.FollowSpeed),
self_z)
class CreateSpawnerAtInit:
Teleporter = Property.Cog()
Delay = Property.Float(5)
def Initialize(self, initializer):
self.Teleporter = self.Space.CreateAtPosition(
"EnemySpawner", self.Owner.Transform.Translation)
if not self.Owner.DestroyTeleport:
self.Owner.AddComponentByName("DestroyTeleport")
self.Teleporter.MonsterSpawner.RespawnDelay = self.Delay
class CameraLogic:
FollowSpeed = Property.Float(0.05)
Tracker = Property.Cog()
MouseIndicator = Property.Cog()
def Initialize(self, initializer):
self.Tracker = self.Space.FindObjectByName("Player")
self.MouseIndicator = self.Space.FindObjectByName("MouseIndicator")
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
tracked_vec = self.Tracker.Transform.Translation
old_vec = self.Owner.Transform.Translation
tracked_vec.z = old_vec.z
self.MouseIndicator.Transform.Translation -= self.Owner.Transform.Translation
self.Owner.Transform.Translation = tracked_vec * self.FollowSpeed + old_vec * (
1 - self.FollowSpeed)
self.MouseIndicator.Transform.Translation += self.Owner.Transform.Translation
class GotLight:
Light = Property.Cog()
Size = Property.Float(.25)
def Initialize(self, initializer):
self.Light = self.Space.CreateAtPosition("LightCircle", self.Owner.Transform.Translation)
self.Light.AttachToRelative(self.Owner)
self.Light.SphereCollider.Radius = self.Size
def ChangeSize(self, size):
self.Size = size
self.Light.SphereCollider.Radius = self.Size
class CreateSpawnerAtInit:
Teleporter = Property.Cog()
Delay = Property.Float(5)
def Initialize(self, initializer):
self.Teleporter = self.Space.CreateAtPosition("EnemySpawner", self.Owner.Transform.WorldTranslation)
seq = Action.Sequence(self.Owner.Actions)
def EnsureDestroyTeleport():
if not self.Owner.DestroyTeleport:
self.Owner.AddComponentByName("DestroyTeleport")
Action.Call(seq, EnsureDestroyTeleport)
self.Teleporter.MonsterSpawner.RespawnDelay = self.Delay
class DestroyTeleport:
TeleportTarget = Property.Cog()
def Initialize(self, initializer):
if not self.Owner.DestroyInterface:
self.Owner.AddComponentByName("DestroyInterface")
def Destroy(self):
if not self.TeleportTarget:
self.TeleportTarget = self.Owner.CreateSpawnerAtInit.Teleporter
self.TeleportTarget.MonsterSpawner.HideDestroy(self.Owner)
self.TeleportTarget.MonsterSpawner.Respawn(self.Owner)
class Triggerer:
Target = Property.Cog()
TriggerDuration = Property.Float(0)
def Initialize(self, initializer):
Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision)
self.TriggerEvent = Zero.ScriptEvent()
self.triggerable = True
if not self.Owner.SoundEmitter:
self.Owner.AddComponentByName("SoundEmitter")
self.Owner.SoundEmitter.Positional = False
def OnCollision(self, CollisionEvent):
if self.triggerable:
if CollisionEvent.OtherObject.CanTrigger and CollisionEvent.OtherObject.CanTrigger.Active:
self.triggerable = False
self.Trigger()
self.Owner.SoundEmitter.PlayCue("ButtonCue")
if self.TriggerDuration:
self.Owner.SoundEmitter.PlayCue("TickCue")
seq = Action.Sequence(self.Owner.Actions)
def Untrigger():
self.Trigger(False)
self.Owner.SoundEmitter.Stop()
self.Owner.SoundEmitter.PlayCue("WallEnterCue")
def TurnTriggerable():
self.triggerable = True
Action.Delay(seq, .5)
Action.Call(seq, TurnTriggerable)
Action.Delay(seq, self.TriggerDuration)
Action.Call(seq, Untrigger)
def Trigger(self, trigger=True):
self.TriggerEvent.Trigger = trigger
self.Target.DispatchEvent("TriggerEvent", self.TriggerEvent)
if self.Owner.AnimManager:
anim = "In" if trigger else "Out"
self.Owner.Sprite.SpriteSource = self.Owner.AnimManager.AnimTable.FindResource(
anim)
if self.Owner.Hierarchy:
for child in self.Owner.Hierarchy.Children:
if child.Triggerer:
child.Triggerer.Trigger(trigger)
class Event_IntroLevel:
Camera = Property.Cog()
CurrentFunction = None
DigipenDisplayDelay = Property.Float(2)
LogoDisplayDelay = Property.Float(0.5)
def Initialize(self, initializer):
self.Logo = self.Space.CreateAtPosition("DigipenLogo", Vec3(0, 0, 0))
Zero.Connect(self.Space, Events.LevelStarted, self.OnLevelStart)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLevelStart(self, LevelStartEvent):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 1),
Vec4(0, 0, 0, 0), 0.01, 0)
self.CurrentFunction = self.E1_ActivateLogo
self.Space.SoundSpace.PlayCue("DigiPenLogoCue")
def OnLogicUpdate(self, UpdateEvent):
if self.CurrentFunction == None: return
self.CurrentFunction()
def E1_ActivateLogo(self):
if self.Camera.CameraFunction.FadeDone:
self.CurrentFunction = None
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, self.DigipenDisplayDelay)
Action.Call(sequence, self.GoToE2)
def GoToE2(self):
self.Logo.Animator.Active = True
self.CurrentFunction = self.E2_CheckAnimatorEnd
def E2_CheckAnimatorEnd(self):
if not self.Logo.Animator.Active:
self.CurrentFunction = None
self.Space.SoundSpace.PlayCue("RavenCue")
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, self.LogoDisplayDelay)
Action.Call(sequence, self.GoToE3)
def GoToE3(self):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 0),
Vec4(0, 0, 0, 1), 0.01, 0)
self.CurrentFunction = self.E3_Done
def E3_Done(self):
if self.Camera.CameraFunction.FadeDone:
self.Space.LoadLevel("LogoScreen")
class ValuePresenter:
CollectibleTable = Property.ResourceTable("CollectibleTable")
RegisterTo = Property.Cog()
def Initialize(self, initializer):
self.hudmanager = self.Space.FindObjectByName(
"LevelSettings").HUDManager
self.hudmanager.RegisterScoreObserver(self.OnUpdateScore)
if self.RegisterTo:
self.RegisterTo.ValuePresenter.RegisterObserver(self.Owner)
self.EnsureObservers()
seq = Action.Sequence(self.Owner.Actions)
Action.Call(seq, lambda: self.OnUpdateScore(0))
def UpdateMax(self):
levelnum = self.hudmanager.GetParentSpace().CurrentLevel.Name[5]
if levelnum in "123":
self.max = self.CollectibleTable.FindValue(
self.hudmanager.GetParentSpace().CurrentLevel.Name[5])
if self.Owner.SpriteText.Text == '-':
self.Owner.SpriteText.Text = '0/' + self.max
else:
self.max = ""
self.Owner.SpriteText.Text = '-'
for child in self.observers:
child.ValuePresenter.UpdateMax()
def Null(self):
pass
def EnsureObservers(self):
self.observers = []
self.EnsureObservers = self.Null
def RegisterObserver(self, observer):
self.EnsureObservers()
self.observers.append(observer)
def OnUpdateScore(self, new_score):
self.EnsureObservers()
self.UpdateMax()
if self.max:
self.Owner.SpriteText.Text = str(new_score) + '/' + self.max
for child in self.observers:
child.ValuePresenter.OnUpdateScore(new_score)
class Triggerer:
Target = Property.Cog()
def Initialize(self, initializer):
Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision)
self.TriggerEvent = Zero.ScriptEvent()
def OnCollision(self, CollisionEvent):
if CollisionEvent.OtherObject.CanTrigger:
self.Trigger()
def Trigger(self):
self.Target.DispatchEvent("TriggerEvent", self.TriggerEvent)
if self.Owner.Hierarchy:
for child in self.Owner.Hierarchy.Children:
if child.Triggerer:
child.Triggerer.Trigger()
class Summoned:
Summoner = Property.Cog()
def Initialize(self, initializer):
self.HideAll()
if self.Summoner:
self.Summoner.TouchSummon.RegisterObserver(self.Owner)
def RegisterTo(self, accepter):
self.Summoner = accepter
accepter.TouchSummon.RegisterObserver(self.Owner)
def HideAll(self):
for child in self.Owner.Hierarchy.Children:
child.Sprite.Visible = False
def ShowAll(self):
for child in self.Owner.Hierarchy.Children:
child.Sprite.Visible = True
class LightReceiver:
last_dist = Property.Float(9999)
last_dominator = Property.Cog()
semarphor = Property.Float(0)
def Initialize(self, initializer):
pass
def AddObserver(self):
self.semarphor += 1
def RemoveObserver(self, alpha):
self.semarphor -= 1
self.last_dist = 9999
self.last_dominator = None
if self.semarphor == 0:
self.Owner.Sprite.Color = VectorMath.Vec4(0, 0, 0, alpha)
class Event_StudioLevel:
Camera = Property.Cog()
CurrentFunction = None
E1ToE2Delay = 2
def Initialize(self, initializer):
self.Space.SoundSpace.PlayMusic("Rain")
self.Space.SoundSpace.Volume *= 1.5
Zero.Connect(self.Space, Events.LevelStarted, self.OnLevelStart)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
if self.CurrentFunction == None: return
self.CurrentFunction()
def OnLevelStart(self, LevelStartEvent):
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 1),
Vec4(0, 0, 0, 0), 0.01, 0)
self.CurrentFunction = self.E1_ActivateLogo
def E1_ActivateLogo(self):
if self.Camera.CameraFunction.FadeDone:
self.CurrentFunction = None
self.Camera.ThunderGenerator.ActivateThunder()
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, self.E1ToE2Delay)
Action.Call(sequence, self.GoToE2)
def GoToE2(self):
self.CurrentFunction = self.E2_CheckAnimatorEnd
self.Camera.CameraFunction.SetCameraFade(Vec4(0, 0, 0, 0),
Vec4(0, 0, 0, 1), 0.01, 0)
def E2_CheckAnimatorEnd(self):
if self.Camera.CameraFunction.FadeDone:
self.Space.LoadLevel("MenuScreen")
class TypeScript:
String = Property.String("")
Delay = Property.Float(0)
Active = Property.Bool(True)
Repeat = Property.Bool(False)
CollisionActivate = Property.Bool(True)
EmphasizeStart = Property.Int(-1)
EmphasizeEnd = Property.Int(-1)
DestroyDelay = Property.Float(10)
Reactivatable = Property.Bool(True)
EmphasizerColor = Property.Color(Vec4(1, 0, 0, 1))
BoxColor = Property.Color(VectorMath.Vec4(.1, .1, .1, .9))
WordColor = Property.Color(VectorMath.Vec4(1, 1, 1, 1))
CreateVisual = Property.Bool(False)
VisualCueColor = Property.Color(VectorMath.Vec4(0.9, 1, 0.9, 0.27))
CharsPerLine = Property.Int(0)
ActivateWhenTargetDestroyed = Property.Cog()
ImmediatePlayMessage = Property.Bool(True)
DestroyWhenTargetDestroyed = Property.Cog()
ShouldBeRealDestroyed = Property.Bool(False)
DestroySpeed = Property.Float(0.95)
def Initialize(self, initializer):
self.Activatable = True if not self.ActivateWhenTargetDestroyed else False
self.hider = self.Space.CreateAtPosition(
"WhiteDot", self.Owner.Transform.Translation)
self.hider.AttachToRelative(self.Owner)
if self.EmphasizeStart >= 0 and self.EmphasizeEnd >= self.EmphasizeStart:
self.emphasizer = self.Space.CreateAtPosition(
"WhiteDot", self.Owner.Transform.Translation)
else:
self.emphasizer = None
self.visual_soul = None
if self.CreateVisual:
self.visual_soul = self.Space.CreateAtPosition(
"VisualSoul",
self.Owner.Transform.Translation + self.Owner.Collider.Offset)
self.visual_soul.SpriteParticleSystem.Tint = self.VisualCueColor
self.init_emit_rate = self.visual_soul.SphericalParticleEmitter.EmitRate
self.Reset()
self.destroy_registered = False
self.CurrentUpdate = self.TextBoxUpdate
self.playSuccessful = False
self.soul_size_changed = False
if self.CollisionActivate:
self.Active = False
Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision)
Zero.Connect(self.Owner, Events.CollisionEnded,
self.OnCollisionEnded)
if self.CharsPerLine:
fontheight = self.TestFontSize().y
fontwidth = self.TestFontSize().x
boxheight = math.ceil(
len(self.String) / self.CharsPerLine) * fontheight
boxwidth = self.CharsPerLine * fontwidth
self.Owner.SpriteText.Size = VectorMath.Vec2(boxwidth, boxheight)
if self.ActivateWhenTargetDestroyed:
self.Active = False
if self.visual_soul:
self.visual_soul.SphericalParticleEmitter.EmitRate = 0
def activate():
if self.visual_soul:
self.visual_soul.SphericalParticleEmitter.EmitRate = self.init_emit_rate
self.Activatable = True
if self.ImmediatePlayMessage:
self.Play()
self.RegisterIt(self.ActivateWhenTargetDestroyed, activate)
if self.DestroyWhenTargetDestroyed:
self.RegisterIt(self.DestroyWhenTargetDestroyed,
lambda: self.Owner.Destroy())
self.touched = False
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def RegisterIt(self, target, callback):
registerer = None
if target.MultiObserverDelegate:
registerer = target.MultiObserverDelegate.RegisterObserver
elif target.KeyHoleDoor:
registerer = target.KeyHoleDoor.RegisterObserver
elif target.DestroyInterface:
registerer = target.DestroyInterface.RegisterObserver
elif target.ClickReceiver:
registerer = target.ClickReceiver.RegisterObserver
if registerer:
registerer(callback)
def ResizeVisualCue(self):
if self.visual_soul and not self.soul_size_changed:
self.soul_size_changed = True
if not self.Reactivatable:
self.visual_soul.SphericalParticleEmitter.Active = False
else:
self.visual_soul.SphericalParticleEmitter.EmitRate *= 0.5
self.visual_soul.SphericalParticleEmitter.Size *= .5
self.visual_soul.SphericalParticleEmitter.EmitterSize *= .5
def OnCollision(self, CollisionEvent):
if self.Activatable:
self.touched = True
if self.CurrentUpdate == self.TextBoxUpdate:
self.Active = True
if self.CreateVisual:
self.ResizeVisualCue()
if self.Reactivatable:
if self.CurrentUpdate == self.WaitForDestroy:
self.CurrentUpdate = self.TextBoxUpdate
self.ResetColor()
self.destroy_registered = False
elif self.CurrentUpdate == self.DestroyUpdate:
self.Reset()
self.Active = True
self.destroy_registered = False
self.CurrentUpdate = self.TextBoxUpdate
def OnCollisionEnded(self, CollisionEvent):
if self.Activatable:
self.destroy_registered = True
def Play(self):
if self.Activatable:
self.Active = True
self.CurrentUpdate = self.TextBoxUpdate
self.ResizeVisualCue()
def Stop(self):
self.Active = False
def RetestSize(self):
self.tested_size = None
return self.TestFontSize()
def TestFontSize(self):
if not self.tested_size:
now_text = self.Owner.SpriteText.Text
now_size = self.Owner.SpriteText.Size
self.Owner.SpriteText.Size *= 0
self.Owner.SpriteText.Text = "A"
size = self.Owner.SpriteText.MeasureText()
self.Owner.SpriteText.Text = now_text
self.Owner.SpriteText.Size = now_size
self.tested_size = size
return self.tested_size
def ShowWord(self, i):
length = len(self.String)
i = length if i > length else i
self.Owner.SpriteText.Text = self.String[:i]
def TextBoxUpdate(self, UpdateEvent):
s = self.hider.Sprite.Size
if self.Active:
self.hider.Sprite.Visible = True
self.accum_dt += UpdateEvent.Dt
if self.accum_dt > self.Delay:
self.accum_dt = 0
self.ShowWord(self.wordhead)
if self.wordhead == len(self.String):
if self.Repeat:
self.wordhead = 1
else:
self.Active = False
self.playSuccessful = True
self.wordhead += 1
if self.emphasizer:
lastwordidx = self.wordhead - 2
if lastwordidx == self.EmphasizeStart:
self.emphasizer.Sprite.Visible = True
if lastwordidx <= self.EmphasizeEnd + 2 and lastwordidx > self.EmphasizeStart:
pos = self.Owner.SpriteText.GetCharacterPosition(
self.EmphasizeStart - 1)
self.emphasizer.Transform.Translation = Vec3(
pos.x, pos.y - self.TestFontSize().y + 0.01, 1)
x1 = self.Owner.SpriteText.GetCharacterPosition(
self.EmphasizeStart).x
x2 = self.Owner.SpriteText.GetCharacterPosition(
lastwordidx).x
self.emphasizer.Transform.Scale = Vec3((x2 - x1) / s.x,
.75, 1)
# Update hider size
ss = self.Owner.SpriteText.MeasureText()
self.hider.Transform.Scale = Vec3(ss.x / s.x + 2.6, ss.y / s.y + 1, 1)
if self.destroy_registered and not self.Active:
self.CurrentUpdate = self.WaitForDestroy
def WaitForDestroy(self, UpdateEvent):
self.accum_dt += UpdateEvent.Dt
if self.accum_dt >= self.DestroyDelay:
self.PerformDestroy()
def OnLogicUpdate(self, UpdateEvent):
if self.Activatable:
self.CurrentUpdate(UpdateEvent)
if self.playSuccessful:
self.destroy_registered = True
if self.touched and self.Activatable:
for ch in self.Owner.Collider.Contacts:
if ch.OtherObject.PlayerController:
self.destroy_registered = False
self.playSuccessful = False
if self.touched and self.destroy_registered:
self.ResizeVisualCue()
def PerformDestroy(self):
self.CurrentUpdate = self.DestroyUpdate
def DestroyUpdate(self, UpdateEvent):
self.Owner.SpriteText.Color *= VectorMath.Vec4(1, 1, 1,
self.DestroySpeed)
self.hider.Sprite.Color *= VectorMath.Vec4(1, 1, 1, self.DestroySpeed)
if self.emphasizer:
self.emphasizer.Sprite.Color *= VectorMath.Vec4(
1, 1, 1, self.DestroySpeed)
if self.ShouldBeRealDestroyed:
if self.Owner.SpriteText.Color.a < 0.01:
if self.Owner.DestroyInterface:
self.Owner.DestroyInterface.Destroy()
else:
self.Owner.Destroy()
def ResetColor(self):
if self.emphasizer:
self.emphasizer.Sprite.Color = self.EmphasizerColor
self.hider.Sprite.Color = self.BoxColor
self.Owner.SpriteText.Color = self.WordColor
def ResetScale(self):
if self.emphasizer:
self.emphasizer.Transform.Scale = Vec3(0, 0, 1)
self.hider.Transform.Scale = Vec3(0, 0, 1)
def ResetVisibility(self):
if self.emphasizer:
self.emphasizer.Sprite.Visible = False
self.hider.Sprite.Visible = False
def Rewind(self):
self.wordhead = 1
self.accum_dt = 0
self.Owner.SpriteText.Text = ""
def ResetColor(self):
self.hider.Sprite.Color = self.BoxColor
self.Owner.SpriteText.Color = self.WordColor
if self.emphasizer:
self.emphasizer.Sprite.Color = self.EmphasizerColor
def ResetTranslation(self):
self.hider.Transform.Translation = self.hider.Transform.Translation = Vec3(
-0.1, 0, -0.1)
if self.emphasizer:
self.emphasizer.Transform.Translation = self.hider.Transform.Translation = Vec3(
-0.1, 0, -0.05)
def Reset(self):
self.RetestSize()
self.Rewind()
self.ResetTranslation()
self.ResetColor()
self.ResetVisibility()
self.ResetScale()
self.ResetColor()
def Destroyed(self):
if self.visual_soul:
self.visual_soul.Destroy()
class PlayerController:
JumpStrength = Property.Float(2.0)
MoveForce = Property.Float(3.0)
JumpActive = Property.Bool(True)
HorizontalSpeedLimit = Property.Float(5)
VerticalSpeedLimit = Property.Float(20)
Mouse = Property.Cog()
FallKillLimit = Property.Float(-60)
def Initialize(self, initializer):
self.TempTick = 10
self.slope_tangent = Vec3(1,0,0)
self.OnGround = True
self.OnSlope = False
self.OnGroundUpdateEnabled = True
self.CanJump = True
self.Space.SoundSpace.PlayCue("BackgroundMusic")
self.IsBounced = False
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
self.Mouse = self.Space.FindObjectByName("MouseIndicator")
self.HorizontalLocked = False
def TriggerBounced(self):
self.IsBounced = True
self.CanJump = False
def IsOnGround(self):
return self.OnGround
def OnLogicUpdate(self, UpdateEvent):
self.Owner.Sprite.AnimationSpeed = abs(self.Owner.RigidBody.Velocity.x)
self.UpdateGroundInfo()
if self.Owner.CanHook and self.Owner.CanHook.IsHooked():
self.CanJump = False
if not self.OnGroundUpdateEnabled or not self.OnGround:
self.TempTick -= 1
if not self.IsBounced and self.TempTick < 10 and self.CanJump:
self.Owner.RigidBody.Velocity *= Vec3(0.75,1,1)
if self.TempTick == 0:
self.TempTick = 10
self.OnGroundUpdateEnabled = True
if self.CanJump:
self.CanJump = False
if not self.IsBounced:
self.Owner.RigidBody.Velocity *= Vec3(0.65,1,1)
else:
self.IsBounced=False
else:
self.TempTick = 10
if self.Owner.Transform.Translation.y < self.FallKillLimit:
self.Owner.HealthStatus.AddHealth(-10000)
# Calculate horizontal movement
force = Vec3(0,0,0)
impulse = Vec3(0,0,0)
if Zero.Keyboard.KeyIsDown(Zero.Keys.D):
if (not self.HorizontalLocked) or self.Owner.RigidBody.Velocity.x >= 0:
self.Owner.Sprite.FlipX = False
force = self.slope_tangent
elif Zero.Keyboard.KeyIsDown(Zero.Keys.A):
if (not self.HorizontalLocked) or self.Owner.RigidBody.Velocity.x <= 0:
self.Owner.Sprite.FlipX = True
force = - self.slope_tangent
# Modify behavior on the slope
if self.OnSlope:
if force.y > 0:
force *= Vec3(1, 0.005,1)
elif force.y < 0:
force *= Vec3(0.5,1,1)
#if not self.OnGround:
# force *= 0.2
#print (self.OnGround,self.Owner.RigidBody.Velocity)
# Apply horizontal movement
hinderer = .75 if self.OnGround else 0.5
if force.x * self.Owner.RigidBody.Velocity.x < self.HorizontalSpeedLimit * hinderer:
self.Owner.RigidBody.ApplyLinearImpulse(force * hinderer * self.MoveForce)
# Update vertical jumping
my_v = self.Owner.RigidBody.Velocity
jumper = my_v.y
if self.CanJump:
if (Zero.Keyboard.KeyIsPressed(Zero.Keys.W) or Zero.Keyboard.KeyIsPressed(Zero.Keys.Space)) and self.JumpActive:
jumper = self.JumpStrength
my_v *= Vec3(0.8,1,1)
self.CanJump = False
self.OnGroundUpdateEnabled = False
if self.OnGround:
my_v *= 0.9
# Apply decay
self.Owner.RigidBody.Velocity = Vec3(my_v.x * 0.998, jumper, 0)
v = self.Owner.RigidBody.Velocity
new_vx = v.x
new_vy = v.y
#if abs(v.x) > self.HorizontalSpeedLimit:
# sign = 1 if self.Owner.RigidBody.Velocity.x > 0 else -1
# new_vx = self.HorizontalSpeedLimit * sign
if abs(self.Owner.RigidBody.Velocity.y) > self.VerticalSpeedLimit:
sign = 1 if self.Owner.RigidBody.Velocity.y > 0 else -1
new_vy = self.VerticalSpeedLimit * sign
self.Owner.RigidBody.Velocity = Vec3(new_vx, new_vy,0)
def UpdateGroundInfo(self):
self.OnGround = False
self.slope_tangent = Vec3(1,0,0)
if self.OnGroundUpdateEnabled:
for ContactHolder in self.Owner.Collider.Contacts:
if ContactHolder.OtherObject.Collider.Ghost == False:
normal = - ContactHolder.FirstPoint.WorldNormalTowardsOther
if normal.y >= 0 and not self.IsSteep(normal):
self.OnGround = True
self.CanJump = True
if self.IsSlope(normal):
self.slope_tangent = Vec3(normal.y, -normal.x, 0)
self.OnSlope = True
else:
self.OnSlope = False
return
def IsSlope(self, normal):
# if slope degree > 22.5
return abs(normal.y) <= abs(normal.x) * 4
def IsSteep(self, normal):
# if slope degree > 45 + 12.5
return abs(normal.y) * 1.5 < abs(normal.x)
def LockHorizontal(self):
self.HorizontalLocked = True
def UnlockHorizontal(self):
self.HorizontalLocked = False
class LevelStart:
HUDLevel = Property.Resource("Level")
HUDManager = Property.Cog()
AbilityOverrideTable = Property.ResourceTable("AbilityTimeOverrideTable")
def Initialize(self, initializer):
self.HUDSpace = Zero.Game.FindSpaceByName("HUDSpace")
if not self.HUDSpace:
self.HUDSpace = Zero.Game.CreateNamedSpace("HUDSpace", "Space")
self.HUDSpace.LoadLevel(self.HUDLevel)
self.HUDManager = self.HUDSpace.FindObjectByName(
"LevelSettings").HUDManager
self.HUDManager.SetParentSpace(self.Space)
self.HUDManager.ShowBoxes()
self.HUDManager.HideScores()
found = self.AbilityOverrideTable.FindValue(
self.Space.CurrentLevel.Name)
if found:
override_time = float(found)
player = self.Space.FindObjectByName("Player")
player.AbilityStatus.PlantTimeOverride = override_time
if self.Space.CurrentLevel.Name[0:3] == "Hub":
self.HUDManager.ResetScores()
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
self.HUDManager.UpdateMax()
self.HUDManager.PlayMusicFor(self.Space.CurrentLevel.Name)
#elif self.Space.CurrentLevel.Name == "Level3":
# self.Space.SoundSpace.PlayMusic("Cave")
# self.sequence = Action.Sequence(self.Owner.Actions)
# self.PlayAmbient()
#elif self.Space.CurrentLevel.Name == "Level4" or self.Space.CurrentLevel.Name == "Level5":
# self.Space.SoundSpace.PlayMusic("SwampLoop")
self.player = self.Space.FindObjectByName("Player")
self.camera = self.Space.FindObjectByName("Camera")
self.CurrentUpdate = self.UpdateCamera
pt = self.player.Transform.WorldTranslation
ct = self.camera.Transform.WorldTranslation
self.camera.Transform.WorldTranslation = VectorMath.Vec3(
pt.x, pt.y + 2.5, ct.z)
def EnsureAbility(self):
self.HUDManager.GetBackSkill()
def Null():
pass
self.EnsureAbility = Null
def PlayAmbient(self):
sound = "DripCue" if random.randint(0, 1) == 1 else "DripCue2"
self.Space.SoundSpace.PlayCue(sound)
Action.Delay(self.sequence, random.random() * 7 + 7)
Action.Call(self.sequence, self.PlayAmbient)
def UpdateCamera(self):
self.camera.CameraFunction.SetCameraFade(Vec4(1, 1, 1, 1),
Vec4(1, 1, 1, 0), 0.03, 0)
self.CurrentUpdate = self.UpdateKey
def UpdateKey(self):
pass
#if Zero.Keyboard.KeyIsDown(Zero.Keys.Six):
# self.Space.LoadLevel("Level1")
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Seven):
# self.Space.LoadLevel("Level2")
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Eight):
# self.Space.LoadLevel("Level3")
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Nine):
# self.Space.LoadLevel("Level4")
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Zero):
# self.Space.LoadLevel("Level5")
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Equal):
# self.player.HealthStatus.ResetHealth()
# self.player.HealthStatus.ResetRegen()
# self.player.BlinkAnim.Active = False
# self.player.HealthStatus.Updatable = False
#elif Zero.Keyboard.KeyIsDown(Zero.Keys.Minus):
# self.player.HealthStatus.Updatable = True
def OnLogicUpdate(self, UpdateEvent):
print(self.GetCollectibleCount(), self.GetHugeCollectibleCount())
self.EnsureAbility()
self.CurrentUpdate()
#self.GetCollectibleCount()
#Zero.Disconnect(self.Space, Events.LogicUpdate, self)
def GetCollectibleCount(self):
return len(list(self.Space.FindAllObjectsByName("Gold")))
def GetHugeCollectibleCount(self):
return len(list(self.Space.FindAllObjectsByName("HugeGold")))
def RemoveHUD(self):
self.HUDSpace.Destroy()
class CameraFunction:
# Shaking Variables
ShakeEnable = False
ShakeInX = False
ShakeRadiusX = 0
ShakeInY = False
ShakeRadiusY = 0
ShakeDelay = 0
ShakeTimer = 0
ShakeCenter = Vec3(0, 0, 0)
# Fading Variables
FadeEnable = False
FadeLayerDepthRelative = Property.Float(-5)
FadeColorStart = Vec4(0, 0, 0, 0)
FadeColorEnd = Vec4(0, 0, 0, 0)
FadeDelay = 0
FadeTimer = 0
FadeRDelta = 0
FadeGDelta = 0
FadeBDelta = 0
FadeADelta = 0
FadeEndFlag = False
FadeDone = True
# Follow & Chase Offsex
OffsexY = Property.Float(0)
# Follow Variables
FollowEnable = Property.Bool(False)
FollowTarget = Property.Cog()
# Chase Variables
ChaseEnable = Property.Bool(False)
ChaseTarget = Property.Cog()
ChaseSpeed = 0
# Shift Variables
ShiftEnable = False
ShiftStartPos = Vec3(0, 0, 0)
ShiftTargetPos = Vec3(0, 0, 0)
ShiftSpeed = 0
ShiftTimer = 0
ShiftDelay = 0
ShiftTravelBack = False
ShiftAction = None
FadeLayer = Property.Cog()
# Froze
Forze = Property.Bool(False)
def Initialize(self, initializer):
if not self.FadeLayer:
self.FadeLayer = self.Space.Create("Sprite")
self.FadeLayer.AttachToRelative(self.Owner)
self.FadeLayer.Transform.LocalTranslation = Vec3(
0, 0, self.FadeLayerDepthRelative)
self.FadeLayer.Sprite.Color = Vec4(0, 0, 0, 0)
self.FadeLayer.Transform.WorldScale = Vec3(
self.Owner.Camera.Size * 2, self.Owner.Camera.Size * 2, 1)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def EnsureFadeLayer(self):
if not self.FadeLayer:
self.FadeLayer = self.Space.Create("Sprite")
self.FadeLayer.AttachToRelative(self.Owner)
self.FadeLayer.Transform.LocalTranslation = Vec3(
0, 0, self.FadeLayerDepthRelative)
self.FadeLayer.Sprite.Color = Vec4(0, 0, 0, 0)
self.FadeLayer.Transform.WorldScale = Vec3(
self.Owner.Camera.Size * 2, self.Owner.Camera.Size * 2, 1)
def OnLogicUpdate(self, UpdateEvent):
if self.Forze: return
if self.ShiftEnable:
self.ShiftUpdate(UpdateEvent)
else:
if self.FollowEnable: self.FollowUpdate(UpdateEvent)
if self.ChaseEnable: self.ChaseUpdate(UpdateEvent)
if self.ShakeEnable: self.ShakeUpdate(UpdateEvent)
if self.FadeEnable: self.FadeUpdate(UpdateEvent)
def SetPos(self, pos):
self.Owner.Transform.WorldTranslation = pos
def FollowUpdate(self, UpdateEvent):
if self.FollowTarget == None: return
self.Owner.Transform.Translation = Vec3(
self.FollowTarget.Transform.WorldTranslation.x,
self.FollowTarget.Transform.WorldTranslation.y + self.OffsexY,
self.Owner.Transform.WorldTranslation.z)
if self.ShakeEnable:
self.ShakeCenter = self.Owner.Transform.WorldTranslation
def SetFollowTarget(self, target):
self.ChaseEnable = False
self.FollowEnable = True
self.FollowTarget = target
def TurnOffCameraFollow(self):
self.FollowEnable = False
self.FollowTarget = None
def ChaseUpdate(self, UpdateEvent):
if self.ChaseTarget == None: return
target = Vec3(
self.ChaseTarget.Transform.WorldTranslation.x,
self.ChaseTarget.Transform.WorldTranslation.y + self.OffsexY,
self.ChaseTarget.Transform.WorldTranslation.z)
towardVec = target - self.Owner.Transform.WorldTranslation
towardVec.z = 0
if (math.fabs(towardVec.length()) > 0.5):
self.Owner.Transform.Translation += towardVec * self.ChaseSpeed
if self.ShakeEnable:
self.ShakeCenter = self.Owner.Transform.WorldTranslation
def SetChaseTarget(self, target, speed):
self.FollowEnable = False
self.ChaseEnable = True
self.ChaseTarget = target
self.ChaseSpeed = speed
def SetChase(self, speed):
self.FollowEnable = False
self.ChaseEnable = True
self.ChaseSpeed = speed
def TurnOffCameraChase(self):
self.ChaseEnable = False
self.ChaseTarget = None
def ShiftUpdate(self, UpdateEvent):
if not self.ShiftAction == None:
self.ShiftAction(UpdateEvent)
def ShitfStage1(self, UpdateEvent):
towardVec = self.ShiftTargetPos - self.Owner.Transform.WorldTranslation
towardVec.z = 0
if (math.fabs(towardVec.length()) > 0.5):
self.Owner.Transform.Translation += towardVec * self.ShiftSpeed
else:
self.ShiftAction = self.ShitfStage2
def ShitfStage2(self, UpdateEvent):
self.ShiftTimer += UpdateEvent.Dt
if self.ShiftTimer > self.ShiftDelay:
self.ShiftAction = self.ShitfStage3
def ShitfStage3(self, UpdateEvent):
if self.ShiftTravelBack:
towardVec = self.ShiftStartPos - self.Owner.Transform.WorldTranslation
towardVec.z = 0
if (math.fabs(towardVec.length()) > 0.5):
self.Owner.Transform.Translation += towardVec * self.ShiftSpeed
else:
self.TurnOffCameraShift()
else:
self.Owner.Transform.Translation = Vec3(
self.ShiftStartPos.x, self.ShiftStartPos.y,
self.Owner.Transform.WorldTranslation.z)
self.TurnOffCameraShift()
def SetShiftTarget(self, targetPos, speed, cd, travelback):
if self.ShiftEnable: return
self.ShiftEnable = True
self.ShiftStartPos = Vec3(self.Owner.Transform.Translation.x,
self.Owner.Transform.Translation.y, 0)
self.ShiftTargetPos = targetPos
self.ShiftSpeed = speed
self.ShiftDelay = cd
self.ShiftTimer = 0
self.ShiftTravelBack = travelback
self.ShiftAction = self.ShitfStage1
def TurnOffCameraShift(self):
self.ShiftAction = None
self.ShiftTimer = 0
self.ShiftEnable = False
def ShakeUpdate(self, UpdateEvent):
if (self.ShakeDelay > 0):
self.ShakeTimer += UpdateEvent.Dt
if (self.ShakeTimer < self.ShakeDelay):
return
else:
self.ShakeTimer = 0
result = Vec3(0, 0, 0)
if self.ShakeInX:
result += Vec3(
random.uniform(-self.ShakeRadiusX, self.ShakeRadiusX), 0, 0)
if self.ShakeInY:
result += Vec3(
0, random.uniform(-self.ShakeRadiusY, self.ShakeRadiusY), 0)
self.Owner.Transform.Translation = self.ShakeCenter + result
def SetCameraShake(self, x_Enable, x_Radius, y_Enable, y_Radius, time, cd):
if self.ShakeEnable: return
self.ShakeEnable = True
self.ShakeCenter = self.Owner.Transform.Translation
self.ShakeInX = x_Enable
self.ShakeInY = y_Enable
self.ShakeRadiusX = x_Radius
self.ShakeRadiusY = y_Radius
self.ShakeDelay = cd
self.ShakeTimer = 0
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, time)
Action.Call(sequence, self.TurnOffCameraShake)
def SetCameraShakeCenter(self, center):
self.ShakeCenter = center
def TurnOffCameraShake(self):
self.ShakeEnable = False
self.ShakeInY = False
self.ShakeInX = False
self.ShakeTimer = 0
self.ShakeDelay = 0
self.Owner.Transform.Translation = self.ShakeCenter
def FadeUpdate(self, UpdateEvent):
if (self.FadeDelay > 0):
self.FadeTimer += UpdateEvent.Dt
if (self.FadeTimer < self.FadeDelay):
return
else:
self.FadeTimer = 0
result = self.FadeLayer.Sprite.Color + Vec4(
self.FadeRDelta, self.FadeGDelta, self.FadeBDelta, self.FadeADelta)
self.FadeEndFlag = self.clampCheck(0.0, result.x, 1.0)
if self.FadeEndFlag: self.clamp(0.0, result.x, 1.0)
self.FadeEndFlag = self.clampCheck(0.0, result.y, 1.0)
if self.FadeEndFlag: self.clamp(0.0, result.y, 1.0)
self.FadeEndFlag = self.clampCheck(0.0, result.z, 1.0)
if self.FadeEndFlag: self.clamp(0.0, result.z, 1.0)
self.FadeEndFlag = self.clampCheck(0.0, result.a, 1.0)
if self.FadeEndFlag: self.clamp(0.0, result.a, 1.0)
if self.FadeEndFlag:
self.FadeLayer.Sprite.Color = self.FadeColorEnd
self.TurnOffCameraFade()
else:
self.FadeLayer.Sprite.Color = result
def SetCameraFade(self, startColor, endColor, deltaRate, cd):
#if self.FadeEnable: return
self.EnsureFadeLayer()
self.FadeColorStart = startColor
self.FadeColorEnd = endColor
delta = endColor - startColor
self.FadeRDelta = delta.x * deltaRate
self.FadeGDelta = delta.y * deltaRate
self.FadeBDelta = delta.z * deltaRate
self.FadeADelta = delta.a * deltaRate
self.FadeLayer.Sprite.Color = startColor
self.FadeDelay = cd
self.FadeEnable = True
self.FadeDone = False
def TurnOffCameraFade(self):
self.FadeEnable = False
self.FadeColorStart = Vec4(0, 0, 0, 0)
self.FadeColorEnd = Vec4(0, 0, 0, 0)
self.FadeDelay = 0
self.FadeTimer = 0
self.FadeRDelta = 0
self.FadeGDelta = 0
self.FadeBDelta = 0
self.FadeADelta = 0
self.FadeEndFlag = False
self.FadeDone = True
# Helper
def clampCheck(self, minimum, x, maximum):
return x > maximum or x < minimum
def clamp(self, minimum, x, maximum):
return max(minimum, min(x, maximum))
class HUDManager:
MusicTable = Property.ResourceTable("MusicTable")
CollectibleTable = Property.ResourceTable("CollectibleTable")
Menu = Property.Cog()
Indicator = Property.Cog()
ScoreUI = Property.Cog()
PairUI = Property.Cog()
SoundEmitter = Property.Cog()
PBoxSmall = Property.Cog()
PBoxLarge = Property.Cog()
PBoxSmallBack = Property.Cog()
PBoxLargeBack = Property.Cog()
ForcedTreeSkill = Property.ResourceTable("ForcedTreeSkill")
ForcedPhysSkill = Property.ResourceTable("ForcedPhysSkill")
LevelJumpTable = Property.ResourceTable("LevelJumpTable")
def Initialize(self, initializer):
self.ParentSpace = None
self.MusicActive = False
self.MusicName = ""
self.Camera = self.Space.FindObjectByName("Camera")
self.Hider = self.Space.CreateAtPosition(
"Sprite", self.Camera.Transform.Translation)
self.Hider.AttachToRelative(self.Camera)
self.Hider.Transform.Translation -= Vec3(0, 0, 50)
self.Hider.Sprite.Color = Vec4(0, 0, 0, 0)
self.Hider.Transform.Scale = Vec3(100, 100, 1)
self.hiding_boxes = False
self.Player = None
self.skillnames = None
self.final_alpha = 0
self.EnsureReloadObserver()
self.EnsureScores()
self.EnsureScoreObservers()
self.is_showing_credits = False
self.PauseDisabled = False
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def RegisterReloadObserver(self, callback):
self.reload_observers.append(callback)
def Null(self):
pass
def EnsureReloadObserver(self):
self.reload_observers = []
self.EnsureReloadObserver = self.Null
def ShowScores(self):
self.cached_loc = self.ScoreUI.Transform.WorldTranslation
self.PauseDisabled = True
#self.ScoreUI.Transform.WorldTranslation = Vec3(3.5, 0.496,0)
self.ScoreUI.HiderScript.Hide()
self.HideBoxesSmooth()
def HideScores(self):
if self.ScoreUI:
self.PauseDisabled = False
self.ScoreUI.HiderScript.Unhide()
#self.ScoreUI.Transform.WorldTranslation = self.cached_loc
self.ShowBoxesSmooth()
def PlayMusicFor(self, LevelName):
mn = self.MusicTable.FindValue(LevelName)
print(LevelName, mn, self.MusicName)
if mn != self.MusicName:
self.SoundEmitter.SoundEmitter.Stop()
self.PlayMusic(mn)
pass
def EnsureScoreObservers(self):
self.score_observers = []
self.EnsureScoreObservers = self.Null
def EnsureScores(self):
self.scores = [0, 0, 0]
self.EnsureScores = self.Null
def AddScore(self, score, type):
self.EnsureScores()
self.scores[type] += score
self.PairUI.PairManager.OnUpdateScore(self.scores[type], type)
def UpdateMax(self):
self.PairUI.PairManager.UpdateMax()
def GetScore(self, score, type):
return self.scores[type]
def ResetScores(self):
self.scores = [0, 0, 0]
def RegisterScoreObserver(self, callback):
self.EnsureScoreObservers()
self.score_observers.append(callback)
def GetParentSpace(self):
return self.ParentSpace
def SetParentSpace(self, space):
self.ParentSpace = space
self.Player = self.ParentSpace.FindObjectByName("Player")
def HideAll(self):
self.Owner.CameraViewport.Layer = -1
def ShowAll(self):
self.Owner.CameraViewport.Layer = 1
def PlayMusic(self, MusicName):
if MusicName:
self.MusicActive = True
self.MusicName = MusicName
#self.Space.SoundSpace.PlayCue(self.MusicName)
self.SoundEmitter.SoundEmitter.PlayCue(self.MusicName)
#self.Space.SoundSpace.Volume = 0
def GetMusicName(self):
return self.MusicName
def MusicActive(self):
return self.MusicActive
def StopMusic(self):
self.MusicActive = False
self.SoundEmitter.SoundEmitter.Stop()
def SetHiderAlpha(self, final_alpha):
c = self.Hider.Sprite.Color
self.Hider.Sprite.Color = Vec4(c.x, c.y, c.z,
c.a * 0.9 + final_alpha * 0.1)
if abs(final_alpha - c.a) > 0.05:
Action.Call(self.sequence, self.SetHiderAlpha, final_alpha)
else:
self.Hider.Sprite.Color = Vec4(c.x, c.y, c.z, final_alpha)
def OnLogicUpdate(self, UpdateEvent):
if not self.PauseDisabled and Zero.Keyboard.KeyIsPressed(
Zero.Keys.Escape):
if self.ParentSpace.TimeSpace.Paused:
self.Space.FindObjectByName("CreditShower").FadeAnim.FadeOut()
self.is_showing_credits = False
self.ResumeGame()
else:
self.PauseGame()
self.final_alpha = .8 if self.ParentSpace.TimeSpace.Paused else 0
c = self.Hider.Sprite.Color
if abs(self.final_alpha - c.a) > 0.05:
self.Hider.Sprite.Color = Vec4(c.x, c.y, c.z,
c.a * 0.6 + self.final_alpha * 0.4)
else:
self.Hider.Sprite.Color = Vec4(c.x, c.y, c.z, self.final_alpha)
if self.ParentSpace.TimeSpace.Paused:
keypressed = Zero.Keyboard.KeyIsPressed(
Zero.Keys.Space) or Zero.Keyboard.KeyIsPressed(Zero.Keys.Enter)
buttonpressed = Zero.Mouse.IsButtonDown(Zero.MouseButtons.Left)
if self.is_showing_credits:
#pass
if keypressed or buttonpressed:
self.ShowBoxes()
self.ScoreUI.Transform.WorldTranslation = self.score_UI_position
self.Menu.FadeAnim.FadeIn()
self.Indicator.FadeAnim.FadeIn()
self.Space.FindObjectByName(
"CreditShower").FadeAnim.FadeOut()
self.is_showing_credits = False
elif not self.is_showing_credits:
if Zero.Keyboard.KeyIsPressed(
Zero.Keys.W) or Zero.Keyboard.KeyIsPressed(
Zero.Keys.Up):
self.Menu.Menu.Increment()
if Zero.Keyboard.KeyIsPressed(
Zero.Keys.S) or Zero.Keyboard.KeyIsPressed(
Zero.Keys.Down):
self.Menu.Menu.Decrement()
if keypressed or buttonpressed:
code = self.Menu.Menu.GetActionCode()
if code == "RestartCheckPoint":
self.ResumeGame()
self.Player.CanFancyDie.Die()
elif code == "RestartLevel":
self.HideBoxes()
def reload_callback():
for callback in self.reload_observers:
callback()
self.ResumeGame()
self.ParentSpace.FindObjectByName(
"Camera").CameraFunction.SetCameraFade(
Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1), .04, 0)
self.Player.RigidBody.Kinematic = True
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, .8)
Action.Call(
sequence, lambda: self.ParentSpace.LoadLevel(
self.ParentSpace.CurrentLevel))
Action.Delay(sequence, .801)
Action.Call(sequence, reload_callback)
elif code == "ExitLevel":
self.ResumeGame()
self.Player.RigidBody.Kinematic = True
self.ParentSpace.FindObjectByName(
"Camera").CameraFunction.SetCameraFade(
Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 1), .04, 0)
sequence = Action.Sequence(self.ParentSpace.Actions)
Action.Delay(sequence, .8)
Action.Call(
sequence,
lambda: self.ParentSpace.LoadLevel("MenuScreen"))
self.Space.Destroy()
elif code == "Credits":
self.Space.FindObjectByName(
"CreditShower").FadeAnim.FadeIn()
self.HideBoxesSmooth()
self.score_UI_position = self.ScoreUI.Transform.Translation
self.ScoreUI.Transform.Translation = Vec3(7.836, 0, 0)
self.Menu.FadeAnim.FadeOut()
self.Indicator.FadeAnim.FadeOut()
self.is_showing_credits = True
elif code == "Exit":
self.ResumeGame()
self.Player.RigidBody.Kinematic = True
self.ParentSpace.FindObjectByName(
"Camera").CameraFunction.SetCameraFade(
Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 1), .06, 0)
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, .5)
Action.Call(sequence, lambda: Zero.Game.Quit())
elif code == "Skip":
levelname = self.LevelJumpTable.FindValue(
self.ParentSpace.CurrentLevel.Name)
if levelname:
self.HideBoxes()
def reload_callback():
for callback in self.reload_observers:
callback()
self.ResumeGame()
self.CacheSkills()
self.ParentSpace.FindObjectByName(
"Camera").CameraFunction.SetCameraFade(
Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1), .04, 0)
self.Player.RigidBody.Kinematic = True
sequence = Action.Sequence(self.Owner.Actions)
Action.Delay(sequence, .8)
Action.Call(
sequence,
lambda: self.ParentSpace.LoadLevel(levelname))
Action.Delay(sequence, .801)
Action.Call(sequence, reload_callback)
elif code == "Resume":
self.ResumeGame()
def SetBoxVisible(self, visible):
self.PBoxLarge.Sprite.Visible = visible
self.PBoxSmall.Sprite.Visible = visible
self.PBoxLargeBack.Sprite.Visible = visible
self.PBoxSmallBack.Sprite.Visible = visible
def HideBoxes(self):
self.SetBoxVisible(False)
def ShowBoxes(self):
self.SetBoxVisible(True)
def ResumeGame(self):
if self.ParentSpace.TimeSpace.Paused:
self.ParentSpace.TimeSpace.TogglePause()
self.Menu.FadeAnim.FadeOut()
self.Indicator.FadeAnim.FadeOut()
self.ScoreUI.Transform.Translation = Vec3(7.836, 0, 0)
def PauseGame(self):
if not self.ParentSpace.TimeSpace.Paused:
self.PairUI.PairManager.ResetAllPosition()
self.ParentSpace.TimeSpace.TogglePause()
self.Menu.FadeAnim.FadeIn()
self.Indicator.FadeAnim.FadeIn()
self.ScoreUI.Transform.Translation = Vec3(-4.902, 2, 0)
def CacheSkills(self):
ts = self.Player.AbilityStatus.GetTreeSkillName()
ps = self.Player.AbilityStatus.GetPhysSkillName()
self.skillnames = (ts, ps)
def GetBackSkill(self):
fts = self.ForcedTreeSkill.FindValue(
self.ParentSpace.CurrentLevel.Name)
fps = self.ForcedPhysSkill.FindValue(
self.ParentSpace.CurrentLevel.Name)
if self.skillnames:
if not fts:
fts = self.skillnames[0]
if not fps:
fps = self.skillnames[1]
self.Player.AbilityStatus.SwapTreeSkill(fts)
self.Player.AbilityStatus.SwapPhysSkill(fps)
def HideBoxesSmooth(self):
self.PBoxLarge.HiderScript.Hide()
self.PBoxSmall.HiderScript.Hide()
self.PBoxLargeBack.HiderScript.Hide()
self.PBoxSmallBack.HiderScript.Hide()
def ShowBoxesSmooth(self):
self.PBoxLarge.HiderScript.Unhide()
self.PBoxSmall.HiderScript.Unhide()
self.PBoxLargeBack.HiderScript.Unhide()
self.PBoxSmallBack.HiderScript.Unhide()
class Parallax:
Active = Property.Bool(True)
DebugDraw= Property.Bool(False)
OffsetY = Property.Float(0)
ScaleX = Property.Float(2)
ScaleY = Property.Float(2)
Layer = Property.Int(-5)
Image = Property.Resource("SpriteSource")
Camera = Property.Cog()
Player = Property.Cog()
ScrollX = Property.Float(1.25)
ScrollY = Property.Float(1)
Org = Vec3(0, 0, 0)
def Initialize(self, initializer):
if not self.Active: return
self.Owner.Transform.WorldTranslation = Vec3(self.Camera.Transform.WorldTranslation.x, self.Owner.Transform.WorldTranslation.y + self.OffsetY, self.Layer)
self.Center = self.Space.Create("Sprite")
self.Center.Transform.WorldTranslation = self.Owner.Transform.WorldTranslation
self.Center.Sprite.SpriteSource = self.Image
self.Center.Transform.Scale = Vec3(self.ScaleX, self.ScaleY, 1)
self.Center.AttachToRelative(self.Owner)
self.Width = self.Center.Sprite.Size.x
self.HalfWidth = self.Width/2
self.DefaultY = self.Owner.Transform.WorldTranslation.y
self.Right = self.Space.Create("Sprite")
self.Right.Transform.WorldTranslation = self.Owner.Transform.WorldTranslation
self.Right.Transform.WorldTranslation += Vec3(self.Width * self.ScaleX, 0, 0)
self.Right.Sprite.SpriteSource = self.Image
self.Right.Transform.Scale = Vec3(self.ScaleX, self.ScaleY, 1)
self.Right.AttachToRelative(self.Owner)
self.Left = self.Space.Create("Sprite")
self.Left.Transform.WorldTranslation = self.Owner.Transform.WorldTranslation
self.Left.Transform.WorldTranslation -= Vec3(self.Width * self.ScaleX, 0, 0)
self.Left.Sprite.SpriteSource = self.Image
self.Left.Transform.Scale = Vec3(self.ScaleX, self.ScaleY, 1)
self.Left.AttachToRelative(self.Owner)
if self.DebugDraw:
self.Center.Sprite.Color = Vec4(0, 1, 0, 1)
self.Right.Sprite.Color = Vec4(0, 0, 1, 1)
self.Left.Sprite.Color = Vec4(1, 0, 0, 1)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
def OnLogicUpdate(self, UpdateEvent):
if not self.Active: return
vecDistance = self.Camera.Transform.WorldTranslation - self.Org
vecDistance = Vec3(vecDistance.x * self.ScrollX, vecDistance.y * self.ScrollY + self.OffsetY, self.Layer)
self.Owner.Transform.Translation = vecDistance
self.CheckPlayerLocation()
def CheckPlayerLocation(self):
#case Right
if self.Player.Transform.WorldTranslation.x > self.Right.Transform.WorldTranslation.x - self.HalfWidth:
self.Left.Transform.WorldTranslation = self.Right.Transform.WorldTranslation + Vec3(self.Width * self.ScaleX, 0, 0)
temp = self.Left
self.Left = self.Center
self.Center = self.Right
self.Right = temp
# case Left
if self.Player.Transform.WorldTranslation.x < self.Left.Transform.WorldTranslation.x + self.HalfWidth:
self.Right.Transform.WorldTranslation = self.Left.Transform.WorldTranslation - Vec3(self.Width * self.ScaleX, 0, 0)
temp = self.Right
self.Right = self.Center
self.Center = self.Left
self.Left = temp
class LevelStart:
HUDLevel = Property.Resource("Level")
HUDManager = Property.Cog()
def Initialize(self, initializer):
self.HUDSpace = Zero.Game.FindSpaceByName("HUDSpace")
if not self.HUDSpace:
self.HUDSpace = Zero.Game.CreateNamedSpace("HUDSpace", "Space")
self.HUDSpace.LoadLevel(self.HUDLevel)
self.HUDManager = self.HUDSpace.FindObjectByName(
"LevelSettings").HUDManager
self.HUDManager.SetParentSpace(self.Space)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
self.HUDManager.PlayMusicFor(self.Space.CurrentLevel.Name)
#elif self.Space.CurrentLevel.Name == "Level3":
# self.Space.SoundSpace.PlayMusic("Cave")
# self.sequence = Action.Sequence(self.Owner.Actions)
# self.PlayAmbient()
#elif self.Space.CurrentLevel.Name == "Level4" or self.Space.CurrentLevel.Name == "Level5":
# self.Space.SoundSpace.PlayMusic("SwampLoop")
self.player = self.Space.FindObjectByName("Player")
self.camera = self.Space.FindObjectByName("Camera")
self.CurrentUpdate = self.UpdateCamera
def EnsureAbility(self):
self.HUDManager.GetBackSkill()
def Null():
pass
self.EnsureAbility = Null
def PlayAmbient(self):
sound = "DripCue" if random.randint(0, 1) == 1 else "DripCue2"
self.Space.SoundSpace.PlayCue(sound)
Action.Delay(self.sequence, random.random() * 7 + 7)
Action.Call(self.sequence, self.PlayAmbient)
def UpdateCamera(self):
self.camera.CameraFunction.SetCameraFade(Vec4(1, 1, 1, 1),
Vec4(1, 1, 1, 0), 0.03, 0)
self.CurrentUpdate = self.UpdateKey
def UpdateKey(self):
if Zero.Keyboard.KeyIsDown(Zero.Keys.Six):
self.Space.LoadLevel("Level1")
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Seven):
self.Space.LoadLevel("Level2")
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Eight):
self.Space.LoadLevel("Level3")
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Nine):
self.Space.LoadLevel("Level4")
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Zero):
self.Space.LoadLevel("Level5")
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Equal):
self.player.HealthStatus.ResetHealth()
self.player.HealthStatus.ResetRegen()
self.player.BlinkAnim.Active = False
self.player.HealthStatus.Updatable = False
elif Zero.Keyboard.KeyIsDown(Zero.Keys.Minus):
self.player.HealthStatus.Updatable = True
def OnLogicUpdate(self, UpdateEvent):
self.EnsureAbility()
self.CurrentUpdate()
class FreezableFlow:
FreezeDelay = Property.Float(1)
FreezingObject = Property.Cog()
def Initialize(self, initializer):
self.StartFreezing = False
self.FreezeCounter = 0
self.Activated = False
Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision)
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
Zero.Connect(self.Owner, "FreezeFlowEvent", self.StartFreeze)
def StartFreeze(self, FreezeEvent=None):
if not self.Activated:
self.StartFreezing = True
self.Owner.DragEffect.Active = True
if self.Owner.BuoyancyEffect:
self.Owner.BuoyancyEffect.Active = False
def OnLogicUpdate(self, UpdateEvent):
if not self.Activated:
if self.StartFreezing:
if self.FreezingObject:
self.last_pos = self.FreezingObject.Transform.WorldTranslation
self.FreezeCounter += UpdateEvent.Dt
self.Owner.DragEffect.Drag *= 1.1
if self.Owner.FlowEffect:
self.Owner.FlowEffect.FlowSpeed *= 0.95
#self.Owner.AddComponentByName("FreezeAnim")
if self.FreezeCounter > self.FreezeDelay:
#freezeflow = Zero.ScriptEvent()
#self.Owner.Region.DispatchEvent("FreezeFlowEvent", freezeflow)
self.Activated = True
self.Owner.Collider.Ghost = False
self.Owner.DragEffect.Active = False
if self.Owner.FlowEffect:
self.Owner.FlowEffect.Active = False
self.Owner.GravityEffect.Active = True
for contactholder in self.Owner.Collider.Contacts:
otherobj = contactholder.OtherObject
if otherobj.MouseLocationIndicator:
continue
elif otherobj.CannotBeFrozen:
continue
elif otherobj.GrowableGround:
continue
elif otherobj.PlantAnnihilator:
continue
if otherobj.RigidBody:
otherobj.RigidBody.Kinematic= False
otherobj.RigidBody.Static= True
if otherobj.AIMovementInterface:
otherobj.AIMovementInterface.Deactivate()
if otherobj.BurnAnim:
otherobj.BurnAnim.Active = False
if otherobj.PoisonAnim:
otherobj.PoisonAnim.Active = False
if otherobj.FreezeAnim:
otherobj.FreezeAnim.Active = False
if otherobj.Hierarchy and not otherobj.FreezableFlow:
for child in otherobj.Hierarchy.Children:
if child.Sprite:
child.Sprite.AnimationActive = False
if otherobj.FreezableFlow:
otherobj.FreezableFlow.DirectActivate(self.Owner)
otherobj.Transform.Translation *= VectorMath.Vec3(1,1,-1)
else:
effect_active = False
for contactholder in self.Owner.Collider.Contacts:
if contactholder.OtherObject.CannotBeFrozen:
effect_active = True
if not effect_active:
s = self.Owner.Sprite.Color
self.Owner.Sprite.Color = VectorMath.Vec4(s.x * 2.3, s.y * 2.3, s.z * 2.3, 1)
self.Owner.GravityEffect.Active = False
if self.Owner.CanHurt:
self.Owner.CanHurt.Active = False
if self.FreezingObject:
self.Owner.WaterLayerGenerator.FreezeAt(self.FreezingObject.Transform.WorldTranslation)
else:
self.Owner.WaterLayerGenerator.FreezeAt(self.last_pos)
self.Owner.AddComponentByName("IsSentry")
Zero.Disconnect(self.Space, Events.LogicUpdate, self)
def DirectActivate(self, obj):
if not self.Activated:
self.FreezingObject = obj
self.StartFreeze()
def OnCollision(self, CollisionEvent):
if not self.Activated:
otherobj = CollisionEvent.OtherObject
if otherobj.CanFreeze and otherobj.CanFreeze.Active:
self.FreezingObject = CollisionEvent.OtherObject
self.StartFreeze()
class PlayerController:
JumpStrength = Property.Float(2.0)
MoveForce = Property.Float(3.0)
JumpActive = Property.Bool(True)
HorizontalSpeedLimit = Property.Float(5)
VerticalSpeedLimit = Property.Float(20)
Mouse = Property.Cog()
FallKillLimit = Property.Float(-60)
DontUpdateAnim = Property.Bool(False)
AnimTable = Property.ResourceTable("PlayerAnimTable")
def Initialize(self, initializer):
self.TempTick = 10
self.slope_tangent = Vec3(1, 0, 0)
self.OnGround = True
self.OnSlope = False
self.OnGroundUpdateEnabled = True
self.CanJump = True
self.IsBounced = False
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
self.Mouse = self.Space.FindObjectByName("MouseIndicator")
self.animstate = "Stand"
self.HorizontalLocked = False
def TriggerBounced(self):
self.IsBounced = True
self.CanJump = False
def IsOnGround(self):
return self.OnGround
def PlayPainAnim(self):
self.Owner.Sprite.SpriteSource = self.AnimTable.FindValue("Pain")
def OnLogicUpdate(self, UpdateEvent):
#self.Owner.Sprite.AnimationSpeed = abs(self.Owner.RigidBody.Velocity.x)
self.UpdateGroundInfo()
if self.Owner.CanHook and self.Owner.CanHook.IsHooked():
self.CanJump = False
if not self.OnGroundUpdateEnabled or not self.OnGround:
self.TempTick -= 1
if not self.IsBounced and self.TempTick < 10 and self.CanJump:
self.Owner.RigidBody.Velocity *= Vec3(0.75, 1, 1)
if self.TempTick == 0:
self.TempTick = 10
self.OnGroundUpdateEnabled = True
if self.CanJump:
self.CanJump = False
if not self.IsBounced:
self.Owner.RigidBody.Velocity *= Vec3(0.65, 1, 1)
else:
self.IsBounced = False
else:
self.TempTick = 10
if self.Owner.Transform.Translation.y < self.FallKillLimit:
self.Owner.HealthStatus.AddHealth(-10000)
#UpdateAnimation
self.UpdateAnimation()
# Calculate horizontal movement
force = Vec3(0, 0, 0)
impulse = Vec3(0, 0, 0)
if Zero.Keyboard.KeyIsDown(Zero.Keys.D):
if not self.DontUpdateAnim and not self.Mouse or not self.Mouse.MouseLocationIndicator.AbsorbActive:
self.Owner.Sprite.FlipX = False
if (not self.HorizontalLocked
) or self.Owner.RigidBody.Velocity.x >= 0:
force = self.slope_tangent
elif Zero.Keyboard.KeyIsDown(Zero.Keys.A):
#if not self.Owner.CanHook.IsHooked():
if not self.DontUpdateAnim and not self.Mouse or not self.Mouse.MouseLocationIndicator.AbsorbActive:
self.Owner.Sprite.FlipX = True
if (not self.HorizontalLocked
) or self.Owner.RigidBody.Velocity.x <= 0:
force = -self.slope_tangent
if self.Owner.AlternateSoundEmitter:
if self.OnGround and (
Zero.Keyboard.KeyIsDown(Zero.Keys.D)
or Zero.Keyboard.KeyIsDown(Zero.Keys.A)) and abs(
self.Owner.RigidBody.Velocity.x) > 0.5:
self.Owner.AlternateSoundEmitter.Active = True
else:
self.Owner.AlternateSoundEmitter.Active = False
# Modify behavior on the slope
if self.OnSlope:
if force.y > 0:
force *= Vec3(1, 0.005, 1)
elif force.y < 0:
force *= Vec3(0.5, 1, 1)
# Apply horizontal movement
hinderer = .75 if self.OnGround else 0.5
if force.x * self.Owner.RigidBody.Velocity.x < self.HorizontalSpeedLimit * hinderer:
self.Owner.RigidBody.ApplyLinearImpulse(force * hinderer *
self.MoveForce)
# Update vertical jumping
my_v = self.Owner.RigidBody.Velocity
jumper = my_v.y
if self.CanJump:
if (Zero.Keyboard.KeyIsPressed(Zero.Keys.W)
or Zero.Keyboard.KeyIsPressed(
Zero.Keys.Space)) and self.JumpActive:
jumper = self.JumpStrength
my_v *= Vec3(0.8, 1, 1)
self.CanJump = False
self.OnGroundUpdateEnabled = False
if not self.Owner.DoorEnterer.IsAtDoor():
self.EnsureSoundEmitter()
self.Owner.SoundEmitter.PlayCue("JumpCue")
self.Owner.SoundEmitter.Volume *= 0.9
def RecoverSound():
self.Owner.SoundEmitter.Volume /= 0.9
seq = Action.Sequence(self.Owner.Actions)
Action.Delay(seq, 6)
Action.Call(seq, RecoverSound)
if self.OnGround:
my_v *= 0.9
# Apply Jumping
self.Owner.RigidBody.Velocity = Vec3(my_v.x * 0.998, jumper, 0)
# Regulate speed
v = self.Owner.RigidBody.Velocity
new_vx = v.x
new_vy = v.y
if abs(self.Owner.RigidBody.Velocity.y) > self.VerticalSpeedLimit:
sign = 1 if self.Owner.RigidBody.Velocity.y > 0 else -1
new_vy = self.VerticalSpeedLimit * sign
self.Owner.RigidBody.Velocity = Vec3(new_vx, new_vy, 0)
def EnsureSoundEmitter(self):
if not self.Owner.SoundEmitter:
self.Owner.AddComponentByName("SoundEmitter")
def Null():
pass
self.EnsureSoundEmitter = Null
def UpdateAnimation(self):
if not self.DontUpdateAnim:
if self.Owner.CanHook and self.Owner.CanHook.IsHooked():
animstate = "Grab"
else:
if self.Mouse and self.Mouse.MouseLocationIndicator.AbsorbActive:
if (self.Owner.RigidBody.Velocity.x > 0.5
and self.Owner.Sprite.FlipX) or (
self.Owner.RigidBody.Velocity.x < -0.5
and not self.Owner.Sprite.FlipX):
animstate = "AttackLeft"
else:
animstate = "Attack"
else:
if not self.OnGround:
if self.Owner.RigidBody.Velocity.y < 0:
animstate = "Fall"
else:
animstate = "Jump"
else:
if abs(self.Owner.RigidBody.Velocity.x) > 2:
animstate = "Walk"
else:
animstate = "Stand"
if self.animstate != animstate:
self.animstate = animstate
self.Owner.Sprite.SpriteSource = self.AnimTable.FindValue(
self.animstate)
if self.Mouse and self.Mouse.MouseLocationIndicator.AbsorbActive:
self.Owner.Sprite.FlipX = self.Mouse.Transform.WorldTranslation.x - self.Owner.Transform.WorldTranslation.x < 0
def UpdateGroundInfo(self):
prefalse = not self.OnGround
self.OnGround = False
self.slope_tangent = Vec3(1, 0, 0)
if self.OnGroundUpdateEnabled:
for ContactHolder in self.Owner.Collider.Contacts:
if ContactHolder.OtherObject.Collider.Ghost == False:
normal = -ContactHolder.FirstPoint.WorldNormalTowardsOther
if normal.y >= 0 and not self.IsSteep(normal):
self.OnGround = True
self.CanJump = True
if prefalse and self.Owner.AlternateSoundEmitter:
self.Owner.AlternateSoundEmitter.PlayOne()
if self.IsSlope(normal):
self.slope_tangent = Vec3(normal.y, -normal.x, 0)
self.OnSlope = True
else:
self.OnSlope = False
return
def IsSlope(self, normal):
# if slope degree > 22.5
return abs(normal.y) <= abs(normal.x) * 4
def IsSteep(self, normal):
# if slope degree > 45 + 12.5
return abs(normal.y) * 1.5 < abs(normal.x)
def LockHorizontal(self):
self.HorizontalLocked = True
def UnlockHorizontal(self):
self.HorizontalLocked = False
class NormalTreeSoulBehavior:
DestinationObject = Property.Cog()
VerticalDetect = Property.Bool(False)
ExtendedDelay = Property.Bool(False)
ShadingColor = Property.Color(VectorMath.Vec4(1,1,1,1))
def Initialize(self, initializer):
self.camera = self.Space.FindObjectByName("Camera")
self.CurrentUpdater = self.Detecting
self.Player = self.Space.FindObjectByName("Player")
Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate)
Zero.Connect(self.Owner, Events.CollisionStarted, self.CollisionStart)
def CollisionStart(self, CollisionEvent):
if CollisionEvent.OtherObject == self.Player:
self.Player.CanHook.ForceUnhooked()
self.CurrentUpdater = self.SlowAttracting
def OnLogicUpdate(self, UpdateEvent):
self.CurrentUpdater()
def Detecting(self):
if abs(self.Owner.Transform.Translation.x - self.Player.Transform.Translation.x) < 4:
self.Owner.SphericalParticleEmitter.Active = True
def SlowAttracting(self):
self.Player.PlayerController.DontUpdateAnim = True
self.Player.Sprite.SpriteSource = self.Player.PlayerController.AnimTable.FindValue("Attack")
self.Player.RigidBody.Kinematic = True
self.Owner.Transform.Translation = 0.996 * self.Owner.Transform.Translation + 0.004 * self.Player.Transform.WorldTranslation
self.Player.Transform.Translation += Vec3(0,0.003,0)
if not self.VerticalDetect:
condition = abs(self.Owner.Transform.Translation.x - self.Player.Transform.Translation.x) < 2
else:
condition = abs(self.Owner.Transform.Translation.y - self.Player.Transform.Translation.y) < 2
if condition:
#self.camera.CameraFunction.SetCameraFade(self.ShadingColor*Vec4(1, 1,1, 0), self.ShadingColor, .01, 0)
self.CurrentUpdater = self.Attracting
def Attracting(self):
self.Owner.Transform.Translation = 0.98 * self.Owner.Transform.Translation + 0.02* self.Player.Transform.WorldTranslation
self.Player.Transform.Translation += Vec3(0,0.001,0)
if not self.VerticalDetect:
condition = abs(self.Owner.Transform.Translation.x - self.Player.Transform.Translation.x) < 0.1
else:
condition = abs(self.Owner.Transform.Translation.y - self.Player.Transform.Translation.y) < 0.1
if condition:
#self.camera.CameraFunction.SetCameraFade(self.ShadingColor*Vec4(1, 1,1, 0), self.ShadingColor, .01, 0)
self.CurrentUpdater = self.Ending
def Ending(self):
self.Owner.SphericalParticleEmitter.Size *= 1.05
self.Owner.SphericalParticleEmitter.EmitRate = 35
if self.Owner.SphericalParticleEmitter.Size > 25:
self.CurrentUpdater = self.Fading
self.Player.Sprite.Visible = False
for child in self.Player.Hierarchy.Children:
if child.Sprite:
child.Sprite.Visible = False
#d = self.DestinationObject.Transform.WorldTranslation
#z = self.Player.Transform.WorldTranslation.z
#self.Player.Transform.WorldTranslation = Vec3(d.x, d.y, z)
#z = self.camera.Transform.WorldTranslation.z
#self.camera.Transform.WorldTranslation = Vec3(d.x, d.y, z)
#def showit():
# self.camera.CameraFunction.SetCameraFade(self.ShadingColor,self.ShadingColor*Vec4(1,1,1,0),0.005,0)
# self.Player.RigidBody.Kinematic = False
#self.CurrentUpdater = self.Fading
#if self.ExtendedDelay:
# self.camera.CameraFunction.SetCameraFade(self.ShadingColor, self.ShadingColor,2,0)
# self.Owner.DestroyInterface.Destroy()
# seq = Action.Sequence(self.Player.Actions)
# Action.Delay(seq, 2)
# Action.Call(seq, showit)
#else:
# self.camera.CameraFunction.SetCameraFade(self.ShadingColor, self.ShadingColor*Vec4(1,1,1,0),0.0025,0)
# self.CurrentUpdater = self.Fading
# self.Player.RigidBody.Kinematic = False
# self.Owner.DestroyInterface.Destroy()
#self.Space.FindObjectByName("EndingWeather").RainGenerator.Activatable = True
#self.Space.SoundSpace.PlayCue("Thunder")
def Fading(self):
self.Owner.SpriteParticleSystem.Tint *= VectorMath.Vec4(1,1,1,0.95)
for child in self.Owner.Hierarchy.Children:
child.SpriteParticleSystem.Tint *= VectorMath.Vec4(1,1,1,0.95)
if self.Owner.SpriteParticleSystem.Tint.a < 0.001:
self.CurrentUpdater = self.Fading2
self.Space.FindObjectByName("LevelSettings").LevelStart.HUDManager.ShowScores()
self.Owner.DestroyInterface.Destroy()
def Fading2(self):
word1 = self.Space.FindObjectByName("EndingWord1")
word2 = self.Space.FindObjectByName("EndingWord2")
word3 = self.Space.FindObjectByName("EndingWord3")
if 1 - word1.SpriteText.Color.a < 0.02:
word1.FadeAnim.FadeDirection = -1
word2.FadeAnim.FadeDirection = -1
word1.FadeAnim.FadingDuration = 2
word2.FadeAnim.FadingDuration = 2
word1.FadeAnim.Active = True
word2.FadeAnim.Active = True
self.CurrentUpdater = self.Fading3
def Fading3(self):
word1 = self.Space.FindObjectByName("EndingWord1")
word3 = self.Space.FindObjectByName("EndingWord3")
if word1.SpriteText.Color.a < 0.02:
word3.FadeAnim.Active = True
def DestroyDelegate(self):
if self.Owner.DestroyInterface:
self.Owner.DestroyInterface.Destroy()
else:
self.Owner.Destroy()
