staal, nerts, rundvlees, papier 28 juli 2017 om 17:03 uur

DIY-game-engine in C++. Deel 1 (Inleiding)

• C++
• Systeemanalyse en ontwerp,
• Spelontwikkeling

Game-engine
Wij ontwerpen, schrijven, denken, redeneren, lezen en nog veel meer
Aandacht: de artikelen bevatten veel krukken!

Goede dag allemaal. Nog niet zo lang geleden besloot ik een 3D-game-engine te gaan ontwikkelen, omdat gestructureerde informatie hier is niet veel over te zeggen, ik heb besloten een reeks artikelen te maken waarin ik zal proberen meer van het technische gedeelte dan het theoretische gedeelte te laten zien.

Nu stap ik af van het onderwerp en wil ik meteen iets verduidelijken... Ik ben geen goede softwarearchitect of senior ontwikkelaar. Ik ben 21 en ik ben een kleine, ambitieuze C++ middenontwikkelaar, ik kan fouten maken en onzin schrijven.

Alleen een Sith handelt in absolute waarden. Obi Wan ‘Ben’ Kenobi

Ik ben blij om opmerkingen en suggesties in de reacties te zien.
Misschien rond ik hiermee het inleidende gedeelte af en gaan we aan de slag.

Deel 1: Inleiding

Eerst moet je begrijpen wat de essentie van de engine is en waarom je deze zou moeten schrijven.
Hmm... En wat is dit?!

Game-engine

centraal softwarecomponent computer- en videogames of andere interactieve toepassingen met afbeeldingen die in realtime worden verwerkt. Het biedt kerntechnologie, vereenvoudigt de ontwikkeling en geeft de game vaak de mogelijkheid om op meerdere platforms te draaien, zoals spelconsoles en bureaublad besturingssystemen bijv. GNU/Linux, Mac OS X en Microsoft Windows.
Wiki-link

- Dus... Dus, alleen een paar lessen schrijven is niet genoeg?!

Goede motoren (UE, Unity, Cocos2D) bestaan ​​uit een paar honderd klassen, verschillende subsystemen en een aantal managers. Om specifieker te zijn:

• Grafisch systeem
• Geluidssysteem
• Netwerksysteem
• Procesmanager
• Taakbeheer
• Objectbeheerder
• Scènemanager

en nog veel meer...

Dus wat moeten we doen? Hoe, wat en waar?

Het allereerste en belangrijkste is verdelen grote taak in kleinere en ga stap voor stap. Kleine, onzekere, slakachtige stapjes.

Volgorde van artikelen:

Tags: game-engine, gamedev, c++, architectuur,

Enige tijd geleden hebben we het onderwerp van het maken van computerspellen besproken en gesproken over een unieke gratis 3D-engine die erin is geschreven Delphi - GLScene(neem de motor van onze CD/DVD ). Het onderwerp van het maken van volwaardige driedimensionale computerspellen was erg interessant voor je, zoals te zien was aan de hand van het aantal ontvangen brieven. Toen besloten we echter dat praten over motorprogrammering te moeilijk was. Sindsdien is je niveau merkbaar gestegen (dit kun je ook beoordelen aan de hand van brieven en activiteit op het tijdschriftforum), je bent vaardiger geworden in programmeerproblemen. Zeker na de publicatie van de serie “ Programmeurskast”.
Met dit nummer beginnen we met het publiceren van een reeks artikelen waarin we in detail zullen kijken naar de verschillende stadia van het maken van een 3D-game. Je verbetert je programmeervaardigheden en kijkt, zoals ze zeggen, achter de sluier van geheimhouding die serieuze game-ontwikkelaars scheidt van gewone stervelingen.
De motor van elk spel bestaat uit vele en vaak onafhankelijke bouwstenen: botsingsbeheersing, fysiek model, spelinterface, hoofdmenu, laadniveaus en nog veel meer. Er zijn specifieke stenendie slechts voor één genre nodig zijn. De weermodule is bijvoorbeeld belangrijk en nodig in een luchtvaart- of maritieme simulator, maar in een real-time strategie is deze secundair of helemaal niet nodig, en in een voetbalsimulator is er geen geweerschotmodule nodig. Maar in elk spel zijn enkele tientallen stenen aanwezig. In een reeks artikelen zullen we over elk van deze bouwstenen praten, laten zien hoe ze worden geïmplementeerd en hoe we ze met de andere kunnen verbinden. Aan het einde van de cyclus kun je deze stenen gebruiken om je eigen computerspel van een redelijk hoog niveau te bouwen.

Wat doe jij hier?
Voor degenen die enkele van mijn eerdere artikelen (of zelfs allemaal) hebben gemist, zal ik al uw vragen beantwoorden. Om zo te zeggen een kleine technische introductie.
Waarom Delphi? Deze ontwikkelomgeving en programmeertaal Voorwerp Pascal flexibel genoeg om een ​​compleet geheel te creëren 3D-spel bijna elk genre met een modern grafisch niveau. Velen zouden beweren dat dit de de facto standaard voor de ontwikkeling van computerspellen is MSVC++ of op andere media gebaseerde C++. Maar zulke normen ontstaan, zoals vaak gebeurt, spontaan. Laten we twee concepten niet verwarren: taal en ontwikkelomgeving.
C++ is absoluut krachtiger dan Object Pascal. Maar het is ook minder hoogstaand, dat wil zeggen vele malen moeilijker. C++ is niet geschikt voor beginners. Object Pascal is niet alleen eenvoudig, maar ook flexibel genoeg om er een volwaardig modern computerspel mee te ontwikkelen. Nu over woensdag. Dat kun je hier niet categorisch zeggen. Ontwikkelomgeving- een kwestie van smaak en gewoonte van elke individuele programmeur. Ik zal mijn mening over deze kwestie delen. MSVC++ genereert iets meer snelle code dan Delphi. Eigenlijk eindigen hier de voordelen (ik herhaal, naar mijn subjectieve en niet-bindende mening). Delphi overtroeft - hoge snelheid compilatie (tientallen en zelfs honderden keren sneller dan MSVC++), hoge kwaliteit foutopsporingstools (in de meeste gevallen geeft Delphi precies de coderegel aan die de fout bevat, terwijl MSVC++ de regel kan aangeven op meerdere pagina's verwijderd van degene die u zoekt) en gebruiksvriendelijke interface.
Waarom GLScene? Ik heb veel gratis 3D-engines gezien en geprobeerd, maar ik heb voor deze gekozen. Het belangrijkste voordeel is dat GLScene voortdurend wordt verbeterd. De ontwikkelaars hebben er geen einde aan gemaakt en zullen dat hoogstwaarschijnlijk ook nooit doen. De motor evolueert voortdurend en absorbeert de nieuwste technische vooruitgang. Dit is de enige gratis engine die ik ken en waarvan ze nooit ‘verouderd’ zullen zeggen. Enkele honderden enthousiastelingen die voortdurend aan de "motor" werken, zullen dit niet toestaan. Als voorbeeld: ondersteuning voor de allereerste shaders verscheen slechts een paar maanden later in de engine NVidia het betreffende uitgegeven hulpmiddelen.
Nog een voordeel: GLScene wordt geleverd met alle bronnen. Voor beginners is dit feit waarschijnlijk niet nuttig. Al is het veel waard om kennis te maken met de door een professional geschreven broncode. Maar ervaren programmeurs voelen de belangrijkste betekenis van deze woorden: ze zullen de engine tenslotte naar eigen inzicht kunnen herontwerpen.naar believen. De enige voorwaarde volgens de MPL-licentie is dat eventuele wijzigingen in de broncode beschikbaar moeten zijn voor de projectcoördinator (momenteel is de coördinator Erik Grange). Wat als uw code nuttig is voor iemand anders?!
Hoewel alle codevoorbeelden die in deze serie artikelen worden gegeven, in Delphi zullen worden geschreven met behulp van GLScene, zullen ze ook nuttig zijn voor degenen die in andere talen en met andere grafische bibliotheken programmeren. Tenslotte algemene principes De creatie van een grafische engine is niet afhankelijk van het een of het ander. Dus... we beginnen.

Waarom heb je een 3D-engine nodig?
Mede-nieuwkomers, concentreer je! Misschien zal wat ik nu zeg de eerste keer niet zo duidelijk zijn. Zorg ervoor dat je het opnieuw leest en begrijpt: dit is een van de basisprincipes van programmeren in het algemeen en de ontwikkeling van complexe systemen (en een spel is complex systeem) in het bijzonder. Stel je een eenvoudig spel voor. Pingpong bijvoorbeeld. De programmeur schreef het in puur OpenGL, passen de broncodes in ongeveer 200 regels. Wat zal de engine zijn en wat zal de hoofdcode van het spel zijn? Je kunt het niet meteen zeggen... Maar als je erover nadenkt, is zo'n opdeling in de engine en de hoofdcode helemaal niet nodig.
Stel je nu voor dat we een min of meer serieuze 3D-actie willen maken (tienduizenden regels code). En we zullen op dezelfde manier programmeren alsof we dezelfde pingpong zouden doen. En binnenkort raken we in de war! Ja, deze code zal dat doensnel, er is niets overbodigs, maar... niet elke programmeur zal het tot het einde kunnen voltooien. En de fouten in zulke compacte codezoeken is pure hel. Dit betekent dat het op de een of andere manier moet worden gesorteerd. De eenvoudigste manier om dit te doen is met het benadrukken van abstractieniveaus.
Abstractieniveau is een van de belangrijkste concepten modulair programmeren. Stel je voor dat je een bouwer bent en een huis moet bouwen. Je werkt met stenen: neem een ​​steen, plaats deze op de muur in aanbouw, verdeel deze met mortel, neem de volgende steen... Bakstenen zijn jouw abstractieniveau. Stel je nu voor dat je een ontwikkelaar bent. En je moet een microdistrict bouwen. Je vertelt de bouwer waar hij huizen moet bouwen en welke huizen hij moet afbreken. Thuis is jouw abstractieniveau. Het zou vreemd zijn als je een bouwer zou vertellen welke steen hij waar moest plaatsen. Je zei: hier komt het huis. De bouwer zorgt voor alle andere zorgen. Stel je nu voor dat je de burgemeester van een stad bent. En je moet de menigte ontwikkelaars de taak geven om de stad tegen dat en dat jaar zoveel nieuwe woningen te geven. Het is onwaarschijnlijk dat u persoonlijk zult plannen waar elk huis moet komen. Dit is de taak van de ontwikkelaar. Het abstractieniveau van de burgemeester is de omvang van de woningvoorraad, die kan worden vergroot of verkleind, maar hoe dit zal worden bereikt is een andere zaak. Over het algemeen maakt het op dit abstractieniveau niet uit waar huizen van zijn gebouwd: of het nu bakstenen zijn of gigantische slagtanden. En de burgemeester kan dat simpelweg niet hebben.” een baksteen leggen”, hoewel al zijn commando's hiertoe via verschillende abstractieniveaus zullen leiden.
In een min of meer complexe situatie computerprogramma of een spel - hetzelfde. Elk abstractieniveau is verantwoordelijk voor zijn deel van het werk en vertrouwt op de mogelijkheden van meer laag niveau. Elk abstractieniveau biedt mogelijkhedenHandige interface op een hoger niveau voor het werken met objecten. In een computerspel lager niveau abstracties zijn programmeertaal (hoewel je in feite nog dieper kunt graven - naar de hardware). Hierna volgen de commando's OpenGL-API(als we ermee programmeren). Op dit niveau kunnen we een commando geven als “ teken een veelhoek" En " verwissel de zichtbare en schaduwgedeelten van de videobuffer" Dan - de teams GLScene. Op dit niveau kunnen we opdrachten geven als “ bouw een kubus”, “download het model in 3ds-formaat" En " pas die en die textuur op het model toe" En dit is het volgende: game-engine. En tot slot spelcode die de game-engine opdrachten kan geven zoals “ laadniveau”, “schiet dat en dat personage neer met dat en dat wapen" En " laat een introductievideo zien" Idealiter gebruikt elk abstractieniveau alleen de commando's van het vorige niveau. Dit is niet altijd mogelijk. Maar we moeten hiernaar streven, omdat in dit geval de code snel, gemakkelijk en gemakkelijk te lezen zal zijn.

Dynamische creatie van objecten
We keken naar de verticale organisatie van een computerspel. Maar elk abstractieniveau kan worden onderverdeeld in semantische blokken - modules. Deze verdeling is optioneel en zal altijd puur voorwaardelijk zijn, het is gewoon eenvoudiger om op deze manier te programmeren. Vandaag zullen we een kleine maar zeer belangrijke bouwsteen analyseren: dynamische creatie objecten, die zonder uitzondering in alle games aanwezig zijn.
Stel dat u een wapenmodule aan het maken bent en er een uitbarsting van wilt programmerenmachinegeweer. Alles zou in orde zijn, maar hoe weet je hoeveel kogels een speler in het hele spel kan afvuren? U kunt alle objecten maken met behulp van de objecteditor in de GLScene IDE, maar alleen als u duidelijk weet hoeveel en welke objecten u nodig heeft. In de meeste gevallen is dit onaanvaardbaar. Je hebt bijvoorbeeld 20 niveaus in je spel, elk niveau heeft zijn eigen set objecten. Moeten we dus alle objecten van alle niveaus maken voordat we het spel starten? Dit zal lang duren en een enorme hoeveelheid geheugen in beslag nemen. De enige uitweg- creëer objecten direct tijdens het spel, dynamisch. In GLScene bestaat de dynamische creatie van elk object uit twee fasen: het creëren van een instantie van de klasse van dit object en het toewijzen van de noodzakelijke eigenschappen eraan. Laten we het reeds genoemde voorbeeld van machinegeweeruitbarstingen nemen en dynamisch een kogel creëren. Laten we aannemen dat onze kogel een industriële sfeer zal zijn. De klasse die verantwoordelijk is voor sferen in GLScene is TGLSfere. Het lijkt erop dat je het zo zou kunnen schrijven:
Bol:=TGLSphere.Create
Het commando zal echter niet werken, omdat elk object in GLScene in de objectwachtrij moet worden geregistreerd. Bovendien kan een object niet in een “leegte” worden gemaakt; het moet aan een object op een hoger niveau worden gebonden. Het hoofdobject op het hoogste niveau is glscene1.Objects (als uw TGLScene-componentobject glscene1 heet). Juiste optie:
Bol:=TGLSphere (glscene1.Objects.AddNewChild(TGLSphere))
Laten we deze regel stukje bij beetje bekijken. Bij het hoofdobject glscene1.Objecten we noemen de methode NieuwKind toevoegen, die aan de root het object toevoegt van de klasse die is opgegeven in de parameter (in in dit geval dit is de bol -TGLSfere). Dit is ook mogelijk: geen objecten, maar hele klassen als parameters doorgeven aan procedures. Waarom is een typeconversie nodig vóór toewijzing? TGLSfere? Het punt is dat de methode NieuwKind toevoegen, ongeacht wat u eraan als parameter doorgeeft, retourneert een object van de klasse TGLBaseSceneObject. Dit bevalt ons niet, daarom converteren we het type naar TGLSphere. Het resulterende object wordt toegewezen aan de Sphere-variabele. Met behulp van deze variabele kunnen we nu onze pool instellen verschillende parameters bijvoorbeeld positie in de ruimte:
Bol.Positie.X:=
Bol.Positie.Y:=
Bol.Positie.Z:=
Of kleur:
Sphere.Material.FrontProperties.Diffuse=
We hebben de dynamische creatie van modellen besproken, en laten we het nu hebben over hun dynamische vernietiging. Sterker nog, op een dag raakt een kogel een muur of een persoon, of vliegt weg in de blauwe verte. Vanaf nu is het niet meer nodig. Als we het zo laten, zal het een bepaald geheugengebied in beslag nemen. Als je bedenkt hoeveel schoten de gemiddelde kampeerder afvuurt voordat zijn gat wordt ontdekt, hebben we niet genoeg computergeheugen om zoveel kogels op te slaan. Daarom moeten alle overbodig geworden spelobjecten onmiddellijk worden vernietigd. De enige de juiste manier Om dit te doen, moet u de methode aanroepen Vrij, Bijvoorbeeld:
Bol.Gratis
Vaak is het nodig om te controleren of een object bestaat of al vernietigd is. Om dit te doen vergelijken we het object met de universele constante nul - nul, Bijvoorbeeld:
Als Bol<>nul dan
Beginnen
(de bol is nog niet vernietigd, Dus we doen hier iets nuttigs)
Einde
Of we noemen de functie Toegewezen, die hetzelfde doet. En hier wacht je een gigantische valkuil, die alle programmeurs vroeg of laat tegenkomen. Als u het object hebt bevrijd met behulp van de methode Vrij, garandeert dit niet dat de objectvariabele gelijk is geworden aan nul! Dat wil zeggen dat onder bepaalde omstandigheden in het bovenstaande voorbeeld, zelfs als de bol wordt vernietigd, aan de voorwaarde zal worden voldaan. Als u na controle in staat bent om met dit gebied om te gaan (en dit gebeurt bijna altijd), zal dit gebeuren kritische fout, wat ertoe kan leiden dat het spel crasht. Gebruik een speciale procedure om ervoor te zorgen dat het bevrijde object nul wordt GratisEnNul, Bijvoorbeeld:
VrijEnNil(Bol)
Nu kunt u er zeker van zijn dat u nooit toegang krijgt tot een object dat niet meer bestaat. De beschreven procedure voor het maken en vernietigen van objecten kan op alle GLScene-objecten worden toegepast.

Waarom hebben games een batterij nodig?
Beschouw het bovenstaande voorbeeld met een machinegeweer. Meestal zijn kogels in games niet alleen maar bollen, maar complexe objecten, die ook een textuur hebben. Elke keer dat u een kogel maakt, wordt er een stukje geheugen vrijgemaakt tijdens de installatie eigenschappen van deze kogel, het kogelmodel wordt geladen, de textuur wordt geladen (vanaf de harde schijf!). Alles wat nodig is bepaalde tijd. Als het aantal kogels dat een machinegeweer per seconde afvuurt erg groot is, kunnen wilde remmen beginnen, vooral op zwakke computers. Er is hetzelfde probleem met het vernietigen van kogels:je moet het object uitladen, geheugen vrijmaken... Hetzelfde geldt niet alleen voor kogels, maar ook voor objecten die vaak verschijnen en verdwijnen, bijvoorbeeld regendruppels, vonken van elektrische bedrading... Wat een verspilling systeembronnen onaanvaardbaar in computerspellen. Je wilt toch niet dat je game alleen op een supercool grafisch station kan draaien?
De oplossing is eenvoudig. Laten we schatten hoeveel van dit soort objecten er gemiddeld tegelijkertijd kunnen bestaan. Laten we zeggen dat een machinegeweer in tien seconden honderden kogels kan afvuren, en in dezelfde tien seconden zullen de kogels het doel zeker bereiken. Voordat het spel begint, maken we alle honderd kogels. De beste tijd om dit te doen is tijdens het laden van het level. Niemand zal een kleine vertraging merken. Vervolgens worden de kogels in een lijst of array geplaatst, die we noemen batterij. Wij maken kogels onzichtbaar of brengen ze ergens buiten de speelruimte. Zodra het machinegeweer begint te schieten, verplaatsen we in plaats van kogels te maken, de reeds gemaakte kogels van de batterij naar de gewenste locatie en maken ze zichtbaar. Zodra de kogel het doel bereikt, vernietigen we hem niet, maar maken we hem weer onzichtbaar en plaatsen hem in de batterij. Als gevolg hiervan besparen we voor elke kogel creatietijd en vernietigingstijd. En dit is heel erg veel! Wat als we een beetje verkeerd waren in onze schattingen, de kogels in de batterij raakten op, maar het machinegeweer bleef vuren? Je kunt er niets aan doen: je zult dynamisch nieuwe kogels moeten maken totdat de oude terugkeren naar de batterij. En nieuwe kogels gaan we ook niet kapot, maar bewaren we in de batterij voor het geval we ze weer nodig hebben...

Aanval van de klonen
Laten we een groot bos hebben waarin heel veel identieke bomen staan, of bijvoorbeeld veel bomen met meerdere verschillende soorten. Het voorbeeld is vergelijkbaar met het vorige, alleen creëren of vernietigen we hier niet dynamisch iets - op dit niveau zijn er altijd bomen. Er zal een probleem optreden bij het laden van het niveau. Het zal lang duren om zoveel bomen te maken. Maar ze zijn allemaal hetzelfde! Dat wil zeggen, we laden keer op keer vanaf de harde schijf en maken kopieën van hetzelfde in het geheugen. Geladen. Laten we spelen. Voordat elke boom wordt weergegeven, worden voorbereidende procedures uitgevoerd. Voor elke boom zullen ze hetzelfde zijn, maar we zullen ze opnieuw noemen groot aantal maal het aantal bomen! Het blijkt verspilling. En voor elke boom moet geheugen worden gereserveerd, en het verwerken ervan kost tijd.
Het zou leuk zijn om één enkele boom te laden, en wanneer u de rest van de bomen op het scherm wilt weergeven, hoeft u alleen maar aan de grafische bibliotheek te laten zien waar u de benodigde gegevens vandaan kunt halen. Wat een besparing in middelen, wat een toename in FPS! Dergelijke "valse" bomen (en niet alleen bomen - wat dan ook), waarover alleen privé-informatie(positie in de ruimte, rotatiehoeken), en dezelfde informatie wordt slechts één keer opgeslagen, worden opgeroepen proxy-objecten.
In GLScene is er een speciale klasse voor het maken van proxy-objecten - TGLProxyObject. Het is heel gemakkelijk te gebruiken. Eerst maken we een bronobject, dat wil zeggen een enkele boom, bijvoorbeeld als volgt:
Boom:=TGLFreeFrom(glscene1.objects.AddNewChild(TGLFreeFrom));
//Laden zijn model:
Boom.LoadFromFile('Boom.3ds');
// Laad de textuur:
Tree.Material.Texture.Disabled:=false;
Boom.Material.Texture.Image,LoadFromFile('boom.jpg');
//Laten we nu tien kloonbomen op willekeurige plaatsen maken:
want i:=1 tot en met 10 beginnen wel
//Maak nog een proxyobject
proxy:=TGLProxyObject(glscene1.objects.AddNewChild(TGLProxyObject));
met proxy beginnen
//Schrijf onze voorbeeldboom naar de eigenschap MasterObject
MasterObject:=Boom;
// Laat zien dat alleen de structuur van het object moet worden overgenomen
ProxyOpties:=;
//De oriëntatie van de boom in de ruimte moet ongewijzigd blijven
Richting:= Boomrichting;
Omhoog:= Boom.Omhoog;
//Maar we hebben de positie willekeurig ingesteld
Positie.X:=Willekeurig(100);
Positie.Y:=Willekeurig(100);
//En draai de boom in een willekeurige hoek om hem er beter uit te laten zien
Rolhoek:=Willekeurig(360);
einde;
einde;
Nu hebben we een tiental bomen voor de prijs van één. Houd er rekening mee dat als we het originele object op welke manier dan ook wijzigen, deze wijziging onmiddellijk van invloed is op alle kloonobjecten.

* * *
We hadden het over de eerste steen. In de volgende artikelen geven we je een vrachtwagen vol met deze stenen, waarmee je de 3D-game-engine van je dromen kunt bouwen. Om het u gemakkelijker te maken, hebben we de nieuwste geteste versie op de compact gezet GLScene.

Doe-het-zelf website-engine. Optie één: als u geen database heeft...

Elke websitebouwer merkt op een gegeven moment ineens dat hij niet meer zozeer bezig is met het voorbereiden van nieuwe materialen voor zijn website, maar eerder met banale en routinematige zaken: hij heeft het menu uitgezocht, vervangen; Ik heb het daar opgeslagen en bijgewerkt; hier - kopiëren, daar - plakken, en vervolgens opslaan en uploaden. “Nou nee”, denkt de webmaster, “dit kan niet meer gebeuren! Maar wat te doen? En je moet een engine voor de site maken...

Dit artikel is het eerste van een reeks artikelen die ik heb gepland, waarin we zullen proberen zoiets als een engine voor eenvoudige websites te maken. We zullen ook de principes bekijken van het scheiden van website-inhoud van het ontwerp (ontwerp) en manieren om het werk van de webmaster te automatiseren.

Een engine wordt meestal een set scripts en programma's genoemd op basis waarvan een website wordt onderhouden, leeft en wordt bijgewerkt. De engine kan een eenvoudig PHP-script zijn waarin artikelen zijn opgeslagen tekstbestanden een bepaald formaat en een complex complex software in combinatie met databases (MySQL, Oracle, etc.) en webservices geschreven in Java.

De beste (maar niet de moeilijkste) optie zou het gebruik van databases zijn. Maar meestal is de database niet beschikbaar voor webmasters, omdat deze (voor zover ik weet) alleen op betaalde hostingsites wordt aangeboden. Daarom zullen we onze eerste motor organiseren op PHP-hulp en een set bestanden. Tegelijkertijd kunnen we onszelf troosten met het feit dat de prestaties van onze site niet zullen worden beïnvloed door extra risicofactoren die worden geïntroduceerd door het gebruik van databases (iedereen heeft, geloof ik, al gehoord van het verhaal met het gat in Microsoft SQL-server 2000) (1).

Onze engine zal speciaal worden aangepast voor inhoudsprojecten (dat wil zeggen sites die regelmatig worden bijgewerkt met originele artikelen of ander materiaal). Dit betekent dat we er alles aan zullen moeten doen om de inhoud van de site gemakkelijk en snel te actualiseren.

We moeten dus eerst een aantal functies definiëren voor het lezen van gegevens uit een bestand. Voor het brengen broncodes, laten we eens kijken naar de tools die we hebben (of beter gezegd, in PHP) voor het werken met bestanden (en degenen die er niet van op de hoogte zijn, zullen er meteen achter komen).

Functies voor het lezen van bestanden in PHP.

... $strings = file("mijnmap/mijnbestand.txt"); $eerste_string = $strings; ...

Laten we onze eigen zelfgemaakte database maken. Daarvoor hebben we in de eerste plaats de volgende functies nodig: één voor het lezen van de pagina-inhoud (bijvoorbeeld de tekst van een artikel) van extern bestand- gegevens laden; een functie voor het laden van een sjabloon uit een bestand - dat wil zeggen het laden van een ontwerp (ontwerp).

functie loadTemplate($pad) /* functie laadt de sjabloon op het opgegeven pad, en retourneert het als een tekenreeks, bijvoorbeeld voor verwerking door de functie parceTemplate() */ { $template = fopen($path, "r") or print("Kan sjabloonbestand niet laden [".$path."]"); Als ($sjabloon) return fread($template, bestandsgrootte($pad)); anders retour vals; Fclose($sjabloon); } Functie parceTemplate($template, $params_values) /* functie parseert het opgegeven patroon, het vervangen van de namen van parameters die als indices dienen array $params_values ​​met hun waarden*/ { terwijl (lijst($param, $value) = elke($params_values)) { $template = str_replace("¤(".$param.")¤", $value, $template); } Retourneer $sjabloon; } Functie read Article($path) /* functie leest opgegeven bestand en keert terug de inhoud ervan in de vorm van een reeks artikelonderdelen, gescheiden door de constructie ¤(onderdeelnaam)¤ */ { $article = fopen($path, "r") or print("Kan artikelbestand [.$path."]" niet laden; Als ($artikel) { $astring = fread($artikel, bestandsgrootte($pad)); $result = split("[¤](1)[(](1)([ a-z_-]*)[)](1)[¤](1)", $astring); $result = eregi_replace("[ ,]*([ - ](1))[, ]*", " - ", $result); $resultaat = basisnaam($pad); retourneer $resultaat; } anders { retour vals; } }

Ergens hier hadden we een granieten plaat moeten vastschroeven met het opschrift "Regelmatige uitingen van dankbare fans", want zonder dit handige ding zou het erg moeilijk zijn om de bovenstaande functies te creëren. Laten we eens nader bekijken hoe deze uitdrukkingen zijn gestructureerd.

Het heeft geen zin om meerdere keren over hetzelfde te schrijven, dus citeer ik een van de artikelen over reguliere expressies (bron: http://sitemaker.ru/):

Reguliere expressies.

Een beetje geschiedenis.

Wiskundige Stephen Klin introduceerde reguliere expressies voor het eerst in 1956, als resultaat van zijn werk met recursieve sets in natuurlijke taal. Ze zijn gemaakt als syntactische sets die worden gebruikt om patronen in strings te matchen, wat later hielp bij het verkrijgen van toegang tot opkomende technologische informatie, waardoor automatisering werd vergemakkelijkt.

Sindsdien hebben reguliere expressies vele iteraties ondergaan, en de huidige standaard wordt onderhouden door de ISO (International Organization for Standardization) en gedefinieerd door de Open Group, een gezamenlijke inspanning van verschillende technische non-profitorganisaties (2).

Karaktermatching.

Moeilijkheidsgraad reguliere expressies is waar je naar wilt zoeken of waar het bij moet passen. Zonder dit concept zijn hernieuwbare energiebronnen nutteloos. Elke expressie bevat een opdracht over waar u op moet letten:

Karaktermatching in reguliere expressies

Exploitant	Beschrijving	Voorbeeld	Resultaat
.	Komt overeen met elk karakter	.ord	Komt overeen met "ford", "lord", "2ord", enz. in het voorbeeld.txt-bestand.
	Komt overeen met elk afzonderlijk teken tussen vierkante haakjes	ord	Komt alleen overeen met "cord", "nord" en "gord"
[^]	Komt overeen met elk afzonderlijk teken dat niet tussen vierkante haken staat	[^cn]orde	Komt overeen met "lord", "2ord", enz., maar niet met "cord" of "nord"
	Komt overeen met elke letter	ord	Komt overeen met "aord", "bord", "Aord", "Bord", enz.
[^0-9]	Komt overeen met elk niet-cijfer in het bereik 0-9	[^0-9]ord	Komt overeen met "Aord", "aord", enz., maar niet met "2ord", enz.

Herhalingsoperatoren.

Herhaaloperatoren, of kwantoren, beschrijven hoe vaak een opgegeven string moet worden doorzocht. Ze worden gebruikt in combinatie met de syntaxis voor het matchen van tekens om te zoeken naar meerdere exemplaren van tekens. IN diverse toepassingen hun ondersteuning kan veranderen of onvolledig zijn. Lees daarom de applicatiedocumentatie als de sjabloon niet werkt zoals verwacht.

Herhaaloperatoren in reguliere expressies

Exploitant	Beschrijving	Voorbeeld	Resultaat
?	Komt één keer overeen met een specifiek teken als het bestaat	?erd	Komt overeen met "berd", "kudde", enz. en "erd"
*	Komt meerdere keren overeen met een specifiek karakter als het bestaat	z.*rd	Komt overeen met "nerd", "nrd", "neard", enz.
+	Komt één of meerdere keren overeen met een specifiek personage	[n]+erd	Komt overeen met "nerd", "nnerd", enz., maar niet met "erd"
(N)	Komt precies n keer overeen met een specifiek teken	(2)erd	Komt overeen met "cherd", "blerd", enz., maar niet met "nerd", "erd", "buzzerd", enz.
(N,)	Komt minstens n keer overeen met een specifiek karakter	.(2,)erd	Komt overeen met "cherd" en "buzzerd", maar niet met "nerd"
(n,N)	Komt minstens n keer overeen met een specifiek karakter, maar niet meer dan N keer	n[e](1,2)rd	Komt overeen met "nerd" en "neerd"

Ankers beschrijven waar een patroon moet passen. Ze kunnen handig zijn als u op zoek bent naar veelgebruikte snarencombinaties.

Ankers voor reguliere expressies

Exploitant	Beschrijving	Voorbeeld	Resultaat
^	Komt overeen met het begin van een tekenreeks	ereg_replace("^/", "blah")	Voegt "blah" in aan het begin van een regel
$	Komt overeen met het einde van de tekenreeks	ereg_replace("$/", "blah")	Voegt "blah" in aan het einde van de regel
\<	Komt overeen met het begin van een woord	ereg_replace("\<", "blah")	Voegt "blah" in aan het begin van een woord
		\	Komt overeen met "Blahfield" enz.
\>	Komt overeen met het einde van een woord	ereg_replace("\>", "blah")	Voegt 'blah' in aan het einde van een woord
		\>bla	Komt overeen met "soupblah" enz.
\B	Komt overeen met het begin of einde van een woord	\bblah	Komt overeen met "blahcake" en "countblah"
\B	Komt overeen met het midden van een woord	\Bbla	Komt overeen met "sublahper", enz.

(einde citaat, bron van beschrijving: http://sitemaker.ru/)

Dus laten we doorgaan. De functies die we hebben gemaakt zijn handig voor het lezen van artikelen uit bestanden en het weergeven van een lijst met de nieuwste artikelen. Om dit allemaal te wijzigen, hoeven we bovendien alleen maar te schrijven nieuw artikel als een bestand met een bepaalde syntaxis (zie hieronder) en voeg het toe aan een map op de server.

De symbolen ¤( en )¤ worden gebruikt om onderdelen van elkaar te scheiden. De naam van het onderdeel heeft geen betekenis en kan een willekeurige reeks tekens uit het Engelse alfabet, spatie, onderstrepingsteken of koppelteken zijn.

Om een ​​lijst met artikelen weer te geven, wordt een lus gebruikt die door alle bestanden loopt de gewenste map. Als hij een *.art-bestand tegenkomt, voegt hij dit onmiddellijk toe aan de array om dit te vieren. Afhankelijk van opgegeven parameter, kan hij de naam van dit bestand toevoegen, of de titel van het artikel dat het bevat, of meteen een kant-en-klare link naar dit artikel.

Goed, klein deel Er is al aan onze motor gewerkt. Dit stukje code is de basis van onze eerste engine. Voor specifieke doeleinden moet u er extra functies aan toevoegen en de teksten en paginasjablonen zelf maken.

Een zelfgemaakte motor kan op verschillende manieren worden gemaakt. Laten we de recensie beginnen met de bipolaire of stappenmotorversie, een elektromotor met een dubbele pool zonder borstels. Het heeft kracht gelijkstroom, verdeelt een volledige revolutie in gelijke delen. Om dit apparaat te bedienen heeft u een speciale controller nodig. Bovendien omvat het ontwerp van het apparaat een wikkeling, magnetische elementen, zenders, signaalgevers en een besturingseenheid met een instrumentenpaneel. Het hoofddoel van de eenheid is het uitrusten van frees- en slijpmachines, en het garanderen van de werking van verschillende huishoudelijke, industriële en transportmechanismen.

Motortypes

Een zelfgemaakte motor kan verschillende configuraties hebben. Onder hen:

• Opties met permanente magneet.
• Gecombineerd synchroon model.
• Variabele motor.

De permanente magneetaandrijving is voorzien van een hoofdelement in het rotorgedeelte. De werking van dergelijke apparaten is gebaseerd op het principe van aantrekking of afstoting tussen de stator en de rotor van het apparaat. Deze stappenmotor is voorzien van een rotordeel van ijzer. Het principe van de werking ervan is fundamentele basis, volgens welke de maximaal toegestane afstoting wordt uitgevoerd met een minimale opening. Dit bevordert de aantrekkingskracht van de rotorpunten op de statorpolen. Combinatieapparaten combineren beide parameters.

Een andere optie zijn tweefasige stappenmotoren. Het apparaat heeft een eenvoudig ontwerp, kan twee soorten wikkelingen hebben en is eenvoudig op de gewenste locatie te installeren.

Monopolaire modificaties

Een zelfgemaakte motor van dit type bestaat uit een enkele wikkeling en een centrale magneetaftakking die alle fasen beïnvloedt. Elke sectie van de wikkeling wordt geactiveerd om een ​​specifiek magnetisch veld te creëren. Omdat in een dergelijk circuit de pool kan functioneren zonder extra schakeling, heeft het schakelen van het pad en de richting van de stroom een ​​elementair apparaat. Voor een standaardmotor met gemiddeld vermogen is één transistor voldoende, aanwezig in de uitrusting van elke wikkeling. Een typisch tweefasig motorcircuit omvat zes draden op het uitgangssignaal en drie soortgelijke elementen op de fase.

De unit-microcontroller kan worden gebruikt om de transistor in een automatisch bepaalde volgorde te activeren. In dit geval worden de wikkelingen verbonden door de uitgangsdraden en een permanente magneet aan te sluiten. Wanneer de spoelaansluitingen op elkaar inwerken, wordt de as geblokkeerd voor rotatie. De weerstandswaarde tussen de gemeenschappelijke draad en het eindgedeelte van de spoel is evenredig met hetzelfde aspect tussen de uiteinden van de bedrading. In dit opzicht is de lengte van de gemeenschappelijke draad twee keer zo lang als de verbindingshelft van de spoel.

Bipolaire opties

Een zelfgemaakte stappenmotor van dit type is uitgerust met één fasewikkeling. De stroom erin wordt op een draaiende manier uitgevoerd met behulp van een magnetische pool, wat de complicatie van het circuit veroorzaakt. Het aggregeert meestal met een verbindingsbrug. Er zijn een paar extra draden die niet gebruikelijk zijn. Wanneer het signaal van een dergelijke motor op hogere frequenties wordt gemengd, neemt de wrijvingsefficiëntie van het systeem af.

Er worden ook driefasige analogen met een beperkte specialisatie gecreëerd. Ze worden gebruikt bij het ontwerp van CNC-machines, maar ook in sommige boordcomputers en printers in de auto-industrie.

Ontwerp en werkingsprincipe

Wanneer spanning naar de klemmen wordt overgebracht, worden de motorborstels continu in rotatie gebracht. Installatie aan stationair is uniek omdat het binnenkomende pulsen omzet naar een vooraf bepaalde positie van de bestaande aandrijfas.

Elk pulssignaal werkt onder een specifieke hoek op de as. Een dergelijke tandwielkast is het meest effectief als een reeks magnetische tanden rond een centrale getande ijzeren staaf of een equivalent daarvan wordt geplaatst. De elektrische magneten worden geactiveerd door een extern regelcircuit bestaande uit een microregelaar. Om de motoras te laten draaien, trekt één actieve elektromagneet de tanden van het wiel naar het oppervlak. Wanneer ze zijn uitgelijnd met het leidende element, bewegen ze iets naar het volgende magnetische deel.

Bij een stappenmotor moet de eerste magneet worden ingeschakeld en het volgende element worden gedeactiveerd. Als gevolg hiervan begint het tandwiel te draaien en wordt het geleidelijk op één lijn gebracht met het vorige wiel. Het proces wordt afwisselend het vereiste aantal keren herhaald. Dergelijke revoluties worden ‘constante stappen’ genoemd. De rotatiesnelheid van de motor kan worden bepaald door het aantal stappen te tellen voor een volledige rotatie van de unit.

Verbinding

De aansluiting van een zelf gemaakte minimotor wordt volgens een bepaald schema uitgevoerd. De belangrijkste aandacht wordt besteed aan het aantal aandrijfdraden, evenals aan het doel van het apparaat. Stappenmotoren kunnen worden voorzien van 4, 5, 6 of 8 draden. De aanpassing met vier bedradingselementen kan uitsluitend worden gebruikt met een bipolair apparaat. Elke fasewikkeling heeft twee draden. Voor het bepalen van de benodigde aansluitlengte in stap voor stap modus Het wordt aanbevolen om een ​​gewone meter te gebruiken, waarmee u de vereiste parameter nauwkeurig kunt instellen.

De krachtige zesdraadsmotor heeft voor elke wikkeling een paar draden en een centreeraftakking die kan worden aangesloten op mono of bipolair apparaat. Voor aggregatie met een enkel apparaat worden alle zes draden gebruikt, en voor een gepaarde analoog zijn één uiteinde van de draad en de centrale aftakking van elke wikkeling voldoende.

met je eigen handen?

Om een ​​basismotor te maken heb je een stuk magneet, een boor, fluorkunststof, koperdraad, een microchip en een draad nodig. In plaats van een magneet kunt u een onnodige trilwaarschuwing voor uw mobiele telefoon gebruiken.

Als rotatieonderdeel wordt een boormachine gebruikt, omdat het gereedschap daar optimaal geschikt voor is technische parameters. Als de binnenradius van de magneet niet overeenkomt met hetzelfde aspect van de as, kan koperdraad worden gebruikt, zo gewikkeld dat de speling van de as wordt geëlimineerd. Deze handeling maakt het mogelijk om de diameter van de as op het verbindingspunt met de rotor te vergroten.

Bij de toekomstige creatie van een zelfgemaakte motor zul je bussen van fluorkunststof moeten maken. Neem hiervoor het voorbereide vel en maak een gat met een diameter van 3 mm. Bouw vervolgens de hulsbuis. De as moet worden geslepen tot een diameter die vrije beweging mogelijk maakt. Dit voorkomt onnodige wrijving.

Laatste fase

Vervolgens worden de spoelen gewikkeld. Het frame van de gewenste maat wordt in een taxus geklemd. Om 60 windingen te winden heb je 0,9 meter draad nodig. Na de procedure wordt de spoel behandeld met een kleefmiddelsamenstelling. Deze delicate procedure kan het beste worden uitgevoerd met een microscoop of vergrootglas. Na elke dubbele wikkeling wordt er een druppel lijm tussen de huls en de draad aangebracht. Eén rand van elke wikkeling is aan elkaar gesoldeerd, waardoor het mogelijk wordt om één enkele eenheid te verkrijgen met een paar uitgangen die aan de microchip zijn gesoldeerd.

Technische planparameters

Een doe-het-zelf-minimotor kan, afhankelijk van de ontwerpkenmerken, verschillende kenmerken hebben. Hieronder staan ​​​​de parameters van de meest populaire stapaanpassingen:

1. SD-1 - heeft een stap van 15 graden, heeft 4 fasen en een koppel van 40 Nt.
2. DSh-0,04 A - stap is 22,5 graden, aantal fasen - 4, snelheid - 100 Nt.
3. DSHI-200 - 1,8 graden; 4 fasen; 0,25 Nt koppel.
4. DSh-6 - 18/4/2300 (waarden worden aangegeven naar analogie met de vorige parameters).

Als je weet hoe je thuis een motor moet maken, moet je onthouden dat de snelheid van de koppelindicator van de stappenmotor zal transformeren in directe verhouding tot dezelfde huidige parameter. Reductie van lineair koppel met hoge snelheden hangt rechtstreeks af van het aandrijfcircuit en de inductantie van de wikkelingen. Motoren met beschermingsgraad IP 65 zijn ontworpen voor zware bedrijfsomstandigheden. Vergeleken met servers werken stepper-modellen veel langer en productiever en hebben ze geen extra apparatuur nodig frequente reparaties. Servomotoren hebben echter een iets andere focus, dus het vergelijken van deze typen heeft niet zoveel zin.

Een zelfgemaakte verbrandingsmotor maken

Je kunt ook met je eigen handen een motor maken met vloeibare brandstof. Hiervoor zijn geen complexe apparatuur of professionele gereedschappen nodig. De benodigde kan uit de brandstofpomp van een tractor of auto worden gehaald. De cilinder van de plunjerhuls wordt gemaakt door het verdikte element van de lus af te snijden. Maak dan gaten voor het uitlaat- en bypass-venster, soldeer een paar moeren in het bovenste gedeelte bedoeld voor de bougies. Elementtype - M-6. De zuiger wordt uit de plunjer gesneden.

Voor een zelfgemaakte dieselmotor is de installatie van een carter vereist. Het is gemaakt van tin met gesoldeerde lagers. Extra sterkte wordt gecreëerd door een met epoxyhars bedekt weefsel dat het element bedekt.

De krukas is samengesteld uit een dikke ring met een paar gaten. De as moet in een ervan worden gedrukt en de tweede buitenste mof wordt gebruikt voor het monteren van het tapeind met de drijfstang. De bewerking wordt ook uitgevoerd met behulp van de persmethode.

Laatste werkzaamheden aan het monteren van een zelfgemaakte dieselmotor

Hieronder vindt u de procedure voor het monteren van de bobine:

• Er wordt gebruik gemaakt van een onderdeel van een auto of motorfiets.
• Er is een geschikte bougie geïnstalleerd.
• Isolatoren zijn geïnstalleerd, bevestigd met epoxy.

Een alternatief voor een motor met een verbrandingsmotorsysteem kan een contactloze motor van het gesloten type zijn, waarvan het ontwerp en het werkingsprincipe een gasomkeersysteem is. Het bestaat uit een tweedelige kamer, een zuiger, een krukas, een transmissiekast en een ontstekingssysteem. Als u weet hoe u met uw eigen handen een motor kunt maken, kunt u veel besparen en een noodzakelijk en nuttig item voor uw huishouden krijgen.

Gemaakt van goedkope materialen. Deze keer zullen we kijken hoe we er een kunnen maken goede zaak zoals een Dremel of een boormachine. Met dit kleine maar multifunctionele gereedschap kun je graveren, boren, snijden, slijpen en nog veel meer. Dit apparaat werkt heel eenvoudig; het is in wezen een boormachine met een flexibele as, wat het werkproces erg handig maakt. De as is een kabel die in een speciale slang draait. Er worden verschillende motoren gebruikt.

Het zelfgemaakte product is geassembleerd op basis van de 775-motor; dit is een zeer populaire en betrouwbare motor voor het maken van verschillende thuismachines. Het is krachtig en heeft dwingend systeem koeling, er zit een ventilator in de behuizing. De auteur besloot reserveonderdelen te gebruiken voor sanitaire voorzieningen gemaakt van PVC als lichaam; het is goedkoop en betrouwbaar.

Gebruikte materialen en gereedschappen

Lijst met materialen:
- ;
- ;
- schakelaar;
- stopcontact voor het aansluiten van de voeding;
- draden;
- PVC-buis, plug en adapter (kegel);
- voeding 12V/6A;
- dubbelzijdig plakband;
- koppeling voor motor 775.

Lijst met hulpmiddelen:
- soldeerbout;
- schroevendraaier;
- ijzerzaag voor metaal;
- tang.

Dremel-productieproces:

Stap één. Het lichaam maken
De auteur besloot een stuk pijp als body te gebruiken. We snijden de benodigde lengte af en markeren vervolgens de plaatsen voor de ventilatieramen. Het is uiterst belangrijk om ze uit te voeren, omdat de motor anders oververhit raakt en snel uitvalt. De auteur snijdt ze uit met een ijzerzaag.

Stap twee. Productie achterkant
De auteur gebruikte een pijpplug als achteromslag. Het bevat een schakelaar en een connector voor het aansluiten van de voeding. We tekenen er installatievensters voor en snijden ze vervolgens uit met een gewone soldeerbout. Probeer geen dampen in te ademen, dit is niet gezond.

Nu moet u de schakelaar en connector op hun plaats installeren. Duw ze gewoon in de sleuven; ze zouden veilig moeten vergrendelen als de gaten de juiste diameter hebben.

Stap drie. We installeren de motor op zijn plaats
Je kunt de motor installeren. Voor zover ik het begrijp, bevestigt de auteur het met dubbelzijdig plakband of iets dergelijks. We omwikkelen de motor met tape, laten een rand achter zodat deze er later uit kan worden getrokken en installeren deze in de pijp. We trekken de bovenste afdekking van de tape eruit en de motor wordt stevig in de pijp bevestigd. Vergeet vóór de installatie niet de draden aan de motorcontacten te solderen.

Stap vier. Het solderen van de draden
Soldeer alle draden zoals de auteur deed. De stroom naar de motor komt van het stopcontact in de opening via de schakelaar. We monteren eindelijk de behuizing en proberen het apparaat aan te zetten. Draait de motor? Alles is in orde! Laten we verder gaan.

Stap vijf. Verbinding
De flexibele as is zeer eenvoudig aan te sluiten; eerst moet u de koppeling op de motoras bevestigen. Het is beveiligd met schroeven en een inbussleutel. Plaats een kegelvormig stuk PVC op de as en zet nu de tetraëdrische kabel vast in de koppeling. Plaats het kegelvormige deel op de behuizing en duw het buitenste deel van de as in de behuizing.

Stap zes. Laatste fase van assemblage en testen
We zullen de eindmontage van de Dremel voltooien met behulp van het vervaardigde apparaat. We moeten de flexibele as goed in de behuizing van het apparaat bevestigen. Om dit te doen, moet je gaten boren, het benodigde hulpstuk in onze Dremel installeren en proberen te boren, de auteur doet goed werk. Schroef de zelftappende schroeven in de gaten; de auteur heeft er 3.