Eigentliche sprite Größe

Lunatic447 · 22. Februar 2013, 17:10

Hey GM's,

um es kurz zu fassen, mein jetziges Projekt ist eine Art Spore Klon, dass sich auf das Anfangsstadium des Mikrokosmos bezieht.

Daher ist die Spielfigur ein "Etwas", welches andere "Dinge" aufisst. Nach dem Motto, je größer desto gefräßiger.
Bzw. Fressen oder gefressen werden.

Doch nun zum eigentlichen Problem:
Die Spielfigur (Kreis) hat eine eigentliche Größe von 64x64px. InGame lasse ich sie via image_x+yScale auf 0.2 schrumpfen.
Doch wie ermittle ich jetzt die aktuelle Größe des sprites inGame?

DragonGamer · 22. Februar 2013, 17:12

image_xscale * 64 ...

Lunatic447 · 22. Februar 2013, 17:19

Und wie sieht das aus wenn sich das Sprite ändert? z.B. statt 64x64 dann 768x768.
EDIT: Ingame natürlich^^

Lunatic447 · 22. Februar 2013, 17:35

Um es mal Bildlich darzustellen(Im Anhang)

Man kann sehen, dass die angegebenen Werte in Betracht der eigentlichen Bildgröße korrekt sind.

Jedoch möchte ich, dass der GM beide Objekte so behandelt, als hätten sie die gleiche Ausgangsgröße (px).

Wie setze ich das um?

DragonGamer · 22. Februar 2013, 17:47

Heh?
Sorry, das verstehe ich jetzt nicht mehr..

Beschreib doch bitte mal was du mit "gleich behadeln" meinst.

TrunX · 22. Februar 2013, 17:52

Spritebreite*image_xscale = Gezeichnete Spritebreite
Das selbe gilt für die Höhe mit image_yscale.

Lunatic447 · 22. Februar 2013, 18:08

Ja sorry, war nicht so gut formuliert.

Das Größere Objekt soll das kleinere "fressen". Aber da ich mit

GML-Quellcode

image_yscale=0.2;
image_xscale=image_yscale;

das Objekt skaliert habe, ist der Wert, welcher abgefragt wird um festzulegen welches Objekt größer ist, immer kleiner.

Beispiel: Ein Bild mit der Ausgangsgröße von 768x768 pixeln wird im GM auf 0.2 skaliert.

Ein zweites Objekt mit der Ausgangsgröße von 64x64 bleibt bei seiner eigentlichen Größe.

Nun kollidieren diese beiden Objekte. Jetzt soll abgefragt werden, welches Objekt größer ist und somit der Gewinner.
Logischerweise ist das erste Objekt trotz einer Skalierung von 0.2 das größere.
Jedoch sagt der GM das Gegenteil da der Wert von image_xscale bzw. yscale gleich 0.2 beträgt und somit geringer ist.

Hoffe es ist verständlich so.

TrunX · 22. Februar 2013, 18:15

Deswegen sollst du den scale-Wert mit der eigentlichen Breite multiplizieren

GML-Quellcode

breite=image_xscale*sprite_get_width(sprite_index)

Lunatic447 · 22. Februar 2013, 18:40

Dann hat mein Objekt aber bei einer Skalierung von 0.02 einen Wert von 15.36. So kann das ja dann auch nicht stimmen.

TrunX · 22. Februar 2013, 18:51

Wieso? Der Sprite ist durch die Skalierung ~15 Pixel breit.

Lunatic447 · 22. Februar 2013, 19:38

Ok, stimmt jetzt sry.

Sobald ich aber den Wert der Variable

GML-Quellcode

global.sizeval=image_xscale*sprite_get_width(sprite_index)

erhöhe,
wird mein Objekt bzw. das sprite nicht größer.

TrunX · 22. Februar 2013, 19:40

Dafür musst du natürlich wieder image_xscale und image_yscale erhöhen.

Lunatic447 · 22. Februar 2013, 20:08

Ok, jetzt funktioniert es. Danke dir!

Ich saß heute wohl zu lange vor den Zahlen..

Lunatic447 · 22. Februar 2013, 20:24

Eines wäre da aber noch. Wie addiere ich die Größe von Objekt 1 zu Objekt 2?

TrunX · 22. Februar 2013, 20:33

objekt2size+=objekt1size;

Jetzt hast du erstmal nur den Wert.
Um den image_x(y)scale-wert zu berechnen teilst du die gewünschte breite durch die spritebreite.

Lunatic447 · 22. Februar 2013, 20:48

Für den Überblick die benutzten Variablen.

GML-Quellcode

//Objekt 1 (Player)
//Create Event
global.playersize=image_yscale;
global.sizeval=0;
//Step Event
global.sizeval=image_xscale*sprite_get_width(sprite_index)
image_yscale=global.playersize;
image_xscale=image_yscale;

GML-Quellcode

//Objekt 2 (victim)
//Create Event
image_yscale=random_range(0.1,1);
image_xscale=image_yscale;
mysize=image_xscale*sprite_get_width(sprite_index);
//Bei Kollision mit Objekt 1
if (global.playersize<1.0) {global.playersize+=image_xscale/sprite_get_width(sprite_index);}

Irgendwas stimmt da noch nicht...
(siehe Anhang)

TrunX · 22. Februar 2013, 21:11

Darf ich dein System auf den Kopf schmeißen?
Ohne globale Variablen und Rechnungen, die jeden Step erfolgen.
Und das Kollisionsevent würd ich auch auf das Spielerobjekt verlagern.

Player-Create

GML-Quellcode

size=16;
image_xscale=size/sprite_get_width(sprite_index);
image_yscale=image_xscale;

Gegner-Create

GML-Quellcode

size=random_range(8,32);
image_xscale=size/sprite_get_width(sprite_index);
image_yscale=image_xscale;

Player-Kollisionsevent mit Gegner:

GML-Quellcode

if size > other.size
{
size+=other.size;
image_xscale=size/sprite_get_width(sprite_index);
image_yscale=image_xscale;
with other
instance_destroy(); //Nehm ich mal an
}

Mehr brauchst du glaub ich nicht.

EDIT: Player-Create angepasst, dass du so wie beim Gegner die Pixelgröße angibst, statt image_xscale.

Lunatic447 · 22. Februar 2013, 22:47

Super!
Das funktioniert um einiges besser. Jetzt müsste es nur noch etwas realistischer werden. Sodass Objekt 1 nur so viel des anderern absorbiert, wie er mit dem Objekt in Berührung kommt. Wie in "Osmos".

DragonGamer · 22. Februar 2013, 23:32

Lunatic447 schrieb:

Wie in "Osmos".

Wusst ichs doch dass du an Osmos denkst...
Eins der stimmungsvollsten Spiele für Android wenn du mich fragst

..wünschte es hätte mehr Level...

Du könntest mal das Kolisionsevent so ändern:

GML-Quellcode

if size > other.size
{
var dis, rad;
dis = point_distance(x,y,other.x,other.y); // Distanz zwischen den Mittelpunkten der Kugeln
rad = sprite_width/2+other.sprite_width/2; // Summe der Radien der beiden Kugeln
if rad-dis < 0
{
size+= other.size;
other.size = 0;
with(other.id) instance_destroy(); // andere Kugel wurde vollständig geschluckt
}
else
{
size+= (rad-dis)/2; // eigene Kugel wächst um die Hälfte der Diferenz
other.size -= (rad-dis)/2; // andere Kugel schrumpft um die Hälfte der Diferenz
}
image_xscale=size/sprite_get_width(sprite_index);
image_yscale=image_xscale;
other.image_xscale=other.size/sprite_get_width(other.sprite_index);
other.image_yscale=other.image_xscale;
}

Alles anzeigen

Dieser code müsste... bzw. sollte dafür sorgen dass genau wie bei Osmos bei kolision so lange Materie geschluckt wird dass die Kolision wieder aufgehoben wird. D.h. es wird nicht sofort vollständig geschluckt sondern praktisch nur wenn dauerhaft koliddiert wird, d.h. wenn sich die Kugeln tatsächlich aufeinander zubewegen.
Genau dieses Element fand ich auch so interesant an Osmos, im Gegensatz zu den 1001 anderen "größer frisst den kleineren* Spielen...

Hoffe da ist jetzt kein Müdigkeitsfehler drin... und dass dieser Code auch im Studio Sinn macht... :whistling:

Lunatic447 · 23. Februar 2013, 00:10

Ja, Osmos war absolut genial. Daher orientiere ich mich auch überwiegend an diesem Spiel.

Danke für den Code. Bin jetzt auch viel zu müde, werde mir das morgen mal ansehen.