Veloren: მფლობელის სახელმძღვანელო

ეს სახელმძღვანელო არის Veloren-ის დოკუმენტაციის ძირითადი წყარო, როგორც მომხმარებლებისთვის, ასევე დეველოპერებისთვის. ის მიზნად ისახავს Veloren-ის მახასიათებლების დოკუმენტირებას, მისი შემუშავების ხერხს და აღწერს როგორც თამაშის, ასევე ძრავის შიდა მუშაობას. ის ასევე მიზნად ისახავს განიხილოს მომავალი გეგმები, რომლებიც განვითარების გუნდს აქვს Veloren-ისთვის.

| _ გადაღებული @bidgehop_

| _ გადაღებული @bidgehop_

| _ გადაღებული @bidgehop_

რა არის ველორენი?

Veloren არის მრავალმოთამაშიანი ვოქსელის RPG დაწერილი Rust. ის შთაგონებულია ისეთი თამაშებით, როგორიცაა Cube World, ზელდას ლეგენდა: ველური სუნთქვა, ჯუჯა ციხესიმაგრე და მაინკრაფტი.

| _ გადაღებული @ogzzmert_

Veloren არის სრულად ღია წყარო, ლიცენზირებული [GPL 3]-ით (https://www.gnu.org/licenses/gpl-3.0.en.html). იგი იყენებს ორიგინალურ გრაფიკას, მუსიკას და სხვა მისი საზოგადოების მიერ შექმნილი აქტივები. კონტრიბუტორზე ორიენტირებული, მისი განვითარების საზოგადოება და მომხმარებლის საზოგადოება ერთი და იგივეა: დეველოპერები, მოთამაშეები, მხატვრები და მუსიკოსები ერთად იკრიბებიან თამაშის განვითარებისთვის.

რა სტატუსშია პროექტი ამჟამად?

ძრავის ნულიდან გადაწერის შემდეგ (ძველი თამაში შეგიძლიათ ნახოთ აქ) ჩვენ ახლა ვართ ეტაპზე სადაც მრავალი მახასიათებელი საკმაოდ სწრაფად ინერგება.

ვინ ავითარებს ველორენს?

Veloren შემუშავებულია მოხალისეთა საზოგადოების მიერ, რომლებსაც აქვთ ერთი გამაერთიანებელი მიზანი: შექმნან ნათელი, ფერადი, სახალისო სამყარო, რომლის შესწავლა და ურთიერთქმედება შესაძლებელია უნიკალური და საინტერესო გზებით.

საიტი

Veloren ვებსაიტი შეიცავს ყოველკვირეულ ბლოგის განახლებებს, დეველოპერის ინფორმაციას და ჩამოტვირთვის ბმულებს. შეგიძლიათ იპოვოთ ის [veloren.net]-ზე (https://veloren.net)

უთანხმოება

Veloren საზოგადოება (როგორც დეველოპერები, ასევე მოთამაშეები) ყველაზე აქტიურია Veloren Discord სერვერზე. შეგიძლიათ შეუერთდეთ სერვერს ქვემოთ მოცემული ბმულის გამოყენებით:

https://veloren.net/discord

სოციალური მედია

ჩვენ ვართ [YouTube]-ზე (https://www.youtube.com/veloren) და Reddit და არ დაგავიწყდეთ გამოგვყვეთ მასტოდონზე.

ჩამოტვირთვა

#ჩამოტვირთვა

ეწვიეთ veloren.net ყველა ხელმისაწვდომი ვარიანტის საპოვნელად.

Veloren მოთამაშეებისთვის

გმადლობთ, რომ დაინტერესდით Veloren-ის თამაშით!

თუ გსურთ დაიწყოთ თქვენი თამაში, შეგიძლიათ წაიკითხოთ Getting Started სახელმძღვანელო Veloren Wiki-ზე.

რადგან თამაში განახლდება კვირაში ერთხელ მაინც, ჩვენ გირჩევთ გამოიყენოთ Airshipper, ოფიციალური Veloren გამშვები.

ისიამოვნეთ თქვენი მოგზაურობით!

Veloren მოთამაშეებისთვის

წიგნის ეს ნაწილი განმარტავს მოთამაშეებისთვის თამაშის ძირითად კონცეფციებს და ზოგად ხელსაწყოებს.

შენიშვნა: გთხოვთ გაითვალისწინოთ, რომ Veloren ჯერ კიდევ არ არის ალფაში და გეიმპლეი არ შეიძლება ჩაითვალოს სრულყოფილად. თამაშის ზოგიერთი ასპექტი, რომელიც აღნიშნულია, ჯერ კიდევ მძიმედ დამუშავების პროცესშია.

• შეცდომის შესახებ შეტყობინება
• Changelog
• საგზაო რუკა
• FAQ

შეცდომების შესახებ შეტყობინება

1. პირველი, რაც უნდა გააკეთოთ, არის ჩვენი GitLab საკითხები შემოწმება, თუ ეს შეცდომა უკვე ცნობილია.
2. თუ არა შექმენით პრობლემა Bug template-ით და შეეცადეთ აღწეროთ ხარვეზი რაც შეიძლება კარგად, საჭიროების შემთხვევაში დაამატეთ ეკრანის ანაბეჭდები.
3. ატვირთეთ ჟურნალის ფაილი დამატებითი ინფორმაციისთვის, რომელიც დაგვეხმარება პრობლემის იდენტიფიცირებაში. იხილეთ ქვემოთ, თუ როგორ უნდა მიიღოთ ჟურნალები. (შენიშვნა: დარწმუნდით, რომ არ არის სენსიტიური ინფორმაცია ჩართული ჟურნალის ფაილებში)
4. გამოაგზავნეთ საკითხი

მინიშნება: თუ არ გსურთ GitLab ანგარიშის შექმნა, შეგიძლიათ შეუერთდეთ ჩვენს Discord და შეატყობინეთ ხარვეზის შესახებ #bugs-and-support-ში.

შეაგროვეთ ჟურნალები

თუ Veloren-თან დაკავშირებული პრობლემები შეგექმნებათ, შეიძლება მოგთხოვოთ მორები ან კვალი. ეს გაკვეთილი გაჩვენებთ, თუ როგორ უნდა შეაგროვოთ ჟურნალები, თქვენი ოპერაციული სისტემისა და Veloren-ის დაყენების მეთოდის მიხედვით.

ნაგულისხმევად Veloren სერვერი და Voxygen ორივე აწარმოებენ ჟურნალებს. ისინი იბეჭდება ტერმინალში/cmd და ფაილში, სახელად voxygen.log.<todays_date>. ის კი ბეჭდავს, სადაც ფაილი მდებარეობს ტერმინალში/cmd:

Nov 25 01:40:14.388  INFO veloren_voxygen::logging: Setup terminal and file logging. logdir="/mnt/games/cargo-build/debug/userdata/voxygen/logs"

ნაგულისხმევად, დეტალურობა არის INFO, მაგრამ გთხოვთ, მოგვაწოდოთ ჟურნალები TRACE დონეზე (როგორც ნაჩვენებია ქვემოთ). მოძებნეთ შეტყობინება სახელწოდებით Tracing is successfully set to TRACE, რათა დაადასტუროთ, რომ TRACE დონე ჩართულია.

Linux და macOS

საჰაერო ხომალდი

1. დაიწყეთ Airshipper -vv არგუმენტით.
2. როდესაც თამაში დაიწყება, ის ტერმინალში დაბეჭდავს ჟურნალის ფაილის ადგილმდებარეობას. შეამოწმეთ Airshipper გვერდი.

შედგენილი

1. დაიწყეთ ვოქსიგენი TRACE დონიდან ტერმინალში:

    RUST_LOG="trace" ./target/debug/veloren-voxygen
    # or RUST_LOG="trace" cargo run
    ```

2. დააკოპირეთ კვალი ტერმინალიდან ან ზემოთ ნახსენები ჟურნალის ფაილიდან.

## Windows

### საჰაერო ხომალდი

1. CMD-ის გახსნა.
> Windows-ზე დააჭირეთ `Windows key + R`. შემდეგ აკრიფეთ `cmd` და დააჭირეთ `enter`.
2. აკრიფეთ `airshipper run -vv` და დააჭირეთ Enter.
3. გაუშვით თამაში (სანამ პრობლემას არ წააწყდებით).
4. ჟურნალები უნდა განთავსდეს `%Appdata%/airshipper/profiles/default/userdata/voxygen/logs`-ში
ან შეამოწმეთ [Airshipper](airshipper.md) გვერდი.

### შედგენილი

#### Git Bash

-> იხილეთ Linux/Compiled ზემოთ

##### Cmd

1. გახსენით CMD.
2. გადადით თქვენს veloren საქაღალდეში `cd` ბრძანებით, მაგ. `cd C:\Users\<Your Username>\Desktop\veloren`.
3. ჩაწერეთ `set RUST_LOG=trace&& veloren-voxygen.exe` და დააჭირეთ Enter (ზუსტად როგორც აქ, უფსკრულის გარეშე `&&`-მდე)
4. ჟურნალები ახლა დაიბეჭდება CMD-ში და საქაღალდეში `userdata\voxygen\logs` ან `%appdata%\veloren\`.

## ინფორმაციის შეგროვება გრაფიკული შეცდომებისთვის

ზოგჯერ შეიძლება სასარგებლო იყოს დამატებითი ინფორმაციის შეგროვება გრაფიკული პრობლემების გამართვისას. ეს ინფორმაცია ყოველთვის არ არის საჭირო, ამიტომ ის ძირითადად ემსახურება როგორც მინიშნებას, რათა მიუთითოს მომხმარებლები, როდის იქნება ინფორმაცია გამოსადეგი.

### wgpu API კვალი

1. შექმენით საქაღალდე, რომელიც ინახავს კვალს. (მაგ. `wgpu-trace`)

```shell
        mkdir wgpu-trace
    ```

2. გაუშვით თამაში გარემოს ცვლადით `WGPU_TRACE_DIR` დაყენებული ახალ საქაღალდეში.
(გზა შეიძლება იყოს აბსოლუტური ან ფარდობითი)
- Linux

```shell
            WGPU_TRACE_DIR="./wgpu-trace" airshipper start
        ```

- ფანჯრები

```shell
            set "WGPU_TRACE_DIR=./wgpu-trace"
            airshipper start
        ```

3. გაიმეორეთ ხარვეზი/ავარია და შემდეგ გამოდით თამაშიდან (კვალი უფრო დიდი იქნება, თუ ამას გარკვეული დრო დასჭირდება).
4. დაარქივეთ კვალის საქაღალდე მარტივი გაზიარებისთვის.

დამატებითი ინფორმაციისთვის wgpu-ს API-ის მიკვლევის შესახებ იხილეთ <https://github.com/gfx-rs/wgpu/wiki/Debugging-wgpu-Applications#tracing-infrastructure>

## Dx12/Dx11 გამართვის ფენის გამომავალი

პირველ რიგში, შეამოწმეთ, რომ იყენებთ dx12 ან dx11 გრაფიკულ ბაზას.

### DebugView++-ის გამოყენებით

1. აიძულეთ გამართვის ფენა Voxygen-ისთვის (შენიშვნა: თუ თქვენ თავად შეადგინეთ თამაში `--release`-ის გარეშე, მაშინ ეს ნაბიჯი შეიძლება გამოტოვოთ):
1. გაუშვით `dxcpl`.
2. დააწკაპუნეთ „სიის რედაქტირებაზე“.
3. დაამატეთ `veloren-voxygen.exe` და დააწკაპუნეთ OK.
4. დარწმუნდით, რომ "Force On" არჩეულია გამართვის ფენის განყოფილებაში.
5. დააწკაპუნეთ "Apply".
> **გაფრთხილება:** გამართვის ფენების ჩართვა დამატებით ხარჯებს ამატებს, დარწმუნდით, რომ მიჰყევით ბოლო საფეხურს
ხელახლა გამორთეთ ისინი.
2. დააყენეთ DebugView++:
1. ჩამოტვირთეთ უახლესი `DebugView++.exe` ვერსია ამ გვერდიდან: <https://github.com/CobaltFusion/DebugViewPP/releases>.
2. ჩამოტვირთეთ ფილტრის პარამეტრები აქ: <a href="assets/debugview++/View.xml" download="View.xml">View.xml</a>
3. გაუშვით `DebugView++.exe`.
4. გახსენით ფილტრის პარამეტრების ეკრანი `F5`-ით.
5. დააწკაპუნეთ ღილაკზე „ჩატვირთვა“, აირჩიეთ გადმოწერილი ფილტრის პარამეტრების ფაილი, დააჭირეთ „გახსნას“ და შემდეგ
დააჭირეთ "OK" ფილტრის პარამეტრების ეკრანის დასახურად.
3. გაუშვით voxygen (dx backend-ს აქვს პრობლემები) და გაუშვით ავარიის/შეცდომის დადგომამდე.
4. DebugView++-ში დააჭირეთ `Ctrl + S`, რათა შეინახოთ მიმდინარე ხედი, რომელიც შეიცავს ყველა გამართვის შეტყობინებას
ვოქსიგენი.
5. გააზიარეთ შენახული ფაილი.
6. ისევ გაუშვით `dxcpl` და ამოიღეთ ვოქსიგენი სიიდან.

#### ვიზუალური სტუდიის გამოყენებით

1. დააინსტალირეთ ვიზუალური სტუდია <https://visualstudio.microsoft.com/downloads/>.
2. აიძულეთ გამართვის ფენა Voxygen-ისთვის (შენიშვნა: თუ თქვენ თავად შეადგინეთ თამაში `--release`-ის გარეშე, მაშინ ეს ნაბიჯი შეიძლება გამოტოვოთ):
1. ღია ვიზუალური სტუდია.
2. გადადით Debug > Graphics > DirectX მართვის პანელზე.
3. დააწკაპუნეთ ღილაკზე `Edit List...`..
4. დაამატეთ `veloren-voxygen.exe` სიას (აუცილებლად წაშალეთ ეს დასრულების შემდეგ).
5. შეცვალეთ Debug Layer პარამეტრი Force On.
6. დააწკაპუნეთ განაცხადის და გადით მართვის პანელიდან.
3. გახსენით Voxygen შესრულებადი როგორც პროექტი ([ორიგინალი ინსტრუქციები](https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-debug-an-executable-not-part-of-a-visual-studio-solution?view=vs-2019#to-create-a-new-exe-project-for-an-existing-app)):
1. ვიზუალურ სტუდიაში: ფაილი > გახსნა > პროექტი.
2. გადადით veloren-voxygen.exe-ზე, აირჩიეთ ის და დააჭირეთ გახსნას.
4. გაუშვით პროექტი (მწვანე ისარი და ან ვარიანტი გამართვის მენიუში).
5. საკითხის რეპროდუცირება.
6. ვიზუალურ სტუდიას ექნება განყოფილება, სახელწოდებით "გამომავალი" გრაფიკული გამართვის ფენის და სხვა შემთხვევითი მასალების გამომავალი (ამის გაზიარება შესაძლებელია კოპირ-პასტის საშუალებით).

შეცვლა

ცვლილებების ჟურნალი შეგიძლიათ იხილოთ საცავში და [Airshipper launcher]-ში (airshipper.md).

საგზაო რუკა

#საგზაო რუკა

Veloren-ის განვითარების პროცესი ბუნებრივად ღიაა და ხელმძღვანელობს მისი საზოგადოების მიერ: ახალი ფუნქციები ემატება როგორც და როდის არსებობს კონსენსუსი საზოგადოებაში. ველორენის განვითარება არის ხელახალი შეფასების და ინკრემენტული მუდმივი პროცესი გაუმჯობესება, კონტრიბუტორებით, რომლებიც მუშაობენ იმ ფუნქციებზე, რომლებიც მათ ყველაზე მეტად აინტერესებთ. ამ მიზეზით, პროექტი არ არის გქონდეთ ზუსტი საგზაო რუკა! ამ საგზაო რუქის მიზანია მიაწოდოს უხეში წარმოდგენა იმის შესახებ, თუ საით მიემართება Veloren და ასევე ცდილობს ახსნას, რატომ არის ყველაფერი ისე, როგორც არის და რატომ არის ზოგიერთი მახასიათებელი ჯერ კიდევ გაურკვეველი. კიდევ ერთი რამ, რაც უნდა აღინიშნოს, არის ის, რომ ჩვენ გვინდა, რომ ყველა ეს ფუნქცია ერთმანეთთან ერთად იმუშაოს, რათა შეიქმნას სინერგია და უფრო ღრმა თამაში. აქედან გამომდინარე, ნახავთ მსგავს თემებს, რომლებიც განხილულია საგზაო რუქის სხვადასხვა ნაწილში. დაბოლოს, ჩვენ არ შეგვიძლია დავასახელოთ კონკრეტული თარიღი ამ ფუნქციებისთვის, რადგან ჩვენ არ ვართ თამაშის სტუდია: თამაში ეფუძნება მოხალისეების მუშაობას, რომელთა დრო და მოტივაცია განსხვავებულია, ამიტომ შეუძლებელია კონკრეტული შეფასებების მიცემა იმ მოთამაშეებისთვის პოტენციური იმედგაცრუების გარეშე, რომლებიც ელოდებიან ამ ფუნქციებს.

** არსებული ფუნქციების გაფართოება/გადამუშავება:**

• გამძლეობა

როგორ მუშაობს

ყველა მოწყობილობა, რომელიც შედგება ჯავშანტექნიკისგან და იარაღისგან, იწყება გამძლეობის 12/12 მუხტით, ყოველი სიკვდილი ამცირებს აღნიშნულ მუხტს 1-ით. გამძლეობა არ ახდენს გავლენას აღჭურვილობის სტატისტიკაზე დამუხტვის აბსოლუტური უმრავლესობისთვის, მოთამაშე ხედავს სტატისტიკის შემცირებას მხოლოდ მას შემდეგ, რაც ჯავშანი მიაღწევს გამძლეობას და მკვეთრად იკლებს 0/12. როგორც კი აღჭურვილობა მიაღწევს 0/12 გამძლეობას, ნივთი კვლავ იქნება გამოსაყენებელი, თუმცა, სტატისტიკის მკვეთრი შემცირების გამო, ის საბრძოლოსთვის შეუსაბამო ხდება. მოთამაშეს შეუძლია შეაკეთოს დაზიანებული ნივთები ქალაქებში აღმოჩენილ სარემონტო სკამებზე, ძვირადღირებული Velorite და პირველადი მასალა ქვედა დონეზე.

რატომ გვინდა ეს?

გამძლეობა მნიშვნელოვანი სასიკვდილო სასჯელია, რადგან ის აფერხებს მოთამაშეებს განუწყვეტლივ აჩქარებულ ობიექტებში, რომლებიც აღემატება მათ შესაძლებლობებს, რათა მიიღონ მაღალი რანგის ნივთები.

სამომავლო გეგმები

გამძლეობა არის შედარებით ახალი მექანიკა Veloren-ის სამყაროში და, შესაბამისად, აკლია პოლონური. იმის გამო, რომ მექანიკის ამჟამინდელი განხორციელება ბევრი მოთამაშისთვის გაურკვეველი და იმედგაცრუებულია, ჩვენ განვიხილავთ რამდენიმე შესწორებას, რაც მას უფრო ხელმისაწვდომს და გასაგებს გახდის მოთამაშეებისთვის. დაგეგმილი ცვლილებები შედგება:

• მაქსიმალური გამძლეობის შემცირება 8-მდე.
• ყველა რემონტის გაკეთება უფასოდ.
• გაძლიერების გამძლეობის ვარიანტის დამატება, მაქსიმალური გამძლეობის დროებით ამაღლება მაგ. 6 ყველა გამაგრებაზე
• ყოველი გამაგრება დაჯდება დამატებითი მასალები (ველორიტი + პირველადი მასალები).
• გაძლიერებული გამძლეობის შეკეთება შეუძლებელია.
• ინტერფეისის ცვლილებები:
• გახადეთ სიკვდილის ეკრანის გამძლეობის განყოფილება უფრო ახსნილი (და ფლეშ!).
• დაამატეთ გამძლეობის ზოლი დაზიანებული ნივთების ქვემოთ.

გარდა ამისა, ჩვენ გვსურს შემოვიტანოთ მეტი საინტერესო პუნქტი Veloren-ის ღია სამყაროში, როგორიცაა Inns ან სხვა დასასვენებელი ადგილები, რომლებიც საშუალებას გაძლევთ შეაკეთოთ თქვენი ნივთები ქალაქების გარეთ.

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** შინაური ცხოველები და მთები **

შინაური ცხოველები და მთები თამაშში უკვე დიდი ხანია არის დანერგილი. თუმცა, ისინი შორს არიან სრული სისტემისგან. სამომავლოდ ვგეგმავთ მათ გადამუშავებას, მაგრამ შინაური ცხოველებისა და სამაგრებისთვის სასურველი მექანიკის უმეტესობა განხილული უნდა იყოს, რათა გავიგოთ, სად მივდივართ. ეს საკმაოდ კომპლექსური თემაა, რადგან ჩვენ მიერ შთაგონებული თამაშებში შინაური ცხოველების მრავალი ვარიანტი იყო. არ არსებობს დასახული გეგმა, თუ როგორ იმუშავებენ ისინი და, ალბათ, დრო დასჭირდება სათანადო გადამუშავებას. ეს არის რამდენიმე კითხვა და დებატები, რომლებიც ჩვენ გვაქვს სისტემის გარშემო:

1. შინაური ცხოველები და მთები სამუდამოდ უნდა მოკვდნენ? თუ კი, როგორ გავხადოთ ისინი უფრო მდგრადი და ნაკლებად ზედაპირული?
2. როგორ უნდა განვახორციელოთ ბრძანებები, რომლებსაც ვაძლევთ? ეს უნარების ხე უნდა იყოს? მხოლოდ ბრძოლასთან უნდა იყოს დაკავშირებული? და ა.შ.
3. როგორ განვასხვავოთ საბრძოლო შინაური ცხოველები ჩვეულებრივი შინაური ცხოველებისგან?

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** მანქანები (საჰაერო ხომალდები, გემები, მატარებლები, ვაგონები და ა.შ.)**

სწრაფი მოგზაურობის შესახებ კითხვაზე ვპასუხობთ, რომ ტელეპორტაცია არ იქნება. ამის ნაცვლად, ჩვენ გადავწყვიტეთ, რომ გვსურს დავამატოთ უფრო სწრაფი სამგზავრო საშუალებები, იგივე მანქანები. მოგზაურობის 100% დადასტურებული საშუალებაა საჰაერო ხომალდები და გემები. ვაგონები და მატარებლები ჯერ კიდევ განხილვის მაგიდაზეა, ან ყოველ შემთხვევაში, ჩვენ არ ვართ 100%-ით დარწმუნებული, როგორ იმუშავებენ ისინი ესთეტიურად თუ ტექნიკურად. გადაწყვეტილება, რომ არ გქონდეთ მყისიერი მოგზაურობა, არის ეკონომიკის დაცვა და მოთამაშეების შესწავლის წახალისება. ფრენებს/მგზავრობას ნაკლები დრო დასჭირდება, მაგრამ არ იქნება მყისიერი. ამის გამო, ჩვენ ასევე გვინდა დავრწმუნდეთ, რომ ეს მოგზაურობები არ არის შრომა, ამიტომ გვსურს გვქონდეს საკმარისი პოტენციური აქტივობები მათზე შესასრულებლად, განსაკუთრებით ხელოსნობის სადგურების და სხვა მოთამაშეების/NPC-ების არსებობით, რომლებთანაც ვისაუბრებთ/ვაჭრობთ. რაც შეეხება მფლობელობას, ჯერ არ არის გადაწყვეტილი, თუ როგორ განხორციელდება ის ტექნიკური და გეიმპლეი მიზეზების გამო. ზოგიერთი კითხვა, რომელსაც საკუთარ თავს ვუსვამთ, არის მაგალითად: „რამდენად ხელმისაწვდომი უნდა იყოს ასეთი მანქანა? ”არ იქნება უცნაური, თუ ყველას აქვს საკუთარი გემი/საჰაერო ხომალდი?” „რას ვუყოთ მანქანას, როდესაც მისი მფლობელი გამოდის? და ა.შ. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• საჭმელი

ამჟამად საკვები ემსახურება როგორც სამკურნალო მექანიკოსს, მაგრამ ჩვენ ვგეგმავთ მის შეცვლას „დიდი ხნის ბუფეტად“.

• ეკონომიკა

ჩვენ ვგეგმავთ გვქონდეს სრული ეკონომიკა, რომელიც შეეხება თამაშის თითოეულ ასპექტს. ეს ნიშნავს, რომ ყველა მექანიზმი პირდაპირ ან ირიბად იქნება ეკონომიკის ზემოქმედება. იდეალური მიზანია მიაღწიოთ იმ დონეს, სადაც მოთამაშეებს და NPC-ებს შეუძლიათ გავლენა მოახდინონ ეკონომიკაზე მისი დარღვევის გარეშე, ამასთან, უზრუნველყონ ხელოვნური რესურსების გამომუშავება. ეს ნიშნავს, რომ ჩვენ გვინდა, რომ ყველა რესურსი და მონეტა რეალურად იყოს ვაჭრობა და არ გამოჩნდეს არსაიდან. ეს საშუალებას მისცემს თამაშს ჰქონდეს თანმიმდევრული/განვითარებული დეფიციტი, მიწოდებისა და მოთხოვნის ფასები, ფასების კონკურენცია, ბაზრის კონტროლი, ბაზრის რეგულაციები, გავლენის რეგიონები, სავაჭრო მარშრუტები, გარე ფაქტორები და ა.შ. მიუხედავად იმისა, რომ ეს უკიდურესად პერსპექტიულია, ასევე ძალიან რთული და ძნელი გამოსავალია, შესაბამისად, სტაბილურ და დასაჯერებელ სტადიაზე მისასვლელად დიდი დრო და კორექტირება დასჭირდება. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• მსოფლიო სიმ

ველორენის აღწერილობაში, ჯუჯა ციხე ჩამოთვლილია, როგორც ერთ-ერთი შთაგონება, და მსოფლიო სიმ არის ის, სადაც ყველაზე მეტი შთაგონება წავა. ამჟამად ჩვენ გვაქვს rtsim, რომელიც არის სისტემა, რომელიც თვალყურს ადევნებს სამყაროში დროთა განმავლობაში ცვლილებებს. ეს მერყეობს NPC-დან დაწყებული და დამთავრებული რამდენი რესურსი რჩება ერთ ნაწილამდე, ამიტომ გასაგებია, რომ ეს დიდ გავლენას მოახდენს მთელ თამაშზე. rtsim-ის ერთ-ერთი საკმაოდ მნიშვნელოვანი მიზანი არის ის, რომ ჩვენ არ გვინდა, რომ იყოს ძალიან დიდი განსხვავება იმიტირებული ნივთებისთვის, ჩატვირთულია თუ არა ნაწილი. ეს ასევე ნიშნავს, რომ ჩვენ არ გვინდა, რომ სხვადასხვა სახის რესურსები შეიქმნას არაფრისგან, როდესაც ნაჭერი ხელახლა ჩაიტვირთება, ეს ასევე იწვევს დაფქვას არაეფექტურს. არის კიდევ ბევრი რამ, რის შესახებაც გვინდა თვალყური ადევნოთ აქ. ჩვენ გვინდა თვალყური ადევნოთ ველური ბუნების პოპულაციას, NPC-ების ინვენტარს განტვირთვისას (შესაძლოა უფრო დაბალი გარჩევადობით). ჩვენ ასევე გვინდა, რომ NPC-ები რეალურად იმუშაონ, ზოგიერთი მაგალითი შეიძლება მოიცავდეს მონადირეებს, რომლებიც გავლენას ახდენენ ველური ბუნების პოპულაციაზე, ან ჰერბალისტებს, რომლებიც გავლენას ახდენენ რესურსების რაოდენობაზე ნაწილებად, როდესაც ისინი იღებენ ნივთებს. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• დუნჯები:

დუნჯები ამჟამად გადამუშავების პროცესშია, გნარლინგის ციხე და ადლეტის გამოქვაბულები პირველი ორი დუნდულია, რომელიც გადაკეთებულია. მომავალი დუნგების გადამუშავება/დამატება მოიცავს Sahagin Dungeon, Haniwa Tombs, Myrmidons Dungeon, Cultist Dungeon, Dwarven Mine, Vampire Dungeon და ა.შ.

მიზანია დუნდულები უფრო უნიკალური გახადოს, თუ როგორ გამოიყურებიან, როგორ თამაშობენ და როგორ ურთიერთობს მოთამაშე მათთან. ჩვენ გვინდა, რომ დუნდულებმა თავი უფრო მეტად იგრძნონ ველორენის სამყაროსთან, სადაც არის ურთიერთქმედება დუნდონის მაცხოვრებლებსა და სამყაროს შორის. ამისთვის მიზნად ისახავს ვუპასუხოთ შემდეგ კითხვებს: რატომ არის ეს დუნდი აქ, რა მნიშვნელობა აქვს რეგიონში, რა მოტივაცია აქვთ და რა მოხდება მათი დამარცხების შემთხვევაში? (და ა.შ.) ამიტომ, ჩვენ გვინდა, რომ ამ დუნდულებმა იგრძნონ თავი „ორგანულად“, ანუ ისინი სამყაროს რეალური ნაწილია და ურთიერთქმედებენ მასთან. ამისთვის დუნდულებს არ ექნებათ შემთხვევები, რადგან ეს შეუთავსებელია მის „ორგანულ“ ნაწილთან. მისი ორგანული ელემენტი ასევე ნიშნავს, რომ როდესაც დუნდული გაწმენდილია, ჩვენ გვინდა გვქონდეს შესაძლებლობა, რომ სხვა ჯგუფი დასახლდეს ამ კონკრეტულ დუნდულში. რთული ნაწილი არის ბალანსის პოვნა ხსენებული დუნდულის ხელმისაწვდომობასა და ჭუჭყიან დუნდულების თავიდან აცილებას შორის.

გარდა ამისა, რაც შეეხება შინაარსს და დუნდულების ირგვლივ დაბალანსებას, ჩვენ გვსურს, რომ დუნდულები იყოს ბრძოლის უფრო ნიშური ასპექტი, რომელიც მოითხოვს ინდივიდების ჯგუფს დასრულებას. ეს, რა თქმა უნდა, ნიშნავს, რომ იქნება როგორც კონტენტი განკუთვნილი სოლო მოთამაშეებისთვის, ასევე დაჯგუფებული მოთამაშეებისთვის, რათა არ მოხდეს აღნიშნული შინაარსის დასრულება. მათთვის, ვინც თამაშობს ერთმოთამაშიან ან მათ, ვისაც უჭირს ჯგუფების შექმნა სხვა ინდივიდებთან, ჩვენ ვთავაზობთ შესაძლებლობას, გაერთიანდნენ NPC-ებთან კეთილგანწყობის მოპოვებით ან მათი შეძენით (იხილეთ NPC Companions საგზაო რუქის ნაწილი).

დამატებითი ინფორმაციისთვის, მოგერიდებათ მიმართოთ საგზაო რუქის შემდეგ თავებს: ჰორიზონტალური პროგრესი, ქვესტები, NPCs Companions და Instances. თქვენ ასევე შეგიძლიათ დაგვიკავშირდეთ Veloren Discord-ზე.

• უნარების ხეები

ამ დროისთვის Sword-მა და Axe-მა მიიღეს Skill Tree-ის გადამუშავება (გაითვალისწინეთ, რომ ეს არ არის საბოლოო, მოგვიანებით იქნება ცვლილებები ყველა იარაღის დასაბალანსებლად). Hammer, Bow, Staff, Sceptre და General skill ხეები ასევე მიიღებენ გადამუშავებას. თუმცა, მათზე დისკუსიები ან არ დაწყებულა, ან ჯერ კიდევ ძალიან ადრეულ ეტაპზეა. აქედან გამომდინარე, ამჟამად შეუძლებელია მათ შესახებ მეტი ინფორმაციის მიწოდება არასტაბილური მოლოდინების შექმნის გარეშე. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** ხელახალი გამოშვება **

Respawns მიიღებს გადამუშავებას, რათა შესთავაზოს გეიმპლეის უფრო საინტერესო და მნიშვნელოვანი ნაწილი. თუმცა, ჯერ არ არსებობს კონკრეტული გეგმები, მხოლოდ რამდენიმე სფეროა მექანიკოსის გარშემო, რომლებიც განიხილება Discord-ზე. პირველ რიგში, ჩვენ შეიძლება შევცვალოთ კოცონები სალოცავებით/ჯადოსნური ქვებით, რათა სხვა გამოვიყენოთ ბანაკი (მაგალითად, სამზარეულო). შემდეგ, დუნდონის გადამუშავებით (იხ. საგზაო რუქის დუნდულის ნაწილი), დუნდულის შესასვლელებიდან შესაძლოა ამოღებულ იქნეს ხელახალი ქულები. და ბოლოს, ჩვენ გვსურს გავხადოთ ხელახალი წერტილები ინტერაქტიული, რაც იმას ნიშნავს, რომ თქვენ მიზანმიმართულად უნდა აირჩიოთ ის თქვენი ქვირითის წერტილად (E დაჭერით). დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** საბრძოლო ანიმაციები **

ერთი გამოხმაურება, რომელსაც ბევრს ვიღებთ, არის ველორენის ანიმაციებზე, უფრო სწორედ საბრძოლო ანიმაციებზე. ისინი, სავარაუდოდ, ერთ მშვენიერ დღეს გადამუშავდება, მაგრამ როგორც საქმე გვაქვს, ანიმაციებზე მომუშავე პირები თავისთავად არ არიან 3D ანიმატორები. ამიტომ, ანიმაციების უმეტესობა ამ დროისთვის შეიძლება ჩაითვალოს ჩანაცვლებად, სანამ ვინმე არ გადაამუშავებს მათ. გასათვალისწინებელია ერთი მნიშვნელოვანი რამ, რომ ჩვენ ვაკეთებთ ანიმაციას კოდის საშუალებით (Sam/Slipped განმარტავს). მინუსი ის არის, რომ ბევრი ანიმატორი მხოლოდ 3D გაყალბებასთან მუშაობს. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

** დაგეგმილი მახასიათებლები: **

• ქვესტი

Quests არის ერთ-ერთი მთავარი ფუნქცია, რომელიც ჩვენ გვინდა, რომელიც ჯერ კიდევ აკლია თამაშს. ამის მიზეზი ის არის, რომ ჩვენ არ გვინდა ტრადიციული ქვესტები, რომლებიც გადატვირთულია და არ აქვთ პირდაპირი კავშირი მსოფლიოს მოვლენებთან. როგორც შეიძლება დაინახეთ world sim-ის განყოფილებაში, ჩვენ გვსურს, რომ ქვესტები წარმოიქმნას ამ სისტემით (RT Sim2), სადაც ქვესტები იქმნება მსოფლიოში არსებული საჭიროებიდან გამომდინარე. ამისთვის, ჩვენ გვჭირდება პროცედურულად გენერირება ქვესტის მიზანი ცვლადების ნაკრების საფუძველზე. მაგალითად, დავუშვათ, რაიონი თავს დაესხნენ მგლებს და დაზიანდა ცხვარი და ფერმა. ადგილობრივ მოსახლეობას სურდა, რომ ვინმე ამით გაუმკლავდეს, მაგრამ ასევე დასჭირდებოდათ საკმარისი ფული მონადირის გადასახდელად. ეს მარტივი მაგალითი შეიძლება შემუშავდეს ყველა სახის ქვესტისთვის, მიკროგარემოდან მაკროგარემოებამდე, რითაც მივყავართ რთული საძიებო ხაზებისკენ და ამ ქვესტების შესრულების მრავალ შესაძლებლობამდე. როგორც თქვენ შეიძლება ეჭვი გეპარებათ, ამას დიდი დრო სჭირდება, რადგან სხვა სისტემები წინასწარ უნდა შემუშავდეს. იქნება პირველი გამეორება ქვესტებისთვის, სადაც ჩვენ ვაყენებთ სტრუქტურას და ვავითარებთ MVP-ს. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** სახელმძღვანელო **

დარწმუნებული იყავით, უკეთესი გაკვეთილი იგეგმება. თუმცა, არსებობს მრავალი მიზეზი, რის გამოც მიმდინარე სახელმძღვანელო აკლია. ჯერ ერთი, ის შეიქმნა ცოტა ხნის წინ, როდესაც თამაშის მარყუჟი განსხვავდებოდა ამჟამინდელისგან, რაც იმას ნიშნავს, რომ ის შეიძლება იყოს არასწორი ზოგიერთ ასპექტში. ის იძლევა ღირებულ ინფორმაციას, მაგრამ შეიძლება მნიშვნელოვნად გაუმჯობესდეს. როგორც ითქვა, ძალიან შრომა იქნებოდა ახლა ძალიან ცოტა გაკვეთილის გადამუშავება. მართლაც, რადგან პრე-ალფა სტადიაში ვართ, თამაში ძალიან სწრაფად ვითარდება და ერთი კვირიდან მეორეში სრულიად ახალი ფუნქციის დანერგვა შეიძლება. ამიტომ, სჯობს დაველოდოთ გეიმპლეის ბირთვს ჩვენი შეხედულებისამებრ, სანამ ახალი ტუტორიალი შევქმნით. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ჰორიზონტალური პროგრესი

ჩვენ ვგეგმავთ გადავიდეთ ვერტიკალურ პროგრესირებაზე და მეტი ფოკუსირება მის ჰორიზონტალურ კოლეგაზე მოთამაშზე დაფუძნებული პროგრესის შემუშავებისას. ჰორიზონტალური სისტემის ხიბლი იმაში მდგომარეობს, რომ ის საშუალებას აძლევს თითოეულ შეხვედრას გარკვეული საშიშროება ჰქონდეს, მაშინაც კი, როდესაც დაბრუნდებით, რაც შეიძლება აღწერილი იყოს, როგორც შინაარსის უფრო ადრეულ სფეროებში. ეს არ ნიშნავს იმას, რომ მოთამაშე ვერასოდეს გაძლიერდება, რადგან მნიშვნელოვანია გარკვეული ხარისხის ვერტიკალურობა, რათა დაეხმაროს მოთამაშეებს თამაშის ადრინდელ ეტაპებზე მუშაობისას, თამაშის მექანიკის და სხვა ფუნდამენტური სისტემების სწავლისას, რომლებიც მოეწყობა თამაშის დიდ ნაწილს, რომელიც ჰორიზონტალურია. ამის გასაფართოვებლად, Veloren დაინახავს ვერტიკალურობის სამ იარუსს და ჰორიზონტალურობის ორ იარუსს მექანიზმის ნახვისას. ეს დონეები აღწერილია, როგორც T1, T2, T3A და T3B, ხოლო ეს უკანასკნელი ორი ერთმანეთის ჰორიზონტალური ვარიანტია, სადაც B ვარიანტი მოქმედებს, როგორც A-ს უფრო ნიშური ვერსია, მაგრამ მაინც ისეთივე ძლიერი და გამოსაყენებელია.

მიუხედავად იმისა, რომ არსებობს ვერტიკალურობის ხარისხი, როგორც უკვე აღვნიშნეთ, თამაშის დიდი ნაწილი ფოკუსირებულია ასპექტებზე, რომლებშიც ვერტიკალურობა ტრივიალურია. ამის ნაცვლად, ჩვენ ვამხნევებთ და გვსურს დავინახოთ მოთამაშის უნარი, გაუმკლავდეს რთულ სიტუაციებს, თამაშის დიდი ცოდნისა და გამოცდილების ქონებით აღნიშნულ გამოწვევასთან გამკლავებაში. გარდა ამისა, ჩვენ გვსურს წავახალისოთ ჯგუფური თამაში უფრო მოღალატე ერთეულებისთვის, რომლებიც გვხვდება სამყაროში, სადაც მხოლოდ ყველაზე გამოცდილ ადამიანებს შეუძლიათ სოლო ჯგუფზე ორიენტირებული კონტენტის შექმნა დიდი შინაარსითა და რესურსებით (იხილეთ NPC Companions საგზაო რუქის ნაწილი).

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** ახალი იარაღი **

ფარები, ხანჯლები, შუბები/პოლუსები, მშვილდოსნები და სხვა ჯადოსნური იარაღი (გრიმორები, ელემენტარული ხელთათმანები და ა.შ.) ყველაფერი დაგეგმილია. მათზე დამუშავება მოხდება მაშინ, როცა ამჟამინდელ იარაღს ყველა გადამუშავებული ექნება. იარაღი განსახილველია (იფიქრეთ მეკობრულ იარაღზე და არა თანამედროვე იარაღზე). ზოგიერთი სხვა კითხვა მოიცავს სროლის იარაღის დამატებას და სროლის იარაღის საბრძოლო მასალის არსებობას. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

** რეცეპტები **

ჩვენ ვგეგმავთ თამაშში გვქონდეს რეცეპტები, რათა გავაფართოვოთ crafting gameplay. ამ დროისთვის, ყველა ხელნაკეთობა გახსნილია დასაწყისში, რაც ამცირებს კვლევისა და პროგრესის გრძნობას. რეცეპტების ქონა უფრო ღრმა ფენას შემატებს ხელოსნობის სისტემას სხვა მექანიკასთან მიბმის გზით, მაგალითად, ქვესტებთან. ამ ფუნქციის განვითარება ადრეულ ეტაპებზეა, ამიტომ ბევრი დეტალი და განხორციელების გეგმები ჯერ კიდევ უნდა იყოს განხილული. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

** სამუშაო ადგილები / პროფესიები **

Veloren-ს ექნება სამუშაოები და პროფესიები მრავალფეროვანი. ჯერჯერობით მხოლოდ მექანიკოსი გვაქვს დაგეგმილი, მაგრამ კონკრეტული განხორციელების გეგმა არ გვაქვს. ზოგიერთი სამუშაო მოიცავს ალქიმიას, სამზარეულოს, მჭედლობას, ნადირობას, სამთო მოპოვებას, ხის ჭრას, ვაჭრობას და ა.შ. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** NPC კომპანიონები **

Veloren-ის ერთ-ერთი ფუნდამენტური წინაპირობაა ის, რომ მოთამაშეები არაფრით განსხვავდებიან მსოფლიოს მაცხოვრებლებისგან. ეს ნიშნავს, რომ ჰუმანოიდური NPC-ები მუდმივად უნდა ურთიერთობდნენ სამყაროსთან ისე, როგორც მოთამაშეები, რათა შეეცადონ თამაშში სიცოცხლე შეიტანონ. რადგან მოთამაშეებს შეუძლიათ ერთმანეთთან გაერთიანება, ჩვენ გვინდა ვიხილოთ თავგადასავლების მოყვარული NPC-ები, რომლებიც ქმნიან წვეულებებს ერთმანეთთან და მოთამაშეებთან. ეს შეიძლება გაკეთდეს ავანტიურისტი NPC-ის კეთილგანწყობის მოპოვებით ან მათი საქონლის დაქირავებით.

რატომ არის ეს სასურველი?

გარდა ზემოაღნიშნული დადებითი მხარეებისა, ის უზრუნველყოფს მსოფლიოსთვის, ის ასევე წარმოუდგენლად მნიშვნელოვანი წინაპირობაა საბრძოლო ბალანსის გულისთვის. ერთეულების დიდი ნაწილი შეიქმნება იმ ვარაუდით, რომ მხეცის მოკვლას ჰუმანოიდების ჯგუფი დასჭირდება. ეს საშუალებას აძლევს ინდივიდებს, რომლებიც თამაშობენ ერთ მოთამაშეზე, განიცადონ ისეთივე კონტენტი, როგორიც მულტიპლეიერში, გარდა იმ ინდივიდებისა, რომლებიც თამაშობენ მულტიპლეიერში, რომლებსაც უჭირთ წვეულების შექმნა სხვებთან და/ან ურჩევნიათ დამოუკიდებლად თამაში.

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** შენახვა / საბანკო მომსახურება **

ბანკინგი არის სასურველი ფუნქცია თამაშის მომავალში. ჩვენ გვსურს, რომ მსხვილ ბანკებს ჰქონდეთ რაიმე სახის ბანკი, რომელიც საშუალებას აძლევს მათ შეინახონ მათში არამაფუჭებელი ნივთები ფასის საფასურად. ამ ნივთების ამოღება შესაძლებელია სხვა ქალაქების სხვა ბანკებში, თუ მათ აქვთ შესაბამისი რესურსი ამისათვის. ამის მაგალითი იქნება, თუ მოთამაშემ უნდა წარადგინოს X-troll დამალვა ქალაქის A-ს ბანკში და შემდეგ გაემგზავროს B ქალაქში, მან შეიძლება ვერ შეძლოს ტროლის დამალვის ამოღება, თუ ქალაქს აქვს ტროლების ნაკლებობა მათ სიახლოვეს, და შემდგომში აკლია მასალა ბანკის მარაგში.

ასეთი სისტემა სასურველია, რადგან ის უზრუნველყოფს შინაარსს, თანმიმდევრულობას Veloren-ის სამყაროში და როლური თამაშის შესაძლებლობებს. Veloren-ში გვსურს შემოგთავაზოთ მრავალფეროვანი არჩევანი სამყაროსთან ურთიერთობის შესახებ. ეს შეიძლება მერყეობდეს როლური თამაშიდან, როგორც კეთილშობილური ავანტიურისტი, წვეულებამდე თაღლითურ ავაზაკებთან ერთად, რომლებიც აპირებენ ქალაქის ადგილობრივი ბანკის გაძარცვას.

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• **საბინაო **

ჩვენ ნამდვილად გვსურს საშუალება, რომ მოთამაშეებს ჰქონდეთ უფრო მყარად ყოფნა Veloren-ის სამყაროში. აქედან გამომდინარე, დაგეგმილია საცხოვრებელი, როგორც მექანიკოსი, მაგრამ ამჟამად არ არსებობს შესრულების კონკრეტული გეგმა, რადგან ის ეყრდნობა ძირითად სისტემებს, რომლებიც ჯერ არ არის დასრულებული. ზოგიერთი კითხვა, რომელიც ამჟამად გვაქვს, არის:

1. როგორ შეგვიძლია გავაგრძელოთ იგი რუკის ცვლილებებით?
2. როგორ დავაკავშიროთ ის ჩვენს rtsim2 სისტემასთან?
3. როგორ მოვაწყოთ უძრავი ქონების ბაზარი?

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** სერვერების ფედერაცია **

საბოლოოდ, ჩვენ გვსურს გვქონდეს “ფედერაციის” სისტემა Veloren სერვერებისთვის, რომელიც საშუალებას მისცემს სანდო სერვერებს ჩართონ პერსონაჟების გადაცემა (და შესაძლოა ეკონომიური გაზიარებისა და კომუნიკაციის სხვა ასპექტები) ერთმანეთთან. გაითვალისწინეთ, რომ ზოგადად, არ არსებობს კარგი გზა მსოფლიოს ან მოთამაშის მონაცემების ავთენტიფიკაციისთვის, რომლებიც გენერირებულია მესამე მხარის სერვერების მიერ, ამიტომ ფედერაციის ყველა სერვერმა უნდა ენდოს ერთმანეთს, რომ იმოქმედონ კანონიერად. გაითვალისწინეთ, რომ ეს არის გრძელვადიანი ფუნქცია, რომელსაც არ აქვს კონკრეტული განხორციელების გეგმა ან ვადები, ამიტომ ნაკლებად სავარაუდოა, რომ ეს მალე მოხდეს. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** რეპუტაციის სისტემა (RTSim) **

ჩვენი მიზანია გვქონდეს რეპუტაციის სისტემა RTSim-ის გამოყენებით, რომელშიც მოთამაშეთა მოქმედებები ახსოვთ NPC-ებს და შეუძლიათ გავლენა მოახდინონ მათ გარშემო არსებულ სამყაროზე. ეს სისტემა ამჟამად ადრეულ სტადიაზეა, სადაც NPC-ები დაიმახსოვრებენ და თავს დაესხმებიან თქვენ, თუ თქვენ მოკალით NPC გასულ საათში და დაინახეთ. ჩვენ ვგეგმავთ სისტემის გაფართოებას, რათა შევქმნათ მეტი სცენარი, რომელიც განამტკიცებს სამყაროს თანმიმდევრულობას. მაგალითად, რეპუტაციას შეუძლია მოთამაშეს მისცეს წვდომა ფრაქციის შეზღუდულ ზონებში, ან მისცეს მათ შესაძლებლობა, ურთიერთქმედონ კონკრეტულ ქვესტში მათი წარსული ქმედებების გამო. ეს მნიშვნელოვნად გააძლიერებს როლური თამაშის ელემენტებს თამაშში, რადგან ყველა მოქმედებას ექნება პოტენციური შედეგები. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• მსოფლიო რუკა

ჩვენ აუცილებლად ვგეგმავთ გვქონდეს უფრო დიდი რუკა, უფრო დიდი ბიომებით და მეტი ბიომის ტიპებით. თუმცა, არსებობს ორი ძირითადი მიზეზი, რის გამოც ჩვენ ამას ამჟამად არ ვაკეთებთ. პირველი, ზოგიერთი worldgen ინსტრუმენტი და სისტემა არ არის შემუშავებული ან ოპტიმიზირებული, რაც ამჟამად ზიანს აყენებს ლანდშაფტის ხარისხს და შესრულებას. ასეთ გაუმჯობესებას დიდი დრო და კვლევა სჭირდება. მეორეც, გეიმპლეის თვალსაზრისით, Veloren არ არის მზად, რომ იყოს ბევრად უფრო დიდი მასშტაბის რუკაზე: ჩვენ უნდა გვქონდეს მეტი კავშირი რეგიონებს შორის, მეტი აქტივობა სამყაროში, უკეთესი მოგზაურობის საშუალებები და საერთო ჯამში მოგზაურობის მეტი მიზეზი.

ჩვენ ვგეგმავთ რუკის გაფართოებას 262x262 კმ^2-მდე და გვქონდეს ოკეანეები და კონტინენტები და არა მხოლოდ ერთი დიდი ხმელეთი. ზოგიერთი დამატებითი ბიომი მოიცავს ოკეანეებს, ველურებს, დაბლობებს, ჭაობებს, ტყეების სხვა ტიპებს, როგორიცაა ბამბუკი, უფრო ჯადოსნური/ფანტასტიკური ბიომები და ა.შ.

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** ფრაქციები / სამეფოები / ომები **

rtsim2-ის წყალობით, ჩვენ გვსურს გვქონდეს ორგანული ფრაქციები/სამეფოები, რომლებიც შეძლებენ მონაწილეობა მიიღონ ძალაუფლების ბრძოლაში ერთმანეთს შორის და საკუთარ თავში. ამრიგად, დიპლომატიური რუკა დროთა განმავლობაში განვითარდება Veloren-ის მსახიობების მოქმედებების გამო. გაითვალისწინეთ, რომ ეს არის ძალიან გრძელვადიანი დაგეგმილი მექანიკა და რომ ძირითადი მექანიკა საჭიროებს განვითარებას და გაფართოებას, სანამ ასეთი ფუნქცია გამოჩნდება თამაშში. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** მოდიფიკაციები და დანამატები **

ჩვენ ნამდვილად გვინდა მოდიფიკაციები და დანამატები თამაშში. ზოგიერთი გადაწყვეტილება, რომელსაც ჩვენ ვიღებთ, შეიძლება ყველას არ მოეწონოს, ამიტომ მიგვაჩნია, რომ მნიშვნელოვანია, რომ ყველას თავისუფლად და მარტივად შეუძლია შეცვალოს თამაში თავის მხარეს. პროექტების ღია კოდის ასპექტი გაზრდის თამაშის მოდიფიკაციის პოტენციალს. #learning არხი ჩვენს Discord-ში ასევე ღიაა ყველასთვის, ვისაც აქვს შეკითხვები კოდირებასთან ან თამაშის ნებისმიერ ასპექტთან ან პროგრამებთან დაკავშირებით, რომლებშიც შეგვიძლია დაგეხმაროთ.

დანამატების ზოგიერთი იდეა არის ის, რომ ისინი ააქტიურებენ (აღმავალი სირთულის მიხედვით):

1. თამაშში ახალი მოდელების (ჯავშნის), გრაფიკის, რონზე დაფუძნებული სტატისტიკის დამატება
2. ახალი ანიმაციების, იარაღის უნარების, NPC-ების, სტრუქტურების (გემების) დამატება
3. ლოგიკური ქცევა სპრაიტის ურთიერთქმედებისთვის (შორეული მომავალი) მე მსურს, რომ პლაგინები გადმოიწეროს სერვერიდან კავშირზე (მაგრამ ადგილობრივად ქეშირებული იყოს საწყისი გამტარუნარიანობის შესამცირებლად).

დანამატებზე მომუშავე ჩვენს დეველოპერებს ასევე სურთ გამოიყენონ wasm კომპონენტის მოდელის ტექნოლოგია (WASI preview2), რათა ჩართონ დანამატები Rust, C/++, Python, JavaScript და შესაძლოა სხვა ენებზე. ეს საშუალებას მისცემს სერვერებს განასხვავონ კიდევ უფრო განსხვავებული თამაშის შინაარსი.

დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

** განხილული მახასიათებლები: **

• ინვენტარის გადამუშავება

ამჟამინდელი ინვენტარიზაციის სისტემა დიდ გავლენას ახდენს ახალი ელემენტების შემოტანით, რადგან ის დაფუძნებულია სლოტებზე. ის ხელს უწყობს ნივთების დაგროვებას, ხოლო მასალების მრავალფეროვნებას ზღუდავს. საუბარია წონაზე დაფუძნებულ სისტემაზე გადასვლის შესახებ, რომელიც მოხსნის ნივთების შემოტანის შეზღუდვას და საშუალებას მისცემს ინვენტარის უფრო ღრმა/მნიშვნელოვან მართვას. თუმცა, დასკვნა ჯერ არ არის მიღებული, ამიტომ ბევრი დეტალი ჯერ კიდევ განსახილველია. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• შენობა

ძირითადი დეველოპერების უმრავლესობას, თუ არა ყველას, სურს რაიმე სახის შენობის სისტემა. აქედან გამომდინარე, უსაფრთხოა ვივარაუდოთ, რომ შენობის სისტემას შეუძლია დღის სინათლე დაინახოს. თუმცა, ასეთი მექანიკის ირგვლივ უამრავი კითხვაა, რადგან ის უპირველეს ყოვლისა RPG-ია. პირველი, უფასო შენობა არ იქნება (იხ. საგზაო რუქის ნაწილი უფასო შენობა). თუმცა, ეს არის ერთადერთი, რაც გარკვეულია თამაშის ოფიციალური ვერსიისთვის შენობასთან დაკავშირებით. ზოგიერთი კითხვა, რომელიც ჩვენ გვაქვს მშენებლობასთან დაკავშირებით, მოიცავს რელიეფის მდგრადობას რუქებს შორის, მექანიკის ხელმისაწვდომობას, სამყაროსთან კავშირს, თავისუფლების დონეს და სხვა. გაითვალისწინეთ, რომ ეს არის გრძელვადიანი ფუნქცია. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** ომის ნისლი / უკეთესი რუქის თამაში **

ამჟამად რუკაზე ნაჩვენებია ყველა დუნდული და რეგიონი რუკაზე. ჩვენ არ ვაპირებთ მის შენარჩუნებას, რადგან ეს ზიანს აყენებს კვლევასა და აღმოჩენას. ომის ნისლი უფრო სავარაუდოა, ვიდრე დაგეგმილია, მაგრამ მისი განხორციელების დეტალები ჯერ არ განიხილება. ზოგიერთი კითხვა, რომელიც ჩვენ გვაქვს, ეხება რუქის აღმოჩენის ირგვლივ თამაშის ციკლს, ანუ უნდა განვიხილოთ სხვადასხვა გზები, რომლითაც მოთამაშე შეძლებს რუკის აღმოჩენას და სხვადასხვა საიტების მონიშვნას. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

** დაუგეგმავი ფუნქციები: **

• ** შემთხვევები **

ინსტანციები არ არის თავსებადი ჩვენს მიერ დაგეგმილ ბევრ ძირითად სისტემასთან. იმის გამო, რომ ჩვენ გვინდა გვქონდეს ორგანული დუნდულები (იხ. საგზაო რუქის დუნდულის ნაწილი), ჩვენ არ შეიძლება გვქონდეს შემთხვევები, რადგან ეს გავლენას მოახდენს მსოფლიო თანმიმდევრულობაზე და ძირითადი სისტემების სინერგიებზე. უფრო მეტიც, ჩვენ გვჯერა, რომ სხვადასხვა მსახიობს უნდა შეეძლოს გავლენა მოახდინოს დუნდონის ევოლუციასა და განვითარებაზე. დასასრულს, ინსტანციებს შეუძლიათ იმუშაონ ტრადიციული რეიდი დუნდულის სისტემაში, მაგრამ ეს არ არის ის, რაც ჩვენ დავგეგმეთ დუნდულებისთვის. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ტელეპორტაცია

სწრაფი მოგზაურობა არის მექანიკა, რომლის ნახვაც არ გვინდა Veloren-ში, რადგან ის ტრივიალიზებს ბევრ დაგეგმილ სისტემას, როგორიცაა მსოფლიო ეკონომიკა. ტელეპორტაცია გულისხმობს გარკვეული იშვიათი მასალის მყისიერად გადატანის უნარს მსოფლიოს ერთი ბოლოდან მეორეში. ეკონომიკური სისტემისთვის, რომელიც ეყრდნობა მიწოდების სიმცირის ცნებას, რომელიც დამოკიდებულია გარემოზე და, შესაბამისად, ღირებულების შემდგომ ზრდაზე, ეს მექანიკოსი მას მთლიანად დაუპირისპირდება. მიუხედავად იმისა, რომ სწრაფი მოგზაურობა არ არის სასურველი, ჩვენ გვსურს ვნახოთ fast_er_ მოგზაურობები, როგორიცაა საჰაერო ხომალდები, მატარებლები, საზღვაო გემები და სხვადასხვა სამაგრები, რათა კვლავ დაამყაროს მსოფლიო თანმიმდევრულობა და წაახალისოს ველორენის მშვენიერი სამყაროს შესწავლა. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• უფასო შენობა

უფასო მშენებლობა Minecraft-ის მსგავსი არ არის ის, რაც თავსებადია იმ თამაშის სტილთან, რომლის მიზანია Veloren. პირველი, ჩვენ გვაქვს სასრული რუკა, ასე რომ რუკა სწრაფად შეივსება უზარმაზარი პოპულაციით. შემდეგ, ჩვენ გვსურს შევინარჩუნოთ სამყაროს თანმიმდევრულობა, როგორც ესთეტიურად, ასევე გეიმპლეის თვალსაზრისით, ანუ გვინდა შევინარჩუნოთ ხელოვნების მიმართულება და ხარისხი, ამასთან ერთად ავიცილოთ უხამსობა თავისუფალი მშენებლობის გზით. შემდეგ, ჩვენ უნდა მივაკავშიროთ ეს შენობები ცივილიზაციას და ჩვენს rtsim2 მახასიათებელს, რომელიც, სავარაუდოდ, შეუთავსებელია ისეთ მექანიკასთან, როგორიცაა თავისუფალი შენობა. აღსანიშნავია, რომ თამაში არის უპირველეს ყოვლისა RPG და არა Survival/Sandbox სამშენებლო თამაში, როგორიც არის Minecraft. იმისათვის, რომ სამყარო იყოს თანმიმდევრული და RPG ელემენტები დარჩეს ბირთვში, ჩვენ ნამდვილად არ შეგვიძლია დავუშვათ უფასო აშენება მთავარ თამაშის რეჟიმში. (მთავარი თამაშის რეჟიმით ვგულისხმობთ, რომ ადამიანებს შეუძლიათ თავისუფლად შექმნან თამაშის სხვა რეჟიმები, სადაც უფასო შენობა იმუშავებს. იფიქრეთ კრეატიულ/ღმერთის მოდებზე სხვა თამაშებში, როგორც თამაშის პოტენციურ რეჟიმებზე. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** ერთმოთამაშიანი პერსონაჟები Multiplayer-ში **

იმის გამო, რომ ყველა არის ადმინი ერთმოთამაშში, ჩვენ არ შეგვიძლია ერთმოთამაშიანი პერსონაჟების გადატანა ოფიციალურ MP სერვერზე, რადგან ამან შეიძლება სწრაფად გაანადგუროს თამაშის ეკონომიკა და ბალანსი. დაგეგმილია სერვერის იერარქია, სადაც შეგიძლიათ გადახვიდეთ სერვერზე „ქვემოთ“ სერვერზე, რომელზეც ამჟამად იმყოფებით „სერვერის ნდობის“ თვალსაზრისით, მაგრამ ვერ ახვიდეთ ზემოთ. ეს საშუალებას მისცემს მოთამაშეებს შეინარჩუნონ თავიანთი პერსონაჟები ერთ მოთამაშეში, სერვერის ბედის მიუხედავად. თუმცა, ასეთ ფუნქციას დიდი დრო სჭირდება და მოკლევადიან პერსპექტივაში არ არის დაგეგმილი. თქვენ ასევე შეგიძლიათ შეამოწმოთ სერვერის ფედერაციის განმარტება დამატებითი დეტალებისთვის. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

• ** Vanity Slots / Transmog:**

ჩვენ არ გვინდა ამაოების სისტემა, რადგან გვსურს მოთამაშემ/NPC-მ შეძლოს იმის თქმა, თუ რამდენად ძლიერია ერთეული დაფუძნებული ხილულ აღჭურვილობაზე. ჩვენ ასევე არ გვინდა ეს უბრალოდ როლური მიზნებისთვის. თუ მოთამაშეს სურს გარკვეული გზით გამოიყურებოდეს როლური თამაშებისთვის, მან ასევე უნდა აიტანოს ამ გადაწყვეტილების შედეგები. სხვა შენიშვნით, თუ მოთამაშეებს ნამდვილად სურთ შეცვალონ თავიანთი გარეგნობა, მათ შეუძლიათ ამის გაკეთება თავის მხრივ, შეცვლილი ნივთის .vox ფაილები. ამგვარად, ის მხოლოდ მათთვის იქნება ხილული და არ იმოქმედებს სხვა მოთამაშეების გამოცდილებაზე. დამატებითი ინფორმაციისთვის, მოგერიდებათ დაგვიკავშირდეთ Veloren Discord-ზე.

განვითარების ფილოსოფია

🔭 ფართო სპექტრი

Veloren-ის სამყარო დიდი და ვრცელია და ჩვენ მოვუწოდებთ თამაშის მრავალფეროვან გზებს, ასევე მრავალფეროვანს ელემენტები, რომლებიც ამდიდრებენ გამოცდილებას. არ არსებობს ერთი, კონკრეტული მიზანი ან ფოკუსირება და ჩვენ გვჯერა, რომ ეს დააზარალებს ფართოს საზოგადოება თუ შემოიღეს.

🗽 მოთამაშის თავისუფლება

სადაც შესაძლებელია, მოერიდეთ „უხილავ კედლებს“ (როგორც პირდაპირი, ისე მეტაფორული), რომლებიც თვითნებურად არღვევენ თანმიმდევრულობას და ზღუდავს რისი გაკეთება შეუძლიათ მოთამაშეებს. თუ შეზღუდვები უნდა არსებობდეს ტექნიკური, ბალანსის, თამაშის ან ზომიერების მიზეზების გამო, მაშინ სცადეთ იპოვონ ამ შეზღუდვების მსოფლიო გამართლება.

🧩 მოდულურობა და გაფართოება

სადაც ეს შესაძლებელია და სადაც ეს არ აყენებს დრამატულ შეზღუდვებს მომავალ განვითარებაზე, Veloren უნდა ეცადოს იყოს მოდულარული ისე, რომ პროექტის განსხვავებული კომპონენტები შეიძლება ხელახლა იქნას გამოყენებული და ინტეგრირებული იყოს სხვადასხვა პარამეტრებში. სად შესაძლებელია, ფუნქციები უნდა იყოს მცირე, თვითშესწორებადი, უხეში და შეუძლია იმუშაოს მრავალფეროვან გარემოში (დიდი ამის მაგალითია Controller/Agent/CharacterState კოდი, რომელიც განზოგადებულია ყველა მოთამაშეზე, NPC-ზე და თუნდაც არამგრძნობიარე სუბიექტები).

🫱🏼‍🫲🏾 საზოგადოებაზე ორიენტირებული

განვითარება საზოგადოებასთან დიალოგით უნდა მოხდეს. მაშინ როცა Veloren აუცილებლად მართავენ ყველაზე აქტიურებს წევრები, მნიშვნელოვანია გავითვალისწინოთ უკუკავშირი პერიფერიიდან: ნაკლებად აქტიური დეველოპერები, მოდერატორები, მხატვრები, მოთამაშეები, ისევე როგორც მესამე მხარეები, როგორიცაა პროექტის მიერ წარმოებული პროგრამული უზრუნველყოფის მომხმარებლები. ველორენი უნდა აქტიურად ეწინააღმდეგება მცდელობებს, რომ პროექტი გადააქციოს მომგებიან საწარმოდ, თანხების მოზიდვით და ფინანსებით გონივრულად გამოყენებული. ძირითადი მიზანია გაზარდოს ძირითადი პროექტი, მოთამაშის გამოცდილება და ზემოთ/ქვემო დინების პროექტები.

🗺 ტელეოლოგიური

Veloren ხაზს უსვამს თამაშს და სისტემებს, რომლებიც წარმოიქმნება მარტივი, ფიზიკურად დაფუძნებული წესების გამოყენების შედეგად შესაძლებელია. სისტემები უნდა იყოს მარტივი, ურთიერთდაკავშირებული, თვითდაბალანსებული და მარტივი იზოლირებულად: რთული და საინტერესო ქცევა უნდა წარმოიქმნას სისტემებს შორის ურთიერთქმედების შედეგად და არა რომელიმე სირთულის გამო სისტემა.

თამაშის კითხვები

• არსებობს სიკვდილით დასჯა?
• აქვს ვოქსელის შენობა?
• რუკა უსასრულოა?
• არის სწრაფი მოგზაურობა?
• შეგვიძლია გვქონდეს კოსმეტიკური ჯავშანი ფაქტობრივი ჯავშანტექნიკის ზემოთ?
• იქნება თუ არა მფრინავი სამაგრები?
• არსებობს საგზაო რუკა?
• თამაში გამოვა Steam-ზე?
• გვაქვს ფარები?
• როგორ გავიღოთ შემოწირულობა?
• ჩვენ შევძლებთ თამაშში აშენებას?
• როგორ გავხდე მოდერატორი?
• დაამატებენ თუ არა Veloren-ის კონტრიბუტორები NFT-ს და კრიპტო თამაშს?
• თამაშს ოდესმე ექნება გადამხდელი კონტენტი?
• შემიძლია გამოვიყენო ნავები ან საჰაერო ხომალდები
• დუნჯები შეიცვლება?
• როდის გამოვა “X” ფუნქცია?

ტექნიკური საკითხები/კითხვები

• საჰაერო ხომალდი ჩამოვარდა გაშვებისას.
• თამაში იშლება გაშვებისას.
• სერვერთან დაკავშირება შეუძლებელია.
• თამაში ჩამორჩება.
• რა პროგრამულ უზრუნველყოფას იყენებთ მოდელებისთვის?
• როგორ ჩამოტვირთოთ თამაში Mac-ზე და Linux-ზე?
• როგორ მოვაწყოთ სერვერი?
• მოდიფიკაციები იქნება?
• შემიძლია ელფოსტა დავამატო ჩემს ანგარიშზე პაროლის შესაცვლელად?
• რამდენად ხშირად ახლდება თამაში?
• როგორ შევცვალოთ ანგარიშის პაროლი
• იქნება თუ არა მომხმარებლის წვდომის პანელი ვებსაიტზე ანგარიშებისთვის?
• შემიძლია გადავიტანო ჩემი პერსონაჟი სერვერებს შორის?
• “Veloren არის ღია წყარო და საზოგადოებაზე ორიენტირებული” როგორ გეგმავთ ერთდროულად ძალიან ბევრი მიმართულებით სიარულის პრობლემის დაძლევას? გეგმავთ თამაშის ერთზე მეტი ვერსიის შექმნას ან იმედოვნებთ, რომ ძალიან ბევრი ფუნქცია არ დაარღვევს კოდს/თამაშის იდენტურობას და ა.შ.?

პასუხები

არსებობს სიკვდილით დასჯა?

დიახ, მოთამაშეები დაღუპვისას კარგავენ ხელსაწყოების გამძლეობას.

არის ვოქსელის შენობა?

არსებობს გარკვეული განადგურება - შეგიძლიათ მადნის ნატეხები და გარკვეული სახის კლდეების მოპოვება მწკრივით.

Building არ არის გამიზნული, რომ იყოს თამაშის ძირითადი ნაწილი და ამჟამად ხელმისაწვდომია მხოლოდ სერვერის ადმინისტრატორებისთვის და ერთი მოთამაშის რეჟიმში ბრძანებების საშუალებით. დაწვრილებით ამის შესახებ შეგიძლიათ წაიკითხოთ აქ.

რუკა უსასრულოა?

რუკა სასრულია და ასე დარჩება. სასრული რუკის არსებობის მრავალი მიზეზი არსებობს, ერთი მათგანი საშუალებას გვაძლევს გავაკეთოთ მოწინავე სიმულაცია (ეროზია, ეკონომია და ა.შ.). რაც ქმნის უფრო მნიშვნელოვან და თანმიმდევრულ სამყაროს. ეს არ ნიშნავს იმას, რომ ჩვენ არ შეგვიძლია დიდი სამყარო გვქონდეს.

არის სწრაფი მოგზაურობა?

დაგეგმილია უფრო სწრაფი მგზავრობა: ოდესღაც საჰაერო ხომალდები და გემები გამოდგება ქალაქთაშორისი მოგზაურობისთვის და შეიძლება იყოს სხვა სატრანსპორტო საშუალებებიც (მიწისქვეშა მატარებლები და ა.შ.). კონტრიბუტორები, როგორც წესი, არ იხრებიან სწრაფი მოგზაურობისკენ მყისიერი ტელეპორტაციის გაგებით, რადგან ეს ხელს უშლის ძიებას და შეიძლება გავლენა იქონიოს ეკონომიკაზე და მსოფლიოს თანმიმდევრულობაზე, რადგან სავაჭრო საქონლის ტრანსპორტირება თავისუფლად შეიძლებოდა.

შეიძლება გვქონდეს კოსმეტიკური ჯავშანი ფაქტობრივ ჯავშანზე მაღლა?

კონტრიბუტორებს, როგორც წესი, არ სურთ კოსმეტიკური ჯავშნები, რომლებიც გამოჩნდებიან რეალურ ჯავშანზე, რადგან ეს გავლენას მოახდენს NPC-ებთან ჩაძირვაზე, ასევე PvP-ზე. ჩვენ გვსურს, რომ მოთამაშეებმა და NPC-ებმა შეძლონ მოწინააღმდეგის სიძლიერის შეფასება მათი გარეგნობის (გადაწყობის) მიხედვით, კოსმეტიკური ჯავშნები ამას ეწინააღმდეგება. მეორეს მხრივ, ჩვენ ვგეგმავთ, გვქონდეს მხოლოდ გარეგნობისთვის განკუთვნილი ხელსაწყოები, როგორც ურბანული სამოსი, რომელიც ქალაქებში შეგიძლიათ ჩაიცვათ. ის ჩაანაცვლებს თქვენს ჯავშანს და არ გამოჩნდება მის ზემოთ.

იქნება მფრინავი სამაგრები?

ამ საკითხში მონაწილეები იყოფა, მაგრამ საერთო შეთანხმება არის ის, რომ მფრინავი სამონტაჟოები შეიძლება გახადონ თამაშის გარკვეული ნაწილის გამოტოვება (საჰაერო მოგზაურობა განსაკუთრებით საჰაერო ხომალდებით), მაგრამ ჩვენ ვფიქრობთ, რომ სწორი მიდგომით და დაბალანსებით მფრინავი სამაგრები შეიძლება იყოს გრძელვადიან პერსპექტივაში.

არსებობს საგზაო რუკა?

დიახ! შეგიძლიათ იპოვოთ იგი ამ გვერდზე.

ნამდვილად არა. ამის მიზეზი ის არის, რომ ეს არის ჰობი პროექტი, რომელზეც ბევრი კონტრიბუტორი მუშაობდა და არ არის იმის ცოდნა, თუ რა ფუნქცია გამოვა პირველი ან რომელ ფუნქციაზე იმუშავებს შემდეგ. ყველაზე ახლოს, რაც შეგვიძლია შემოგთავაზოთ, არის ჩვენი # სამუშაო ჯგუფების არხების ნახვა Discord-ზე, სადაც შეგიძლიათ ნახოთ რაზე მუშაობს. ასევე, ყოველკვირეული ბლოგის პოსტები დაგეხმარებათ გაიგოთ, რა არის დაგეგმილი მომავალში.

გამოვა თამაში Steam-ზე?

ჩვენ ვგეგმავთ მომავალში Steam-ის გამოშვებას, მაგრამ ეს არ მოხდება მანამ, სანამ არ ვიფიქრებთ, რომ საკმარისი კონტენტი იქნება Steam-ისთვის მზადყოფნაში. ჩვენ გვჯერა, რომ Steam-ის გამოშვებამ შეიძლება სამუდამოდ გადააგდოს ზოგიერთი მოთამაშე, თუ ისინი არ არიან კმაყოფილი პირველი ვერსიით, რომელსაც თამაშობენ. უფრო მეტიც, ამ დროისთვის თამაში ბევრს არ უნდა ეთამაშა, რადგან ის პრე-ალფაშია. ბევრ მოთამაშეს ექნება მოთხოვნები და მოლოდინები, რომლებიც აღემატება პრე-ალფა კონტენტის მოთხოვნებს, რამაც შეიძლება ზიანი მიაყენოს Veloren-ის კარგ განვითარებას.

გვექნება ფარები?

და სხვა სახის იარაღი? დიახ, დაგეგმილია ფარები და სხვა იარაღები, მაგრამ ჩვენ დავიწყებთ მათზე მუშაობას მხოლოდ მოდულური იარაღისა და უნარების რემონტის განახლების დასრულების შემდეგ, რადგან გვსურს, რომ მიმდინარე იარაღი იყოს იქ, სადაც ჩვენ გვინდა, სანამ ახალზე ვიმუშავებთ.

როგორ გავიღოთ შემოწირულობა?

Veloren-ის მხარდაჭერა შეგიძლიათ აქ: https://veloren.net/donate. ყველა შემოწირულობა გადადის სერვერის შენარჩუნებასა და მართვაში.

შევძლებთ თამაშში აშენებას?

დიახ და არა. ამჟამად აშენება შესაძლებელია ზოგიერთ სერვერზე, რომელიც განკუთვნილია მისთვის ან singleplayer-ში, build-ის რეჟიმით. მაგრამ, გრძელვადიან პერსპექტივაში, ჩვენ არ ვგეგმავთ ისეთივე უფასო შენობას, როგორც ეს არის Minecraft-ზე, რადგან ეს შეიძლება გავლენა იქონიოს Veloren-ის RPG ელემენტზე. უფასო შენობა გავლენას მოახდენს რეალურ დროში სიმულაციაზე. კიდევ ერთი მიზეზი ის არის, რომ, სამწუხაროდ, მოთამაშეების მიერ შექმნილი ყველა ნაგებობა არ შეესაბამება თამაშის არტ სტილს, რამაც შეიძლება გავლენა მოახდინოს სხვა მოთამაშეების გამოცდილებაზე. თუმცა, არ არის გამორიცხული, რომ შეგეძლოთ თქვენი სახლის შიგნიდან მორგება ქალაქში ან ქალაქში წინასწარ დამზადებული აქტივებით.

დაამატებენ თუ არა Veloren-ის კონტრიბუტორები NFT და კრიპტო თამაშს?

მარტივად რომ ვთქვათ, არა. ჩვენ არ გვინდა რაიმე სახის კრიპტო-ს დამატება და არც მასთან მიბმული. თუ ხედავთ Veloren-თან დაკავშირებულ კრიპტოვალუტებს ან NFT-ებს, გთხოვთ გაითვალისწინოთ, რომ ეს არ არის თამაშის ოფიციალური ნაწილი და რომ ჩვენ არ ვართ პასუხისმგებელი იმაზე, თუ რას აკეთებთ მასთან.

ექნება თამაშს ოდესმე გადამხდელი კონტენტი?

არა. ოფიციალური გუნდის მიერ გაკეთებული ყველაფერი უფასო იქნება. ჩვენ გვინდა, რომ ყველა მომხმარებელს ჰქონდეს იგივე სათამაშო გამოცდილება.

შემიძლია გამოვიყენო ნავები ან საჰაერო ხომალდები?

ამჟამად, არა, ნავები და დირიჟაბლები შეფერხებულია, მაგრამ სამომავლოდ ვგეგმავთ, გვქონდეს სამგზავრო საშუალებები საჰაერო ხომალდებით და გემებით.

საჰაერო ხომალდი ჩამოვარდა გაშვებისას

Airshipper არ მუშაობს ზოგიერთი ადამიანისთვის, შეგიძლიათ სცადოთ თქვენი გრაფიკული დრაივერების განახლება. მაგრამ თქვენ მაინც შეგიძლიათ გახსნათ თამაში Airshipper-ის გამოყენებით კონსოლში ბრძანებით airshipper run.

შეიცვლება დუნდულები?

დიახ. დუნდულები ამჟამად გადამუშავების პროცესშია. ეს არის პროცესი, რომელსაც დრო სჭირდება, რადგან ჩვენ გვინდა, რომ ყველა დუნდული იყოს უნიკალური გეიმპლეიით და გამოცდილებით.

როდის გამოვა “X” ფუნქცია?

ჩვენ არ ვიცით. Veloren-ის ყველა კონტრიბუტორი მუშაობს თამაშზე თავის დროზე, რაც იმას ნიშნავს, რომ არ არსებობს გზა იმის ცოდნა, თუ რამდენად სწრაფად მოხდება რაღაცის შერწყმა თამაშში.

თამაში იშლება გაშვებისას

• Airshipper-ით შეგიძლიათ შეცვალოთ გრაფიკის რეჟიმი დაკვრის ღილაკის გვერდით მდებარე ღეროების დაჭერით. თუ არცერთი გრაფიკული რეჟიმი არ მუშაობს, შეგიძლიათ სცადოთ თქვენი ვიდეო დრაივერების განახლება. წინააღმდეგ შემთხვევაში, თქვენი GPU შეიძლება ძალიან ძველი იყოს Veloren-ის გასაშვებად 😔
• თუ თამაშს კონსოლიდან იწყებთ, შეგიძლიათ გადართოთ გრაფიკის რეჟიმი WGPU_BACKEND გარემოს ცვლადის დაყენებით dx12, dx11 ან vulkan.
• Windows cmd-ში: set WGPU_BACKEND="vulkan"
• PowerShell-ში: $env:WGPU_BACKEND="vulkan"
• macOS-ზე და Linux-ზე: export WGPU_BACKEND="vulkan"

შემდეგ გაუშვით თამაში airshipper run-ით

სერვერთან დაკავშირება შეუძლებელია

ზოგიერთი ადამიანისთვის DNS სერვერის გადართვა აგვარებს ამ პრობლემას. აქ არის სახელმძღვანელო.

უარეს შემთხვევაში, თქვენ მოგიწევთ VPN-ის გამოყენება სერვერთან დასაკავშირებლად.

თამაში ჩამორჩება

• თუ შეფერხების პრობლემა გაქვთ, ეს დაგეხმარებათ ჩართოთ „დაკარგული რელიეფის შეკუმშვა“ და შეამციროთ ხედვის მანძილი გრაფიკის პარამეტრებში. _ შენიშვნა: თამაშის სერვერი მასპინძლობს გერმანიაში, ასე რომ, ველით მაღალ შეყოვნებას, თუ გეოგრაფიულად შორს ხართ._
• თუ თქვენ გაქვთ fps პრობლემები, შესაცვლელი საუკეთესო პარამეტრებია:
• Cloud Rendering რეჟიმი იაფად
• Shadow Rendering Mode None-ზე
• სითხის გადაცემის რეჟიმი იაფად
• აირჩიეთ ქვედა შიდა გარჩევადობა
• განათავსეთ Bloom და Point Glow 0%-ზე.

თუ ჯერ კიდევ გაქვთ პრობლემები fps-თან დაკავშირებით, შეგიძლიათ სცადოთ BareMinimum ექსპერიმენტული შადერის ჩართვა. აქ არის სახელმძღვანელო, თუ როგორ უნდა ჩართოთ ექსპერიმენტული ჩრდილები.

რა პროგრამულ უზრუნველყოფას იყენებთ მოდელებისთვის?

ჩვენ ვიყენებთ MagicaVoxel-ს, შეგიძლიათ ჩამოტვირთოთ აქ: https://ephtracy.github.io/ თუმცა, თუ გნებავთ, შეგიძლიათ გამოიყენოთ სხვა აპლიკაციებიც (Goxel და ა.შ.), მაგრამ ზოგიერთი ფუნქცია, რომელსაც ჩვენ ვიყენებთ, შესაძლოა არ იყოს ხელმისაწვდომი.

როგორ ჩამოტვირთოთ თამაში macOS-ზე და Linux-ზე?

Mac: ნაბიჯები Mac-ზე Airshipper-ის გასაშვებად

1. ჩამოტვირთეთ Airshipper Mac-ისთვის
2. ფაილის მისაღებად გახსენით zip
3. გახსენით ტერმინალი და ჩაწერეთ chmod +x ~/Downloads/airshipper-macos/airshipper
4. ორჯერ დააწკაპუნეთ ფაილზე
5. ჩართეთ გაშვება სისტემის პარამეტრებში > უსაფრთხოება და კონფიდენციალურობა > დაშვება Linux: შეგიძლიათ ჩამოტვირთოთ Linux Airshipper აქ: https://veloren.net/download

როგორ მოვაწყოთ სერვერი?

შემოგვთავაზეთ, გადახედოთ ამას და მიჰყვეთ ნაბიჯებს. თუ რამე არ გესმით, ნუ შეგეშინდებათ დაუკავშირდეთ დეველოპერებს Discord-ზე და მოითხოვეთ დახმარება ჩვენი მრავალი არხით, როგორიცაა #support: ჰოსტინგის სახელმძღვანელო

იქნება მოდიფიკაციები?

დიახ. ეს თამაში არის ღია წყარო, რაც იმას ნიშნავს, რომ ნებისმიერს შეუძლია შეასრულოს პროექტი საკუთარი ხედვით მოდიფიკაციის შესაქმნელად. ჩვენ ვგეგმავთ ამ თამაშში ბევრი მოდიფიკაციის ყოლას!

შემიძლია დავამატო ელფოსტა ჩემს ანგარიშზე პაროლის შესაცვლელად?

ამ დროისთვის (2022-06-07) შეუძლებელია ელფოსტის ანგარიშზე დამატება. ჩვენ ვგეგმავთ მომხმარებლის ანგარიშის პანელის დამატებას, რაც შესაძლებელს გახდის.

რამდენად ხშირად ახლდება თამაში?

ყოველ ხუთშაბათს უნდა გვქონდეს განახლება, მაგრამ თითოეულ განახლებაში კონტენტის რაოდენობა დამოკიდებულია იმაზე, თუ რაზე იმუშავეს კვირაში, რაც საკმაოდ ხშირად განსხვავდება. ჩვენ ასევე გვაქვს ოფიციალური გამოშვებები, რომლებიც მოიცავს უფრო მეტ შინაარსს, ვიდრე ყოველკვირეული განახლებები, რათა ყველა მოთამაშე იყოს ინფორმირებული.

როგორ გავხდე მოდერატორი?

მოდიფიკაცია შედარებით ბუნებრივია.

თუ ვინმე არის გრძელვადიანი, მოლაპარაკე და აქტიური მოთამაშე დისკუსიაში, მაშინ მას სავარაუდოდ აღიარებენ ამჟამინდელი საზოგადოება და მოდერატორებიც. თუ დეველოპერებს სჭირდებათ მეტი მოდერატორი, რათა გაუმკლავდნენ მოთამაშეების ნაკადს, ისინი პირადად დაუკავშირდებიან მათ და ჰკითხავენ, სურთ თუ არა გახდნენ.

როგორ შევცვალოთ ანგარიშის პაროლი?

ამჟამად ვერ შეცვლით პაროლს ჩვენი დაშიფვრის სისტემის მუშაობის გამო. იყო დისკუსია ელფოსტის არჩევით დადასტურებასთან დაკავშირებით. ისინი, ვინც არ აკავშირებს მათ ანგარიშებს, ვერ შეძლებენ თავიანთი პაროლების შეცვლას, როგორც შეიძლება გამოიცნოთ

შემიძლია ჩემი ანგარიშის წაშლა?

თეორიულად, ამჟამად შეგიძლიათ თქვენი ანგარიშის წაშლა. ზოგიერთ დეველოპერს შეუძლია მისი წაშლა (AngelOnFira), მაგრამ ძნელი ამოცანაა, რომ ჩვენ ვცდილობთ ხალხის თავიდან აცილება მოითხოვონ ანგარიშის წაშლა. აბსოლუტურად არანაირი ნაკლი არ არის ანგარიშის შენახვასთან დაკავშირებით, ყველა პაროლი დაშიფრულია. ჩვენ მას ერთხელ დავამარცხებთ კლიენტის მხარეს auth დომენთან, როგორც salt-ის გამოყენებით argon2id და შემდეგ კიდევ ერთხელ სერვერის მხარეს რანდომიზებული 256-ბიტიანი მარილით. კლიენტის მხრიდან წინასწარი ჰეშმა უნდა აიცილოს მესამე მხარის ავთენტიფიკაციის სერვერები პოტენციურად ხელახლა გამოყენებული მომხმარებლის პაროლების აღმოჩენაში. თუ გადაწყვეტთ თქვენი ანგარიშის შენარჩუნებას, ეს უბრალოდ ნიშნავს, რომ თქვენ შეგიძლიათ შეხვიდეთ მასზე, როცა გსურთ.

იქნება თუ არა საიტზე მომხმარებლის წვდომის პანელი ანგარიშებისთვის?

მომავალში, დიდი ალბათობით, გვექნება მომხმარებლის წვდომის პანელი ანგარიშებისთვის.

შემიძლია გადავიტანო ჩემი პერსონაჟი სერვერებს შორის?

თქვენ ამჟამად არ შეგიძლიათ სიმბოლოების გადაცემა, რადგან არ არსებობს სათანადო გზა, რომ მოთამაშეს ენდობოდეს, რომ არ მისცეს საკუთარ თავს ნივთები (თამაშში თუ კოდის საშუალებით), რაც გავლენას მოახდენს ოფიციალურ სერვერზე. ჩვენ შეიძლება საბოლოოდ დავამატოთ გზა თქვენი მრავალმოთამაშიანი პერსონაჟის ერთ მოთამაშეზე გადაყვანის ან სერვერის მასპინძლებისთვის სიმბოლოების გადაცემის უფლებას.

“Veloren არის ღია წყაროზე და საზოგადოებაზე ორიენტირებული” როგორ გეგმავთ გადალახოთ პრობლემა ერთდროულად ძალიან ბევრი მიმართულებით წასვლის? გეგმავთ თამაშის ერთზე მეტი ვერსიის შექმნას ან იმედოვნებთ, რომ ძალიან ბევრი ფუნქცია არ დაარღვევს კოდს/თამაშის იდენტურობას და ა.შ.?

Veloren-ის კონტრიბუტორები იყენებენ ორგანიზებულ სისტემას Discord-ისა და GitLab-ის მეშვეობით, რათა შეზღუდონ რა კონტენტი დაემატება მთავარ თამაშში. ეს საშუალებას აძლევს დეველოპერის გუნდს პროგრესი და გააუმჯობესოს თამაში იმ ხარისხით, როგორც მას სურთ. გარდა ამისა, მისი FOSS ბუნების გამო, ჩვენ ველოდებით, და კიდევ ვამხნევებთ, Veloren-ის ჩანგალი. მოდერებს შეეძლებათ შეასრულონ საჭირო ცვლილებები თამაშის კოდში, შემდეგ კი წარუდგინონ საზოგადოებას, რათა სცადონ და ჩაეჭიდონ რამდენიმე მოთამაშეს და ასევე განუწყვეტლივ დაამატონ ახალი კოდი ძირითადიდან ჩანგალში, სანამ ის დარჩება GPL3 სახელმძღვანელოს ფარგლებში. ჩვენ უკვე ვნახეთ, რომ ეს მოხდა პოპულარულ ჩინურ სერვერზე, რომელიც შეიქმნა Evan Meek-ის მიერ, რომელმაც ძლიერად შეცვალა და შეცვალა თამაში, დაამატა ახალი ერთეულები, შესაძლებლობები და ტონა მეტი!

საჰაერო ხომალდი

<video src=“https://s3.eu-central-2.wasabisys.com/veloren-blog/cdn/523568428905398283/1135936028562165842/airshipper.webm” type=“video/webm>video/webm”

Airshipper არის მრავალპლატფორმული Veloren გამშვები, რომელიც ზრუნავს Veloren-ის განახლებაზე. ჩვენი ხშირი განახლებების გამო, ეს არის Veloren-ის ინსტალაციის რეკომენდებული გზა.

ჩამოტვირთეთ

ეწვიეთ ჩამოტვირთვის გვერდს Airshipper-ის ჩამოსატვირთად.

ფაილები

Airshipper ინახავს თავის ფაილებს შემდეგ დირექტორიაში თქვენი ოპერაციული სისტემის მიხედვით:

Airshipper მხარს დაუჭერს პროფილებს მომავალში და უკვე ინახავს თამაშის ფაილებს პროფილში, სახელწოდებით default. ჟურნალები, ეკრანის ანაბეჭდები, აქტივები განთავსებულია userdata დირექტორიაში პროფილის შიგნით.

პრობლემების მოგვარება

თუ Airshipper არ იხსნება ან არ აჩვენებს სწორად, შეგიძლიათ გამოიყენოთ CLI

1. ტერმინალის გახსნა

Windows-ზე დააჭირეთ [Windows] + [R]. შემდეგ აკრიფეთ cmd და დააჭირეთ enter.

2. აკრიფეთ airshipper run და დააჭირეთ Enter
3. ისიამოვნეთ თამაშით.

Voxygen - 3D კლიენტის წინა ნაწილი

Voxygen არის Veloren-ის ოფიციალური 3D წინა ნაწილი. ეს არის წინა ნაწილი, რომლითაც თითქმის ყველა მომხმარებელი ურთიერთობს Veloren-თან, თუმცა ალტერნატივები არსებობს. თუმცა, თითქმის ყველა Veloren-ის შესახებ დოკუმენტაცია ვარაუდობს, რომ Voxygen არის კლიენტის წინა ნაწილი, რომელიც გამოიყენება.

Voxygen შექმნილია მომხმარებლისთვის მოსახერხებელი და ინტუიციური.

settings.ron

Voxygen-ის კონფიგურაციის ფაილი შეგიძლიათ იხილოთ userdata დირექტორიაში.

Gamepad კონტროლი

Voxygen მხარს უჭერს შეყვანას გეიმპდის ან თამაშის კონტროლერის საშუალებით. სამწუხაროდ, შეყვანები ჯერ არ არის კონფიგურირებული GUI-ის საშუალებით, მაგრამ settings.ron შეიძლება ხელით რედაქტირება controller განყოფილების მეშვეობით.

ექსპერიმენტული ჩრდილები

Voxygen-ს აქვს რამდენიმე ექსპერიმენტული შადერი, რომელთა ჩართვა შესაძლებელია graphics.render_mode.experimental_shaders ვარიანტის საშუალებით.

გთხოვთ გაითვალისწინოთ, რომ ამ შადერებს არ გააჩნიათ გარანტიები: ისინი შეიძლება იყოს მთლიანად გატეხილი, ურთიერთშეთავსებადი, ან შეიძლება გაათბეთ თქვენი GPU. გთხოვთ, არ შეატყობინოთ რენდერის შეცდომების შესახებ, თუ ისინი ჩართული გაქვთ (თუ არ ხართ დარწმუნებული, რომ შეცდომა არაფერ შუაშია შადერებთან).

ექსპერიმენტული შადერები აშკარად არ თამაშის მახასიათებელია. ისინი შეიძლება ნებისმიერ დროს მოიხსნას, გატეხოს ან შეიცვალოს და გაფრთხილების გარეშე. ისინი არსებობს მხოლოდ როგორც დეველოპერებისთვის, რათა გამოსცადონ ახალი რენდერინგის იდეები და როგორც დამატებითი გასართობი გამოცდილი მოთამაშეები.

ექსპერიმენტული შადერების ჩართვა შესაძლებელია შესაბამის განყოფილებაში მათი დამატებით. მაგალითად, Brickloren-ის გასააქტიურებლად და NoNoise შადერი:

(
    ...
    graphics: (
        ...
        render_moder: (
            ...
            experimental_shaders: [Brickloren, NoNoise],
            ...
        ),
        ...
    )
    ...
)

ჩრდილების ბრძანება შეუსაბამოა.

თქვენ შეგიძლიათ იპოვოთ ყველა ხელმისაწვდომი ექსპერიმენტული შადერის სია აქ.

ბრძანებები

ყველა ბრძანება, რომელიც შეიძლება შესრულდეს თამაშში, ჩამოთვლილია ქვემოთ, გაითვალისწინეთ, რომ ბევრი ბრძანება მოითხოვს ადმინისტრატორის ან მოდერატორის ნებართვას. <>-ით გარშემორტყმული არგუმენტები საჭიროა, [] მიუთითებს არასავალდებულო არგუმენტზე.

შენიშვნა: ქვემოთ მოცემული ცხრილები ავტომატურად გენერირებულია Veloren-ის წყაროს კოდის ბრძანებებიდან cargo cmd-doc-gen ბრძანების გამოყენებით.

<სტილი> მაგიდა { სიგანე: 100%; }

სერვერის ბრძანებები

Voxygen კლიენტის ბრძანებები

ცნობები

ყველა პარამეტრი, რომელიც შეიძლება გამოყენებულ იქნას თამაშში შესრულებულ ბრძანებებში, ჩამოთვლილია ქვემოთ.

მომხმარებლის მონაცემების საქაღალდის სტრუქტურა

საქაღალდე userdata აერთიანებს ყველა მოთამაშისა და სერვერის კონფიგურაციას ერთ ადგილზე, რომელიც უნდა იყოს გადატანილი Veloren-ის სხვადასხვა ინსტალაციას შორის v0.8-დან.

საქაღალდე იქნება თქვენი Veloren შესრულებადი გვერდის გვერდით, ან თქვენი საცავის ძირში, თუ თვითკომპლირდება. იხილეთ სად ინახავს Airshipper ფაილებს თუ იყენებთ გამშვებს.

• ვოქსიგენი
• მორები
• voxygen.log.< შესვლის თარიღი>
• settings.ron
• profile.ron
• მარტოხელა მოთამაშე Error 500 (Server Error)!!1500.That’s an error.There was an error. Please try again later.That’s all we know.
• db.sqlite
• სერვერი_კონფიგურაცია
• settings.ron (ზოგიერთი ჩანაწერი იგნორირებულია)
• description.ron
• whitelist.ron (იგნორირებულია)
• banlist.ron (იგნორირებულია)
• admins.ron (იგნორირებულია)
• სერვერი
• გადაარჩენს
• db.sqlite
• სერვერი_კონფიგურაცია
• settings.ron
• description.ron
• whitelist.ron
• banlist.ron
• admins.ron
• server-cli
• settings.ron

voxygen/settings.ron

შეიცავს პარამეტრებს [Voxygen]-ისთვის (voxygen.md), Veloren-ის ოფიციალური 3D კლიენტის წინა ნაწილისთვის.

ამ ფაილის თითქმის მთლიანად კონფიგურირება შესაძლებელია Voxygen-ის თამაშში არსებული პარამეტრების ინტერფეისის მეშვეობით. დამატებითი ინფორმაციისთვის იხ აქ.

მთავარი, რაც არ არის ხელმისაწვდომი თამაშის მთავარი მენიუდან არის გეიმპედის კლავიშები, რომელთა შეცვლა შესაძლებელია მხოლოდ ფაილის უშუალო რედაქტირებით.

profile.ron

შეიცავს Hotbar ინფორმაციას თითო სიმბოლოზე და თითო სერვერზე. არასდროს არ უნდა იყოს საჭირო ხელით შეცვლა.

server/server_config/settings.ron

ეს ფაილი განკუთვნილია ხელით რედაქტირებისთვის და არ უნდა იყოს გადაწერილი თამაშის მიერ. თუ ფაილი არასწორ მდგომარეობაშია, სერვერი გამოსცემს გაფრთხილებას შეცდომის პოზიციის ჩათვლით, შექმნის ნაგულისხმევი მნიშვნელობებით სავსე settings.template.ron ფაილს და დაიწყებს ყველა ნაგულისხმევი მნიშვნელობებით.

server/server_config/description.ron

შეიცავს შესავალი ჩატის შეტყობინებებს, რომლებსაც კლიენტები იღებენ სერვერზე შესვლისას, ციტირებული სტრიქონის სახით. შეიძლება იყოს მრავალი ხაზი.

მაგალითი:

"This is the best Veloren server"

server/server_config/whitelist.ron

შეიცავს თეთრ სიაში შესული ანგარიშის ID-ების სიას და ითვლება გათიშულად, თუ ცარიელია. მკაცრად რეკომენდირებულია გამოიყენოთ /whitelist add/remove თამაშში ბრძანება, ვიდრე ხელით რედაქტირება.

მაგალითი: /whitelist add Treeco და /whitelist add treeco2-ის გამოყენების შედეგი.

[
    "6f15b915-074f-f78d-df88-34fb33e4e13f",
    "3445349e-d03c-64bf-6ecf-a15806275a1f",
]

server/server_config/banlist.ron

შეიცავს აკრძალული ანგარიშების ჩამონათვალს და მიზეზებს. მკაცრად რეკომენდირებულია გამოიყენოთ /ban და /unban ბრძანებები თამაშში, ვიდრე ხელით რედაქტირება.

მაგალითი: /ban Treeco General nuisance და /ban treeco2 alt account-ის გამოყენების შედეგი.

{
    "6f15b915-074f-f78d-df88-34fb33e4e13f": (
        username_when_banned: "treeco2",
        reason: "alt account",
    ),
    "3445349e-d03c-64bf-6ecf-a15806275a1f": (
        username_when_banned: "Treeco",
        reason: "General nuisance",
    ),
}

server/server_config/admins.ron

შეიცავს ადმინისტრატორის ანგარიშის ID-ების ჩამონათვალს. მკაცრად რეკომენდირებულია გამოიყენოთ admin add/remove სერვერის TUI-დან, ვიდრე ხელით რედაქტირება. არ არსებობს თამაშში ბრძანება ადმინისტრატორების მუდმივად დასამატებლად, უსაფრთხოების მიზეზების გამო.

მაგალითი: admin add Treeco-ის გამოყენების შედეგი.

[
    "ee193d08-8f5a-4862-a279-1a8c4bd357f3",
]

თუ თქვენ გათიშული გაქვთ TUI ან სხვაგვარად ვერ იყენებთ მის გამოყენებას, შეგიძლიათ გამოიყენოთ სერვერის CLI ადმინისტრატორების დასამატებლად/წაშლაზე.

მაგალითი:

veloren-server-cli admin add Treeco

server-cli/settings.ron

ამ ფაილის პარამეტრები არეგულირებს გაფრთხილების პერიოდს, რომელსაც სერვერი აძლევს განახლებების ავტომატური გამორთვისთვის.

Veloren სერვერის ჰოსტინგი

შესავალი

მისი ძირითადი ნაწილი Veloren იყოფა 2 კომპონენტად, კლიენტად (veloren-voxygen) და სერვერად (veloren-server-cli). ერთი მოთამაშის რეჟიმში თამაში იწყებს სერვერის მოსმენას შემთხვევითი პორტის ფონზე და ავტომატურად უერთდება მას. თუმცა, multiplayer რეჟიმში Veloren ასევე იყენებს ავტორიზაციის სერვერს (veloren-auth). ეს საშუალებას აძლევს მოთამაშეებს დარეგისტრირდნენ მხოლოდ ერთხელ ჩვენს ვებსაიტზე და შევიდნენ ნებისმიერ სერვერზე იმავე ანგარიშით, მაგალითად Minecraft-ის მსგავსი.

როგორ გამოვიყენოთ ეს სახელმძღვანელო

1. მიჰყევით ერთ-ერთ Setup Guide:

• სერვერის გაშვება თქვენს კომპიუტერზე
• სერვერის გაშვება Docker-ის გამოყენებით (გამოყოფილი სერვერებისთვის)
• სერვერის გაშვება Raspberry Pi-ზე

2. გადადით სერვერის კონფიგურაცია გვერდზე, რათა გაიგოთ, როგორ დააყენოთ ის თქვენი საჭიროებებისა და პრეფერენციების მიხედვით.
3. (არასავალდებულო) მორგებული სამყაროს გენერირება.

ხელმისაწვდომი დაყენების სახელმძღვანელო

აირჩიეთ ინსტრუქციები გაშვების პლატფორმისთვის, რომელზეც გსურთ Veloren-ის გაშვება:

• სერვერის გაშვება თქვენს კომპიუტერზე
• სერვერის გაშვება Docker-ის გამოყენებით (გამოყოფილი სერვერებისთვის)
• სერვერის გაშვება Raspberry Pi-ზე

სერვერის ჰოსტინგი თქვენს კომპიუტერზე

თუ გსურთ მეგობრებთან თამაში და არ გაქვთ გამოყოფილი სერვერი, მიჰყევით ამ ინსტრუქციას, რომ დააყენოთ ის თქვენს კომპიუტერში.

თამაში LAN-ზე

** შენიშვნა: ** _ ეს იმუშავებს მხოლოდ მაშინ, როდესაც ყველა დაკავშირებულია იმავე ლოკალურ ქსელთან (ზოგადად ეს ნიშნავს იგივე WiFi ქსელს ან როუტერს)._

1. სერვერის გაშვება
2. იპოვეთ თქვენი ადგილობრივი IP მისამართი და გაუზიარეთ თქვენს მეგობრებს. მათ უნდა შეიყვანონ ის თამაშში სერვერთან შესაერთებლად.
3. გაერთეთ!

თამაში ინტერნეტით

შენიშვნა: თქვენ დაგჭირდებათ წვდომა თქვენს როუტერზე და ცოდნა პორტის გადამისამართების შესახებ.

მინიშნება: თუ ვერ ახერხებთ პორტის გადამისამართების დაყენებას, არსებობს პროგრამები, როგორიცაა ZeroTier, Netbird ან Hamachi, რომლებიც საშუალებას აძლევს მომხმარებლებს შეზღუდული რაოდენობით დაუკავშირდნენ ადგილობრივ სერვერს ინტერნეტის საშუალებით.

1. გადამისამართების პორტი 14004 TCP და UDP თქვენს როუტერზე.
2. სერვერის გაშვება
3. იპოვეთ თქვენი საჯარო IP მისამართი და გაუზიარეთ თქვენს მეგობრებს. მათ უნდა შეიყვანონ ის თამაშში სერვერთან შესაერთებლად.
4. გაერთეთ! :)

შენიშვნა: თუ თქვენი კომპიუტერის ლოკალური IP მისამართი გჭირდებათ პორტის გადამისამართებისთვის, იხილეთ თქვენი ადგილობრივი IP მისამართის პოვნა განყოფილება ქვემოთ.

სერვერის გაშვება

Airshipper-ის მიერ მოწოდებული სერვერის გამოყენებით

ეს კარგი ვარიანტია, თუ ყველა ვინც თამაშობს იყენებს Airshipper.

1. იპოვეთ თქვენი თამაშის ინსტალაციის საქაღალდე.
2. შედით profiles/default-ში.
3. გაუშვით veloren-server-cli[.exe].

პერსონალური სერვერის შესრულებადი

ეს კარგი ვარიანტია, თუ გსურთ ძველი გამოშვების ან მორგებული ვერსიის თამაში.

1. გახსენით საქაღალდე ამოღებული თამაშის ფაილებით.
2. დარწმუნდით, რომ თქვენ გაქვთ assets საქაღალდე იმავე ადგილას, სადაც სერვერის შესრულებადი.
3. გაუშვით veloren-server-cli[.exe].

თქვენი ადგილობრივი IP მისამართის პოვნა

მინიშნება: ზოგადად ადგილობრივ IPv4 მისამართებს აქვთ 192.168.xxx.xxx ან უფრო იშვიათად 10.xxx.xxx.xxx ფორმა. IPv6 მისამართებისთვის ლოკალური ჩვეულებრივ იწყება fe80:-ით

Linux-ზე და macOS-ზე

1. გახსენით ტერმინალი.
2. აკრიფეთ ip addr || ifconfig და დააჭირეთ Enter.
3. თქვენ იხილავთ თქვენი კომპიუტერის ყველა IP მისამართს, დაჯგუფებულს ქსელის ბარათის/ინტერფეისის მიხედვით. ინტერფეისის სახელები, რომლებიც იწყება e-ით, ძირითადად არის Ethernet, ხოლო w-ით დაწყებული სახელები ძირითადად უკაბელოა. inet-ით დაწყებული ხაზები და inet6 აჩვენებს IPv4 და IPv6 მისამართებს შესაბამისად. თუ ერთ ხაზზე რამდენიმე მისამართია, მნიშვნელოვანია მხოლოდ პირველი. მაგალითად, lo არის loopback ინტერფეისი 127.0.0.1 IPv4 მისამართით და ::1 IPv6 მისამართით. სავარაუდოდ, პირველი მისამართი, რომელიც არ ეკუთვნის loopback ინტერფეისს, არის ის, რასაც ეძებთ.

Windows-ზე

1. გახსენით CMD (აკრიფეთ cmd.exe დაწყების მენიუში და დააჭირეთ Enter).
2. აკრიფეთ ipconfig და დააჭირეთ Enter.
3. თქვენ იხილავთ თქვენი კომპიუტერის ყველა IP მისამართს, დაჯგუფებულს ქსელის ბარათის/ინტერფეისის მიხედვით. IPv4 address ან IPv6 address-ით დაწყებული ხაზები აჩვენებს მისამართების შესაბამის ტიპებს. სავარაუდოდ, პირველი მისამართი, რომელიც არ არის 127.0.0.1 ან ::1, იქნება ის, რასაც ეძებთ.

Windows Firewall (სურვილისამებრ)

თუ იყენებთ Windows Firewall-ს, გახსენით cmd როგორც ადმინისტრატორი და ჩაწერეთ ეს ბრძანებები და დააჭირეთ enter. ის ავტომატურად დაამატებს წესებს Windows Firewall-ში. დაიმახსოვრე, რომ ასევე დააკონფიგურიროთ თქვენი როუტერის firewall-ი.

netsh advfirewall firewall add rule name="Veloren 14004" dir=in action=allow protocol=TCP localport=14004
netsh advfirewall firewall add rule name="Veloren Metrics" dir=in action=allow protocol=TCP localport=14005  

სერვერის ჰოსტინგი Docker-ის გამოყენებით

თუ გსურთ 24/7 გამოყოფილი Veloren სერვერის გაშვება, მიჰყევით ამას.

** შენიშვნა: ** _ ჩვენ ვივარაუდებთ, რომ ზოგადი ბრძანების ხაზი და დოკერ-კომპოზიტორი ცოდნა. თქვენ დაგჭირდებათ docker და docker-compose დაინსტალირებული სერვერზე. თქვენ ასევე დაგჭირდებათ root წვდომა დოკერზე წვდომისთვის._

მინიშნება: იხილეთ Docker Compose ფაილის მითითება დამატებითი ინფორმაციისთვის docker-compose.yml ფაილის შესახებ.

დაყენება

** შენიშვნა: ** _ ნაგულისხმევი docker_compose.yml ავტომატურად განაახლებს თამაშის სერვერს უახლესი ყოველკვირეული გამოშვებით._

1. შექმენით საქაღალდე სერვერის მონაცემებისთვის და cd მასში.
2. ჩამოტვირთეთ ნიმუში docker-compose.yml საცავიდან საქაღალდეში. wget https://gitlab.com/veloren/veloren/-/raw/master/server-cli/docker-compose.yml
3. საჭიროების შემთხვევაში, გახსენით შემდეგი პორტები თქვენს Firewall-ში:

• 14004 (TCP/UDP, საჭიროა): Gameserver
• 14005 (TCP, სურვილისამებრ): HTTP მეტრიკა
• 14006 (UDP, სურვილისამებრ): შეკითხვის სერვერის პროტოკოლი

4. კონტეინერების შესაქმნელად და დასაწყებად გაუშვით sudo docker-compose up -d. თუ თქვენ შეცვლით docker-compose.yml ფაილს, თქვენ დაგჭირდებათ ამ ბრძანების ხელახლა გაშვება, რომ ის ძალაში შევიდეს.
5. დაამატეთ მოდერატორები/ადმინისტრატორები [ქვემოთ მოცემული ინსტრუქციების] მიყოლებით (#running-commands-inside-the-docker-container)

** შენიშვნა: ** _ თუ თქვენ იყენებდით მოწოდებულ docker-compose ფაილს, შეგიძლიათ გამოიყენოთ veloren-game-server-master <CONTAINER_ID>-ის ნაცვლად შემდეგ ინსტრუქციებში._

მონიტორინგი და მოვლა

• სერვერის გადატვირთვისთვის გაუშვით docker-compose restart.
• ჟურნალების სანახავად გაუშვით docker logs <CONTAINER_ID>.
• სერვერის კონფიგურაციის ფაილებზე წვდომისთვის გახსენით userdata საქაღალდე, რომელიც ავტომატურად შეიქმნა docker-compose.yml-ის გვერდით.

ბრძანებების გაშვება დოკერის კონტეინერში

თამაშის სერვერს აქვს CLI ინტერფეისი, რომელიც შეიძლება გამოყენებულ იქნას ამოცანების ბრძანებების გასაშვებად, როგორიცაა ადმინისტრატორების და მოდერატორების დამატება. ამ ინტერფეისზე წვდომის ნაბიჯები, სანამ სერვერი მუშაობს Docker-ში, მოცემულია ქვემოთ:

1. გაუშვით docker attach <CONTAINER_ID> (გაუშვით docker ps თამაშის სერვერის კონტეინერის ID-ის მოსაძებნად, შემდეგ თუ ID არის მაგალითად e002d350ab26, გაუშვით docker attach e002d350ab26).
2. ახლა შეგიძლიათ სერვერის CLI ბრძანებების გაშვება. ხელმისაწვდომი ვარიანტების სანახავად აკრიფეთ help და დააჭირეთ Enter.
3. როგორც კი დაასრულებთ, გასაქცევად დააჭირეთ Ctrl+p, რასაც მოჰყვება Ctrl+q.

მინიშნება: ადმინისტრატორის ან მოდიფიკაციის დასამატებლად გამოიყენეთ admin add <USER> <ROLE>. <ROLE> შეიძლება იყოს admin ან moderator.

მინიშნება: _ სერვერის მოვლა-პატრონობისთვის 2 წუთის დათვლის მოხდენილად გამორთვისთვის გამოიყენეთ:_

shutdown graceful --reason "Shutting down for maintenance :)" 120

შენიშვნა: _ სერვერიდან გამომავალი შესვლამ შეიძლება გააფუჭოს ბრძანების შეყვანის ვიზუალიზაცია, მაგრამ ეს შეიძლება იგნორირებული იყოს და დაშლილი ბრძანებები კვლავ იმუშავებს._

თქვენ დაასრულეთ!

Veloren სერვერის შექმნა Raspberry Pi-სთვის

Raspberry Pi-ს მოდელმა, რომელიც გაქვთ და ოპერაციული სისტემა, რომელსაც თქვენი Pi აქვს, შეიძლება მნიშვნელოვნად იმოქმედოს თქვენს ინსტალაციის ნაბიჯებზე და Veloren-ის შესრულებაზე თქვენს Pi-ზე. საუკეთესო შესრულებისთვის ჩვენ გირჩევთ გამოიყენოთ Raspberry Pi მოდელი 4 და 64-ბიტიანი OS, როგორიცაა Ubuntu Server, რომელიც ხელმისაწვდომია Raspberry Pi Imaging უტილიტა მეშვეობით. ასევე არსებობს 64-ბიტიანი Raspberry Pi OS ბეტა.

** შენიშვნა: ** _ ოპერატიული მეხსიერების რაოდენობას Pi 4-ზე არ აქვს მნიშვნელობა. ოფიციალური Veloren სერვერიც კი უმეტეს დროს იყენებს 2 გიბაიტზე ნაკლებ მეხსიერებას._

ჯვარედინი შედგენა თუ არა

ჯვარედინი კომპილაცია ნიშნავს ინსტრუმენტთა ჯაჭვის დაყენებას Raspberry Pi-ის ინსტრუქციების ნაკრებისთვის ცალკე კომპიუტერზე, რათა შეიქმნას Veloren სერვერის ორობითი, რომელიც შემდეგ დააკოპირეთ Pi-ზე.

პირდაპირი შედგენა სასურველია, თუ:

• თქვენ არ გსურთ დააინსტალიროთ და დააყენოთ იმდენი რამ თქვენს კომპიუტერში
• გსურთ იყოთ და იმუშაოთ ნაკლები ნაბიჯებით

ჯვრის შედგენა სასურველია, თუ:

• თქვენ გაქვთ კომპიუტერის დაყენება განვითარებისთვის
• გსურთ, რომ შედგენის ნაბიჯი იყოს უფრო სწრაფი

** შენიშვნა: ** _ ჯვარედინი კომპილაციის დროსაც კი აუცილებელია assets საქაღალდის კლონირება კოდის საცავიდან Pi-ზე, რადგან ეს ფაილები არ არის კომპილირებული სერვერის ბინარში._

პირდაპირი შედგენა

შედით თქვენს Pi-ში SSH-ის გამოყენებით.
ssh <username>@<ip> და შეიყვანეთ პაროლი დააინსტალირეთ Rust პროგრამირების ენა Pi-ზე, თუ ის უკვე არ არის დაინსტალირებული.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

დააინსტალირეთ Git LFS, რათა ჩამოტვირთოთ აუდიო და ვიზუალური აქტივები წყაროს კოდთან ერთად.

sudo apt install git-lfs

Git კლონირებს Veloren codebase. შეიძლება დაგჭირდეთ SSH გასაღებების გენერირება თქვენს Pi-ზე თქვენი GitLab ანგარიშისთვის.

git clone https://gitlab.com/veloren/veloren.git

შეადგინეთ სერვერის ორობითი კოდი Veloren დირექტორიაში.

cd veloren
cargo build --bin veloren-server-cli --release

გაუშვით სერვერის ორობითი, სურვილისამებრ -h ან --help-ით, რომ ნახოთ არგუმენტების სია, რომელთა მიწოდებაც შეგიძლიათ.

./target/release/veloren-server-cli

** შენიშვნა: ** _ Raspberry Pi 4-ზე გაშვებული Ubuntu სერვერის 64-ბიტიანი კომპილაცია შეიძლება დაახლოებით 30 წუთი დასჭირდეს ოპტიმიზებული კონსტრუქციისთვის._

შენიშვნა: _ დაიმახსოვრეთ, შეცვალოთ <username> თქვენი საკუთარი მომხმარებლის სახელით და <ip> თქვენი Raspberry Pi-ის IP მისამართით!_

** შენიშვნა: ** _ პროცესი თავისთავად რესურსით მძიმეა. იქნებ მაინც განიხილოს ჯვრის შედგენა. ოპერატიული მეხსიერების მოხმარება შეიძლება გადავიდეს 8 გ-ზე, ასე რომ თქვენ შეგიძლიათ განიხილოთ სვოპის შექმნა (თუმცა გაცვლა ანელებს კომპილაციის მთელ პროცესს)_

შენიშვნა: თუ შეგექმნათ შეცდომა wasmer-vm-ის შედგენისას, თქვენ უნდა გამორთოთ დანამატის მხარდაჭერა plugins = ["server/plugins"]-დან server-cli/Cargo.toml-დან წაშლით.

ჯვრის შედგენა

დამოკიდებულებების ინსტალაცია

დააინსტალირეთ შემდეგი დამოკიდებულებები ჯვრის შემდგენელ მანქანაზე და Raspberry Pi-ზე:

Cross Compiling PC:

• გიტ
• git-lfs
• ტვირთი (რომელიც დამონტაჟებულია Rust-თან ერთად)
• დოკერი

Raspberry Pi:

• გიტ
• git-lfs

Raspberry Pi-ს მომზადება

ჯერ უნდა მოვახდინოთ Veloren git საცავების კლონირება.

git clone https://gitlab.com/veloren/veloren

შემდეგ ჩვენ შეგვიძლია გადავაყენოთ საცავი ბოლო სტაბილური გამოშვების მდგომარეობაში. ამისათვის ჩვენ უნდა გავარკვიოთ ამ ვერსიის git hash. ეს შეგიძლიათ იხილოთ საიტზე https://gitlab.com/veloren/veloren/-/releases. git hash არის თანმიმდევრობა გამოშვების ქვედა მარცხენა კუთხეში. ეს ნაბიჯი შეიძლება გამოტოვოთ, თუ გსურთ უახლესი განახლებებით თამაში.

cd veloren
git checkout <git hash>

შემდეგ ჩვენ უნდა შევქმნათ რამდენიმე საქაღალდე, რომ მოგვიანებით ჩავდოთ ბინარი.

mkdir target
mkdir target/release

შემდეგი, ჩვენ უნდა დავამატოთ გარემოს ცვლადი ჩვენს .profile-ს.

nano ~/.profile

ამ ფაილის ბოლო სტრიქონში დაამატეთ ხაზი export VELOREN_USERDATA="$(pwd)/userdata

და ბოლოს, ჩვენ ხელახლა ვტვირთავთ ჩვენს გარემოს ახალი ცვლადის გამოსაყენებლად

. ~/.profile

ჯვარი კოდის შედგენა

ჩვენ კვლავ უნდა მოვახდინოთ Veloren-ის საცავი კლონირება ჩვენს ჯვრის შემდგენელ მანქანაზე, გადავაყენოთ იგი უახლესი სტაბილური გამოშვების მდგომარეობაში და დავაყენოთ git-lfs.

git clone https://gitlab.com/veloren/veloren
cd veloren
git checkout <git hash>
git lfs install
cargo install cross

ინსტალაციის ბრძანება განსხვავებული იქნება იმისდა მიხედვით, თუ რომელი OS გაქვთ გაშვებული Raspberry Pi-ზე.
თუ იყენებთ 64-ბიტიან ოპერაციულ სისტემას, როგორიცაა Ubuntu Server, ARMv8 ინსტრუქციის ნაკრებით, გაუშვით ბრძანება:

cross build --target aarch64-unknown-linux-gnu --bin veloren-server-cli --release

თუ იყენებთ Raspberry Pi OS-ს, რომელიც ამჟამად არის 32-ბიტიანი და იყენებთ ARMv7 ინსტრუქციების კომპლექტს უკანა თავსებადობის მიზეზების გამო, გაუშვით ბრძანება:

cross build --target armv7-unknown-linux-gnueabihf --bin veloren-server-cli --release

შენიშვნა: შეიძლება დაგჭირდეთ ანგარიშის რეგისტრაცია [docker hub]-ზე (https://hub.docker.com/) და გაუშვათ docker login ბრძანება ტერმინალში ჯვარედინი კომპილაციისთვის საჭირო Docker სურათზე წვდომისთვის.

როდესაც კომპილაციის პროცესი დასრულდება, შეგვიძლია ბინარული გადავიტანოთ Raspberry Pi-ში. თუ თქვენს Raspberry Pi-ზე ჩართული გაქვთ SSH, შეგიძლიათ გამოიყენოთ scp ბრძანება.

scp target/<instruction_set>/release/veloren-server-cli <username>@<ip>:~/veloren/target/release/veloren-server-cli

** შენიშვნა: ** <instruction_set> ეხება aarch64-unknown-linux-gnu ან armv7-unknown-linux-gnueabihf-ს, რომელის კომპილაციასაც გამოიყენებდით. გახსოვდეთ, რომ შეცვალოთ <username> თქვენი საკუთარი მომხმარებლის სახელით და <ip> თქვენი Raspberry Pi-ის IP მისამართით!

სისტემური სერვისის შექმნა

Raspberry Pi-ზე ახლა ჩვენ შეგვიძლია შევქმნათ სისტემური სერვისი სერვერისთვის. ამისათვის შექმენით სერვისის ფაილი ქვემოთ მოცემული შინაარსით.

sudo nano /etc/systemd/system/veloren-server.service

შენიშვნა: თუ ორობითი შეადგინეთ, დაამატეთ გარემოს ცვლადი Service განყოფილებას: Environment="VELOREN_USERDATA=/home/veloren/target/release/userdata"

[Unit]
Description=Veloren Server
After=network.target
StartLimitIntervalSec=0
[Service]
Type=simple
User=<username>
WorkingDirectory=/home/<username>/veloren
ExecStart=/home/<username>/veloren/target/release/./veloren-server-cli

[Install]
WantedBy=multi-user.target

ახლა ჩვენი სერვისი მზად არის და შეიძლება დაიწყოს.

sudo systemctl start veloren-server.service

სერვერის მუშაობის სანახავად და გამართვის ინფორმაციის სანახავად, შეგიძლიათ გამოიყენოთ შემდეგი ბრძანება.

sudo journalctl -f -u veloren-server.service

თუ გსურთ სერვერის გაშვება ყოველ ჯერზე Raspberry Pi-ის ჩატვირთვისას, შეგიძლიათ ჩართოთ სერვისი.

sudo systemctl enable veloren-server.service

სერვერის მონიტორინგი

როდესაც სერვერი მუშაობს, შეგიძლიათ უყუროთ თქვენი Pi-ს მუშაობას ისეთი ხელსაწყოებით, როგორიცაა htop, ან დააყენოთ Prometheus server მეტრიკის ამოსაღებად თქვენი Veloren სერვერიდან მისამართზეhttp://<ip>:14005/metrics.

სერვერის კონფიგურაცია

რომელი მარშრუტიც არ უნდა აირჩიოთ სერვერის ჰოსტინგისთვის, შეიძლება დაგჭირდეთ მისი კონფიგურაცია. ეს განყოფილება შეიცავს Veloren სერვერთან დაკავშირებული ყველა კონფიგურაციის ფაილის ახსნას, მათ მიზნებსა და შინაარსს.

მომხმარებლის მონაცემების საქაღალდის სტრუქტურა

veloren-server-cli-ის პირველად გაშვების შემდეგ შეიქმნება userdata საქაღალდე, რომელიც შეიცავს მის ყველა კონფიგურაციას და მონაცემებს. მისი შინაარსი ასე გამოიყურება:

userdata
├── server
│   ├── saves
│   │   └── db.sqlite
│   └── server_config
│       ├── admins.ron
│       ├── banlist.ron
│       ├── description.ron
│       ├── settings.ron
│       └── whitelist.ron
└── server-cli
    └── settings.ron

სერვერი/სერვერის_კონფიგურაცია

ეს საქაღალდე ჩვენთვის ყველაზე საინტერესოა. ის შეიცავს სხვადასხვა მნიშვნელოვან კონფიგურაციის ფაილს.

მინიშნება: _ მომხმარებლის სახელით ადმინისტრატორის ან მოდიფიკაციის დასამატებლად, აკრიფეთ admin add <USER> <ROLE> სერვერის კონსოლში._ <ROLE> შეიძლება იყოს admin ან moderator.

admins.ron

ეს ფაილი შეიცავს ადმინისტრატორის პრივილეგიების მქონე მოთამაშეების UUID-ების ჩამონათვალს.

ამ ფაილის შესაცვლელად გჭირდებათ სერვერის კონსოლზე წვდომა.

მაგალითი:

[
    "f60e23c6-345c-449b-b05a-e431d53fc65c",
]

ბანლისტი.რონ

ეს ფაილი შეიცავს აკრძალული მოთამაშეების სიას და მათთან დაკავშირებულ ინფორმაციას თითოეული აკრძალვის შესახებ.

სერვერის ადმინისტრატორებს შეუძლიათ გამოიყენონ თამაშში არსებული ბრძანებები ამ ფაილის შესაცვლელად.

მაგალითი:

{
    "7ea1a4cd-3002-4fe6-957e-4483f3fda3e7": (
        username_when_banned: "YuriMomo",
        reason: "No testing bugs on this server >:(",
    ),
}

აღწერა.რონ

ეს ფაილი შეიცავს სერვერის აღწერას (ასევე ცნობილია როგორც ‘დღის მესიჯი’ (MTOD)) და სერვერის წესებს.

ორივე მხარს უჭერს ლოკალიზაციას. თუ მომხმარებლის ლოკალი ემთხვევა ერთ-ერთ ჩანაწერს, ისინი დაინახავენ შესაბამისს ლოკალიზებული ჩანაწერი ორივესთვის.

თუ rules ველი დაყენებულია Some("...") და არა None, მომხმარებლები დაინახავენ წესებს, როდესაც ისინი პირველად შეუერთდებიან სერვერი, სავალდებულო ღილაკით “მიღება” (წესებში ნებისმიერი ცვლილება ასევე გამოიწვევს მათ ხელახლა ჩვენებას მომხმარებლებისთვის).

default_locale ველი განსაზღვრავს აღწერილობების რომელი ნაკრები იქნება ნაჩვენები, თუ მათი ლოკალი არ ემთხვევა რომელიმეს ფაილში არსებული (ნაგულისხმევად, ეს ველი არის "en", ანუ ინგლისური).

სერვერის ადმინისტრატორებს შეუძლიათ გამოიყენონ თამაშში არსებული ბრძანებები ამ ფაილის შესაცვლელად.

მაგალითი:

V2((
    default_locale: "en",
    descriptions: {
        "en": (
            motd: "This is the best Veloren server",
            rules: None,
        ),
    },
))

პარამეტრები.ron

ეს არის ფაილი, რომელიც შეიცავს კონფიგურაციის ვარიანტების უმეტესობას.

ველების უმეტესობა თავისთავად განმარტებულია, მაგრამ მეტი ინფორმაცია შეგიძლიათ ნახოთ აქ.

თქვენ გჭირდებათ პირდაპირი წვდომა სერვერის ფაილებზე ამ ფაილის შესაცვლელად.

მაგალითი:

(
    gameserver_address: "0.0.0.0:14004",
    metrics_address: "0.0.0.0:14005",
    auth_server_address: Some("https://auth.veloren.net"),
    max_players: 100,
    world_seed: 25269,
    server_name: "Veloren Alpha",
    start_time: 32400,
    map_file: None,
    max_view_distance: Some(65),
    banned_words_files: [],
    max_player_group_size: 6,
    client_timeout: (
        secs: 40,
        nanos: 0,
    ),
    spawn_town: None,
    safe_spawn: true,
    max_player_for_kill_broadcast: Some(20),
)

შენიშვნა: სანამ თქვენ შეგიძლიათ გამოიყენოთ მორგებული ავტორიზაციის სერვერი, თუ ამას გააკეთებთ, მოთამაშეები დაინახავენ უსაფრთხოების გაფრთხილებას თქვენი თამაშის სერვერთან დაკავშირებისას.

შენიშვნა: მიუხედავად იმისა, რომ თქვენ შეგიძლიათ სრულად გამორთოთ ავტორიზაცია, ეს საშუალებას მისცემს ნებისმიერ შევიდეს ნებისმიერი მომხმარებლის სახელი, მათ შორის სერვერის ადმინისტრატორის გამოყენებით.

არა აშკარა ვარიანტების ახსნა:

• ზოგიერთი მნიშვნელობა იყენებს Option ტიპს, რაც ნიშნავს, რომ მათი დაყენება შესაძლებელია Some(value) ან None.
• max_player_for_kill_broadcast შეიძლება საშინლად ჟღერდეს, მაგრამ ეს ხელს უშლის ჩეთის სპამს მხოლოდ სხვების სიკვდილის შეტყობინებების გაგზავნით მათ ჯგუფში და ახლომდებარე მოთამაშეებზე, თუ მოთამაშეთა დაყენებული რაოდენობა გადააჭარბებს. მისი დაყენება None-ზე ნიშნავს, რომ სერვერი არასოდეს გაავრცელებს მოკვლის შეტყობინებებს გლობალურად.

თეთრი სია.ron

თუ ეს ფაილი ცარიელი არ არის, სერვერზე შეერთება შეძლებენ მხოლოდ მოთამაშეებს, რომელთა UUID-ებსაც შეიცავს.

სერვერის ადმინისტრატორებს შეუძლიათ გამოიყენონ თამაშში არსებული ბრძანებები ამ ფაილის შესაცვლელად.

მაგალითი:

[
     "f60e23c6-345c-449b-b05a-e431d53fc65c",
]

სერვერი/შენახვა

ეს საქაღალდე შეიცავს სერვერის მონაცემთა ბაზას.

სერვერი-კლი

ეს საქაღალდე შეიცავს მხოლოდ settings.ron ფაილს შემდეგი შინაარსით:

(
    update_shutdown_grace_period_secs: 120,
    update_shutdown_message: "The server is restarting for an update",
)

ის საშუალებას გაძლევთ დააკონფიგურიროთ ლოდინის დრო გადატვირთვამდე, რათა განაახლოთ სერვერი და გაგზავნა, რომელსაც ის იყენებს, როდესაც აფრთხილებს მოთამაშეებს ამის შესახებ. ეს გამოიყენება მხოლოდ Docker ჰოსტინგის მეთოდით.

შენობა

Veloren არის პირველადი სამოქმედო-სათავგადასავლო RPG, ვიდრე ქვიშის საშენი თამაში. ამის მიუხედავად, ის გარკვეულწილად იძლევა ფუნქციები, რომლებიც თამაშში შეზღუდულ შენობას იძლევა.

აშენების რეჟიმი

Build რეჟიმის ჩართვა შესაძლებელია /build ბრძანებით. როდესაც ჩართულია, მოთამაშეებს შეუძლიათ დაამატოთ (მარჯვენა დაწკაპუნებით), წაშლა (მარცხნივ დაწკაპუნებით) და აირჩიეთ (შუა დაწკაპუნება) ბლოკები build რეგიონებში, რომლებზეც მათ აქვთ ნებართვა. აშენების რეჟიმი არ ითვლება კანონიკურად Veloren გამოცდილების ნაწილი. ეს არის სახალისო ფუნქცია, რომელიც შეგიძლიათ გამოიყენოთ, თუ გსურთ ექსპერიმენტი გააკეთოთ თამაშის მახასიათებლებზე.

რეგიონები

ნაგულისხმევად, არის რეგიონი, რომელიც მოიცავს მთელ მსოფლიოს სახელად world. თქვენ შეგიძლიათ ჩართოთ მასზე ნებართვები /permit_build world (ამისთვის საჭიროა ადმინისტრატორის ნებართვები).

vox_spawn ფილიალი

არსებობს უაღრესად ექსპერიმენტული ფილიალი, სახელწოდებით vox_spawn. ის ამატებს კლიენტის მხარეს ბრძანებას, რომელიც ჩართულია build რეჟიმში და იყენებს მას “3D ბეჭდვისთვის” (სტრიქონი მწკრივი) .vox მოდელები თამაშში მსოფლიო. ზოგადად, ეს პროცესი საკმაოდ სწრაფია და ყველა მოდელს, გარდა უდიდესს, როგორც წესი, სრულყოფილებას ერთ წუთზე ნაკლებ დრო სჭირდება თუ თქვენ ხართ ადმინისტრატორი, რომელსაც სურს შექმნას სტრუქტურები თქვენს სამყაროში, შესაძლოა ღირდეს სტრუქტურების დაპროექტება ჯერ ვოქსელის მოდელირების ხელსაწყოთი და vox_spawn-ის გამოყენებით მათ სამყაროში გამოსაყვანად, რათა თავიდან აიცილოთ სტრუქტურის დაკარგვა სამუდამოდ თუ ნაჭერი განიტვირთება.

გამძლეობა

სტანდარტულად, Veloren არ აგრძელებს მსოფლიოში განხორციელებულ ცვლილებებს. ნაწილის გადმოტვირთვა გამოიწვევს მასში შეტანილ ნებისმიერ ცვლილებას იკარგება. თუმცა, 2021-08-14 მდგომარეობით, Veloren-ს აქვს თამაშში ჩაშენებული ექსპერიმენტული გამძლეობის სისტემა. ეს არ არის ნაგულისხმევად ჩართულია.

ჩართვა

მუდმივი მშენებლობის ჩასართავად, თამაშის შედგენისას უნდა იყოს ჩართული persistent_world ფუნქცია (ეს ჩართულია ნაგულისხმევად). გარდა ამისა, სერვერს უნდა ჰქონდეს experimental_terrain_persistence დროშა დაყენებული true სერვერზე settings.ron ფაილი (ეს ასევე მუშაობს ერთი მოთამაშისთვის). ეს დროშა ნაგულისხმევად არ არსებობს პარამეტრების ფაილში და ხელით უნდა დაემატოს სერვერის მფლობელს.

ჩართვის შემდეგ, გაშვებისას ნახავთ ჟურნალის ჩანაწერს სერვერის კონსოლში (ან მთავარ სათამაშო კონსოლში, თუ ერთმოთამაშშია), ასევე შეტყობინება build-ის რეჟიმის გადართვისას.

მნიშვნელოვანი ინფორმაცია

ექსპერიმენტული რელიეფის მდგრადობა არ არის ოფიციალურად მხარდაჭერილი ფუნქცია. მიუხედავად იმისა, რომ გარკვეული მცდელობები არ ხდება თვითნებურად არღვევს ნივთებს შემდგომ განახლებებს შორის, ეს არ არის გარანტია და სავსებით შესაძლებელია, რომ განახლებები შეიძლება დაზიანდეს, წაშალოს ან სხვაგვარად დაარღვიოს რელიეფის არსებული მონაცემები ნებისმიერ დროს. გარდა ამისა, არ არსებობს სტაბილურობის გარანტიები (თუმცა თქვენ მაინც შეგიძლიათ შეატყობინოთ ფუნქციებთან დაკავშირებული შეცდომები): ფუნქციის ჩართვამ შეიძლება გამოიწვიოს ავარია, არასტაბილურობა, ჩამორჩენა და ა.შ.

ექსპერიმენტული რელიეფის მდგრადობის მახასიათებელი უბრალოდ დაუსრულებელი არ არის: ის არის შეჩერება სათანადო, უფრო შეზღუდული შემუშავებულია მოთამაშეზე ორიენტირებული შენობის სისტემა. ის არ არის გამიზნული, რომ ჩამოყალიბდეს ასეთ სისტემაში და არც არის გამიზნული თავსებადია მასთან: ის არსებობს მხოლოდ იმისათვის, რომ ხელი შეუწყოს სერვერის ადმინისტრატორებს, დაამატონ მცირე პერსონალიზაცია მათ სერვერებზე. მოთამაშეები სარგებლობენ იმ დრომდე, როდესაც იქნება საიმედო, წინ თავსებადი, მოთამაშეზე ორიენტირებული შენობის სისტემა განვითარებული.

როგორც შეიძლება ველოდოთ, თამაშის განახლებებს ხშირად შეუძლია დახვეწილად (ან არა ისე დახვეწილად, როგორც ეს შეიძლება იყოს) დაარღვიოს მდგრადი რელიეფი მონაცემები. მაგალითად, მსოფლიო თაობის მნიშვნელოვანმა ცვლილებებმა შეიძლება გამოიწვიოს სტრუქტურები, რომლებიც აგებულია სისტემაში არასწორი სიმაღლე, სხვა გენერირებული სტრუქტურების შიგნით ჩაჭრა, ან შესაძლოა მთლიანად გადაფარვა/ამოღება. როგორც ადრე ამის შესახებ არანაირი გარანტია არ არის გაცემული. თუ მსოფლიო თაობა მნიშვნელოვნად შეიცვლება ან თქვენ გამორთეთ რუკის ფაილი, საუკეთესო რამ, რაც უნდა გააკეთოთ, არის ალბათ ამოიღოთ რელიეფის დირექტორია და თავიდან დაიწყოთ.

როგორ მუშაობს?

სერვერის გაშვებისას, რელიეფის მდგრადობის სისტემა ქმნის {DATADIR}/terrain/ დირექტორიას, თუ ის არ არსებობს უკვე სადაც {DATADIR} არის სერვერის მონაცემთა დირექტორია (userdata/singleplayer/ ან userdata/server/, უმეტეს შემთხვევაში შემთხვევები). ეს დირექტორია შეიძლება შეიცვალოს VELOREN_TERRAIN გარემოს ცვლადის გამოყენებით.

ფუნქცია აკავშირებს თამაშის გაშვებისას შესრულებულ სხვადასხვა მოქმედებებს: ახლად ჩატვირთულ ნაწილებს ექნება მუდმივი ცვლილებები გამოყენებული იქნება მათ თავზე და გადმოტვირთვის ნაწილებში ცვლილებები შენარჩუნდება დისკზე. ნებისმიერი მოდიფიკაცია, რომელიც შესრულებულია რომელიმეს მეშვეობით build რეჟიმი ან /make_sprite და /make_block ბრძანებები ჩაიწერება. იგივე არ ეხება სხვა სახეობებს ბლოკის მოდიფიკაცია: მწკრივით მოპოვებული ან აფეთქების შედეგად გაუფერულებული/დანგრეული ბლოკები არ ჩაიწერება. ეს ნიშნავს, რომ მოთამაშეებს არ შეუძლიათ მუდმივად დააზიანონ სერვერის ადმინისტრატორების მიერ შექმნილი სტრუქტურები.

იხილეთ ორიგინალური გაერთიანების მოთხოვნა უფრო დეტალური ტექნიკური ინფორმაციისთვის ინფორმაცია.

რისთვის არის?

როგორც აღვნიშნეთ, რელიეფის მდგრადობის სისტემა არ არის გამიზნული მოთამაშისკენ. აშენების რეჟიმი არც ინტუიციურია და არც კარგად არის ინტეგრირებული დანარჩენ თამაშში. ჩვენ მას არ ვთვლით თამაშის არცერთ არსებულ მექანიკაში და ასეც არის შესაძლებელია სერვერისა და კლიენტების ავარია, ჩამორჩენა ან გაყინვა, თუ აშენებთ ძალიან მაღალ სიმაღლეზე ან დაბალი.

ჩვენ ვაპირებთ, რომ რელიეფის მდგრადობა იყოს საშუალება სერვერის ადმინისტრატორებისთვის სერვერის გამოცდილების მორგებისთვის მოთამაშეებისთვის წინასწარ აშენებული სტრუქტურები, რომლებთანაც შეიძლება ურთიერთქმედება. ქვემოთ მოცემულია რამდენიმე იდეა დასაწყებად:

• სრიალების კურსები, რომლებიც შემოიფარგლება სვეტებითა და რგოლებით პლანერებით რბოლისთვის

• მორგებული ქვირითის ზონა, რომელიც სავსეა ხელოსნობის სადგურებითა და მოთამაშეებისთვის შეხვედრის ადგილებით

• მაინინგის გამოწვევები (მაინინგის ბლოკების გამოყენება, როგორიცაა WeakRock და მადნები), რომლებშიც მოთამაშეებს შეუძლიათ მონაწილეობა. რადგან მაინინგი არ არის შენარჩუნებულია, ნებისმიერი დანაღმული ბლოკი ბუნებრივად აღდგება, როდესაც ნაჭერი გადაიტვირთება!

• მორგებული ლაბირინთები და ცოცვა/ხტომა გამოწვევები მოთამაშეებისთვის ჯილდოებით ზარდახშების/მადნების/ა.შ.

• Pixel-ის ნამუშევრები და ქანდაკებები, რომლებიც მოფენილია მთელ მსოფლიოში მოთამაშეებისთვის საპოვნელად

• არსებული მსოფლიო სტრუქტურების ვიზუალური პერსონალიზაცია, როგორიცაა ქალაქები და დუნდულები, რაც მათ შესასწავლად უფრო საინტერესოს ხდის

• PvP ან PvE არენები მოთამაშეებისთვის, რომ შეებრძოლონ მონსტრები და ერთმანეთს გარემოში, სადაც სხვებს შეუძლიათ ყურება

თუ რამეს აკეთებთ ამ ფუნქციით, მოგერიდებათ გვითხრათ! ის შეიძლება გამოჩნდეს ყოველკვირეულ ბლოგში!

გარემოს ცვლადები

Veloren იყენებს სპეციალურ გარემოს ცვლადებს თამაშის ქცევაზე ზემოქმედებისთვის. გარემოს ცვლადები უნდა იყოს მითითებული თამაშის დაწყებამდე, მოძებნეთ გაკვეთილები, თუ როგორ უნდა გავაკეთოთ ეს ინტერნეტში.

შენიშვნა: ეს სია არასრულია და საჭიროებს გაფართოებას.

VELOREN_ASSETS

არჩევითი ცვლადი, რომელიც მიუთითებს veloren assets დირექტორიაზე. არ არის საჭირო, თუ იყენებთ Airshipper, მაგრამ შეიძლება სასარგებლო იყოს უფრო ეგზოტიკურში სცენარები.

VELOREN_ASSETS_OVERRIDE

ცვლადი დირექტორიას დასამატებლად აქტივების უგულებელყოფით. რეკომენდირებულია თუ გსურთ შეცვალეთ ზოგიერთი ფაილი, მაგალითად, სხვადასხვა იარაღის ტექსტურა.

Linux-ის მაგალითი:

env VELOREN_ASSETS_OVERRIDE="/home/user/veloren/override_assets/" airshipper run

თუ თქვენ გაქვთ $VELOREN_ASSETS_OVERRIDE/voxygen/voxel/weapon/caladbolg.vox ერთად caladbolg.vox-ის თქვენი შეცვლილი ვერსია, ის გამოყენებული იქნება main-ის ნაცვლად caladbolg.vox ფაილი veloren აქტივებში.

WGPU_BACKEND

შეიძლება სასარგებლო იყოს, თუ თქვენი თამაში ავარიულად იშლება. ალტერნატიულად, შეგიძლიათ აირჩიეთ ის Airshipper GUI-ში.

შესაძლო მნიშვნელობები:

• “ვულკანი”
• “ლითონი” (მხოლოდ macOS)
• “dx12” (მხოლოდ Windows)
• “dx11” (მხოლოდ Windows)
• “პირველადი”
• “opengl” (მხარდაჭერილი არ არის წერის დროს)
• “მეორადი”
• “ყველა”

პერსონალური სამყაროს გენერირება ან ჩატვირთვა

1. გახსენით თქვენი singleplayer ან სერვერის პარამეტრების ფაილი. იხილეთ აქ.

2. დააყენეთ თქვენი მორგებული world_seed და map_file Some(Save(())).

3. გაუშვით თქვენი თამაში ჩვეულებრივად, მიუხედავად იმისა, ამას აკეთებთ ერთი მოთამაშის საშუალებით თუ სერვერის კლიკით.

4. გენერირების პროცესს შეიძლება დიდი დრო დასჭირდეს, მცირე მითითებით, რომ ის გამართულად მუშაობს. 10 წუთი კარგ პროცესორზეა მოსალოდნელი, სტანდარტული ზომის სამყაროსთვის. საბოლოოდ, ის იტვირთება ახალ სამყაროში.

5. სამყარო შეინახება maps საქაღალდეში, ორობითი ფაილის სახით. დააყენეთ map_file-ზე Some(Load("maps/<filename>.bin")),, წინააღმდეგ შემთხვევაში ის შეეცდება მის რეგენერაციას ყოველ ჯერზე.

map_file ოფციები

თაობის პარამეტრები

ზემოთ მოცემული ვარიანტების შევსება შესაძლებელია გენერირებული რუქების ზომის შესაცვლელად და მათში არსებული მთების მასშტაბის შესაცვლელად. ვარიანტები, რომელთა შეცვლაც არ გსურთ, შეიძლება დარჩეს ცარიელი და შეიცვალოს ნაგულისხმევად, თუმცა თქვენ უნდა შეინახოთ სათადარიგო ბრეკეტები. ოფციების ნაგულისხმევი ნაკრების ხელით ჩაწერა იძლევა Some(Save((x_lg: 10, y_lg: 10, scale: 2.0))).

მსოფლიო ზომა

x_lg და y_lg იძლევა ორობით ლოგარითმს სამყაროს თითოეული ღერძის გასწვრივ ნაწილაკების რაოდენობის შესახებ, ანუ x_lg: 10 მიგვიყვანს სამყაროში 2^10=1024 ცალი სიგანით.

თითოეული ნამატი აორმაგებს სიგრძეს და ყოველი კლება განახევრდება. მართკუთხა სამყაროები სრულად არის მხარდაჭერილი, თუმცა თითოეული განზომილების ყოველი გაორმაგება ასევე უხეშად აორმაგებს მსოფლიო გენერირების დროს და ოპერატიული მეხსიერების მოხმარებას, რაც შეიძლება სწრაფად გამოვიდეს ხელიდან.

მაქსიმუმ 14 უნდა იყოს მხარდაჭერილი თითოეულ განზომილებაში, რაც კვადრატულ სამყაროს აძლევს 524 კმ დიამეტრს, რაც დაახლოებით გაერთიანებული სამეფოს ექვივალენტურია ფართობით, მაგრამ ეს საკმაოდ ცუდად გამოიყურება ტექტონიკის სიმულაციის ამჟამინდელი ნაკლებობის გამო, რაც უფრო მნიშვნელოვანი ხდება უფრო დიდ მასშტაბებში. 13x13 არის ყველაზე დიდი აქამდე მცდელობა.

მსოფლიო მასშტაბი

scale უბრალოდ ცვლის მთების, ხმელეთის მასივების მასშტაბებს და ა.შ. 4.0 მნიშვნელობა ანიჭებს უხეშად მიწიერ მასშტაბს, თუმცა ამისთვის რეკომენდებულია ნაგულისხმევზე დიდი სამყარო. 4.0-ზე გადასვლა არ ითვლება მხარდაჭერად, მაგრამ ზოგადად მუშაობს. როგორც მეგზური, ყველაზე მაღალი მთები ამ მნიშვნელობაზე ოდნავ მაღალი იქნება, კილომეტრებში.

წინასწარ გენერირებული რუქის ჩატვირთვა კონკრეტული თესლით

გადადით თქვენი სერვერის ან ერთი მოთამაშის პარამეტრების ფაილზე, როგორც ნაჩვენებია აქ.

იქ

1. შეცვალეთ მსოფლიო თესლი, ე.ი. world_seed: 40382,\
2. შეცვალეთ map_file მსგავსი რამით
   map_file: Some(Load("userdata/server/maps/map_1624935538562.bin")),\
3. სურვილისამებრ, ასევე შეგიძლიათ დააყენოთ ქვირითის ქალაქი: spawn_town: Some("Elden"),

დარწმუნდით, რომ გამოიყენეთ ფაილის სწორი გზა (თქვენი veloren საქაღალდის ძირიდან) და ფაილის სახელები!
ყველა ამ შეყვანის უკან უნდა იყოს ,, წინააღმდეგ შემთხვევაში სერვერი გამოიყენებს სარეზერვო პარამეტრების შაბლონის ფაილს.\

შენიშვნა: ამ მაგალითში გამოყენებული ფაილის გზა მოითხოვს დამატებით საქაღალდის შექმნას სახელწოდებით “რუკები” userdata/server საქაღალდეში.

რუქის მაყურებელი

თუ თქვენ შეძლებთ შედგენას, შეგიძლიათ სცადოთ რუქის გენერატორისა და მაყურებლის აპლიკაციის მაგალითი. გაუშვით შემდეგი ბრძანება თქვენი ადგილობრივი საცავიდან, სასურველი ტერმინალის მიხედვით.

Unix-ის მსგავსი:

RUST_LOG="info,veloren_world=debug" cargo run --release --example water

Windows, cmd:

set RUST_LOG=info,veloren_world=debug&& cargo run --release --example water

Windows, PowerShell:

$env:RUST_LOG="info,veloren_world=debug"; cargo run --release --example water

ნაგულისხმევად ის ჩატვირთავს ნაგულისხმევ სამყაროს assets საქაღალდიდან. შეიყვანეთ მორგებული თესლი აქ და შეცვალეთ ორი ხაზი ქვემოთ, თუ გსურთ შექმნათ ან ჩატვირთოთ სხვა სამყარო.

ეს მეთოდი **მიუთითებს პროგრესს მსოფლიო თაობაზე, პროგრესირებად Erosion iteration 0-დან 99-მდე და ამიტომ რეკომენდებულია უფრო დიდი სამყაროებისთვის.

რუკის ჩატვირთვის შემდეგ, ნაგულისხმევი ხედი აჩვენებს ტემპერატურისა და ტენიანობის გადაფარვას. დააჭირეთ T და H, რომ გამორთოთ ისინი, შესაბამისად, და M, რომ ჩართოთ რეალური რუქის ფერები. F4 გადაიღებს ეკრანის სურათს.

რუქის მაყურებელი გარკვეულწილად არ რეაგირებს, ამიტომ შეიძლება დაგჭირდეთ კლავიშების დაჭერა ერთი წუთით, რათა მათ ძალაში შესულიყვნენ.

პრობლემების მოგვარება

თუ მორგებული სამყაროს ჩატვირთვა ვერ მოხერხდა ან ნაგულისხმევი რუკა კვლავ ჩატვირთულია, ორჯერ შეამოწმეთ, რომ რომელიმე პარამეტრი არასწორად არ დაგიწერიათ. გავრცელებული შეცდომაა ის, რომ დაგავიწყდათ ერთ-ერთი ბოლო მძიმის მოთავსება პარამეტრების .ron ფაილ(ებ)ში.

პრობლემების მოგვარება

Veloren მუშაობს ბევრ ოპერაციულ სისტემაზე, არქიტექტურაზე, GPU-ზე და სისტემის კონფიგურაციაზე. ხანდახან რაღაცეები არ მუშაობს!

ეს გვერდი შეიცავს საერთო პრობლემებისა და გადაწყვეტილებების ჩამონათვალს.

გამოიყენეთ ქვემოთ მოცემული ბმულები, რომ გადახვიდეთ თქვენთვის ყველაზე აქტუალურ განყოფილებაში. თქვენ ასევე შეგიძლიათ გამოიყენოთ საძიებო ფუნქცია აქ გვერდის ზედა საკვანძო სიტყვების მოსაძებნად.

• ⛔ ავარია

• 🎨 გრაფიკა

• 🎧 აუდიო

• 🎮 შეყვანა და კონტროლერები

თუ იპოვნეთ პრობლემის გადაწყვეტა, რომელიც აქ არ იყო ნახსენები, შეგიძლიათ შეიტანეთ წვლილი ამ განყოფილებაში!

თუ აქ ვერ იპოვნეთ თქვენი პრობლემის გადაწყვეტა, შეგიძლიათ დახმარება სთხოვოთ საზოგადოებას:

• Discord Community
• Zulip Community
• Reddit Community

თუ ფიქრობთ, რომ უფრო სერიოზულ შეცდომას წააწყდით, შეგიძლიათ შეატყობინეთ ხარვეზის შესახებ GitLab-ზე.

⛔ ავარია

მიუხედავად იმისა, რომ ჩვენ ვცდილობთ უზრუნველვყოთ, რომ Veloren იყოს მაქსიმალურად სტაბილური, არსებობს რამდენიმე რამ, რამაც შეიძლება გამოიწვიოს ეს თამაში კრახისთვის. საბედნიეროდ, ბევრი მათგანი გამოსწორდება!

საჰაერო ხომალდი არ დაიწყებს (ან ავარია გაშვებისას)

შესაძლო გადაწყვეტილებები:

• განაახლეთ თქვენი გრაფიკის დრაივერები

• Airshipper-ის გაშვება თავსებადობის რეჟიმში

თავსებადობის რეჟიმი

Airshipper-ს შეუძლია იმუშაოს რეჟიმში, სადაც მომხმარებლის ინტერფეისი არ ჩანს, რომელიც ცნობილია როგორც “თავსებადობის რეჟიმი”. ამ რეჟიმში, Airshipper ავტომატურად ჩამოტვირთავს და გაუშვებს Veloren-ის უახლეს ვერსიას თქვენთვის.

• Windows-ზე თავსებადობის რეჟიმის გამოყენება შესაძლებელია გამოყოფილი „Airshipper: Compatibility Mode“ ხატულასთან

• ყველა პლატფორმაზე, თქვენს კონსოლში airshipper run შეყვანით დაიწყება Airshipper თავსებადობის რეჟიმში

Veloren (Voxygen) ავარია გაშვებისას

შესაძლო გადაწყვეტილებები:

• განაახლეთ თქვენი გრაფიკის დრაივერები

• გადართეთ სხვა გრაფიკული ფონზე

• სცადეთ გამორთეთ აუდიო

🎨 გრაფიკა

Veloren მოითხოვს, რომ თქვენს კომპიუტერს მხარდაჭერილი ჰქონდეს ერთ-ერთი შემდეგი:

• DirectX (მხოლოდ Windows, ვერსია 11.2 ან უფრო მაღალი)
• (შენიშვნა: Airshipper-ის ბოლო ვერსიები საჭიროებს DirectX 12-ს, მაგრამ თავსებადობის რეჟიმი მაინც უნდა იმუშაოს)
• Vulkan (მხოლოდ Windows და Linux, ვერსია 1.2 ან უფრო მაღალი)
• მეტალი (მხოლოდ Mac OS)

თუ თქვენს კომპიუტერს არ აქვს ერთ-ერთი მათგანის მხარდაჭერა, შეიძლება ვერ შეძლოთ თამაშის გაშვება.

მძღოლები

Veloren-ის გაშვებამ შეიძლება მოითხოვოს თქვენი გრაფიკის დრაივერების განახლება ან მათი ინსტალაცია, თუ ისინი უკვე არ გაქვთ.

• თუ გაშვებულია Windows, შეგიძლიათ მიჰყვეთ ამ სახელმძღვანელოს თქვენი განახლებისთვის გრაფიკის დრაივერები

• თუ გაშვებულია Linux, შეგიძლიათ მიჰყვეთ ამ სახელმძღვანელოს ინსტალაციისთვის ვულკანის მძღოლები. გთხოვთ გაითვალისწინოთ, რომ ბევრ დისტრიბუციას არ აქვს Vulkan-ის დრაივერები წინასწარ დაინსტალირებული: ის ფაქტი, რომ სხვა თამაშები კარგად მუშაობს არ არის იმის მანიშნებელი, რომ თქვენ გაქვთ Vulkan დრაივერები დაინსტალირებული!

• თუ მუშაობს Mac OS, შეიძლება დაგჭირდეთ სისტემის განახლება უახლესი დრაივერების მისაღებად

გრაფიკული უკანა ნაწილი

<video width=“640” height=“460” autoplay loop დადუმებულია> <წყარო src=“https://s3.eu-central-2.wasabisys.com/veloren-blog/cdn/464698017283440640/1016333211472764928/airshipper_qDdxbKVHnq=“vide.mp4” type“ თქვენს ბრაუზერს არ აქვს ვიდეო ტეგის მხარდაჭერა

ზოგიერთ პლატფორმაზე Veloren-ის გაშვება შესაძლებელია რამდენიმე განსხვავებული გრაფიკული API-დან ერთ-ერთის გამოყენებით.

შეგიძლიათ გადართოთ ხელმისაწვდომ გრაფიკულ ფონებს შორის Airshipper-ის პარამეტრებში.

• Windows-ზე მხარდაჭერილია შემდეგი გრაფიკული ბაქენდები:
• DirectX 11
• DirectX 12
• ვულკანი
• Linux-ზე მხოლოდ Vulkan არის მხარდაჭერილი (თუმცა ცნობილია, რომ Veloren კარგად მუშაობს WINE Windows-ზე მხარდაჭერილი backend-ების გამოყენებით, ასე რომ, ეს შეიძლება თქვენთვის სასურველი ვარიანტი იყოს)
• Mac OS-ზე მხოლოდ Metal არის მხარდაჭერილი

თუ თქვენ იყენებთ Airshipper-ს თავსებადობის რეჟიმში, თქვენ მაინც შეგიძლიათ შეცვალოთ გრაფიკული გვერდი გაშვებული airshipper config თქვენს კონსოლში. თქვენ წარმოგიდგენთ მენიუს, რომელიც საშუალებას მოგცემთ დააკონფიგურიროთ Airshipper-ის პარამეტრები GUI-ის ანალოგიურად.

Airshipper-ის ძველ ვერსიებში, თქვენ კვლავ შეგიძლიათ შეცვალოთ გრაფიკული ბაქენდი ფაილის გახსნით airshipper_state.ron ტექსტის რედაქტორში. ფაილის ბოლოში არის შემდეგი ხაზი:

wgpu_backend: Auto,

შეგიძლიათ შეცვალოთ Auto ერთით DX11, DX12, Vulkan, ან Metal-ით (თქვენი ოპერაციული სისტემის მიხედვით). გთხოვთ, გაითვალისწინოთ, რომ ეს ველი *სენსიტიურია რეგისტრის მიმართ.

Airshipper-ს აკლია ინტერფეისის ელემენტები ან ციმციმები მაუსის გადაადგილებისას

ამის გამოსასწორებლად შეიძლება დაგჭირდეთ თქვენი გრაფიკის დრაივერების განახლება.

გრაფიკული ხარვეზები თამაშში

შეიძლება დაგჭირდეთ განახლება თქვენი გრაფიკის დრაივერების განახლება.

ალტერნატიულად, სხვა [graphic backend]-ზე (#graphics-backend) გადართვამ შეიძლება გადაჭრას პრობლემა.

დარწმუნდით, რომ თქვენს კომპიუტერს აქვს საჭირო გრაფიკული მხარდაჭერა.

🎧 აუდიო

აუდიო არ მუშაობს

Linux-ზე შესაძლოა დაგჭირდეთ ALSA კონფიგურაციის დაყენება PulseAudio-სთვის.

• Arch Linux-ისთვის ეს ნიშნავს pulseaudio-alsa პაკეტის დაყენებას. ამის გაკეთება შეგიძლიათ pacman -S pulseaudio-alsa-ით

აუდიოს გამორთვა

განსაკუთრებით მძიმე შემთხვევებში, შეიძლება საჭირო გახდეს აუდიოს გამორთვა Veloren-ში ავარიის ან მსგავსი პრობლემების თავიდან ასაცილებლად. შენ შეუძლია ამის გაკეთება:

1. დარწმუნდით, რომ Veloren დახურულია.
2. settings.ron მდებარეობა (იხილეთ სად ინახავს Airshipper ფაილებს)
3. მისი რედაქტირება და output: Automatic output: Off-ით ჩანაცვლება. ეს უნდა გამოიყურებოდეს:

  audio: (
    master_volume: 1,
    music_volume: 1
    sfx_volume: 1,
    max_sfx_channels: 10,
    output: Off, // The important line!
  ),

4. ფაილის შენახვა და თამაშის ხელახლა გაშვება.

🎮 შეყვანა და კონტროლერები

მაუსი უხილავია ან ფანჯრის ზომის შეცვლა არ მუშაობს სწორად Wayland-ის გამოყენებისას Linux-ზე

მიუხედავად იმისა, რომ Veloren მხარს უჭერს Wayland-ს, ეს მხარდაჭერა ხანდახან შეიძლება იყოს მტკივნეული. ეს პრობლემები შეიძლება გამოსწორდეს xcursor თემის მკაფიოდ მითითებით გამოსაყენებელი პროგრამა. ამისათვის ჯერ გაუშვით შემდეგი ბრძანება ტერმინალში მიიღეთ გამოსაყენებელი თემა:

find /usr/share/icons/ -type d -name "cursors" | head -1 | awk -F / '{print $5}'

დააყენეთ XCURSOR_THEME გარემოს ცვლადი შედეგზე. თუ თქვენ გაქვთ Adwaita, მაგალითად, თქვენ გააკეთეთ შემდეგი:

• თუ იყენებთ Airshipper, დაამატეთ XCURSOR_THEME=Adwaita ველში “Environment Variables” პარამეტრებში

• თუ მუშაობს დამოუკიდებელ პროგრამად, დააყენეთ თქვენი დესკტოპის გარემო XCURSOR_THEME-ზე Adwaita გაშვებისას თამაში

• თუ გაშვებულია ბრძანების სტრიქონიდან, მიამაგრეთ XCURSOR_THEME=Adwaita ბრძანებას, რომელსაც იყენებთ თამაშის გასაშვებად, მაგ. XCURSOR_THEME=Adwaita ./veloren-voxygen

თუ ეს არ მუშაობს, შეგიძლიათ სცადოთ xwayland თავსებადობის შრის გამოყენება გაშვებისას.

• თუ იყენებთ Airshipper, დაამატეთ WINIT_UNIX_BACKEND=x11 ველში “Environment Variables” პარამეტრებში

• თუ მუშაობს როგორც დამოუკიდებელი პროგრამა, დააყენეთ თქვენი დესკტოპის გარემო WINIT_UNIX_BACKEND-ზე x11 გაშვებისას თამაში

• თუ მუშაობს ბრძანების სტრიქონზე, დაუდეთ WINIT_UNIX_BACKEND=x11 ბრძანებას, რომელსაც იყენებთ თამაშის გასაშვებად, მაგ. WINIT_UNIX_BACKEND=x11 ./veloren-voxygen

PS4 ან სხვა კონტროლერი არ მუშაობს

ამჟამად Windows-ზე მხარდაჭერილია მხოლოდ XInput კონტროლერები. ეს ნიშნავს, რომ კონტროლერები, როგორიცაა PS4, Switch და ზოგიერთი ძველი გენერიკ კონტროლერები შეიძლება არ იმუშაონ Veloren-თან.

ამის ირგვლივ მუშაობისთვის, პროგრამა, როგორიცაა DS4Windows შეიძლება იყოს გამოყენებულია. შეგიძლიათ იხილოთ როგორც ტექსტური, ასევე ვიდეო გაკვეთილი DS4Windows-ის გამოყენების შესახებ აქ.

შესრულება

ამ გვერდზე თქვენ იხილავთ რჩევებსა და ხრიკებს, რომლებიც დაგეხმარებათ მიიღოთ მაქსიმალური სარგებლობა Veloren-ისგან.

შესავალი

ველორენის სამყარო შეიძლება ძირითადად კუბებისგან იყოს დამზადებული, მაგრამ არ მოგატყუოთ! ველორენის სამყარო ვრცელი და დეტალურია საბაზო თამაშს აქვს მრავალი გრაფიკული ეფექტი. უმაღლეს პარამეტრებზე, Veloren-ს შეიძლება დასჭირდეს ძალიან ძლიერი კომპიუტერი გასაშვებად. ნუ ველით, რომ შეძლებთ ყველა სლაიდერის მაქსიმუმამდე გადაგდებას და ველით, რომ თამაში იდეალურად წარიმართება.

თქვენი ბოსტნის იდენტიფიცირება

უმეტეს შემთხვევაში, Veloren-ის ცუდი შესრულება გამოწვეულია 3-დან ერთ-ერთ „ბუშტუკთან“. ამის შესახებ ინფორმაციისთვის იხილეთ ქვემოთ შემთხვევები, როგორ ამოვიცნოთ ისინი და როგორ გამოვასწოროთ ისინი.

ფრაგმენტით შეზღუდული

თუ თქვენ ფრაგმენტებით შეზღუდული ხართ, შესრულება გაუარესდება, თუ თითოეული პიქსელის რენდერისთვის საჭირო დრო იზრდება. თუ თქვენი შიდა გარჩევადობის შემცირება აუმჯობესებს კადრების სიხშირეს, ეს სავარაუდოდ თქვენც გეხებათ. ამ სიტუაციის გამოსასწორებლად, თქვენ შეუძლია:

• შიდა გარჩევადობის შემცირება (ანტიალიასინგის ტექნიკას შეუძლია გააუმჯობესოს თამაშის იერსახე ქვედა რეზოლუციებზე)
• შეამცირეთ ღრუბლის გადაცემის ხარისხი
• გადაერთეთ სითხის გადაცემაზე “იაფზე”
• შეამცირეთ ჩრდილის რუკის გარჩევადობა ან გადართეთ “იაფი” ჩრდილებზე
• შეამცირეთ ან გამორთეთ აყვავება

Vertex-Limited

თუ თქვენ ხართ ვერტექსით შეზღუდული, ყველაფერი, რაც გამოიწვევს თამაშის ეკრანზე მეტი მრავალკუთხედის გადმოცემას, აუარესებს თქვენს შესრულება. თუ სპრაიტის ხედვის მანძილის შემცირება აუმჯობესებს თქვენს კადრების სიხშირეს, ეს სავარაუდოდ თქვენც გეხებათ. ამის გამოსასწორებლად სიტუაცია, შეგიძლიათ:

• შეამცირეთ ხედვის მანძილი (ამცირებს რელიეფის რაოდენობას, რომელიც თამაშმა უნდა გამოიტანოს)
• შეამცირეთ sprite/entity/entity დეტალების ხედვის მანძილი
• შეამცირეთ LoD მანძილი
• შეამცირეთ LoD დეტალები

CPU შეზღუდული

თუ თქვენ CPU შეზღუდული ხართ, თამაშის შესრულება შემოიფარგლება თქვენი CPU-ის სიჩქარით და არა GPU-ით. თუ თქვენი CPU გამოყენება რეგულარულად ძალიან მაღალია, ეს სავარაუდოდ თქვენც გეხებათ. სამწუხაროდ, ეს არის შეზღუდული რაოდენობის რამ, რისი გაკეთებაც შეგიძლიათ გამოასწორეთ ეს სიტუაცია, რადგან CPU-ს მუშაობის უმეტესობა აუცილებელია თამაშის ფუნქციონირებისთვის. ამის თქმით, შეგიძლიათ:

• შეამცირეთ თქვენი ხედვის მანძილი (ნაკლები ერთეული და ნაკლები რელიეფის მონაცემები დასამუშავებლად)
• გადაერთეთ მულტიპლეიერზე (ახლა სერვერის ამოცანაა სამყაროს სიმულაცია და რელიეფის გენერირება)
• დახურეთ ნებისმიერი სხვა პროგრამა, რომელიც შესაძლოა გახსნილი გქონდეთ

რა კომპრომისს ეძებთ?

Veloren-ს აქვს პარამეტრების გაცილებით დიდი რაოდენობა (და ამ პარამეტრების უფრო ფართო დიაპაზონი), ვიდრე სხვა თამაშებს. ჩვენ არ მოგვწონს როდესაც თამაშები ხელოვნურად ზღუდავს ჩვენი თამაშის გზას, ამიტომ Veloren შექმნილია იმისთვის, რომ აირჩიოთ ეფექტები თქვენ ზრუნავთ შესახებ. აქ მოცემულია რამდენიმე არქეტიპი, რომლებიც შეიძლება მოერგოთ და რამდენიმე რჩევას, რომელთა შესრულებაც გსურთ:

პიქსელის პერფექციონისტი

სიზუსტეზე ზრუნავთ. გაღიზიანებთ, როდესაც თამაშებს აქვთ aliasing artifacts. თქვენ ელით, რომ ყოველი პიქსელი თავისთავად ხელოვნების უნაკლო ნამუშევარი იქნება. შენ ხარ ისეთი ადამიანი, ვინც მორროვინდის როლს თამაშობს, ოღონდ მხოლოდ 8x სუპერ შერჩევით. შეიძლება გინდოდეთ:

• გაზარდეთ “შიდა გარჩევადობა” (1.0x-ზე მეტი შეესაბამება სუპერ ნიმუშის საწინააღმდეგო ალიასინგი, ანუ: SSAA)
• გამორთეთ FXAA (მას შეუძლია შექმნას დახვეწილი არტეფაქტები)
• გაზარდეთ ჩრდილის რუკის გარჩევადობა

დაბალი სიმძლავრის ქვეშევრდომი

თქვენ უბრალოდ გსურთ, რომ Veloren დაკვრა იყოს თქვენს აპარატურაზე. თქვენ მზად ხართ შესწიროთ უფრო ლამაზი გრაფიკული ეფექტები, მაგრამ იდეალურ შემთხვევაში, თამაშის გარეშე ვირის ტრაკივით გამოიყურება. ყველაფერი, რაც აღემატება 20 fps და 240p არის თქვენი წარმატება წიგნები. შეიძლება გინდოდეთ:

• გადაერთეთ “იაფი” ჩრდილებზე
• გადართეთ ღრუბლის რენდერი „დაბალზე“ ან „მინიმალურზე“
• შეამცირეთ შიდა გარჩევადობა (შეგიძლიათ ჩართოთ ანტი-ალიასინგის ტექნიკა, როგორიცაა FXAA ან HQX დარტყმის შესარბილებლად)
• გადართეთ „სითხის გაცემა“ „იაფიზე“
• შეამცირეთ მაქსიმალური FPS, რათა თავიდან აიცილოთ თქვენი GPU გადახურება
• სცადეთ ‘BareMinimum’ [ექსპერიმენტული შადერის] ჩართვა (voxygen.md#experimental-shaders)

ღმერთის სხივის ღმერთი

ყოველ დილით აყრით ყვავილობას თქვენს საუზმის მარცვლეულს. თქვენ არ ხართ ბედნიერი, სანამ თქვენი თამაში წყალქვეშა თამაშს არ ჰგავს დისკო. ერთადერთი პროგრამა, რომელსაც Veloren-ზე მეტად აწარმოებთ, არის “ReShade”. შეიძლება გინდოდეთ:

• “აყვავების” გაზრდა
• გაზარდეთ “წერტილი ბზინვარება”
• გადართეთ “მსუბუქი გადაცემის რეჟიმი” “მაღალზე”
• გაზარდეთ ღრუბლის რენდერაცია “მაღალ” ან თუნდაც “ულტრა” (უფრთხილდით: ძალიან ძვირი)
• შეამცირეთ “შიდა გარჩევადობა”, რათა გაათავისუფლოთ თქვენი GPU მეტი შემდგომი დამუშავების ეფექტისთვის
• გადართეთ “სითხის გაცემა” “მბზინავზე”
• გაუმჯობესებული ესთეტიკისთვის ჩართეთ „კამერის გამარტივება“ „Gameplay“-ში
• სცადეთ ზოგიერთი ექსპერიმენტული შადერები.

144 ჰც-იანი მოთამაშე

თქვენი გრძნობები დახვეწილია ათწლეულების განმავლობაში, რათა გამოვლინდეს ქვემილიწამიანი შეყოვნება. იმ დღეს, თქვენ მართავდით კონსოლებს NTSC-ში კონფიგურაციები დამატებითი 4,97 კადრი წამში PAL-ზე. უბრალოდ შევხედე ეკრანს განახლების სიხშირით ორნიშნა რიცხვი იწვევს პირღებინებას. თქვენ უკვე გამორთეთ „მოძრაობის ინტერპოლაცია“ თქვენს ტელევიზორზე და ყველა ტელევიზორზე შენ იცი. შეიძლება გინდოდეთ:

• გაზარდეთ მაქსიმალური FPS “შეუზღუდავად”
• გადართეთ „აწმყო რეჟიმი“ „vsync uncapped“-ზე, რათა შემცირდეს ცრემლდენა
• შეამცირეთ “შიდა გარჩევადობა”, რათა თქვენს GPU-ს ნაკლები სამუშაო ჰქონდეს თითო ჩარჩოზე
• გადაერთეთ „ექსკლუზიურ სრულეკრანიანზე“, რათა მინიმუმამდე დაიყვანოთ ნებისმიერი შეყოვნება, რომელიც შეიძლება დაწესდეს თქვენი ფანჯრის მენეჯერის მიერ
• დარწმუნდით, რომ “კამერის გამარტივება” გამორთულია თამაშის პარამეტრებში
• გამოიყენეთ “GPU timeings” ხელსაწყო, რათა გაარკვიოთ, თუ რა სფეროებს ჭირდება ყველაზე მეტი დრო

Veloren კონტრიბუტორებისთვის

გმადლობთ, რომ დაინტერესდით წვლილით!
დარწმუნდით, რომ წაიკითხეთ სექცია შესავალი და თუ გსურთ განყოფილება დეველოპერებისთვის.

წინააღმდეგ შემთხვევაში, თავისუფლად გადახტეთ, როგორც გჭირდებათ.

Veloren კონტრიბუტორებისთვის

წიგნის ამ განყოფილებაში მოცემულია მიმოხილვა იმის შესახებ, თუ როგორ უნდა შეიტანოთ წვლილი Veloren-ში, არ აქვს მნიშვნელობა, მიიღეთ ხარისხი ან თავად ასწავლეთ. იქნება ეს კოდი, აქტივები, არსებები, შეცდომების გამოსწორება თუ თავად წიგნი!

შენიშვნა: ამ სახელმძღვანელოში ჩვენ ვივარაუდებთ კომპიუტერის საბაზისო ცოდნას და გარკვეულ ცნობისმოყვარეობას ვისწავლოთ თუ რას ვაკეთებთ აქ დამოუკიდებლად.

• განვითარების ხელსაწყოები
• Git-თან მუშაობა
• სანამ წვლილს შეიტანთ
• FAQ
• პრობლემების აღმოფხვრა

განვითარების ხელსაწყოები

#ინსტალაცია

თუ გსურთ თქვენი წვლილი შეიტანოთ Veloren-ში რაიმე ფორმით, თქვენ ალბათ უნდა გაუმკლავდეთ Veloren-ის source კოდი. ამიტომ, ეს ძირითადი ხელსაწყოები უნდა დამონტაჟდეს მასთან ურთიერთობისთვის.

შენიშვნა: მთელი წიგნის განმავლობაში აღვნიშნავთ უამრავ ბრძანებას. ამიტომ ჩვენ უაღრესად გირჩევთ კომფორტული ტერმინალით.

გიტ

_ ველორენის ისტორიის თვალყურის დევნება._

Windows-ისთვის, ‘Git for Windows’ კომპლექტი გონივრული გზაა დააინსტალირეთ Git, ინსტრუმენტების კომპლექტთან ერთად, რომელიც გაგიადვილებთ გამოყენებას.

Linux-ზე Git დიდი ალბათობით უკვე დაინსტალირებულია, თუ არ არის, გამოიყენეთ თქვენი დისტრიბუციის პაკეტი მენეჯერი დააინსტალიროს.

ბოლო macOS ვერსიებზე თქვენ მოგეთხოვებათ დააინსტალიროთ Git პირველად გაშვებისას. წინააღმდეგ შემთხვევაში დააინსტალირეთ Homebrew გამოყენებით brew install git ან MacPorts port install git-ის მეშვეობით.

Git LFS

_ თვალყური ადევნეთ იქ არსებულ მართლაც დიდ გიგანტებს (აკა. აქტივების ფაილები)._

Git LFS არის Git გაფართოება, რომელიც გამოიყენება დიდი ფაილების შესანახად როგორიცაა სურათები და აუდიო ფაილები. თქვენ უნდა დააინსტალიროთ აქტივების ჩამოსატვირთად.

1. Windows-ისთვის შეგიძლიათ ჩამოტვირთოთ ინსტალერი აქ.

Linux-ზე შეგიძლიათ გამოიყენოთ პაკეტის მენეჯერი Git LFS-ის დასაყენებლად, ჩვეულებრივ პაკეტს ეწოდება git-lfs.

macOS-ზე შეგიძლიათ გამოიყენოთ Homebrew brew install-ის საშუალებით git-lfs or MacPorts via port დააინსტალირე git-lfs.

2. Git LFS უნდა დაყენდეს git lfs install ან git-lfs install (macOS) გაშვებით ტერმინალში.

შენიშვნა: _ თუ თქვენ უკვე მოახდინეთ რეპოს კლონირება Git LFS-ის დაყენებამდე, დამატებითი ნაბიჯებია აუცილებელია._

შენიშვნა: git-lfs-ს აქვს დისტანციური მართვის ფუნქციონირების ცნობილი შეცდომა. თუ გეგმავთ ჩანგლის დამუშავებას, იხილეთ ამ განყოფილებაში.

ჟანგი

_ ჩვენ ვიცავთ უსაფრთხოდ და საიმედოდ, რათა ავაშენოთ საიმედო და ეფექტური თამაში._

Rust არის ზოგადი დანიშნულების პროგრამირების ენა, რომელსაც ჩვენ ვიყენებთ. იხილეთ FAQ განყოფილება იმის გასაგებად, თუ რატომ.

Rust-ის ინსტალაციის რეკომენდებული გზაა Rustup. მიჰყევით ინსტრუქციები ყურადღებით და ყველაფერი კარგად უნდა იყოს.

ადგილობრივი საცავის დაყენება და მოვლა

ეს განყოფილება აღწერს თქვენი ადგილობრივი საცავების თავდაპირველ დაყენებას და შენარჩუნებას.

შენიშვნა: შემდეგის გასაგებად, ჩვენ გირჩევთ წაიკითხოთ git-ის შესახებ!

ჩამოტვირთეთ საწყისი კოდი

შენიშვნა: Veloren-ს სჭირდება git LFS-ის დაყენება კლონირებამდე, რათა შეძლოს აქტივების ჩამოტვირთვა. თუ git LFS-ის დაყენებამდე უკვე კლონირებდით საცავს, გამოიყენეთ ეს ნაბიჯები აქტივების ჩამოტვირთვის მისაღებად.

საცავის კლონირება

git clone https://gitlab.com/veloren/dev/veloren.git

შეცვალეთ თქვენი სამუშაო დირექტორია კლონირებულ საცავში

cd veloren

შენიშვნა: _ ამ თავში ამიერიდან ყველა ბრძანება უნდა შესრულდეს იქიდან._

ძირითადი რეპო ნავიგაცია

ფილიალების შეცვლა

იმისათვის, რომ გამოსცადოთ ახალი შეუერთებელი ან დაუმთავრებელი ფუნქციები, შეიძლება დაგჭირდეთ სხვა ფილიალზე გადასვლა.

განვითარების ფილიალზე გადასვლა

git checkout <branch_name>

სამაგისტროზე დასაბრუნებლად

git checkout master

განახლება

ჩამოტვირთეთ უახლესი ცვლილებები და განაახლეთ თქვენი მიმდინარე ფილიალი

git pull

ჩამოტვირთეთ უახლესი ცვლილებები მათ ადგილობრივ ფილიალში გაერთიანების გარეშე

git fetch

დახმარების ბრძანება

Git ასევე გთავაზობთ დახმარების ბრძანებას სხვა ბრძანებების შესახებ დეტალური ინფორმაციით

git help <optional subcommand name>

საწყის კოდის შეცვლა

თუ გსურთ შეცვალოთ საწყისი კოდი, იხილეთ დეველოპერი განყოფილება.

თქვენ მიერ საწყის კოდში განხორციელებული ცვლილებების გაუქმება

git reset --hard

გაითვალისწინეთ, რომ ეს წაშლის ყველა ცვლილებას ** მათი აღდგენის გარეშე **.

თქვენი ცვლილებების გაუქმება მოგვიანებით მათი აღდგენის შესაძლებლობით

git stash

დამალული ცვლილებების აღსადგენად

git stash pop

ძველი build ფაილების გაწმენდა

დროთა განმავლობაში, როგორც დამოკიდებულებები განახლდება, ძველი შედგენილი ვერსიები დიდ ადგილს იკავებენ. მათი წასაშლელად აკრიფეთ

cargo clean

** შენიშვნა: ** გაითვალისწინეთ, რომ ტვირთს დასჭირდება ყველა დამოკიდებულების ხელახლა შედგენა, რასაც შეიძლება დიდი დრო დასჭირდეს.

Rust ინსტრუმენტთა ჯაჭვის განახლება

ჩვენ ვიყენებთ rust-toolchain ფაილს საცავში, რომელიც ავტომატურად განახლდება თქვენი rust toolchain რომელ ვერსიასაც ვიყენებთ. არ უნდა იყოს საჭირო რაიმე დამატებითი ძალისხმევა თქვენი მხრიდან.

ველორენის შედგენა

ეს განყოფილება მოიცავს Veloren-ის აშენებას ჟანგის წყაროდან cargo-ით და მის გაშვებას.

** შენიშვნა: ** _ ყველა ბრძანება უნდა შესრულდეს საცავიდან._

საჭირო ბიბლიოთეკები

Windows-ზე დაგჭირდებათ შემდეგი პროგრამების დაყენება:

• [Visual Studio Build Tools] (https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022)
• CMake
• Ninja build system
• პითონი 3

საბედნიეროდ, არსებობს ** სწრაფი გზა ინსტალაციისთვის ** მათი უმეტესობისთვის

1. ჩამოტვირთეთ და გაუშვით Visual Studio Build Tools და დააინსტალირეთ:

• C++ ინსტრუმენტები.
• Windows 10 SDK.

2. გახსენით PowerShell ტერმინალი და გაუშვით შემდეგი ბრძანებები:

    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
    Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
    scoop install cmake ninja python
    ```

პირველი ორი ხაზი დააინსტალირებს Scoop პაკეტის მენეჯერს და
მესამე ხაზი აინსტალირებს CMake-ს, Ninja-ს და Python-ს Scoop-ის მეშვეობით ერთი ნაბიჯით.

**Linux**-ზე დაგჭირდებათ GTK3, Python და CMake დაყენებული.

**Gentoo**-ზე შეიძლება დაგჭირდეთ გარკვეული გამოყენების დროშების ჩართვა კონკრეტული პაკეტებისთვის.

* sys-devel/binutils (`gold`-ით გამოიყენეთ დროშა ld.gold ლინკერის გასააქტიურებლად)
* media-libs/mesa (`vulkan`გამოყენების დროშით)

**Debian** სისტემებზე შეიძლება დაგჭირდეთ დამატებითი ბიბლიოთეკების ჩამოტვირთვა, ქვემოთ მოცემულია არასრული სია:

* g++
* libglib2.0-dev
* libcairo2-dev
* libasound2-dev
* libpango1.0-dev
*libatk1.0-dev
* libgdk-pixbuf2.0-dev
* libgtk-3-dev
* libxcb-shape0-dev
* libxcb-xfixes0-dev
* ლიბუდევ-დევ
* libxkbcommon-x11-dev
* libxcb-xkb-dev

და ერთი ლაინერი ყველა ჩამოსატვირთად და დასაინსტალირებლად:<br/>
`sudo apt install g++ libglib2.0-dev libasound2-dev libcairo2-dev libpango1.0-dev libatk1.0-dev libgtk-3-dev libxcb-shape0-dev libxcb-xfixes0-dev libudev-dev libxkbcommon-x11-dev libxcb-xkb-dev`

**Fedora** სისტემებზე შეიძლება დაგჭირდეთ დამატებითი ბიბლიოთეკების ჩამოტვირთვა, ქვემოთ მოცემულია ბრძანება მათი ინსტალაციისთვის:<br/>
`sudo dnf install gcc gcc-c++ binutils-gold cmake alsa-lib-devel libxkbcommon-x11-devel libudev-devel`

**openSUSE Tumbleweed** სისტემებზე შეიძლება საჭირო გახდეს დამატებითი დამოკიდებულებები:<br/>
`sudo zypper in binutils-gold alsa-devel systemd-devel libxkbcommon-devel libxkbcommon-x11-devel`

**macOS**-ზე თქვენ მხოლოდ უნდა დააინსტალიროთ cmake.
ეს შეიძლება გაკეთდეს **homebrew** ან **macports** გამოყენებით.
homebrew-ის გამოყენებით შეიყვანეთ `brew install cmake` ან ანალოგიურად, macports-ის გამოყენებით შეიყვანეთ `sudo port install cmake`.
**შენიშვნა**: არ გამოიყენოთ სუდო ჰოუმბრუსთან ერთად.

** შენიშვნა: ** _ თავისუფლად გახსენით საკითხი, თუ ეს დამოკიდებულებები არასწორია._

## შეადგინეთ და გაუშვით Veloren

გაუშვით ეს ტერმინალში Veloren-ის შედგენისა და გასაშვებად:

```bash
cargo run

გაშვების გარეშე კომპილაციისთვის გამოიყენეთ cargo build.

შენიშვნა: _ თავდაპირველი შედგენა დასჭირდება 5 წუთიდან 30 წუთამდე, ამიტომ აიღეთ ჩაი და რამდენიმე საჭმელი და დაბრუნდით მოგვიანებით._

შეადგინეთ და გაუშვით Veloren სერვერი

cargo run --bin veloren-server-cli

შესვლა გამომავალი

ჩვენ ვიყენებთ tracing ჟურნალების შესაგროვებლად. მათი გაფილტვრა შესაძლებელია RUST_LOG გარემოს ცვლადის შესაბამის დონეზე დაყენებით (error, warn, info, debug, trace).

ფილტრაციის ყველა ხელმისაწვდომი ვარიანტისთვის ეწვიეთ დოკუმენტებს.

** რჩევა: ** _ ეს მუშაობს როგორც სერვერზე, ასევე კლიენტზე.

ოპტიმიზებული გამოშვების შენობები

ნაგულისხმევად იქმნება გამართვის კონსტრუქციები, რომლებიც კომპლირდება უფრო სწრაფად, მაგრამ მუშაობს ოდნავ ნელა, ვიდრე ოპტიმიზირებული გამოშვების ნაგებობები. ბევრი სხვა პროექტისგან განსხვავებით, ჩვენ დავაყენეთ ისინი ისე, რომ ისინი საკმარისად სწრაფი იყვნენ დაკვრად. თუ გსურთ მიიღოთ ოპტიმიზირებული ნაგებობები, დაამატეთ --release დროშა cargo-ის დარეკვისას. გაითვალისწინეთ, რომ გამოშვების შედგენა შეიძლება ძალიან ნელი იყოს!

თუ გსურთ გაეცნოთ ტვირთს, ჩვენ გირჩევთ Cargo Book.

ჯვარედინი ველორენის შედგენა

რამდენადაც უფრო და უფრო მეტ ადამიანს სურს Veloren-ისთვის თამაში ან განვითარება სხვა პლატფორმებზე, შეიძლება გასაკვირი არ იყოს, რომ ამ პლატფორმებზე ზე აშენება შეიძლება არ იყოს ყველაზე ელეგანტური გადაწყვეტა, ემულაცია საკმაოდ ხშირად ნელია და არჩეულ პლატფორმას უბრალოდ არ აქვს საჭირო რესურსები თამაშის შესაქმნელად გონივრულ დროში.

გთხოვთ გაითვალისწინოთ: ამ ნაბიჯების დოკუმენტაცია ამჟამად მიმდინარეობს, შესაძლოა დაგჭირდეთ მათი კორექტირება თქვენი კონკრეტული სცენარისთვის.

Linux

წინაპირობები

იმისათვის, რომ შექმნათ თქვენი არჩეული პლატფორმისთვის, მაგალითად arm64, თქვენ უნდა დააინსტალიროთ შემდგენელი ხელსაწყოების ჯაჭვი ამ არქიტექტურისთვის. ჩვენს შემთხვევაში, ეს არის aarch64-linux-gnu-gcc.

თქვენ ასევე დაგჭირდებათ თქვენი არქიტექტურისთვის დაინსტალირებული პროექტის კომპილაციის დამოკიდებულებები. ჩვენს მაგალითში, ჩვენ გამოვიყენეთ Raspberry Pi პროექტის შედგენისთვის საჭირო ყველა დამოკიდებულების დასაყენებლად, შემდეგ SD ბარათი ჩაერთო შენობის სისტემაში და მისი root ფაილური სისტემა დამონტაჟდა /mnt-ში.

ჯვარედინი შედგენა

პროექტის წყაროს ხე კლონირებული იქნა ჩვენს სამშენებლო მანქანაში, თვითნებურ ადგილას. გახსენით ტერმინალი და გადადით პროექტის root-ზე, შემდეგ შეასრულეთ:

rustup target add [target]

სადაც [target] არის ერთ-ერთი სამიზნე აქ. ჩვენს შემთხვევაში, ეს იყო aarch64-unknown-linux-gnu. ამის შემდეგ, თქვენ უნდა შეხვიდეთ ახლად შექმნილ .cargo დირექტორიაში და შეცვალოთ config ფაილი. დაამატეთ შემდეგი ჩანაწერი:

[target.X]
linker="Y"

სადაც X იყო aarch64-unknown-linux-gnu ჩვენს შემთხვევაში, და Y იყო aarch64-linux-gnu-gcc შესაბამისად. ისინი უნდა შეესაბამებოდეს ზემოთ აღნიშნულ მიზანს და შესაბამისად შემდგენელი ხელსაწყოების ქსელს (ის, რომელიც დააინსტალირეთ, როგორც წინაპირობა).

თავად კომპილაციისთვის, თქვენ უნდა უთხრათ Cargo-ს, სად არის სწორი ბიბლიოთეკები. იმის გათვალისწინებით, რომ ჩვენ დავამონტაჟეთ ჩვენი სამიზნის root ფაილური სისტემა /mnt-ზე, შეგვიძლია გამოვიყენოთ PKG_CONFIG_SYSROOT_DIR გარემოს ცვლადი.

კომპილაციის ბრძანება ასე გამოიყურება:

PKG_CONFIG_SYSROOT_DIR=Z cargo build --release --target X

სადაც X არის სამიზნე, რომლისთვისაც ჩვენ ვაშენებთ, და Z არის იმ პლატფორმის ფაილური სისტემის ფესვი, რომლისთვისაც ჩვენ ვაშენებთ. სწორედ აქ იყო დამონტაჟებული Raspberry Pi-ს SD ბარათი, ჩვენს შემთხვევაში /mnt.

მოგერიდებათ შეცვალოთ ბრძანება თქვენს საჭიროებებზე, ორიგინალური კომპილაციის ინსტრუქციების მიხედვით. თქვენ უნდა იპოვოთ ჩაშენებული ბინარები პროექტის root-ის target ქვესაქაღალდეში.

შენიშვნა

წერის დროს, პრობლემაა keyboard-keynames ბიბლიოთეკაში aarch64-ისთვის და, ალბათ, სხვებისთვისაც. თუ ვივარაუდებთ, რომ ~/.cargo არის თქვენი Cargo ჩამოტვირთვების ნაგულისხმევი მდებარეობა, შეცვალეთ ფაილი, რომელიც მდებარეობს მისამართზე: ~/.cargo/git/checkouts/keyboard-keynames-0b8339ee617b0344/a97ae50/src/platform/unix/key_layout.rs და შეცვალეთ ყველა ეგზემპლარი

#![allow(unused)]
fn main() {
unsafe { &*(utf_key as *const [i8] as *const [u8]) }
}

თან

#![allow(unused)]
fn main() {
unsafe { &*(utf_key as *const [c_char] as *const [u8]) }
}

რის შემდეგაც შედგენა წარმატებული იქნება.

სანამ წვლილს შეიტანთ

იმ შემთხვევაში, თუ გსურთ შეიტანოთ კოდი (ან თავად დაამატოთ აქტივები თამაშში) განაგრძეთ კითხვა. თუ არ გსურთ თქვენი აქტივების დამატება, გადადით Contributing Assets.

Git Workflow

არსებობს ორი ძირითადი ვარიანტი, თუ როგორ შეიძლება შეიტანოთ წვლილი თამაშში. მიუხედავად იმისა, თუ როგორ გადაწყვეტთ თქვენი ვალდებულებების შესრულებას, დარწმუნდით, რომ მიჰყევით ქვემოთ მოყვანილ ჩვენს ვალდებულებებს.

ვარიანტი #1: თანამშრომლობის საცავი

ეს არის ჩვენი შემოთავაზებული გზა პროექტში წვლილისთვის.

ეს არის საჯარო საცავი, სადაც ყველას შეუძლია ფილიალების შექმნა (ქვემოთ მოცემული ნაბიჯების შემდეგ), ის სინქრონიზებულია ძირითადი რეპოდან საათობრივ ცვლილებებთან და რეგულარულ ფილიალებთან არ არის გაზიარებული ორს შორის (ერთადერთი გამონაკლისი არის სამაგისტრო ფილიალი). ფილიალის ქონა ჩანგლების გარეშე შეიძლება იყოს უფრო მოსახერხებელი კონტრიბუტორებისთვის როგორც თქვენ შეგიძლიათ თავიდან აიცილოთ ჩანგლის არსებობის ყველა ნაკლოვანება.

თქვენი პირველი წვლილისთვის, მიჰყევით ამ ნაბიჯებს, რათა მიიღოთ წვდომა ჩვენს განვითარების საცავზე:

1. შემოუერთდით ჩვენს თანამშრომლობის ჯგუფს: https://gitlab.com/veloren/dev.
2. Ping ან Core Developers ან Admins-ზე ჩვენს Discord #new-contributors არხზე (ან რომელი არხი შესაფერისია). შეგვატყობინეთ თქვენი GitLab მომხმარებლის სახელის შესახებ და ჩვენ შევძლებთ მოგცეთ დეველოპერის ნებართვები.
3. გადადით მისამართზე https://gitlab.com/veloren/dev/veloren და კლონირეთ საცავი თქვენს კომპიუტერში.
4. შექმენით ფუნქციების ფილიალი (დაწვრილებით მის შესახებ ქვემოთ). ახლა შეგიძლიათ დამოუკიდებლად იმუშაოთ ან სხვებთან ერთად იმუშაოთ იმავე ფილიალში.

განვითარების საცავი პრაქტიკულად იგივეა, რაც მთავარი საცავი მაგრამ ყველას შეუძლია მართოს ფილიალები განვითარების საცავში გარეშე ძირითადი რეპოს ნებისმიერი გზით დაშლის შესაძლებლობა.

ფუნქციების ფილიალების დასახელება

ჩვენ ვიყენებთ ფუნქციების ფილიალებს შემდეგი დასახელების სქემით ფილიალის მფლობელის ადვილად იდენტიფიცირებისთვის:

git checkout -b <your_nickname>/<branch_name>

მაგალითი: zesterer/fix_scrolling_in_chat

ვარიანტი #2: ჩანგალი საცავი

ჩანგლის გამოყენების უარყოფითი მხარეები:

• თქვენ უნდა დააკონფიგურიროთ CI, რომ იმუშაოთ თქვენს ჩანგალზე.
• დამხმარეებს არ შეუძლიათ ადვილად შეიტანონ ცვლილებები თქვენს შერწყმის მოთხოვნებში.

მაგრამ თქვენ თავისუფლად შეგიძლიათ აირჩიოთ ეს სამუშაო პროცესი თანამშრომლობის რეპოს ნაცვლად (იხ. ზემოთ). გადადით GitLab-ში, მთავარ საცავში (არა თანამშრომლობის) და გამოიყენეთ მათი ჩანგლის ღილაკი. გამოიყენეთ პრობლემების მოგვარების ნაბიჯები შემდეგ ნაწილში, რათა LFS-მა იმუშაოს.

პრობლემების მოგვარება Git LFS

როდესაც მთავარ რეპოში ფილიალზე მუშაობის ნაცვლად ჩანგალზე მუშაობთ, git-lfs-ში შეცდომის გამო ამ დროისთვის შემდეგი უნდა გააკეთოთ:

1. დააკონფიგურირეთ git-lfs დაბინძურების იგნორირებაზე:

    git config filter.lfs.smudge "git-lfs smudge --skip -- %f"
    git config filter.lfs.process "git-lfs filter-process --skip"
    ```

2. დაამატეთ Veloren თქვენს ზემოთ დისტანციურ პულტად:

```bash
    git remote add upstream https://gitlab.com/veloren/veloren
    ```

3. განაგრძეთ და გაუშვით `git lfs pull upstream` და გააგრძელეთ ასე, როდესაც ახალი აქტივები დაემატება რეპოს.

#### ჩაიდინეთ მითითებები

მიუხედავად იმისა, თუ რომელი ვარიანტი აირჩიე, ჩვენ გვინდა ჩვენი
ჩაიდინეთ ისტორია, რომ იყოს სუფთა და გაუადვილეთ თვალყური ადევნოთ ჩვენს წარსულ ცვლილებებს.
სუფთა ვალდებულებების უზრუნველსაყოფად, ჩვენ შევადგინეთ შემოთავაზებული პრაქტიკისა და რჩევების სია:

* ** დაყავით თქვენი ცვლილებები გონივრული ზომის, მაგრამ მუშაობის ლოგიკურ ნაწილებად.**

თუ გრძნობთ, რომ მახასიათებელი შეიძლება დაიყოს სამუშაოს მცირე ნაწილად, შეგიძლიათ ასახოთ ეს თქვენი ვალდებულებებით.
შეიძლება ძნელი იყოს ბალანსის პოვნა სწორი რაოდენობის ვალდებულებებს შორის, უბრალოდ შეეცადეთ შეასრულოთ ვალდებულებები, რომლებიც თქვენთვის გონივრული იქნება.

* **გამოიყენეთ აღწერილობითი დავალების სახელები.**

დაუთმეთ ერთი წუთით მოკლედ აღწეროთ რას ცვლის თქვენი ვალდებულება ან თუნდაც რატომ ცვლის ის რაღაცას.
მაგალითად, `fixes` ცუდი სახელია ჩადენისთვის, რადგან ის არაფერს გეუბნებათ თავად ვალდებულების მნიშვნელოვნების შესახებ.
თუ GitLab-ზე არის პრობლემა, რომელიც დაკავშირებულია commit-თან, შეგიძლიათ გამოიყენოთ საკითხის ნომერი და სათაური, მაგ. `Fixes #123 - UDP buffer overflow when too many players are on the server`.

* **გამოიყენეთ `git commit --amend` ბოლო დავალებების შესაცვლელად.**

მაგალითად, თქვენ აიძულეთ თქვენი ცვლილება და ახლა CI იტყობინება, რომ ფორმატის შემოწმება ვერ მოხერხდა,
ახლა იმის ნაცვლად, რომ შევქმნათ ცალკე დაკომპლექტება, დავაფიქსიროთ დასრულება მანამდე,
გაუშვით `cargo fmt` ლოკალურად, გაუშვით `git add` და შემდეგ გაუშვით `git commit --amend` და `git push -f` არასრული დავალებების გამოსასწორებლად ახლის შექმნის ნაცვლად.
იგივე ეხება უფრო მცირე გამოსწორებებს, როგორიცაა მართლწერის შეცდომებს, რომლებიც თქვენს მიერ არის შემოღებული, შეასწორეთ დაშვება, სადაც დაშვებული იყო შეცდომა, ნაცვლად იმისა, რომ შექმნათ ახალი.
გაითვალისწინეთ, ზოგჯერ `cargo fmt` ფორმატირების წესები შეიცვალა, ამ შემთხვევაში ფორმატირებამ შეიძლება შეცვალოს კოდების ბაზის ნაწილები, რომლებსაც არ შეხებიხართ.
ამ შემთხვევაში, თავისუფლად გააკეთეთ ცალკეული ვალდებულება, რომელიც აფორმებს მთელ კოდბაზს.

**მინიშნება:** როგორც შენიშნეთ, თუ უკვე გადახვედით დისტანციურზე, თქვენ მოგიწევთ აიძულოთ თქვენი შეცვლილი ვალდებულება (ამისთვის ორივე `git push --force-with-lease` ან `git push -f` იმუშავებს.)

* ** რებაზირება კარგი გზაა შეცვალოთ თქვენი ვალდებულებები მოგვიანებით.**

იმ შემთხვევაში, თუ გრძნობთ, რომ რაღაც მომენტში შეაწუხეთ თქვენი კომიტები, შეგიძლიათ შეაჩეროთ ჩანაწერები და შეცვალოთ დავალების სახელები.
1. დათვალეთ რამდენ commit-ს შეიცავს თქვენი ფილიალი, მაგ. `git status`-ში.
2. გაუშვით `git rebase -i HEAD~N`, სადაც `N` არის დავალების რაოდენობა, რომელიც დაითვალეთ 1-ელ საფეხურზე.
3. მიჰყევით რედაქტორში მითითებებს. თქვენ შეგიძლიათ შეცვალოთ საკომისიოს სახელი ხაზში ტექსტის შეცვლით.
მაგალითად, იმისთვის, რომ ჩართოთ #2 და #3 კომიტი ერთ კომიტად, ჩაწერეთ `squash` დავალების #3-ის წინ, არ არის საჭირო შეცვალოთ დავალება #2.
4. აწარმოეთ `fmt` თქვენს ფილიალში (bash-ში) ყოველი შესრულებით
`git filter-branch -f --tree-filter "cargo fmt" $(git merge-base origin/master HEAD)..HEAD`

### სამაგისტრო ფილიალში ცვლილებების დაფიქსირება

ხშირად, როდესაც ფუნქციაზე მუშაობთ ერთ ან ორ დღეზე მეტხანს, შეიძლება შეამჩნიოთ, რომ თქვენი ფილიალი ჩამორჩება მთავარ ფილიალს.
საბედნიეროდ, თქვენ შეგიძლიათ დაეწიოთ ნებისმიერ ცვლილებას, რომელიც თქვენმა ფილიალმა გამოტოვა [მასტერზე ხელახალი ბაზისით](https://www.atlassian.com/git/tutorials/merging-vs-rebasing) შესაბამისად, თქვენ **არასდროს** გააერთიანოთ მასტერი თქვენს ფუნქციურ ფილიალში!

#### როგორ გადავაყენოთ ოსტატის თავზე

1. პირველ რიგში, დარწმუნდით, რომ არ გაქვთ დაუსრულებელი სამუშაო, ე.ი. ახალი ვალდებულების შექმნით.
2. გაუშვით `git fetch --all` ყველა უახლესი ცვლილების მისაღებად.
3. გაუშვით `git rebase origin/master` ხელახალი ბაზაზე დასაწყებად.
შეიძლება შეგხვდეთ ან არ შეგხვდეთ გაერთიანების კონფლიქტები, თუ არა, გადადით შემდეგ ეტაპზე.
თუ ასე მოიქცევით, მოგიწევთ კონფლიქტების მოგვარება. ეს ჩვეულებრივ წარმოიქმნება ბოლო ცვლილებების შედეგად
სამაგისტრო, რომელიც ეწინააღმდეგება საკუთარ ცვლილებებთან და ჯიტში, უნდა გითხრათ, რომელს ანიჭებთ უპირატესობას. მოგერიდებათ
ითხოვეთ დახმარება ჩვენს Discord-თან დაკავშირებით.
4. გაუშვით `git push -f` თქვენი ხელახალი ფუნქციების განშტოების გასააქტიურებლად. ეს უნდა იყოს ძალისმიერი ბიძგი, რადგან თქვენ შეცვალეთ არსებული ჩადენის ისტორია.

**მინიშნება:** გაუშვით `git status` თქვენი ფილიალის ამჟამინდელი მდგომარეობის სანახავად.

## მიიღეთ თქვენი წვლილი თამაშში

თქვენ შექმენით ფუნქციების ფილიალი, გააკეთეთ თქვენი ვალდებულებები, რა არის ახლა?
ახლა ფილიალი სხვა წევრებმა უნდა განიხილონ; ამისათვის თქვენ უნდა შექმნათ შერწყმის მოთხოვნა GitLab-ზე.

### შერწყმის მოთხოვნის (MR) შექმნა GitLab-ზე

1. როგორც კი თქვენი ფუნქცია მზად იქნება განსახილველად, შექმენით [MR GitLab](https://gitlab.com/groups/veloren/dev/-/merge_requests) თქვენი ფილიალიდან `your-nickname/your-branch-name``veloren/veloren/master`-მდე.
2. დარწმუნდით, რომ მონიშნეთ ყუთი *წაშალე წყაროს ფილიალი* MR-ში. იშვიათად არის იმის მიზეზი, რომ ტოტი შეინარჩუნოს მის შერწყმის შემდეგ.
მოგერიდებათ დაამატოთ დამატებითი ინფორმაცია აღწერილობაში.
გარდა იმ შემთხვევისა, როდესაც თქვენი ფილიალის ჩაბარების ისტორია არ შეიცავს სუფთა ვალდებულებებს აღწერითი სათაურებით,
თქვენი MR ჩაიშლება - შეგიძლიათ წინასწარ შეამოწმოთ *squash commits* ჩამრთველი, თუ გსურთ ეს მოხდეს.
3. გაგზავნეთ შეტყობინება ჩვენს Discord-ზე (თუ გაქვთ წვდომა `#programmers`-ზე ან სამუშაო ჯგუფის არხზე, სხვაგვარად `#new-contributors`-ში)
და ახსენეთ `@Code Reviewer` MR-ის ბმულით, ვინმე გადახედავს მას და იმუშავებს თქვენთან ერთად მის გაერთიანებაზე.

## ხელშემწყობი აქტივები

თუ აქამდე არასოდეს გიმუშავიათ git-ით და უბრალოდ გსურთ აქტივების შეტანა,
გამოაქვეყნეთ ისინი `#veloren-art`-ში ჩვენს Discord-ზე და მოითხოვეთ გამოხმაურება. დარწმუნდით, რომ ფლობთ აქტივებზე უფლებებს და ეთანხმებით, რომ ის საჯაროდ ხელმისაწვდომი იყოს [GPLv3](https://choosealicense.com/licenses/gpl-3.0/) ლიცენზიით.
**მინიშნება:** დამატებითი ინფორმაციისთვის ეწვიეთ [მხატვრების განყოფილებას](artists).

## თქვენი პირველი წვლილის შემდეგ

გილოცავთ თქვენს პირველ წვლილს და მადლობას გიხდით დახმარებისთვის!
თქვენი პირველი წვლილის შემდეგ თქვენ უნდა მიიღოთ `Contributor` როლი Discord-ზე, რომელიც გაძლევთ წვდომას მნიშვნელოვან არხებზე.

გუნდში გაწევრიანება

თუ აქამდე გიყვარდათ წვლილის შეტანა და გსურთ შემდგომი დახმარება, განიხილეთ სამუშაო ჯგუფში გაწევრიანება აცნობეთ შესაბამისი გუნდის ლიდერს.

** რჩევა ** _ შეგიძლიათ შეუერთდეთ მრავალ ჯგუფს და თავისუფლად იმუშაოთ ჯგუფების ფოკუსის მიღმა. ძირითადად ეს ეხმარება იმის გასარკვევად, ვის ელაპარაკება ველორენის კონკრეტულ ნაწილზე.

ჯგუფის წევრების პოვნა და დაკავშირება შესაძლებელია მათი შესაბამისი უთანხმოების ჯგუფის როლების მეშვეობით.

აუდიო (ხელმძღვანელობით DaforLynx (@daforlynx))

მუსიკისა და SFX-ის განხილვა, გაზიარება და დამტკიცება, რომელიც წარმოდგენილი იქნება Veloren-ში.

აქტივები და ვიზუალური დიზაინი (ხელმძღვანელობს Gemu (@gemupeachems))

3D მოდელები, 2D პიქსელის ხელოვნება/ხატები, ინტერფეისის დიზაინი, კონცეფციის ხელოვნება.

ბალანსი (ნექტის ხელმძღვანელობით (@nectical))

მექანიკის და გეიმპლეის დაბალანსება

საბრძოლო (ხელმძღვანელობით სემი (@goldfalcon9))

იარაღი, ჯავშანი, საბრძოლო უნარები, მტრები და სხვა საბრძოლო საგნები.

თამაშის დიზაინი (ფორმალური ლიდერობის გარეშე)

მუშაობს იმაზე, თუ როგორ თამაშობს თამაში მოთამაშის მიერ. აყალიბებს მოთამაშის სამყაროსთან ურთიერთქმედების გზას და სისტემას, რომელსაც იყენებს ამისათვის.

მეტა (ხელმძღვანელობით AngelOnFira (@angelonfira))

ხელმძღვანელობს CI-ს, ვებსაიტს, Discord-ს და უამრავ მათ შორის.

რენდერი (ხელმძღვანელობს imbris (@imbris))

გრაფიკა, ფანჯარა და UI ლოგიკა Voxygen-ისთვის.

სერვერი და Multiplayer (ხელმძღვანელობს xMAC94x (@xmac94x))

შექმენით სერვერები, რომლებსაც შეუძლიათ მრავალი ადამიანის მასპინძლობა და გახადონ მრავალმოთამაშიანი გამოცდილება რაც შეიძლება.

ტესტირება (ხელმძღვანელი YuriMomo (@yurimomo))

თამაშის ტესტირება სპეციალიზებული ხელსაწყოების გამოყენებით და დარწმუნდით, რომ ახალი ფუნქციები არ იწვევს რაიმე შეცდომებს.

თარგმანი და ლოკალიზაცია (ხელმძღვანელობს juliancoffee (@juliancoffee_ua))

ჩვენ ვმართავთ Veloren-ის თარგმანებს სხვა ენებზე და ვმუშაობთ შიდა ლოკალიზაციის სისტემების გაუმჯობესებაზე, რათა ადამიანებს შეეძლოთ მეტი, უკეთ და სწრაფად თარგმნა.

UX & UI (ხელმძღვანელობს Pfau (@pf4u))

ჩვენ ვაუმჯობესებთ Veloren-ის მომხმარებლის გამოცდილებას და მომხმარებლის ინტერფეისს ცნობილი UX პრაქტიკის გამოყენებით არსებულ ფუნქციებზე და ვაგროვებთ ინფორმაციას, შეცდომების შესახებ ანგარიშებს მომხმარებლებისგან, რათა განვსაზღვროთ, თუ რომელი ცხოვრების ხარისხის გაუმჯობესებაა ყველაზე მეტად საჭირო.

Worldgen (ხელმძღვანელობით Isse (@isse.rs) და Zesterer (@zesterer))

მსოფლიო თაობა და რელიეფის თაობა.

Worldsim (ხელმძღვანელობით Isse (@isse.rs) და Zesterer (@zesterer))

მსოფლიო სიმულაცია

FAQ

1) როგორ აირჩიე Rust ამ თამაშისთვის? ეს არ არის ყველაზე მომწიფებული ენა თამაშების განვითარებისთვის.

Rust შეიძლება ჩანდეს უჩვეულო არჩევანი მსგავსი პროექტისთვის. ეს არის ახალი ენა, რომელსაც ჯერ კიდევ არ აქვს სათანადოდ დამტკიცება საწარმოო გარემოში და ჯერ კიდევ განიცდის შედარებით სწრაფ ცვლილებებს. ჩვენ ავირჩიეთ Rust, რადგან მას აქვს რამდენიმე უნიკალური მახასიათებელი, რომელიც, ჩვენი აზრით, სარგებელს მოუტანს პროექტს გრძელვადიან პერსპექტივაში.

**ჟანგი უსაფრთხოა ** Vanilla Rust-ში დაწერილი კოდი არ შეიძლება გამოიწვიოს გაურკვეველი ქცევა. Rust-ის დიზაინი გვეხმარება თავიდან ავიცილოთ შეცდომების სიმრავლე, რომლებიც გავრცელებულია სხვა შედგენილ ენებში, როგორიცაა ჩამოკიდებული მაჩვენებლები, ბუფერული გადადინება, არასწორი/ნულის მაჩვენებლები, მონაცემთა რბოლა, მასივის შეკრული შეცდომები და მრავალი სხვა. ეს მას განსაკუთრებით შესაფერისს ხდის ისეთი დიდი ერთობლივი პროექტისთვის, როგორიც ეს არის, რადგან ართულებს ახალი კოდის შეტანას შეცდომების გამოსწორებას კოდების ბაზაში.

**ჟანგი სწრაფია ** Rust არის შედგენილი ენა, რომელიც არ საჭიროებს ნაგვის შემგროვებელს, გამონაკლისს ან ბევრ სხვა გაშვების სისტემას, რაც სხვა ენებს ასე ანელებს. უმეტეს სცენარში, კარგად დაწერილი Rust სულ მცირე ისეთივე სწრაფია (და ხშირად უფრო სწრაფი), ვიდრე კარგად დაწერილი C++.

** ჟანგი მოდულარულია ** Rust-ს მოყვება Cargo build სისტემა და პაკეტის მენეჯერი. ის საშუალებას აძლევს Rust-ის შედგენას მოდულური გზით, ადვილად ისესხებს სხვა ბიბლიოთეკებს (ცნობილია როგორც კრატები) დანარჩენი Rust-ის ეკოსისტემიდან.

**Rust არის პორტატული ** Rust-ის შემდგენელი იყენებს LLVM-ს ძირითადი ტექნიკის პლატფორმების უმრავლესობისთვის. Cargo-ს, როგორც მისი კონსტრუქციის სისტემის გამოყენებით, ის იძლევა თანმიმდევრული შედგენის საშუალებას მრავალ პლატფორმაზე. აღარ არის სათაურის ფაილების ძებნა ან ლინკერის შეცდომებთან ბრძოლა!

** Rust კარგად არის შემუშავებული ** Rust-ის სინტაქსი შექმნილია ისე, რომ იყოს მოსახერხებელი (სადაც შეუძლია ფუნქციებზე კომპრომისის გარეშე) და კარგად მოერგოს სისტემის პროგრამირებას. დაბალი დონის კონტროლისა და უსაფრთხოების უნიკალური კომბინაცია მას შესანიშნავს ხდის როგორც თამაშის ძრავების, ასევე მაღალი დონის თამაშის ლოგიკის შესაქმნელად.

2) რატომ გამოვიყენოთ GitLab GitHub-ზე?

GitLab-ს აქვს უკეთ ინტეგრირებული CI/CD და გთავაზობთ ყველაფერს, რაც GitHub-ს აქვს. ორივე მათგანი მხოლოდ სერვისია git-ის თავზე კომპიუტერზე, ასე რომ, არც თუ ისე განსხვავებული.

3) რა ხმაურის ფუნქციას ვიყენებთ რეალურად?

Perlin, worley, simplex, value, gradient და რამდენიმე Zesterer გამოიგონეს.

4) როგორ შემიძლია დაგეხმაროთ? უნდა ვიყო გუნდის წევრი? რუსთში არ მაქვს გამოცდილება, მაგრამ ძალიან მინდა ვისწავლო და დავეხმარო.

ზოგადად, თქვენ შეგიძლიათ დაეხმაროთ ნებისმიერ სფეროში, რაც გსურთ. თქვენ არ გჭირდებათ გუნდის წევრი გახდეთ. მაგრამ როგორც კი ცოტათი დაეხმარე და აჩვენე, რომ გაინტერესებს, შეგიძლიათ მოხვდეთ შესაბამის “გუნდში”.

5) როგორ ხდება მოძრაობის/ფიზიკის/მექანიკის პროგრამირება?

ეს დანერგილია [common]-ში (developers/codebase-structure.md#common), რომელიც არის კოდის ყუთი, რომელიც საერთოა როგორც სერვერს, ასევე კლიენტს შორის. (რადგან სერვერი უნდა იყოს საბოლოო ავტორიტეტი ფიზიკაზე, მაგრამ კლიენტმა უნდა გააკეთოს ფიზიკის პროგნოზირება, რათა შეფერხება/დაყოვნება ცუდად არ გამოიყურებოდეს).

6) აქვს თუ არა მას ყველა ის OOP მასალა, რომელიც გჭირდებათ მსგავსი პროექტისთვის? არის შემთხვევები, როცა კოდირებთ Rust-ში და არის რაღაც, რაც ფიქრობთ, რომ ბევრად უკეთესად შეიძლება გამოიხატოს C++-ში? მე თავიდან უარვყავი Rust, როდესაც პირველად შევხვდი მას, რადგან ჩანდა, რომ ეს იყო მხოლოდ C განსხვავებული სინტაქსით და პროგრამირების გარკვეული ფუნქციებით, მაგრამ ცოტა ხნის წინ გავიგე, რომ ეს სავარაუდოდ ბევრად მეტია.

მიუხედავად იმისა, რომ Rust-ს აქვს ისეთი თვისებები, რომლებიც, როგორც ჩანს, მას ობიექტზე ორიენტირებულ ენად აქცევს (მას აქვს ობიექტები, მეთოდები, ინტერფეისები და ა.შ.), ის სინამდვილეში არ არის ობიექტზე ორიენტირებული ენა. ახალი დეველოპერების ერთ-ერთი ჩვეულებრივი ატრიბუტი არის ის, რომ ცდილობენ აიძულონ Rust მოიქცეს OO ენაზე, როდესაც კონკრეტული პრობლემა უკეთესად მოგვარდება Rust-y გზით.

7) რა მოქნილობას უზრუნველყოფს Rust, რომელსაც არ აქვს Unreal Engine? ეს უბრალოდ იმიტომ ხდება, რომ Rust პროექტს მოდულურად აქცევს, ხოლო Unreal Engine საკმარისად მოდულარული არ არის ღია კოდის განვითარებისთვის?

Voxel თამაში საკმაოდ სპეციფიკური თამაშია. ის ეხება უამრავ მონაცემს, რომლებთანაც ძრავების უმეტესობა უბრალოდ არ არის შექმნილი. ამასთან ერთად, თამაშის დიდი ნაწილი პროცედურულია, რასაც არსებული აქტივებზე ორიენტირებული ძრავები არც ისე კარგად არიან აღჭურვილი. ჩვენთვის არსებული ძრავა შედარებით მცირე უპირატესობებს მოიტანს, მიუხედავად რამდენიმე საკმაოდ მნიშვნელოვანი მინუსისა.

8) გსურს ოდესმე ეს პროექტი გადაიტანო ფონდების მოზიდვის პლატფორმაზე, როგორიცაა Kickstarter, რათა ვინმემ შეძლოს მასზე მუშაობა სრული დროით? შესაძლებელია, რომ ეს ერთ დღეს მიზნად იქცეს? ან ეს არასოდეს იქნება მიზანი?

ჩვენ ალბათ ამ გზას არ გავალთ, თუმცა, ვფიქრობ, ძნელია რაიმეს დარწმუნებით თქმა. ჩვენ ვხედავთ ამას, როგორც მოხალისეობრივ პროექტს. უფრო სავარაუდოა, რომ ნებისმიერი დაფინანსება, რომელსაც ჩვენ ვაკეთებთ, მიმართული იქნება სერვერების შენარჩუნებაზე და სხვა.

9) გამიჩნდა შეკითხვა, როგორ შევადგინო თამაში?

ყველაფერი უნდა იყოს აღწერილი განყოფილებაში კონტრიბუტორები.

პრობლემების მოგვარება

იმ შემთხვევაში, თუ თქვენ შეექმნათ პრობლემა, ეს სექცია დაგეხმარებათ მის მოგვარებაში.

Git LFS

თუ LFS არ არის დაინსტალირებული და სწორად დაყენებული, lfs მაჩვენებლები არ შეიცვლება ფაქტობრივი აქტივებით. ეს წარმოქმნის შეცდომას Voxygen-ის გაშვებისას, სადაც ის უჩივის ნებისმიერი ფაილის ნამდვილობას, რომლის ჩატვირთვას ცდილობს.

შეამოწმეთ სტატუსი

იმის შესამოწმებლად, მუშაობს თუ არა Git LFS სწორად:

git lfs status

როდესაც LFS არ იყო დაყენებული რეპოს კლონირებამდე

Windows და Linux

LFS-ის დასაყენებლად და აქტივების ფაილების ჩამოსატვირთად Linux ან Windows-ზე

git lfs install
git lfs fetch
git lfs checkout

macOS

git-lfs install
git-lfs fetch
git-lfs checkout

Git pull/rebase ვერ მოხერხდა დაბინძურების შეცდომის გამო/404

ეს არის ცნობილი შეცდომა თავად git-lfs-ით და აქვს კარგი გამოსავალი. იხილეთ ეს სექცია აქ.

Mingw64 (Windows) გამოყენებისას

Git LFS ვერ ჩამოტვირთავს ფაილებს სწორად. მთავარი პრობლემა, როგორც ჩანს, არის ის, რომ askpass პროგრამა არ ჩნდება ნორმალური CMD მოთხოვნის გამოყენებისას, რაც ხელს უშლის Git LFS-ს ავთენტიფიკაციას SSH-ით დროებითი წვდომის ჟეტონის მისაღებად. SSH_ASKPASS, GIT_ASKPASS და DISPLAY ცვლადების დაყენება, როგორც ჩანს, გადაჭრის ამ პრობლემას:

SET "SSH_ASKPASS=C:\Program Files\Git\mingw64\libexec\git-core\git-gui--askpass"
SET "GIT_ASKPASS=%SSH_ASKPASS%"
SET "DISPLAY=required"

მიგრაცია ქვემოდულებიდან

თუ იყენებდით წინა ქვემოდულების სისტემას, შეგიძლიათ გამორთოთ ის შემდეგი გზით:

git submodule deinit --force --all

ავტომატური ფორმატი git commit hook-ით

თქვენ შეგიძლიათ დააყენოთ git commit hook, რომ ავტომატურად დააფორმატოთ თქვენი კოდი ჩადენამდე, თუ თქვენი IDE არ უჭერს მხარს მას ნაგულისხმევად. უბრალოდ შექმენით ფაილი .git/hooks/pre-commit შემდეგი შინაარსით.

#!/bin/sh
#
# An example hook script to verify what is about to be committed.
# Called by "git commit" with no arguments.  The hook should
# exit with non-zero status after issuing an appropriate message if
# it wants to stop the commit.
#
# To enable this hook, rename this file to "pre-commit".

# run rustfmt to auto check changed files
changefmt=$(git config --bool hooks.changefmt)

rustup component add rustfmt-preview
if [ "$changefmt" != "true" ]
then
  exec cargo fmt --all -- --check
else
  echo "change files via fmt"
  cargo fmt --all --
  echo "adding all files via git add ."
  exec git add .
fi

# enable change to make fmt change files instead of just warn
# git config hooks.changefmt true

დამოკიდებულებები

დარწმუნდით, რომ დაინსტალირებული გაქვთ ყველა runtime dependencies.

თვალთვალის საკითხები

ძალიან დიდი, რთული ან გრძელვადიანი ფუნქციებისთვის ჩვენ ვინარჩუნებთ „თვალთვალის საკითხებს“: დიდი საკითხები, რომლებიც აჯამებს ინფორმაციას მახასიათებლისა და მისი განვითარების პროგრესის შესახებ. დიდი ფუნქციების დანერგვა ხშირად ნიშნავს მრავალი პატარას განხორციელებას, ამიტომ მნიშვნელოვანია თვალყური ადევნოთ მათ, რათა თავიდან აიცილოთ დაბნეულობა და საზოგადოება განახლებული იყოთ.

გაითვალისწინეთ, რომ თვალთვალის რამდენიმე საკითხი შესაძლოა მოძველებული იყოს ან არ ჰქონდეს საზოგადოების კონსენსუსი: გადახედეთ საგზაო რუკა თუ ეძებთ დაგეგმილი ფუნქციების ჩამონათვალს ფართო შეთანხმებით საზოგადოება!

აქ მოცემულია ამჟამად არსებული თვალთვალის საკითხების სია. მოგერიდებათ შეიტანეთ წვლილი ამ განყოფილებაში თუ ფიქრობთ, რომ რაღაც აკლია!

მახასიათებლები

• 🌦 ამინდი
• 🛠 მოთამაშეზე ორიენტირებული შენობა
• 📰 სერვერის ბრაუზერი
• 📜 თარგმანები
• 🎲 ბალანსი და იარუსები
• 💸 ეკონომიკის გადამუშავება
• 🗣 ჩატი
• 🏗 აშენების რეჟიმი
• ⛰ Worldgen
• 🐉 ქვესტი
• 💥 Hitboxes
• 🏹 დამიზნება (დარტყმის იარაღი)
• 🗡 საბრძოლო ტექსტის გადახვევა (SCT)
• 💹 ვაჭრობის გაუმჯობესება
• 🐢 არსების ვარიანტები
• 🥷 სტელსი
• 🧩 დანამატები
• 🪴 Sprites და ნივთების მოდელები
• 📡 აურა
• 🙊 NPC ხმის ეფექტები
• 🔊 ხმოვანი ეფექტები
• 🐶 შინაური ცხოველები
• 🗡 საბრძოლო
• 🧠 NPC/enemi AI
• ✋ სერვერის მხრიდან მოტყუების საწინააღმდეგო
• 📑 GDPR და კონფიდენციალურობა

პლატფორმის მხარდაჭერა

• 🎮 Steam Deck
• 🖌 გრაფიკული შეცდომები

ინტერიერი

• 📋 ერთეულის მუშაობის გაუმჯობესება
• 📋 ქსელი და სინქრონიზაცია
• 📋 გზის ძებნა

დეველოპერები შეცდომების გარეშე ცა

_ რუსტის განვითარების ძალის გაცნობა.

• IDE-ის ინსტალაცია
• სასწავლო ჟანგი
• ECS
• კოდების ბაზის სტრუქტურა
• კოორდინატთა სისტემები
• გამართვა
• ეფექტურობის ანალიზი

IDE-ის ინსტალაცია

სანამ Rust კოდის კომფორტულად შეცვლას შეძლებთ, თქვენ უნდა დააინსტალიროთ IDE.

მინიშნება: შეამოწმეთ rust tools გვერდი, რათა იპოვოთ საერთო IDE-ები, რომლებიც მხარს უჭერენ Rust-ს და ინსტალაციას შესაბამისი დანამატები.

სასწავლო ჟანგი

Rust-ის შესახებ ბევრი რესურსი არსებობს.

საფუძვლებისთვის გირჩევთ გადახედოთ წიგნს და კულინარიული წიგნი.

ამის შემდეგ შეგიძლიათ დაიწყოთ [კოდების ბაზის] გაცნობა (codebase-structure.md).

ECS

Veloren იყენებს Entity Component System (ECS). ეს არის შედარებით ახალი პარადიგმა თამაშის ძრავის განვითარებაში კონკურენციას უწევს ტრადიციულ ობიექტზე ორიენტირებულ დიზაინის მოდელებს, რომლებიც ინტენსიურად იყენებენ იერარქიას, მემკვიდრეობას და პოლიმორფიზმი. ის მოუწოდებს თამაშის დეველოპერებს შეიმუშაონ მონაცემთა სტრუქტურები ისე, რომ შესაძლებელი იყოს ეფექტური პარტია მონაცემთა დამუშავება თანამედროვე პროცესორის არქიტექტურებზე ღრმა ქეშით, მეხსიერებაში შენახული მონაცემების შენახვით.

ტრადიციულად, თამაშში ერთეულების წარმოდგენა ასე ხდება:

#![allow(unused)]
fn main() {
struct Entity {
    position: Vec3<f32>,
    velocity: Vec3<f32>,
}
}

მრავალი ერთეულის წარმოდგენისას, ჩვეულებრივია მონაცემთა მასივის მსგავსი სტრუქტურის გამოყენება.

#![allow(unused)]
fn main() {
struct World {
    entities: Vec<Entity>,
}
}

თუმცა, ამას პრობლემები მოჰყვება. თანამედროვე პროცესორებს აქვთ ღრმა ქეში, რაც იმას ნიშნავს, რომ ისინი მნიშვნელოვნად უფრო სწრაფად წვდებიან მეხსიერება, რომელიც მისამართთა სივრცეში უფრო ახლოს არის მეხსიერებასთან, რომელიც უკვე მიუწვდომელია. შენახვის ყველაზე ეფექტური ფორმატების პაკეტი მონაცემთა დამუშავება მეხსიერებაში ძალიან ახლოს. ჩვენი ამჟამინდელი წარმომადგენლობა ასე გამოიყურება:

| Entity 0            | Entity 1            | Entity 2            |
|---------------------|---------------------|---------------------|
| position | velocity | position | velocity | position | velocity |

წარმოვიდგინოთ „ტიპიური“ ოპერაცია, რომლის შესრულებაც გვსურს: გრავიტაციის გამოყენება ერთეულებზე. ეს გულისხმობს დამატებას 9.81 ვერტიკალური სიჩქარით თითოეული ერთეულისთვის. სამწუხაროდ, ამ ოპერაციის წვდომის ნიმუში მოიცავს თითოეულ velocity ველზე შეხება, მაგრამ თითოეული position ველის გამოტოვება. ჩვენს მონაცემებში არსებული ეს ხარვეზები ანელებს ოპერაციას. In ტექნიკური ჟარგონი, ჩვენ ამას ვუწოდებთ “ქეში თანმიმდევრულობის” ნაკლებობას.

ყველაფერი არ არის დაკარგული.

დიზაინის ნიმუში, რომლის შესახებაც შეიძლება გსმენიათ, ეწოდება Struct Of Arrays, ან SOA. ის ვარაუდობს, რომ შეფუთვის ნაცვლად თითოეულ ობიექტთან დაკავშირებული მონაცემები ერთ ადგილზე ერთად, ჩვენ უნდა დავაჯგუფოთ მონაცემები მისი მიზნის მიხედვით.

#![allow(unused)]
fn main() {
struct World {
    positions: Vec<Vec3<f32>>,
    velocities: Vec<Vec3<f32>>,
}
}

ახლა ჩვენი წარმოდგენა ბევრად უფრო მჭიდროდ არის შეფუთული და ჩვენი გრავიტაციის გამოყენება ერთეულებზე უფრო ეფექტურია, რადგან ჩვენ აღარ გვჭირდება პოზიციის მონაცემების გამოტოვება ერთეულის სიჩქარის გამეორებისას.

| Entity 0 | Entity 1 | Entity 2 |     | Entity 0 | Entity 1 | Entity 2 |
|----------|----------|----------| ... |----------|----------|----------|
| position | position | position |     | velocity | velocity | velocity |

ECS არის ეს იდეა მის ლოგიკურ დასკვნამდე: ერთეულები, როგორც კომპონენტების ასოცირებული, მაგრამ ცალკეული კოლექციები თითოეული ტიპის კომპონენტი ინახება თავის ცალკეულ შესანახ ბუფერში. ამ მიდგომას აქვს მეტი უპირატესობაც: იმიტომ კომპონენტები ინახება ცალ-ცალკე, მარტივი და სწრაფია კომპონენტების დამატება ან ამოღება ერთეულიდან თამაშის გაშვებისას, რითაც ცვლის სუბიექტის ქცევას და მის შესაძლებლობებს. ეს საოცრად ძლიერი ტექნიკაა და საშუალებას იძლევა რამხელა უნარი რადიკალურად შეცვალოს თამაშის ქცევა და მასში შემავალი ერთეულები თამაშის დროს გაშვებული და შესრულების შეწირვის გარეშე.

სპეციფიკური ECS ყუთი, რომელსაც Veloren იყენებს არის SPECS. შეგიძლიათ მეტი წაიკითხოთ ECS და სპეციფიკა, თუ როგორ მუშაობს SPECS აქ. თუ თქვენ ეძებთ მუშაობას ძალიან, მე დაჟინებით გირჩევთ წაიკითხოთ ეს რესურსი თავიდან ბოლომდე (ეს საკმაოდ მოკლეა).

საპროექტო არქიტექტურა

როდესაც ჩვენ დავიწყეთ Veloren-ის განვითარება, რამდენიმე მიზნის გათვალისწინებით დავიწყეთ.

• მოდულურობა: პროექტი უნდა შედგებოდეს მრავალი ურთიერთდაკავშირებული ნაწილისგან
• შესრულება: პროექტმა თავიდან უნდა აიცილოს არქიტექტურული არჩევანი, რომელიც ზღუდავს შესრულებას
• ჩაკეტვის თავიდან აცილება: პროექტმა თავიდან უნდა აიცილოს გარკვეული კომპონენტების იძულებითი გამოყენება, სადაც ეს შესაძლებელია

ყუთები

Veloren იყოფა რამდენიმე Rust crates. ამის მიზანი ორმხრივია.

1. შევამციროთ შედგენის დრო კოლოფების პარალელური დამუშავების დაშვებით შედგენის დროს

2. მიეცით საშუალება Veloren-ის ეკოსისტემის მომხმარებლებს დამოკიდებულნი იყვნენ მხოლოდ პროექტის კონკრეტულ ნაწილებზე

ფრონტენტები

თუ თქვენ რაიმე დრო გაატარეთ თამაშებში აქტიური მოდიფიკაციის სცენით, უეჭველად შეგხვედრიათ თამაშები, რომლებსაც ჰქონდათ მათთვის დაწერილი სრულიად ახალი გრაფიკული ფრონტენტები, რომლებიც საშუალებას გაძლევთ ითამაშოთ თამაში სხვადასხვა გრაფიკის ან ამ ხედის გამოყენებით საინტერესო თამაშის მონაცემები, რომლებსაც ნაგულისხმევი თამაში ჩვეულებრივ არ აჩვენებს, როგორიცაა Legends Viewer of Dwarf Fortress. ესენი ფრონტენტები ხშირად აგებულია ჰაკიურად, საჭიროებს მეხსიერების პირდაპირ წვდომას თამაშის RAM-ზე, არ გააჩნია მნიშვნელოვანი ფუნქციები, ან მოითხოვეთ, რომ ძირითადი თამაში პარალელურად მიმდინარეობდეს.

ველორენი წყვეტს ამ მიდგომას და ამის ნაცვლად ფრონტენტებს პირველი კლასის აბსტრაქციად აქცევს. voxygen, ნაგულისხმევი გრაფიკა კლიენტის წინა ნაწილი, არ აქვს თანდაყოლილი დაწყვილება შიდა client ბიბლიოთეკასთან. სრულიად ახლის დაწერა შესაძლებელია ფრონტენტები, რომლებიც თამაშის შიგთავსს სრულიად განსხვავებულად აჩვენებენ ზოგადი client ბიბლიოთეკის თავზე. მაგალითები ასეთი ალტერნატიული ფრონტენტები მოიცავს:

• Teloren, ბრძანების ხაზის წინა ნაწილი ნეტჰაკის სტილის გრაფიკით
• chat-cli, მხოლოდ ჩეთის ბრძანების ხაზის წინა ნაწილი

(რამე აკლია ამ სიას? თავისუფლად დაამატეთ)

voxygen

წაიკითხეთ ამ ყუთის დოკუმენტები

Voxygen არის ნაგულისხმევი კლიენტის წინა ნაწილი Veloren-ისთვის და არის პროგრამა, რომელთანაც მომხმარებლები ყველაზე ხშირად ურთიერთობენ. ეს არის ა სრულად მოვლილი და აღჭურვილია ველორენის სამყაროს სრულად 3D ხედით და იყენებს თამაშის კლიენტის ყველა მახასიათებელს.

server-cli

წაიკითხეთ ამ ყუთის დოკუმენტები

server-cli არის ნაგულისხმევი სერვერის წინა ნაწილი Veloren-ისთვის. ის საშუალებას გაძლევთ გაუშვათ Veloren სერვერები მარტივი ბრძანების ხაზის საშუალებით ინტერფეისი, რომელიც მოიცავს როგორც “ძირითად” რეჟიმს (ნაკადის გამომავალი stdout/stderr) და უფრო რთულ რეჟიმს, რომელიც საშუალებას იძლევა სერვერის ბრძანებების შეყვანა მარტივი ncurses სტილის ტერმინალის ინტერფეისის საშუალებით.

ბექენდები

როგორც აღვნიშნეთ, Veloren ახორციელებს ძირითადი გეიმპლეის ფუნქციონირებას უთავო დეველოპერების წინაშე მდგარი ბიბლიოთეკების მეშვეობით. ესენია:

server

წაიკითხეთ ამ ყუთის დოკუმენტები

Veloren-ის ძირითადი სერვერის განხორციელება, ყველა ზარითა და სასტვენით. იგი მოიცავს API-ებს სერვერის ფრონტენტებისთვის მოითხოვეთ თამაშის მდგომარეობა, ჩაატარეთ მოვლენები (როგორიცაა სერვერის მაუწყებლობა) და ჩატვირთეთ დანამატები. მომავალში ჩვენ წარმოვიდგენთ სიმრავლეს სერვერის ფრონტენტები, რომლებიც აკმაყოფილებენ ბევრ მოთხოვნას: მარტივი გრაფიკული ფრონტენტები მოთამაშეებისთვის, რომლებსაც სურთ LAN თამაშის მასპინძლობა მეგობრებთან ერთად, ან მძლავრი CLI სერვერის წინა ნაწილი, რომელსაც მხარს უჭერს ვებ პანელი, რომელიც თამაშზე ზუსტი კონტროლის საშუალებას იძლევა სახელმწიფო და მოწინავე ფუნქციები, როგორიცაა ცოცხალი რუქები ან ცივილიზაციის სტატისტიკა, რომელიც ჩანს ინტერნეტში.

client

წაიკითხეთ ამ ყუთის დოკუმენტები

Veloren-ის ძირითადი კლიენტის განხორციელება. ეს არ არის განსაზღვრული იმის შესახებ, თუ როგორ აჩვენებს კლიენტის წინა ნაწილი მონაცემებს და აძლევს საშუალებას კლიენტებს სერვერებთან დაკავშირება მრავალი „რეჟიმიდან“ ერთ-ერთი, მათ შორის მხოლოდ ჩატის, მაყურებლისა და პერსონაჟის საშუალებით. ნაგულისხმევი კლიენტის ფრონტენტი, Voxygen, არის 3D, მაგრამ არ არსებობს მიზეზი იმისა, თუ რატომ ვერ ახერხებენ სხვა კლიენტების ფრონტენდებს ჩვენების დანერგვა სამყარო იზომეტრიული გრაფიკის, ჯუჯა ციხესიმაგრის სტილის ფენიანი 2D გრაფიკის ან ნებისმიერი სხვა გამოსახულების გამოყენებით. წარმოიდგინე.

world

წაიკითხეთ ამ ყუთის დოკუმენტები

Veloren-ის ძირითადი მსოფლიო თაობის განხორციელება. ამ კრატის გამოყენება მსოფლიოში ცოტა უფრო ბუნდოვანია გენერაცია და სიმულაცია აქტიური განვითარების პროცესშია, მაგრამ ეს კრატი გამიზნულია ნახვის, გენერირების და Veloren სამყაროს სიმულაცია კლიენტის ან სერვერის გარეშე. მომავალში ჩვენ წარმოვიდგენთ ფრონტენტებს არსებული, რომელიც საშუალებას გაძლევთ ნახოთ მსოფლიო ისტორიის ისეთი ასპექტები, როგორიცაა Dwarf Fortress’ Legends Viewer, ან მსოფლიო მონაცემების რედაქტირება დაუშვით საბაჟო სამყაროები და სცენარები.

კომუნალური ყუთები

ეკოსისტემაში ბევრი სხვა ყუთი არის სასარგებლო ყუთები, რომლებიც შეიცავს მრავალი სხვა უჯრის საერთო ფუნქციებს. ესენი არიან არ არის განკუთვნილი მოხმარებისთვის, გარდა ძირითადი Veloren ბიბლიოთეკისა და უნდა განიხილებოდეს, როგორც განხორციელება დეტალი. ესენია:

common (და მისი ქვე-კრატები)

წაიკითხეთ ამ ყუთის დოკუმენტები

ახორციელებს ქცევას და შეიცავს განმარტებებს, რომლებიც საერთოა როგორც კლიენტისთვის, ასევე სერვერისთვის.

network

წაიკითხეთ ამ ყუთის დოკუმენტები

შეიცავს Veloren-ის ქსელის კომუნალური საშუალებების დაუმუშავებელ განხორციელებას.

დანამატები

Veloren-მა ახლახან მოიპოვა მოდულის API, რომელიც საშუალებას გაძლევთ განავითაროთ დამატებითი ფუნქციები ბირთვის თავზე ველორენის გამოცდილება. მიუხედავად იმისა, რომ მოდულის API ჯერ კიდევ უკიდურესად ექსპერიმენტულია, ჩვენ ვგეგმავთ, რომ ის მალე გახდება სტანდარტული გზა თამაშის ფუნქციების გაფართოებისთვის. დანამატები იწერება ნებისმიერ ენაზე, რომელიც შეიძლება შედგეს ვებ ასამბლეაში (WASM), თუმცა Rust ჯერჯერობით ერთადერთი ენაა, რომელსაც აქვს ოფიციალური მხარდაჭერა და სავალდებულო. დანამატები სრულად არის შეფუთული და მათი გაზიარება ხდება კლიენტები სერვერთან დაკავშირებისას. დანამატებს შეიძლება ჰქონდეთ სერვერის და კლიენტის მხარის ქცევა იმავეში პაკეტი.

არსებობს რამდენიმე კრატი, რომელიც დაკავშირებულია დანამატებთან:

plugin-rt

წაიკითხეთ ამ ყუთის დოკუმენტები

ძირითადი მოდულის გაშვების დრო. ეს კრატი აადვილებს კომუნიკაციას მასპინძელ ძრავასთან და მართავს დანამატების კაკვებს და IO-ს.

plugin-api

წაიკითხეთ ამ ყუთის დოკუმენტები

შეიცავს ტიპის განმარტებებს, რომლებიც ქმნიან მოდულის ინტერფეისს, რომელიც გამოიყენება Veloren-თან კომუნიკაციისთვის. ეს მოიცავს ტიპებს და სტრუქტურები, რომლებიც გამოიყენება თამაშში არსებული მდგომარეობის წარმოსაჩენად და ამ მდგომარეობის ცვლილებების შესახებ კომუნიკაციისთვის.

plugin-derive

წაიკითხეთ ამ ყუთის დოკუმენტები

შეიცავს სასარგებლო პროცედურულ მაკროებს დანამატის დასაყენებლად, ავტომატიზირებს ზოგიერთი უფრო რთული API-ს მიერ მოწოდებული plugin-rt.

კოორდინატთა სისტემები

სხვადასხვა კოორდინატთა სისტემა გამოიყენება სხვადასხვა ამოცანებისთვის კოდების ბაზაში, ასე რომ ეს შეიძლება იყოს სასარგებლო ჰქონდეთ მინიშნება იმის შესახებ, თუ როგორ მუშაობენ და როგორ უკავშირდებიან ერთმანეთს.

არ არის აუცილებელი ამომწურავი სია:

• “მსოფლიო” კოორდინატები
• ცალი კოორდინატები
• ამინდის SIM უჯრედის კოორდინატები
• “რეგიონები”, რომლებიც გამოიყენება სერვერზე კლიენტებთან სინქრონიზაციისთვის
• ვოქსიგენში გამოყვანის დროს გამოყენებული სივრცეების კოორდინაცია
• LoD ზონები (იხ. common/src/lod.rs)

შენიშვნა: ეს დოკუმენტი დაუმთავრებელია და უფრო მეტის დეტალები შეიძლება იყოს ჩართული.

მსოფლიო კოორდინატები

მსოფლიო კოორდინატები რეალურად შეიძლება დაიყოს ორ განსხვავებულ ტიპად.

ამჟამად არის არამთლიანი პოზიციები წარმოდგენილი Vec3<f32>-ის საშუალებით, მაგ. რომლის გამოყენებაც შეიძლება წარმოადგენს ერთეულის პოზიციას.

შემდეგ არის მთელი პოზიციები, რომლებიც ამჟამად წარმოდგენილია Vec3<i32>-ის საშუალებით, მაგ. რომლის გამოყენებაც შესაძლებელია ვოქსელის პოზიციისთვის მსოფლიოში. ვოქსელის კოორდინატები, რომელიც შეიცავს Vec3<f32> წერტილის მიღება შესაძლებელია .floor() as i32-ის საშუალებით Vec3-ის თითოეულ ელემენტზე. შესაბამისად, როდესაც ვოქსელის მთელი პოზიცია პირდაპირ გარდაიქმნება Vec3<f32>-ად, ეს მდებარეობს მინიმუმზე ამ ვოქსელის კუთხე. ამ სივრცეში ვოქსელის ცენტრის მისაღებად თითოეულს უნდა დაემატოს 0.5 პოზიციის ელემენტი.

გამართვა

ეს განყოფილება მოიცავს რამდენიმე სასარგებლო რჩევას გამართვის შესახებ Veloren პროექტის ფარგლებში. ეს დაგეხმარებათ, თუ გსურთ შეისწავლოთ კოდის ბაზა გაშვების დროს, ან იმუშაოთ ფუნქციის განხორციელებაზე.

შედგენა გამართვის სიმბოლოებით

იმისათვის, რომ გამართვის სიმბოლოები შეიქმნას პროექტისთვის, უნდა იყოს გამოყენებული debuginfo პროფილი. თქვენ შეგიძლიათ ააწყოთ პროექტი გამართვის სიმბოლოებით ამ ბრძანების გაშვებით:

cargo build --profile debuginfo

Visual Studio კოდი

მიჰყევით ამ სახელმძღვანელოს თქვენი VS Code ინსტალაციის დასაყენებლად.

ამის შემდეგ გააკეთეთ შემდეგი ცვლილებები launch.json-ში (გახსოვდეთ აშენება ზემოთ ჩამოთვლილი cargo ბრძანებით!)

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "(Windows) Launch",
      "type": "cppvsdbg",
      "request": "launch",
      "program": "${workspaceRoot}\\target\\debuginfo\\veloren-voxygen.exe",
      "args": [],
      "stopAtEntry": false,
      "cwd": "${workspaceRoot}",
      "environment": [],
      "externalConsole": true
    },
    {
      "name": "(OSX) Launch",
      "type": "lldb",
      "request": "launch",
      "program": "${workspaceRoot}/target/debuginfo/veloren-voxygen",
      "args": [],
      "cwd": "${workspaceRoot}"
    }
  ]
}

JetBrains ინტეგრირებული განვითარების გარემო

გთხოვთ, გაითვალისწინოთ, რომ JetBrains IDE-ებზე გამართვა მხარდაჭერილია მხოლოდ მათი პროდუქტების მცირე ქვეჯგუფზე (როგორიცაა CLion ან IntelliJ Idea Ultimate). ეწვიეთ ამ ბმულს დამატებითი ინფორმაციისთვის.

დააინსტალირეთ This plugin თქვენს IDE-ში (ან File -> Settings -> Plugins [Ctrl + Alt + x], ან თქვენი ბრაუზერის მეშვეობით) და გახსენით თქვენი rust პროექტი IDE-ში.

დააჭირეთ ღილაკს “დაამატე კონფიგურაცია …” ზედა მარჯვენა კუთხეში. ეს გაიხსნება ფანჯარა, რომელიც გაძლევთ შესაძლებლობას შექმნათ გაშვების / გამართვის პროფილები.

დააჭირეთ პატარა ღილაკს “+” და აირჩიეთ “ტვირთი” ჩამოსაშლელ სიაში. ეს შეგიქმნით გაშვების პროფილს.

შეცვალეთ “სახელი” ველი, როგორც გსურთ. შემდეგ აქ არის საინტერესო ნაწილი: “ბრძანების” ველის რედაქტირება

ნაგულისხმევად, “Command” ველს უნდა ჰქონდეს “Run” მასში, შეინახოს იგი და დაამატოთ “–bin {bin} –profile debuginfo”, სადაც bin არის ორობითი სისტემის სახელი, რომელიც უნდა გამართოს (veloren-server-cli, veloren-voxygen, …).

შემდეგ ველი “ბრძანება” უნდა შეიცავდეს რაღაცის მსგავსს “run –bin veloren-server-cli –profile=debuginfo”.

თუ თქვენ გაქვთ რაიმე შეკითხვა, გთხოვთ დამიკავშირდეთ (infrandomness#4003) Veloren Discord სერვერზე.

პრობლემების მოგვარება

შენიშვნა: ზოგიერთმა მომხმარებელმა განაცხადა, რომ საჭიროა VSCode-ის გაშვება ადმინისტრატორად, რათა გამართვა სწორად იმუშაოს. თუ შეამჩნევთ შეცდომის მსგავს შეტყობინებას ქვემოთ, სცადეთ ხელახლა გაუშვათ VSCode როგორც ადმინისტრატორი.

Unable to open 'panicking.rs': Unable to read file (Error: File not found
(c:\rustc\7dbfb0a8ca4ab74ee3111e57a024f9e6257ce37c\src\libstd\panicking.rs)).

შესრულების ანალიზი

გსურთ გააუმჯობესოთ ველორენის შესრულება? მაგრამ თქვენ არ იცით როგორ შეაფასოთ ველორენის შესრულება? ეს გვერდი არის ინსტრუმენტების კოლექცია, რომლებიც უკვე ინტეგრირებულია veloren-ში და შეიძლება გამოყენებულ იქნას მონაცემების შეგროვებაში.

შედგენა გამოშვების და გამართვის სიმბოლოებით

ინსტრუმენტების უმეტესობა უკეთ მუშაობს გამართვის სიმბოლოებთან და გამოშვების რეჟიმში: თქვენ შეგიძლიათ ააწყოთ პროექტი გამართვის სიმბოლოებით ამ ბრძანების გაშვებით:

cargo build --profile releasedebuginfo

ინტეგრირებული ხელსაწყოები

პრომეთე

Prometheus გაძლევთ საშუალებას შეაგროვოთ ველორენის შიდა ნაწილები მუშაობის დროს. მონაცემთა ქულები აგრეგირებულია (მაგ. ყველა ერთეული, ფიზიკის სისტემაში გატარებული დრო). ეს საშუალებას გაძლევთ სწრაფად, უხეში შეხედოთ ველორენის შესრულებას, მაგრამ არ არის ძალიან დეტალური.

პრომეთეს სტატიკა ექსპორტირებულია ნაგულისხმევად, როდესაც თქვენ გაუშვით veloren-server-cli გახსენით თქვენი ვებ ბრაუზერი http://localhost:14005/metrics, რათა ნახოთ ნედლეული მნიშვნელობები.

თქვენ შეგიძლიათ ამ მონაცემების იმპორტი Prometheus-ში ამ სახელმძღვანელოს მეშვეობით: https://prometheus.io/docs/prometheus/latest/getting_started/ დაამატეთ localhost:14005/metrics თქვენს /etc/prometheus/prometheus.yml-ს. დაუკავშირდით http://localhost:9090-ს და შეიყვანეთ tick_time, შეასრულეთ და გადადით Graph რეჟიმში.

შეგიძლიათ დააკავშიროთ თქვენი Prometheus სერვისი Grafana-ს ინსტანციას: https://prometheus.io/docs/visualization/grafana/ თქვენ იპოვით დაფების მაგალითებს veloren ინფრასტრუქტურის რეპოში (ჯერ არ არის ხელმისაწვდომი): https://gitlab.com/veloren/infrastructure/-/blob/master/veloren-infra/templates/grafana-dashboads-gameserver.yaml

ტრეისი

Tracy საშუალებას გაძლევთ თვალყური ადევნოთ გარკვეულ პერიოდებში გატარებულ დროს კოდში ჩასმული ინსტრუმენტზე. ეს საშუალებას გაძლევთ მიიღოთ დეტალური დონე გარკვეულ ბლოკებში კოდი, როდის შესრულდება და რამდენი დრო სჭირდება.

ტრეისის აქვს ვრცელი სახელმძღვანელო ხელმისაწვდომი https://github.com/wolfpld/tracy/releases/latest/download/tracy.pdf.

ჩართეთ ტრეისის მხარდაჭერა ფუნქციით tracy ერთ-ერთ ბინარულ ყუთზე:

cargo run --bin veloren-voxygen --no-default-features --features tracy,simd,egui-ui,shaderc-from-source --profile no_overflow"

ჩვენ გვაქვს ამის მეტსახელი განსაზღვრული .cargo/config-ში, ასე რომ, შემდეგი სტენოგრამის გამოყენება შეიძლება, თუ თქვენ არ არის საჭირო პროფილის მორგება ან რა ფუნქციებია ჩართული:

cargo tracy-voxygen

ანალოგიურად, ჩვენ გვაქვს მეტსახელი სერვერის გასაშვებად ჩართული ტრეისის ფუნქციით:

cargo tracy-server

დაუკავშირდით გაშვებულ პროცესს თქვენი ტრეისის ხელსაწყოს მეშვეობით: https://github.com/wolfpld/tracy/releases

** შენიშვნა: ** ტრეისის საჭირო ვერსია დამოკიდებულია tracy_client-ის მიმდინარე ვერსიაზე კოლოფს იყენებს ველორენი. ეს შეგიძლიათ იხილოთ Cargo.lock ფაილში რეპოს ძირში და შემოწმებულია ამ ცხრილის მიხედვით https://github.com/nagisa/rust_tracy_client#version-support-table

‘ტვირთის აგება -Z დროები’

როდესაც გსურთ კომპილაციის დროის ანალიზი, შეგიძლიათ გამოიყენოთ ტვირთის ფუნქცია -Z timings. გამოვა ა .html ფაილი ინდივიდუალური კომპილაციის დროებით, დამოკიდებულებებით და მთლიანი გრაფიკით, რომელიც აჩვენებს არააქტიურს, აქტიური და უმოქმედო პროექტები.

გარე ხელსაწყოები

ჟანგი: ფლამეგრაფი

მიჰყევით ინსტალაციის ინსტრუქციას აქ: https://github.com/flamegraph-rs/flamegraph შეასრულეთ იგი cargo flamegraph ან უბრალოდ flamegraph-ის საშუალებით და მიაწოდეთ მდებარეობა შესრულებადს. როგორც კი დახურავთ, შეიქმნება flamegraph.svg ფაილი, შეგიძლიათ გახსნათ თქვენი ბრაუზერით

Visual Studio 2019 Community Edition (მხოლოდ Windows)

ვიზუალურ სტუდიას აქვს ჩაშენებული პროფილერი, მიჰყევით ამ სახელმძღვანელოს და მიამაგრეთ იგი გაშვებულ ველორენ პროგრამას: https://docs.microsoft.com/de-de/visualstudio/profiling/cpu-usage?view=vs-2019

valgrind/cachegrind

თქვენ შეგიძლიათ გამოიყენოთ valgrind/cachegrind profiler გამომავალი ფაილის გენერირებისთვის და მოგვიანებით გაანალიზოთ valgrind-ის საშუალებით. სახელმძღვანელო: https://www.valgrind.org/docs/manual/cg-manual.html

მხატვრების შემოქმედებითი სამოთხე

_ შესავალი ველორენში მხატვრული შინაარსის დამატების ხელოვნებაში.

• Voxel Models
• აუდიო
• გრაფიკა

„გამარჯობა“ ერთ-ერთ არტ-არხზე

ეს არის საუკეთესო გზა Discord-ზე ჩვენს არტ-გუნდთან დასაკავშირებლად. გარდა ამისა, თქვენ უკვე გაქვთ წარმოდგენა იმის შესახებ, თუ როგორ ვმუშაობთ ერთად, როგორც გუნდი და შესაძლოა გაიცნოთ ზოგიერთი ჩვენგანი.

მხატვრები აჩვენებენ თავიანთ შემოქმედებას ამ არხებზე, რათა მიიღონ გამოხმაურება ან “OK” Core-Devs-ისგან, რომ მათი მოდელი მზად არის ანიმაციისთვის და თამაშში მოთავსებისთვის.

ატრიბუცია და ლიცენზირება

აქტივებს, რომლებიც არის (ან ადაპტირებულია) ლიცენზირებული საავტორო უფლებებით დაცული მასალისგან, ხშირად აქვთ გარკვეული მოთხოვნები, მათ შორის წყაროს მითითება და ცვლილებების შენიშვნა.

მაგალითად, Creative Commons ლიცენზიები ზოგადად მოითხოვს ატრიბუტს:

• ორიგინალური ნაწარმოების სათაური
• ბმული ორიგინალურ ნამუშევარზე
• ორიგინალური ნაწარმოების ავტორი
• ლიცენზიის სახელი სრული ლიცენზიის ბმულით
• შენიშვნები ორიგინალური ნაწარმოების ნებისმიერი ცვლილების შესახებ
• თუ მოდიფიკაციები საკმარისია წარმოებულად/ადაპტაციად რომ ჩაითვალოს, ახალი სათაური და ავტორები

ატრიბუტების თვალყურის დევნებისთვის და ჩვენ მიერ შექმნილი assets/common/credits.ron თამაშში გამოსატანი ფორმატის უზრუნველსაყოფად. ** შერწყმის მოთხოვნები, რომლებიც ამატებენ ნამუშევრებს, რომლებიც საჭიროებენ ატრიბუტს, უნდა განაახლონ ეს ფაილი ახალი შენატანებით.** ეს მანიფესტი საშუალებას აძლევს ჩანაწერებს შემდეგი ველებით:

#![allow(unused)]
fn main() {
(
    name: String,
    source_link: String,
    authors: Vec<String>,
    asset_path: String,
    license: String,
    license_link: String,
    modfications: String,
    notes: String,
)
}

სამუშაოს მიკუთვნება ცვლილებების გარეშე ან წყაროდან მცირე მოდიფიკაციების გარეშე შეიძლება დაფორმატდეს შემდეგნაირად:

#![allow(unused)]
fn main() {
(
    name: "Original Title",
    source_link: "https://fonts.com/fancyfont/",
    authors: ["Author One"],
    asset_path: "relative/path/to/fancyfont.ttf",
    license: "CC BY-SA 3.0",
    license_link: "https://creativecommons.org/licenses/by-sa/3.0/",
    modifications: "Trivial modification",
)
}

წარმოებული სამუშაო შეიძლება დაფორმატდეს მიმდინარე სქემაში, როგორიცაა:

#![allow(unused)]
fn main() {
(
    name: "Derivative Title",
    source_link: "https://fonts.com/fancyfont/",
    authors: ["Author Two (derivative)", "Author One (original)"],
    asset_path: "relative/path/to/fancyfont.ttf",
    license: "CC BY-SA 3.0",
    license_link: "https://creativecommons.org/licenses/by-sa/3.0/",
    modfications: "Added additional characters to the font.",
    notes: "Derived from Original Title",
)
}

გაუმჯობესების ადგილია წარმოებული სამუშაოების ფორმატში და მისასალმებელია აზრები ამაზე! მაგალითად, ზემოთ მოცემულ მაგალითში ორიგინალი და წარმოებული ავტორები უნდა განვასხვავოთ ფრჩხილებში ჩანაწერის გამოყენებით და ორიგინალური ნაწარმოების სათაური ჩამოთვლილია notes ველში.

ამ დროისთვის, ატრიბუციის მოთხოვნებს, რომლებიც არ შეესაბამება მოწოდებულ ველებს, შეუძლიათ გამოიყენონ notes ველი დამატებითი ინფორმაციის მოსაწოდებლად. დამატებითი შემთხვევები, რომლებიც შეიძლება საჭირო გახდეს, არის:

• მრავალი ორიგინალური ნაწარმოებიდან მიღებული ნამუშევარი.
• მიღებული სამუშაოდან მიღებული სამუშაო (წინა ცვლილებების მითითება უნდა შენარჩუნდეს).

** რეკომენდებულია კონკრეტული ლიცენზიის და ორიგინალური ავტორის მოთხოვნების ფრთხილად განხილვა.** Creative Commons ლიცენზიების შესახებ დამატებითი სასარგებლო ინფორმაციისთვის იხილეთ:

• https://wiki.creativecommons.org/wiki/Best_practices_for_attribution
• https://creativecommons.org/faq/#attribution

Voxel მოდელების წვლილი

კეთილი იყოს თქვენი მობრძანება განყოფილებაში თქვენი ვოქსელის მოდელების Veloren-ში შეყვანის შესახებ!

პროგრამა Voxel ფაილების შესაქმნელად

ჩვენი შემსრულებლების უმეტესობა იყენებს თავისუფლად ხელმისაწვდომ MagicaVoxel ეფტრაციისგან. ის ხელმისაწვდომია Mac-ისთვის, Windows-ისთვის და მუშაობს Wine-ზე Linux-ზე.

რა თქმა უნდა, თქვენ არ ხართ ვალდებული გამოიყენოთ ეს პროგრამული უზრუნველყოფა, მაგრამ რეკომენდებულია, რადგან ზოგიერთი ბლოკის თვისება განისაზღვრება უშუალოდ MagicaVoxel-ში ნაჩვენები პალიტრის პარამეტრებით.

რაღაც მომენტში ჩვენ შეიძლება შევქმნათ ჩვენი საკუთარი voxel რედაქტორი ჩაშენებული მოდელის გაყალბებითა და ანიმაციით.

დაწყება - სასარგებლო ბმულები

MagicaVoxel მარტივია დასაწყებად, მაგრამ რთული დასაუფლებელი. YouTube ყოველთვის კარგი იდეაა დასაწყებად.

თქვენ მთლიანად უნდა გადახედოთ controls MagicaVoxel-ში, რადგან ისინი აუმჯობესებენ თქვენს სამუშაო პროცესს.

ჩვენი GitLab აქტივების რეპო მოგცემთ წარმოდგენას, თუ როგორ არის ორგანიზებული აქტივები და როგორი სტილის მიღწევას ვცდილობთ მათთან ერთად.

თუ გსურთ ჯავშნის/იარაღის მოდელების შექმნა, რეკომენდებულია გადახედოთ საცნობარო მოდელებს თმის ვარცხნილობისთვის შეგიძლიათ გადახედოთ თმის ვარცხნილობის მითითებას.

დეტალური ინფორმაციისთვის, თუ როგორ შექმნათ და დაამატოთ ისინი თამაშში, გადახედეთ წიგნის სახელმძღვანელოების განყოფილებას.

რამდენიმე საფუძვლები, რომელთა შესახებაც უნდა იცოდეთ

ჩვენი სამყარო შედგება დიდი, “ლანდშაფტური” ზომის ბლოკებისაგან და მცირე ზომის ბლოკებისგან. სახლები, ხეები და ყველაფერი, რაც პირდაპირ არის განთავსებული პროცედურულად წარმოქმნილ სამყაროში, დამზადებულია ლანდშაფტის ბლოკებისგან. ობიექტები, ფიგურები და შპრიტები (ანუ კულტურები) მზადდება მცირე ზომის ბლოკებისგან.

ერთი ლანდშაფტის ბლოკი არის 11x11x11 მცირე ზომის ვოქსელი დიდი.

მოდელების შექმნისას ყოველთვის უნდა გაითვალისწინოთ მათი მასშტაბები. პერსონაჟის მოდელი არის დაახლოებით 22 მცირე ზომის ვოქსელი სიმაღლისა და 10 ვოქსელის სიგანე. ეს არის 1x2 ლანდშაფტის ბლოკები.

მცირე მასშტაბის ვოქსელებისგან შექმნილ ობიექტებს/ფიგურებს შეუძლიათ თვითნებურად მასშტაბირება, რათა შეცვალონ მათი ზომა სამყაროსთან მიმართებაში.

მოდელი გავაკეთე, Core-Devs-ის მიერაა დამტკიცებული, ახლა რა?

თქვენი შემოქმედების ჩვენთვის ხელმისაწვდომობის საუკეთესო გზაა მათი ატვირთვა ჩვენს Google Drive-ის მოდელების დირექტორიაში.

თუ ვერ პოულობთ საქაღალდეს, რომელიც შეესაბამება თქვენს მოდელს, შეგიძლიათ უბრალოდ შექმნათ ახალი.

როდესაც ჩვენ ვეძებთ ახალ მოდელებს და არ გვაქვს ისინი ხელმისაწვდომი ჩვენს ადგილობრივ აქტივების საცავებში, ჩვენ მივმართავთ ამ დისკს.

როგორ მივიღო მხატვრის წოდება?

თვითმოტივირებული მოდელის შექმნა, ზოგადი აღფრთოვანების ჩვენება Veloren-ის მიმართ და მაღალი ხარისხის კონტენტი და ზომიერი და მაღალი აქტივობა Discord-ზე, მოგანიჭებთ არტისტის წოდებას. გახდე კონტრიბუტორი უფრო ადვილია და მხოლოდ გულისხმობს რაიმე სახის მოტივაციის ჩვენებას Veloren-ში წვლილისთვის.

რა არის ხელოვნების და აქტივების სამუშაო ჯგუფი?

ეს სამუშაო ჯგუფი განკუთვნილია ყველაზე თავდადებული და გამოცდილი ხელოვანებისთვის, რომლებიც მუდმივად იღებენ მონაწილეობას პროექტში. სწორედ მათ უნდა მოუსმინონ ახალწვეულებმა და მიიღონ წინადადებები.

არის თუ არა თამაშისთვის ხელოვნების შექმნა, როგორც მისი თამაში და ძირითადად სახალისო?

კი და არა. მოდელების შექმნა სამუშაოდ იგრძნობა. ჩვეულებრივ, ველორენის აღმოჩენისთანავე, მოტივაციის თავდაპირველი სწრაფვის შემდეგ, ადამიანები სწრაფად აცნობიერებენ, თუ რამდენად ბევრია გასაკეთებელი და რომ სხვა ვალდებულებების გამო ვერ დახარჯავს საჭირო დროს ამ ჰობიში. ჩვენ ამას მიჩვეულები ვართ, ასე რომ, გთხოვთ, ნუ იგრძნობთ თავს ცუდად, თუ რამდენიმე კვირა მოგიწევთ გაქრობა.

შინაგანი მოტივაციის შენარჩუნება და თვითორგანიზებული მუშაობა ყველასთვის არ არის.

იმის დანახვა, რომლებიც რეალურად თამაშობენ თქვენს მოდელებთან და იდეებთან, როგორც ჩანს, უზარმაზარი მიღწევაა. ამიტომაც ჩვენგანმა უმეტესობამ არჩია გამხდარიყო მხატვრები ამ პროექტზე:

შევქმნათ მშვენიერი სამყარო ყველასთვის სასიამოვნო.

** თუ გრძნობთ, რომ გსურთ შემოგვიერთდეთ ამ დიდ მოგზაურობაში: ჩვენ მოუთმენლად ველით თქვენს გუნდს და თქვენი შემოქმედების ნახვას!**

ხელს უწყობს აუდიოს

აუდიოს წვლილის საუკეთესო გზაა ჯერ ეწვიოთ Discord-ს, მოითხოვოთ კონტრიბუტორის როლი #new-contributors არხზე და დაიწყოთ საუბარი #აუდიო არხზე.

ყველა ხმის ფაილი უნდა იყოს Vorbis ფორმატში (.ogg ფაილის გაფართოებით) და ექსპორტირებულია ცვლადი ბიტის სიჩქარის დონეზე 5. ამის გაკეთების სწრაფი და მარტივი გზაა ექსპორტი .wav-ის სახით, გახსენით იგი Audacity-ში, და კვლავ ექსპორტირდება როგორც Ogg Vorbis ფაილი შეკუმშვის დონეზე “5”.

ჩვეულებრივია, რომ შეამოწმოთ Discord-ის ერთ-ერთი აუდიო სიგნალი, რათა მიიღოთ თქვენი მუსიკა და ხმოვანი ეფექტები თამაშისთვის.

ხმოვანი ეფექტები

ხმის ეფექტების უმეტესობა მიდის შესაბამის საქაღალდეში assets\voxygen\audio\sfx\-ში.

ხმოვანი ეფექტები, რომლებიც გამოსცემენ წყაროდან 3D სივრცეში, როგორიცაა ნაბიჯები, ხმები და გამოთქმები, უნდა იყოს ექსპორტირებული მონო-ს სახით.

თამაშში ხმის ეფექტის გააქტიურების ორი ძირითადი გზა არსებობს: SFX მოვლენები და შედეგები.

SFX მოვლენები იღებენ SFX-ს sfx.ron ფაილიდან. ისინი ძირითადად გამოწვეულია ნებისმიერი mod.rs-ის მიერ voxygen\src\audio\sfx\-ში.

შედეგი SFX არის ამოღებული sfx.ron-დან და დამუშავებულია voxygen\src\audio\sfx\mod.rs-ში. შედეგები ემიტირებულია ნებისმიერი კოდიდან, რომელიც მას უკავშირდება, იქნება ეს საბრძოლო, სერვერის მოვლენა და ა.შ. შედეგი ასევე უნდა დაემატოს common\src\outcome.rs-ს.

UI SFX ჩვეულებრივ სტერეო ხმებია, რომლებიც პირდაპირ უკრავს პლეერზე (ანუ არა მსოფლიოს ადგილიდან).

ასევე არის ატმოსფერო, რომელიც გამოიყენება ქარისა და წვიმისთვის. ეს ხმები ყოველთვის სტერეოა. მისი კოდი არის voxygen\src\audio\ambience.rs-ში, ფაილები არის assets\voxygen\audio\ambience-ში და მისი manifest არის assets\voxygen\audio\ambience.ron.

თუ შესაძლებელია, შეამოწმეთ თქვენი SFX თამაშში, სანამ შეეცდებით მის გაერთიანებას; დარწმუნდით, რომ ის სწორად ჟღერს და უკრავს სწორ ხმაზე. აუცილებლად მიიღეთ მეორე აზრი Discord არხიდან!

მუსიკა

მუსიკალური ფაილები გვხვდება assets\voxygen\audio\soundtrack\-ში. თამაში იღებს ფაილებს soundtrack.ron ფაილის მეშვეობით. მასტერინგის შემდეგ მუსიკა უნდა იყოს ნორმალიზებული -1დბ.

უხეში ხმაურის მითითებები: LUFS ანალიზის პროგრამული უზრუნველყოფის მქონე ადამიანებისთვის, შეეცადეთ შეინარჩუნოთ მაქსიმალური LUFS-S (ნორმალიზების შემდეგ) -14-დან -13-მდე საძიებო ბილიკებისთვის და -13-დან -12-მდე საბრძოლო ბილიკებისთვის. თუ ეჭვი გეპარებათ, შეადარეთ პირდაპირ არსებულ ტრეკებს.

კვლევა

თამაში უკრავს საძიებო მუსიკას, როგორც ცალკეული, დამოუკიდებელი ტრეკების ფონზე. როდესაც ერთი სიმღერა მთავრდება, გარკვეული დრო გადის მეორე ტრეკის დაკვრამდე. რომელი ტრეკის დაკვრა განისაზღვრება იმ საიტის, ბიომის, ამინდისა და დღის დროის მიხედვით, რომელშიც იმყოფება მოთამაშე.

ამჟამად ხელმისაწვდომი ადგილებია სამყარო, დუნდულები, გამოქვაბულები და ქალაქები. საიტების განახლებული სიისთვის იხილეთ /common/src/terrain/site.rs.

ამჟამად ხელმისაწვდომი ბიომებია მდელოები, ტყე, უდაბნო, ტუნდრა, ტბა, მთა, ოკეანე, ჯუნგლები, სავანა და ტაიგა. ჭაობის ბიომი დაგეგმილია, მაგრამ ჯერ არ არსებობს. ბიომების განახლებული სიისთვის იხილეთ common\src\terrain\biome.rs.

აღსანიშნავია, რომ ბიომები არის აღწერითი და არა აღწერითი, როდესაც საქმე ეხება კოდს. სამყარო არ წარმოქმნის ბიომების საფუძველზე და ბიომები განისაზღვრება არსებული ცალი მონაცემების საფუძველზე.

ზოგიერთი ბიომი ანაცვლებს სხვებს - განსაკუთრებით, თოვლით დაფარული მთები ჩაითვლება ტუნდრად. თუ გსურთ იცოდეთ ზუსტად როგორ განისაზღვრება ბიომები, იხილეთ get_biome() world\src\sim\mod.rs-ში.

ასევე გაითვალისწინეთ, რომ მუსიკა შეიძლება დაკვრას ერთზე მეტ ბიომში და დღის მონაკვეთში, თუმცა ჩვენ, როგორც წესი, გვსურს ეს მინიმუმამდე დავიყვანოთ, რადგან უფრო მეტი მუსიკა დაემატება, რათა თითოეულ ბიომს მივცეთ უფრო განსხვავებული ტონი.

დღის დრო არის დღე და ღამე.

საუკეთესო გზა საუნდტრეკის ტონის მისაღებად არის მისი უბრალოდ მოსმენა.

საძიებო მუსიკას უნდა ჰქონდეს რბილი დასაწყისი და დასასრული, რადგან ისინი შემოდის არსებითად შემთხვევით დროს.

საბრძოლო

** შენიშვნა: ამჟამად საბრძოლო მუსიკა გათიშული ფუნქციაა, რადგან ის კარგად არ მუშაობს ახალ დუნდულებთან და არც ახალ ბექენდთან. იგი განკუთვნილია ხელახალი დიზაინისთვის.**

საბრძოლო მუსიკის სისტემის ამჟამინდელი დანერგვა შემდეგია:

“ბრძოლა”, როგორც მდგომარეობა, არის ის, როდესაც მოთამაშე უახლოვდება მტრებს გარკვეულ მანძილზე ან მაღალი სიჯანსაღით ან დიდი რაოდენობით. ამჟამად საბრძოლო მუსიკა დაცულია ძველი, მიწისქვეშა დუნდულებისთვის. მოთამაშის ბრძოლაში შესვლისას ითამაშება start სეგმენტი. თუ ის დასრულდება და ბრძოლა გაგრძელდება, მაშინვე ითამაშება loop სეგმენტი, სანამ ან გაქრება ან ითამაშებს end სეგმენტს, როდესაც ბრძოლა დასრულდება.

• start არის მოკლე შესავალი მიმაგრებული loop-ს. თუ კომპოზიტორი ჭკვიანია, მათ შეუძლიათ შეამოკლონ ეს სეგმენტი, თუ როგორმე სრულყოფილად გადაინაცვლებს loop-ში დაუკვრის გარეშე მთელი loop თავად.

• loop არის საბრძოლო მუსიკის ძირითადი ნაწილი. იმის გამო, რომ მუსიკა მხოლოდ მაშინ მოდის, როდესაც მოთამაშე საკმაოდ მძიმე მდგომარეობაშია (მტრების ბრბო, მძიმე მტრები და ავტორიტეტები), მუსიკის ინტენსივობა საკმაოდ მაღალი უნდა იყოს.

• end არის ძალიან მოკლე კადენცია, რომელიც მოდის loop-ის ბოლოდან და ითამაშება მხოლოდ იმ შემთხვევაში, თუ გაქრობა ვერ დასრულდება loop-ის დასრულებამდე. უნდა მისცეს საბოლოოობის განცდა.

მნიშვნელოვანია, რომ გადასვლები და მარყუჟები იყოს გლუვი. ეს ნიშნავს, რომ loop უნდა იყოს “ექსპორტირებული როგორც მარყუჟი”; loop-ის (და start) კუდი (ნარჩენი გათავისუფლება/აღმოხმა ბოლოს) ასევე უნდა შევიდეს მის დასაწყისში, ისევე როგორც end-ში.

მთარგმნელობითი სამუშაო ჯგუფი

_ შესავალი შინაარსის თარგმნის შესახებ თქვენს ენაზე და არა მხოლოდ.

• თამაშის თარგმნა
• ვებლაიტის მართვა
• დეველოპერის სახელმძღვანელო

თამაშის თარგმნა

წინასიტყვაობა

Veloren იყენებს Fluent ლოკალიზაციის სისტემას შინაარსის თარგმნისთვის. თარგმანის ფაილებს აქვთ .ftl ფაილის გაფართოება. Fluent ფაილები შეიცავს შეტყობინებების ჩამონათვალს გასაღები-მნიშვნელობის ფორმატში.

თავისუფალ შეტყობინებებს შეიძლება ჰქონდეს ან არ ჰქონდეს ცვლადები შიგნით placeables სინტაქსის მეშვეობით.

main-servers-other_error = Server general error: { $raw_error }
main-credits = Credits

გამართულ შეტყობინებებს შეიძლება ჰქონდეთ მიმაგრებული ატრიბუტები.

common-abilities-hammer-leap = Smash of Doom
    .desc = An AOE attack with knockback. Leaps to position of cursor.

Fluent ასევე მხარს უჭერს მრავლობითი სელექტორებს Unicode წესების მეშვეობით:

https://www.unicode.org/cldr/cldr-aux/charts/30/supplemental/language_plural_rules.html

შენიშვნა: თითოეულ ენას აქვს თავისი მრავლობითი ნაკრები. რაც ინგლისურს არ დააკოპიროთ-პასტე აკეთებს.

hud-trade-buy_price = { $coin_num ->
  [1] Buy Price: one coin
  *[other] Buy Price: { $coin_formatted } coins
}

*-ით მონიშნული ფილიალი გამოყენებული იქნება ნაგულისხმევად.

მრავლობითი ამომრჩევი საშუალებას აძლევს Fluent-ს შეარჩიოს “ჯგუფის” მიხედვით (განსხვავებული თითოეული ენისთვის). ფლუენტს ასევე შეუძლია გამოიყენოს ლიტერალები სელექტორებში პირდაპირი შედარება. იგივე მაგალითი უკრაინულად შეიძლება ასე გამოიყურებოდეს:

hud-trade-buy_price = { $coin_num ->
  [1] Ціна покупки: одна монета
  [one] Ціна покупки: { $coin_formatted } монета
  [few] Ціна покупки: { $coin_formatted } монети
  *[other] Ціна покупки: { $coin_formatted } монет
}

შენიშვნა: [1] და [one] განსხვავებულია უმეტეს ენებში, მიუხედავად იმისა, რომ ერთნაირია ინგლისურად. უკრაინულად 1 და 21 წავიდოდა [ერთზე], მაგრამ იმიტომ რომ აქ ჩვენ აშკარად ვდებთ დასაწყისში [1], ის უფრო ადრე დაემთხვევა, რაც გვაძლევს ამის საშუალებას სპეციალური საქმის ერთჯერადი მონეტა.

ნუ გადააჭარბებთ, თუ რამე შესაძლებელია, ეს არ ნიშნავს იმას, რომ საჭიროა.

Fluent გვაძლევს გრამატიკული სქესების დამუშავების საშუალებასაც. შეგიძლიათ თარგმნოთ წინადადებები მსახიობების მოწოდებული სქესის გამოყენებით. გახსოვდეთ ნაგულისხმევი დაყენება ვარიანტი * სიმბოლოთი იმ შემთხვევებისთვის, როდესაც შეტყობინებები ვერ ხერხდება მიუთითეთ სქესი.

hud-chat-offline_msg = { $user_gender ->
    [she] [{ $name }] вийшла з серверу
    [he] [{ $name }] вийшов з серверу
    *[any] [{ $name }] оффлайн
}

შენიშვნა: ყველა შეტყობინება არ შეიცავს სქესს. თუ ეჭვი გაქვთ, შეამოწმეთ კომენტარები ინგლისურ თარგმანში ან ჰკითხეთ მთარგმნელობით ჯგუფს. თუ გენდერული ინფორმაცია არ არის ხელმისაწვდომი, სცადეთ წინადადების გადაკეთება ის, სადაც გრამატიკა არ მოითხოვს სქესის დაზუსტებას.

შეგიძლიათ მეტი გაიგოთ Fluent-ისა და მისი სინტაქსის შესახებ აქ:

https://projectfluent.org/

Weblate-ის გამოყენება (რეკომენდებულია)

Weblate არის ყველაზე მოსახერხებელი გზა Veloren-ის თქვენს ენაზე თარგმნისთვის.

https://translate.codeberg.org/engage/veloren/

თამაში თარგმნილია Weblate-ზე თარგმანის წინადადებებით. ესენი წინადადებები განსხვავებულად მუშაობს იმისდა მიხედვით, აქვს თუ არა ენას ნებისმიერი თავდადებული მიმომხილველი.

• ენას ჰყავს ერთი ან მეტი მიმომხილველი.
• შეგიძლიათ მხოლოდ თარგმანის შემოთავაზებების დამატება. რეცენზენტები გადაწყვეტენ მიიღოს თუ უარყოს წინადადებები.
• ენას არ ჰყავს თავდადებული რეცენზენტები.
• შეგიძლიათ დაამატოთ და ხმა მისცეთ თარგმანის წინადადებებს. ვარაუდები, რომ მიაღწიოს დადებითი ხმების გარკვეულ რაოდენობას, მიიღება ავტომატურად.
• ენა არ არსებობს Weblate-ზე.
• თქვენ უნდა დააყენოთ პრობლემა GitLab-ზე და გვთხოვოთ ენის დამატება Weblate, ასე რომ თქვენ შეგიძლიათ დაიწყოთ თქვენი წინადადებების გაგზავნა იქ.
• თქვენ შეგიძლიათ შექმნათ საკითხი აქ: https://gitlab.com/veloren/veloren/-/issues/new

თავდადებული მიმომხილველები არიან საზოგადოების სანდო წევრები, რომლებიც ერთგულები არიან მათ მიერ დანიშნულ ენა(ებ)ის თარგმანების მართვა. ისინი წყვეტენ რა თარგმანის სტრიქონები მოხვდება GitLab-ის საცავში.

თუ გსურთ გახდეთ ენის ერთგული მიმომხილველი, მოგერიდებათ ჩვენთან განსახილველად.

პროგრამირების ხელსაწყოების გამოყენება (ძველი გზა)

სანამ Weblate ხელმისაწვდომი იქნებოდა კონტრიბუტორებისთვის, თამაშის თარგმნა იყო უფრო რთული, რადგან თარჯიმნებს სჭირდებოდათ Git ვერსიის კონტროლის გამოყენება მათი თარგმანების გაგზავნის სისტემა.

ზოგიერთი მთარგმნელობითი ინსტრუმენტი ავსებდა ძველ სამუშაო პროცესებს. ისინი ჯერ კიდევ ხელმისაწვდომია, მაგრამ ერთადერთი მხარდაჭერილი გზაა თარგმანების შესატანად თამაშში იყენებს Weblate-ს.

თქვენი თარგმანის გადახედვა

Veloren მხარს უჭერს თარგმანის ფაილებში თქვენი ცვლილებების რეალურ დროში ნახვას. თამაში უნდა იყოს შედგენილი “გამართვის” კონსტრუქციით, ამ ფუნქციის მხარდასაჭერად. თქვენ შეგიძლიათ შეადგინოთ თამაში თავად ამ რეჟიმში მიჰყევით ინსტრუქციას აქ:

ველორენის შედგენა

მას შემდეგ რაც შეადგინეთ თამაში და, ეფექტურად, შეგიძლიათ გაუშვათ “გამართვის” build თუმცა, ნებისმიერი ცვლილება, რომელსაც თქვენ განახორციელებთ Fluent ფაილებში, აისახება თამაშში რეალურ დროში. ეს არის ფაილები, რომლებიც შეიცავს assets/voxygen/i18n დირექტორიაში.

ინფორმაციის მიღება თარგმანის შესახებ

Veloren მოიცავს ლოკალიზაციის ტესტის ინსტრუმენტს, თუ თქვენ გაქვთ შედგენილი თამაში.

ეს სპეციალური ინსტრუმენტი ადარებს თქვენი არჩეული ენის Fluent კლავიშებს საცნობარო ენასთან, ინგლისურთან. ინსტრუმენტი შემდეგ კლასიფიცირებს, ითვლის და ბეჭდავს ამ შედარებებს თარჯიმნებისთვის კარგად შესამოწმებლად.

ეს არის იგივე პროგრამა, რომელსაც ჩვენ ვატარებთ ჩვენს ავტომატიზირებულ CI მილსადენებში, მაგრამ ნაკლებად სიტყვიერი.

მაგალითად, შეგიძლიათ გაუშვათ ეს ბრძანება, რომ მიიღოთ ინფორმაცია ამის შესახებ უკრაინული თარგმანი.

cargo run --bin i18n-check --features=bin -- uk

დამატებითი ინფორმაციისთვის, თუ როგორ გამოიყენოთ ეს ინსტრუმენტი, გაუშვით ის --help არგუმენტით:

cargo run --bin i18n-check --features=bin --help

ონლაინ ლოკალიზაციის ტესტი

ჩვენ ვთავაზობთ ვებ სერვისს თარგმანის სტატისტიკის საჩვენებლად.

https://grafana.veloren.net/d/mNjODNM7z/translations

ჩვენ მაგალითს გამოვიყენებთ უკრაინულ თარგმანს.

აქ ჩვენ გვაქვს დეტალური ინფორმაცია უკრაინულში გამოყენებული ყველა ენის გასაღებების შესახებ თარგმანი (uk დირექტორია) საცნობარო ენასთან შედარებით თარგმანი (ინგლისური - en/ დირექტორია).

თითოეული გასაღებისთვის ნაჩვენები status განყოფილებას აქვს შემდეგი შესაძლო მნიშვნელობები:

• Unused: გასაღები არსებობს უკრაინულ თარგმანში, მაგრამ არა ინგლისურში თარგმანი. ეს არის გასაღებები, რომლებიც ადრე გამოიყენებოდა თამაშში, მაგრამ ამოღებულ იქნა, რადგან არ იყო საჭირო ან დაარქვეს სახელი. ესენი უსაფრთხოა ამოღება.

• NotFound: გასაღები არსებობს ინგლისურ თარგმანში, მაგრამ არ არსებობს უკრაინული თარგმანი. აქ გვჭირდება თქვენი თარგმანი!

• Outdated: ამჟამად მიუწვდომელია, ნიშნავს, რომ გარკვეული ცვლილებები განხორციელდა ინგლისური თარგმანი, მაგრამ არა უკრაინული თარგმანი.

პრობლემების მოგვარება

მე არ შემიძლია თარგმანის შეთავაზებები Veloren-ისთვის Weblate-ზე

თუ თქვენი მომხმარებლის ანგარიში Codeberg Translate-ზე შეიქმნა 2024 წლის თებერვლამდე, თქვენს ანგარიშს შესაძლოა არ მიეცეს საჭირო ნებართვები წვლილისთვის ველორენის თარგმანი.

გთხოვთ, დაუკავშირდეთ მთარგმნელობით ჯგუფს Discord-ზე ან ელ საკითხი GitLab-ზე. ჩვენ განვიხილავთ თქვენს ნებართვებს და დაგეხმარებით პრობლემის მოგვარებაში.

ტექსტის ზოგიერთი სიმბოლო აკლია ან არასწორად არის ნაჩვენები

გთხოვთ, დააყენოთ პრობლემა GitLab-ზე თამაშში დაკარგული სიმბოლოების დასამატებლად შრიფტები თქვენი ენისთვის.

ვებგვერდის მართვა

თარგმანის სამუშაო პროცესი

ზოგჯერ საჭიროა ცვლილებების შეტანა თარგმანის ფაილებში Weblate-ის გარეთ, ამ შემთხვევაში მნიშვნელოვანია შემდეგი მოთხოვნების დაცვა:

• ცვლილებები, რომლებიც ** მხოლოდ ინგლისურ წყაროზე მოქმედებს ** ფაილების გაერთიანება შესაძლებელია ნებისმიერ შემთხვევაში დრო.
• ცვლილებები, რომლებიც ცვლის თარგმნილი ენის ფაილებს, შეიძლება მხოლოდ გაერთიანებული იყოს Weblate-თან კოორდინაცია:
• Weblate-დან თარგმანები ყველა შესრულებულია (“შემდეგი ცვლილებების შესრულება”).
• თარგმანები იძაბება და იხსნება შერწყმის მოთხოვნა.
• თარგმანები ჩაკეტილია Weblate-ში ცვლილებებისთვის.
• Weblate MR გაერთიანდა, Weblate რჩება ჩაკეტილი.
• თავად პოტენციური შერწყმის კონფლიქტების მოგვარების შემდეგ, იცვლება გარეგანი შერწყმულია.
• მას შემდეგ, რაც ყველა ცვლილება განხორციელდება მთავარ ფილიალში, Weblate განახლდება და განბლოკილია.
• თარგმნილი ენის ფაილების განახლება უნდა მოხდეს მხოლოდ მაშინ, როცა ისინი სინქრონიზებულია Weblate და Weblate დაბლოკილია კონფლიქტური ცვლილებების თავიდან ასაცილებლად.

ენის ტიპები

ენები იყოფა ორ ტიპად:

1. ენები ერთი ან მეტი გამოყოფილი მიმომხილველით.

• კონტრიბუტორებს შეუძლიათ მხოლოდ თარგმანის შემოთავაზებების დამატება.
• მიმომხილველები პასუხისმგებელნი არიან შეამოწმონ წინადადებები და მიიღონ გადაწყვეტილება მიიღოს თუ უარყო ისინი.

2. ენები ყოველგვარი მიმომხილველის გარეშე.

• ეს არის ნაგულისხმევი ტიპი.
• კონტრიბუტორებს შეუძლიათ თარგმანის წინადადებების დამატება და ხმის მიცემა.
• შეთავაზება ხდება ახალი თარგმანი, როდესაც ის მიაღწევს გარკვეულ რაოდენობას დადებითი ხმების.

ენის კონფიგურაცია

დააყენეთ ენის ტიპი

ჩვენი პროექტი Weblate-ზე ნაგულისხმევად ვარაუდობს, რომ არცერთ ენას არ აქვს გამოყოფილი ენა რეცენზენტები. კონფიგურირებულია მხოლოდ ერთი ან მეტი მიმომხილველის მქონე ენები აშკარად ადმინისტრატორების მიერ.

წარმოვიდგინოთ შემდეგი სცენარი:

1. თურქულ ენას არ ჰყავს სპეციალური მიმომხილველი Weblate-ზე.
2. ჩვენი საზოგადოების წევრი, მერი, ითხოვს იყოს რეფერენტი თურქულში ველორენის თარგმანი.
3. თურქული ენა უნდა შეიცვალოს ნაგულისხმევი, იმპლიციტური ქცევისგან ახალ, გამოკვეთილ ქცევას. ქცევა ენებისთვის თავდადებული რეცენზენტები.

როგორც ჩვენი Weblate პროექტის ადმინისტრატორს, თქვენ უნდა მიჰყვეთ ეს ნაბიჯები:

1. გადადით თურქულის ენის პარამეტრებზე Weblate-ზე.

• URL ამ კონტექსტში იქნება: https://translate.codeberg.org/settings/veloren/-/tr/

2. დარწმუნდით, რომ ჩართულია მხოლოდ ეს ველები:

• დააკონფიგურიროთ თარგმანის სამუშაო პროცესი ამ ენაზე
• ჩართეთ წინადადებები

3. დაამატეთ Mary-ის მომხმარებელი Weblate-ზე ** მიმომხილველები: თურქული ** პროექტის გუნდში.

• URL ამ კონტექსტში იქნება: https://translate.codeberg.org/teams/487/

განსხვავება ახლა, რაც შეეხება ნაგულისხმევ ქცევას, არის ის, რომ თურქული აქვს Suggestion voting გამორთულია. ამრიგად, რეცენზენტები, როგორიცაა მერი, ერთადერთია ადამიანები, რომლებსაც შეუძლიათ თარგმანის მართვა: რა სტრიქონები ქმნიან მას GitLab საცავი.

თუ გსურთ დაიბრუნოთ ნაგულისხმევი ქცევა ენისთვის (განმხილველის გარეშე), მიჰყევით ამ ნაბიჯებს:

1. წაშალეთ ყველა მომხმარებელი შესაბამისი მიმომხილველი გუნდიდან.
2. გადადით ენის პარამეტრებზე და გამორთეთ **Customize translation სამუშაო პროცესი ამ ენისთვის ** მოსანიშნი ველი.

ენის დამატება Weblate-ში

ჩვენ შეიძლება დროდადრო მივიღოთ მოთხოვნები Weblate-ზე ენების დასამატებლად რომელიც ჯერ არ არის თამაშის თარგმანი. ჩვენი ვებგვერდის ადმინისტრატორები პროექტები პასუხისმგებელნი არიან ასეთ თხოვნაზე დასწრებაზე.

Weblate-ში ახალი ენების დასამატებლად საჭიროა Git-ის ლოკალური ინსტალაცია.

თაღლითური ფურცელი

თუ ენის სწრაფად დამატება გჭირდებათ, მიჰყევით ამ ნაბიჯებს:

1. დარწმუნდით, რომ თქვენს მოწყობილობაზე გაქვთ Veloren საცავის ადგილობრივი ასლი.

    git clone https://gitlab.com/veloren/dev/veloren.git
    ```

2. შექმენით ახალი ფილიალი.

```bash
    cd veloren
    git checkout -b <yourusername>/add-<language>
    ```

3. გადადით `assets/voxygen/i18n` დირექტორიაში.

```bash
    cd assets/voxygen/i18n
    ```

4. გააკეთეთ თქვენი ენის სახელის დასახელებული `en/` დირექტორიას ასლი.
მაგალითად, თუ გსურთ თარგმნოთ თურქულად,
თქვენს დირექტორიას დაერქმევა `tr/`:

```bash
    cp en <ietf_bcp_47_code>
    ```

5. წაშალეთ ყველა Fluent ფაილის შიგთავსი თქვენს ახალ დირექტორიაში. ყველა
ფაილები `.ftl` ფაილის გაფართოებით. დარწმუნდით, რომ ფაილები ჯერ კიდევ არსებობს,
მაგრამ ცარიელი.
6. გახსენით `_manifest.ron` ფაილი და შეცვალეთ `language_name` და `language_identifier`
შესაბამისი ველები (იხილეთ ქვემოთ ამ ფაილის შესახებ დამატებითი დეტალებისთვის.)
7. განახორციელეთ თქვენი ცვლილებები ადგილობრივად.

```bash
    git commit
    ```

8. დააყენეთ თქვენი ადგილობრივი ფილიალი დინების ზემოთ.

```bash
    git push -u origin <yourusername>/add-<language>
    ```

9. გადადით თქვენს ახალ ფილიალში GitLab-ზე: <https://gitlab.com/veloren/dev/veloren/-/branches>
10. შექმენით შერწყმის მოთხოვნა (MR), რომელიც მიზნად ისახავს მთავარი საცავის `master` ფილიალს.

#### manifest ფაილის შესახებ

`_manifest.ron` ფაილს აქვს მეტამონაცემების განყოფილება.
ამ განყოფილებას აქვს თქვენი თარგმანის საჩვენებელი სახელი და ენის იდენტიფიკატორი.
შეცვალეთ `language_name` ადამიანის წაკითხვადი სახელით თქვენს ენაზე ამ ფორმატით:

```txt
<name_in_original_language> (<name_in_english>)

მაგალითად:

metadata: (
    language_name: "Türkçe (Turkish)",
    language_identifier: "tr",
),

თუ ენა არის ვარიანტი, რომელზეც საუბრობენ გარკვეულ რეგიონში ან ქვეყანაში, მიჰყევით ამ ფორმატს:

<name_in_original_language> (<name_in_english> - <region>)

ამ შემთხვევის ორი მაგალითია:

metadata: (
    language_name: "Español de España (Spanish - Spain)",
    language_identifier: "es",
),

და:

metadata: (
    language_name: "Español de Hispanoamérica (Spanish - Latin America)",
    language_identifier: "es-419",
),

არ დაგავიწყდეთ დააყენოთ language_identifier მნიშვნელობა, რათა შეესაბამებოდეს მშობლის დირექტორიას სახელს.

აი სრული მაგალითი:

/// Localization for Čeština
(
    metadata: (
        language_name: "Čeština (Czech)",
        language_identifier: "cs",
    ),
    fonts: {
        "alkhemi": Font (
            asset_key: "voxygen.font.Alkhemikal",
            scale_ratio: 1.0,
        ),
        "cyri": Font (
            asset_key: "voxygen.font.EnterCommand",
            scale_ratio: 1.0,
        ),
    }
)

შრიფტებს აქვს ორი აუცილებელი ჩანაწერი და ერთი არასავალდებულო:

• alkhemi ნიშნავს სუპერ ლამაზი შრიფტს, რომელსაც ვიყენებთ სპეციალური სტრიქონებისთვის. მხოლოდ ინგლისური ჩვეულებრივ.
• cyri ნიშნავს ჩვეულებრივ შრიფტს, რომელსაც ვიყენებთ ყველაფერში. გამოიყენება თარგმნილი სტრიქონებისთვის.
• უნივერსალური ნიშნავს შრიფტს, რომელიც უნდა მოიცავდეს ყველა ენას. გამოიყენება ჩეთის ან მსგავსი შემთხვევებისთვის.

ჩვეულებრივ, არ გჭირდებათ “უნივერსალური” შრიფტის დაყენება, მაგრამ თუ უნივერსალური შრიფტი არ მოიცავს თქვენს ენას, გსურთ მისი გადალახვა. ასე აკეთებს კორეელი.

/// WARNING: Localization files shall be saved in UTF-8 format without BOM

/// Localization for Korean
(
    metadata: (
        language_name: "한국어 (Korean)",
        language_identifier: "ko",
    ),
    fonts: {
        "universal": Font (
            asset_key: "voxygen.font.bdfUMplus-outline",
            scale_ratio: 0.75,
        ),
        "alkhemi": Font (
            asset_key: "voxygen.font.bdfUMplus-outline",
            scale_ratio: 0.75,
        ),
        "cyri": Font (
            asset_key: "voxygen.font.bdfUMplus-outline",
            scale_ratio: 0.75,
        ),
    }
)

ახალი შრიფტის დამატება

თუ assets/voxygen/font/ საქაღალდეში არსებული შრიფტები საკმარისი არ არის თქვენთვის, შეგიძლიათ დაამატოთ ახალი ან შეცვალოთ არსებული შრიფტები. არსებული შრიფტების შეცვლის ინსტრუქცია სცილდება, მაგრამ გახსოვდეთ, რომ შრიფტებს აქვთ სხვადასხვა ლიცენზია და პოტენციურად ყველა შრიფტი არ უჭერს მხარს მოდიფიკაციას.

თუ გსურთ დაამატოთ ახალი შრიფტი, უნდა იპოვოთ ის, აიღოთ მისი ლიცენზია, შეამოწმოთ, რომ ის თავსებადია ჩვენს პროექტთან და ჩვენ შეგვიძლია გადაანაწილეთ იგი.

როდესაც თქვენ გაქვთ შრიფტის ფაილი (TTF ფორმატში) და ლიცენზია, ნაბიჯები შემდეგია:

1. ჩასვით შრიფტი assets/voxygen/font-ში
2. დაამატეთ <font>-license.txt ლიცენზიით
3. აღნიშნეთ შრიფტი assets/credits.ron-ში

თარგმანის სისტემა განმარტა

თქვენ შეგიძლიათ იხილოთ ლოკალიზაციის ფაილები assets/voxygen/i18n დირექტორიაში. შიგნით თითოეული ქვედირექტორი წარმოადგენს ენას, ან მის ვარიანტს. დირექტორიები დასახელებულია IETF BCP 47 (RFC5646) ენის ტეგების (მაგ. en/, de/, pt-BR/ და ა.შ.) მიხედვით. ენის ტეგი შედგება ერთი ან მეტი ქვეთეგისაგან, გამოყოფილი დეფისებით (“-”).

ეს არის ხელმისაწვდომი ენის ქვეთეგების ყოვლისმომცველი სია:

IANA ენის ქვეთეგების რეესტრი

ისინი უნდა იყოს ფორმატირებული UTF-8-ში, [BOM]-ის გარეშე (https://en.wikipedia.org/wiki/Byte_order_mark). თითოეული ენის დირექტორია შეიცავს _manifest.ron ფაილს მეტამონაცემების განყოფილებით, შრიფტის პარამეტრები, რომლებიც გამოყენებული იქნება თამაშში და convert_utf8_to_ascii ვარიანტი, რომელიც შეიძლება გამოყენებულ იქნას ენის თარგმნისას, რომელსაც აქვს სიმბოლოები, რომლებიც არ არის შრიფტებში Veloren იყენებს.

მეტამონაცემების განყოფილება შეიცავს საჩვენებელ სახელს და იდენტიფიკატორს ენა. საჩვენებელი სახელი შეიძლება თავისუფლად შეიცვალოს, მაგრამ იდენტიფიკატორი უნდა იყოს დარჩით იგივე ახალი ენის შემოღების შემდეგ:

metadata: (
    language_name: "English",
    language_identifier: "en",
),

შენიშვნა: ენის იდენტიფიკატორი უნდა შეესაბამებოდეს ენის შემცველი საქაღალდის სახელს. ეს მოთხოვნა გულისხმობს, რომ იდენტიფიკატორი ასევე უნდა შეესაბამებოდეს IETF BCP 47 დასახელების სტანდარტს.

პრობლემების მოგვარება

მე ვიღებ ასობით ან თუნდაც ათასობით წერილს Weblate-ისგან

ერთხელ, ჩვენი Weblate პროექტის პირველად კონფიგურაციისას, იყო ინციდენტი, სადაც მაშინდელმა ადმინისტრატორებმა მნიშვნელოვანი მიიღეს შეტყობინებების რაოდენობა Weblate-დან ელ.ფოსტით. როგორც ჩანს, ეს გამოწვეული იყო ან პროგრამული შეცდომით ან ცუდი კონფიგურაციით.

თუ თქვენ ხართ ჩვენი პროექტის ადმინისტრატორი Weblate-ზე და გსურთ მიიღოთ შეტყობინება ელექტრონული ფოსტით, ყოველი შემთხვევისთვის, ჩვენ გირჩევთ დააყენოთ პირადი შემოსულების წესები, რათა გადაიტანოთ შეტყობინებები შემდეგი გამგზავნიდან თქვენს მიერ არჩეულ ელფოსტის საქაღალდეში:

[email protected]

ინტერნაციონალიზაციის დეველოპერის გზამკვლევი

ასე რომ, თუ ფუნქცია, რომელზეც მუშაობთ, მოითხოვს რაიმე ტექსტს, ის ალბათ დაკავშირებულია i18n-თან. ეს სახელმძღვანელო დაგეხმარებათ ამ მოგზაურობაში და მოიცავს:

• მაღალი დონის სისტემის მიმოხილვა
• საუკეთესო პრაქტიკა და ანტი-ნიმუშები
• მაგალითები

დავიწყოთ სწრაფი მაღალი დონის მიმოხილვით.

საძირკვლის ყუთები

ჩვენ გვაქვს ორი საძირკველი ყუთი კომუნალური საშუალებებით, რომელთა გამოყენება დაგჭირდებათ:

• client/i18n
  ჩვენი მთარგმნელობითი შესაძლებლობების ხორცი და სისხლი.
  ის ეფუძნება fluent-rs ყუთს და assets_manager-ის შეფუთვას, რომელიც გვაქვს common/assets-ში.
  
  ყველაზე სასარგებლო ტიპი ამ ყუთიდან არის ლოკალიზაცია რომელიც ავლენს get_msg-ოჯახის მეთოდებს, რომლებიც იღებენ i18n კლავიშს და get_content მეთოდს რომელსაც შეუძლია მიიღოს Content ობიექტი. ორივე გაძლევთ მზა ნათარგმნ სტრიქონს გამოსაყენებლად.
• common/i18n
  მართავს ინტერფეისებს ლოკალიზაციისთვის, როცა ამის გაკეთება გჭირდებათ voxygen-ის გარეთ.
  რაც მთავარია Content ტიპი, რომელიც არის რეკურსიული ტიპი, რომელიც წარმოადგენს i18n-ის დაგვიანებულ შეფასებას საჭირო კონტექსტით.

მინიშნება: თქვენ არ გჭირდებათ Content, თუ უკვე ხართ voxygen-ში. უბრალოდ გამოიყენეთ get_msg ან get_msg_ctx.

ფუნდამენტური ყუთების აზრი იმაში მდგომარეობს, რომ ისინი ძალიან მცირეა, სწრაფად შედგენილია და ბევრად უფრო აბსტრაქტული.

აპლიკაციის ყუთები

ახლა, როდესაც იცით რა შეგიძლიათ გამოიყენოთ თარგმანისთვის, მოდით ვისაუბროთ ყუთებზე სად შეგიძლიათ გამოიყენოთ იგი:

• voxygen \

• კლიენტის ყუთი. მართავს გრაფიკას, აუდიოსა და ინტერფეისს. და UI იყენებს ტექსტს, როგორც თქვენ შეგიძლიათ გამოიცნოთ.
  ყველა ვიჯეტს უნდა ჰქონდეს წვდომა იქ i18n::Localization-ზე, ასე რომ, თუ თარგმნილი სტრიქონი გჭირდებათ, გააკეთეთ.

• server და თანამშრომელი
  დიდი განსხვავებაა, თუ რომელ კოლოფს მუშაობთ, რადგან მათ არ აქვთ წვდომა Localization ობიექტზე.
  მათ არც კი იციან რა ენას იყენებენ მოთამაშეები.
  ამის ნაცვლად, თუ თქვენ აწარმოებთ შეტყობინებების სერვერის მხარეს, როგორიცაა NPC შეტყობინება, ბრძანების შედეგი, NPC სახელი, თქვენ უნდა გამოიყენოს Content.

აქტივები

კარგია, რომ შეგიძლია დააკოდირო რაც გინდა, მაინც გჭირდება აქტივები.

მოდით შევამოწმოთ ისინი:

• assets/voxygen/i18n/
  საქაღალდე, სადაც ყველა Fluent ფაილი ცხოვრობს. თუ გსურთ დაამატოთ ახალი სტრიქონი, აირჩიეთ ფაილი, რომელიც კარგად გამოიყურება, დადე ახალი გასაღები და კარგად ხარ.
  თუ ფიქრობთ, რომ გჭირდებათ ახალი ფაილის შექმნა, გთხოვთ, მიმართოთ მთარგმნელობით ჯგუფს.
• assets/common/
  ინახავს სხვადასხვა ფაილებს, რომლებიც საკმაოდ შეიცავს Content იდენტიფიკატორებს:
• assets/common/entity/**/*.ron იყენებს name: Translated-ს i18n კონტენტზე მითითებისთვის.
• assets/common/npc_names.ron იყენებს generic: <i18n-key> სახელების თარგმანების მისაღებად.
• assets/common/item_i18n_manifest.ron არის ასახვა ერთეულის def-დან მის თარგმანამდე.
• და ა.შ

საუკეთესო პრაქტიკა და რეკომენდაცია

კარგი, ამას თამამად დავწერ: ** შეინახე მარტივი **

თუ სხვა არაფერი გახსოვთ, დაიმახსოვრე ეს.
Fluent არის ძლიერი ფორმატი, რადგან ლოკალიზაცია რთულია. ჩვენ ** უნდა** მივაწოდოთ ყველაზე მარტივი ინტერფეისი მთარგმნელებთან და საკუთარი აბსტრაქციების დანერგვა და ხელახლა გამოსაყენებელი ნაწილების ზემოდან მოთხოვნილება იქნება გამოიწვიოს შეცდომები.

ეს ეწინააღმდეგება პროგრამირების ტრადიციულ წესებს, სადაც ჩვენ ვცდილობთ დავწეროთ რაც შეიძლება ნაკლები კოდი და შეძლებისდაგვარად ხელახლა გამოყენება, მაგრამ ეს არ მუშაობს თარგმანებზე, რადგან ზუსტად არ ვიცით რა ხელახლა გამოსაყენებლად.

ნუ აერთიანებთ

ფლუენტის დოკუმენტების მითითება.

# ❌ Avoid splitting messages.
reaction-thumbs-up = thumbs up
reaction-smiley-face = smiley face
reacted-with = { $user_name } has reacted with a { $reaction_type }.

ეს ინგლისურად სწორ შეტყობინებას ჰგავს, მაგრამ ის შეიძლება სწრაფად დაიშალა. რა მოხდება, თუ დაამატებთ რეაქციას „თვალის გახვევაზე“, რომელიც უნდა დაიწყოს an-ით და არა a-ით?

ასეთი სიტუაციების თავიდან აცილების მიზნით, აქ არის პირველი წესი თქვენთვის: არ შეერთოთ

იგივე შეიძლება გადაიწეროს შემდეგნაირად.

# ✅ Redundancy helps localizers understand each message in full.
reacted-with-thumbs-up = { $user_name } has reacted with a thumbs up.
reacted-with-smiley-face = { $user_name } has reacted with a smiley face.
reacted-with-eye-roll = { $user-name } has reacted with an eye-roll.

ამ წესიდან არის გამონაკლისები. თუ სხვაგვარად გექნებოდათ სტრიქონების კომბინაციური რაოდენობა, იქნებით იძულებული გახდა გამოიყენოს შეერთება, მაგრამ გთხოვთ იყოთ ძალიან ფრთხილად და მიმართოთ მთარგმნელობით ჯგუფს.
და თუ თქვენ გჭირდებათ შეერთების გამოყენება, გახსენით შაბლონი, რათა მთარგმნელებს მაქსიმალური კონტროლი მისცეთ.

არ გამოიყენოთ სელექტორები ლოგიკისთვის

# ❌ Don't use selectors for logic
dialogue-buy_hire_days = { $days ->
    [1] A day
    [7] A week
    *[other] { $days } days
}

ოქროს წესი არის ის, რომ სელექტორების ყველა ვარიანტს ზუსტად იგივე მნიშვნელობა უნდა ჰქონდეს.
თუ გსურთ სადმე ლოგიკის ჩასმა, ჩადეთ ის თქვენს კოდში და დარეკეთ მარჯვენა კლავიშს.

# ✅ Uses attributes for logic, exposes selectors to handle plurals.
dialogue-buy_hire_days =
   .day = A day
   .week = A week
   .unknown = { $days ->
     [one] { $days } day
     *[other] { $days } days
    }

ყურადღება მიაქციე სქესს

ჩვენ ახლახან დავიწყეთ ამის გაკეთება, მაგრამ თუ ეს შესაძლებელია, შეეცადეთ მოგვაწოდოთ გენდერული სტრიქონი.

hud-chat-online_msg =
    { $user_gender ->
        [she] [{ $name }] si è connessa.
       *[he] [{ $name }] si è connesso.
    }

ამის კოდი დაახლოებით ასე გამოიყურება.

    // getting the string
    let gender_str = |uid: &Uid| {
        if let Some(pi) = info.player_info.get(uid) {
            match pi.character.as_ref().and_then(|c| c.gender) {
                Some(Gender::Feminine) => "she".to_owned(),
                Some(Gender::Masculine) => "he".to_owned(),
                _ => "??".to_owned(),
            }
        } else {
            "??".to_owned()
        }
    };
    // usage
    localization
        .get_msg_ctx("hud-chat-online_msg", &i18n::fluent_args! {
            "user_gender" => gender_str(uid),
            "name" => name_format(uid),
        })

მნიშვნელოვანი ბიტი არის player_info-ში, რომელიც შეიცავს character-ს, რომელიც შეიცავს სქესს. ამ დროისთვის ჩვენ მხოლოდ ორ სქესს ვუჭერთ მხარს, რაც სამწუხაროა, მაგრამ იმედია მალე გავაუმჯობესებთ.

მიეცით კარგი მაგალითი

თარჯიმნებს აქვთ ცოდნის განსხვავებული დონე, ამიტომ შეეცადეთ შექმნათ რაიმე ზედმეტი ინგლისურ ვერსიებში.

# ❌ [one] doesn't mean *single* item
# ❌ Concatenation makes it harder to see whole picture
hud-trade-buy = Buy Price: { $coin_num ->
    [one] one coin
    *[other] { $coin_formatted } coins
}

მიუხედავად იმისა, რომ ისევ სწორი სტრიქონია, ყოველ შემთხვევაში, როდესაც საქმე ეხება ინგლისურს, მას აქვს გარკვეული პრობლემები.

# ✅ Uses [1] for exact match
# ✅ String isn't interrupted by selectors, always full.
hud-trade-buy = { $coin_num ->
    [1] Buy Price: one coin
    *[other] Buy Price: { $coin_formatted } coins
}

მაგალითად, უკრაინულ ენაზე თარგმნის სწორი გზა იქნება შემდეგი.

hud-trade-buy =
    { $coin_num ->
        [1] Ціна купівлі: одна монета
        [one] Ціна купівлі: { $coin_formatted } монета
        [few] Ціна купівлі: { $coin_formatted } монети
        [many] Ціна купівлі: { $coin_formatted } монет
       *[other] Ціна купівлі: { $coin_formatted } монет
    }

მაგრამ თუ ადამიანი, რომელსაც სრულად არ ესმის წესები, დააკოპირებს პირველ მაგალითს, ჩვენ შეგვიძლია მივიღოთ რაღაც მსგავსი

# ❌ 21 would mean [one] as well, while we assume [one] means 1 only
hud-trade-buy = { $coin_num ->
    [one] Ціна купівлі: 1 монета
    *[other] Ціна купівлі: { $coin_formatted } монет
}

და რადგან უკრაინულში რაღაცეები, როგორიცაა “21” მიჰყვება იგივე წესებს, რაც “1”, ის მიეკუთვნება კატეგორიას [one]-დან, ჩვენ მივიღებთ “შესყიდვის ფასს: 1 მონეტა”, რაც აშკარად არასწორია, რადგან, კარგად “21” არ არის “1”.

ასე რომ, გთხოვთ, გაითვალისწინოთ ეს ინგლისური სტრიქონების მოწოდებისას.

მაგალითები

GUI

ვთქვათ, გსურთ გამაფრთხილებელი შეტყობინების ინტერნაციონალიზაცია, როდესაც რაიმე აბსტრაქციაა აიძულებს ნივთების ჩამოგდებას.

თქვენ დაიწყებდით გამართულ ფაილში გასაღების დამატებით, assets/voxygen/i18n/en/hud/bag.ftl.

hud-bag-swap_slots_drop_items = { $slot_deficit ->
    [1] This will result in dropping 1 item on the ground. Are you sure?
    *[other] This will result in dropping { $slot_deficit } items on the ground. Are you sure?
}

შემდეგ იღებთ ფუნქციას, რომელიც მოელის სტრიქონს და იყენებთ LocalizationHandle::get_msg_ctx მასზე.

self.hud.set_prompt_dialog(PromptDialogSettings::new(
    global_state.i18n.read().get_msg_ctx(
            "hud-bag-use_slot_equip_drop_items",
            &i18n::fluent_args! {
                "slot_deficit" => slot_deficit.unsigned_abs(),
            })
        ),
    ),

p.s. თუ თქვენ მიიღებთ შეცდომებს მთელი ცხოვრების განმავლობაში, ეს არის Rust, ეს ხდება, ცეკვა სესხის შემმოწმებელთან არ არის მოცემული სახელმძღვანელო, შეიძლება ფერიის თქვენთან ერთად იყოს.

სერვერის შეტყობინება

კარგი, ეს არის ძალიან მარტივი ფუნქცია, მაგრამ ის საშუალებას გვაძლევს ვაჩვენოთ, როგორ გამოიყენებდით Content ტიპს.

fn handle_version(
    server: &mut Server,
    client: EcsEntity,
    _target: EcsEntity,
    _args: Vec<String>,
    _action: &ServerChatCommand,
) -> CmdResult<()> {
    server.notify_client(
        client,
        ServerGeneral::server_msg(
            ChatType::CommandInfo,
            Content::localized_with_args("command-version-current", [
                ("hash", (*common::util::GIT_HASH).to_owned()),
                ("date", (*common::util::GIT_DATE).to_owned()),
            ]),
        ),
    );
    Ok(())
}

ServerGeneral::server_msg ფუნქცია იღებს Content, რადგან ჩვენ გვჭირდება ლოკალიზაცია, მაგრამ ვერ გამოვიყენებთ LocalizationHandle-ს.
აქ ჩვენ ვიყენებთ Content::localized_with_args, რომელიც იღებს გასაღებს, რომლის ლოკალიზებაც გსურთ და არგუმენტების ჩამონათვალს (გასაღები, მნიშვნელობა).

და რა თქმა უნდა, თუ ჩვენ განვსაზღვრავთ ბრძანებას, ასევე უნდა მივცეთ აღწერა, რისთვისაც შეგიძლიათ გამოიყენოთ Content ასევე. ServerChatCommand::data() ფუნქციის სიღრმეში თქვენ უნდა დაამატოთ ეს.

            ServerChatCommand::Version => {
                cmd(vec![], Content::localized("command-version-desc"), None)
            },

ბრძანებების უმეტესობას აქვს უფრო რთული მონაცემები, მაგრამ /version ძალიან მარტივია, ჩვენ მხოლოდ მისი აღწერილობის განსაზღვრა გვჭირდება.
და რადგან მას არავითარი კონტექსტი არ სჭირდება, ჩვენ შეგვიძლია უბრალოდ გამოვიყენოთ Content::localized და არა Content::localized_with_args.

დაბოლოს, რაც არანაკლებ მნიშვნელოვანია, არ დაგავიწყდეთ ორივე სტრიქონის დამატება assets/voxygen/i18n/en/command.ftl-ში.

command-version-desc = Prints server version
command-version-current = Server is running { $hash }[{ $date }]

დასკვნა

სულ ესაა. ვეცადე ყველაფერი დამეფარა, მაგრამ რაღაცეები გამომრჩა ალბათ, ასე რომ არ მოგერიდოს კითხვა.
ზოგადად, MR-ის გაკეთებამდე, კატეგორიულად გირჩევთ, დაუკავშირდეთ ვინმეს და * ისაუბროთ*.
ამასთან დაკავშირებით, დოკუმენტაციის დაწერა რთულია და დახმარება ყოველთვის დასაფასებელია. თუ რამეა გაუგებარია, თქვენ შეგიძლიათ გააუმჯობესოთ იგი. თქვენ არ გჭირდებათ ყველაფერი იცოდეთ, რომ დაგეხმაროთ, უბრალოდ უნდა იყოთ მოთმინება.

თამაშის დიზაინერებისთვის

მშენებარე მონაკვეთი. ფრთხილად იყავი.

• დაწერეთ წინადადება

წინადადების დაწერა @Silentium-ის მიერ

პირველი, რაც უნდა გვახსოვდეს დიზაინის წინადადების წერისას არის ის, რომ ნებისმიერი იდეა შესაძლოა თამაშში არ მოხვდეს დიზაინერების გუნდის კონსენსუსის გამო. სამწუხაროდ, ჩვენ არ შეგვიძლია ყველა იდეის ჩართვა, მაგრამ გარკვეული კომპრომისებით და გარკვეული შემოქმედებითი აზროვნებით, ჩვენ ჩვეულებრივ შეგვიძლია გამოვყოთ იდეის მნიშვნელოვანი ასპექტები. იდეებსაც კი, რომლებიც არ გამოიყენება სრულ მდგომარეობაში, მაინც შეუძლიათ თამაშის დიზაინის სხვა ასპექტების ძალიან მნიშვნელოვანი ხედვა, ასე რომ არ იფიქროთ, რომ გამოუყენებელი იდეა არასწორია. ყველა იდეა სასარგებლოა, უბრალოდ, შესაძლოა, არა ისე, როგორც იყო განკუთვნილი. რაც მეტი მით უკეთესი.

მეორე, რაც უნდა გვესმოდეს, არის ის, რომ წინადადება არ უნდა იყოს ძალიან დეტალური. მიზანია შეასრულოს მინიმალური სამუშაო იდეის ფუნდამენტური პრინციპებისა და მსჯელობის ეფექტური კომუნიკაციისთვის. ეს იმიტომ ხდება, რომ თუ იდეა არ არის კარგად მიღებული, ან თუ მას სჭირდება გადამუშავება ან ცვლილებები, ისინი შეიძლება განხორციელდეს წინადადების დასაწერად შესრულებული სამუშაოს დიდი ნაწილის დარღვევის გარეშე. თამაშის დიზაინის გუნდს შემოთავაზებული არცერთი იდეა არ გამოიყენება სიტყვასიტყვით.

მესამე რამ არის ღია იდეების შეცვლისთვის. როგორც უკვე აღვნიშნეთ, არცერთი იდეა არ გამოიყენება გარკვეული ცვლილებების განხორციელების გარეშე. სანამ წინადადების მიმწოდებელი ინახავს ღია გონებას იმის შესახებ, თუ რა შეიძლება შეიცვალოს, მათი იდეა ძალიან სასარგებლო იქნება თამაშის დიზაინისთვის. ეს ასევე ხელს უწყობს ჯანსაღი საუბრის საფუძველის შენარჩუნებას.

მეოთხე არის ყველა წინა დოკუმენტის წაკითხვა. თითქმის ყველაფერი, რასაც ამჟამად ვაკეთებთ, წინა სამუშაოზეა აგებული. ჩვენ გვაქვს ძალიან კონკრეტული თანმიმდევრობა, რომლითაც ვქმნით გეიმპლეის ელემენტებს და სისტემებს და ზოგიერთი მათგანი სხვებზე ადრე უნდა განიხილებოდეს. დარწმუნდით, რომ არ ვივარაუდოთ, რომ ჩვენ არ გვაქვს შემუშავებული თამაშის ელემენტი და დარწმუნდით, რომ ძალიან ღრმად არ წაიკითხავთ ჩვენს მიერ შემუშავებული სისტემის პოტენციურ შედეგებს. წინადადებები დაწერილია, რომ იყოს კონკრეტული, მათ შორის მხოლოდ ის, რაზეც ცალსახად არის გადაწყვეტილი. მის ფარგლებს გარეთ არსებული ნივთები შესაძლოა კვლავ ჰაერში იყოს.

ბოლო ის არის, რომ ყველაფერი ცვალებადია, თუნდაც ის, რაც უკვე დავწერეთ ჩვენს ოფიციალურ დოკუმენტაციაში. ამით, მე არ ვგულისხმობ, რომ ჩვენ მზად ვართ ხელახლა შევცვალოთ ყველაფერი. ჩვენ ძალიან ვამაყობთ იმ საქმით, რაც გავაკეთეთ და მირჩევნია არ გავაუქმოთ იგი. როგორც ითქვა, თუ ვინმე ფიქრობს, რომ არის პრობლემა ჩვენს მიერ შემუშავებულ სისტემასთან ან ჩვენ მიერ გაკეთებული ფუნდამენტური ფატალური დიზაინის არჩევანით, ჩვენ მზად ვართ მოვისმინოთ კრიტიკის შესახებ. არა მხოლოდ ეს, არამედ ჩვენ სრულად ველით, რომ ზოგიერთი სისტემა არ იქნება სიცოცხლისუნარიანი, როდესაც დავიწყებთ playtesting-ს. ამის შედეგად, ჩვენ, სავარაუდოდ, მოგვიწევს ჩვენი ზოგიერთი სისტემის გადამუშავება და მეტი გამეორება.

ყოველ ჯერზე, როდესაც ვიწყებთ დიზაინის ახალ თემას, მე გავაკეთებ პოსტს, რათა გუნდის წევრებს მივცეთ თავიანთი იდეები ერთ დოკუმენტში. ჩვენ ყველა ვთანამშრომლობთ ამაზე, რათა საბოლოო წინადადება დასრულდეს, ამიტომ თვალი ადევნეთ მათ, ვინც #თამაშის დიზაინშია!

სანამ ვინმეს შეუძლია გაითვალისწინოს ეს პრინციპები, სანამ ისინი წერენ თავიანთ წინადადებას, ისინი ძალიან ეფექტური იქნებიან თავიანთი იდეების წვლილის შეტანაში თამაშის დიზაინის გუნდში. გთხოვთ, შემატყობინოთ, თუ გაქვთ რაიმე შეკითხვა ამ საკითხთან დაკავშირებით, ან თუ გჭირდებათ განმარტება. მე მიყვარს, როდესაც ადამიანები ინტერესდებიან ჩვენი საქმიანობით, ამიტომ გთხოვთ, ნუ მოგერიდებათ მომწერეთ!

გაიხარე ✨👍✨ @Silentium

მწერლების ლექსიკის ცენტრი

_ ხელოვნების სტილი, რომლის ნახვაც ღირს.

• წიგნის გაფართოება
• Write Lore

წვლილი შეიტანეთ ამ წიგნში

თქვენ შეგიძლიათ იპოვოთ ამ წიგნის წყარო ჩვენს [GitLab]-ში (https://gitlab.com/veloren/book), შეიტანეთ ცვლილებები, შეასწორეთ შეცდომები და დაამატეთ მეტი კონტენტი.

საერთო ელემენტები

თანმიმდევრულობა არის მთავარი. მაშასადამე, აქ მოცემულია წიგნში გამოყენებული საერთო ელემენტები და როგორ უნდა იყოს მათი სტილი:

შინაარსი

** შენიშვნა: ** _ მონიშნეთ მნიშვნელოვანი შენიშვნა, რომელიც მკითხველმა უნდა გაითვალისწინოს._

მოკლე აღწერა გამოცდილი ადამიანებისთვის

უფრო დეტალური აღწერა დამწყებთათვის და ახალბედებისთვის.

გამოიყენეთ <br/> ხაზების გარღვევისთვის.

Rust სინტაქსის ხაზგასმა კარგად მუშაობს .ron ფაილებზე. (გამოიყენეთ rust,ignore, რათა თავიდან აიცილოთ მათი გაშვება)

Brown: (
    vox_spec: ("armor.chest.grayscale", (-7.0, -3.5, 2.0)),
    color: Some((90, 49, 43))
),

შინაარსი
** რჩევა:** შენიშვნა, რომელიც დაგეხმარებათ დროისა და ძალისხმევის შემცირებაში.

DevOps ავტომატური შესავალი

მშენებარე მონაკვეთი. ფრთხილად იყავი.

• CI runner-ის მიწოდება

მიაწოდეთ CI მორბენალი

ჩვენ უნდა გავუმასპინძლოთ ჩვენს საკუთარ CI მორბენალებს, თუ თქვენ გაქვთ სათადარიგო კომპიუტერი ან სერვერი და გაქვთ თავისუფალი დრო Veloren-ისთვის, ეს ძალიან დაგვეხმარება.

რა არის CI?

უწყვეტი ინტეგრაცია (CI) არის ავტომატური ტესტებისა და ამოცანების ნაკრები, რომელიც მუშაობს GitLab-ის რეპოზე ყოველ ჯერზე კოდის დამატებისას. ეს ნიშნავს, რომ შერწყმის მოთხოვნებს აქვს კოდების ბაზის დარღვევის ნაკლები შანსი და ჩვენ შეგვიძლია ავტომატურად მივიღოთ შემოტანილი კოდის კონსტრუქციები, სხვა უპირატესობებთან ერთად.

ჩვენ გვჭირდება თქვენი კომპიუტერი, რომელიც დაგვეხმარება ტესტირებაში. CI-ის გაშვება უფასო არ არის, ამიტომ ჩვენ ვიყენებთ საკუთარ კომპიუტერებს ამისათვის.

ტექნოლოგია

ჩვენ ვიყენებთ GitLab runner-ებს Docker-თან ერთად.

მოთხოვნები

• = 2 CPU ბირთვი. ჩვენ არ ვიწვევთ მუდმივ 100% დატვირთვას, მაგრამ როდესაც კომპილაციაც კი მოდის, მეტი ბირთვი ეხმარება მათ სწრაფად დამუშავებას.

• 50 გიბაიტი თავისუფალი ადგილი HDD-ზე. Docker გამოსახულება შეიცავს ქეშს და არის დაახლოებით 20 გიბაიტი, დამატებით ქეშებს შეუძლიათ მეტი ადგილი დაიკავონ.

• = 1 მბიტ/წმ ინტერნეტი. თქვენ არ გჭირდებათ სწრაფი ინტერნეტი, მაგრამ მორბენალი დროდადრო დაუკავშირდება ინტერნეტს. უცვლელი განაკვეთი იდეალურია.

დააინსტალირეთ მორბენალი

უპირველეს ყოვლისა, თქვენ მოგიწევთ დაუკავშირდეთ შემსრულებელს GitLab runner ტოკენის მისაღებად. ამისათვის ან გაგზავნეთ @xMAC94x, ან @AngelOnFira. ჩვენ, ალბათ, დავრწმუნდებით, რომ თქვენ ცოტა ხანი იყავით პროექტთან, რადგან არ გვინდა ეს ნიშანი ვინმეს მივცეთ.

დაგჭირდებათ Docker-ის დაყენება, რადგან მას ყველა კონსტრუქცია იყენებს. შეგიძლიათ მიჰყვეთ ინსტრუქციას აქ,

• Linux
• Windows
• macOS

კლონირეთ ჩვენი Veloren CI repo და დაიწყეთ დამხმარე სკრიპტი runner დირექტორიადან

git clone https://gitlab.com/veloren/veloren-docker-ci
cd veloren-docker-ci/runner
./launch-runner.sh
# provide the token from above
# provide a name in the style: `<discord-username>-<descriptor>`. So for example, @angelonfira's might be `angelonfira-server-1`.

სკრიპტს დაახლოებით 10 წუთი დასჭირდება და როდესაც ის დასრულდება, Docker კონტეინერი იწყება ფონზე. მას მხოლოდ გადამამუშავებელი სიმძლავრე დასჭირდება, როცა შესასრულებელია Pipelines.

ამჟამად, სკრიპტი არის მხოლოდ Linux-ის, თუ თქვენ მართავთ Windows-ს, უმჯობესია შექმნათ Linux VM (მაგ. VirtualBox-ისა და Ubuntu Server 20.04-ის გამოყენებით)

განაახლეთ მორბენალი

ქეშების ეფექტურად გამოსაყენებლად, ჩვენ გვჭირდება მინიმუმ gitlab-runner v13.8.0. თუ თქვენი მორბენალი უფროსია, გთხოვთ, ხელახლა შექმენით მორბენალი, შეგიძლიათ გამოიყენოთ update-runner.sh სკრიპტი. გაითვალისწინეთ, რომ ის ინტერაქტიულია და საჭიროებს თქვენს შეყვანას

# 1. update repo veloren-docker-ci repo
git pull
# 2. go in runner folder
cd runner
# 3. execute update script
./update-runner.sh
# provide if you want to prune old images, choose yes except if you have certain images you want to keep or run other Docker containers
# provide the CONTAINER ID that reflects the old image
# see the Install section above for re-setting up the runner

როკ სტაბილური პროგრამული უზრუნველყოფის გამოშვება

შესავალი გამოშვების ნაბიჯები პროგრამული უზრუნველყოფის მიხედვით.

• თამაში
• Airshipper

გამოშვების ციკლი

ეს გვერდი მიზნად ისახავს Veloren-ის გამოშვების პროცესის დოკუმენტირებას. იგი თავდაპირველად აღწერს მიმოხილვას და აქვს უფრო დეტალური თავები ცალკეული ნაბიჯებისთვის.

ამოცანები

გამოშვებამდე 2 თვით ადრე

კვირას შეხვედრაზე:

1. შეაფასეთ გამოშვების თარიღი და აცნობეთ მას შიდა მხარეებს. თარიღი შეიძლება შეიცვალოს, სანამ ის მოგვიანებით გახდება ოფიციალური.
2. მოაგვარეთ შემდეგი პუნქტები:
3. გათავისუფლების წვეულების თემა.
4. ფუნქციები, რომლებიც უნდა განხორციელდეს გამოშვებით და ის, რაც სასიამოვნო იქნებოდა.
5. პარტიულ რუქაზე დანიშნული პირები.

• პარტიის რუკის დიზაინი.

4. გამოშვების თრეილერზე დანიშნული ხალხი.

• თრეილერის შინაარსი.

5. გამოშვების შესახებ ბლოგ პოსტის დაწერაზე დავალებული ადამიანები.
6. ფუნქციების გაყინვის პერიოდის მართვაზე დავალებული ადამიანები.
7. გამოშვების ბინარების შექმნასა და გამოცემაზე დავალებული ადამიანები.
8. ადამიანები, რომლებსაც ევალებათ გამოაცხადონ ჩვენი სოციალური მედიის ანგარიშებზე.
9. გათავისუფლების წვეულების განრიგი:

• აქტივობები პარტიისთვის.
• თითოეული აქტივობის ხანგრძლივობა.
• (თითოეულ) საქმიანობაზე პასუხისმგებელი პირები.

3. შექმენით ეტაპები GitLab-ზე, რათა თვალყური ადევნოთ გამოშვების პროგრესს.

გამოშვებამდე 1 თვით ადრე

კვირას შეხვედრაზე:

1. აირჩიეთ გამოშვების ოფიციალური თარიღი, როდესაც ხელმისაწვდომი იქნება ძირითადი დეველოპერები და შესაბამისი მიმდევრები.
2. შეაგროვეთ გამოხმაურება აქტივობებისა და თრეილერის შესახებ.
3. განიხილეთ რუკაზე პასუხისმგებელ ადამიანებთან:

• ამჟამად როგორია რუკა?
• რა გეგმები აქვთ რუკასთან დაკავშირებით?
• განრიგის დადგენა შეუძლიათ?

გამოშვებამდე 3 კვირით ადრე

გამოშვებამდე 2 კვირით ადრე

გამოშვებამდე 1 კვირით ადრე

გამოშვებამდე 8 საათით ადრე

კვირა გამოშვების შემდეგ

კვირას შეხვედრაზე:

• განიხილეთ, როგორ ჩაიარა გათავისუფლების წვეულებამ.
• რა კარგად გაკეთდა?
• უკეთესად რისი გაკეთება შეიძლებოდა?

დაგეგმეთ ბინარების გამოშვება

ამ განყოფილების ბრძანებების ნიმუში გაშვებული იქნება თამაშის 0.12.0 ვერსიისთვის. დაიმახსოვრე, რომ ეს ბრძანებები შეცვალოთ თქვენს მოქმედ ვერსიაზე.

1. დააკოპირეთ CHANGELOG.md-ზე.

• განაახლეთ მხოლოდ server, client, server-cli და voxygen ყუთები. სხვა ყუთებს აქვთ დამოუკიდებელი სემანტიკური ვერსია. მაგალითი MR

2. შექმენით გამოშვების ფილიალი master-დან:

    git checkout -b "r0.12"
    ```
3. შექმენით გამოშვების ტეგი:
```bash
    git tag -a "v0.12.0" -m "Version 0.12.0"
    ```
4. დააწკაპუნე გამოშვების ტეგი.
```bash
    git push --tag "v0.12.0"
    ```
5. შეამოწმეთ, რომ გათავისუფლების ტეგის მილსადენი წარმატებით შესრულდა.
- <https://gitlab.com/veloren/veloren/-/pipelines>
6. გააქტიურეთ დაგეგმილი მილსადენი.
- <https://gitlab.com/veloren/veloren/-/pipelines>
7. დარწმუნდით, რომ გათავისუფლების კონტეინერი აშენებულია.
- <https://gitlab.com/veloren/veloren/container_registry>
8. დაამატეთ ბმული ვებსაიტზე გამოშვებაზე.
- <https://veloren.net/download-other>
9. შექმენით გამოცემა GitLab-ზე.
10. დარწმუნდით, რომ გამოშვების ორობითი ფაილები დაკოპირებულია Wasabi-ში.

## სოციალური მედიის მოტყუების ფურცელი

| ვადები | მდებარეობა | შენიშვნები |
|-----------|----------|-------|
| T-1 კვირა | უთანხმოება | დაარეგისტრირეთ `@NewsPingSquad` და `@MediaPingSquad` როლები. |
| T-30 წთ | უთანხმოება | პინგით `@everyone` როლი. |
| T-8 საათი | Reddit | ქვერედიტი არის `r/veloren`. |
| T-8 საათი | მასტოდონი ||

## შაბლონები

### GitLab საეტაპო

```txt
# v0.xx Release

## People responsible
Blog post:
Trailer:
Map:
Feature freeze:
Release binaries:
Social media:

## Overview
Theme is: ``
Rough release day is: ``
Included features are:
-
Excluded features are:
-
Party schedule is:
- 18:00 UTC+00 start of party

## Checklist

Sunday meeting:
- [ ] Fixed release day is: `` *(T-1 month)*
- [ ] Map is approved by the core developers
- [ ] Activities are approved by core developers
- [ ] Trailer is approved by core developers

Blog:
- [ ] Release blog is prepared *(T-1 month)*
- [ ] Release blog is uploaded *(T-1 week)*

Trailer:
- [ ] Trailer is ready for review *(T-2 weeks)*
- [ ] Trailer is uploaded *(T-1 week)*

Map:
- [ ] Map is ready for review *(T-3 weeks)*
- [ ] Map is uploaded *(T-8 hours)*

Feature freeze:
- [ ] Freeze period is announced to public in #town-hall *(T-1 month)*
- [ ] Feature freeze is enforced *(T-1 week)*

Release binaries:
- [ ] Release binaries are produced, uploaded and verified *(T-8 hours)*

Social media:
- [ ] Posts are prepared *(T-1 month)*
- [ ] Posts are uploaded *(T-8 hours)*

ფუნქციის გაყინვის განცხადება

Hey @Contributor @DevPingSquad ,

**0.13 release is on Saturday, 2022-07-23 18:00 GMT**

As usual, there will be a **feature freeze** starting from 2022-07-16 18:00 GMT. We recommend submitting critical and large MRs for review now, before the feature freeze.

This release will also have a **stress test event** between the feature freeze and the release. We will be sharing further details of this later.

__Getting your large MR merged before feature freeze__
Please mention @xmac94x in the <#992383235332001942> thread with a short summary with the following details:

* What is complete.
* What needs to be done.
* Can your feature be partially introduced to master in its current state (as multiple MRs)?
* Do you foresee any issues with your MR and if so, which ones?
* Why should this feature be in 0.13?

This is required to align our testing and review strategies to ensure a smooth release.

**Schedule**
``
2022-07-16 18:00:00 GMT Feature freeze — No new feature MRs will be merged.
2022-07-18 18:00:00 GMT Stress test event.
2022-07-22 10:00:00 GMT Total freeze — no new merges will be introduced unless they're critical.
2022-07-22 16:00:00 GMT Release build will be compiled.
2022-07-23 12:00:00 GMT Main server hardware upgrade.
2022-07-23 18:00:00 GMT Release party!
``

გამოუშვით ახალი ვერსია

1. დააკოპირეთ CHANGELOG-ზე, განაახლეთ მხოლოდ ყუთები. მაგალითი MR
2. შექმენით გამოშვების ფილიალი master git checkout -b "r0.7"-ისგან
3. შექმენით გამოშვების ტეგი git tag -a "v0.7.0" -m "release 0.7.0"
4. დააწკაპუნე გამოშვების ტეგი git push --tag "v0.7.0"
5. დაადასტურეთ, რომ გაშვების ტეგის მილსადენი გადის: https://gitlab.com/veloren/airshipper/-/pipelines
6. დარწმუნდით, რომ გაშვების კონტეინერი აშენებულია: https://gitlab.com/veloren/airshipper/container_registry
7. დაადასტურეთ github/airshipper ქმედებები გამოშვების ორობითი ვერსიის შესაქმნელად
8. შექმენით გამოცემა GitHub-ზე
9. Ping @LunarEclipse#3307 AUR პაკეტის განახლებისთვის და ping @Frinksy#1694 Flathub ვერსიისთვის.

შეფუთვის მითითებები

ეს განყოფილება შეიცავს ინფორმაციას, რომელიც სასარგებლოა Veloren-ის ახალი პლატფორმებისთვის შეფუთვისას.

• თამაში

დამოუკიდებელი თამაშის შეფუთვა

Veloren-ის მიწოდების სასურველი მეთოდი ახლა არის Airshipper, მაგრამ აქ არის ინფორმაცია დამოუკიდებელი თამაშის შეფუთვის შესახებ.

** შენიშვნა: ** ეს დოკუმენტი ძირითადად ორიენტირებულია Veloren-ის შეფუთვაზე Linux-ისთვის, მაგრამ ზოგიერთი ინფორმაცია ასევე სასარგებლო იქნება სხვა პლატფორმებისთვის.

ზოგადი ინფორმაცია

გთხოვთ, მიმართოთ ამ სახელმძღვანელოს ზოგადი დაყენებისა და კომპილაციის ინსტრუქციებისთვის.

** რჩევა:** როგორც დამატებითი მითითება, იხილეთ veloren-git AUR პაკეტი, უფრო კონკრეტულად PKGBUILD ფაილი. მას ყოველთვის უნდა ჰქონდეს განახლებული buildtime და გაშვების დამოკიდებულების სია.

Rust ვერსია და Rustup

Nightly Rust-ის კონკრეტული ვერსია, რომლის შედგენაც იგეგმება Veloren-ის მოცემული ვერსიით, მითითებულია rust-toolchain ფაილში. თუ იყენებთ rustup-ს, ის ავტომატურად დააინსტალირებს და გამოიყენებს სწორ ვერსიას. წინააღმდეგ შემთხვევაში თქვენ უნდა დარწმუნდეთ, რომ თავად იყენებთ სწორს. Veloren ვერ შედგეს Stable Rust-ზე და ჩვენ ** არ ვუჭერთ მხარს მის შედგენას Rust ვერსიებით გარდა rust-toolchain ფაილში მითითებულისა.

კომპილაციის დროის პარამეტრები

• რეკომენდირებულია გამოიყენოთ --release დროშა, რათა მიღებული ბინარები სრულად იყოს ოპტიმიზირებული.
• იმისათვის, რომ თამაშმა გამოიყენოს სტანდარტული (XDG-თან თავსებადი) დირექტორიები მომხმარებლის მონაცემების შესანახად, ნაცვლად იმისა, რომ სცადოთ მისი შენახვა შესრულებადში, თქვენ უნდა დააყენოთ VELOREN_USERDATA_STRATEGY გარემოს ცვლადი system.
• კონკრეტული ბინარების შედგენისთვის, თქვენ უნდა გადასცეთ --bin <NAME> არგუმენტები.

თამაშის სერვერისა და კლიენტის შედგენის შედეგად მიღებული ბრძანება ზემოაღნიშნული პარამეტრების გამოყენებით იქნება: VELOREN_USERDATA_STRATEGY='system' cargo build --release --bin veloren-voxygen --bin veloren-server-cli ამ შემთხვევაში, ორობითი რიცხვები იქნება target/release/veloren-voxygen და target/release/veloren-server-cli.

სხვა ფაილები

• თქვენ უნდა შეიყვანოთ აქტივები თამაშის გასაშვებად. მათთვის მოსალოდნელი მდებარეობაა /usr/share/veloren/assets.

• აქტივების საქაღალდეში ჩვენ გთავაზობთ .desktop^[spec] ფაილს, ხატულას და .metainfo.xml^[spec] ფაილი. თქვენ უნდა მოათავსოთ ისინი შემდეგნაირად:

• assets/voxygen/net.veloren.veloren.png -> /usr/share/pixmaps/net.veloren.veloren.png

• assets/voxygen/net.veloren.veloren.desktop -> /usr/share/applications/net.veloren.veloren.desktop

• assets/voxygen/net.veloren.veloren.metainfo.xml -> /usr/share/metainfo/net.veloren.veloren.metainfo.xml

გიდები

წიგნის ეს განყოფილება მოგცემთ სახელმძღვანელოებს Veloren-ის საერთო ცვლილებებისთვის, როგორიცაა ახალი ჯავშნის დამატება.

• ჯავშნის დამატება
• მრავალი მოდელი ერთ ფაილში
• Sprites დამატება
• იარაღების დამატება
• const_tweaker-ის გამოყენება

გზამკვლევი: ველორენს ჯავშნის დამატება

\_ დამზადებულია @Pfau-ს მიერ

\_ განახლებულია @BottledByte-ის მიერ

რაც გჭირდებათ

თქვენი არჩევანის IDE (პროგრამა, რომელიც საშუალებას გაძლევთ ნახოთ და შეცვალოთ კოდი)

მაგალითები: VSCode, Atom, Notepad++

Voxel Editor (ჯავშნის მოდელის შესაქმნელად)

მაგალითი: Magicavoxel

სიმბოლო შაბლონი. (შეიძლება გაიხსნას ნებისმიერი voxel-რედაქტორით, რომელიც მხარს უჭერს ფენებს; მაგიკავოქსელი.)

ეს ასევე შედის Veloren კლიენტის აქტივებში.

დაწყება

ვოქსელის რედაქტორში თქვენი ჯავშნის შექმნამდე უნდა იცოდეთ რამდენიმე რამ:

იმისათვის, რომ „კანი“ (ნაწილები, რომლებიც არ არის დაფარული ჯავშნით) თქვენს სამუშაოზე, უნდა გამოიყენოთ ნებისმიერი ფერი, რომელიც ინახება თქვენი პალიტრის 1-ელ (ღია ტონალობა) და მე-5 (მუქი ტონალობაში) ჭრილში/ინდექსი.

შენიშვნა: მნიშვნელოვანია არა ფერი, არამედ პოზიცია პალიტრაზე სწორი შედეგის მისაღებად.

ჯავშანი ასევე შეიძლება იყოს ფერადი კოდში.

ამისათვის უბრალოდ გამოიყენეთ ნაცრისფერი ფერები თქვენს მოდელში. (მოგვიანებით შეისწავლით თუ როგორ გამოიყენოთ ფერები კოდით.)

კიდევ ერთი რამ, რაც შეიძლება შეამჩნიოთ, არის კისერი, რომელიც დაემატა მკერდის ჯავშანს. ეს საჭიროა იმისათვის, რომ თავი არ გამოჩნდეს მოწყვეტილი სხეულისგან, როდესაც ის მობრუნებულია.

მოდელის იმპორტი და თამაშში დამატება

იმისათვის, რომ თამაში რეალურად დატვირთოს თქვენი შემოქმედება, თქვენ უნდა შეასრულოთ რამდენიმე ნაბიჯი.

ისინი შეიძლება გაკეთდეს ნებისმიერი თანმიმდევრობით.

.vox-ის კოპირება აქტივების საქაღალდეში

დარწმუნდით ** თქვენი მოდელების ექსპორტზე .vox** სახით და არა მხოლოდ შენახული .vox ფაილის კოპირება magicavoxel-დან. უბრალოდ კოპირება გამოიწვევს ფაილის ზომას ~ 10-ჯერ.

ფაილის გზა აქტივების საქაღალდეში არის რაღაც მსგავსი

assets/voxygen/voxel/armor/<Armor Type>/<Model Name>

ასე რომ, მკერდის ჯავშნისთვის სახელწოდებით “leather_vest-0.vox” არის:

assets/voxygen/voxel/armor/chest/leather_vest-0.vox

სახელების სქემა .vox ფაილებისთვის

ცალკეული სიტყვები იყოფა ქვედა ხაზით („_“)

დათვლა იწყება ნულიდან.

რიცხვებს ემატება ერთი ტირე (“-”) მათ წინ.

თქვენი ნივთის სახელი ყოველთვის უნდა მთავრდებოდეს ნომრით, თუ არ ხართ აბსოლუტურად დადებითი, რომ არ იქნება ნივთის ალტერნატიული ვერსია/დიზაინი

ჩატვირთეთ ფაილი და შეინახეთ იგი კოდის შიგნით

ეს არის ფაილის ბილიკები, რომლებიც დაგჭირდებათ Veloren-ის root საქაღალდის გახსნის შემდეგ თქვენს IDE-ში:

assets/voxygen/voxel/humanoid_armor_<armour type>_manifest.ron

საჭიროა მხოლოდ ჯავშანტექნიკისთვის .vox ფაილებით

(ადგენს ფაილის გზას და ოფსეტებს .vox-ის)

assets/common/items/armor/<armour type>

(შექმენით ახალი .ron აქ, რომ შექმნათ თამაშში არსებული ელემენტი)

assets\voxygen\item_image_manifest.ron

(აქ შექმენით ახალი ჩანაწერი ნივთის სურათის დასამატებლად)

common/src/comp/inventory/item/armor.rs

** შენიშვნა: ** _ საჭიროა მხოლოდ ჯავშანტექნიკისთვის .vox ფაილებით_

(ჩამოთვალეთ თქვენი ახალი ჯავშნის სტილი აქ)

Veloren-ს აქვს 12 ტიპის ჯავშანი

**საქონლის ტიპებს ** სჭირდება 3D .vox ფაილი

• თავი
• კისერი (ყელსაბამები)
• ტაბარდი
• მხრები
• ** მკერდი **
• ხელი
• ფარანი
• ქამარი
• ბეჭედი
• ზურგი (კეპები, ზურგჩანთები…)
• ** ფეხები **
• ** ფეხები **

ჯავშნის ტიპები, რომლებსაც სჭირდებათ 3D .vox ფაილი, უნდა იყოს ჩამოთვლილი ყველა ზემოთ მოცემულ ფაილში.

მაგალითი ახალი კონცხის დასამატებლად

1. ახალი ჩანაწერი assets\voxygen\voxel\humanoid_armor_back_manifest.ron-ში

** ოფსეტი მოგვიანებით განისაზღვრება!** მხოლოდ თქვენი კოპირებული მაგალითიდან ციფრების შენახვა კარგი იქნება ახლა.

დააკოპირეთ ეს ნაწილი (დარწმუნდით, რომ შეიტანეთ ფრჩხილები და მძიმეები!) და ჩასვით:

შეავსეთ ** ელემენტის სტილის (სახის) სახელი.** ეს არის სახელი, რომელსაც მოგვიანებით გამოიყენებთ აქტივების შესატყვისად.

შენიშვნა: color: None მიუთითებს, რომ ნაცრისფერი ნაწილები არ შეიღებება.

ამ ნაწილების გასაფერადებლად ჩაწერეთ „color: Some((<R>, <G>, <B>))“ აქ.

ხელახლა შეღებილი ჯავშნის მაგალითი

"Brown": (
    vox_spec: ("armor.chest.grayscale", (-7.0, -3.5, 2.0)),
    color: Some((90, 49, 43))
),

2. ახალი ჩანაწერი assets/common/items/armor/<armour type>-ში

დააკოპირეთ და ჩასვით ერთ-ერთი არსებული .ron ფაილი (შენიშვნა: გამოიყენეთ ნომრები აქაც).

Item(
    name: "New Cape",
    description: "Example Item",
    kind: Armor(
        kind: Back("NewCape"),
        stats: (20),
    ),
)

შეცვალეთ ფაილი, რომ გქონდეთ სწორი kind. (იგივე ტიპი, რაც ადრე ჩადეთ.)

description ველი Item-ში ქმნის ამის მსგავს ტექსტს.

3. დაამატეთ ახალი ელემენტის სურათი assets\voxygen\item_image_manifest.ron-ში

თქვენ შეგიძლიათ გამოიყენოთ .png ან .vox ფაილი, როგორც ელემენტის გამოსახულება.

მაგალითი .png:

// Lanterns
Lantern("Black0"): Png(
    "element.icons.lantern_black-0",
),

მაგალითი .vox-ისთვის:

Armor(Back("Short0")): VoxTrans(
    "voxel.armor.back.short-0",
    (0.0, 0.0, 0.0), (-90.0, 180.0, 0.0), 1.0,
),

იმისათვის, რომ იპოვოთ სწორი პოზირებელი ნომრები .vox-ისთვის, ხშირად კარგი იდეაა მოძებნოთ მსგავსი ელემენტი.

Armor(Back("NewCape")): VoxTrans(
    "voxel.armor.back.new_cape-0",
    (0.0, 0.0, 0.0), (-90.0, 180.0, 0.0), 1.0,
),

თქვენ შეგიძლიათ გამოიყენოთ იგივე .vox, როგორც ფაქტობრივი 3D აქტივი, რომელიც ნაჩვენებია სიმბოლოზე მოგვიანებით.

4. იპოვნეთ სწორი კომპენსაცია თქვენი ნივთისთვის

იმისათვის, რომ შეამოწმოთ თქვენი ელემენტი თამაშში, თქვენ უნდა შეადგინოთ თქვენი თამაში ახლავე.

თქვენი ახალი ელემენტი ** ხელმისაწვდომი იქნება მხოლოდ ადგილობრივად**, ამიტომ დარწმუნდით, რომ დაუკავშირდით ადგილობრივ სერვერს ან აირჩიეთ „Singleplayer“.

ნივთის თქვენს ინვენტარში ჩასატანად გამოიყენეთ ჩატის ბრძანება /give_item:

/give_item common.items.armor.back.new_cape

თქვენი ახალი ნივთის აღჭურვისას თქვენ შეიძლება წარმოგიდგინოთ ეს სანახაობა.

სწორი ოფსეტურის დასაყენებლად საჭიროა ხელახლა ეწვიოთ ssets/voxygen/voxel/humanoid/<armour type>_manifest.ron

იქ არსებული მნიშვნელობები შეიძლება ცხელი ხელახლა ჩაიტვირთოს. ეს ნიშნავს, რომ მათი შენახვა დაუყოვნებლივ ამოქმედდება თამაშში.

"Admin": (
    vox_spec: ("armor.back.admin", (-5.0, -1.0, -0.0)),
    color: None
),

ისინი წარმოადგენენ კოორდინატებს:

(X, Y, Z)

X = მარცხნივ (შეამცირეთ რიცხვი) და მარჯვნივ (რიცხვის გაზრდა)
Y = უკან (შეამცირეთ რიცხვი) და მეოთხე (რიცხვის გაზრდა)
Z = ზევით (რაოდენობის გაზრდა) და ქვევით (რიცხვის შემცირება)

შეცვალეთ ნომრები, სანამ არ მიიღებთ სასურველ ოფსეტს.

შესრულებულია. თქვენ დაამატეთ ახალი ჯავშანტექნიკის სტილი და ელემენტი Veloren-ს. :)

მაგრამ იმ შემთხვევაში, თუ რამე არასწორედ წარიმართება, პრობლემების მოგვარების მცირე რჩევა

შეიძლება მოხდეს, რომ თქვენი ჯავშანი გამოჩნდეს როგორც დიდი ვარდისფერი ყუთი კითხვის ნიშნით (მსოფლიოში ან ინვენტარში).

თუ ეს მოხდება, ზოგიერთი ჩანაწერი არასწორია, სავარაუდოდ თქვენს სტილში შეცდომის გამო (მაგალითად, “NewCape”) ან აქტივების ერთ-ერთი გზა. იხილეთ ჟურნალი დეტალებისთვის, რათა მიუთითოთ წყარო.

თუ თქვენი ჯავშნის ჩატვირთვისას თამაში პანიკაშია, ეს ძირითადად სინტაქსის ნიშნავს .ron ფაილში ერთი ან მეტი ჩანაწერი გაფუჭდა (როგორც გამოტოვებული ფრჩხილები ან ციტატები).

გზამკვლევი: რამდენიმე მოდელის გამოყენება ერთ VOX ფაილში

\_ დამზადებულია @Christof-ის მიერ

შესავალი

ეს თავი ვარაუდობს, რომ თქვენ წაიკითხეთ თავი ჯავშნის დამატება და დაგეხმარებათ, როგორ შეინახოთ ყველა ნაწილი ერთი ჯავშანი, რომელიც დამონტაჟებულია ერთ VOX ფაილში. ამის გამოყენებით უფრო ადვილია დანახვა და შეცვალეთ დაკავშირებული მოდელები MagicaVoxel-ის ერთ ინსტანციაში.

მოდელების გაერთიანება მრავალი ფაილიდან

ფილიალის სიმბოლო კონტურის პანელში ხსნის მენიუს მრავალ მოდელზე მუშაობისთვის. პლუს სიმბოლო ქმნის ახალს, ორმაგი დაწკაპუნებით ირჩევს სხვას. მარჯვენა დაწკაპუნება საშუალებას გაძლევთ შეცვალოთ სახელი. მხოლოდ ყვითლად დაბეჭდილი აქტიური მოდელი იქნება რედაქტირებული, ჩასმული და ა.შ.

ჯავშანტექნიკის ნაკრებიდან ერთი ფაილის შესაქმნელად, შეგიძლიათ დააკოპიროთ მოდელები ერთიდან ფაილი და შემდეგ ჩასვით სხვაში. ერთ დროს. დაიმახსოვრე ჯერ შექმნა ახალი მოდელის ჩანაწერი სიის ხედში და აირჩიეთ იგი ვოქსელების ჩასმამდე.

მთავარ რედაქტორში ზევით/ქვემოთ ისარი ზედა მარჯვნივ (აქ ღია ცისფერი) გადართავს შორის სამყარო და ვოქსელის რედაქტირება. მოდელების სხვასთან შედარებით გადატანა მსოფლიო რეჟიმში და გაიყვანეთ მიმდინარე შერჩევის ისრები.

გენერირებული ფაილების ზომის შესამცირებლად ჩვენ სამწუხაროდ არ შეგვიძლია ექსპორტის გამოყენება რამდენიმე მოდელით, მაგრამ ჩვენ შეგვიძლია გამორთოთ არასავალდებულო ნაწილები და შევინახოთ შემდეგ:

მოდელის ინდექსის დაზუსტება მანიფესტებში

ისევ ისე, როგორც ჯავშნის დამატებაში, თქვენ ამატებთ ჩანაწერს assets/voxygen/voxel/humanoid_armor_<armour type>_manifest.ron თითოეულისთვის ჯავშანტექნიკის ნაწილები:

#![allow(unused)]
fn main() {
"common.items.armor.mail.orichalcum.belt":(
    vox_spec: ("armor.mail.orichalcum", (-4.0, -3.5, 1.0), 2),
    color: None
),
}

ბოლო (ინტეგრალი) რიცხვი მეორე სტრიქონში არის მოდელის ინდექსი, თუ ნომერი არ არის, გამოყენებულია ფაილში პირველი მოდელი. გაითვალისწინეთ, რომ პირველი ფაილში მოდელს აქვს ნომერი ნული.

და assets\voxygen\item_image_manifest.ron-ში:

#![allow(unused)]
fn main() {
Simple("common.items.armor.mail.orichalcum.belt"): VoxTrans(
    "voxel.armor.mail.orichalcum",
    (0.0, 0.0, 0.0), (-120.0, 210.0,15.0), 0.9, 2,
),
}

ისევ, ბოლო (სურვილისამებრ) რიცხვია მოდელის ინდექსი, დაწყებული ნულიდან.

გზამკვლევი: ველორენში სპრიტების დამატება

\_ დამზადებულია @Pfau-ს მიერ

რაც გჭირდებათ

• თქვენი არჩევანის IDE (პროგრამა, რომელიც საშუალებას გაძლევთ ნახოთ და შეცვალოთ კოდი)

მაგალითები: VSC, Atom, Notepad++

• Voxel Editor (სპრაიტის მოდელის შესაქმნელად)

მაგალითი: Magicavoxel

• სახელმძღვანელო იმის შესახებ, თუ როგორ უნდა შეადგინოთ და გაუშვათ Veloren თქვენს OS-ზე.

• Veloren’s-ის ღამის ვერსია ადგილობრივად კლონირებული ფილიალი.

დაწყება

სანამ შექმნით თქვენს სპრიტებს, რამდენიმე რამ უნდა იცოდეთ:

• სპრაიტები მოქმედებენ როგორც ლანდშაფტის ზომის ბლოკები, რომლებიც იცვლება მცირე ზომის მოდელებით.
  მათი დაყენება შესაძლებელია ჰაერის მსგავსად (შეჯახების გარეშე) ან მყარ ობიექტებად.

• ბალახის მსგავს ნივთებს არ უნდა ჰქონდეს შეჯახება. მიუხედავად იმისა, რომ საშინელებები და ფანჯრები უნდა.

• ამ დროისთვის ისინი ყოველთვის იმოქმედებენ როგორც ერთი რიგის სამი ლანდშაფტის ბლოკი (33 მცირე მასშტაბის ვოქსელი) ერთმანეთზე ზემოთ. ეს ნიშნავს, რომ თქვენ შეგიძლიათ აკონტროლოთ თქვენი სპრაიტის შეჯახების სიმაღლე, მაგრამ არა სიგანე.
  სპრაიტის ყველა ნაწილი, რომელიც აღემატება ერთი ბლოკის x და y ღერძის საზღვრებს, არ იკვრება ფიგურებთან და ობიექტებთან.

• Sprites მოქმედებენ როგორც უძრავი ობიექტები, როგორიცაა ბლოკები. მათი გადაადგილება შეუძლებელია, როგორც ფიგურები ან საგნები.
  

• Sprites შეიძლება დაყენდეს ისე, რომ მოთამაშეებს მისცეს გარკვეული ნივთი, როდესაც აიღებენ.
  

• სპრაიტებს შეიძლება ჰქონდეთ ქვირითობისა და ორიენტაციის გარკვეული წესები.

დასახელების სქემა .vox ფაილებისთვის

• ცალკეული სიტყვები იყოფა ქვედა ხაზით (_)
• დათვლა იწყება ნულიდან.
• რიცხვებს ემატება ერთი ტირე (-) მათ წინ.
• თქვენი მოდელის სახელი ყოველთვის უნდა მთავრდებოდეს ნომრით, გარდა იმ შემთხვევისა, როდესაც აბსოლუტურად დადებითი არ ხართ, რომ არ იქნება ნივთის ალტერნატიული ვერსია/დიზაინი

მოდელის იმპორტი და დაამატეთ კოდის ბაზაში

assets/voxygen/voxel/sprite_manifest.ron

აქ თქვენ განსაზღვრავთ რამდენი ვარიაცია შეიძლება ჰქონდეს თქვენს სპრაიტს, რამდენად ირხევა ის ქარში და რომელი მოდელი(ები) ჩაიტვირთოს აქტივების საქაღალდეებიდან.

common/src/terrain/sprite.rs

აქ თქვენ განსაზღვრავთ სპრაიტების თვისებებს, როგორიცაა შეჯახება, ორიენტაცია, მათი “შეჯახების ჩარჩოს” სიმაღლე ან მათი შეგროვება.

ეტაპობრივად: მაგალითის სპრაიტის დამატება

1. **ვოქსელის მოდელის დამატება **

assets/voxygen/voxel/sprite_manifest.ron-ში დააკოპირეთ და ჩასვით კოდის ერთ-ერთი ბლოკი, მაგ.:

        Window1: Some((
          variations: [
              (
                  model: "voxygen.voxel.sprite.window.window-0",
                  offset: (-5.5, -5.5, 0.0),
                  lod_axes: (1.0, 1.0, 1.0),
              ),
          ],
          wind_sway: 0.0,
        )),
      ```

... და დააყენეთ იგი ფაილის ბოლო ჩანაწერის უკან, დარწმუნდით, რომ დატოვეთ ბოლო `)` ფაილის ბოლოს.
შეცვალეთ ობიექტის სახელი (მაგ., `Window1`), იმ სახელით, რომელიც გსურთ დაარქვათ თქვენს ობიექტს (სახელში ინტერვალი არ არის).

შემდეგ დაამატეთ თქვენი .vox მოდელი `assets/voxygen/voxel/sprite/`-ში, ან შესაბამის ქვესაქაღალდეში ან შექმენით ახალი საქაღალდე, თუ ის სხვაგან არ ჯდება. მაგალითად, თუ თქვენი სპრაიტი ავეჯის ნაწილია, დაამატეთ ის `furniture` ქვესაქაღალდეში. მიჰყევით ამ გვერდზე ადრე ნახსენები .vox ფაილების დასახელების სქემას.

ახალ კოდბლოკში, რომელიც ჩასვით, შეცვალეთ `model` განყოფილება, რათა მიუთითოთ თქვენს .vox ფაილზე; დარწმუნდით, რომ შეინახეთ ორმაგი ბრჭყალები და მძიმები ბოლოს. ზემოთ მოცემულ მაგალითში, ფაილი `window-0.vox` დაემატა `window` ქვესაქაღალდეს და მოდელი განისაზღვრა როგორც `"voxygen.voxel.sprite.window.window-0",`
  
შემდეგი, მოდელის ცენტრი წერტილი უნდა განისაზღვროს `offset` განყოფილებაში. თქვენს voxel რედაქტორში დააყენეთ სამუშაო სივრცე თქვენს მოდელზე. თუ იყენებთ MagicaVoxel-ს, ამისათვის დააჭირეთ ღილაკს "მორგებული მოდელის ზომა". სამუშაო სივრცე შემცირდება, რათა მოერგოს თქვენს მოდელს. ცენტრის წერტილი არის x და y ღერძების ბლოკების რაოდენობის ნახევარი. მაგალითად, Windows1 კოდბლოკში ზემოთ, მოდელი არის 11 x 11 ბლოკი. ასე რომ, ჩვენ შევიყვანეთ `-5.5, -5.5` x-ღერძისთვის და y-ღერძისთვის, შესაბამისად. დააყენეთ z-ღერძი `0.0`-ზე, თუ მოდელი არ არის ჩაძირული მიწაში (მაგ., მადანი).

`lod_axes` ეხება ობიექტის დეტალების დონეს რაც უფრო შორს არის იგი მოთამაშისგან. დეტალების დონის შემცირება, როდესაც ობიექტი შორს არის, ეხმარება თამაშის შესრულებას. ეს პარამეტრი ეუბნება თამაშს, როგორ გააფართოვოს დეტალების შემცირების დონე სამივე ღერძზე (x, y, z). ამ დროისთვის, უბრალოდ გამოიყენეთ 1.0 სამივე ღერძისთვის, როგორიცაა Windows1 ზემოთ მოყვანილი მაგალითი, ან იპოვეთ თქვენი მსგავსი ობიექტი და დააკოპირეთ მისი lod_axes მნიშვნელობები.

თუ თქვენი სპრაიტი შექმნილია ქარში რხევისთვის (მაგ., ბალახი ან ყვავილები), შეცვალეთ `wind_sway` რიცხვი 0.0-დან 1.0-მდე. რაც უფრო მაღალია ეს რიცხვი მით უფრო ირხევა. გადახედეთ ზოგიერთ სხვა ობიექტს, რომ მიიღოთ წარმოდგენა იმის შესახებ, თუ რა მნიშვნელობა უნდა გამოიყენოთ.

2. **თამაშს უთხარით, რომ სპრაიტი არსებობს და გახადოთ ის მყარი **

`common/src/terrain/sprite.rs`-ში

ფაილის დასაწყისთან ახლოს, მოძებნეთ ობიექტების გრძელი სია ყოველი ობიექტის შემდეგ თექვსმეტობითი რიცხვით (მაგ., 0x0A). ამ სიაში ობიექტების სახელი ემთხვევა წინა საფეხურზე მოცემულ სახელს. მაგალითად, წინა ეტაპზე ჩვენ ვუყურებდით `Window1`-ს. ობიექტების სიაში აქ ვიპოვით `Window1 = 0x28,`.

თქვენი ობიექტის ამ სიაში დასამატებლად გადადით ქვემოთ ამ სიის ბოლოში (ის საკმაოდ გრძელია). სიის **END**-ზე დაამატეთ თქვენი ობიექტის სახელი და მიეცით მას შემდეგი თექვსმეტობითი რიცხვის მნიშვნელობა თანმიმდევრობით.

> _ რჩევა: თექვსმეტობითი რიცხვები მერყეობს 0-დან 15-მდე, მაგრამ ორნიშნა რიცხვები წარმოდგენილია ასოებით: 0 1 2 3 4 5 6 7 8 9 A B C D E F. დააკვირდით, როგორ არის 10 სინამდვილეში A, 11 არის B და ა.შ. ასე რომ, თუ სიაში ბოლო ობიექტს აქვს 0xB9 მნიშვნელობა, შემდეგი ობიექტი უნდა იყოს 0xBA. (0xB9 + 1 = 0xBA). თუ დახმარება გჭირდებათ, შეგიძლიათ ჩაწეროთ `0xB9 + 1` Google-ში და ის გეტყვით პასუხს._

შემდეგი, თუ თქვენი სპრაიტი მყარია და მოთამაშეები მას უნდა შეეჯახონ, თქვენ უნდა დაამატოთ ის ფუნქციას სახელად `pub fn solid_height`. მოძებნეთ ეს ფუნქცია `sprite.rs` ფაილში. ეს ფუნქცია ეუბნება თამაშს, თუ რა სიმაღლის უნდა იყოს ობიექტის შეჯახების ყუთი. თქვენ შეგიძლიათ გამოტოვოთ ეს, თუ თქვენი სპრაიტი არ არის გამიზნული, რომ შეჯახება მოხდეს და მოთამაშეებმა უნდა გადაადგილდნენ მასში (მაგალითად, ბალახი და ყვავილები).

ფუნქციის ფარგლებში ნახავთ ობიექტების გრძელ სიას, რომელიც ასე გამოიყურება: `SpriteKind::Tomato => 1.65,`. გადადით ამ სიის ბოლოში და დაამატეთ თქვენი სპრაიტი ბოლოს. თქვენ უნდა გამოთვალოთ რა რიცხვის მნიშვნელობა უნდა მივანიჭოთ თქვენს სპრაიტს. ეს რიცხვი უბრალოდ არის თქვენი სპრაიტის სიმაღლე ვოქსელებში გაყოფილი 11-ზე. მაგალითად, თუ თქვენი ვოქსელის მოდელი არის 18 ვოქსელი სიმაღლის, გაანგარიშება არის 18/11 = 1.64. თქვენ შეგიძლიათ იპოვოთ თქვენი მოდელის სიმაღლე ვოქსელის რედაქტორში გადასვლით და ბლოკების რაოდენობის დათვლით.

_შენიშვნა: 3.0 არის მაქსიმალური მნიშვნელობა, რომელიც შეიძლება მოხვდეს ამ სიაში. თუ წინა საფეხურზე განისაზღვრა სპრაიტის მრავალი ვარიაცია, ისინი ყველა იზიარებენ ერთსა და იმავე სიმაღლეს._

ბოლოს, `pub fn has_ori` ფუნქციაში დაამატეთ თქვენი სპრაიტი სიის ბოლოს. მიჰყევით უკვე არსებულ მაგალითებს და არ დაივიწყოთ `|` დასაწყისში (მაგ., `| SpriteKind::Window1`). ამ ფუნქციაში თქვენი სპრაიტის დამატება საშუალებას მისცემს მას შემობრუნდეს (ორიენტირებული) კოდით, როდესაც ის მსოფლიოში ჩნდება.

3. **სხვა თვისებები სპრაიტისთვის**

გარდა იმისა, რომ მყარია, სპრაიტები ასევე შეიძლება იყოს კოლექციური ან დასამუშავებელი.

საკოლექციო სპრაიტი შეიძლება აიღოს სამყაროდან მოთამაშის მიერ (მაგ. ქვები). ან შეიძლება მოთამაშემ გახსნას მისგან ამოღებული ნივთით (მაგ., ზარდახშა).

მოპოვებადი სპრაიტი საჭიროებს მაინინგის ხელსაწყოს შეგროვებამდე (მაგ., მადანი).

ნაბიჯები, რომლებიც საჭიროა სპრაიტების კოლექციური ან დამუშავების გასაკეთებლად, ზედმეტად ჩართულია ამ გვერდისთვის და საჭიროა ცალკე სახელმძღვანელოში განხილვა.

თუმცა, მათთვის, ვისაც სურს ჩასწვდეს კოდს და თავად გაარკვიოს, აქ არის რამდენიმე მითითება, რომ დაიწყოთ.

- დაამატეთ სპრაიტი `pub fn collectible_id`-ში `common/src/terrain/sprite.rs`-ში.
- თუ სპრაიტი საჭიროებს მაინინგს, დაამატეთ იგი `pub fn mine_tool`-ში `common/src/terrain/sprite.rs`-ში.
- თუ თქვენი სპრაიტი გამიზნულია გასახსნელად და მოთამაშეს მისცემს ნივთს, მიჰყევით კოლოფებისა და ზარდახშების მაგალითებს `common/src/terrain/sprite.rs`-ში. ეს მოიცავს .ron ფაილის შექმნას `assets/common/loot_tables`-ში.
- თუ თქვენი სპრაიტი უნდა შეგროვდეს და მოხვდება მოთამაშის ინვენტარში:
- შექმენით .ron ფაილი თქვენი კოლექციური სპრაიტისთვის `assets/common/items`-ის ქვესაქაღალდეში და გამოიყენეთ მაგალითი, რომელიც ყველაზე მეტად ემთხვევა იმას, რასაც აკეთებს თქვენი სპრაიტი (მაგ., საკვები).
- დაამატეთ თქვენი ნივთი `assets/voxygen/item_image_manifest.ron`-ში. თქვენ ასევე დაგჭირდებათ თქვენი voxel მოდელის ფაილის ასლის დამატება სხვა საქაღალდეში, რომელიც განსაზღვრულია ამ მანიფესტში. იპოვეთ ნივთი, რომელიც ყველაზე მეტად ჰგავს თქვენსას და გამოიყენეთ იგი, როგორც მაგალითი.
- დაამატეთ თქვენი ელემენტი `assets/voxygen/voxel/item_drop_manifest.ron` შესაბამის განყოფილებაში მსგავსი ელემენტებით.
- დაამატეთ თქვენი ელემენტი `common/src/states/sprite_interact.rs` სექციაში `fn from(sprite_kind: SpriteKind) -> Self`.

# სპრაიტების დამზადება მსოფლიოში

Sprites ჩნდება სამყაროში კოდის საშუალებით, ვიდრე ხელით განთავსდეს. ეს ნიშნავს, რომ იმისათვის, რომ თქვენი ახალი სპრაიტი იქცეს იქ, სადაც აპირებთ (მაგ., სახლში, მინდორში, დუნდულში და ა.შ.), თქვენ უნდა შეგეძლოთ კოდის შეცვლა.

მაგრამ... თუ თქვენ ეძებთ სწრაფ გზას, რომ ნახოთ, როგორ გამოიყურება თქვენი სპრაიტი თამაშში, კოდირების გარეშე, არსებობს უფრო მარტივი გზა, რომ გაოცდეთ თქვენი ხელებით. ეს სასარგებლოა იმის შესამოწმებლად, არის თუ არა თქვენი სპრაიტი სწორი ზომის, მაგალითად.

- თქვენ უნდა შეადგინოთ კოდი, რომელიც აქამდე დაწერეთ ზემოთ მოცემულ ნაბიჯებში. არის სახელმძღვანელოს [სხვა ნაწილები](/contributors/compiling.md), რომლებიც განმარტავს, თუ როგორ უნდა გააკეთოთ ეს, მაგრამ არსებითად თქვენ აკრიფეთ: `cargo run`
- _რჩევა: ნუ გაგიკვირდებათ, თუ თქვენი კომპილი შეცდომით ვერ მოხერხდა, ეს ჩვეულებრივ მხოლოდ ბეჭდვითი შეცდომაა. დააკვირდით თქვენს მიერ დაწერილ კოდს, ნახეთ, არის თუ არა აშკარა შეცდომები და საჭიროების შემთხვევაში გაიმეორეთ ზემოთ მოცემული ნაბიჯები_.
- იპოვნეთ და დაიმახსოვრეთ სპრაიტის სახელი, რომელიც თქვენ შექმენით 1-ელ საფეხურზე ზემოთ. ჩვენ ვიყენებდით `Window1` როგორც მაგალითად.
- როგორც კი თქვენი ადგილობრივი ასლი შედგენილია და გაშვებულია, დაიწყეთ ერთი მოთამაშის თამაში.
- თამაშში აკრიფეთ: `/make_sprite YourSpriteName` ჩაანაცვლეთ სიტყვა "YourSpriteName" თქვენი სპრაიტის სახელით 1-ლი ნაბიჯით.
- მაგალითი: `/make_sprite Window1`
- შენი სპრაიტი გაჩნდება იქ, სადაც შენი პერსონაჟი დგას. ჰუზა!

თუ გსურთ გადახვიდეთ შემდეგ დონეზე და დაინახოთ, რომ თქვენი სპრაიტი სწორად ჩნდება მსოფლიოში, თქვენ უნდა დაიბინძუროთ ხელები Rust კოდირებით. ეს სცილდება ამ გვერდის ფარგლებს, მაგრამ აქ მოცემულია რამდენიმე რჩევა დასაწყებად:

- `world/src/layer/scatter.rs` შეიცავს კოდს ისეთი ნივთებისთვის, როგორიცაა ყვავილები, ყლორტები, ქვები და ა.შ. ყველაფერი, რაც "მიმოფანტულია" გარემოში შემთხვევით.
- `world/src/site2/plot/house.rs`შეიცავს სახლებში არსებულ ავეჯს, როგორიცაა მაგიდები, საწოლები და ხალათების თაროები.
- სხვა მაგალითებისთვის მიმოიხედე `world/src/`.
- Veloren Discord სერვერზე #new-contributors არხი კარგი ადგილია კითხვების დასმისთვის.

**გილოცავთ Veloren-ს ახალი სპრაიტის დამატებას!**

გზამკვლევი: იარაღის დამატება Veloren-ში

\_ დამზადებულია @BOB17368
-ის მიერ

რაც გჭირდებათ

1. თქვენი არჩევანის IDE (პროგრამა, რომელიც საშუალებას გაძლევთ ნახოთ და შეცვალოთ კოდი)

მაგალითები: VSC, Atom, Notepad++

2. Voxel რედაქტორი (იარაღის მოდელის შესაქმნელად)

მაგალითი: Magicavoxel

3. Veloren-ის შედგენილი ვერსია (ასე რომ თქვენ შეგიძლიათ შეცვალოთ თამაშის ფაილები)

სურვილისამებრ

1. სიმბოლო შაბლონი. (შეიძლება გაიხსნას ნებისმიერი voxel-რედაქტორით, რომელიც მხარს უჭერს ფენებს; მაგიკავოქსელი.)

2. წვდომა veloren google drive model directory.

ზოგიერთი რამ, რისი ცოდნაც გსურს, სანამ დაიწყებ იარაღის შექმნას

1. Veloren-ს აქვს 12 ტიპის იარაღი:

• პოლეარმები
• იარაღები
• ფარები
• ხანჯლები
• ხმალი
• ცული
• ** გრძელი მშვილდი / მოკლე მშვილდი **
• პერსონალი

არაგათამამებულები ან სამუშაოა, ან ჯერ არ დაუწყიათ განვითარება.

2. Veloren google drive ფაილები სასარგებლოა, რადგან ის საშუალებას გაძლევთ გამოიყენოთ იარაღის არსებული მოდელები ფორმატად

3. თქვენ უნდა გქონდეთ თქვენი მოდელი(ებ)ის დამტკიცება ძირითადი დეველოპერების მიერ, თუ გსურთ თქვენი მოდელი რეალურ თამაშში მოხვდეს

4. იარაღის სახელური უნდა იყოს მაქსიმუმ სამი ვოქსელი სიგრძისა და სამი ვოქსელის სიგანე

მოდელის იმპორტი და თამაშში მისი იარაღის დამატება

იმისათვის, რომ თამაში რეალურად დატვირთოს თქვენი შემოქმედება, თქვენ უნდა შეასრულოთ რამდენიმე ნაბიჯი.

ისინი შეიძლება გაკეთდეს ნებისმიერი თანმიმდევრობით.

ნაბიჯი 1: ექსპორტი და დააკოპირეთ .vox ფაილი აქტივების საქაღალდეში

სანამ მოდელების ექსპორტს განახორციელებთ, ორჯერ შეამოწმეთ, რომ გაქვთ…

1. ექსპორტირებულია თქვენი მოდელი(ები) როგორც .vox და არა მხოლოდ შენახული .vox ფაილის კოპირება magicavoxel-იდან. უბრალოდ კოპირება გამოიწვევს ფაილის ზომას ~ 10-ჯერ.

2. დარწმუნდით, რომ არ არის არა დამატებითი სივრცის გაპარსვა შესაძლებელია ვოქსელების შეწირვის გარეშე.

გადადით ქვემოთ მოცემულ ფაილის ბილიკზე და ჩასვით თქვენი .vox ფაილი და დაარქვით სახელი ქვემოთ მოცემული დასახელების სქემის მიხედვით.

assets/voxygen/voxel/weapons/<Weapon Type>/<Model Name>

ფაილის ბილიკი დაახლოებით ასე უნდა გამოიყურებოდეს, სანამ დაასრულებთ

assets/voxygen/voxel/weapon/sword/long_2h_fine-0.vox

სახელების სქემა .vox ფაილებისთვის

• ცალკეული სიტყვები იყოფა ქვედა ხაზით (“_”)
• დათვლა იწყება ნულიდან.
• რიცხვებს ემატება ერთი ტირე (“-”) მათ წინ.
• თქვენი იარაღის სახელი ყოველთვის უნდა მთავრდებოდეს ნომრით, თუ არ ხართ აბსოლუტურად დადებითი, რომ არ იქნება ნივთის ალტერნატიული ვერსია/დიზაინი

ნაბიჯი 2: შექმენით .ron ფაილი

1. შექმენით ახალი ჩანაწერი

assets/common/items/weapons/<weapon type>

დააკოპირეთ და ჩასვით იმავე ტიპის იარაღის ერთ-ერთი არსებული .ron ფაილი, რომლის მიზანია შექმნათ და დაარედაქტიროთ [ ]-ში ჩასმული ნაწილები თქვენი სურვილის მიხედვით

Item(
    name: "[Crude Mallet]",
    description: "[Two-Hand Hammer\n\nPower: 10-12\n\nBreaks bones like sticks and stones.\n\n<Right-Click to use>]",
    kind: Tool(
        (
            kind: Hammer([BasicHammer]),    
            equip_time_millis: 500,
            power: 1.30,
        )
    )
)

შენიშვნა: ამიერიდან, როდესაც ვგულისხმობ “იარაღის სახეს” მე ვსაუბრობ იმ სახელწოდებაზე, რომელიც თქვენ დანიშნეთ “BasicHammer”-ისთვის

ნაბიჯი 3: შექმენით ახალი ჩანაწერი იარაღის მანიფესტის ფაილში

გადადით ფაილის ამ გზაზე და გახსენით humanoid_main_weapon_manifest ტექსტის რედაქტორში

assets/voxygen/voxel/humanoid_main_weapon_manifest.ron

დააკოპირეთ და ჩასვით კოდის მოდული, სადაც დაჯგუფებულია იგივე ტიპის იარაღი, რომელსაც თქვენ ამატებთ (დარწმუნდით, რომ შეიტანეთ ფრჩხილები და მძიმეები!)

შემდეგ შეცვალეთ WornIronAxe0 თქვენი „Weapon Kind“-ით

Axe(WornIronAxe0): (
        vox_spec: ("weapon.axe.2haxe_worn_iron-0", (-1.5, -3.0, -4.0)),
        color: None
    ),

** ოფსეტი მოგვიანებით იქნება ახსნილი!**
თქვენ მიერ კოპირებული მაგალითიდან მხოლოდ ციფრების შენახვა კარგი იქნება ახლა.

**სურვილისამებრ: ** color: None გამოიყენება იარაღს კონკრეტული შეფერილობის მისაცემად. უბრალოდ მიუთითეთ rgb მნიშვნელობები None Some((<R>, <G>, <B>))-ით შეცვლით

3. ნაბიჯი 4: ჯავშანტექნიკის დამატება tool.rs-ში

გახსენით common/src/comp/inventory/item/tool.rs ტექსტის რედაქტორში

და დაამატეთ თქვენი “Weapon Kind” შესაბამის სიას

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ShortbowKind {
    BasicShortbow,
    WoodShortbow0,
    WoodShortbow1,
    LeafyShortbow0,
}

ნაბიჯი 5: დაამატეთ ახალი ელემენტის სურათი image manifest ფაილში

იპოვეთ სად მდებარეობს თქვენი იარაღის ტიპის კოდი და დააკოპირეთ იგი იმავე ადგილას

თქვენ შეგიძლიათ გამოიყენოთ .png ან .vox ფაილი, როგორც ელემენტის გამოსახულება. მაგრამ მხოლოდ პრაქტიკულია იარაღის ვოქსის მოდელის გამოყენება.

მაგალითი .vox-ისთვის:

Tool(Longbow(WoodLongbow1)): VoxTrans(
        "voxel.weapon.longbow.longbow_wood-1",
        (0.0, 0.0, 0.0), (90.0, 90.0, 0.0), 1.0,
    ),

იმისათვის, რომ იპოვოთ იარაღის სწორი პოზიციონირების მნიშვნელობები, ხშირად კარგი იდეაა მოძებნოთ მსგავსი ნივთი.

Armor(Back(NewCape)): VoxTrans(
    "voxel.armor.back.new_cape-0",
    (0.0, 0.0, 0.0), (-90.0, 180.0, 0.0), 1.0,
),

თქვენ შეგიძლიათ გამოიყენოთ იგივე .vox, როგორც ფაქტობრივი 3D აქტივი, რომელიც ნაჩვენებია სიმბოლოზე მოგვიანებით.

ნაბიჯი 6: იპოვნეთ სწორი კომპენსაცია თქვენი ნივთისთვის

იმისათვის, რომ შეამოწმოთ თქვენი იარაღი თამაშში, თქვენ უნდა შეადგინოთ თქვენი თამაში ახლავე.

თქვენი ახალი ელემენტი ** ხელმისაწვდომი იქნება მხოლოდ ადგილობრივად**, ამიტომ დარწმუნდით, რომ დაუკავშირდით ადგილობრივ სერვერს ან აირჩიეთ „Singleplayer“.

ჩაყარეთ იარაღი თქვენს ინვენტარში შემდეგი ჩატის ბრძანების გამოყენებით:

სრული ბრძანება:

/give_item common.items.weapons.<weapon type(ex: staff)>.<Weapon Kind>

მინიშნება: შეგიძლიათ აკრიფოთ /give_item common.items.weapons. და შემდეგ დააჭიროთ ჩანართს ხელმისაწვდომ იარაღზე გადასასვლელად

თუ არ მოგწონთ ის, თუ როგორ უჭირავს თქვენი პერსონაჟი თქვენს იარაღს, თქვენ უნდა გააფუჭოთ იარაღის ოფსეტები.

სწორი ოფსეტის დასაყენებლად საჭიროა ხელახლა ეწვიოთ assets/voxygen/voxel/humanoid_main_weapon_manifest.ron

და შემდეგ შეცვალეთ ქვემოთ მონიშნული ოფსეტები დაკმაყოფილებამდე

Sword(LongFine4): (
    vox_spec: ("weapon.sword.long_2h_fine-4", (<x offset>, <y offset>, <z offset>)),
    color: None
),

იქ არსებული მნიშვნელობები შეიძლება ცხელი ხელახლა ჩაიტვირთოს. ეს ნიშნავს, რომ მათი შენახვა დაუყოვნებლივ ამოქმედდება თამაშში.

ისინი წარმოადგენენ კოორდინატებს:

(X, Y, Z)

X = მარცხნივ (შეამცირეთ რიცხვი) და მარჯვნივ (რიცხვის გაზრდა)
Y = უკან (შეამცირეთ რიცხვი) და მეოთხე (რიცხვის გაზრდა)
Z = ზევით (რიცხვის გაზრდა) და ქვევით (რიცხვის შემცირება)

შეცვალეთ ნომრები, სანამ არ მიიღებთ სასურველ ოფსეტს.

** შესრულებულია. თქვენ დაამატეთ იარაღის ახალი სტილი და ნივთი Veloren-ს.**

გზამკვლევი: const_tweaker crate-ის გამოყენება გაშვების დროს მნიშვნელობების შესაცვლელად

\_ დამზადებულია @Pfau-ს მიერ

რისი გაკეთება შეგიძლიათ მასთან

const_tweaker კრატი საშუალებას გაძლევთ შეცვალოთ მუდმივები გაშვების დროს. ეს შეიძლება გამოყენებულ იქნას ანიმაციების, ინტერფეისის ვიჯეტის პოზიციების შესასწორებლად და მრავალი სხვა!

მოკლე სახელმძღვანელო მაგალითით

დაამატეთ ახალი const თქვენს ფაილს

#[const_tweaker::tweak(min = -100.0, max = 20.0, step = 1.0)]
const EXAMPLE: f64 = 10.0;

ყურადღება მიაქციეთ ზემოთ მოცემულ თანდართულ ატრიბუტებს. ყოველ ახალ კონსტტს სჭირდება საკუთარი!
ეს შექმნის f64 ტიპს, რომელიც შეიძლება შეიცვალოს -100.0-დან 20.0-მდე 1.0 ნაბიჯებით.
თქვენი ცვალებადი მნიშვნელობის კოდში დამატება ასე გამოიყურება:

Foo + *EXAMPLE = Sum

ყურადღება მიაქციეთ, როგორ უნდა მოხდეს მისი გაუქმება იმისთვის, რომ იმუშაოს.

Const_tweaker ფუნქცია შეკრულია Veloren/voxygen-ში. ასე რომ, თქვენ უნდა შეადგინოთ cargo run --features tweak-ით.

** შენიშვნა: ** _ ამისათვის გადადით voxygen საქაღალდეში, რადგან შემდგენელი არ მიიღებს --features-ის გაშვებას root დირექტორიადან._

ეს შექმნის ადგილობრივ ვებ GUI-ს მისამართზე 127.0.0.1:9938, სადაც შეგიძლიათ ითამაშოთ მნიშვნელობებთან.

გზამკვლევი: იარაღის უნარების დამატება Veloren-ში

\_ დაწერილი @Sam-ის მიერ @James-ის დამატებებით

განსაზღვრეთ თქვენი უნარი

პირველი რაც თქვენ უნდა გააკეთოთ არის განსაზღვროთ თქვენი უნარი და გაარკვიოთ რა პარამეტრები დასჭირდება მას. მნიშვნელოვანია ამის გაკეთება, რადგან ზოგჯერ ახალ უნარს შეუძლია გაუმკლავდეს პერსონაჟის ერთ-ერთ ამჟამინდელ მდგომარეობას, და თუ ის ახლოსაა, მაშინ მხოლოდ 1 ან 2 დამატებითი შეიძლება დაემატოს ადრე არსებულ პერსონაჟის მდგომარეობას.

დაამატეთ თქვენი უნარი

იარაღზე თავდასხმის უნარებს ამუშავებენ ხასიათის მდგომარეობა. რაც შეეხება ამ რედაქტირებას, ეს არის შემდეგი ხასიათის მდგომარეობები (თუმცა ComboMelee მუშაობს და TripleStrike გამოსასვლელია).

pub enum CharacterAbilityType {
      BasicMelee,
      BasicRanged,
      Boost,
      ChargedRanged,
      ChargedMelee,
      DashMelee,
      BasicBlock,
      TripleStrike(Stage),
      LeapMelee,
      SpinMelee,
  }

სიმბოლოების ეს მდგომარეობები შეიძლება იყოს (და გამოიყენება) მრავალჯერადი უნარებისთვის. თქვენი ახალი უნარი შეიძლება ადვილად მოერგოს ერთ-ერთ ამ მდგომარეობას. შესაძლოა, მდგომარეობა ოდნავ მორგებული იყოს თქვენი უნარების დასაკმაყოფილებლად. მესამე ალტერნატივა არის ახალი ხასიათის მდგომარეობის დამატება. სამივე ეს შესაძლებლობა განხილულია შემდეგ თავებში.

თუ თქვენი უნარი შეიძლება დამუშავდეს არსებული პერსონაჟის მდგომარეობით

გადადით common/src/somp/inventory/item/tool.rs-ზე

როდესაც იქ ხართ, დაამატეთ დამატებითი თავდასხმა იარაღს, რომელსაც ამატებთ შეტევას. გაითვალისწინეთ, რომ იარაღის უნარებს ამუშავებს ვექტორი, პირველი უნარი მიბმულია M1-ზე, მეორე M2-ზე, მესამე უნარების ზოლის სლოტ 1-ზე და დამატებითი უნარების ზოლის სლოტზე (მხოლოდ უნარების ზოლის სლოტი 1 შეიძლება განხორციელდეს ახლა).

თუ თქვენი უნარი მოითხოვს არსებული სიმბოლოების მდგომარეობის შეცვლას

გადადით common/src/states/-ზე.

გახსენით შესაბამისი სიმბოლოს მდგომარეობის ფაილი. მონაცემთა სტრუქტურის ზედა ნაწილში დაამატეთ თქვენთვის საჭირო დამატებითი ველები, ასევე დაგჭირდებათ მისი დამატება კოდის ყველა განყოფილებაში, რომელიც განაახლებს სიმბოლოების მდგომარეობის მონაცემებს (შემდგენელი დააგდებს შეცდომებს, თუ დაგავიწყდებათ). შემდეგ გააგრძელეთ კოდი და შეცვალეთ საჭირო ლოგიკა.

გადადით common/src/comp/ability.rs-ზე.

მოძებნეთ სად არის განსაზღვრული სიმბოლოს მდგომარეობის ველები. ისინი განსაზღვრულია 3 ადგილას. ზედა განსაზღვრავს თუ რომელი ველები იკითხება tool.rs-დან, მეორე იკითხება tool.rs-დან და მესამე აყალიბებს Data struct-ს სიმბოლოების მდგომარეობის ფაილში. ზოგჯერ შეიძლება დაგჭირდეთ მხოლოდ ახალი ველის დამატება მე-3 სექციაში, თუმცა, როგორც წესი, მოგიწევთ ახალი ველის დამატება სამივეში.

გადადით common/src/comp/inventory/item/tool.rs-ზე.

იქვე დაამატეთ თქვენი ახალი თავდასხმა თქვენთვის სასურველ იარაღზე. ასევე, თუ რომელიმე იარაღს უკვე ჰქონდა შეტევა, განაახლეთ ველები, რომ შეიცავდეს თქვენს მიერ დამატებულ ახალ ცვლადს.

თუ თქვენი უნარი მოითხოვს ახალი პერსონაჟის მდგომარეობის შექმნას

გადადით common/src/states/-ზე.

შექმენით ახალი ფაილი და მიეცით მას სახელი, რომელიც შეესაბამება თქვენ მიერ დამატებულ სიმბოლოს. შეიძლება სასარგებლო იყოს ფაილის კოპირებით დაწყება მსგავსი სიმბოლოების მდგომარეობიდან. შექმენით თქვენი პერსონაჟის მდგომარეობის ლოგიკა და დაადგინეთ, რა ველები უნდა გადავიდეს მდგომარეობაში მონაცემთა სტრუქტურის ზედა ნაწილში.

ასევე, ამ განყოფილებაში, თქვენ უნდა დაადგინოთ, რა სახის შეტევაა თქვენი პერსონაჟის მდგომარეობა. ამჟამად არსებობს სისტემები მელეული შეტევების, ჭურვებისა და აფეთქებებისთვის. მალე იქნება მხარდაჭერა შოკის ტალღებისა და სხივებისთვის. თუ თქვენ გჭირდებათ სხვა სისტემა თქვენი შეტევის მოსაგვარებლად, მომწერეთ (@Sam) დახმარებისთვის.

გადადით common/src/states/mod.rs-ზე.

დაამატეთ თქვენი პერსონაჟის მდგომარეობა ამ ფაილს, შეინახეთ ის დალაგებული ანბანის მიხედვით

გადადით common/src/comp/ability.rs-ზე.

თითოეულ ლოკაციაში დამუშავებულია ყველა სხვა სიმბოლოს მდგომარეობა, დაამატეთ თქვენი ახალი სიმბოლოს მდგომარეობა (შეიძლება სასარგებლო იყოს ფაილში მოძებნოთ „leapmelee“ ან „leap“ და უბრალოდ დაამატოთ თქვენი ხასიათის მდგომარეობა თითოეულ მდებარეობაში. ადგილები, რომლებიც ფრთხილად უნდა იყოთ თქვენს ლოგიკაზე, არის 3 ადგილი, სადაც არის განსაზღვრული თქვენი სიმბოლოს მდგომარეობის ველები (იხილეთ განყოფილება შეცვალოს სიმბოლოები რას აკეთებენ სხვა პერსონაჟები).

გადადით common/src/comp/inventory/item/tool.rs-ზე.

დაამატეთ თქვენი ახალი პერსონაჟის მდგომარეობა, როგორც თავდასხმა იმ იარაღისთვის, რომლებშიც გსურთ მისი დამატება. დარწმუნდით, რომ ამ ადგილის ველები ემთხვევა უნარების პირველ ნაწილში გადასულ ველებს.rs.

გადადით common/src/comp/character_state.rs-ზე.

დაამატეთ თქვენი პერსონაჟის მდგომარეობა CharacterState სიაში (იდეალურად შეიტანეთ მოკლე აღწერაც). შეხედეთ CharacterState-ის განხორციელებას, თუ თქვენი აღწერილია რომელიმე ფუნქციით, დაამატეთ იგი იქ.

გადადით common/src/sys/character_behavior.rs-ზე.

მოძებნეთ ნებისმიერი პერსონაჟის მდგომარეობა (მაგ. LeapMelee). დაამატეთ თქვენი პერსონაჟის მდგომარეობა იმ 2 ადგილას, სადაც სხვა სიმბოლოების მდგომარეობა მუშავდება იმავე ლოგიკით.

გადადით common/src/sys/stats.rs-ზე.

დაამატეთ ლოგიკა იმის შესახებ, თუ როგორ მოქმედებს თქვენი ხასიათის მდგომარეობა ბუნებრივ ენერგეტიკულ რეგენზე. (თუ ეს არის შეტევა ან მოიხმარს ენერგიას, უნდა გამორთოთ ბუნებრივი ენერგიის რეგენი).

უნარის დამატება უნარების ზოლში

(როდესაც უნარების ხეები განხორციელდება, ეს განყოფილება განახლდება)

იმის გამო, რომ ამჟამად დანერგილ ყველა იარაღს უკვე აქვს მინიმუმ 2 უნარი, დიდია შანსი, რომ დაგჭირდეთ თქვენი უნარის დამატება უნარების ზოლში ან გადაიტანოთ ამჟამად არსებული უნარი უნარების ზოლში.

tool.rs ფაილში, ვექტორში უნარების დალაგება განსაზღვრავს, თუ რა სლოტზე იქნება მინიჭებული. პირველი სლოტი არის M1, მეორე M2, მესამე უნარების ზოლი 1, მეოთხე უნარების ზოლი 2 და ა.შ. ასე რომ, როდესაც დაამატებთ თქვენს შესაძლებლობებს, დარწმუნდით, რომ ის სწორ მდებარეობაშია შესაძლებლობების ვექტორში.

გადადით voxygen/src/hud/hotbar.rs-ზე

დაამატეთ იარაღის ტიპი, რომელსაც თქვენ ამატებთ მესამე უნარს ლოგიკაში, როდესაც უნდა იყოს წარმოდგენილი ბოლის მნიშვნელობის განსაზღვრა. ის ისეთივე მარტივი უნდა იყოს, როგორც დამატება:

else if let ToolKind::Hammer(_) = &kind.kind {
    true
}

დაამატეთ ხატულა assets/voxygen/element/icons-ში. უნარების ხატები უნდა იყოს 20 x 20 პიქსელი გამჭვირვალე კუთხის პიქსელებით. შეამოწმეთ ქინძისთავები აქტივებში ან veloren-art არხში Discord-ზე, რომ იპოვოთ შესაბამისი ფერის პალიტა. დარეკეთ @Pfau-ზე Discord-ზე, რათა ნახოთ ვინმე უკეთეს ხატულას შეიმუშავებს თუ თქვენი დამტკიცებისთვის.

გადადით voxygen/src/hud/img_ids.rs-ზე.

140-ე სტრიქონის გარშემო არის განყოფილება, სადაც ჩამოთვლილია ყველა M1 და M2 ხატის მდებარეობა. დაამატეთ თქვენი უნარი აქ მისი ხატის ბილიკით. თუ თქვენი უნარი მიდის უნარების ზოლზე, ამის ნაცვლად დაამატეთ თქვენი უნარი/ხატი წყვილი “ხატები” განყოფილებაში 270-ე სტრიქონის გარშემო.

გადადით voxygen/src/hud/skillbar.rs-ზე.

თუ თქვენი უნარი ანაცვლებს M1 ან M2 უნარს, დაამატეთ ის მატჩს 620 ხაზის გარშემო M1-ისთვის და 700 ხაზის გარშემო M2-ისთვის.

M1-ისთვის და M2-ისთვის, დაამატეთ მკლავი შესატყვისის გამოხატულებას 730-ე სტრიქონის გარშემო, რათა უნარების ხატულა გაქრეს, როდესაც self.energy.current() თქვენი უნარების ენერგიის ხარჯვას გადააჭარბებს. თუ თქვენს უნარს არ აქვს ენერგიის გადინება (და ყოველთვის ხელმისაწვდომი უნდა იყოს), თქვენ არ გჭირდებათ თქვენი უნარი ამ მატჩში ჩართოთ.

თუ თქვენი უნარი მიდის Hotbar-ში, მიჰყევით ქვემოთ მოცემულ ნაბიჯებს:

დაამატეთ უნარ-ჩვევის სახელი და აღწერა voxygen/src/hud/skillbar.rs-ის 800-ე ხაზის გარშემო. უბრალოდ შეხედეთ ამჟამად არსებული უნარების ლოგიკას. ეს დაამატებს ინსტრუმენტს და სახელს უნარს.

გადადით voxygen/src/hud/slots.rs-ზე.

90-ე სტრიქონის გარშემო დაამატეთ თქვენი უნარი HotbarImage-ის სიაში.

120-ე სტრიქონში იარაღთან შესაბამისობა დააბრუნებს შესაბამის უნარს HotbarImage-დან.

130-ე ხაზის ირგვლივ დაამატეთ თქვენი უნარი მატჩს. დააკოპირეთ აქ ერთ-ერთი სხვა უნარის ლოგიკა, მაგრამ გააკეთეთ energy.current() < ENERGY_DRAIN სადაც ENERGY_DRAIN არის თქვენი უნარების ენერგიის გადინება. ეს გამოიწვევს ხატის გაქრობას, როდესაც მოთამაშეს არ აქვს საკმარისი გამძლეობა.

image_id ფუნქციაში 165-ე ხაზის გარშემო, დაამატეთ ბილიკის იდენტიფიკატორი თქვენი უნარისთვის (დააკოპირეთ სხვა უნარების ლოგიკა).

ანიმაციები

Ping @Slipped on Discord. თქვენ ასევე შეგიძლიათ გაეცნოთ წინა MR-ებს (როგორც ეს: https://gitlab.com/veloren/veloren/-/merge_requests/1171/diffs), თუ გსურთ ნახოთ, როგორ გააკეთოთ ეს თავად (ეს გაჩვენებთ, სად უნდა დაამატოთ პერსონალი და გაჩვენებთ, როგორ გამოიყურება სხვა ანიმაციის კოდი).

ცვლილებების ჟურნალი

გადადით CHANGELOG.md-ზე დაამატეთ ხაზი, რომელშიც ნათქვამია, რომ თქვენ დაამატეთ შეტევა

თამაშის მოდიფიკაცია

შენ ყოველთვის არ გჭირდება კოდირების ცოდნა!

• მოდულის დაწერა
• ერთეულების დამატება დანამატის საშუალებით
• [სერვერის მხარის აქტივების დამატება მანიფესტებით]

მოდულის დაწერა

ეს სახელმძღვანელო გაჩვენებთ, თუ როგორ უნდა დაწეროთ მარტივი სერვერის (და კლიენტის მხარის) მოდული Veloren-ისთვის. გთხოვთ გაითვალისწინოთ, რომ ორივე მოდულის API და დანამატის განვითარების პროცესი აქტიური განვითარების პროცესშია და ამჟამად არ გვაქვს სტაბილურობა გარანტიები API-ების, ხელსაწყოების შესახებ და ა.შ. თუ ეჭვი გეპარებათ, გთხოვთ, შეამოწმოთ ეს გვერდი, რათა იპოვოთ უახლესი ინფორმაცია.

ასევე მნიშვნელოვანია გვახსოვდეს, რომ მოდულის API ჯერ კიდევ ძალიან ახალია და ბევრი ფუნქციონალობა არ არის მხარდაჭერილი. იმედი გვაქვს რომ ამ სახელმძღვანელოს გამოქვეყნებით და ხალხის წახალისებით, რომ ექსპერიმენტები ჩაატარონ დანამატის API-ზე, რომლის შექმნაც შეიძლება დავიწყოთ კონსენსუსი სამომავლო მიმართულებაზე და სამომავლო ფუნქციებზე API-სთვის. თუ გაინტერესებთ დახმარება, დაგვიკავშირდით!

მაგალითი კოდი

შეგიძლიათ იპოვოთ ამ მაგალითის მოდულის კოდი აქ.

მოთხოვნები

• საბაზისო Rust-ის ცოდნა

• მარტივი Unix-ის მსგავსი ტერმინალების და ბრძანებების გამოყენების შესაძლებლობა

• Veloren-ის განახლებული მაგალითი (თავსებადობის მიზნებისთვის სასურველია ადგილობრივი საცავი)

• შენიშვნა: გაქვთ პრობლემები? თავისუფლად იკითხეთ #learning Veloren Discord სერვერზე.*

მიმოხილვა

Veloren-ის დანამატები იწერება ვებ ასამბლეაში (აქ მოიხსენიება როგორც ‘WASM’), კოდის ფორმატი, რომელიც თავდაპირველად შექმნილია მაღალი წარმადობის, მეხსიერებისთვის უსაფრთხო ვებ შემსრულებელი ფაილები, მაგრამ ასევე იდეალურად შეეფერება სხვა მრავალ აპლიკაციებს. ეს გულისხმობს შემდეგ საკითხებს Veloren დანამატების შესახებ:

• ისინი სავარჯიშოში არიან და ამიტომ უსაფრთხოა კლიენტის მხარეს გასაშვებად ავტომატურად

• WASM-ს ჯერ არ აქვს კარგად განსაზღვრული ჰოსტი ABI, ამიტომ თამაშის ძრავთან კომუნიკაცია მოვლენებზეა ორიენტირებული

• ისინი პორტატულია და იმუშავებენ ყველა არქიტექტურასა და პლატფორმაზე

• (დაგეგმილი) დანამატები იმართება სერვერის მიერ და ეგზავნება კლიენტებს სერვერთან დაკავშირებისას, ამიტომ მოდულის გაწევრიანება ჩართულია სერვერი არის უწყვეტი პროცესი.

დაყენება

ჩვენ ვვარაუდობთ, რომ თქვენ იყენებთ Unix-ის მსგავს სისტემას, ან მსგავსი თვისებების მქონე გარემოს (როგორიცაა WSL ან Cygwin).

შენიშვნა: ამიერიდან, სადაც ხედავთ my_plugin, შეცვალეთ ეს თქვენი მოდულის სახელით.

პირველი, შექმენით ახალი სატვირთო პროექტი.

cargo new --lib my_plugin

დანამატებს აქვთ მრავალი შესვლის წერტილი (მაგ.: მოდულისგან ნივთების მოთხოვნის გზები), რომლებიც შეიძლება იყოს გამოძახებული თამაშის მიერ. რომ დარწმუნდით, რომ ეს ყველაფერი სათანადოდ ხელმისაწვდომი იქნება თამაშისთვის, დაამატეთ შემდეგი Cargo.toml:

[lib]
crate-type = ["cdylib"]

იმის გამო, რომ Veloren-ის მოდულის API არასტაბილურია, ჩვენ დამოკიდებულნი ვიქნებით Veloren-ის git საცავზე. Cargo.toml-ში დაამატეთ შემდეგ მისამართზე [dependencies]:

veloren-plugin-rt = { git = "https://gitlab.com/veloren/veloren.git" }

veloren-plugin-rt კრატი ახვევს მოდულის API-ს, მოვლენის დამმუშავებლის მიერ წარმოქმნილ მაკროებს და სხვა სასარგებლო ბიტების სერიას და ნაწილებად იქცა ის, რასაც ჩვენ კოლოქიურად ვუწოდებთ „მოდულის გაშვებას“ (rt).

იმის გამო, რომ ჩვენ უნდა შევადგინოთ ჩვენი დანამატი WASM მოდულზე, ჯერ დარწმუნდით, რომ დაინსტალირებულია შესაბამისი ხელსაწყოების ჯაჭვი (და მუშაობს) შემდეგი მოქმედებებით:

cargo build --target wasm32-wasi

თუ მიიღებთ error[E0463]: can't find crate for 'core'-ს, შეგიძლიათ დააინსტალიროთ core-ის შესაბამისი ვერსია შემდეგი rustup ბრძანება:

rustup target add wasm32-wasi

Veloren-ის კოდების ბაზა ამჟამად მოითხოვს Rust შემდგენელის ღამის ვერსიას (იმედი გვაქვს, რომ ეს ასე არ იქნება მომავალი) და ასე რომ თქვენ ასევე გჭირდებათ. თუ უკვე არ იყენებთ ღამეს, შეგიძლიათ დააყენოთ კატალოგის სპეციფიკური გადაფარვა ამისათვის შემდეგი ბრძანებით (დარწმუნდით, რომ თქვენ ხართ my-plugin დირექტორიაში, სანამ გაუშვით):

rustup override set nightly

მოდულის შეფუთვა

დანამატები შეფუთულია არაკომპრესირებულად (შეკუმშვა შეიძლება მოგვიანებით იყოს მხარდაჭერილი, მაგრამ ამჟამად არ არის) tar არქივები გაფართოებით .plugin.tar. თითოეული არქივი შეიცავს:

• ფაილი სახელით plugin.toml, რომელიც განსაზღვრავს დანამატის მეტამონაცემებს

• და ნებისმიერი რაოდენობის WASM მოდული (პირობითად გაფართოებით .wasm)

my_plugin.plugin.tar
  |- plugin.toml
  |- foo.wasm
  `- bar.wasm

plugin.toml-ის ფორმატია TOML. საჭირო ველები საკმაოდ მარტივია, როგორც ქვემოთ ნაჩვენები მაგალითი აჩვენებს (შეგიძლიათ გამოტოვოთ კომენტარები):

# The name of the plugin (lowercase, no spaces)
name = "my_plugin"

# A list of paths to WASM modules in the plugin (this can be used to group
# plugins together in a rudimentary way until we implement dependencies).
modules = []

# Plugins required by this plugin (currently unsupported, keep this empty)
dependencies = []

ჩვენ გვინდა დავიწყოთ ერთი მოდულის შექმნით. მოდით მივცეთ მას იგივე სახელი, როგორც ჩვენი პროექტი. დაიწყეთ მისი დამატებით modules სიაში ასე:

modules = ["my_plugin.wasm"]

მოდულის შესაფუთად, ჩვენ შეგვიძლია დავაკოპიროთ შედგენილი WASM მოდული წინა ნაბიჯებიდან, რომელიც მდებარეობს target/wasm32-wasi/debug/my_plugin.wasm თქვენს მიერ შექმნილ შეფუთვის დირექტორიაში ერთად plugin.toml და შემდეგ გამოიყენეთ tar ბრძანება (ან თქვენი საყვარელი არქივის მენეჯერი), რომ შეფუთოთ ისინი. The შემდეგი ბრძანება, რომელიც შესრულებულია შეფუთვის დირექტორიაში, კარგად უნდა მუშაობდეს:

tar -cvf ../my_plugin.plugin.tar *

შეიძლება დაგჭირდეთ ამ პროცესის ავტომატიზაცია სკრიპტით, რადგან ამას ხშირად გააკეთებთ. მარტივი shell სკრიპტი იქნებოდა სავარაუდოდ საკმარისია.

მომავალში ჩვენ გვსურს შევქმნათ ტვირთის ქვებრძანება, რომელიც ავტომატიზირებს ამ ნაბიჯს, მაგრამ ეს ჯერ არ გაკეთებულა.

ცნობისთვის, მე უბრალოდ ვიყენებ ჭურვის მარტივ სკრიპტს შემდეგი შინაარსით:

cargo build --target wasm32-wasi
cp target/wasm32-wasi/debug/my_plugin.wasm build_dir/.
cd build_dir
tar -cvf ../my_plugin.plugin.tar plugin.toml my_plugin.wasm
cd ..

მოდულის გაშვება

მოდულის გასაშვებად, უბრალოდ დააკოპირეთ ის plugins დირექტორიაში Veloren-ის აქტივების დირექტორიაში. მოდული იქნება იგზავნება ქსელის მეშვეობით კლიენტებთან დამაკავშირებელთან, ამიტომ მნიშვნელოვანია მხოლოდ ის იყოს ხელმისაწვდომი სერვერისთვის (ან Voxygen-ისთვის, თუ გსურთ მოდულის გაშვება singleplayer-ში).

ჩემს შემთხვევაში, ეს უბრალოდ გულისხმობს საბოლოო არქივის კოპირებას assets/plugins/my_plugin.tar-ში ჩემს ადგილობრივ საცავში და თამაშის გაშვება.

როდესაც სერვერი იწყება (ან როდესაც ერთი მოთამაშე იწყება) თქვენ უნდა ნახოთ შემდეგი შეტყობინებები კონსოლში:

INFO veloren_common_state::plugin: Searching "/home/zesterer/projects/veloren/assets/plugins" for plugins...
INFO veloren_common_state::plugin: Loading plugin at "/home/zesterer/projects/veloren/assets/plugins/my_plugin.plugin.tar"
INFO veloren_common_state::plugin: Loaded plugin 'my_plugin' with 1 module(s)

თუ აქამდე მიაღწიეთ, გილოცავთ: თქვენ ოფიციალურად შექმენით თამაშის მოდული!

მოვლენების მართვა

ამ ეტაპზე, ღირს მოკლედ გადახედოთ მოდულის API-ს დოკუმენტაციას, აქ. მიუხედავად იმისა, რომ ჩვენ დამოკიდებულნი ვართ veloren-plugin-rt, ანალოგიურად დასახელებულზე veloren-plugin-api ყუთი ექსპორტირებულია მის მიერ ჩვენი მოხერხებულობისთვის. ჩვენ ახლა მზად ვართ დავწეროთ პირველი მოვლენის დამმუშავებელი ჩვენი მოდული.

lib.rs-ში შეიყვანეთ შემდეგი:

#![allow(unused)]
fn main() {
use veloren_plugin_rt::{*, api::{*, event::*}};

#[event_handler]
pub fn on_load(load: PluginLoadEvent) {
    emit_action(Action::Print(String::from("Hello, Veloren!")));
}
}

ამის ასახსნელად ღირს ცოტა დრო დახარჯოთ, განსაკუთრებით თუ არც ისე კარგად იცნობთ Rust-ს.

#![allow(unused)]
fn main() {
use veloren_plugin_rt::{*, api::{*, event::*}};
}

აქ ჩვენ იმპორტირებთ საჭირო მაკროებს, ტიპებსა და ფუნქციებს, რომლებიც გვჭირდება ჩვენი მოდულის დასაწერად.

#![allow(unused)]
fn main() {
#[event_handler]
pub fn on_load(load: PluginLoadEvent) { ... }
}

აქ ჩვენ ვაცხადებთ ახალ ფუნქციას, რომელიც იღებს a PluginLoadEvent. ჩვენ ვიყენებთ event_handler ატრიბუტი გაშვების დროისთვის რომ გვსურს გამოვიყენოთ ეს ფუნქცია მოვლენის დამმუშავებლად, რომელიც იქნება გამოიძახება, როდესაც ხდება მითითებული ტიპის მოვლენა.

ამ შემთხვევაში, on_load ღონისძიება უბრალოდ გამოიძახება ერთხელ, როდესაც დანამატი პირველად ჩაიტვირთება სერვერის გაშვებისას.

#![allow(unused)]
fn main() {
emit_action(Action::Print(String::from("Hello, Veloren!")));
}

ჩვენ უკვე აღვნიშნეთ მოდულის შეყვანის მიღების გზა მოვლენის დამმუშავებლების საშუალებით. როგორ ვიმოქმედოთ ამ მოვლენებზე? Actions მეშვეობით! Action არის ის, რაც გსურთ, რომ სერვერმა შეასრულოს და შეგიძლიათ გამოიყენოთ emit_action და emit_actions ფუნქცია, რათა სერვერმა შეასრულოს ისინი.

თუ სერვერს ახლად შედგენილი მოდულით მართავთ, ახლა სერვერის კონსოლში უნდა ნახოთ შემდეგი:

INFO veloren_common_state::plugin::module: Hello, Veloren!

თუ თქვენ აწარმოებთ თამაშს ერთი მოთამაშით, ამას ორჯერ ნახავთ: ერთხელ შიდა სერვერისთვის და ერთხელ შიდა კლიენტი (მას შემდეგ, რაც ის მიიღებს დანამატს სერვერიდან).

ჩატის ბრძანებები

ჩვენ ვაპირებთ გავაფართოვოთ ჩვენი დანამატი ისე, რომ როდესაც ჩატში აკრიფებთ /ping, მოთამაშე მიიღებს პასუხს Pong!. რატომ? კონკრეტული მიზეზი არ არის, მაგრამ ეს არის ჩატის ფუნქციონირების კარგი დემონსტრირება.

დაამატეთ შემდეგი lib.rs-ს:

#![allow(unused)]
fn main() {
#[event_handler]
pub fn on_command_ping(chat_cmd: ChatCommandEvent) -> Result<Vec<String>, String> {
    Ok(vec![String::from("Pong!")])
}
}

ერთადერთი, რაც აქ ასახსნელია, არის რაღაც, რაც შეიძლება ცოტა მოულოდნელი იყოს წინა მაგალითის გათვალისწინებით: დაბრუნება ტიპი.

Event თვისების ყველა განმახორციელებელი (როგორიცაა PluginLoadEvent, ChatCommandEvent და ა.შ.) ასევე განსაზღვრავს პასუხს რაც მას მოეთხოვება. PluginLoadEvent-ის შემთხვევაში, პასუხი არის უბრალოდ (), რის გამოც ჩვენ არ დაგვჭირდა ცალსახად დააბრუნეთ არაფერი on_load მოვლენიდან. დაბრუნების ტიპი ChatCommandEvent-ისთვის განსხვავებულია, თუმცა: ის მოელის ან ბრძანებაზე შეტყობინების პასუხების სიას, ან შეცდომის შეტყობინებას, თუ ბრძანების სინტაქსი არასწორია.

თუ თამაშს ახლად შედგენილი დანამატით აწარმოებთ და შემდეგ სამყაროში შედიხართ, უნდა შეგეძლოთ აკრიფოთ /ping ესაუბრეთ და მიიღეთ Pong! პასუხად.

გლობალური სახელმწიფო

მოდულის API-ის ბოლო მახასიათებელია, რომელზეც უნდა ვისაუბროთ ამ გაკვეთილის დასრულებამდე: გლობალური სახელმწიფოს მართვა.

თუ თქვენ ცოტაზე მეტად იცნობთ Rust-ს, ეს შეიძლება საშინლად ჟღერდეს: მაგრამ იმის გათვალისწინებით, რომ მოვლენების დამმუშავებლები არიან თავად არიან „გლობალური“ (ანუ: ისინი ურთიერთობენ თამაშის მხოლოდ ერთ მაგალითთან, რომელმაც ჩატვირთა ის დანამატი, რომელიც ისინი არიან in), ასევე აზრი აქვს, რომ ნებისმიერი მონაცემი, რომლის შენახვაც გსურთ თქვენს დანამატში თამაშის მდგომარეობის შესახებ, ასევე უნდა იყოს გლობალური.

საბედნიეროდ, მოდულის API-ს აქვს ამის ფუნქცია!

თქვენი გლობალური სახელმწიფოს ტიპის დასადგენად, შეგიძლიათ დაამატოთ global_state ატრიბუტი მსგავსი ტიპის ზემოთ:

#![allow(unused)]
fn main() {
#[global_state]
#[derive(Default)]
struct State {
    ping_count: u64,
}
}

ასევე მნიშვნელოვანია, რომ მან განახორციელოს Default თვისება: ეს საჭიროა, რადგან ჩვენ ჯერ არ ვუზრუნველყოფთ გზას გლობალური მდგომარეობა ინიციალიზდება on_load მოვლენის დამმუშავებლის მეშვეობით.

მოვლენების დამმუშავებელში ამ გლობალურ მდგომარეობაზე წვდომისთვის, უბრალოდ დაამატეთ მეორე პარამეტრი მოვლენის დამმუშავებელს ასე:

#![allow(unused)]
fn main() {
#[event_handler]
pub fn on_command_ping(chat_cmd: ChatCommandEvent, state: &mut State) -> Result<Vec<String>, String> {
    state.ping_count += 1;
    Ok(vec![format!("Pong! The total number of pings so far is {}", state.ping_count)])
}
}

ახლა ნებისმიერ მოთამაშეს შეუძლია გამოიყენოს /ping და სერვერი ეტყვის, რამდენჯერ იქნა გამოყენებული ბრძანება სერვერის შემდეგ დაიწყო!

მოდულის ზომის შემცირება

იხილეთ min-sized-rust ინფორმაციისთვის Rust-ის ზომის შემცირების შესახებ ბინარები.

მომავალი თემები

მომავალი შესაძლო თემები მოიცავს:

• მეტი ღონისძიების დამმუშავებლები
• ერთეულის ატრიბუტების შეცვლა
• მოდულის მუდმივი მდგომარეობა
• კონტროლი NPC AI
• მეტი მოდულის API ფუნქციები
• დანამატის სპეციფიკური აქტივები

თამაშისშიდა ელემენტების დამატება მოდულიდან

ახალი ჯავშანტექნიკის ან იარაღის ტიპების დასამატებლად არ გჭირდებათ Rust-ის დაწერა და შედგენა, ეს სახელმძღვანელო გაჩვენებთ აუცილებელ ნაბიჯებს.

მოდულის მეტამონაცემები

პირველი, დაიწყეთ ახალი, ცარიელი დირექტორიადან. აღწერილია აქ მსგავსად, ჩვენ უნდა შევქმნათ a plugin.toml ფაილი:

# The name of the plugin (lowercase, no spaces)
name = "cool-armor"

# A list of paths to WASM modules in the plugin (not needed for items).
modules = []

# Plugins required by this plugin (currently unsupported, keep this empty)
dependencies = []

გთხოვთ გაითვალისწინოთ, რომ ყველა აქტივი პირდაპირ ინახება ამ დირექტორიაში, ეს ნიშნავს, რომ ნორმალური assets/ პრეფიქსი ან დირექტორია არ არის საჭირო.

შემდეგ მიჰყევით სახელმძღვანელოს armor შექმნის-ში შექმენით voxel ფაილი voxygen/voxel/armor/<Armor Type>/<Model Name>-ში, აგრეთვე იხილეთ რამდენიმე მოდელის გამოყენება იმის შესახებ, თუ როგორ შეგიძლიათ მოათავსეთ ყველა ნაწილი ერთ VOX ფაილში.

იარაღისთვის გთხოვთ, მიჰყევით ეს სახელმძღვანელო.

ახალი ფაილების დამატება, როგორიცაა voxygen/voxel/weapon/tool/paddle.vox, common/items/weapons/tool/paddle.ron ან common/items/armor/hide/lizard_boots.ron არის მარტივი და აღწერილია ზემოთ მოცემულ სახელმძღვანელოებში (გახსოვდეთ, რომ გამოტოვოთ ზედა დონის assets/ დირექტორია), მაგრამ voxygen/voxel/biped_weapon_manifest.ron უკვე არსებობს თამაშში.

აქ უბრალოდ შექმენით ახალი ფაილი ზუსტად იგივე განლაგებით, როგორც არსებული assets/-ში:

({
    Tool("common.items.weapons.tool.paddle"): (
        vox_spec: ("weapon.tool.paddle", (-2.5, -4.0, -4.0)),
        color: None
    ),
})

Veloren აერთიანებს ამ RON ფაილების შიგთავსს, როდესაც იტვირთება manifest.

voxygen/voxel/humanoid_armor_foot_manifest.ron ასევე მოითხოვს default: ნაწილს, თუმცა ის არ იქნება გამოყენებული:

((
    default: (
        vox_spec: ("armor.misc.foot.none", (-2.5, -3.5, -2.0)),
        color: None
    ),
    map: {
        "common.items.armor.hide.lizard_boots": (
            vox_spec: ("npc.lizardman.male.foot_r", (-2.5, -3.5, -2.0)),
            color: None
        )
    }
))

შემდეგ, როგორც აღწერილია აქ, შექმენით tar ფაილი, რომელიც შეიცავს ყველაფერს ახლად შექმნილი ფაილები და შეიტანეთ სერვერზე assets/plugins/ საქაღალდეში:

tar -cvf ../my_plugin.plugin.tar *

შეგიძლიათ იპოვოთ სამაგალითო დანამატი [GitHub]-ზე (https://github.com/cpetig/veloren-plugin-canoe).

გთხოვთ გაითვალისწინოთ, რომ ამჟამად ჩვენ არ ვაძლევთ რაიმე გარანტიას მოდულების თავსებადობაზე Veloren-ის ვერსიებში, თუმცა ჩვენ შეიძლება დავწეროთ მოდულის მიგრაციის ინსტრუმენტი მომავალში, მონაცემთა ბაზის მიგრაციის ხელსაწყოს მსგავსად, მას შემდეგ რაც დავინახავთ მის საჭიროებას და რესურსებს.

ჟურნალისტებისთვის

#ჟურნალისტებისთვის

თუ გსურთ შეგვატყობინოთ ჩვენს შესახებ, ეს განყოფილება მოგაწოდებთ გარკვეულ მითითებებს თქვენი სამუშაოს გასაადვილებლად. ჩვენ მოვამზადეთ პრეს-ნაკრების ნიმუში ლოგოებით/გამოსახულებებით, რომ გამოვიყენოთ შემდეგ გვერდზე.

თუ გსურთ დაგვიკავშირდეთ ინტერვიუსთვის, ჩვენი Discord არხი საუკეთესო საშუალებაა ჩვენთან დასაკავშირებლად.

ოფიციალური ინფორმაცია ხელმისაწვდომია https://veloren.net/-ზე. სხვა ვებსაიტები შეიძლება იყოს მესამე მხარის ფან-გვერდები და თუმცა შეიცავს სასარგებლო ინფორმაციას, მაგ. არაინგლისური თემებისთვის, ისინი არ უნდა აირიონ ოფიციალურ განცხადებებში.

პრესის ნაკრები

სრული პრეს-ნაკრების ჩამოტვირთვა შესაძლებელია აქ ალტერნატიულად შეგიძლიათ ჩამოტვირთოთ ცალკეული ფაილები GitLab-დან

ლოგოები

ჩვენ გვაქვს 1 სრული ზომის ლოგო, ისევე როგორც ჩვენი ლოგოს ხატული ვერსია, 2 ზომით.

ეკრანის მაგალითები

მოგერიდებათ ეწვიოთ veloren-ის სერვერებს, რომ გააკეთოთ თქვენი საკუთარი ეკრანის ანაბეჭდები, მაგრამ ასევე ყოველთვის შეგიძლიათ გადაიღოთ ზოგიერთი ჩვენი მაგალითის ეკრანის ანაბეჭდები თქვენი ტექსტის გასაფორმებლად.

შიდა ნაწილები

#ინტერიერები

| სურათის წყარო

წიგნის ეს ნაწილი შეიცავს დოკუმენტაციას, თუ როგორ მუშაობს შიდა სისტემები

• Worldgen
• გაყვანილობა

Worldgen (WIP)

(ეს დოკუმენტი აგებულია zesterer#3131-თან ინტერვიუდან)

• გეოლოგიური ეტაპი
• შევსების ეტაპი
• გადაფორმების ეტაპი

გეოლოგიური ეტაპი

• ხმაურის გამოყენებით “წარმოქმნის” თვისებებს, როგორიცაა სიმაღლე, კლდის სიძლიერე, ტენიანობა და ტემპერატურა, რომელიც გამოიყენება შეყვანის სახით.¹
• გაუშვით ეროზიის ალგორითმი, რომელიც დაფუძნებულია ხმაურის მიერ წარმოქმნილ შეყვანებზე.²
• წარმოებული გამომავალი არის სიმაღლის რუკა რამდენიმე სხვა მარტივი ატრიბუტით, როგორიცაა ტენიანობა (მაგრამ არა ბევრი სხვა).³

(ის შენახულია როგორც .bin ფაილი თამაშის აქტივებში)

1. ხმები შეიძლება წარმოვიდგინოთ, როგორც შემთხვევითი ტექსტურა. შეგიძლიათ იხილოთ ხმაურის დონის პირდაპირ სიმაღლე რუქაზე გადათარგმნის მაგალითი აქ დააწკაპუნეთ აქ სურათის გასახსნელად
2. შეგიძლიათ იხილოთ ეროზიის ალგორითმის ლამაზი მარტივი მაგალითი აქ (შეგიძლიათ გამოტოვოთ 3:52) დააწკაპუნეთ აქ YouTube ვიდეოს გასახსნელად
3. სიმაღლის რუკა შეგიძლიათ წარმოიდგინოთ როგორც შიშველი რუკა მხოლოდ „ფორმით“ - მდინარის ხეობები, აუზები, მთის ქედები და ა.შ.

შევსების ეტაპი

(ხდება მაშინ, როდესაც რეალურად აწარმოებთ singleplayer/სერვერს)

გეოლოგიური ეტაპის მონაცემების გამოყენებით ტბები და მდინარეები.

გამოთვალეთ ხეების სიმკვრივე, უდაბნოს დიუნები…

(მაგ. “ფორმის” და ზოგიერთი მეტამონაცემების გამოყენებით გარკვევა უნდა იყოს თუ არა მიწაში არსებული ხვრელი სითხით)

გამომავალი ასე გამოიყურება:

(ამ ეტაპზე შეიცავს_გზა, ბილიკი, გამოქვაბული, ადგილები და ადგილი ცარიელია)

ფორმის შეცვლის ეტაპი

| ადგილობრივი, დროებითი, ბუნებრივი ელემენტები

(ზუსტი ციტატა zesterer-დან საკმაოდ გასაგებია :)
ასე რომ, ეს არის კლდეები და გამოქვაბულები
ჩვენ ვაფენთ მათ მსოფლიოს თავზე სხვადასხვა ტექნიკის გამოყენებით
ზუსტად როგორ არ არის ძალიან მნიშვნელოვანი
გამოქვაბულები და ბილიკები ფაქტობრივად კეთდება იმავე სისტემის გამოყენებით, რომელიც ცნობილია როგორც “გზის” სისტემა
ის ძირითადად უზრუნველყოფს ნაწილებს შორის გრძელი ელემენტების დაკავშირების მეთოდს

გაყვანილობა

ზოგადი სისტემის მიმოხილვა

არაღრმა განმარტებები:

• Circuit კომპონენტი არის მთელი სისტემის ხერხემალი. ის ინახავს ინფორმაციას იმის შესახებ, თუ საიდან და სად უნდა გადაეცეს მონაცემები.
• Wire არის Circuit-ის ნაწილი (ერთ წრეს შეიძლება ჰქონდეს ბევრი მავთული) ის ინახავს მონაცემებს თუ რომელი ერთეულიდან და რა ველის სახელის მნიშვნელობა უნდა გადაეცეს რომელ ერთეულს და ველის სახელს.
• გაყვანილობა კომპონენტი არის “მუშაკი”, მან იცის რა მონაცემები აქვს და რა უნდა შეასრულოს მისი შესრულებისას.
• OutputFormula იღებს შეყვანებს (და საკუთარ კონფიგურაციას) და აწარმოებს გამომავალს.

თუ რაიმეს გამოთვლა შეუძლებელია, მაგრამ მოცემული ადგილი უნდა მოჰყვეს გარკვეულ მნიშვნელობას - ეს გამოიწვევს f32 0-ს.

გაყვანილობის თითოეულ კომპონენტს აქვს 3 ინფორმაცია:

1. შეყვანები (მონაცემები შეყვანილია Circuit-ით)
2. შედეგები (ინფორმაცია როგორ გამოვთვალოთ გამომავალი)
3. მოქმედებები (ინფორმაცია იმის შესახებ, თუ რა უნდა მოხდეს, თუ შეყვანები მოცემულ მდგომარეობაშია)

თითოეულ გაყვანილობას აქვს 3 ეტაპი:

1. გამოთვლა (აიღეთ გაყვანილობის თითოეული კომპონენტი, შეიტანეთ შეყვანები გამომავალ ფორმულებში, გამოიტანეთ შედეგები)
2. ტრანსპორტირება (მიიღეთ წინა ეტაპის შედეგები და Circuit-ის გამოყენებით გადაიტანეთ ისინი)
3. გაგზავნა (მიიღეთ მონაცემები (გაითვალისწინეთ, რომ ჩვენ ვიყენებთ შეცვლილ მდგომარეობას ტრანსპორტით) და დისპეტჩერიზაციის ლოგიკას)

გამოთვლა

• აიღეთ გაყვანილობის ყველა კომპონენტი და მოახაზეთ ისინი
• გამოთვალეთ თითოეული შედეგების გამომავალი ფორმულა
• შექმენით გამოსავლები ტიპით HashMap<E, Hashmap<F, V>> სადაც:
• E არის specs::Entity, რომელიც შეიცავს გაყვანილობის გარკვეულ კომპონენტს.
• F არის String, რომელიც წარმოადგენს ველის სახელს.
• V არის OutputFormula-ის მიღებული მნიშვნელობა. (ამჟამად ყველა შედეგი არის f32)

ტრანსპორტი

• აიღეთ სქემები და თითოეული წრედისთვის აიღეთ მიმაგრებული მავთული *
• აიღეთ ყველა მავთული და თითოეული მავთული *
• მიიღეთ from what entity, from what field, to what entity და to what field მავთულიდან.
• შეასრულეთ მსგავსი რამ to what entity.inputs[to what field] = from what entity[from what field] **

* ეს არის ძირითადად “აიღე ყველა მავთული” დატვირთული სერვერის მონაცემებში

** გაითვალისწინეთ, რომ ჩვენ ვიყენებთ Compute step-ის პროდუქტს, როგორც ამ გამარტივების მარჯვენა მხარეს.

დისპეტჩერიზაცია

• თითოეული მოქმედებისთვის გაყვანილობის ყველა კომპონენტში
• თუ გაყვანილობის მოქმედების ფორმულის გამოსავალი* მეტია ან ტოლია მოქმედების ზღურბლზე…
• გაყვანილობასთან დაკავშირებული თითოეული ეფექტის გაგზავნა

* გამოითვლება შეყვანის გამოყენებით

გამომავალი ფორმულები

მუდმივი

გამოაქვს მუდმივი მნიშვნელობა.

შეყვანა

გამოაქვს შეყვანის ველის მნიშვნელობა მოცემული სახელით.

ლოგიკა

იძლევა გამომავალი ფორმულების შედგენის საშუალებას. ის იღებს left და right გამომავალ ფორმულებს, რომლებიც გამოითვლება და შემდეგ ახორციელებს მათზე ლოგიკას.

ხელმისაწვდომი ლოგიკური ტიპები (მე ვგულისხმობ left და right გამომავალს, როგორც გვერდით):

• Min - ქვედა მხარის დაბრუნების მნიშვნელობა.
• მაქს - უმაღლესი მხარის დაბრუნების მნიშვნელობა.
• ქვე - დაბრუნების მნიშვნელობა left - right.
• ჯამი - დაბრუნების მნიშვნელობა left + right.
• Mul - დაბრუნების მნიშვნელობა left * right.

სინუსური ტალღა (არ განხორციელებული)

იღებს სერვერის დროს და აბრუნებს.

OnCollide

თუ ფიზიკა აფიქსირებს შეჯახებას მიმაგრებული ერთეულისთვის (touching_entities) აბრუნებს მოცემულ მნიშვნელობას.

OnInteract (არ განხორციელებული)

თუ რაიმე ურთიერთქმედებს (მაგ. მოთამაშე „იწევს“ ბერკეტს) აბრუნებს მოცემულ მნიშვნელობას.

სიკვდილზე

აბრუნებს value * count of entities that died in last tick in given radius.

მოქმედებები

ქვირითის ჭურვი

აყალიბებს ჭურვებს ჭურვის კონსტრუქტორის გამოყენებით.

ბლოკის შეჯახების დაყენება (არ განხორციელებული)

ცვლის ბლოკის თვისებებს გარკვეულ კოორდინატებზე.

განათების დაყენება

ცვლის მიმაგრებული ერთეულის LightEmitter თვისებებს.