Érdekes programozási útmutató tervezőnek-Futtassa a képet (első rész): 16 lépés

2025 Szerző: John Day | [email protected]. Utoljára módosítva: 2025-01-23 14:48

Fuss! Fuss! Fuss!

A programozás nem olyan nehéz. A legfontosabb, hogy megtaláld a ritmusodat, és egyenként végezd el.

Mielőtt elolvassa ezt a fejezetet, remélem, már ismeri az alapvető függvényrajzolási módszert, különben szédül és összezavarja magát két nagy fejfunkció: a beállítás és a rajzolás.

Mivel mozgásos grafikákat szeretnénk készíteni, tudnunk kell, hogyan készül az animáció.

A fenti kép meglehetősen vonzónak tűnik, és vizuálisan feltárja az animáció megvalósítási elvét.

Az animáció varázslatos. Varázslatos a vizuális csalás. Azonban ebben az információ robbanásszerű, videó árvíz kor, már megszoktuk. Kevesen fognak meglepődni, hogy elképesztő dolog látni az animációt.

Ugyanez az elv alkalmazható a rajzos animációban a programmal. Meg kell fontolnunk, hogyan rajzoljunk különböző grafikákat minden keretbe, és a program automatikusan lapozni fog, miközben fejben kiegészítjük az elkészült animációt. A következő fejezetben az alapvető grafikai mozgás megvalósításáról fogunk beszélni. Ezt megelőzően ismernünk kell néhány alapvető tudást a változókról.

1. lépés: Változó

A változó az adatok tárolója. Egy programon belül többször is használható.

Például:

[cceN_cpp theme = "hajnal"] méret (500, 500); ellipszis (100, 250, 50, 50); ellipszis (200, 250, 50, 50); ellipszis (300, 250, 50, 50); ellipszis (400, 250, 50, 50);

[/cceN_cpp]

Ez a kódrész nem használt semmilyen változót. Négy kört rajzol a képernyőn. Megállapíthatjuk, hogy szélességük és magasságuk azonos. Most, hogy ez ugyanaz, az ismételt adatbevitel minimalizálása érdekében definiálhatunk egy jelet annak ábrázolására. Ez a jel változó.

Íme a kód a változó hozzáadása után:

[cceN_cpp theme = "hajnal"] méret (500, 500); int a = 50; ellipszis (100, 250, a, a); ellipszis (200, 250, a, a); ellipszis (300, 250, a, a); ellipszis (400, 250, a, a);

[/cceN_cpp]

Teljesen ugyanazt az eredményt kapjuk!

Mivel definiáltuk az a változót, kényelmesen megváltoztathatjuk a paramétereket. Ha az a = 50 értéket a = 100 -ra változtatjuk, akkor a körök szélessége és magassága egyenletesen 100 lesz. Tehát nem kell egyesével megváltoztatni a paramétereket. A változó valóban jó találmány.

2. lépés: A változó létrehozása

A változó használata előtt nyilatkozatot kell tennünk, és meg kell jelölnünk annak adattípusát.

int i;

i ＝ 50;

A kód első mondata kijelentést tett az i változóra. Az int szimbólum főleg a változó deklarálására szolgál. Deklaráláskor helyet foglal a számítógép memóriájában, amely egyenértékű egy "doboz" létrehozásához, amelyet kifejezetten egész adatok visszaállítására használnak. A második mondat azt jelenti, hogy az 50 -es feladatot az i változóval kell végrehajtani. E mondat végrehajtása után az adatok stabilan tárolódnak az i változóban. Vagy lustább lehet, ha a fenti két mondatot egyesíti és befejezi a feladatot, miközben nyilatkozik.

int i ＝ 50;

Viszonylag szabad nevezni egy változót. De néha oda kell figyelnünk valamire.

3. lépés: A változó elnevezési szabályozása

• Az ábécé és az aláhúzás kombinációjának kell lennie. Ez lehet szimbólum vagy szó.

• Kis-nagybetű érzékeny. A név és a név különböző változókat jelenthet.

• Próbálja meg a lehető legegyszerűbben elnevezni, hogy egy pillantásra megértse. A kezdő karakternek ábécének kell lennie, nem szám vagy speciális karakter helyett.

• Nincsenek kulcsszavak, mint az int, float

A következők néhány téves állítást tartalmaznak.

int $ a;

int 89b;

Íme a helyes állítások:

int r;

int szuper_24;

int openTheDoor;

4. lépés: Változótípus

Az egész számok deklarálását leszámítva a decimális adatokra (más néven lebegőpontos adatok) deklarálhatjuk a float kulcsszóval.

úszó b = 0,5

Szem előtt kell tartanunk, hogy milyen adattípust használtunk nyilatkozatunkhoz. Ha az int kulcsszót használtuk, akkor az utóbbi hozzárendelés nem írhat i ＝ 0,5 vagy valami hasonlót, vagy a program hibává válik. De ha ellentétesen írunk, akkor minden rendben. Például az i = 5 lebegés a helyes nyelvtan, de a program decimális számként ismeri fel.

Néhány változót a rendszer már definiált. Nem kell magunknak bejelentenünk őket. Csakúgy, mint a korábban említett "szélesség, magasság", ez automatikusan megszerzi a számítógép képernyőjének szélességét és magasságát. Olyan magas gyakoriságú használat, hogy a tervező közvetlenül definiálja, hogy alapértelmezett változó, hogy kényelmesebb legyen a használatunk.

5. lépés: Kezelő

A feldolgozást a következők végzik:

+ plusz

- mínusz

* szaporodni

feloszt

％ A maradék modulusa

A %kivételével ismernie kell ezeket az operátorokat. Elég furcsának tűnik, mert az eredménye maradék. 9%3 az 0. Míg a 9%5 a 4.

Az operátorok felhasználhatók a hozzárendelések és a változók között.

[cceN_cpp theme = "hajnal"] int a = 1; // egész változó deklarálása a, a hozzárendelés 1. int b = 2; // A b egész változó deklarálása, a hozzárendelés 2. int c; // C egész változó deklarálása. c = a + b; // Plusz két hozzárendelés, és annak eredményét hozzárendeljük c -hez. nyomtatás (c); // Kimeneti változó c.

[/cceN_cpp]

6. lépés: Műveleti eredmény:

A kimeneti eredmény nem az ablakban jelenik meg, hanem az alsó konzolban.

A negyedik sor írásmódja elég furcsán néz ki. De ez egy gyakori formátum, amelyet gyakran használnak a számítógép -hozzárendelés során. Az egyenlő szimbólum bal oldala a végső hozzárendelt változó, míg a jobb oldal a működési folyamat.

Az ötödik sor nyomtatási funkciója képes a konzolon lévő változók kinyomtatására, amelyet gyakran használnak az adatkimenet állapotának tesztelésére.

7. lépés: Működési szabályozás

A feldolgozás problémás pontja, hogy tisztáznunk kell a változó típusát. Különös figyelmet kell fordítanunk a lebegőpontos szám és az egész típusú típus folyamatára.

nyomtatás （6 /5）; // eredmény 1

Az egész számok közötti művelet új egész számot kap. 6 osztva 5 -tel 1,2. De a program kimeneti eredménye 1. Ez ellentétes a megérzésünkkel. A program nem kerekítéssel foglalkozik, hanem törli a tizedespont mögötti számot.

nyomtatás (6.0 / 5.0); // eredmény 1.2

A lebegőpontok közötti művelet új lebegőpontos számot eredményez. Ha a tényleges eredmény 1,2, a program kimeneti eredménye ugyanaz lesz.

nyomtatás (6 / 5.0); // eredmény 1.2

nyomtatás (6,0 / 5); // eredmény 1.2

Végül az egész és a lebegőpontos szám keveréke. A végeredmény 1,2 lesz.

• Valójában szem előtt kell tartania, hogy a szabályozás célja, hogy ne veszítse el az adatok pontosságát. Tehát ha egy elem lebegőpontos szám, akkor az eredmény lebegőpontos szám is lesz.

8. lépés: A funkció beállítása és a rajzolás funkció

Korábban beszélgettünk egy rakás földelő tudással. Most végre valami érdekeset játszunk. A funkció beállítása és a rajzolás egyenértékűek a feldolgozás fő funkcióival. Ez a két funkció nagyon különleges. Ellenőrizheti a program folyamatát. Egy viszonylag bonyolult program magában foglalja ezt a két funkciót, mivel ezek képezik a program alapkeretét. Formátum:

void setup () {

}

void draw () {

}

A különleges használat megkülönbözteti a meghívási formátumukat a többi funkciótól. Hozzá kell adnunk a "void" függvényt a függvény neve előtt, ami a "visszaadott érték" hiánya. A függvény neve mögött zárójeleket és zárójeleket kell hozzáadnunk.

[cceN_cpp theme = "hajnal"] void setup () {print (1); } void draw () {print (2); } [/cceN_cpp]

Nézzünk egy példát:

Amikor megnyomja a kezelőgombot, a konzol először "1" -et ad ki, majd folyamatosan "2" -et, amíg le nem nyomja a stop gombot vagy bezárja az ablakot.

A beállítási funkció zárójelben lévő kódja csak egyszer kerül végrehajtásra. Míg a függvény sorsoláson belüli kód folyamatosan forgalomban fut (alapértelmezett megvalósítás 60 -szor/másodperc).

Ennek a karakternek köszönhetően a beállításokat általában a környezet tulajdonságainak inicializálására használják, például a képernyő szélességét és magasságát, a háttérszínt és mindenféle változó hozzárendelését. Míg gyakran rajzolási funkciókat helyezünk a függvényrajzolásba annak érdekében, hogy folyamatosan változó grafikákat készítsünk.

9. lépés: Kör vízszintes mozgásban

A function draw segítségével elkezdhetjük animációink létrehozását. Az animációs effektus feldolgozási módszere meglehetősen „kínos”. Nincs létező parancs. Például jelöljön ki egy bizonyos alakzatot, amely görbe vonalú.

Ezeket a részleteket magunknak kell meghatároznunk. Meg kell mondania a programnak, hogy milyen grafikára van szükség minden egyes kerethez.

Írja be a következő kódot (most kezdjük el kézzel csinálni):

[cceN_cpp theme = "hajnal"] int x; int y; void setup () {méret (300, 300); x = 0; y = magasság/2; } void draw () {háttér (234, 113, 107); noStroke (); ellipszis (x, y, 50, 50); x = x+1; }

[/cceN_cpp]

Ez a kódrész mozgó kört jelenít meg. A korábbi deklarált x, y változót a koordináta pozíció tárolására használják. A hozzárendelések a funkcióbeállításokban futnak. A kulcskód a következő a függvény rajzolásán belül:

x = x + 1

Ne tekintse matematikai egyenletnek, különben nagyon furcsa lesz. Itt a "＝" a hozzárendelés szimbóluma. Ez azt jelenti, hogy a jobb számokat a bal változóba kell helyezni. Tegyük fel, hogy x 50, ha a kód futni kezd, a "＝" jobb oldala 50+1, azaz 51. A végeredmény az x változóhoz lesz rendelve. Tehát x értéke 51 lesz.

Kövesse a program eljárását, minden alkalommal, amikor a függvényhúzás egyszer működik, az x értéke 1 -re nő. Tehát minden alkalommal, amikor rajzolunk, a kör egy pixelirányt vízszintesen jobbra mozgat az előző kerethez képest. Ezért a grafika mozgássá válik.

• Annak érdekében, hogy a kód jobban olvasható legyen, a zárójeleken belüli kódsorok előtt egy bizonyos helyet kell kímélnünk. És a lehető legjobban össze kell hangolni. Nyomja meg a TAB billentyűt vagy több üres mezőt, ez visszahúzható.

• Az üres hely és a sortörés szimbóluma a programban nincs hatással a programra. Tehát nem baj, ha többet vagy kevesebbet írunk be.

Íme egy másik egyszerűbb kifejezésmód. Ahhoz, hogy a változó kör növekedése automatikusan 1 legyen, azt a következő formátumba kell írnunk.

kör ＝ kör ＋1

Elég kényelmetlen! Ha a változó neve hosszabb, akkor több szót kell beírnunk. Tehát lusta elődeink egy ilyen ötletet gondolnak ki.

kör ＋＋

Hát nem nagyon egyszerű? Ez azt jelenti, hogy automatikusan növeli az 1 -et. Ehhez hasonlóan létezik - -, ami automatikusan 1 csökkenést jelent.

De ha azt reméljük, hogy az automatikus növekedés mennyisége más, mint 2, akkor meg kell próbálnunk egy másik kifejezést.

kör += 2

Ez egyenlő azzal

kör = kör + 2

Hasonlóképpen létezik - ＝, /=, *=.

10. lépés: A mozgás iránya

A grafika melyik iránya mozog, attól függ, hogyan változtatja meg a koordinátáját. Ha y ＝ y ＋ 1 -re változik, a kör lefelé mozog. Ha mindx, mind y növeli az 1 -et, a kör lefelé mozdul el a jobb alsó sarokban. Ha azt írjuk, hogy mínusz szimbólum, akkor az ellenkező irányba mozog.

[cceN_cpp theme = "hajnal"] int x, y; // Több változót is deklarálhat egyszerre, vesszővel válassza el. void setup () {méret (300, 300); x = 0; y = 0; } void draw () {háttér (234, 113, 107); noStroke (); ellipszis (x, y, 50, 50); x ++; y ++; }

[/cceN_cpp]

Mozgássebesség

Emlékszel az alapértelmezett 60 képkocka / másodperc funkciósorozatra? Ennek az aránynak megfelelően a fenti kör másodpercenként 60 képpontot mozgat jobbra.

Ha meg akarjuk változtatni a grafikus mozgási sebességet, akkor két módszer létezik: az egyik az x érték növelése minden alkalommal, mióta megváltozik.

x ＝ x ＋ 10

10 -szer javította a sebességet az eredetihez képest!

A másik módszer a vászon frissítésének gyakoriságának megváltoztatása. filmkocka szám()

Ez a funkció megváltoztathatja a vászon sugárzási frekvenciáját. Ha írja a frameRate (10) értéket a funkcióbeállításba, akkor az eredeti 60 képkocka másodpercenként 10 képkocka / másodperc értékre változik. A sebesség hatszor lassul, mint korábban.

11. lépés: figyelmen kívül hagyott háttér

A korábbi példák mindegyike háttérképet ír a függvényrajzba. Gondolt már arra, hogy beírja a funkcióbeállításba? Lesz -e különbség? Most frissítsük a vízszintes mozgás példáját.

[cceN_cpp theme = "hajnal"] int x, y; void setup () {méret (300, 300); háttér (234, 113, 107); x = 0; y = magasság/2; } void draw () {noStroke (); ellipszis (x, y, 50, 50); x += 1; } [/cceN_cpp]

Mi történt? Talán nem tudja megfelelően megérteni a probléma előidézésének okát. Törölje a noStroke függvényt, adjon hozzá ismét vonást, és nézze meg a kör mozgási útvonalát.

Ó, ez azért van, mert a korábban létrehozott kör nem törlődött! Mivel a funkcióbeállítások csak egyszer működnek, ha fölé írunk hátteret, akkor csak egyszer tölti ki a hátteret, és ez utóbbinak már nincs hatása. A funkció háttere olyan, mint a festékvödör eszköz. Használat után lefedi a vászon összes tartalmát, ahelyett, hogy csak a háttérszínt állítaná be. A függvényrajzolás előtt írjuk le, hogy a korábbi keretet minden alkalommal lefedjük, amikor új mintát hozunk létre. Ezért a kör futhat a várt módon. Az egyes funkciók használatára való emlékezés kivételével gondolnunk kell a kód helyzetére. Sok idő, felfelé vagy lefelé egy sor a codea számára, és ha azt zárójelbe vagy abból ki kell írni, egészen más hatásokat hoz létre. A kód iránya kétdimenziós. Ha hiba jelenik meg, ebben a két dimenzióban kell kalibrálnunk.

• Ez az ismétlődő rajzolási módszer nagyon különleges hatást kelthet, ha megfelelően használják. Másolhatja az alábbi kódot, és megpróbálhatja.

[cceN_cpp theme = "dawn"] void setup () {méret (400, 400); } void draw () {ellipszis (szélesség/2-mouseX, height/2-mouseX, mouseY, mouseY); ellipszis (szélesség/2-mouseX, height/2+mouseX, mouseY, mouseY); ellipszis (szélesség/2+mouseX, height/2-mouseX, mouseY, mouseY); ellipszis (szélesség/2+egérX, magasság/2+egérX, egérY, egérY); } [/cceN_cpp]

Itt az mouseX és mouseY mágikus változót használtuk. Később részletesen beszélünk róla.

12. lépés: Rázó kör

Mi van, ha azt akarom, hogy a körmozgás iránya szabálytalan legyen? Az okos véletlenszerű funkcióval ezt a hatást is felismerheti. A véletlenszerű funkció gyakran használt. Véletlen függvény generálására használható. Olyan, mint a nyomtalan szellem. Ha már a változókhoz kapcsolódik, nem tudja elképzelni, mi lesz ezután.

Meghívási formátum:

véletlen (magas)

A magas a véletlenszerű felső határt jelöli, és az alapértelmezett alsó korlát 0. Például véletlen (10). Véletlenszerűen 0 és 10 közötti számot állít elő (0 szerepel, de 10 nincs benne).

véletlen (alacsony, magas)

Ha két paramétert állítunk be, akkor visszatér a köztük lévő véletlenszerű értékre. Például véletlen (5, 10). Véletlenszerűen 5 -től 10 -ig terjedő számot állít elő (5 szerepel, de 10 nincs benne).

Példa:

[cceN_cpp theme = "hajnal"] float x;

x = véletlenszerű (50, 100);

nyomtatás (x); [/cceN_cpp]

Minden alkalommal, amikor futtatjuk a programot, a konzol különböző értékeket ad ki.

• Megjegyzés: A random függvény által létrehozott értékek lebegőpontos típushoz (decimális szám típus) tartoznak. Ha értéket szeretnénk rendelni egy egész változóhoz, akkor azt az int () függvénnyel kell átalakítanunk. Az átalakítás nem kerek, hanem közvetlenül törli a tizedes részt. Így az int kimenetének (random (5)) csak 5 lehetősége van: 0, 1, 2, 3, 4.

Miután megismerkedtünk a véletlen függvény használatával, közvetlenül az alábbi esetbe kerülhetünk.

[cceN_cpp theme = "hajnal"] int x, y; void setup () {méret (300, 300); x = szélesség/2; y = magasság/2; } void draw () {háttér (234, 113, 107); noStroke (); x += int (véletlenszerű (-5, 5)); y += int (véletlenszerű (-5, 5)); ellipszis (x, y, 50, 50); }

[/cceN_cpp]

A korábbi hozzáadott koordináta -értékek rögzítettek. Csak ha egy véletlen értéket növelünk, a kör határozatlan irányba mozog. A nagyobb véletlenszerű tartománynál gyakrabban remeg. Mivel a keretek közötti értékváltozás visszapattan, a mozgás már nem lesz zökkenőmentes. Míg az előbbi képkocka (150, 150) állásban van, addig az utóbbi egy pillanat alatt a (170, 170) pozícióba kerül.

13. lépés: Költöző kör

Vándorló kör

Sima mozgást fog létrehozni? A funkciózaj segíthet nekünk. Jobb a ritmusa, mint a standard random. És a véletlenszerűen generált véletlen számok folyamatosan.

Meghívási formátum:

zaj （t）

A funkciózaj nem tudja meghatározni a kimeneti tartományát. A program definiálja, hogy csak 0 és 1 közötti lebegőpontos számokat tud generálni, és a fix bemenetnek csak fix kimenete lehet.

[cceN_cpp theme = "hajnal"] float x = zaj (5); úszó y = zaj (5); nyomtatás (x, y); [/cceN_cpp]

Mivel a fenti bemeneti paraméterek 5, így a kimeneti eredmények ugyanazok. Akkor hogyan lehet megváltoztatni az eredményt? A válasz az, hogy a bemeneti paramétereket dinamikusan kell megváltoztatni. Valójában a zajt korlátlan hanganyagnak tekinthetjük, a bemeneti paraméterek olyanok, mint a "jelen idő". Ha a paraméterbevitel folyamatos, akkor a kimenet is folyamatos lesz.

[cceN_cpp theme = "hajnal"] float x, y; void setup () {méret (700, 100); x = 0; háttér (0); } void draw () {x += 1; y = zaj (frameCount/100.0)*100; noStroke (); ellipszis (x, y, 2, 2); }

[/cceN_cpp]

Ebben az esetben megrajzoljuk Y változási útvonalát, hogy jobban megértsük a függvényzajt.

• A változó frameCount megkapja a jelenlegi keretet. Az előző szélességétől és magasságától eltérően minden változtatás nélkül stabil. Ezenkívül 0 -ról kezd növekedni. Ha a kezdeti kijelzőn megjelenő animált grafikánkat megértjük, az azt az oldalt mutatja, amelyhez fordultunk (inkább a programban szereplő időkoncepcióhoz).

• A frameCount egész változó. Egy másik egész változóval osztva a program alapértelmezés szerint az eredményt egész számként dolgozza fel. Az eredmény pontosságának javítása érdekében 100 -ról 100,0 -ra kell változtatnunk. Ha lebegőpontos számmal osztjuk, akkor lebegőpontos számot is kapunk.

• Ahhoz, hogy az Y tengelyt 0 -ról 100 -ra változtassuk, meg kell szorozni a zaj eredményét 100 -zal. Így szabályozhatjuk a véletlenszerű értéktartományt.

Néhányan, akik jól gondolkodnak, megkérdezhetik: "Miért kell felosztanunk a frameCountby 100 -at? Nem helyes a frameCount közvetlen írása?" Persze lehet! De itt a funkciózaj jellemzőinek jobb megjelenítése érdekében lassítjuk a "sugárzási sebességet". Az alábbi példa a kimeneti érték változását mutatja különböző változási sebesség mellett.

[cceN_cpp theme = "hajnal"] float x, y1, y2, y3, y4, y5; void setup () {méret (700, 500); x = 0; háttér (0); } void draw () {x += 1; y1 = zaj (frameCount)*100; y2 = zaj (frameCount/10.0)*100; y3 = zaj (frameCount/100.0)*100; y4 = zaj (frameCount/1000.0)*100; y5 = zaj (frameCount/10000.0)*100; noStroke (); ellipszis (x, y1, 2, 2); ellipszis (x, y2+100, 2, 2); ellipszis (x, y3+200, 2, 2); ellipszis (x, y4+300, 2, 2); ellipszis (x, y5+400, 2, 2); stroke (80); vonal (0, 100, szélesség, 100); vonal (0, 200, szélesség, 200); vonal (0, 300, szélesség, 300); vonal (0, 400, szélesség, 400); }

[/cceN_cpp]

A funkciózajon belüli változó paramétereket haladási sávnak tekintheti. A paraméter módosítása olyan, mintha a folyamatjelzőt mozgatnánk. Tehát ha ennek a "hangnyomnak" a változó hatóköre nagyobb, a kimeneti érték elülső és hátsó folyamatos jellemzői gyengébbek lesznek. (El tudjuk képzelni, mi fog történni, ha egy zenét vagy videót kétszeres sebességgel sugározunk, 5 sebesség, 20 -szoros sebesség). Ha a hatókör nagyobb, mint egy bizonyos érték, akkor nincs nagy különbség, ha véletlenszerűen működik az értékgenerálás során.

Ha meg tudja érteni a fenti példákat, akkor úgy fogja érezni, hogy semmi sem lehet könnyebb egy vándorló kör rajzolása. Megértheti a belső elveket is.

[cceN_cpp theme = "hajnal"] float x, y; void setup () {méret (300, 300); x = 0; } void draw () {háttér (234, 113, 107); x = zaj (frameCount/100.0 + 100)*300; y = zaj (frameCount/100.0)*300; noStroke (); ellipszis (x, y, 50, 50); }

[/cceN_cpp]

Most a mozgás érdekesebb, mint egy forgó giroszkóp.

• Azért, hogy miért kell a függvényzajban az x változónak plusz 100 -at adni, az az oka, hogy egy távolságra el kell különíteni őket. Ha a függvényzajon belül az xy paraméterei azonosak vagy egészen közel vannak, az x, y koordináta változása közel azonos lesz. Ennek célja, hogy a mozgás sokkal véletlenszerűbbé váljon.

14. lépés: Egér által mozgatott kör

Ezután végre két változóhoz jutunk, amelyek a legjobban tetszenek: mouseX és mouseY. A két felfogás első látására a szemem fényben csillog. Mert ez a legközvetlenebb módja a grafikával való interakciónak. Sok érdekes programot készíthetünk vele.

Az eset meglehetősen egyszerű:

[cceN_cpp theme = "hajnal"] int x, y; void setup () {méret (300, 300); x = 0; y = 0; } void draw () {háttér (234, 113, 107); noStroke (); x = egérX; y = egérY; ellipszis (x, y, 50, 50); }

[/cceN_cpp]

Az mouseX megszerezheti az egér x koordinátáját, míg az mouseY az y koordinátát.

• Próbáljuk meg megváltoztatni a pozitív és a negatív szimbólumot, vagy cseréljük ki az mouseX -t és az mouseY -t.

15. lépés: Vége

Ezekből az ismerős parancsokból képes lehet a grafika mozgására. Az utolsó fejezet tartalmával megfelelően használja a fantáziáját, sok érdekes animált effektust hozhat létre.

Következő fejezetünkben bővebb példákat láthatunk. Ugyanakkor matematikai függvényeket fogunk használni, és grafikus mozgással kombinálni.

Ez a cikk Wenzy tervezőtől származik.

16. lépés: Relatív értékek:

Érdekes programozási útmutató tervezőnek-Az első érintés feldolgozása

Érdekes programozási útmutató tervezőnek-Készítse el első feldolgozó programját

Ez a cikk innen származik:

Ha segítségre van szüksége, akkor vegye fel a kapcsolatot: [email protected].