"Ech weess datt ech näischt weess" Sokrates
Fir ween: fir IT Leit déi op all Entwéckler späizen an hir Spiller spille wëllen!
Iwwer wat: wéi ufänken Spiller an C / C ++ ze schreiwen wann Dir et braucht!
Firwat sollt Dir dëst liesen: App Entwécklung ass net meng Aarbecht Spezialitéit, mee ech probéieren all Woch ze codéieren. Well ech Léift Spiller!
Moien mäin Numm ass , Ech sinn en DevOps bei Luxoft. Applikatioun Entwécklung ass net meng Aarbecht Spezialitéit, mee ech probéieren all Woch ze codéieren. Well ech Léift Spiller!
D'Computerspillerindustrie ass enorm, nach méi rumoréiert haut wéi d'Filmindustrie. D'Spiller sinn zënter dem Ufank vun der Entwécklung vu Computere geschriwwe ginn, mat modernen Normen, komplex a Basis Entwécklungsmethoden. Mat der Zäit hunn Spillmotoren ugefaang mat scho programméierte Grafiken, Physik an Toun ze erschéngen. Si erlaben Iech op d'Entwécklung vum Spill selwer ze fokusséieren an net iwwer seng Fondatioun ze stéieren. Awer zesumme mat hinnen, mat de Motoren, ginn d'Entwéckler "blann" an degradéieren. Déi ganz Produktioun vu Spiller gëtt op de Fërderband gesat. An d'Quantitéit vun der Produktioun fänkt un hir Qualitéit ze herrschen.
Zur selwechter Zäit, wann Dir aner Spiller spillt, si mir dauernd limitéiert vu Plazen, Komplott, Personnagen, Spillmechanik, déi aner Leit erstallt hunn. Also hunn ech gemierkt datt ...
... et ass Zäit Är eege Welten ze kreéieren, nëmmen ënner mir. Welten, wou ech de Papp, an de Jong, an den Hellege Geescht sinn!
An ech gleewen éierlech datt Dir Ären eegene Spillmotor an e Spill drop schreift, Dir kënnt Är Aen opmaachen, d'Fënstere wëschen an Är Kabine pumpen, e méi erfuerene an integralen Programméierer ginn.
An dësem Artikel probéieren ech Iech ze soen wéi ech ugefaang hunn kleng Spiller an C / C ++ ze schreiwen, wat ass den Entwécklungsprozess a wou ech Zäit fir en Hobby an engem beschäftegten Ëmfeld fannen. Et ass subjektiv a beschreift de Prozess vun engem individuellen Start. Material iwwer Ignoranz a Glawen, iwwer mäi perséinlecht Bild vun der Welt am Moment. An anere Wierder, "D'Administratioun ass net verantwortlech fir Äre perséinleche Gehir!".
Praxis
"Wëssen ouni Praxis ass nëtzlos, Praxis ouni Wëssen ass geféierlech." Confucius
Meng Notizbuch ass mäi Liewen!
Also, an der Praxis, kann ech soen datt alles fir mech mat engem Notizbuch ufänkt. Ech schreiwen do net nëmmen meng deeglech Aufgaben op, mee och molen, programméieren, designen Flowcharts a léisen Problemer, och mathematesch. Benotzt ëmmer en Notizblock a schreift nëmme mat engem Bleistift. Et ass propper, bequem an zouverlässeg, IMHO.
Meng (schon gefëllt) Notizbuch. Esou gesäit et aus. Et enthält alldeeglechen Aufgaben, Iddien, Zeechnungen, Diagrammer, Léisungen, schwaarz bookkeeping, Code, etc.
Op dëser Etapp hunn ech et fäerdeg bruecht dräi Projeten ofzeschléissen (dëst ass a mengem Verständnis vun "Finale", well all Produkt relativ endlos entwéckelt ka ginn).
- Projet 0: Dëst ass eng Architekt Demo 3D Szen geschriwwen an C # mat der Unity Spillmotor. Fir macOS a Windows Plattformen.
- Spill 1: Konsol Spill Simple Snake (bekannt fir jiddereen als "Snake") fir Windows. geschriwwen an C.
- Spill 2: Konsol Spill Crazy Tanks (bekannt fir jiddereen als "Tanks"), schonn an C ++ geschriwwen (mat Klassen) an och ënner Windows.
Projet 0 Architekt Demo
- Plattform: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
- Sprooch: C#
- Spillmotor:
- Inspiratioun:
- Repository:
3D Szen Architekt Demo
Den éischte Projet gouf net an C / C ++ ëmgesat, mee am C # mat der Unity Spillmotor. Dëse Motor war net esou exigent op Hardware wéi , a schénge mir och méi einfach ze installéieren an ze benotzen. Ech hunn aner Motore net berücksichtegt.
D'Zil an der Unity fir mech war net eng Aart Spill z'entwéckelen. Ech wollt eng 3D Zeen mat iergendenger Charakter kreéieren. Hien, oder éischter Si (ech hunn d'Meedchen modelléiert an deem ech verléift war =) huet misse plënneren a mat der Äussewelt interagéieren. Et war nëmme wichteg ze verstoen wat Unity ass, wat den Entwécklungsprozess ass, a wéi vill Effort et brauch fir eppes ze kreéieren. Dëst ass wéi de Projet Architect Demo gebuer gouf (den Numm gouf bal aus dem Bullshit erfonnt). Programméiere, Modeller, Animatioun, Texturéierung huet mech wahrscheinlech zwee Méint vun alldeeglecher Aarbecht gedauert.
Ech hunn ugefaang mat Tutorialvideoen op YouTube iwwer wéi een 3D Modeller erstellt . Blender ass e super gratis Tool fir 3D Modeller (a méi) dat keng Installatioun erfuerdert. An hei huet e Schock op mech gewaart ... Et stellt sech eraus datt Modelléierung, Animatioun, Texturéierung enorm separat Themen sinn, op deenen Dir Bicher schreiwen kann. Dëst ass virun allem wouer fir d'Personnagen. Fir Fanger, Zänn, Aen an aner Deeler vum Kierper ze modelléieren, braucht Dir Wëssen iwwer Anatomie. Wéi sinn d'Muskelen vum Gesiicht arrangéiert? Wéi beweegen d'Leit? Ech hu misse Schanken an all Aarm, Been, Fanger, Knéien "asetzen"!
Modell de Clavicle, zousätzlech Knochenheber, sou datt d'Animatioun natierlech ausgesäit. No esou Lektioune mierkt Dir wat fir eng grouss Aarbecht d'Creatoren vun animéierten Filmer maachen, just fir 30 Sekonnen Video ze kreéieren. Awer 3D Filmer daueren fir Stonnen! An da komme mir aus den Kinoen a soen eppes wéi: “Ta, e scheiss Cartoon/Film! Si hätte besser kënne maachen ... "Narren!
An nach eng Saach iwwer d'Programmatioun an dësem Projet. Wéi et sech erausstellt, war den interessantsten Deel fir mech de mathematesche. Wann Dir d'Szen leeft (Link op de Repository an der Projektbeschreiwung), mierkt Dir datt d'Kamera ronderëm de Meedchen Charakter an enger Kugel rotéiert. Fir esou eng Kamerarotatioun ze programméieren, muss ech fir d'éischt d'Koordinate vum Positiounspunkt um Krees (2D) an dann op der Kugel (3D) berechnen. Déi witzeg Saach ass datt ech Mathematik an der Schoul haassen an et mat engem Minus wousst. Deelweis, wahrscheinlech, well se Iech an der Schoul einfach net erkläre wéi d'Häll dës Mathematik am Liewen applizéiert gëtt. Awer wann Dir obsesséiert sidd mat Ärem Zil, Dram, da gëtt de Geescht geläscht, opgedeckt! An Dir fänkt un komplex Aufgaben als spannend Abenteuer ze gesinn. An dann denkt Dir: "Ma, firwat konnt net * beléifte * Mathematiker normalerweis soen, wou dës Formelen hänke kënnen?".
Berechnung vu Formelen fir d'Berechnung vun de Koordinate vun engem Punkt op engem Krees an op enger Kugel (vu mengem Notizbuch)
Spill 1
- Plattform: Windows (getest op Windows 7, 10)
- Sprooch: Ech mengen et gouf a pure C geschriwwen
- Spillmotor: Windows Konsol
- Inspiratioun:
- Repository:
Einfach Snake Spill
D'3D Szen ass kee Spill. Zousätzlech ass d'Modelleréieren an Animatioun vun 3D Objeten (besonnesch Charaktere) laang a schwéier. Nodeem ech mat Unity gespillt hunn, hunn ech gemierkt, datt ech misste weidergoen, oder éischter ufänken, vun de Basics. Eppes einfach a séier, awer gläichzäiteg global, fir déi ganz Struktur vu Spiller ze verstoen.
A wat hu mir einfach a séier? Dat ass richteg, Konsol an 2D. Méi präzis, souguer d'Konsol a Symboler. Ech hunn erëm ugefaang no Inspiratioun um Internet ze sichen (am Allgemengen, ech betruechten den Internet déi revolutionärst a geféierlechst Erfindung vum XNUMX. Joerhonnert). Ech hunn e Video vun engem Programméierer gegruewen, deen d'Konsole Tetris gemaach huet. An an der Ähnlechkeet vu sengem Spill huet hien decidéiert d'"Schlaang" ofzeschneiden. Vum Video hunn ech iwwer zwou fundamental Saache geléiert - d'Spillschleife (mat dräi Basisfunktiounen / Deeler) an d'Ausgab zum Puffer.
D'Spillschleife kéint esou ausgesinn:
int main()
{
Setup();
// a game loop
while (!quit)
{
Input();
Logic();
Draw();
Sleep(gameSpeed); // game timing
}
return 0;
}De Code presentéiert déi ganz Haaptfunktioun () gläichzäiteg. An de Spillzyklus fänkt nom entspriechende Kommentar un. Et ginn dräi Basisfunktiounen an der Loop: Input (), Logik (), Zeechnen (). Éischt, Input Daten Input (haaptsächlech Kontroll vun Tastekombinatiounen), dann Veraarbechtung der aginn Daten Logik, dann um Écran ugewisen - Zeechnen. An esou all Frame. Animatioun gëtt op dës Manéier erstallt. Et ass wéi Cartoons. Normalerweis hëlt d'Veraarbechtung vun den Inputdaten déi meescht Zäit a bestëmmt, souwäit ech weess, de Frame Taux vum Spill. Awer hei ass d'Logik () Funktioun ganz séier. Dofir muss de Frame Taux vun der Sleep () Funktioun mat dem GameSpeed Parameter kontrolléiert ginn, deen dësen Taux bestëmmt.
Spill Zyklus. Schlaang programméiere am Notizblock
Wann Dir e symbolescht Konsolespill entwéckelt, dann d'Daten um Bildschierm ze weisen mat der üblecher Streamoutput 'cout' funktionnéiert net - et ass ganz lues. Dofir muss d'Ausgab am Bildschirmbuffer duerchgefouert ginn. Sou vill méi séier an d'Spill funktionnéiert ouni Feeler. Fir éierlech ze sinn, verstinn ech net ganz wat e Bildschirmbuffer ass a wéi et funktionnéiert. Awer ech ginn e Code Beispill hei, a vläicht kann een an de Kommentaren d'Situatioun klären.
Den Écranbuffer kréien (wann ech dat soen däerf):
// create screen buffer for drawings
HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
DWORD dwBytesWritten = 0;
SetConsoleActiveScreenBuffer(hConsole);Direkt Ausgang op den Ecran vun enger bestëmmter Zeil ScoreLine (d'Linn fir Partituren ze weisen):
// draw the score
WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);An der Theorie gëtt et näischt komplizéiert an dësem Spill, et schéngt mir e gutt Beispill vun engem Entry-Level Spill. De Code ass an engem Fichier geschriwwen an a verschiddene Funktiounen arrangéiert. Keng Klassen, keng Ierfschaft. Dir kënnt selwer alles am Quellcode vum Spill gesinn andeems Dir an de Repository op GitHub gitt.
Spill 2 Crazy Tanks
- Plattform: Windows (getest op Windows 7, 10)
- Sprooch: C ++
- Spillmotor: Windows Konsol
- Inspiratioun: e Buch
- Repository:
Crazy Tanks Spill
D'Personnagen op d'Konsole drécken ass wahrscheinlech déi einfachst Saach, déi Dir an e Spill verwandele kënnt. Awer dann erschéngt ee Problem: d'Personnagen hunn verschidden Héichten a Breeten (d'Héicht ass méi grouss wéi d'Breet). Also wäert alles disproportionnéiert ausgesinn, an erof oder erop réckelen schéngt vill méi séier wéi lénks oder riets. Dësen Effekt ass ganz merkbar am "Snake" (Spill 1). "Tanks" (Spill 2) hunn net esou en Nodeel, well d'Ausgab do organiséiert gëtt andeems d'Bildschierm Pixel mat verschiddene Faarwen gemoolt gëtt. Dir kënnt soen datt ech e Renderer geschriwwen hunn. Richteg, dëst ass schonn e bësse méi komplizéiert, obwuel vill méi interessant.
Fir dëst Spill ass et genuch fir mäi System ze beschreiwen fir Pixel um Bildschierm ze weisen. Ech mengen dat ass den Haaptdeel vum Spill. An alles anescht kënnt Dir mat Iech selwer kommen.
Also, wat Dir um Écran gesitt ass just eng Rei vu bewegt faarwege Rechtecker.
Rechteck gesat
All Rechteck gëtt duerch eng Matrix gefëllt mat Zuelen duergestallt. Iwwregens kann ech eng interessant Nuance markéieren - all d'Matrizen am Spill sinn als eendimensional Array programméiert. Net zweedimensional, mee eendimensional! Eendimensional Arrays si vill méi einfach a méi séier mat ze schaffen.
E Beispill vun engem Spill Tank Matrixentgasung
Representéiert d'Matrix vun engem Spilltank mat engem One-Dimensional Array
E méi illustrativt Beispill vun enger Matrixrepresentatioun duerch eng eendimensional Array
Awer den Zougang zu den Elementer vum Array geschitt an enger duebeler Loop, wéi wann et net eng eendimensional war, awer eng zweedimensional Array. Dëst gëtt gemaach well mir nach mat Matrizen schaffen.
Traverséiere vun engem eendimensionalen Array an enger duebeler Loop. Y ass d'Zeil ID, X ass d'Kolonn ID
Notéiert w.e.g. datt amplaz vun den üblechen Matrixidentifizéierer i, j, benotzen ech d'Identifikatoren x an y. Also, et schéngt mir, méi erfreelech fir d'Aen a méi kloer fir d'Gehir. Zousätzlech mécht esou eng Notatioun et méiglech, d'Matrixen, déi benotzt ginn, bequem op d'Koordinatenachse vun engem zweedimensionalen Bild ze projizéieren.
Elo iwwer Pixel, Faarf an Affichage. D'StretchDIBits Funktioun (Header: windows.h; Bibliothéik: gdi32.lib) gëtt fir Output benotzt. Ënnert anerem gëtt déi folgend Funktioun iwwerginn: den Apparat op deem d'Bild ugewise gëtt (a mengem Fall ass dat d'Windows Konsole), d'Koordinate vum Ufank vum Affichage vum Bild, seng Breet / Héicht an d'Bild selwer a Form vun enger Bitmap (Bitmap), representéiert duerch eng Array vu Bytes. Bitmap als Array vu Bytes!
D'StretchDIBits() Funktioun op der Aarbecht:
// screen output for game field
StretchDIBits(
deviceContext,
OFFSET_LEFT, OFFSET_TOP,
PMATRIX_WIDTH, PMATRIX_HEIGHT,
0, 0,
PMATRIX_WIDTH, PMATRIX_HEIGHT,
m_p_bitmapMemory, &bitmapInfo,
DIB_RGB_COLORS,
SRCCOPY
);Erënnerung gëtt am Viraus fir dës Bitmap mat der VirtualAlloc () Funktioun zougewisen. Dat ass, déi erfuerderlech Unzuel u Bytes ass reservéiert fir Informatioun iwwer all Pixel ze späicheren, déi dann um Bildschierm ugewise ginn.
Eng m_p_bitmapMemory Bitmap erstellen:
// create bitmap
int bitmapMemorySize = (PMATRIX_WIDTH * PMATRIX_HEIGHT) * BYTES_PER_PIXEL;
void* m_p_bitmapMemory = VirtualAlloc(0, bitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);Grof geschwat, e Bitmap besteet aus engem Set vu Pixelen. All véier Bytes an der Array ass e RGB Pixel. Ee Byte pro roude Wäert, ee Byte pro grénge Wäert (G), an ee Byte pro blo Faarf (B). Plus, et gëtt ee Byte pro Indent. Dës dräi Faarwen - Rout / Gréng / Blo (RGB) - gi mateneen a verschiddene Verhältnisser gemëscht - an déi resultéierend Pixelfaarf gëtt kritt.
Elo, erëm, all Rechteck, oder Spill Objet, gëtt duerch eng Zuel Matrixentgasung duergestallt. All dës Spillobjekter ginn an enger Sammlung gesat. An da gi se op de Spillfeld gesat, a bilden eng grouss numeresch Matrix. Ech hunn all Zuel an der Matrix op eng spezifesch Faarf gemoolt. Zum Beispill ass d'Nummer 8 blo, d'Nummer 9 ass giel, d'Nummer 10 ass donkelgrau, a sou weider. Also kënne mir soen datt mir eng Matrix vum Spillfeld hunn, wou all Zuel eng Zort Faarf ass.
Also hu mir eng numeresch Matrix vum ganze Spillfeld engersäits an eng Bitmap fir d'Bild op der anerer Säit ze weisen. Bis elo ass de Bitmap "eidel" - et huet nach keng Informatioun iwwer d'Pixel vun der gewënschter Faarf. Dëst bedeit datt de leschte Schrëtt de Bitmap mat Informatioun iwwer all Pixel fëllt op Basis vun der numerescher Matrix vum Spillfeld. En illustrativt Beispill vun esou enger Transformatioun ass am Bild hei drënner.
E Beispill fir e Bitmap (Pixel Matrix) mat Informatioun auszefëllen baséiert op der numerescher Matrix (Digital Matrix) vum Spillfeld (Faarf Indizes passen net mat den Indizes am Spill)
Ech wäert och e Stéck real Code aus dem Spill presentéieren. De variabelen ColorIndex bei all Iteratioun vun der Loop gëtt e Wäert (Faarfindex) vun der numerescher Matrix vum Spillfeld (mainDigitalMatrix) zougewisen. Da gëtt d'Faarf selwer op d'Faarfvariabel geschriwwen op Basis vum Index. Weider ass déi resultéierend Faarf an de Verhältnis vu rout, gréng a blo (RGB) opgedeelt. An zesumme mam Indent (PixelPadding) gëtt dës Informatioun ëmmer erëm op de Pixel geschriwwen, a bilden e Faarfbild an der Bitmap.
De Code benotzt Pointer a bitwise Operatiounen, déi schwéier ze verstoen kënne sinn. Also ech roden Iech iergendwou separat ze liesen wéi esou Strukturen funktionnéieren.
Fëllt eng Bitmap mat Informatioun baséiert op der numerescher Matrix vum Spillfeld:
// set pixel map variables
int colorIndex;
COLORREF color;
int pitch;
uint8_t* p_row;
// arrange pixels for game field
pitch = PMATRIX_WIDTH * BYTES_PER_PIXEL; // row size in bytes
p_row = (uint8_t*)m_p_bitmapMemory; //cast to uint8 for valid pointer arithmetic
(to add by 1 byte (8 bits) at a time)
for (int y = 0; y < PMATRIX_HEIGHT; ++y)
{
uint32_t* p_pixel = (uint32_t*)p_row;
for (int x = 0; x < PMATRIX_WIDTH; ++x)
{
colorIndex = mainDigitalMatrix[y * PMATRIX_WIDTH + x];
color = Utils::GetColor(colorIndex);
uint8_t blue = GetBValue(color);
uint8_t green = GetGValue(color);
uint8_t red = GetRValue(color);
uint8_t pixelPadding = 0;
*p_pixel = ((pixelPadding << 24) | (red << 16) | (green << 8) | blue);
++p_pixel;
}
p_row += pitch;
}No der uewen beschriwwen Method, gëtt ee Bild (Frame) am Crazy Tanks Spill geformt an um Écran an der Draw () Funktioun ugewisen. No der Enregistréiere vun Tastekombinatiounen an der Input () Funktioun an hir spéider Veraarbechtung an der Logic () Funktioun, gëtt en neit Bild (Frame) geformt. Richteg, Spillobjekter kënnen schonn eng aner Positioun um Spillfeld hunn an deementspriechend op enger anerer Plaz gezeechent ginn. Dëst ass wéi Animatioun (Bewegung) geschitt.
An der Theorie (wann Dir näischt vergiess hutt), d'Spillschleife vum éischte Spill ze verstoen ("Snake") an de System fir Pixel um Bildschierm vum zweete Spill ze weisen ("Tanks") ass alles wat Dir braucht fir ze schreiwen vun Äre 2D Spiller fir Windows. Tounlos! 😉 De Rescht vun den Deeler si just e Fluch vu Fantasi.
Natierlech ass d'Spill "Tanks" vill méi komplizéiert entwéckelt wéi de "Snake". Ech benotzt schonn d'C ++ Sprooch, dat ass, ech beschriwwen verschidde Spill Objete mat Klassen. Ech hunn meng eege Kollektioun erstallt - Dir kënnt de Code an Header gesinn / Box.h. Iwwregens huet d'Kollektioun héchstwahrscheinlech e Gedächtnisleck. Benotzt Pointer. Geschafft mat Erënnerung. Ech muss soen datt d'Buch mir vill gehollef huet. Ufank C ++ Duerch Spill Programméiere. Dëst ass e super Start fir Ufänger am C ++. Et ass kleng, interessant a gutt organiséiert.
Et huet ongeféier sechs Méint gedauert fir dëst Spill z'entwéckelen. Ech geschriwwen haaptsächlech während Mëttegiessen a Snacks op der Aarbecht. Hien souz an der Büroskichen, huet op Iessen gestampt a Code geschriwwen. Oder doheem fir Iessen. Also hunn ech sou "Kichenkricher". Wéi ëmmer hunn ech aktiv en Notizbuch benotzt, an all konzeptuell Saache sinn do gebuer.
Um Enn vum prakteschen Deel zéien ech e puer Scans vu mengem Notizbuch eraus. Fir ze weisen wat ech genau opgeschriwwen hunn, zeechnen, zielen, designen ...
Tank Bild Design. An d'Definitioun vu wéivill Pixel all Tank um Écran soll besetzen
Berechnung vum Algorithmus a Formelen fir d'Rotatioun vum Tank ëm seng Achs
Diagramm vu menger Sammlung (déi mat der Erënnerungslek, héchstwahrscheinlech). D'Kollektioun gëtt als Linked List erstallt
An dëst sinn futil Versuche fir kënschtlech Intelligenz an d'Spill ze schrauwen
Theorie
"Och eng Rees vun dausend Meilen fänkt mam éischte Schrëtt un" (Ancient Chinese Wäisheet)
Loosst eis vu Praxis op Theorie goen! Wéi fannt Dir Zäit fir Ären Hobby?
- Bestëmmt wat Dir wierklech wëllt (Elo, dëst ass déi schwéierst).
- Prioritéite setzen.
- Opfer all "iwwerflësseg" fir méi héich Prioritéiten.
- Beweegt all Dag op Är Ziler.
- Erwaart net datt et zwou oder dräi Stonnen Fräizäit fir en Hobby gëtt.
Engersäits musst Dir bestëmmen wat Dir wëllt a prioritär. Op der anerer Säit ass et méiglech e puer Fäll / Projeten zugonschte vun dëse Prioritéiten opzeginn. An anere Wierder, Dir musst alles "iwwerflësseg" opferen. Ech hunn iergendwou héieren, datt am Liewen maximal dräi Haaptaktivitéite solle sinn. Da kënnt Dir op déi bescht méiglech Manéier mat hinnen ëmgoen. An zousätzlech Projeten / Richtungen fänken corny ze iwwerlaascht. Awer dëst ass alles, wahrscheinlech, subjektiv an individuell.
Et gëtt eng gewësse gëllen Regel: ni en 0% Dag! Ech hunn doriwwer an engem Artikel vun engem Indie Entwéckler geléiert. Wann Dir un engem Projet schafft, da maacht all Dag eppes doriwwer. An et ass egal wéi vill Dir maacht. Schreift ee Wuert oder eng Zeil vum Code, kuckt een Tutorialsvideo oder hammer een Nol an d'Brett - maacht just eppes. Den haardsten Deel ass unzefänken. Wann Dir ufänkt, wäert Dir wahrscheinlech e bësse méi maachen wéi Dir wollt. Also wäert Dir stänneg Richtung Äert Zil réckelen an, gleeft mir, ganz séier. No allem ass d'Haaptbrems op all Saache Verspéidung.
An et ass wichteg ze erënneren datt Dir de gratis "Säge" vun der Zäit an 5, 10, 15 Minutten net ënnerschätzen an ignoréiere sollt, waart op e puer grouss "Logbicher" déi eng Stonn oder zwou daueren. Sidd Dir an der Rei? Denkt un eppes fir Äre Projet. Gitt Dir d'Rolltrap erop? Schreift eppes an engem Notizbuch. Iessen Dir am Bus? Okay, liesen en Artikel. Benotzt all Geleeënheet. Stop Kazen an Hënn op YouTube kucken! Maacht net mat Ärem Gehir!
An déi lescht. Wann Dir, nodeems Dir dësen Artikel gelies hutt, d'Iddi gär hutt Spiller ze kreéieren ouni Spillmotoren ze benotzen, erënnert Iech un den Numm Casey Muratori. Dëse Guy huet . An der Rubrik "Kucken -> FRÉIER EPISODES" fannt Dir erstaunlech gratis Video Tutorials wéi Dir e professionnelle Spill vun Ufank un erstellt. Dir kënnt méi a fënnef Intro zu C fir Windows Lektioune léieren wéi a fënnef Joer Studie op der Uni (een huet iwwer dëst an de Kommentarer ënner dem Video geschriwwen).
De Casey erkläert och datt andeems Dir Ären eegene Spillmotor entwéckelt, Dir e bessere Verständnis vun all existente Motoren hutt. An der Welt vu Kaderen, wou jidderee probéiert ze automatiséieren, léiert Dir wéi Dir erstellt, net benotzt. Verstinn d'Natur vu Computeren. An Dir wäert och e vill méi intelligenten a reife Programméierer ginn - e Profi.
Vill Gléck op Ärem gewielte Wee! A loosst eis d'Welt méi professionell maachen.
Auteur: , DevOps
Source: will.com