Ez egy egyszerű játékos példa a mozgó célpontok bombázására.
Forrás;
from Tkinter import *
from math import sin, cos, pi
from random import randrange
from threading import Thread
import time
def __init__(self, boss, num, x, y, irany):
self.boss = boss # a vászon hivatkozása
self.num = num # az ágyú száma a listában
self.x1, self.y1 = x, y # ágyú forgástengelye
self.irany = irany # lövés iránya (-1:balra, +1:jobbra)
self.lagyucso = 30 # ágyú hossza
# ágyú rajzolása (vízszintes) :
self.x2, self.y2 = x + self.lagyucso * irany, y
self.cso = boss.create_line(self.x1, self.y1,
self.x2, self.y2, width =10)
# ágyútest rajzolása (színes kör) :
self.rc = 15 # a kör sugara
self.test = boss.create_oval(x -self.rc, y -self.rc, x +self.rc,
y +self.rc, fill ='black')
# egy eaketa előrajzolása (kiinduláskor egy pont) :
self.lovedek = boss.create_oval(x, y, x, y, fill='red')
self.anim = 0
# a célterület szélességének és magasságának meghatározása :
self.xMax = int(boss.cget('width'))
self.yMax = int(boss.cget('height'))
def iranyzas(self, angle):
"ágyú dőlésszögének beállítása"
# rem : az <angle> (szög) paramétert stringként kapja.
# át kell alakítani valós számmá, majd radiánná :
self.angle = float(angle)*2*pi/360
self.x2 = self.x1 + self.lagyucso * cos(self.angle) * self.irany
self.y2 = self.y1 - self.lagyucso * sin(self.angle)
self.boss.coords(self.cso, self.x1, self.y1, self.x2, self.y2)
def tuz(self):
"raketa kilövésének indítása"
# céltárgy hivatkozása :
self.celtargy = self.boss.master.celtargy
if self.anim ==0:
self.anim =1
# raketa kezdő pozíciója (ez az ágyú torka) :
self.xo, self.yo = self.x2, self.y2
v = 20 # kezdõ sebesség
# ennek a sebességnek a függőleges és vízszintes komponensei :
self.vy = -v *sin(self.angle)
self.vx = v *cos(self.angle) *self.irany
self.animacio_raketa()
def animacio_raketa(self):
"rakéta animációja (ballisztikus pálya)"
# rakéta pozícionálása koordinátái újradefiniálásával :
self.boss.coords(self.lovedek, self.xo -3, self.yo -3,
self.xo +3, self.yo +3)
if self.anim >0:
# a következõ pozíció számolása :
self.xo += self.vx
self.yo += self.vy
self.vy += .5
self.test_akadaly() # akadályba ütközött ?
self.boss.after(1, self.animacio_lovedek)
else:
# animáció vége :
self.boss.coords(self.lovedek, self.x1, self.y1, self.x1, self.y1)
def test_akadaly(self):
"Eldöntjük: a lövedék célba talált-e vagy elveszett"
if self.yo >self.yMax or self.xo <0 or self.xo >self.xMax:
self.anim =0
return
if self.yo > self.celtargy.y -3 and self.yo < self.celtargy.y +18 \
and self.xo > self.celtargy.x -3 and self.xo < self.celtargy.x +43:
# vizuális visszajelzés látjuk a lövedék robbanását (narancssárga kör) :
self.robbanas = self.boss.create_oval(self.xo -10,
self.yo -10, self.xo +10, self.yo +10,
fill ='orange', width =0)
self.boss.after(150, self.robbanas_vege)
self.anim =0
def robbanas_vege(self):
"a robbanási kör törlése - a pontszám kezelése"
self.boss.delete(self.robbanas)
# a siker jelzése a master-ablaknak :
self.boss.master.goal()
class VezerloPult(Frame):
"""Egy ágyúhoz asszociált vezérlőpult"""
def __init__(self, boss, canon):
Frame.__init__(self, bd =3, relief =GROOVE)
self.score =0
s =Scale(self, from_ =88, to =65,
troughcolor ='dark grey',
command =canon.iranyzas)
s.set(45) # a lövés kezdő szöge
s.pack(side =LEFT)
Label(self, text ='Dõlésszög').pack(side =TOP, anchor =W, pady =5)
Button(self, text ='Tûz !', command =canon.tuz).\
pack(side =BOTTOM, padx =5, pady =5)
Label(self, text ="pont").pack()
self.pontok =Label(self, text=' 0 ', bg ='white')
self.pontok.pack()
# positionner a gauche ou a droite suivant le sens du canon :
gd =(LEFT, RIGHT)[canon.irany == -1]
self.pack(padx =3, pady =5, side =gd)
def pontHozzaadasa(self, p):
"a pontszám növelése vagy csökkentése"
self.score += p
self.pontok.config(text = ' %s ' % self.score)
class Celtargy:
"""céltárgyként szolgáló objektum"""
def __init__(self, can, x, y):
self.can = can # a felület hivatkozása
self.x, self.y = x, y
self.celtargy = can.create_oval(x, y, x+40, y+15, fill ='purple')
def elmozditas(self, dx, dy):
"a céltárgy dx,dy elmozdítása"
self.x += dx
self.y += dy
self.can.move(self.celtargy, dx, dy)
return self.x, self.y
class Thread_celtargy(Thread):
def __init__(self, app, celtargy):
Thread.__init__(self)
self.celtargy = celtargy # az elmozdítandó objektum
self.app = app # az alkalmazásablak hivatkozása
self.sx, self.sy = 6, 3 # távolság- és idõnövekmények
self.dt =.3 # az animációhoz
def run(self):
"animálás, amíg az alkalmazásablak létezik"
while self.app != None:
x, y = self.celtargy.elmozditas(self.sx, self.sy)
if x > self.app.xm -50 or x < self.app.xm /5:
self.sx = -self.sx
if y < self.app.ym /2 or y > self.app.ym -20:
self.sy = -self.sy
time.sleep(self.dt)
def stop(self):
"a thread zárása, ha az alkalmazásablak zárva van"
self.app =None
def gyorsit(self):
"a mozgás gyorsítása"
self.dt /= 1.5
class Application(Frame):
def __init__(self):
Frame.__init__(self)
self.master.title('<<< Lövés mozgó céltárgyra >>>')
self.pack()
self.xm, self.ym = 600, 500
self.jatek = Canvas(self, width =self.xm, height =self.ym,
bg ='ivory', bd =3, relief =SUNKEN)
self.jatek.pack(padx =4, pady =4, side =TOP)
# Egy ágyú és egy vezérlő pult objektum létrehozása :
x, y = 30, self.ym -20
self.agyu =Canon(self.jatek, 1, x, y, 1)
self.pult =VezerloPult(self, self.agyu)
Készítsünk a teszthez egy mozgó célpontot.
Példa
# mozgó célpont létrehozása :
self.celtargy = Celtargy(self.jatek, self.xm/2, self.ym -25)
# mozgó célpont animálása saját thread-del :
self.tc = Thread_celtargy(self, self.celtargy)
self.tc.start()
# az összes thread leállítása amikor zárjuk az ablakot :
self.bind('<Destroy>',self.zaras_threadek)
def goal(self):
"a célpontot eltaláltuk"
self.pult.pontHozzaadasa(1)
self.tc.gyorsit()
def zaras_threadek(self, evt):
"a célpont animációs thread-jének leállítása"
self.tc.stop()
if __name__ =='__main__':
Application().mainloop()
Ha szükséges adatbázist is készíthetünk
Példa
# Adatbázis létrehozása és feltöltése
import gadfly
import os
path_ = os.getcwd() # aktualis konyvtar
connection = gadfly.gadfly()
connection.startup("music", path_)
cur = connection.cursor()
request = "create table zeneszerzok (eloado varchar, ev_szul integer,\
ev_halal integer)"
cur.execute(request)
request = "create table muvek (eloado varchar, cim varchar,\
ido integer, interpr varchar)"
cur.execute(request)
print "Bevitt adatok kiirasa a zeneszerzok adattablaba :"
while 1:
nv = raw_input("Zeneszerzo neve (<Enter> befejezes) : ")
if nm =='':
break
esz = raw_input("Szuletes eve : ")
eha = raw_input("Halal eve : ")
request ="insert into zeneszerzok(eloado, ev_szul, ev_halal) values \
('%s', %s, %s)" % (nv, esz, eha)
cur.execute(request)
# Ellenorzeskent kiirja a bevitt adatokat :
cur.execute("select * from zeneszerzok")
print cur.pp()
print "Bevitt adatok rögzitese a muvek adattablaba :"
while 1:
nev_ = raw_input("Zeneszerzo neve (<Enter> befejezes) : ")
if nev_ =='':
break
cim_ = raw_input("Zenemu cime : ")
ido_ = raw_input("idotartam (perc) : ")
int = raw_input("eloado : ")
request ="insert into muvek(eloado, cim, ido, interpr) values \
('%s', '%s', %s, '%s')" % (nev_, cim_, ido_, int)
cur.execute(request)
# Ellenorzeskent kiirja a bevitt adatokat :
cur.execute("select * from muvek")
print cur.pp()
connection.commit()
Időzités
Python turtl e modulja rendelkezik egy időzítővel, amely eseményt okozhat, ha az ideje lejár . import turtle turtle.setup(x,y) w n = turtle .Screen () wn.title("Időzítő használata")
péplda
Automatikus végrehajtás
import turtle
turtle.setup(400,500)
ablak = turtle.Screen()
ablak.title("Időzítő használata")
ablak.bgcolor("lightgreen")
Gun = turtle.Turtle()
Gun.color("purple")
Gun.pensize(3)
def ek1():
Gun.forward(100)
Gun.left(56)
ablak.ontimer(ek1, 2000)
ablak.mainloop()
Repülés alakzatban parancs
shapesize
Eseményfigyelés és kezelés akár a flotta minden résztvevőjének külön külön.
import turtle
gun.listen()
gun.mainloop()
Nyomkövetés, légi felvételek elemzése.
Felemelkedés
#############DEPENDENCIES#######################
from dronekit import connect, VehicleMode,LocationGlobalRelative,APIException
import time
import socket
import exceptions
import math
##############FUNCTIONS##########################
##Function to arm the drone props and takeoff at targetHeight (m)
def arm_and_takeoff(targetHeight):
while vehicle.is_armable!=True:
print("Waiting for vehicle to become armable.")
time.sleep(1)
print("Vehicle is now armable")
vehicle.mode = VehicleMode("GUIDED")
while vehicle.mode!='GUIDED':
print("Waiting for drone to enter GUIDED flight mode")
time.sleep(1)
print("Vehicle now in GUIDED MODE. Have fun!!")
vehicle.armed = True
while vehicle.armed==False:
print("Waiting for vehicle to become armed.")
time.sleep(1)
print("Look out! Virtual props are spinning!!")
vehicle.simple_takeoff(targetHeight)
while True:
print("Current Altitude: %d"%vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt>=.95*targetHeight:
break
time.sleep(1)
print("Target altitude reached!!")
return None
############MAIN EXECUTABLE#############
####sim_vehicle.py opens up port on localhost:14550
vehicle = connect('127.0.0.1:14550',wait_ready=True)
####Arm the drone and takeoff into the air at 5 meters
arm_and_takeoff(5)
print("Vehicle reached target altitude")
####Once drone reaches target altitude, change mode to LAND
vehicle.mode=VehicleMode('LAND')
while vehicle.mode!='LAND':
print("Waiting for drone to enter LAND mode")
time.sleep(1)
print("Vehicle now in LAND mode. Will touch ground shortly.")
Nincsenek megjegyzések:
Megjegyzés küldése