Megkérdezem itt is, hátha tud valaki segíteni: Egy másik (nem saját fejlesztésű) alkalmazás egyik textboxának szövegére lenne szükségem. Spy++-el megnéztem az azonosítóját (handle). Azt direktben beírva nem ad vissza a WM_GETTEXT semmilyen szöveget. Kipróbáltam ugyanezt más programokon is és ott minden ok, vagyis hozza a szöveget. Spy++-ban nézve más programok textboxának szövege megjelenik a General -> Window Caption mezőben. Ennél a programnál ez viszont üres. (A komponenseknél Class Name-ként Edit-et hoz. A programot nem .NET-ben írták.) Hogyan olvashatnám ki mégis a textbox szövegét? Előre is köszönöm a segítséget! AE
Remoting helyett használj inkább WCF-et, az elrejti előled a kommunikációs protokollt, működik SOAP és remoting kapcsolaton is, tehát ha később valamit módosítani kell akkor konfig módosítással megoldható.
Rengeteg példát találsz rá, Visual Studioban van WCF projekt sablon akár abból is kiindulhatsz. Kliensoldalon pedig add service reference és a VS megcsinálja neked ami szükséges.
Újabb problémával fordulok hozzátok. Elkezdtem foglalkozni a Remoting-al. A lényeg az lenne, hogy a kliensprogram elküldene két stringet a szervernek, ami ezeket feldolgozva visszadob a kliensnek egy boolean értéket.(Egy sima bejelentkezési progi). Sajnos nekem ez nem jött össze. Körülnéztem és valahogy a System.Net.Socket-el kéne megoldanom, de gőzöm sincs hogy hogyan.
Wow! nagyon szépen köszönöm mindkettőtöknek! Igazából most kezdtem a Form-ban programozni, eddig Console-ban csináltam, ott meg elég volt az az egy Program.cs
Igen, eredetileg én is így próbálkoztam de nem jött be. Íme a program.cs:
namespace WindowsFormsApplication1 { static class Program { public static string vm = "2"; /// <summary> /// The main entry point for the application. /// </summary> [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1());
} } }
Én a vm stringet szeretném elérni a Form1.cs-ben A jelenlegi állásban nem lehet
Köszi a segítséget. Így már eltudok indulni a gugli :) barátom segítségével. De azért még befogok támadni a kérdéseimmel, mert biztos elakadok valahol :P
Egy windowsos form alkalmazást írok. Van egy olyan problémám hogy egy string változót több Form-ból szeretnék elérni. Hogyan csináljam? Ha a program.cs-ben dekrarálom, akkor sem érem el.
1) A memóriahasználat a futtatókörnyezettől függ, teljesen más C++-ban mint Delphiben és C#-ban. Ebből adódóan az optimalizálás is ettől függ.
A .Net memóriahasználata teljesen más elvek alapján működik mint a hagyományos programoknál, ezért optimalizálni is teljesen másképpen kell, ill. csak nagyon ritkán kell foglalkozni ezzel.
A háttérképállító programodnál biztosan nem kell, amit a Task Manager mutat azzal amúgy sem nagyon érdemes foglalkozni.
Ha mégis kellene akkor rengeteg cikket találsz a témában (search://.net memory management, search://.net memory management best practices), vagy kereshetsz célzottan pl. working set-re is.
2) Úgy kell megírni mint minden más alkalmazást: feleljen meg a felhasználó igényeinek.
Ha lassú mert sok elem van egy ablakon akkor oszd fel kisebb ablakokra, dialogokra, úgysem fognak egyszerre dolgozni mindennel, a főablakod pedig inkább csak egy gyűjtő legyen, rajta kevés, max. 2-3 leggyakrabban használt művelet.
Lehet betölteni háttérben (másik thread, async hívás).
Lehet betölteni csak akkor ha szükséges is valami, tehát nem töltesz be mindent induláskor csak mikor valóban használni is akarják (lazy initialization).
Ha úgy szeretnéd "mint ahogy a nagyobb programoknál van", akkor nézd meg hogy a "nagyobb programok" hogyan csinálják és csináld te is úgy ;-)
Hali Egy kis segítséget szeretnék kérni, ami inkább általános programozáshoz tartozhat, de azért mégis jobbnak láttam ide írni Momentán két kérdésem lenne:
Hogy tudom a program fogyasztását kontrollálni, vagy a programhoz tartozó memóriaszakaszt időnként törölni? Ez azért lenne fontos, mert van néhány programom, ami nagyon lehasználja a Ramokat, pedig nincs bennük semmi. Mint például a legutóbbi programom, amellyel az asztal háttérképét tudom állítani kb. 80MB használ. De volt amikor ez felment 500MB-ra is. Ez kicsit hihetetlen és bosszantó. Van benne 4 pictureBox, 2 button, kb. 6 string és már ennyit kajál :@. Más ennél nagyobb programok meg szinte alig használnak valamit...
A másik kérdésem meg egy kicsit fúra és szokatlan lehet, de nekem nagyon fontos. Belevágtam egy nagyobb programba, mivel már mondhatni elég jól megy a programozás. A gond csak az, hogy leragadtam egy nagy problémánál. A program kinézete és kiterjedése nagyjából akkor mint a visual studiónak. Szóval, Rengeteg control van és bő fejléc.... Mármint sok elem van a menüben... Na mind1. A lényeg az, hogy a program ill. ezen form betöltése nagyon hosszadalmas. A kérdés az lenne, hogy hogy tudnám ezt a folyamatot felgyorsítani, úgy mint ahogy a nagyobb programoknál van? Szóval hogy kell egy nagy programot megírni? :) Mert egyenlőre még semmit nem csinál a program, csak úgy van. És már így is nagyon lomha. Mi lesz, ha már teleírtam a Load_eseményt?! :@
Nekem a problémám az, hogy egy consolos programmal nincs bajom. Sokat programoztam c++-ban és c#-ban is. Nem votl gondom egy kicsivel komolyabb programokkal sem. De összekötni nehéz nekem a grafikus dolgokkal. Úgyhogy gdi lörnin!!!!
Programozási feladatok szempontjából csak kevés esetben számít hogy konzol alkalmazás, WinForms vagy éppen webservice. Teljesen mindegy hogyan jelenik meg az alkalmazásod vagy hogy egyáltalán megjelenik-e, a ciklust ugyanúgy írod, az osztályokat is, eseményekre is ugyanúgy iratkozol fel.
De ha ez zavar akkor keress egy másik könyvet amelyikben WinForms példák vannak.
Sok feladatot oldottam meg könyvből. De az a baj, hogy javarésze consolos volt. Még mai napig is előveszem ezeket és próbálom összerakni. Nagyon szépen köszönöm a segítséget és a türelmet, ez a válsz sokat segített. Értem, hogy hol a probléma, mármint sokkal közelebb kerültem hozzá, hogy rájöjjek hol rontottam el. A végén a tervezés folyamatának leírása lényegében az amit amire talán igazán szükségem volt, még akkor is ha nem közvetlenül erre irányult a kérdésem. Rájöttem, hogy valóban a gombhoz keresek kabátot... azaz tetőt építek, úgy hogy még alapom sincs... ebből nehezen lesz ház! De ettől most számomra ez még izgalmasabb lett. Újraértékeltem magamban a vázlataimat, a feljegyzéseimet /*nagyjából 1 teljes spirál füzet*/, és elkezdtem újra felépíteni és sorrendbe állítani az elvégzendő feladatokat. Most egy pár napig nem fogok annyira odafigyelni rá, mert Analízis II vizsgám lesz és muszáj, hogy sikerüljön, de a vizsgaidőszak után, mindenképpen újra nekiállok. Felhasználok minden eddigi kódot és magamba szívom a tudást a könyvekből! :)
Köszönöm a türelmet és ha lesz még kérdésem, akkor mindenképpen felteszem majd!
Most már egyre jobban érdekel! Meg fogom csinálni... köszönöm a választ. Értem mire gondolsz és már átgondoltam a dolgot. Mivel pontosan tudom mit szeretnék megvalósítani és hogyan ezért sikerült felmérem nagyjából, mekkora munka és mennyi energia lesz mögötte. Nem játékhoz akarom írni a fizikát és javarészt csak a gyakorlás miatt csinálom és mert foglalkoztam fizikával és szeretném megcsinálni, szemléltetni akarok bizonyos dolgokat, bizonyos dinamikai eseteket. Sokat segítene nekem a munkámban.
"az első problémám az, hogy ha létrehozok egy osztályt, akkor arra nem tudom, hogyan hivatkozhatnék."
Erre csak egy megoldás van: veszel néhány könyvet és elolvasod őket vagy beiratkozol egy tanfolyamra (ez a második egy megoldás :-D).
Legalább ezekre a könyvekre lenne szükséged:
-programozás alapjai (ideértve OOP)
-.Net/C# alapjai
-GDI+ (enélkül nem fogod érteni a grafikai részt)
Konkrét válasz: deklarálsz egy osztályváltozót.
Pl.
private Osztály osztály;
Példányosítás pl. konstruktorban:
osztály = new Osztály();
Mivel neked több labdád van ezért listában kell tárold őket, pl. Ball[] vagy List<Ball>. Hogy ezek mik és mikor melyiket jó használni arra az első két könyvben találod a választ.
GetX, GetY helyett public int X { get; private set; }. Property a neve.
"Aztán a timer1_Tick-ben pedig berakom, hogy"
Ha itt hozod létre a példányt akkor minden mozgáskor új példány jön létre tehát elvesznek az értékek. Korábban kell létrehozni (pl. gombnyomásra) és a timerben csak használod: balls[i].Move(playground).
Azért balls[i] ciklusban mert az összes labdát kell mozgatni, és azért kell a playgroung paraméter mert a labdák kell figyeljék a pálya szélét is (vagy pattannak vagy "leesnek" a pályáról).
"Az golyó osztályt úgy akarom megalkotni, hogy az osztály rajzolja ki és mozgassa az aktuális golyót."
Túlbonyolítod. Ha majd lesz egy osztályod ami tud mozogni akkor csinálhatsz egy másikat ami formákat tud rajzolni egy felületre.
"Pl. mit adjak át, az osztálynak, hogy a Graphics jó legyen"
A kérdéseid alapján úgy látom még mindig nem tudod hogyan szeretnéd megoldani a feladatot programozási nyelvtől függetlenül. Amíg ezt nem fogalmazod meg (pl. lerajzolod folyamatábrákkal, osztálydiagrammokkal, stb) addig hiába próbálod használni a Graphics osztályt. Ne a gombhoz varrjál kabátot, hanem a kabáthoz keress megfelelő gombokat.
"Saját magamtól szeretném összehozni, mindegy, hogy mennyi idő alatt, csak legyen meg."
Kompromisszumokat kell kötni. A világ már túl bonyolult ahhoz hogy mindent egy ember csináljon meg, 2 ezer évvel ezelőtt ez még működött valamennyire de ma már nem. Nem az a jó építész aki a téglát is maga csinálja, hanem az aki ügyesen fel tudja használni a rendelkezésre álló kész elemeket, te esetedben pl. ha már van 2D/3D modellezés akkor talán fel kellene használd azokat és mikor már behunyt szemmel is fel tudsz iratkozni egy objektum valamelyik eseményére akkor írsz egy saját 2D szimulációt.
"Pl.: nemrég jöttem rá, hogy ha beírok egy más által írt kódot egy új dokumentumba, akkor ha lérehozom a formon azokat a dolokat amik működtek, még nem megyek vele semmire, mert az eventhandlerbe be kell illesztenem a Form1_Load eseményt stb."
Ha a programozás és az adott nyelv alapjait nem ismered akkor nem is lesz jobb. A programozás nem olyan mint a vályogvetés hogy megnézed hogyan tapicskolnak a sárban és 5 perc után neked is megy. Rengeteg alapismeretre van szükséged, és ezeket kódírással és kódmásolással nem lehet megszerezni, csak rengeteg olvasással.
Bármilyen szakmában alapfeltétel hogy ismerd az eszközöker és azok használati módját. Nem lehetsz jó autószerelő ha csak a csavarhúzót ismered.
Vagy a könyv nem volt megfelelő, vagy rosszul olvastál, vagy kihagytad a példákat, mert már egy alapfokú könyv után kellene tudd mik az osztályok, változók, metódusok és propertyk, hogyan kell példányosítani, metódust hívni, feliratkozni egy eseményre (event), listákat kezelni.
Ugyanez igaz a GDI-re is, ez egy nagyon egyszerű modell alig néhány fogalommal, egy 2D/3D rendszer ennél sokkal bonyolultabb és ha a GDI megértése gondot okoz akkor még biztosan várni kell a bonyolultabb grafikai feladatokkal.
Célszerű kisebb feladatokkal kezdeni a tanulást, nem egy ilyen összetettel. Vannak tutorialok azokkal kellene kezdeni, célzottan azokban a témákban melyek érdekelnek (természetesen csak azután ha túl vagy az első két könyv elolvasásán és érted a bennük levő példaprogramokat).
Ha a könyvek példái és a tutorialok már megvoltak akkor első feladat lehetne az hogy csinálsz egy labda listát, egyik gombbal hozzáadsz egy labdát, egy másikkal pedig kiveszel belőle, egy harmadik gombbal pedig listázod a labdákat pl. egy ListView-ban.
A labda osztály egyelőre nem fog tudni semmit, csak lesz egy egyedi azonosítója (Id, Név, vagy valami más).
Ha ezt megcsináltad akkor bővítheted a feladatot, pl. adhatsz koordinátákat a labdáknak és kirajzolod őket egy panelre.
Ha ez is megvan akkor csinálhatsz valami alap mozgást, pl. gombnyomásra a labdák véletlenszerű irányba mozdulnak egy egységet.
Ha ez is kész akkor kezdheted figyelni a pálya szélét, majd automatizálod a mozgatást (Timer), aztán valamikor a többi labdát is kezdheted figyelni, és mire észrevennéd kész is a programod.
Az a baj hogy túl sokat kérdezel egyszerre és összetettet. Haladj lépésenként. Szóval pl. azt hogy gombnyomásra keletkezzek a labdák hagyd későbbre.
Amúgy amit te akarsz az egy 2D-s mini dinamikai rendszer. Ezek kb. (gondolom) úgy szoktak festeni hogy vannak objektumok (nálad 2D-sek). Ezek vagy 'aktívak', vagy 'passzívak'. A passzívak (nálad a keret négy éle) nem mozognak, csak ütközhet vele a többi. Az aktívak(labdák) mozognak és ütközhet is a többi tárggyal. Ezek a tárgyak hozzáadhatóak a rendszeredhez, aztán van egy loop ami addig fut míg le nem állítod. Ez ciklikusan kiszámolja a mozgó tárgyak aktuális pozícióját az eltelt idő függvényében, realtime (aktuális idő mínusz előző ciklus ideje) és közben ütközésvizsgálatot végez a többi tárggyal, végezetül kirajzolja az egészet, aztán kezdi újra.
Az ütközésvizsgálat elvileg lehet 'diszkrét' vagy 'folytonos'. Az előbbi az egyszerűbb de gyors mozgásoknál áthaladhatnak egymáson a tárgyak ha pont azt pillanatot nem csípi el a program amikor egymásba lógnak a tárgyak. Előfordulhatnak egy cikluson belül többszörös ütközesek ezek sorban összegződnek (vektorokhoz hasonlóan) és persze a mozgás egyenletek ezt figyelembe veszik.
Ha sikerül egy ilyen alapsémát jól (struktúráltan, értelmesen) megvalósítani, akkor utána viszonylag könnyen lehet bővíteni komolyabb fizikával (tömegek, gravitáció, pattanási együtthatók, stb.) Engem is érdekelne az ilyesmi csak nincs most időm erre sajnos. A másik hogy hülye vagyok a C#-hoz és a .NET-hez. :( A harmadik hogy ez csak gyakorlásnak jó, mert ha valami komolyabbat akarsz akkor úgy is valami kész game engine-t fogsz használni.
Ezek után is érdekel a dolog és meg akarod csinálni?
Ha rápakolsz egy Formra néhány kontrolt akkor láthatod hogy azok pl. a Form1 osztály adattagjaiként vannak példányosítva és eléri őket. Úgy pl. nem jó?
az első problémám az, hogy ha létrehozok egy osztályt, akkor arra nem tudom, hogyan hivatkozhatnék. A problémám a követező. Fuhh, remélem érthetően fogom megfogalmazni...
Tehát létrehozok egy osztályt, pl.:
class BallMove { private int x, y, widthForm, heightForm, speed_X, speed_Y;
public BallMove() { }
public BallMove(int X, int Y, int WidthForm, int HeightForm, int Speed_X, int Speed_Y) { x = X; y = Y; widthForm = WidthForm; heightForm = HeightForm; Speed_X = speed_X; Speed_Y = speed_Y; }
Ezután a formon belül hol hívjam meg /*az osztályba beírtam a using System.Windows.Forms; -t*/? a timer1_Tick-ben? mert példányosítom, hogy pl:
BallMove ballmove;
Aztán a timer1_Tick-ben pedig berakom, hogy
ballmove = new BallMove(x, y, Width, Height, speed_x, speed_y);
ballmove.Move();
majd a getx és gety segítségével átadom az értéket az x és y koordinátának:
x = ballmove.GetX();
y = ballmove.GetY();
Így számomra logikus lenne, hogy átadja a paramétereket az osztálynak az végrehajtja a kívánt műveletet, majd visszadja az értékeket, az új értéket átadja az x és y koordinátáknak és kezdi előről. De még ha nekem logikusnak is tűnik a programnak nem. Tehát valamit nem értek, vagy valamit nagyon elbambulok. Hogyan tudok hivatkozni, hogy példányosítsam.
Hozzá tartozik még az is, hogy amit szeretnék csinálni, az egy panel. A panelen gombnyomásra megjelenik egy golyó. A golyó mozog, majd újabb kattintásra bejön még egy golyó. Ütközik a falon, egymáson. Ezt szeretném megcsinálni. Most annak is örülnék, ha egyáltalán rendesen pattanna a golyó. Az golyó osztályt úgy akarom megalkotni, hogy az osztály rajzolja ki és mozgassa az aktuális golyót. Még csak elképzelésem sincs hogyan tudnám ezt megalkotni, de dolgozom az ügyön. Pl. mit adjak át, az osztálynak, hogy a Graphics jó legyen, hogyan példányosítsam, bár ezt még nagyonából értem... hiszen egy btn_OnClick eseménybe berakom a példányosítást és a golyó mozgását berakom a timer1_Tick-be de attól tartok, hogy így a mozgás ugyanazokat a koordinátákat fogja felvenni, szóval valóban sok a kérdésem. Sokat olvastam utána különböző fórumokon a megoldásnak és semmit nem találtam sehol. A feladatom amit kitűztem magam elé annyi, hogy teljesen saját magamtól intézzem el a fizikát. Nem akarok már megírtat használni. Saját magamtól szeretném összehozni, mindegy, hogy mennyi idő alatt, csak legyen meg. Viszont ilyen alap dolgokra nem jöttem rá még. Az, hogy a kódom átláthatatlan... hát igen, sokszor szembesülök vele és próbálom átláthatóvá tenni, de már ez is sokkal inkább értelmezhető, ahhoz képest amit régebben csináltam. Nem is az lenne a baj szerintem, hogy hülyén fogalmazom meg a változóimat, inkább csak az, hogy mivel nem ismerem azokat a metódusokat amiket használhatnék, nehezebb, saját megoldások után kutatok és bár láttam már metódusokat, és azoknak a működését amik segítenének, nem tudtam őket használni, mert nem tudtam, hogyan tegyem mindezt. Ha nem tudja alapból a Windows GDI a környezetfelismerést akkor nem baj, kitalálok mást de nem szeretnék Silverlight-hoz nyúlni még. Windows Application-ben szeretném megírni mindenképpen. Szeretnék egy golyó osztályt, ami mozgat, ütköztet és ha kell véges számszor sokszorosítható. Ehhez kellene segítség nekem, hogy hogyan fogjak hozzá az osztályhoz, csak sajnos az a baj, hogy van eszközöm, viszont nem tudom használni és soksok keresés és utána olvasás után sem találom a megfelelő válaszokat. nem voltam rest heteket tölteni c# könyvek felett és gdi tutorialokat olvasni. Mégsem állt még össze. nem találtam a megfelelő magyarázatokat a kérdsemre ezért fordultam ide, hátha valaki tud nekem segíteni, hogy kicsit jobban átlássam.
"Vagy van-e valami olyan metódusa a Graphics nak, ami érzékeli két rajzolt elem érintkezését?"
rendben van... ezt láttam már és nézegettem. De nem tudom HOGYAN használjam. Elolvastam melyik mit csinál és hogyan... rendben van, de még nem találtam meg a megfelelőt és nem tudom használni néha a dolgokat, mert le van írva hogyan kell, csak ha úgy használom néha nem működik. Pl.: nemrég jöttem rá, hogy ha beírok egy más által írt kódot egy új dokumentumba, akkor ha lérehozom a formon azokat a dolokat amik működtek, még nem megyek vele semmire, mert az eventhandlerbe be kell illesztenem a Form1_Load eseményt stb. Ilyeneken buktam el idáig. Most már erre is odafigyelek. Ilyen hibáim és figyelmetlenségből fakadó csúszásaim vannak. Ezeket a problémákat szeretném orvosolni. Napi szinten írom a programot. Sokat foglalkozom vele és szeretem a kihívásokat, nem igazán rettentenek el az ilyen dolgok és szeretném megoldani a problémát... és meg is fogom. Csak sok idő és türelem kérdése, de menetközben sokat tanulok "magamtól" és sokat a különböző oldalaktól és ha szembesülök a hibákkal könyebben tanulok belőle, mert saját szememmel látom. Elnézést ha bármilyen szinten is zavaró kódokat írok, még nem alakult ki annyira nálam a szép kód. Idővel bizonyára ki fog és soksok és még több gyakorlás után átláthatóbb lesz a kódom, most még örülök, hogy ilyen szinten el tudom érni amit szeretnék. Közben folyamatosan változni fog. Tudom, mert ez a folyamata a tanulásnak.
köszönöm a választ és a megértést és a segítséget!
"Pontosabban látom, hogy a pattanás feltételeinél kellene"
Az a baj, hogy a kódodban keresni kell hol van ez a rész, mert nincs strukturálva. Nagyon ráérős kell legyen valaki hogy nekiálljon megfejteni és megérteni amit bemásoltál.
"Meg lehet-e csinálni, hogy Enter eseményt használok a golyók ütközésére?"
Természetesen. A Control.Enter Event viszont teljesen másról szól, ha erre gondoltál felejtsd el.
"Vagy van-e valami olyan metódusa a Graphics nak, ami érzékeli két rajzolt elem érintkezését?"
Legelső lépésként el kellene döntsd, hogy hogyan szeretnéd megoldani a feladatot. Még mielőtt egy sor kódot is írnál. El kellene döntsd, hogy milyen szereplőid vannak és melyiknek mik a felelősségei, mi mikor mit csinál és annak milyen következményei vannak. Amíg ezt nem tudod addig csak a kérdéseid száma növekszik.
Ha ezt már tudod akkor sokkal könnyebb eldönteni, hogy hogyan jobb implementálni. Pl. .Net (GDI), WPF vagy Silverlight. És átláthatóbb is lesz ha már tudod hogy van Golyó osztályod amelyiknek van pozíciója, sebessége, és talán egy Ütközik(Golyó másikGolyó) metódusa is, de lehet egy Mozog(Pálya pálya) metódusa is.
Addig csak azt tudom megismételni amit a 728-ban írtam. Ha ilyen összevissza kódot írsz addig te is nehezen érted meg, egy kívülállónak pedig még nehezebb megérteni.
Event handlerbe ne írj kódot, hanem hívj meg megfelelően elnevezett metódusokat hogy könnyen meg lehessen érteni mi történik.
Ha olyant szeretnél hogy a grafikai objektumok ismerjék a környezetüket akkor Silverlight vagy hasonló kell neked, a Windows GDI ezt nem tudja alapból.
Üdv, elnézést, hogy csak betoltam a kódot, az előnézet helyett az elküldésre kattintottam. Azt szeretném elérni, hogy a két golyó akármilynem mozgást végez, mindig ha találkoznak pattanjanak el egymásról. Most nem szempont a fizika, csak, hogy ha érintkeznek akkor pattanjanak.
Sikerült megoldanom a rajzolás és a pattanás problémáját, csak egy apróságot nem értek. Miért viselkedik ilyen hülyén a program? Mondom mi a gond, de ha kipróbáljátok látni is fogjátok. Szimetrikus pattanásnál nincs baj, mert pattan, de ha asszimetrikus mozgásra kerül a sor, akkor hamarabb pattan el a golyó, vagy messzebbről vagy nem pattan. Szimetrikus mozgásnak azt nevezem ebben a programban, hogy az x és y koordináta sebessége megegyezik és tükörszerűen ellentétesen pattannak a golyók. Ha a tempót állítom és csak az x akkor semmi baj. ha már az x és y-on is állítok akkor már bezavarodik a program és nem látom a problémát, hogy hol kéne még alakítani. Pontosabban látom, hogy a pattanás feltételeinél kellene de nem tudom, hogy mi az a lépés amit bele kellene vennem és ezt szeretném kérdezni, hogy mit rontottam el, mert több szem többet lát én meg már olyan sokat foglalkoztam ezzel a kóddal, hogy tuti elsiklok valami felett.
VAGY
Meg lehet-e csinálni, hogy Enter eseményt használok a golyók ütközésére? Tehát, ha az egyik rajzolt alakzat érzi, hogy a másik beleért.
például:
if (g.Ellipse1.Enter)
{
speed_x *= -1;
}
vagy valami hasonlót. Vagy van-e valami olyan metódusa a Graphics nak, ami érzékeli két rajzolt elem érintkezését? Remélem értitek mire szeretnék kilyukadni. Én eddig csak consolos alkalmazásokat írtam c++ ban. A c# és a grafikus felület kicsit kusza még itt ott, sokat olvasok utána és próbálom teljesen átlátni, csak ezen nem tudok túljutni.
A kódot még egyszer nem rakom be /*úgyis alatta van :) */, hogy ne tolja szét a topicot feleslegesen.
A mozgatás, ütközés és egyéb logika nem szabad függjön attól hogy éppen egy Image vagy valami más van megjelenítve mint labda.
Azaz írjál egy osztályt amelyik Ball objektumokat tud mozgatni, vagy egy Ball osztályt ami magától tud mozogni (esetleg oszd szét a kettő között a funkcionalitást), majd írjál egy másik osztályt amelyik Ball objektumokat tud rajzolni.
Megjelenítéshez van Bitmap osztály (ez lehet transzparens is), de akár egy kontrol Graphics-a is használható rajzolásra (pl. DrawEllipse metódus).
Ha visszakeresel megtalálod ugyanezt a témát, annyi az eltérés hogy labdák helyett lények mozogtak. Ha az jó lett megírva akkor a mozgatás rész módosítás nélkül felhasználható nálad is, csak lények helyett labdákat kell megjeleníteni.
Grafikához van még Silverlight, az ilyen téren sokkal többet tud mint az alap Framework, pl. úgy tudom alapból tud ütközéseket kezelni.
Köszönöm a választ a nulla kérdésre... igen, válaszoltál mindenre, amit fel akartam tenni... csak az kimaradt. Az internált miután bemásoltam, azonnal cseréltem. Valóban több közöm volt a java-hoz meg a c++-hoz, mint a c#hoz. Még csak tanulom.
Ami még szeretnék: két golyót mozgatni. Van egy pontom, vagy egy image, vagy akármi. Mivel nem ismerem annyira az MSV2010-t ezért nem tudom, hogy mit használjak a Formon. Tegyek be egy képet, egy labáról pl 30X30 méretben és vágjam le a kis csücsköket, vagy rajzoljak telt köröket, mert gondolom egy Formon mindennek van koordinátája. De ha képet rakok be, akkor annál milyen eseménybe tudnám beírni egy "falhoz-ütközötél-pattanj-vissza" kódot. Ami megvan a fejemben és le is írtam és egy consolos programnál működött is, de szeretnék majd több golyót is lerakni. pl úgy, hogy a két golyó ha egymásnak meg ugyanúgy pattanjon vissza, mintha falról tette volna. nem kell, hogy realisztikusan pattanjon, csak pattanjon. a beesési szög ugyanakkora lenne mint amivel beérkezett. a golyónál meg számolnék, mert ott sok tényező szerepel még, legalább is úgy gondolom. Nem vagyok benne profi, de szeretném már átlátni.
tehát:
Mivel hozzak létre golyót, hogy később használhassak rá olyan eseményt ami mozgatja azt?
Mi ez az esemény? (nem a kódra vagyok kíváncsi, hanem, hogy az Event-ek közül melyiket használjam, ami beszédes lenne a kódban. )
Szeretném ha ezek a golyók egymáson is elpattannának ugyanúgy ahogy a falról is. Figyeljem a két golyó x és y közti távolságát, és erre is írjak ifeket, vagy van rá valami más mód?
"Inkonzisztens láthatóság: 'Main.Ball' ősosztály láthatósága kisebb mint a 'Main.BallMove' osztály láthatósága."
Hogy hogyan kell javítani?
A láthatóság nem módosítható leszármazással, tehát ha az ősosztály internal akkor a leszármazott is internal kell legyen. Alapszintű logikával levezethető, hogy ha az ősosztály nem látható egy modul számára (pl. mert internal egy másik modulban) akkor a leszármazott sem lehet látható mert ősosztály nélkül nem tud működni a leszármazott.
Javaslatok:
-A láthatóságot mindig add meg explicit módon, ne bízd a fordítóra.
-A namespace legyen specifikusabb, hogy ne ütközzön másokéval. Pl. SteK.Játék.Labda.
-Ha a BallMove arra való amire a neve utal akkor nem kell leszármazzon a Ball osztályból hanem inkább használnia kell azt.
-Vagy mindenütt legyen this vagy sehol ne legyen (fölösleges, a compiler odateszi helyetted).
-Dx, Dy és hasonló titkosított nevek helyett használj értelmes neveket. Nem csak másokét, hanem a saját életedet is megkönnyíted ha olvasható a kódod. Nem papírra írsz mint régen a matematikusok, mióta van kódkiegészítés azóta nem gond ha hosszú egy azonosító.
-SetDx, SetDy: ezeknek hibás a neve ugyanis nem Dx, Dy állítást csinálnak (a GetDx eredménye nem az lesz amit a SetDx-ben megadsz). Ha jól értelmezem a kódot akkor inkább MoveBy kellene legyen a metódusnév.
-SetDv: ennek sem jó a neve, inkább ResetDv lenne helyes.
-setDx(getDv() * (-1)); ugyanaz mint setDx(-getDv());
