So I am making a pong game in pygame while implementing oop. My problem is the colliderect function is giving me the error " ball_hitter object has no attribute 'colliderect'". I've used the colliderect function before but it's not working for me this time.
Code:
import pygame
from pygame.locals import *
pygame.init()
screen = pygame.display.set_mode((500,500))
pygame.display.set_caption("Pong With Classes!")
#Variables
red = (255,0,0)
blue = (0,0,255)
black = (0,0,0)
clock = pygame.time.Clock()
#End of Variables
class ball_hitter:
def __init__(self,x,y,length,width,color):
self.x = x
self.y = y
self.length = length
self.width = width
self.color = color
self.left = False
self.right = False
def draw_ball_hitter(self):
screen.fill(black)
pygame.draw.rect(screen,self.color,(self.x,self.y,self.length,self.width))
#Paddle creation
paddle = ball_hitter(250,400,130,20,red)
#End of Paddle Creation
class thing_thats_being_hit:
def __init__(self,x,y,color):
self.x = x
self.y = y
self.radius = 27
self.color = color
self.speed_x = -4
self.speed_y = 4
def draw_googlyball(self):
pygame.draw.circle(screen,self.color,(self.x,self.y),self.radius)
def move(self):
self.x += self.speed_x
self.y += self.speed_y
#Ball Creation
ball = thing_thats_being_hit(200,50,blue)
#End of Ball Creation
#Paddle Collision
if paddle.colliderect(ball):
print("It Worked!")
#End Of Paddle Collision
ball.move()
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
paddle.left = True
if event.key == pygame.K_RIGHT:
paddle.right = True
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
paddle.left = False
if event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
paddle.right = False
paddle.draw_ball_hitter()
ball.draw_googlyball()
if paddle.left == True:
paddle.x = paddle.x - 2
if paddle.right == True:
paddle.x = paddle.x + 2
if ball.x <= 0:
ball.speed_x*=-1
if ball.x >= 500:
ball.speed_x *= -1
if ball.y >= 500:
pygame.quit()
ball.move()
pygame.display.update()
clock.tick(100)
I would appreciate it if someone could give me a fixed code and explain is to me.
See How do I detect collision in pygame?. colliderect is a method of pygame.Rect. Therefore you need to create pygame.Rect objects. Also you have to do the collision test in the application loop instead of before the application loop:
while True:
# [...]
paddle_rect = pygame.Rect(paddle.x, paddle.y, paddle.width, paddle. length)
ball_rect = pygame.Rect(ball.x - ball.radius, ball.y - ball.radius,
ball.radius * 2, ball.radius * 2)
if paddle_rect.colliderect(ball_rect):
print("It Worked!")
Related
I tried to add videowidget to QFrame inside QstackedWidget but when i use QMediaPlayer.setVideoOutput the program run but
frozen, when i click on the window it just give beeping sound. when i comment the setVideoOutput it
run just fine.
`class halaman_belajar(QWidget):
def init(self):
super().init()
uic.loadUi(".\Asset\GuiHalamanBelajar.ui", self)
self.kembali_menu.clicked.connect(self.kembali)
self.kembali_menu.setCursor(QCursor(Qt.PointingHandCursor))
self.kembali_menu.setShortcut("esc")
self.bab_selanjutnya.clicked.connect(self.selanjutnya)
self.bab_selanjutnya.setCursor(QCursor(Qt.PointingHandCursor))
self.bab_selanjutnya.setShortcut(Qt.Key_Right)
self.bab_sebelumnya.clicked.connect(self.sebelumnya)
self.bab_sebelumnya.setCursor(QCursor(Qt.PointingHandCursor))
self.bab_sebelumnya.setShortcut(Qt.Key_Left)
self.halaman_isi.setCurrentIndex(0)
self.bab_sebelumnya.setEnabled(False)
if self.halaman_isi.currentIndex == 0:
self.bab_sebelumnya.setEnabled(False)
else:
self.bab_sebelumnya.setEnabled(True)
#Combo Box
self.pintasan_halaman.activated.connect(self.pintasanhalaman)
#video player
video = QVideoWidget()
self.videoproklamasi = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoproklamasi.setMedia(QMediaContent(QUrl.fromLocalFile("E:\ProjectHistoryApp\Asset\proklamasi.mp4")))
#self.videoproklamasi.setVideoOutput(video)
self.play = QPushButton()
self.play.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
#self.play.clicked.connect(self.mulaivideo)
self.slider= QSlider(Qt.Horizontal)
self.slider.setRange(0,0)
self.wadahnisor = QHBoxLayout()
self.wadahnisor.setContentsMargins(0,0,0,0)
self.wadahnisor.addWidget(self.play)
self.wadahnisor.addWidget(self.slider)
self.wadahvideo = QVBoxLayout(self.isi_video)
self.wadahvideo.addWidget(video)
self.wadahvideo.addLayout(self.wadahnisor)
def kembali(self):
pesan2 = QMessageBox()
pesan2.setWindowTitle("Status")
pesan2.setText("Kembali Ke Menu?")
pesan2.setWindowIcon(QIcon(".\Asset\Mascot.png"))
pesan2.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
hasil = pesan2.exec()
if hasil == QMessageBox.Yes:
show_halaman.setCurrentIndex(show_halaman.currentIndex() - 1)
def selanjutnya(self):
self.halaman_isi.setCurrentIndex(self.halaman_isi.currentIndex() + 1)
self.bab_sebelumnya.setEnabled(True)
#if halaman_isi.currentIndex == 10:
#self.bab_selanjutnya.setEnabled(False)
def sebelumnya(self):
self.halaman_isi.setCurrentIndex(self.halaman_isi.currentIndex() - 1)
if self.halaman_isi.currentIndex() == 0:
self.bab_sebelumnya.setEnabled(False)
def pintasanhalaman(self):
self.halaman_isi.setCurrentIndex(self.pintasan_halaman.currentIndex())
if self.halaman_isi.currentIndex() != 0:
self.bab_sebelumnya.setEnabled(True)
def mulaivideo(self):
if self.videoproklamasi.state() == QMediaPlayer.PlayingState():
self.videoproklamasi.pause()
else:
self.videoproklamasi.play()`
Basically, I am making a code that uses oop and pygame together. It draws 4 rectangles in the corners of the screen and gives each rectangle a name. I have to ask the user the name of one of the rectangles and change that rectangles color randomly.
Code:
import random
import pygame
from pygame.locals import *
pygame.init()
screen = pygame.display.set_mode((500,500))
pygame.display.set_caption("BOOGABOOGA")
blue = (0,0,255)
red = (255,0,0)
green = (0,255,0)
white = (255,255,255)
random = [blue,red,green,white]
class Rectangle:
def __init__(self,name,color,x,y,width,height,thickness):
self.name = name
self.color = color
self.x = x
self.y = y
self.width = width
self.height = height
self.thickness = thickness
def coolboymethoddraw(self):
pygame.draw.rect(screen,self.color,(self.x,self.y,self.width,self.height),self.thickness)
recty1 = Rectangle("YOYO",blue,50,50,50,50,0)
recty2 = Rectangle("BABYBOOGA",blue,450,450,50,50,0)
recty3 = Rectangle("ChotaBEAM",blue,0,450,50,50,0)
recty4 = Rectangle("CHOTAJAGGU",blue,450,0,50,50,0)
jaggu = [recty1,recty2,recty3,recty4]
recty3.coolboymethoddraw()
recty1.coolboymethoddraw()
recty4.coolboymethoddraw()
recty2.coolboymethoddraw()
def change_color(self):
print("Give me the name of 1 of the 4 rectangles!")
x = input()
for chota in jaggu:
if x == chota.name:
l = random.choice(random)
chota.color = l
recty1.change_color()
recty2.changecolor()
recty3.change_color()
recty4.change_color()
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
exit()
pygame.display.update()
I would appreciate an answer and why it wasn't working. Thanks!
First of all move your method change_color inside the class Rectangle.
class Rectangle:
def __init__(self,name,color,x,y,width,height,thickness):
self.name = name
self.color = color
self.x = x
self.y = y
self.width = width
self.height = height
self.thickness = thickness
def coolboymethoddraw(self):
pygame.draw.rect(screen,self.color,(self.x,self.y,self.width,self.height),self.thickness)
def change_color(self):
print("Give me the name of 1 of the 4 rectangles!")
x = input()
for chota in jaggu:
if x == chota.name:
l = random.choice(random)
chota.color = l
Then you need to move the draw methods inside the main loop, otherwise the rectangles will not be drawn.
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
recty3.coolboymethoddraw()
recty1.coolboymethoddraw()
recty4.coolboymethoddraw()
recty2.coolboymethoddraw()
pygame.display.update()
Dont name your list of colors random because you import a package called random. Name the list something like colors_list
You dont need to call the change_color method for all 4 rectangles because inside of this method you go through a list of your 4 rectangles already.
There is also a problem in the change_color method. You need to call the method inside the main loop as well, but because of the print statement and the input it will end in an ifinite loop.
I'm using Oanda API to automate Trading strategies, I have a 'price' error that only occurs when selecting some instruments such as XAG (silver), my guess is that there is a classification difference but Oanda is yet to answer on the matter.
The error does not occur when selecting Forex pairs.
If anyone had such issues in the past and managed to solve it I'll be happy to hear form them.
PS: I'm UK based and have access to most products including CFDs
class SMABollTrader(tpqoa.tpqoa):
def __init__(self, conf_file, instrument, bar_length, SMA, dev, SMA_S, SMA_L, units):
super().__init__(conf_file)
self.instrument = instrument
self.bar_length = pd.to_timedelta(bar_length)
self.tick_data = pd.DataFrame()
self.raw_data = None
self.data = None
self.last_bar = None
self.units = units
self.position = 0
self.profits = []
self.price = []
#*****************add strategy-specific attributes here******************
self.SMA = SMA
self.dev = dev
self.SMA_S = SMA_S
self.SMA_L = SMA_L
#************************************************************************
def get_most_recent(self, days = 5):
while True:
time.sleep(2)
now = datetime.utcnow()
now = now - timedelta(microseconds = now.microsecond)
past = now - timedelta(days = days)
df = self.get_history(instrument = self.instrument, start = past, end = now,
granularity = "S5", price = "M", localize = False).c.dropna().to_frame()
df.rename(columns = {"c":self.instrument}, inplace = True)
df = df.resample(self .bar_length, label = "right").last().dropna().iloc[:-1]
self.raw_data = df.copy()
self.last_bar = self.raw_data.index[-1]
if pd.to_datetime(datetime.utcnow()).tz_localize("UTC") - self.last_bar < self.bar_length:
break
def on_success(self, time, bid, ask):
print(self.ticks, end = " ")
recent_tick = pd.to_datetime(time)
df = pd.DataFrame({self.instrument:(ask + bid)/2},
index = [recent_tick])
self.tick_data = self.tick_data.append(df)
if recent_tick - self.last_bar > self.bar_length:
self.resample_and_join()
self.define_strategy()
self.execute_trades()
def resample_and_join(self):
self.raw_data = self.raw_data.append(self.tick_data.resample(self.bar_length,
label="right").last().ffill().iloc[:-1])
self.tick_data = self.tick_data.iloc[-1:]
self.last_bar = self.raw_data.index[-1]
def define_strategy(self): # "strategy-specific"
df = self.raw_data.copy()
#******************** define your strategy here ************************
df["SMA"] = df[self.instrument].rolling(self.SMA).mean()
df["Lower"] = df["SMA"] - df[self.instrument].rolling(self.SMA).std() * self.dev
df["Upper"] = df["SMA"] + df[self.instrument].rolling(self.SMA).std() * self.dev
df["distance"] = df[self.instrument] - df.SMA
df["SMA_S"] = df[self.instrument].rolling(self.SMA_S).mean()
df["SMA_L"] = df[self.instrument].rolling(self.SMA_L).mean()
df["position"] = np.where(df[self.instrument] < df.Lower) and np.where(df["SMA_S"] > df["SMA_L"] ,1,np.nan)
df["position"] = np.where(df[self.instrument] > df.Upper) and np.where(df["SMA_S"] < df["SMA_L"], -1, df["position"])
df["position"] = np.where(df.distance * df.distance.shift(1) < 0, 0, df["position"])
df["position"] = df.position.ffill().fillna(0)
self.data = df.copy()
#***********************************************************************
def execute_trades(self):
if self.data["position"].iloc[-1] == 1:
if self.position == 0 or None:
order = self.create_order(self.instrument, self.units, suppress = True, ret = True)
self.report_trade(order, "GOING LONG")
elif self.position == -1:
order = self.create_order(self.instrument, self.units * 2, suppress = True, ret = True)
self.report_trade(order, "GOING LONG")
self.position = 1
elif self.data["position"].iloc[-1] == -1:
if self.position == 0:
order = self.create_order(self.instrument, -self.units, suppress = True, ret = True)
self.report_trade(order, "GOING SHORT")
elif self.position == 1:
order = self.create_order(self.instrument, -self.units * 2, suppress = True, ret = True)
self.report_trade(order, "GOING SHORT")
self.position = -1
elif self.data["position"].iloc[-1] == 0:
if self.position == -1:
order = self.create_order(self.instrument, self.units, suppress = True, ret = True)
self.report_trade(order, "GOING NEUTRAL")
elif self.position == 1:
order = self.create_order(self.instrument, -self.units, suppress = True, ret = True)
self.report_trade(order, "GOING NEUTRAL")
self.position = 0
def report_trade(self, order, going):
time = order["time"]
units = order["units"]
price = order["price"]
pl = float(order["pl"])
self.profits.append(pl)
cumpl = sum(self.profits)
print("\n" + 100* "-")
print("{} | {}".format(time, going))
print("{} | units = {} | price = {} | P&L = {} | Cum P&L = {}".format(time, units, price, pl, cumpl))
print(100 * "-" + "\n")
trader = SMABollTrader("oanda.cfg", "EUR_GBP", "15m", SMA = 82, dev = 4, SMA_S = 38, SMA_L = 135, units = 100000)
trader.get_most_recent()
trader.stream_data(trader.instrument, stop = None )
if trader.position != 0: # if we have a final open position
close_order = trader.create_order(trader.instrument, units = -trader.position * trader.units,
suppress = True, ret = True)
trader.report_trade(close_order, "GOING NEUTRAL")
trader.signal = 0
I have done Hagmann course as well and I have recognised your code immediately.
Firstly the way you define your positions is not the best. Look at the section of combining two strategies. There are two ways.
Now regarding your price problem I had a similar situation with BTC. You can download it's historical data but when I plotted it to the strategy code and started to stream I had exactly the same error indicating that tick data was never streamed.
I am guessing that simply not all instruments are tradeable via api or in your case maybe you tried to stream beyond trading hours?
I tried to create a scene that resembles a bullet for a platformer shooter in Godot. I have created a scene with the root node being an Area2D, with a collision, and a visibility notifier. The code in that root node goes like this:
extends Area2D
export var bullet_speed = 400
var motion = Vector2()
func start():
position = Vector2()
pass
func _physics_process(delta):
motion.x = bullet_speed * delta
translate(motion)
func _on_VisibilityNotifier_screen_exited():
queue_free()
pass # Replace with function body.
Then I have a scene which has the player scene in it. In the player scene, the root node is a KinematicBody2D, A Collision Shape, and a Position2D with no name changes
The script of a player (cut short) has a physics process delta with the following commands:
const bulletlaunch = preload("res://Sprites/Gun Animation/Bullet.tscn") ##Declared the bullet scene
func _physics_process(delta):
Engine.target_fps = 60
#Playable when NOT dead
if is_dead == false:
var x_input = Input.get_action_strength("ui_right") - Input.get_action_strength("ui_left")
hud_score_display.text = String(GlobalScore.score)
score_display.text = String(GlobalScore.score)
heart_hud.value = health
if health >= 75 && health <= 100:
heart_hud.tint_progress = Color.green
if health >= 50 && health <= 74:
heart_hud.tint_progress = Color.orange
if health >= 25 && health <= 49:
heart_hud.tint_progress = Color.red
if x_input != 0:
if x_input == -1:
if playing_health_damage == false:
character.flip_h = true
character.play("Idle")
if x_input == 1:
if playing_health_damage == false:
character.flip_h = false
character.play("Idle")
motion.x += x_input * acceleration * delta
motion.x = clamp(motion.x, -max_speed, max_speed)
else:
if playing_health_damage == false:
motion.x = lerp(motion.x, 0, air_resistance)
character.play("Idle")
motion.y += gravity * delta
if is_on_floor():
if x_input == 0:
motion.x = lerp(motion.x, 0, friction)
if Input.is_action_just_pressed("ui_up"):
motion.y = -jump_force
small_jump_sound.play()
if Input.is_action_just_pressed("ui_action"): ##The place where I have the error
var bulletinstance = bulletlaunch.instance()
get_parent().add_child(bulletinstance)
bulletinstance.position = $Position2D.global_position
motion = move_and_slide(motion, Vector2.UP)
pass
However I when I press the ui_action key, I get this error
Invalid get index 'global_position' (on base: 'null instance').
Which I don't really understand..
What I've tried:
Changing the global_position to position in both of them and doing
all the combinations
Find another Position2D like replacement but I can't find anything like that
use the print(playershootpos.position) on the if ui_action statement but I seem to get the same error. Weird.
Other question:
Are there any replacements for the Position2D node?
And what is the issue?
In my other question, some of the posters asked to see the code and suggested I make a new question. As requested, here is most of the code I'm using. I've removed the Vector class, simply because it's a lot of code. It's well-understood math that I got from someone else (https://gist.github.com/mcleonard/5351452), and cProfile didn't have much to say about any of the functions there. I've provided a link in the code, if you want to make this run-able.
This code should run, if you paste the the vector class where indicated in the code.
The problem is, once I get above 20 critters, the framerate drops rapidly from 60fps to 11fps around 50 critters.
Please excuse the spaghetti-code. Much of this is diagnostic kludging or pre-code that I intend to either remove, or turn into a behavior (instead of a hard-coded value).
This app is basically composed of 4 objects.
A Vector object provides abstracted vector operations.
A Heat Block is able to track it's own "heat" level, increase it and decrease it. It can also draw itself.
A Heat Map is composed of heat blocks which are tiled across the screen. When given coordinates, it can choose the block that those coordinates fall within.
A Critter has many features that make it able to wander around the screen, bump off of the walls and other critters, choose a new random direction, and die.
The main loop iterates through each critter in the "flock" and updates its "condition" (whether or not it's "dying"), its location, its orientation, and the heat block on which it is currently standing. The loop also iterates over each heat block to let it "cool down."
Then the main loop asks the heat map to draw itself, and then each critter in the flock to draw itself.
import pygame
from pygame import gfxdraw
import pygame.locals
import os
import math
import random
import time
(I got a nice vector class from someone else. It's large, and mostly likely not the problem.)
(INSERT CONTENTS OF VECTOR.PY FROM https://gist.github.com/mcleonard/5351452 HERE)
pygame.init()
#some global constants
BLUE = (0, 0, 255)
WHITE = (255,255,255)
diagnostic = False
SPAWN_TIME = 1 #number of seconds between creating new critters
FLOCK_LIMIT = 30 #number of critters at which the flock begins being culled
GUIDs = [0] #list of guaranteed unique IDs for identifying each critter
# Set the position of the OS window
position = (30, 30)
os.environ['SDL_VIDEO_WINDOW_POS'] = str(position[0]) + "," + str(position[1])
# Set the position, width and height of the screen [width, height]
size_x = 1000
size_y = 500
size = (size_x, size_y)
FRAMERATE = 60
SECS_FOR_DYING = 1
screen = pygame.display.set_mode(size)
screen.set_alpha(None)
pygame.display.set_caption("My Game")
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
def random_float(lower, upper):
num = random.randint(lower*1000, upper*1000)
return num/1000
def new_GUID():
num = GUIDs[-1]
num = num + 1
while num in GUIDs:
num += 1
GUIDs.append(num)
return num
class HeatBlock:
def __init__(self,_tlx,_tly,h,w):
self.tlx = int(_tlx)
self.tly = int(_tly)
self.height = int(h)+1
self.width = int(w)
self.heat = 255.0
self.registered = False
def register_tresspasser(self):
self.registered = True
self.heat = max(self.heat - 1, 0)
def cool_down(self):
if not self.registered:
self.heat = min(self.heat + 0.1, 255)
self.registered = False
def hb_draw_self(self):
screen.fill((255,int(self.heat),int(self.heat)), [self.tlx, self.tly, self.width, self.height])
class HeatMap:
def __init__(self, _h, _v):
self.h_freq = _h #horizontal frequency
self.h_rez = size_x/self.h_freq #horizontal resolution
self.v_freq = _v #vertical frequency
self.v_rez = size_y/self.v_freq #vertical resolution
self.blocks = []
def make_map(self):
h_size = size_x/self.h_freq
v_size = size_y/self.v_freq
for h_count in range(0, self.h_freq):
TLx = h_count * h_size #TopLeft corner, x
col = []
for v_count in range(0, self.v_freq):
TLy = v_count * v_size #TopLeft corner, y
col.append(HeatBlock(TLx,TLy,v_size,h_size))
self.blocks.append(col)
def hm_draw_self(self):
for col in self.blocks:
for block in col:
block.cool_down()
block.hb_draw_self()
def register(self, x, y):
#convert the given coordinates of the trespasser into a col/row block index
col = max(int(math.floor(x / self.h_rez)),0)
row = max(int(math.floor(y / self.v_rez)),0)
self.blocks[col][row].register_tresspasser()
class Critter:
def __init__(self):
self.color = (random.randint(1, 200), random.randint(1, 200), random.randint(1, 200))
self.linear_speed = random_float(20, 100)
self.radius = int(round(10 * (100/self.linear_speed)))
self.angular_speed = random_float(0.1, 2)
self.x = int(random.randint(self.radius*2, size_x - (self.radius*2)))
self.y = int(random.randint(self.radius*2, size_y - (self.radius*2)))
self.orientation = Vector(0, 1).rotate(random.randint(-180, 180))
self.sensor = Vector(0, 20)
self.sensor_length = 20
self.new_orientation = self.orientation
self.draw_bounds = False
self.GUID = new_GUID()
self.condition = 0 #0 = alive, [1-fps] = dying, >fps = dead
self.delete_me = False
def c_draw_self(self):
#if we're alive and not dying, draw our normal self
if self.condition == 0:
#diagnostic
if self.draw_bounds:
pygame.gfxdraw.rectangle(screen, [int(self.x), int(self.y), 1, 1], BLUE)
temp = self.orientation * (self.linear_speed * 20)
pygame.gfxdraw.line(screen, int(self.x), int(self.y), int(self.x + temp[0]), int(self.y + temp[1]), BLUE)
#if there's a new orientation, match it gradually
temp = self.new_orientation * self.linear_speed
#draw my body
pygame.gfxdraw.aacircle(screen, int(self.x), int(self.y), self.radius, self.color)
#draw a line indicating my new direction
pygame.gfxdraw.line(screen, int(self.x), int(self.y), int(self.x + temp[0]), int(self.y + temp[1]), BLUE)
#draw my sensor (a line pointing forward)
self.sensor = self.orientation.normalize() * self.sensor_length
pygame.gfxdraw.line(screen, int(self.x), int(self.y), int(self.x + self.sensor[0]), int(self.y + self.sensor[1]), BLUE)
#otherwise we're dying, draw our dying animation
elif 1 <= self.condition <= FRAMERATE*SECS_FOR_DYING:
#draw some lines in a spinningi circle
for num in range(0,10):
line = Vector(0, 1).rotate((num*(360/10))+(self.condition*23))
line = line*self.radius
pygame.gfxdraw.line(screen, int(self.x), int(self.y), int(self.x+line[0]), int(self.y+line[1]), self.color)
def print_self(self):
#diagnostic
print("==============")
print("radius:", self.radius)
print("color:", self.color)
print("linear_speed:", self.linear_speed)
print("angular_speed:", self.angular_speed)
print("x:", self.x)
print("y:", int(self.y))
print("orientation:", self.orientation)
def avoid_others(self, _flock):
for _critter in _flock:
#if the critter isn't ME...
if _critter.GUID is not self.GUID and _critter.condition == 0:
#and it's touching me...
if self.x - _critter.x <= self.radius + _critter.radius:
me = Vector(self.x, int(self.y))
other_guy = Vector(_critter.x, _critter.y)
distance = me - other_guy
#give me new orientation that's away from the other guy
if distance.norm() <= ((self.radius) + (_critter.radius)):
new_direction = me - other_guy
self.orientation = self.new_orientation = new_direction.normalize()
def update_location(self, elapsed):
boundary = '?'
while boundary != 'X':
boundary = self.out_of_bounds()
if boundary == 'N':
self.orientation = self.new_orientation = Vector(0, 1).rotate(random.randint(-20, 20))
self.y = (self.radius) + 2
elif boundary == 'S':
self.orientation = self.new_orientation = Vector(0,-1).rotate(random.randint(-20, 20))
self.y = (size_y - (self.radius)) - 2
elif boundary == 'E':
self.orientation = self.new_orientation = Vector(-1,0).rotate(random.randint(-20, 20))
self.x = (size_x - (self.radius)) - 2
elif boundary == 'W':
self.orientation = self.new_orientation = Vector(1,0).rotate(random.randint(-20, 20))
self.x = (self.radius) + 2
point = Vector(self.x, self.y)
self.x, self.y = (point + (self.orientation * (self.linear_speed*(elapsed/1000))))
boundary = self.out_of_bounds()
def update_orientation(self, elapsed):
#randomly choose a new direction, from time to time
if random.randint(0, 100) > 98:
self.choose_new_orientation()
difference = self.orientation.argument() - self.new_orientation.argument()
self.orientation = self.orientation.rotate((difference * (self.angular_speed*(elapsed/1000))))
def still_alive(self, elapsed):
return_value = True #I am still alive
if self.condition == 0:
return_value = True
elif self.condition <= FRAMERATE*SECS_FOR_DYING:
self.condition = self.condition + (elapsed/17)
return_value = True
if self.condition > FRAMERATE*SECS_FOR_DYING:
return_value = False
return return_value
def choose_new_orientation(self):
if self.new_orientation:
if (self.orientation.argument() - self.new_orientation.argument()) < 5:
rotation = random.randint(-300, 300)
self.new_orientation = self.orientation.rotate(rotation)
def out_of_bounds(self):
if self.x >= (size_x - (self.radius)):
return 'E'
elif self.y >= (size_y - (self.radius)):
return 'S'
elif self.x <= (0 + (self.radius)):
return 'W'
elif self.y <= (0 + (self.radius)):
return 'N'
else:
return 'X'
# -------- Main Program Loop -----------
# generate critters
flock = [Critter()]
# generate heat map
heatMap = HeatMap(60, 40)
heatMap.make_map()
# set some settings
last_spawn = time.clock()
run_time = time.perf_counter()
frame_count = 0
max_time = 0
ms_elapsed = 1
avg_fps = [1]
# Loop until the user clicks the close button.
done = False
while not done:
# --- Main event loop only processes one event
frame_count = frame_count + 1
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
# --- Game logic should go here
#check if it's time to make another critter
if time.clock() - last_spawn > SPAWN_TIME:
flock.append(Critter())
last_spawn = time.clock()
if len(flock) >= FLOCK_LIMIT:
#if we're over the flock limit, cull the herd
counter = FLOCK_LIMIT
for critter in flock[0:len(flock)-FLOCK_LIMIT]:
#this code allows a critter to be "dying" for a while, to play an animation
if critter.condition == 0:
critter.condition = 1
elif not critter.still_alive(ms_elapsed):
critter.delete_me = True
counter = 0
#delete all the critters that have finished dying
while counter < len(flock):
if flock[counter].delete_me:
del flock[counter]
else:
counter = counter+1
#----loop on all critters once, doing all functions for each critter
for critter in flock:
if critter.condition == 0:
critter.avoid_others(flock)
if critter.condition == 0:
heatMap.register(critter.x, critter.y)
critter.update_location(ms_elapsed)
critter.update_orientation(ms_elapsed)
if diagnostic:
critter.print_self()
#----alternately, loop for each function. Speed seems to be similar either way
#for critter in flock:
# if critter.condition == 0:
# critter.update_location(ms_elapsed)
#for critter in flock:
# if critter.condition == 0:
# critter.update_orientation(ms_elapsed)
# --- Screen-clearing code goes here
# Here, we clear the screen to white. Don't put other drawing commands
screen.fill(WHITE)
# --- Drawing code should go here
#draw the heat_map
heatMap.hm_draw_self()
for critter in flock:
critter.c_draw_self()
#draw the framerate
myfont = pygame.font.SysFont("monospace", 15)
#average the framerate over 60 frames
temp = sum(avg_fps)/float(len(avg_fps))
text = str(round(((1/temp)*1000),0))+"FPS | "+str(len(flock))+" Critters"
label = myfont.render(text, 1, (0, 0, 0))
screen.blit(label, (5, 5))
# --- Go ahead and update the screen with what we've drawn.
pygame.display.update()
# --- Limit to 60 frames per second
#only run for 30 seconds
if time.perf_counter()-run_time >= 30:
done = True
#limit to 60fps
#add this frame's time to the list
avg_fps.append(ms_elapsed)
#remove any old frames
while len(avg_fps) > 60:
del avg_fps[0]
ms_elapsed = clock.tick(FRAMERATE)
#track longest frame
if ms_elapsed > max_time:
max_time = ms_elapsed
#print some stats once the program is finished
print("Count:", frame_count)
print("Max time since last flip:", str(max_time)+"ms")
print("Total Time:", str(int(time.perf_counter()-run_time))+"s")
print("Average time for a flip:", str(int(((time.perf_counter()-run_time)/frame_count)*1000))+"ms")
# Close the window and quit.
pygame.quit()
One thing you can already do to improve the performance is to use pygame.math.Vector2 instead of your Vector class, because it's implemented in C and therefore faster. Before I switched to pygame's vector class, I could have ~50 critters on the screen before the frame rate dropped below 60, and after the change up to ~100.
pygame.math.Vector2 doesn't have that argument method, so you need to extract it from the class and turn it into a function:
def argument(vec):
""" Returns the argument of the vector, the angle clockwise from +y."""
arg_in_rad = math.acos(Vector(0,1)*vec/vec.length())
arg_in_deg = math.degrees(arg_in_rad)
if vec.x < 0:
return 360 - arg_in_deg
else:
return arg_in_deg
And change .norm() to .length() everywhere in the program.
Also, define the font object (myfont) before the while loop. That's only a minor improvement, but every frame counts.
Another change that made a significant improvement was to streamline my collision-detection algorithm.
Formerly, I had been looping through every critter in the flock, and measuring the distance between it and every other critter in the flock. If that distance was small enough, I do something. That's n^2 checks, which is not awesome.
I'd thought about using a quadtree, but it didn't seem efficient to rebalance the whole tree every frame, because it will change every time a critter moves.
Well, I finally actually tried it, and it turns out that building a brand-new quadtree at the beginning of each frame is actually plenty fast. Once I have the tree, I pass it to the avoidance function where I just extract an intersection of any of the critters in that tree within a bounding box I care about. Then I just iterate on those neighbors to measure distances and update directions and whatnot.
Now I'm up to 150 or so critters before I start dropping frames (up from 40).
So the moral of the story is, trust evidence instead of intuition.