Beispiel #1
0
def think(dt, controls):
    background.update(dt)
    if self.ending:
        self.center = math.softapproach(self.center, self.box0.center, 30 * dt)
        if self.center == self.box0.center and not self.done:
            scene.pop()
            self.done = True
            ondone_(self.text)
            settings.save()
    else:
        self.center = math.softapproach(self.center, self.box1.center, 16 * dt)
    self.box.center = I(self.center)

    if not self.ending and self.center == self.box1.center:
        if pygame.K_BACKSPACE in controls.kdowns:
            self.text = self.text[:-1]
        if pygame.K_TAB in controls.kdowns:
            self.text = ""
            sound.play("no")
        for char in acceptedchars:
            if char in controls.kdowns:
                self.text += char
        self.text = self.text[:32]

        if pygame.K_RETURN in controls.kdowns:
            self.ending = True
            sound.play("place")
Beispiel #2
0
 def move(self, you, dt, dx, dy, turn):
     if turn:
         you.heading += self.toturn
         self.toturn = math.tau / 2
     vphi = view.getphi()
     if vphi is None:
         you.heading += 2 * dt * dx
     if self.toturn:
         toturn = math.softapproach(self.toturn, 0, 10 * dt, dymin=0.01)
         you.heading += self.toturn - toturn
         self.toturn = toturn
     if vphi is None:
         speed = 10 if dy > 0 else -3 if dy < 0 else 0
         v = pygame.math.Vector3(0, speed,
                                 0).rotate_z(math.degrees(-you.heading))
         you.v = math.approach(you.v, v, 200 * dt)
     else:
         v = pygame.math.Vector3(dx, dy, 0)
         if v.length():
             v = 10 * v.normalize().rotate_z(vphi)
         vnew = math.approach(you.v, v, 200 * dt)
         #			if you.v.length() and vnew.length():
         #				you.heading += math.degrees(math.asin(you.v.cross(vnew).z / (you.v.length() * vnew.length())))
         you.v = vnew
         if you.v.length():
             you.heading = math.atan2(you.v.x, you.v.y)
     if not you.draining and self.candropfrom(you):
         you.startdrain()
     if self.canfeed(you):
         state.food = state.foodmax
         sound.manager.PlaySound('food_got')
Beispiel #3
0
	def think(self, dt):
		if self.jdelay > 0:
			self.Ajolt = 0
			self.tjolt = 0
			self.jdelay -= dt
			if self.jdelay <= 0:
				self.jdelay = 0
				self.Ajolt = 40
				self.tjolt = 0
		else:
			self.tjolt += dt
			self.Ajolt = math.softapproach(self.Ajolt, 0, 10 * dt)
Beispiel #4
0
def think(dt, kdowns, kpressed):
    global youftarget, boards, blocks, hills, effects
    kright = (1 if settings.ispressed(kpressed, "right") else
              0) - (1 if settings.ispressed(kpressed, "left") else 0)
    if kright:
        dftarget = 2 * dt * kright
        youftarget = math.clamp(youftarget + dftarget, -1, 1)
    else:
        youftarget = math.softapproach(youftarget, 0, 4 * dt)
    view.X0 += settings.speed * dt
    you.think(dt)
    for hazard in hazards:
        hazard.think(dt)
    removegone()
    for hazard in hazards:
        if hazard.hitsyou():
            you.gethit()
Beispiel #5
0
def Fspotapproach(Fspot0, Fspot1, dlogx):
    pos0, r0 = Fspot0
    pos1, r1 = Fspot1
    return math.softapproach(pos0, pos1,
                             dlogx), math.softapproach(r0, r1, dlogx)
Beispiel #6
0
def think(dt, dmx, dmy):
	self.tosnap = max(self.tosnap - dt, 0)

	if settings.manualcamera:
		self.mgamma = math.clamp(self.mgamma - 100 * dmy, 5, 85)
		self.mphi -= 100 * dmx

	camera = 1 * state.you.pos
	atilt = state.you.section.atilt(state.you)
	Rvantage = 20
	gamma = 55 - state.you.drainangle()
	phi = -math.degrees(state.you.heading)

	if state.you.section.fmode is None:
		pass
	elif state.you.section.fmode:
		if not self.fmode:
			self.fmode = True
			self.tosnap = 1
	else:
		if self.fmode:
			self.fmode = False
			self.tosnap = 1

	if state.you.section.bmode is None:
		pass
	elif state.you.section.bmode:
		if not self.bmode:
			self.bmode = True
			self.tosnap = 1
	else:
		if self.bmode:
			self.bmode = False
			self.tosnap = 0.5

	if self.fmode:
#		if state.you.section.label == "pool":
		self.fcamera = state.you.section.pos * 1
		camera = math.softapproach(self.camera, self.fcamera, 2 * dt)
		phi = 0
		gamma = 40
		Rvantage = math.softapproach(self.Rvantage, 28, 3 * dt)

	if self.bmode:
		camera = math.softapproach(self.camera, state.you.section.pos, 1 * dt)
		d = state.you.pos - state.you.section.pos
		d.z = 0
		
		if d.x == 0 and d.y == 0:
			kappa = 0
		else:
			kappa = math.degrees(math.atan2(d.y, d.x)) - 90
		dphi = math.zmod(self.bphi - kappa, 360)
		if 0 < dphi < 70:
			self.bphi += 70 - dphi
		elif -70 < dphi < 0:
			self.bphi += -70 - dphi
		phi = self.bphi
		gamma = 55
		Rvantage = math.softapproach(self.Rvantage, 45, 3 * dt)

	if state.you.section.rapid > 1:
		if not self.rapid:
			self.tosnap = 1
			self.rapid = True
		Rvantage = 12
		gamma = 68
	else:
		if self.rapid:
			self.tosnap = 1
			self.rapid = False

	# f is approximately dt / self.tosnap for large values of self.tosnap
	# rapidly approaches 1 as self.tosnap goes to 0
	fsnap = 1 - math.exp(-dt / self.tosnap) if self.tosnap > 0 else 1

	if settings.manualcamera:
		gamma = self.mgamma
		phi = self.mphi

	self.gamma = math.mix(self.gamma, gamma, fsnap)
	self.phi += fsnap * math.zmod(phi - self.phi, 360)
	if fsnap == 0:
		self.phi = phi
	self.Rvantage = math.mix(self.Rvantage, Rvantage, fsnap)
	self.atilt = math.mix(self.atilt, atilt, 2 * dt)
	
	if not settings.manualcamera:
		self.mgamma = self.gamma
		self.mphi = self.phi

	theta = self.gamma
	uvantage = Vector3(0, 0, 1).rotate_x(theta).rotate_z(self.phi)
	
	dtilt = self.atilt.length()
	utilt = self.atilt.normalize() if dtilt else Vector3(0, 0, 1)
	self.camera = camera
	self.vantage = self.camera + self.Rvantage * uvantage.rotate(dtilt, utilt)
	self.up = Vector3(0, 0, 1).rotate_z(self.phi).rotate(dtilt, utilt)