Surfacy

[kt1117]

Witam, ma problem. Mam system zaginania liny i liny malowane są za pomocą surfaca'ów. Powoduje to, że wiele surface'ów, musi być odmalowane w każdym stepie. To zaś powoduje, że obraz w okolicy liny śnieży. Wiecie co na to poradzić?

[kt1117]

Wiem, że nie wolno duble' postować, ale chciałbym odświeżyć temat. Bardzo proszę o pomoc.

[Konrad-GM]

A czy używasz

GML

draw_clear_alpha

?

[Dawidds]

Może zacznijmy od tego po co rysujesz liny za pomocą surfaceów, tym bardziej że sam stwierdziłeś, że "wiele surface'ów musi być odmalowywane w każdym stepie".

[kt1117]

Chodzi o to, że liny mają mieć teksturę sprite'a.

[Dawidds]

I w jaki sposób surface'y pomogły Ci uzyskać ten efekt ^^ ?

 

Rysuj primitivami i będziesz miał broblem z głowy i nawet wydajniejsze rysowanie, chociaż w sumie nie wiem co Ty wykombinowałeś dokładnie z tymi surfami.

[kt1117]

Bardzo prosta rzecz. Podam zaraz kod. Chodzi o to, że dopóki lina się nie zginała, to miałem tylko jeden surfek, a teraz mam ich więcej.

 

Kod:

GML (step)

ilosc=0

while (ilosc<=czek)

{

if ilosc<czek

{

execute_string("surface_set_target(sprite_linka"+string(ilosc)+")")

///////////////////////////////////długości liczone z pitagorasa/////////////////

draw_rectangle(0,0,1000,32,0)

draw_clear_alpha(c_white,0)

xx=max(czek_x[ilosc],czek_x[ilosc+1])

xxx=min(czek_x[ilosc],czek_x[ilosc+1])

 

yy=max(czek_y[ilosc],czek_y[ilosc+1])

yyy=min(czek_y[ilosc],czek_y[ilosc+1])

}

else

{

surface_set_target(sprite_linka)

///////////////////////////////////długości liczone z pitagorasa/////////////////

draw_rectangle(0,0,1000,32,0)

draw_clear_alpha(c_white,0)

xx=max(czek_x[ilosc],player.x)

xxx=min(czek_x[ilosc],player.x)

 

yy=max(czek_y[ilosc],player.y)

yyy=min(czek_y[ilosc],player.y)

}

 

 

xxxx=xx-xxx

yyyy=yy-yyy

 

dlll=power(power(xxxx,2)+power(yyyy,2),0.5)

///////////////////////////////pętelka rysujaca///////////////////////

a=0

while (a+58<dlll)

{

draw_sprite(sprite6,0,a,0)

a+=58

}

 

 

draw_sprite_part(sprite6,0,0,0,dlll-a,7,a,0)

 

surface_reset_target()

ilosc+=1

}

 

if player.lina=1

{

surface_set_target(sprite_linka)

///////////////////////////////////długości liczone z pitagorasa/////////////////

draw_rectangle(0,0,1000,32,0)

draw_clear_alpha(c_white,0)

xx=max(x,player.x)

xxx=min(x,player.x)

 

yy=max(y,player.y)

yyy=min(y,player.y)

 

xxxx=xx-xxx

yyyy=yy-yyy

 

dlll=power(power(xxxx,2)+power(yyyy,2),0.5)

///////////////////////////////pętelka rysujaca///////////////////////

a=0

while (a+58<dlll)

{

draw_sprite(sprite6,0,a,0)

a+=58

}

 

 

draw_sprite_part(sprite6,0,0,0,dlll-a,7,a,0)

 

surface_reset_target()

ilosc+=1

}

 

Wiem, że lepiej było by zamienić tą tablicę na listę, ale to utrudnia debug.

 

sprite6, to sprite 32x58 z teksturką liny.

E:Dam jeszcze kod na zaginanie:

GML (draw)

draw_set_color(c_red)

if player.lina=2

{

n=0

while (n<czek)

{

execute_string("draw_surface_ext(sprite_linka"+string(n)+",/*tutaj czek*/czek_x[n],/*tutaj czek*/czek_y[n],1,1,point_direction(/*tutaj czek*/czek_x[n],/*tutaj czek*/czek_y[n],czek_x[n+1],czek_y[n+1]),c_white,1)")

//draw_line(czek_x[n],czek_y[n],czek_x[n+1],czek_y[n+1])

n+=1

}

draw_surface_ext(sprite_linka,czek_x[czek],czek_y[czek],1,1,point_direction(czek_x[czek],czek_y[czek],player.x,player.y),c_white,1)

}

 

if player.lina=1

draw_surface_ext(sprite_linka,/*tutaj czek*/x,/*tutaj czek*/y,1,1,point_direction(/*tutaj czek*/x,/*tutaj czek*/y,player.x,player.y),c_white,1)

//draw_line(x,y,player.x,player.y);</span></span>

i

GML (begin step)

if collision_line(czek_x[czek],czek_y[czek],player.x,player.y,parent,1,1) and player.lina=2

{

czek+=1

pk=point_direction(czek_x[czek-1],czek_y[czek-1],player.x,player.y)

 

po=0

 

///while(!collision_line(czek_x[czek-1],czek_y[czek-1],czek_x[czek-1]+lengthdir_x(po,pk),czek_y[czek-1]+lengthdir_y(po,pk),parent,0,0))

//{

// po+=1

// }

//////////////////////////////////////////////////Wyszukiwanie binarne\\\\\\\\\\\\\\\\\\\\\\\\\

p=0

k=point_distance(czek_x[czek-1],czek_y[czek-1],player.x,player.y)

 

while(p!=k) //w pewnym momencie nasz przedział będzie tak krótki, że będzie zawierał jeden element (p==k). To będzie nasz wynik

{

po=floor((p+k)/2); //Strzelamy w połowę przedziału i zapisujemy do zmiennej q

if(collision_line(czek_x[czek-1],czek_y[czek-1],czek_x[czek-1]+lengthdir_x(po,pk),czek_y[czek-1]+lengthdir_y(po,pk),parent,0,0)) //jeśli q spełnia nasz warunek...

k=po; //ucinamy przedział o wszystkie liczby większe od q

else //w przeciwnym wypadku...

p=po+1; //ucinamy przedział o wszystkie liczby mniejsze i równe q (bo q też jest złe więc je też ucinamy, stąd q+1)

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

czek_x[czek]=czek_x[czek-1]+lengthdir_x(po-1,pk)

czek_y[czek]=czek_y[czek-1]+lengthdir_y(po-1,pk)

 

execute_string("sprite_linka"+string(czek)+"=surface_create(1000,5)")

}

 

m=0

ok=0

 

 

while (ok=0)

{ if czek>0

{

if !collision_line(czek_x[czek-1],czek_y[czek-1],player.x,player.y,parent,0,0)

{

 

czek_x[czek]=0

czek_y[czek]=0

 

execute_string("surface_free(sprite_linka"+string(czek)+")")

 

czek-=1

}

else

ok=1

}

else

ok=1

}

if !collision_line(x,y,player.x,player.y,parent,0,0)

{

n=1

repeat(czek)

{

czek_x[czek]=0

czek_y[czek]=0

 

execute_string("surface_free(sprite_linka"+string(n)+")")

 

czek-=1

n+=1

 

}

}

z=0

while (z+2<=czek)

{

if point_distance(czek_x[z],czek_y[z],czek_x[z+2],czek_y[z+2])<5

{

while(zz<czek-z)

{

czek_x[z+zz]=czek_x[z+zz+1]

czek_y[z+zz]=czek_y[z+zz+1]

zz+=1

}

 

execute_string("surface_free(sprite_linka"+string(czek)+")")

czek-=1

}

z+=1

}

 

E2:Trochę kodu zaczerpnięte z przykładów.