def test_cross_product(self): other = (1,1,1) cross, angle = VectorMath.cross_product(self.z,other) numpy.testing.assert_allclose([-math.sqrt(3)/3,math.sqrt(3)/3,0.0], cross, atol = 1e-07) numpy.testing.assert_allclose ([math.asin(math.sqrt(2.0/3))],[angle], atol = 1e-07) bad_vec = (0,0,0,1) #print 'This should say vector A is bad:' cross,angle = VectorMath.cross_product(bad_vec,self.z) #this bad vector argument should fail and return none for both values self.assertIsNone(cross) self.assertIsNone(angle) #print 'This should say vector B is bad:' cross,angle = VectorMath.cross_product(self.z,bad_vec) #this bad vector argument should fail and return none for both values self.assertIsNone(cross) self.assertIsNone(angle) simple_x = (1,0) simple_y = (0,1) cross,angle = VectorMath.cross_product(simple_x,self.y) numpy.testing.assert_allclose(self.z,cross) numpy.testing.assert_allclose([math.pi/2],angle, atol = 1e-07) cross,angle = VectorMath.cross_product(self.z,simple_y) numpy.testing.assert_allclose([-1,0,0],cross) numpy.testing.assert_allclose([math.pi/2],angle, atol = 1e-07)
def test_decompose_vector(self): mybasis = [self.x,self.y,self.z] myvector = (1,2,3) assert VectorMath.decompose_vector(myvector,mybasis) == [1,2,3] another_basis = [[1,2,3],[0,0,0],[0,0,0]] result = VectorMath.decompose_vector(myvector,another_basis) self.assertEquals(result,[14,0,0])
def test_orthagonal(self): x_prime = (-1,0,0) y_close = (0,-.9999999,0.00000000002) self.assertFalse (VectorMath.check_orthagonal(self.x,self.x) ) self.assertFalse (VectorMath.check_orthagonal(self.x,x_prime) ) self.assertTrue (VectorMath.check_orthagonal(self.x,y_close) )
def updateAngle(self, masterOrSlave): if not masterOrSlave == self.state: return if self.state: if self.target: self.setAngle(self.angleToTarget(self.installation.getTarget(self.target))) elif self.tertiaryTarget: distance = self.targetXDistance(self.tertiaryTarget) maxAngle = abs(self.angleToTarget( [ float(self.range[1]),0, 1200 ] )) if distance > 0: relevantRange = self.range[1] outOfRange = distance - (int(relevantRange) - int(self.phyLocation[0])) self.setAngle(vm.mapToDomain(outOfRange, 0, float(abs(relevantRange-float(self.extRangeX[1]))), maxAngle, 0)) elif distance < 0: relevantRange = self.range[0] outOfRange = int(self.phyLocation[0]) - int(relevantRange) + distance self.setAngle( vm.mapToDomain(outOfRange, 0, -1 * float(abs(relevantRange-float(self.extRangeX[0]))), -1 * float(maxAngle), 0) ) else: raise Exception("Evil's afoot!") elif not self.state: i = 0 comComb = 0 for command in self.commands: comComb += command i += 1 if i == 0: self.setAngle(0) else: self.setAngle(comComb/i)
def angleToTarget(self, target): target3D = target target2D = (int(target3D[0]), int(target3D[2])) location2D = (int(self.phyLocation[0]), int(self.phyLocation[2])) targetVector = vm.createVector(location2D, target2D) targetAngle = vm.angleBetween2D([0,-1], targetVector) return targetAngle
def generateProjectile(self, pos): shotLifeLength = 200 shotSpeed = 1 attack = Attack.Attack("shot.png", self.game, pos, (4,4)) attack.damage = 5 attack.velocity = VectorMath.normalize(VectorMath.sub (self.game.player.getMidPos(),self.getMidPos()),shotSpeed) attack.framesToLive = shotLifeLength return attack
def test_basis_generation(self): expected_basis = [[0.0,0.0,-1.0],[0.0,1.0,0.0],[1.0,0.0,0.0]] gen_basis = VectorMath.generate_basis(self.x) for index,vector in enumerate(expected_basis): numpy.testing.assert_allclose(gen_basis[index],vector, atol = 1e-07) gen_basis2 = VectorMath.generate_basis((1,1,0)) expected_basis2 = [[0.5,-0.5,-0.707106781],[-.5,0.5,-0.707106781],[0.707106781,0.707106781,0.0]] for index,vector in enumerate(expected_basis2): numpy.testing.assert_allclose(gen_basis2[index],vector, atol = 1e-07)
def nn_multi_base_context(self, targets, n=5): """ Find and return the n nearest base neighbours to a set of target vectors from the context matrix. :rtype : 2-tuple of ndarrays :param target: int :param n: int """ d = np.ones(self.size, dtype=np.float) new_target = self.base_vectors[targets].sum(axis=0) for i, vector in enumerate(self.context_vectors): compare = True for index in targets: if i == index: compare = False if compare: d[i] = VectorMath.cosine(new_target, vector) args = np.argsort(d)[1:n + 1] vals = d[args] return args, vals
def act(self, level): SPEED = 1 oldPos = self.pos if(self.facing == FACE_LEFT): self.pos = VectorMath.add(self.pos, (-SPEED, 0)) else: self.pos = VectorMath.add(self.pos, (SPEED, 0)) if(self.isInAir(level)): self.pos = oldPos self.flipFacing() self.pos = VectorMath.add(self.pos, self.velocity) if(self.hurtTimer > 0): self.hurtTimer -= 1
def attack(self): if(self.shotCoolDown == 0): distance = self.distanceToPoint(self.game.player.getMidPos()) shotInitPos = VectorMath.add(self.pos, (6,3)) self.game.simpleSprites.append(self.generateProjectile(shotInitPos)) self.shotCoolDown = SHOTCOOLDOWN Globals.SOUNDPLAYER.playSound("shoot.wav") if(self.shotCoolDown >= 1): self.shotCoolDown -=1
def determineClosestTarget(self, targetList): """ targetList is a dictionary of targets k = targetID v = point returns ID/key of closest Point """ distances = {} for key in targetList.keys(): distances[key] = vm.getPointDistance(self.phyLocation, targetList[key]) return min(distances, key=distances.get)
def updateAngle(self, masterOrSlave): if not masterOrSlave == self.state: return if self.state: if self.target: self.setAngle(self.angleToTarget(self.installation.getTarget(self.target))) elif self.secondaryTarget: distance = self.targetXDistance(self.secondaryTarget) #if self.arrLocation[0] == '0' and self.arrLocation[1] == '4': #print distance #print "distance " + str(distance) #maxAngle = abs(self.angleToTarget( [ float(self.range[1])-float(self.phyLocation[0]),0, 1200 ] )) maxAngle = abs(self.angleToTarget( [ float(self.range[1]),0, 1200 ] )) #print "maxAngle = " + str(vm.radToDeg(maxAngle)) if distance > 0: relevantRange = self.range[1] outOfRange = distance - (int(relevantRange) - int(self.phyLocation[0])) #print outOfRange #print vm.mapToDomain(outOfRange, 0, float(abs(relevantRange-float(self.phyLocation[0]))), maxAngle, 0) self.setAngle(vm.mapToDomain(outOfRange, 0, float(abs(relevantRange-float(self.phyLocation[0]))), maxAngle, 0)) elif distance < 0: relevantRange = self.range[0] outOfRange = int(self.phyLocation[0]) - int(relevantRange) + distance #print "oor " + str(outOfRange) #print "reR ", relevantRange #print self.phyLocation self.setAngle( vm.mapToDomain(outOfRange, 0, -1 * float(abs(relevantRange-float(self.phyLocation[0]))), -1 * float(maxAngle), 0) ) else: raise Exception("Evil's afoot!") elif not self.state: i = 0 comComb = 0 for command in self.commands: comComb += command i += 1 if i == 0: self.setAngle(0) else: self.setAngle(comComb/i)
def update(self): if not self.lastHurtBox is None: if self.lastHurtBox.numberOfHurtFrames > 0: self.toBeRemoved = True return self.tick() self.pos = VectorMath.add(self.pos, self.velocity) box = pygame.Rect(self.pos, self.frameSize) hurtBox = HurtBox.HurtBox(box, 2, 1) self.game.hurtBoxHandler.addHurtBox(hurtBox, self.alignment) self.lastHurtBox = hurtBox
def IncreaseAlpha(self): self.Soul.SpriteParticleSystem.Tint *= VectorMath.Vec4(1, 1, 1, 0.9) color = self.Owner.Sprite.Color color.w += self.IncreaseAlphaDelta if (color.w >= 1.0): color.w = 1.0 self.CurrentUpdate = None self.DeathActive = True self.Soul.Destroy() self.Owner.Sprite.Color = color
class CanBlow: BlowDirection = Property.Vector3(VectorMath.Vec3(0, 1, 0)) BlowForce = Property.Float(4) def Initialize(self, initializer): pass def Blow(self, target, decay): if target.RigidBody: if VectorMath.Vec3.dot(target.RigidBody.Velocity, self.BlowDirection) < 4: target.RigidBody.ApplyForce(self.BlowDirection * self.BlowForce * decay)
def OnTrigger(self, TriggerEvent): if self.Owner.FadeAnim: self.Owner.FadeAnim.Active = True if self.Owner.Sprite: s = self.Owner.Sprite.Color self.Owner.Sprite.Color = VectorMath.Vec4(s.x, s.y, s.z, s.a * 0) if self.Owner.Collider: self.Owner.Collider.Ghost = True if self.Owner.Hierarchy: for child in self.Owner.Hierarchy.Children: if child.Sprite.Color: s = child.Sprite.Color child.Sprite.Color = VectorMath.Vec4( s.x, s.y, s.z, s.a * 0) if child.Collider: child.Collider.Ghost = True if self.Owner.IsSentry: self.Owner.RemoveComponentByName("IsSentry")
def OnLogicUpdate(self, UpdateEvent): if self.Active: if self.blink_tick <= self.BlinkTick: self.blink_tick += 1 if self.blink_tick >= self.BlinkTick: if not self.Owner.Sprite.Color == self.BlinkColor: self.Owner.Sprite.Color = self.BlinkColor else: self.Owner.Sprite.Color = self.oricolor self.blink_tick = 0 else: c = self.Owner.Sprite.Color self.Owner.Sprite.Color = VectorMath.Vec4(self.oricolor.x,self.oricolor.y,self.oricolor.z,c.a)
def HideDestroy(self, target): target.Sprite.Visible = False if target.AIMovementInterface: target.AIMovementInterface.Deactivate() target.Transform.Translation = VectorMath.Vec3(0, 0, -100) target.Collider.Ghost = True if not target.RigidBody.Static and not target.RigidBody.Kinematic: target.RigidBody.Static = True if target.HealthStatus: target.HealthStatus.ResetHealth()
def leftMbRelease(coords=(0, 0)): ClickHandler.mouse_release_coords = coords ClickHandler.mouse_is_down = False # select group of nodes if you made a selection box big enough to not be an accident or single click if VectorMath.distance(ClickHandler.mouse_press_coords, ClickHandler.mouse_release_coords) > 10: UIGraph.GraphRenderer.selectNodes( ClickHandler.mouse_press_coords, ClickHandler.mouse_release_coords) else: # if single click, check for buttons for button in UIButton.UIButton.buttons: button.checkClicked(ClickHandler.mouse_release_coords)
def onMouseUpdate(self, ViewportMouseEvent): if (self.clicked): if (ViewportMouseEvent.ToWorldZPlane(0).x >= self.x_right): self.Owner.Transform.Translation = VectorMath.Vec3( self.x_right, self.yvalue, -1) self.percent = 100 * (self.Owner.Transform.Translation.x - self.x_left) / self.total self.volume.SpriteText.Text = "Volume: " + str( round(self.percent)) + "%" elif (ViewportMouseEvent.ToWorldZPlane(0).x <= self.x_left): self.Owner.Transform.Translation = VectorMath.Vec3( self.x_left, self.yvalue, -1) self.percent = 100 * (self.Owner.Transform.Translation.x - self.x_left) / self.total self.volume.SpriteText.Text = "Volume: " + str( round(self.percent)) + "%" else: self.Owner.Transform.Translation = VectorMath.Vec3( ViewportMouseEvent.ToWorldZPlane(0).x, self.yvalue, -1) self.percent = 100 * (self.Owner.Transform.Translation.x - self.x_left) / self.total self.volume.SpriteText.Text = "Volume: " + str( round(self.percent)) + "%"
def OnLogicUpdate(self, UpdateEvent): self.EnsureSetting() if not self.LevelName == self.parentspace.CurrentLevel.Name: self.EnsureAbility() if self.now_ability != self.GetName(): c = self.Owner.Sprite.Color self.Owner.Sprite.Color *= Vec4(1,1,1,0.9) if self.Owner.Sprite.Color.a <= 0.01: self.Owner.Sprite.SpriteSource = self.PicTable.FindValue(self.GetName()) self.now_ability = self.GetName() else: c = self.Owner.Sprite.Color self.Owner.Sprite.Color = VectorMath.Vec4(c.x, c.y, c.z, c.a * 0.9 + 0.1)
def Perform(self, position, pre_rotate=None): if self.TreeSkill: tree = self.TreeSkill.Perform(position, self.PhysSkill) if pre_rotate: tree.Transform.RotateByAngles( VectorMath.Vec3(0, 0, pre_rotate.angleZ() - math.pi / 2)) if tree.Name == "Mushroom": tree.CanBounce.ToDirection(pre_rotate) elif self.PhysSkill: self.PhysSkill.Perform(position) else: pass
def IncreaseAlpha(self): self.Soul.SpriteParticleSystem.Tint *= VectorMath.Vec4(1, 1, 1, 0.9) color = self.Owner.Sprite.Color color.w += self.IncreaseAlphaDelta if (color.w >= 1.0): color.w = 1.0 self.CurrentUpdate = None self.DeathActive = True self.Soul.Destroy() if self.Owner.PlayerController.Mouse: self.Owner.PlayerController.Mouse.MouseLocationIndicator.Deactivated = False self.IsImmune = False self.Owner.Sprite.Color = color
def Initialize(self, initializer): #Setting up Update Event Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate) #Creating a variable for camera object cameraCog = self.Space.FindObjectByName("Camera") #Setting up Mouse Related Events Zero.Connect(cameraCog.Camera.Viewport, Events.MouseMove, self.OnMouseMove) Zero.Connect(cameraCog.Camera.Viewport, Events.MouseUpdate, self.OnMouseUpdate) #Setting mouse position to an x,y,z vector self.mousePosition = VectorMath.Vec3(0,0,0) #making Windows cursor invisible Zero.Mouse.Cursor = -1
class Checkable: DarkenedColor = Property.Vector4(VectorMath.Vec4(0.5, 0.5, 0.5, 1)) def Initialize(self, initializer): self.CheckOut() Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision) def OnCollision(self, CollisionEvent): if CollisionEvent.OtherObject.CanCheck and not self.activated: self.activated = True CollisionEvent.OtherObject.CanCheck.SetCheck(self.Owner) self.Owner.Sprite.Color = VectorMath.Vec4(1, 1, 1, 1) def CheckOut(self): self.activated = False self.Owner.Sprite.Color = self.DarkenedColor
def Perform(self, position): ice = self.Space.CreateAtPosition("IceParticle", self.mouse.Transform.Translation) ice.AddComponentByName("ActionList") ice.Transform.Translation += VectorMath.Vector3(0, 0, 1) def shrink(self): self.Owner.SpriteParticleSystem.Tint -= VectorMath.Vec4( 0, 0, 0, 0.01) if self.Owner.SpriteParticleSystem.Tint.a < 0.01: self.Owner.Destroy() ice.ActionList.AddCallback(callback=shrink, has_self=True, blocking=True, countdown=None)
def __init__(self,CENTER = (0,0,0),WIDTH = 0,HEIGHT = 0,DEPTH = 0,\ NORMAL = (0,1,0)): '''These values are in Leap coordinates''' self.center = CENTER self.normal_direction = NORMAL # keep this as a tuple, this should not be changing '''These values are in local coordinates''' self.width = WIDTH self.height = HEIGHT self.depth = DEPTH # when we initialize we set up local coordinates self.local_basis = VectorMath.generate_basis(self.normal_direction) '''These are values that have nothing to do with reference frame''' self.gain_object = Gain()
def OnCollision(self, CollisionEvent): if not self.hooked and CollisionEvent.OtherObject.Hookable and CollisionEvent.OtherObject.Hookable.Active: self.hookobject = CollisionEvent.OtherObject self.hookobject.Hookable.Hook(self.Owner) self.Owner.AddComponentByName("GravityEffect") self.Owner.GravityEffect.Strength = 5 self.Owner.GravityEffect.Direction = VectorMath.Vec3(0,-1,0) self.Owner.AddComponentByName("DragEffect") if not self.Owner.Blowable: self.Owner.AddComponentByName("Blowable") self.Owner.PlayerController.JumpActive = False self.hooked = True
def OnCollision(self, CollisionEvent): if CollisionEvent.OtherObject.GrowableGround: self.normal = -CollisionEvent.FirstPoint.WorldNormalTowardsOther self.normal.z = 0 self.Owner.Transform.Translation += self.normal * CollisionEvent.FirstPoint.Penetration if self.ShouldRoot: self.Owner.Transform.RotateByAngles( VectorMath.Vec3(0, 0, self.normal.angleZ() - math.pi / 2)) CollisionEvent.OtherObject.Transform.Rotation self.Owner.RigidBody.Kinematic = True if self.Owner.CanBounce: self.Owner.CanBounce.ToDirection(self.normal) Zero.Disconnect(self.Owner, Events.CollisionStarted, self)
def get_circular_graph_coords(x, y, node_keys, radius): # Calculates coordinates in a circle # returns dictionary containing node keys to coordinates return_dict = dict() # returns coordinates for each node assert len(node_keys) > 0 deg_current = 0 deg_increment = float(360 / len(node_keys)) for circle in node_keys: coords = VectorMath.polar_to_cartesian(deg_current, radius) coords[0] += x coords[1] += y return_dict[circle] = coords deg_current += deg_increment return return_dict
def OnLogicUpdate(self, UpdateEvent): if self.Active: # Update age and do out of bounds check self.age += UpdateEvent.Dt * self.direction / self.Duration if self.age > 1: self.age = 1 self.Active = False if self.Repeat: self.ReversePlay() elif self.age < 0: self.age = 0 self.Active = False if self.Repeat: self.ReversePlay() # set new transform self.Owner.Transform.Translation += VectorMath.Vec3(0, 1, 0)
def OnLogicUpdate(self, UpdateEvent): self.UpdateEnvironmentInfo() if self.Active and self.WithInRange: self.PerformAbsorb() target_color = VectorMath.Vec4(1, 1, 1, 0.25) target_scale = 2 target_sprite = self.ShadeTable.FindValue("Circle") radius = 1.2 self.Owner.Transform.Rotation = self.init_rotate skillname = self.hero.AbilityStatus.GetTreeSkillName() physskill = self.hero.AbilityStatus.GetPhysSkillName() if physskill: self.Owner.BurnAnim.Active = False self.Owner.FreezeAnim.Active = False self.Owner.PoisonAnim.Active = False if self.WithInRange and not self.Deactivated: if self.TouchAttackable: target_color = VectorMath.Vec4(1, 0, 0, 0.25) target_scale = 5 radius = 2.4 elif self.TouchAnnihilator or not skillname: target_color = VectorMath.Vec4(0, 0, 0, 1) target_scale = 0.5 elif self.TouchGrowable and not self.hero.AbilityStatus.NoTreeSkill( ): target_color = VectorMath.Vec4(1, 1, 1, 0.75) target_scale = 5 target_sprite = self.ShadeTable.FindValue(skillname) target_scale *= self.scale_table[skillname] if not skillname == "TreeSkillWhirlingnut": self.Owner.Transform.RotateByAngles( VectorMath.Vec3( 0, 0, self.touch_normal.angleZ() - math.pi / 2)) if physskill: target_color = self.color_table[physskill] self.anim_table[physskill].Active = True else: target_color = VectorMath.Vec4(0, 0, 0, 1) target_scale = 0.5 self.Owner.SphereCollider.Radius = radius self.Owner.Sprite.Color = target_color self.Owner.Transform.Scale = self.initial_size * target_scale self.Owner.SphereCollider.Radius = self.ball_size / target_scale self.Owner.Sprite.SpriteSource = target_sprite
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 OnCollision(self, CollisionEvent): if not self.hooked and CollisionEvent.OtherObject.Hookable and CollisionEvent.OtherObject.Hookable.Active: #if not self.Owner.PlayerController.IsOnGround() and Zero.Keyboard.KeyIsDown(Zero.Keys.W): if Zero.Keyboard.KeyIsDown(Zero.Keys.W) or Zero.Keyboard.KeyIsPressed(Zero.Keys.W): self.hookobject = CollisionEvent.OtherObject self.hookobject.Hookable.Hook(self.Owner) self.Owner.AddComponentByName("GravityEffect") self.Owner.GravityEffect.Strength = 5 self.Owner.GravityEffect.Direction = VectorMath.Vec3(0,-1,0) self.Owner.AddComponentByName("DragEffect") if not self.Owner.Blowable: self.Owner.AddComponentByName("Blowable") self.Owner.PlayerController.JumpActive = False self.Owner.PlayerGravityModifier.Active = False self.hooked = True
def nn_base_base(self, target, n=5): """ Find and return the n nearest base neighbours to a target vector from the base matrix. :rtype : 2-tuple of ndarrays :param target: int :param n: int """ d = np.zeros(self.size, dtype=np.float) for i, vector in enumerate(self.base_vectors): d[i] = VectorMath.cosine(self.base_vectors[target], vector) args = np.argsort(d)[1:n + 1] vals = d[args] return args, vals
def GoUnder(self): self.Owner.Teleportable.Active = False self.Owner.Bounceable.Active = False self.Owner.Collider.Ghost = True if not self.Owner.Sprite.SpriteSource == self.inanim: self.Owner.Sprite.SpriteSource = self.inanim if self.Owner.Sprite.CurrentFrame == 2: self.dumbcounter = 50 self.CurrentUpdate = self.UndergroundWalking sandsmoke = self.Space.CreateAtPosition( "SandSmokeParticle", self.Owner.Transform.Translation) t = sandsmoke.SpriteParticleSystem.Tint sandsmoke.SpriteParticleSystem.Tint = VectorMath.Vec4( t.x, t.y, t.z, 0.1) sandsmoke.SphericalParticleEmitter.RandomVelocity *= .5 sandsmoke.SphericalParticleEmitter.StartVelocity *= .5 sandsmoke.SphericalParticleEmitter.EmitCount = 10 sandsmoke.SphericalParticleEmitter.ResetCount()
class PlayerDetectorInterface: Size = Property.Vector3(VectorMath.Vec3(1, 1, 1)) def Initialize(self, initializer): self.playerdetector = None def Activate(self): if not self.playerdetector: self.playerdetector = self.Space.CreateAtPosition( "PlayerDetectorEntity", self.Owner.Transform.Translation) self.SyncSize() self.playerdetector.AttachToRelative(self.Owner) def Deactivate(self): if self.playerdetector: self.playerdetector.DetachRelative() self.playerdetector.Destroy() def SetSize(self, size): self.Size = size self.SyncSize() def SyncSize(self): if self.playerdetector: self.playerdetector.Transform.Scale = VectorMath.Vec3( 1, 1, 1) * self.Size def GetDirection(self): if self.playerdetector: return self.playerdetector.PlayerDetector.GetDirection() else: return VectorMath.Vec3(0, 0, 0) def InRange(self): if self.playerdetector: return self.playerdetector.PlayerDetector.InRange() else: return False def Destroyed(self): self.Deactivate()
def OnLogicUpdate(self, UpdateEvent): Parent = self.Owner.Parent Position = self.Owner.Transform.WorldTranslation Child1 = self.Owner.FindChildByName("LookPoint2") Child1Pos = Child1.Transform.WorldTranslation Ray = VectorMath.Ray() Ray.Start = Vector3(Position.x, Position.y, 0) #Start Ray.Direction = Vector3(Child1Pos.x - Position.x, Child1Pos.y - Position.y, 0) #End MaxRayCastDistance = 1.0 #RayColor = Color.Yellow CastResultsRange = self.Space.PhysicsSpace.CastRayResults(Ray, 1) # Number Of Objects LastCastResult = None #Limit #print(Parent.GunManStatus.CanShoot) for CastResult in CastResultsRange: if(CastResult.Distance >= MaxRayCastDistance): break if(CastResult.ObjectHit.Name == "Tung" or CastResult.ObjectHit.Name == "Austin" or CastResult.ObjectHit.Name == "Trey" or CastResult.ObjectHit.Name == "Peyton" or CastResult.ObjectHit.Name == "Sedrick" or CastResult.ObjectHit.Name == "Julio"): Parent.GunManStatus.CanShoot = True Parent.GunManStatus.RayCast2 = True else: Parent.GunManStatus.RayCast2 = False if(Parent.GunManStatus.RayCast1 is False and Parent.GunManStatus.RayCast2 is False and Parent.GunManStatus.RayCast3 is False and Parent.GunManStatus.RayCast4 is False and Parent.GunManStatus.RayCast5 is False and Parent.GunManStatus.RayCast6 is False and Parent.GunManStatus.RayCast7 is False and Parent.GunManStatus.RayCast8 is False and Parent.GunManStatus.RayCast9 is False): Parent.GunManStatus.CanShoot = False LastCastResult = CastResult #Limit if(not LastCastResult): #Limit EndPosition = Ray.Start + Ray.Direction * MaxRayCastDistance #self.DrawArrow(Ray.Start, EndPosition, RayColor) else: EndPosition = Ray.Start + Ray.Direction * LastCastResult.Distance
def OnLogicUpdate(self, UpdateEvent): #Define target object as the player self.targetObject = self.Space.FindObjectByName("Player") #If the player exists if(self.targetObject): #Get cameras current translation currentTranslation = self.Owner.Transform.Translation #Get players's translation targetTranslation = self.targetObject.Transform.Translation #Store x component of player translation with camera's current y and z translation newTranslation = VectorMath.Vec3(targetTranslation.x, currentTranslation.y, currentTranslation.z) #set this to cameras translation self.Owner.Transform.Translation = newTranslation #If M is pressed music will be muted if(Zero.Keyboard.KeyIsPressed(Zero.Keys.M)): #Pauses the Soundspace self.Space.SoundSpace.Pause = not self.Space.SoundSpace.Pause #Sets up the camera for the background so it is slighty off of player movement for effect self.Space.FindObjectByName("LevelSettings").HUDCreator.BGSpace.FindObjectByName("Camera").Transform.Translation = VectorMath.Vec3(self.Owner.Transform.Translation.x/2, self.Owner.Transform.Translation.y/2, 40)
def Attacking(self): self.Owner.ClickReceiver.Receivable = True if not self.Owner.Sprite.SpriteSource == self.outanim: self.Owner.Sprite.SpriteSource = self.outanim if self.Owner.Sprite.CurrentFrame == 2: hurtbox = self.Space.CreateAtPosition("HurtBox",self.Owner.Transform.Translation + Vec3(0,.5,0)) hurtbox.Transform.Scale = Vec3(1,1.5,1) hurtbox.CanHurt.HurtRate = -20 hurtbox.TimedDeath.LifeTime = 0.3 sandsmoke = self.Space.CreateAtPosition("SandSmokeParticle", self.Owner.Transform.Translation) t = sandsmoke.SpriteParticleSystem.Tint sandsmoke.SpriteParticleSystem.Tint = VectorMath.Vec4(t.x, t.y, t.z, 0.1) sandsmoke.SphericalParticleEmitter.EmitCount = 3 sandsmoke.SphericalParticleEmitter.ResetCount() if self.Owner.Sprite.CurrentFrame == 5: self.dumbcounter = 20 self.CurrentUpdate = self.Resting
def OnLogicUpdate(self, UpdateEvent): if self.Active: if self.Countdown > 0: self.Countdown -= 1 if self.Countdown == 0: self.Active = False self.Countdown = -1 if self.blink_tick <= self.BlinkTick: self.blink_tick += 1 if self.blink_tick >= self.BlinkTick: if not self.Owner.Sprite.Color == self.BlinkColor: self.Owner.Sprite.Color = self.BlinkColor #self.Owner.Sprite.BlendMode = Zero.BlendMode.Additive else: self.Owner.Sprite.Color = self.oricolor self.blink_tick = 0 else: c = self.Owner.Sprite.Color self.Owner.Sprite.Color = VectorMath.Vec4(self.oricolor.x,self.oricolor.y,self.oricolor.z,c.a)
def Destroy(self): if self.InvalidateColliderBox: self.Owner.Collider.Offset += VectorMath.Vec3(0, 0, 9999) if not self.Activated: self.Activated = True self.Owner.FadeAnim.Active = True def waitmovieend(): return not self.Owner.FadeAnim.Active def destroy(): self.Owner.Destroy() self.Owner.ActionList.AddCallback(callback=waitmovieend, has_self=False, blocking=True, countdown=None) self.Owner.ActionList.AddCallback(callback=destroy, has_self=False, blocking=True, countdown=1)
class BlinkAnim: BlinkColor = Property.Color(VectorMath.Vec4(1,0,0,1)) BlinkTick = Property.Int(3) Active = Property.Bool(False) def Initialize(self, initializer): self.blink_tick = self.BlinkTick self.blink_counter = 0 self.oricolor = self.Owner.Sprite.Color Zero.Connect(self.Space, Events.LogicUpdate, self.OnLogicUpdate) def OnLogicUpdate(self, UpdateEvent): if self.Active: if self.blink_tick <= self.BlinkTick: self.blink_tick += 1 if self.blink_tick >= self.BlinkTick: if not self.Owner.Sprite.Color == self.BlinkColor: self.Owner.Sprite.Color = self.BlinkColor else: self.Owner.Sprite.Color = self.oricolor self.blink_tick = 0 else: c = self.Owner.Sprite.Color self.Owner.Sprite.Color = VectorMath.Vec4(self.oricolor.x,self.oricolor.y,self.oricolor.z,c.a)
class TouchFlyhere: HidingOffset = Property.Float(10) Normal = Property.Vector3(VectorMath.Vec3(0, 1, 0)) def Initialize(self, initializer): self.destination = self.Owner.Transform.WorldTranslation hiding_vec = self.HidingOffset * self.Owner.Transform.TransformNormalLocal( self.Normal) self.Owner.Transform.WorldTranslation += hiding_vec self.Owner.Collider.Offset -= VectorMath.Vec3(0, self.HidingOffset, 0) Zero.Connect(self.Owner, Events.CollisionStarted, self.OnCollision) def OnCollision(self, CollisionEvent): Zero.Connect(self.Space, Events.LogicUpdate, self.FlyUpdate) Zero.Disconnect(self.Owner, Events.CollisionStarted, self) def FlyUpdate(self, UpdateEvent): t = self.Owner.Transform.WorldTranslation self.Owner.Transform.WorldTranslation = t * 0.9 + self.destination * 0.1 if (self.Owner.Transform.WorldTranslation - self.destination).length() < 0.01: Zero.Disconnect(self.Space, Events.LogicUpdate, self)
def distanceToPoint(self, point): return VectorMath.magnitude((VectorMath.sub(self.pos,point)))
def convert_to_local_coordinates(self,coordinates,basis): # find the relative vector from local origin to leap point relative_vector = [value-self.center[index] for index,value in enumerate(coordinates)] local_coordinates = VectorMath.decompose_vector(relative_vector,basis) return local_coordinates
stl_regex = re.compile("(\.STL)|(\.stl)$") if(re.search(stl_regex, fn) is not None): out_name = re.split(stl_regex, fn)[0] else: print "Exiting: invalid filename is not a .stl or .STL" print "\t"+fn exit(1) #try to create a dir for output out_dir = "./out" try: os.mkdir(out_dir) except OSError: print "dir already exists" magnitude = VectorMath.magnitude(norm_vec) norm_vec = tuple([norm_vec[i]/magnitude for i in range(0, len(norm_vec))]) if norm_vec != (0,0,1): #print norm_vec #print VectorMath.magnitude(norm_vec) (basis, rot_quaternion) = VectorMath.generate_basis(norm_vec) mesh = smi.parsers.parseBinarySTL(fn, quaternion = rot_quaternion, scale = global_scale ) else: mesh = smi.parsers.parseBinarySTL(fn) print "Min",mesh.min_coord print "Max",mesh.max_coord all_dwg = ezdxf.new("AC1015") all_msp = all_dwg.modelspace()