Detekcja kolizji a widok w grze

Siema, Zastanawiam się czy programowanie detekcji kolizji jest w jakimś stopniu uzależnione od perspektywy gry? Tzn. jeśli np. mam już napisaną gotową funkcję, która działa w grze z widokiem izometrycznym, to jeśli wykorzystam ją przy pisaniu załóżmy jakiejś platformowki z widokiem z boku to zadziała w identyczny sposób czy będę musiał coś pozmieniać?

I jeszcze jedno... Jak poprawnie powinien wyglądać w Javie poniższy fragment kodu napisanego w Pythonie? Uprzejmie proszę o translację.

def collision(x1,y1,r1,x2,y2,r2):
if (x2-x1)**2+(y2-y1)**2<=(r1+r2)**2:
return True
else:
return False

Z góry dzięki za pomoc.

boolean collision(double x1,double y1,double r1, double x2, double y2, double r2){
    return Math.pow(x2-x1,2)+Math.pow(y2-y1,2) <= Math.pow(r1+r2,2);
}

Dzięki, ja jakoś nie potrafię zrozumieć tej składni... Mógłbym prosić o translacje do Javy jeszcze tylko tych 2 poniższych przykładów?

1).

def collision(self,x1,y1,w1,h1,x2,y2,w2,h2):
if x1 >= x2+w2: return True
if x1+w1 <= x2: return True
if y1 >= y2+h2: return True
if y1+h1 <= y2: return True
return False

2).

def collision(x,y,w,h,cx,cy,r):
# ustalamy pozycje najblizszego wierzcholka do srodka okregu
tx = cx
ty = cy
if cx < x: tx = x
if cx >= (x + w): tx = x + w
if cy < y: ty = y
if cy >= (y + h): ty = y + h
# sprawdzamy odleglosc miedzy wierzcholkiem a srodkiem okregu
# jesli mniejsza niz promien, oznacza to kolizje
if (cx-tx)**2+(cy-ty)**2 < r**2: return True
return False

I mógłby mi ktoś powiedzieć czym jest to "self" w 1 przykładzie? Tutaj cały kod (tego nie chce tłumaczyć do Javy jak coś):

import pygame # importujemy biblioteki pygame
from pygame.locals import * # importujemy nazwy [QUIT, KEYDOWN,K_ESCAPE] itp.
from sys import exit # importujemy funkcje systemowa exit
screen_size = (800,600) # ustalamy rozmiar ekranu
class IsoGame(object):
def __init__(self):
pygame.init() # incjalizujemy biblioteke pygame
flag = DOUBLEBUF # wlaczamy tryb podwojnego buforowania
# tworzymy bufor na grafike
self.surface = pygame.display.set_mode(screen_size,flag)
# zmienna stanu gry
self.gamestate = 1 # 1 - run, 0 - exit
self.images = [None] *2
self.images[0] = pygame.image.load('rectangle1.png')
self.images[1] = pygame.image.load('rectangle2.png')
self.sprite_x = 220 # pozycja x duszka
self.sprite_y = 130 # pozycja y duszka
self.speed = 1.2 # szybkosc poruszania duszka
self.player_x = 320 # pozycja x duszka na ekranie
self.player_y = 250 # pozycja y duszka na ekranie
self.loop() # glowna petla gry
def move(self,dirx,diry):
""" poruszanie duszkiem """
dx = self.player_x + (dirx * self.speed)
dy = self.player_y + (diry * self.speed)
if not self.collision(dx,dy,100,100,self.sprite_x,self.sprite_y,100,100):
return
self.player_x = dx
self.player_y = dy
def game_exit(self):
""" funkcja przerywa dzialanie gry i wychodzi do systemu"""
exit()
def collision(self,x1,y1,w1,h1,x2,y2,w2,h2):
if x1 >= x2+w2:
return True
if x1+w1 <= x2:
return True
if y1 >= y2+h2:
return True
if y1+h1 <= y2:
return True
return False
def loop(self):
""" glowna petla gry """
while self.gamestate==1:
player_anim = 0
for event in pygame.event.get():
if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
self.gamestate=0
keys = pygame.key.get_pressed() # odczytujemy stan klawiszy
if keys[K_s]:
self.move(0,1) # ruch w dol
if keys[K_w]:
self.move(0,-1) # ruch w gore
if keys[K_d]:
self.move(1,0) # ruch w prawo
if keys[K_a]:
self.move(-1,0) # ruch w lewo
self.surface.fill((0,0,0)) # czyscimy ekran, malo wydajne ale wystarczy
# umieszczamy gracza
self.surface.blit(self.images[1],(self.player_x,self.player_y))
self.surface.blit(self.images[0], (self.sprite_x,self.sprite_y))
pygame.display.flip() # przenosimy bufor na ekran
self.game_exit()
if __name__ == '__main__':
IsoGame()

Ad 1, 2: a czego w nich nie potrafisz przetłumaczyć?
Ad 3: self jest obiektem utworzonym na początku kodu, który opakowuje stan gry.

Rozmowy na temat do postów.

witek901 napisał(a)

No dobra... generalnie to nie potrafię przełożyć całości, a szczególnie nie wiem jak mam przerobić te self na kod do Javy, nie znam kompletnie Pythona i nie rozumiem kompletnie jego składni.

Jeżeli już musisz to tłumaczyć, w Javie będziesz potrzebował iść drogą nieco na około - musisz utworzyć singletona, który będzie zawierał te wszystkie pola, do których następuje przypisanie w pythonowskim kodzie (self.images, self.player_x i tak dalej) i wydedukować ich typy.
Np. self.images będzie tablicą czegoś, co zwraca pygame.image.load (na cokolwiek to tam zamieniłeś), self.player_x będzie floatem, i tak dalej.

W ten sposób funkcje move etc. zostaną metodami tego singletona.

1. ze łzami w oczach dałem tag code=python

def collision(self,x1,y1,w1,h1,x2,y2,w2,h2):
    if x1 >= x2+w2: return True
    if x1+w1 <= x2: return True
    if y1 >= y2+h2: return True
    if y1+h1 <= y2: return True
    return False

boolean collision(double x1, double y1, double w1, double h1, double x2, double y2, double w2, double h2){
    return (x1 >= x2+w2 || x1+w1 <= x2 || y1 >= y2+h2 || y1+h1 <= y2)

Też nie wiem o co w tym chodzi. Drugiego mi się nie chce, ale nie jest to zbyt skomplikowane więc spróbuj.

A nie powinno to być jednak tak?

boolean collision(double x1, double y1, double w1, double h1, double x2, double y2, double w2, double h2){
    return (x1 >= x2+w2 && x1+w1 <= x2 && y1 >= y2+h2 && y1+h1 <= y2)
}

Nie.

def collision(self,x1,y1,w1,h1,x2,y2,w2,h2):
    if x1 >= x2+w2: return True
    if x1+w1 <= x2: return True
    if y1 >= y2+h2: return True
    if y1+h1 <= y2: return True
    return False

return True wykona się, gdy którykolwiek z ifów zwróci true - u Ciebie, @witek901, wszystkie warunki musiałyby zostać spełnione (skądinąd afair nigdy by się tak nie stało), czyli zupełnie na odwrót.