Tehát az oldalnak csodálatos hálózata van. De benne csak néhány sort szentelnek a szerver indításának és konfigurálásának.
Megpróbálok segíteni azoknak a felhasználóknak, akik szeretnének játszani a helyi oldalon szerver barátaival és saját beállításaival. Ebben a rövid cikkben megpróbálom bemutatni a teljes folyamatot: a szerver telepítésétől a konfigurálásig, beleértve a modok használatát is.

1. Az első dolog, amit át kell váltanunk a Rust hálózaton keresztüli futtatására és Letöltés mindent tartalmazó archívum szükséges eszközöket, és csomagolja ki tetszőleges helyre.

2. Most menjünk tovább telepítés. Futtassa a fájlt Update-Rust-Server.bat mappából SteamCMDés várja meg, amíg a szerverünk letöltődik. A szerverek betöltődnek a RustServer mappába.

Minden, telepítettük a szervert, folytassa a következő lépésekkel.

3. Most fogunk indítsa el a szervert, szabja testre, és hívjon meg barátokat. A létrehozott szerverhez való csatlakozáshoz hajtsa végre a következő lépéseket:

megyek a mappához SteamCMDés futtassa a fájlt Run-Rust-Server.bat(Ő az, nem Rust_server). A kísérleti Rust-kiszolgáló elindításához futtassa a fájlt Run-Rust-Exp-Server.bat
- Indítás után a parancssorban sorok lesznek a letöltéssel kapcsolatos információkkal, várjuk a pillanatot, amikor megjelenik a felirat "szerver inicializálva".
- Minden, a szerver működik.
- Most, hogy beléphessünk a szerverre, meg kell találnunk a szerverünk címét. Klasszikus változat -
- Írd le valahova az ip-d szöveges fájl(nem elfelejteni).
- Ezután indítsd el a játékot és nyomd meg az F1 billentyűt (konzol) és írd be oda a net.connect parancsot Az ip-d: 28015 (ahol a Your ip az ip-d, amit előre megtanultál). Elméletileg ennek is 127.0.0.1-nek kell lennie.

Ha minden rendben van, csatlakozni fog a szerverhez. Ahhoz, hogy az ismerősök kapcsolódhassanak Önhöz, természetesen szükséges, hogy a szerver futjon a számítógépen, és hogy barátai helyesen írják be a kapcsolódási parancsot, amelyet Ön mond nekik.
Most már elkezdheti játszani. DE! Az összes művelet helyes végrehajtása bizonyos esetekben nem garantálja a sikert. Mert sok oka van annak, hogy miért nem sikerül. A leggyakoribb problémák megoldása be van írva.

4. Nos, most, ha minden sikerült neked, és tetszett, játszhatsz vele szerver beállításait.
Például be legújabb frissítés a fejlesztők ezt tették hozzá érdekes dolog hogy a fegyverek kopása (Rögtön eszembe jutott egy sorozat halott sziget), valamint a ruházat és a felszerelés elhasználódása.
Ez sokaknak nem felelt meg, és itt a lehetőség a funkció letiltására.

Ehhez szüksége van:
> Jelentkezzen be a szerverre rendszergazdai jogokkal. Ehhez nyissa meg a konzolt a játékban az F1 billentyűvel, és írja be az Rcon.login your password parancsot (jelszava a server.cfg fájlban van beállítva, és alapértelmezés szerint 123456-nak néz ki). Belépés után egy feliratnak kell megjelennie (a konzolon) "adminként bejelentkezve", ami azt jelenti, hogy rendszergazdaként vagy bejelentkezve. Most írja be a parancsokat:
- Ruhaviselet letiltásához: conditionloss.armorhealthmult "0.0"
- A fegyver/készlet viselésének letiltásához: conditionloss.damagemultiplier "0.0"

Különféle modok segítségével különböző dolgokat is letilthat vagy engedélyezhet. Például tiltsa le a szétesést a szerveren, vagy állítsa be a repülési intervallumot a repülőgépek esetében. A hálózatnak már vannak megfizethető és nem túl megfizethető modjai is. Javaslom egy ingyenes mod használatát magma, a könnyű testreszabhatóság és a nagyszámú bővítmény miatt.

A Rust játékoptimalizálása egyszerűen "értéktelen", ami nehézségeket okoz közben játékmenet egyes felhasználók számára. Egyes esetekben akár erős számítógép képtelenek megbirkózni közvetlen feladataikkal, nevezetesen, hogy a „rozsda” felületen késések nélkül kiváló képet nyújtsanak. Természetesen néhány manipulációnak köszönhetően kissé növelheti az fps-t a játékban, de ez a legjobb, ha különféle parancsokat ír be a konzol sorába, amelyek letiltják az adott effektusokat. De hogyan képzeled el? Minden alkalommal, amikor csatlakozik a szerverhez, írjon be körülbelül 30 parancsot a konzolba - ez mennyi időt veszít el ... De van kiút, és ez a Rust konfigurációs fájlja, amelybe beírhatja ezeket a parancsokat , és egyszerűen helyezze el egy speciális könyvtárba.

De honnan szerezhetem be ezt a cfg-t Rusthoz? Valójában kétféleképpen lehet megszerezni. A következőket teheti...

Konfig készítése a Rust játékhoz

1. Lépjen a játék gyökérkönyvtárába.
2. Keresse meg ott a CFG mappát.
3. Keressen benne két fájlt: client.cfg és config.cfg.
4. Ha nincsenek, akkor csak újakat kell létrehozni, és ennek megfelelően elnevezni őket.
5. Írja be ide a megfelelő parancsokat a következőhöz: , shadows, wind stb.

És megteheti másként is.

Töltse le a cfg-t a játékhoz

1. A kész Rust konfigurációt (az összes szükséges paranccsal) letöltheti közvetlenül a weboldalunkról, innen.
2. Másolja az archívumban lévő két fájlt a megfelelő (az első módszernél megadott) könyvtárba.
3. Ha ezek a fájlok már megvannak, akkor másold ki cserével, ha nem, akkor csak illeszd be.

Alapvetően nem mindegy, hogy merre indulsz el. Ezt követően csak:

Jelentkezzen be a játékba
Kattintson az "Opciók" fülre
Törölje a "Water Reflectins" és a "VSync" jelölést
És húzza a "Render Quality" csúszkát egészen balra

Megjegyzendő, hogy a Rust konfig nagyon pozitívan hat, akár azt is mondhatjuk, hogy a Rust konfig (természetesen helyesen konfigurálva) sokkal több előnnyel jár, mint a további 512 MB videomemória.

A sorozat korábbi cikkeiben általános áttekintés készült a Rust programozási nyelvről, szó esett a szintaxis alapjairól: a legegyszerűbb komponensekről (változók, egyszerű adattípusok, operátorok és kiterjesztések), vezérlőkonstrukciók és összetett adatszerkezetek, függvények, ill. pusztítókat ismertettek. Különös figyelmet fordítottak a memóriamodellre általában, az objektumtulajdon fogalmára, Általános elvek memóriakezelés, saját és kezelt blokkok használata megosztott memória, valamint kölcsönzött mutatók. Ez a cikk a Rust nyelv bemeneti/kimeneti lehetőségeit tárgyalja.

Minden programozási nyelvben fontos az I/O alrendszer szerves része. A szabványos kimenettel való munkavégzés legegyszerűbb eszközeit már a korábbi cikkekben is alkalmaztuk ( print , println ). Ezek a funkciók intuitívak, és nem okoznak nehézséget alkalmazásuk folyamatában. Ezért most elsősorban a felhasználó által bevitt adatok fogadásának módjaira és a fájlokkal való munkavégzéshez szükséges eszközökre koncentrálunk.

1. Az std::io modul

A Rustban az összes I/O létesítmény egy modulban van összegyűjtve io.

Az Olvasó és Író tulajdonságok meghatározzák a legtöbb minimális halmazát egyszerű módszerek bemenet és kimenet. A ReaderUtil és WriterUtil tulajdonságok a módszerek szélesebb választékát kínálják, amelyek a felhasználó számára nagyobb irányítást biztosítanak a bemenet és a kimenet felett. Például a Reader csak adott számú bájt beolvasását teszi lehetővé egy pufferbe, míg a ReaderUtil metódusokat kínál egy egész sor, több sor, numerikus értékek stb. olvasására. Ezen kívül létezik a ReaderUtil implementációja (implementációja) for , amely hozzáférést biztosít az összes Reader metódushoz.

Egy tulajdonság olyan módszerek halmazát írja le, amelyek egy adott típusra vagy több típusra is alkalmazhatók. A tulajdonságokkal a sorozat következő cikkeiben részletesebben foglalkozunk.

Mint fentebb említettük, a leggyakrabban használt print() és println() függvények is definiálva vannak a modulban io, de a legtöbb esetben nem kell kifejezetten importálni őket, mivel a fordítási és összekapcsolási rendszer már gondoskodott erről.

Ezen kívül nagyon hasznos funkciókat stdin() , stdout() és stderr() , amelyek mutatót adnak vissza a három szabványos fájlleíróhoz: standard input, standard output és standard error.

2. Adatok fogadása a felhasználótól

Mindenesetre a legtöbbet egyszerű módon az adatok fogadása a felhasználótól az stdin() függvény használata, amely mutatót hoz létre a @Reader objektumra, amely lehetővé teszi az adatok olvasását a szabványos bemeneti adatfolyamból (hasonló függvények léteznek a szabványos kimeneti adatfolyamhoz - stdout() , mint pl. valamint a szabványos hibafolyamhoz - stderr() ). A @Reader mutató létrehozása után használhatja a read_line() függvényt a felhasználó bevitelének olvasásához, amint az az 1. listában látható.

Lista 1. Felhasználói bevitel olvasása
fn main() ( hagyja, hogy stdin = std::io::stdin(); print("Mi a neved?"); let name_str = stdin.read_line(); println(fmt!("Örülök, hogy találkoztunk, %s \ n", name_str)); )

A ReaderUtil tulajdonságban amellett egyszerű funkciók A bájtok és az egyes sorok olvasása eszközök gazdag készletét is meghatározza az adatok olvasásához különböző feltételek mellett: bájtok olvasása a fájlvégi jel megjelenéséig - read_until() , C-stílusban írt karakterlánc olvasása (null befejező karakterrel ) - read_c_str() , a teljes adatfolyam beolvasása - read_whole_stream() , az adatfolyam összes sorának kiolvasása - read_lines() , valamint számos függvénykészlet, amely lehetővé teszi számértékek, egész és lebegőpontos értékek olvasását.

3. Adatok olvasása fájlból

A fájlokkal való munkához szükséges összes eszköz szintén a modulban található std::io. Mindenekelőtt a következő funkciókra kell figyelni:

fn FILE_reader(f: *libc::FILE, tisztítás: bool) -> @Reader fn FILE_writer(f: *libc::FILE, tisztítás: bool) -> @Writer fn fájl_olvasó(elérési út: &Elérési út) -> Eredmény<@Reader, ~str>fn file_writer(elérési út: &elérési út, zászlók: &) -> Eredmény<@Writer, ~str>fn mk_file_writer(elérési út: &elérési út, zászlók: &) -> Eredmény<@Writer, ~str>

A FILE_* opciók C-stílusú fájlokat olvasnak és írnak, míg a file_* opciók a Rust stílusban használhatók. Mivel az első két funkció nyilvánvalóan segédeszközök szerepét tölti be az adott feladatokhoz, és emellett a Rust nyelvről van szó, ezért a Rust-stílust kell előnyben részesíteni. Ezért a továbbiakban csak a file_reader és file_writer függvényeket vesszük figyelembe. Mindkét függvény egy ~str típusú fájl elérési utat vesz fel első paraméterként, és mindkettő Result típusú értéket ad vissza. Így a Rust fájl I/O megértéséhez meg kell értenie és ki kell értékelnie az Eredmény típusát is.

3.1. Visszaküldés típusa Eredmény

Ez a típus eszközként szolgál a Rustban a futásidejű hibák elkerülésére. Az eredmény egy sor, amely a következő értékeket tartalmazza (lásd src/libstd/result.rs):

kocsmai enum eredménye (Ok(T), /// tartalmazza az Err(U) függvényből a sikeres visszatérés értékét /// tartalmazza a függvényből a visszatérési hiba értékét)

Az Eredmény típusú értékeket használat előtt ki kell csomagolni (megsemmisíteni).

A példaprogram a következő függvényt fogja használni a modulból std::eredmény :

fn kicsomagolás (res: Eredmény ) -> T

Ha az eredmény Ok(T) , akkor a függvény az Ok(T) -ból kinyert T értéket adja vissza, amely a programban tovább használható.

Természetesen ezzel a funkcióval a könyvtári eszköztár std::eredmény nincs korlátozva. Az egyéb funkciók leírása a fenti dokumentációban található.

3.2. Példa adatok fájlból való olvasására

A példa forráskódja a 2. listában látható. A példa egyszerűen beolvassa a bájtokat az adott fájlból, majd az olvasási eredményt karakterláncsá alakítja, és mintaegyeztetést hajt végre. Feltételezzük, hogy maga a program és a tesztfájl read.txt, ahonnan az adatok olvashatók, ugyanabban a könyvtárban találhatók.

Felsorolás 2. Adatok olvasása fájlból bájtonként.
std::io::* használata; std::vec::* használata; használd az std::path::*; fn is_success(fpath: &PosixPath) (legyen talán_teszt_olvasó: Eredmény<@Reader, ~str>= file_reader(fpath); let test_reader: @Reader = std::result::unwrap(talán_teszt_olvasó); let mut byte: ~ = ~; loop ( let byte: int = teszt_olvasó.read_byte(); if test_reader.eof() ( break; ) append_one(bytes, byte as u8); ) let sample: ~str = ~"siker"; legyen talán_siker: ~str = std::str::from_bytes(bytes); if Maybe_success == minta ( println("A fájl olvasási művelete sikerült"); ) ) fn main() ( legyen fpath: ~PosixPath = ~PosixPath("./read.txt"); is_success(fpath); )

A fenti példában az is_success() tesztfüggvény létrehoz egy test_reader objektumot a neki átadott fájl elérési út használatával. Az áttekinthetőség kedvéért a fájl tartalmát egy-egy bájt olvassa be, és az olvasási bájt hozzáadódik a bájtvektorhoz. A bájtok int típusú egész értékekként kerülnek beolvasásra, de amikor a következő bájtot beillesztjük a vektorba, u8 típusú érték várható. Ezért minden beszúrt bájtnál egy explicit u8 konverzió kerül végrehajtásra. Ezek a műveletek addig folytatódnak, amíg a fájl végét (fájl vége) meg nem találjuk olvasás közben.

A reader.eof() metódus igaz értéket ad vissza, ha az éppen olvasott bájt tartalmazza az eof jelzőt. Ebben az esetben ennek a bájtnak az értéke -1 (ez az oka annak, hogy a reader.read_byte() int értéket ad vissza, és nem u8-at), és nem kell hozzáadni a vektorhoz. A feltétel ellenőrzésre kerül, és ha EOF található, a hurok kilép.

Az olvasási eredmény érvényesítése azon a tényen alapul, hogy az olvasott bájtok ASCII-értékek (és ezért egyeznek az UTF8 kódolás megfelelő részével), vagyis a „siker” szót alkotó karakterekkel.

3.3. Miért nem egy while ciklus

Amikor a 2. listában szereplő kódot vizsgáljuk, ésszerű kérdés merülhet fel: miért lép ki a hurokból az eof ellenőrzése a ciklustörzsben, nem pedig a gyakoribb feltételes teszt használata a következő iteráció előtt? Ennek oka az read.eof() működése. Amikor egy while ciklust használunk az eof ellenőrzésével a feltételes kifejezésben, egy -1 (255u8) értékű EOF bájt hozzáadódik a célvektorhoz. Tehát amikor a while használod, akkor a legfrissebb értéket kell "kipattannod" a vektorból, ahogy az a 3. listában látható.

Lista 3. Olvasási bájtok részlete while ciklus használatával
let mut byte: ~ = ~; while !reader.eof() ( std::vec::append_one(bytes, reader.read_byte() as u8); ) std::vec::pop(bytes);

Természetesen ilyen adatkezelési lehetőségnek joga van létezni.

Következtetés

Rustban szinte az összes I/O a modulban összpontosul std::io. Minden elemi adattípushoz eszközök vannak biztosítva annak olvasásához és megjelenítéséhez a kimenet során. A modul fő összetevői std::io a Reader , Writer , ReaderUtil és WriterUtil tulajdonságok, amelyek minden szükséges vezérlést biztosítanak a bemenet és a kimenet felett.


Ebben a témakörben megmutatom, hogyan hozhat létre sajátot Rozsda szerver Kísérletezzen modokkal. Miért van rá szükség? Nos, legalábbis ha a Rust-tal játszol, akkor sok ötleted van, amelyeket sokkal kényelmesebben tesztelhetsz a saját szervereden végtelen erőforrásokkal és repülési képességgel. És ha tovább megy, akkor népszerűvé teheti szerverét, és valódi pénzt kaphat, ha játékot árul a szerverén lévő játékosoknak.

Tehát kezdjük.
Első rész - Szerver létrehozása.
1. Ezzel töltse le a Rust_server.zip archívumot a hivatalos webhelyről
2. Csomagolja ki az archívumot egy Önnek megfelelő mappába. Például ez: C:\Games\Rust_Server\Server
A továbbiakban példákat adok a mappához tartozó címekre.
3. Lépjen a C:\Games\Rust_Server\Server mappába, és futtassa az update.bat fájlt.
Megnyílik egy fekete ablak parancssorral, és ebben töltődnek le a szerver fájlok, mérete körülbelül 2,15 GB. Amikor a letöltés befejeződött, az ablak automatikusan bezárul.
4. Lépjen a C:\Games\Rust_Server\Server\rustds mappába.
Teremt Szöveges dokumentum a jegyzettömbben másold be ezt a szöveget:
RustDedicated.exe -batchmode -server.hostname "Saját kiszolgáló" -szerver.port 28015 -szerver.identitás Hello_World -server.maxplayers 5 -server.seed 777 -server.worldsize 4000 -chat.serverlog 1 -servernet. .saveinterval 300 -spawn.max_rate 1 -spawn.max_density 1
Ezután a Jegyzettömbben kattintson a "Mentés másként..." gombra, és mentse a fájlt "start server.bat" kiterjesztéssel "Minden fájl".
A megjelenő "start server.bat" fájl a szerver kezdőfájlja. Ha rákattint, újra megnyílik egy fekete ablak. parancs sorés megy a térkép elkészítése és a szerver indítása. Az ablak jobb alsó sarkában lévő fps számlálóból megtudhatja, hogy a szerver készen áll a munkavégzésre: betöltéskor 0 fps-t mutat, a vége után pedig megjelenik. digitális érték nekem például 262 fps-em van.
5. Ezután meg kell találnia a külső IP-címét.
Tegyük fel, hogy felkereste az egyik szolgáltatást az IP-cím meghatározására, és a címe 213.180.193.11 lett.
Nyissa meg a Rustot, és nyomja meg az F1 gombot, a megnyíló konzolon írja be a client.connect parancsot: 213.180.193.11:28015

Ha mindent megfelelően csinált, akkor a kapcsolat megszakad, és a saját szerverén találja magát

Ui.: A kiszolgáló fájljait tartalmazó mappa (mentés stb.) a következő helyen található: C:\Games\Rust_Server\Server\rustds\server\Hello_World

Második rész: admin

1. Ahhoz, hogy magad (vagy egy barátod) rendszergazda legyen a szervereden, először ismerned kell a Steam azonosítódat. Ehhez nyissa meg a steam profilját és bármelyikén szabad hely- például az avatarodtól balra kattints Jobb klikk egérrel, és válassza az "Oldalcím másolása" lehetőséget. Ezt a címet bárhová beillesztjük, például egy jegyzettömbbe vagy egy böngészőbe. Valami hasonló )