កម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី

យូនីធី គឺជាវេទិកាមួយ ដែលធ្លាប់មានតាំងពីយូរយារណាស់មកហើយ ហើយកំពុងវិវត្តន៍ឥតឈប់ឈរ។ ទោះជាយ៉ាងណាក៏ដោយ នៅពេលធ្វើការនៅក្នុងវាជាមួយនឹងគម្រោងជាច្រើនក្នុងពេលតែមួយ អ្នកនៅតែអាចជួបប្រទះការលំបាកក្នុងការប្រើប្រាស់ប្រភពទូទៅ (.cs) បណ្ណាល័យ (.dll) និងទ្រព្យសម្បត្តិផ្សេងទៀត (រូបភាព សំឡេង ម៉ូដែល ការរៀបចំជាមុន)។ នៅក្នុងអត្ថបទនេះ យើងនឹងនិយាយអំពីបទពិសោធន៍របស់យើងជាមួយនឹងដំណោះស្រាយដើមចំពោះបញ្ហាបែបនេះសម្រាប់ Unity ។

វិធីសាស្រ្តចែកចាយធនធានដែលបានចែករំលែក

មានវិធីច្រើនជាងមួយក្នុងការប្រើប្រាស់ធនធានរួមគ្នាសម្រាប់គម្រោងផ្សេងៗគ្នា ប៉ុន្តែវិធីសាស្រ្តនីមួយៗមានគុណសម្បត្តិ និងគុណវិបត្តិរបស់វា។

1. ការចម្លង - យើងចម្លងធនធានរវាងគម្រោង "ដោយដៃ" ។

ប្រុស:

• សាកសមសម្រាប់ធនធានគ្រប់ប្រភេទ។
• មិនមានបញ្ហាភាពអាស្រ័យ។
• មិនមានបញ្ហាជាមួយ GUIDs ទ្រព្យសកម្មទេ។

គុណវិបត្តិ:

• ឃ្លាំងយក្ស។
• មិនមានលទ្ធភាពនៃកំណែទម្រង់ទេ។
• ការលំបាកក្នុងការតាមដានការផ្លាស់ប្តូរចំពោះធនធានដែលបានចែករំលែក។
• ការលំបាកក្នុងការធ្វើបច្ចុប្បន្នភាពធនធានដែលបានចែករំលែក។

2. ម៉ូឌុលរង Git - ការចែកចាយធនធានចែករំលែកតាមរយៈម៉ូឌុលរងខាងក្រៅ។

ប្រុស:

• អ្នកអាចធ្វើការជាមួយប្រភព។
• អ្នកអាចចែកចាយទ្រព្យសម្បត្តិ។
• មិនមានបញ្ហាភាពអាស្រ័យ។

គុណវិបត្តិ:

• ត្រូវការបទពិសោធន៍។
• Git មិនមានភាពរួសរាយរាក់ទាក់ជាមួយឯកសារគោលពីរទេ - អ្នកនឹងត្រូវភ្ជាប់ LFS ។
• ការគ្រប់គ្រងការចូលប្រើសម្រាប់ឃ្លាំង។
• ភាពលំបាកជាមួយការអាប់ដេត និងបន្ទាបកំណែ។
• ការប៉ះទង្គិចគ្នារបស់ GUID គឺអាចធ្វើទៅបាន ហើយមិនមានអាកប្បកិរិយាច្បាស់លាស់លើផ្នែករបស់ Unity ដើម្បីដោះស្រាយវាទេ។

3. NuGet - ការចែកចាយបណ្ណាល័យចែករំលែកតាមរយៈកញ្ចប់ NuGet ។

ប្រុស:

• ការងារងាយស្រួលជាមួយគម្រោងដែលមិនអាស្រ័យលើយូនីធី។
• កំណែងាយស្រួល និងដំណោះស្រាយភាពអាស្រ័យ។

គុណវិបត្តិ:

• Unity មិនអាចដំណើរការជាមួយកញ្ចប់ NuGet ចេញពីប្រអប់បានទេ (នៅលើ GitHub អ្នកអាចស្វែងរក NuGet Package Manager សម្រាប់ Unity ដែលជួសជុលវា ប៉ុន្តែមានចំនុចមួយចំនួន)។
• ភាពលំបាកក្នុងការចែកចាយទ្រព្យសកម្មផ្សេងៗ។

4. កម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី - ការចែកចាយធនធានចែករំលែកតាមរយៈដំណោះស្រាយដើមសម្រាប់យូនីធី។

ប្រុស:

• ចំណុចប្រទាក់ដើមសម្រាប់ធ្វើការជាមួយកញ្ចប់។
• ការការពារប្រឆាំងនឹងការសរសេរជាន់លើឯកសារ .meta នៅក្នុងកញ្ចប់ដោយសារតែការប៉ះទង្គិច GUID ។
• លទ្ធភាពនៃកំណែទម្រង់។
• សមត្ថភាពក្នុងការចែកចាយធនធានគ្រប់ប្រភេទសម្រាប់យូនីធី។

គុណវិបត្តិ:

• ជម្លោះ GUID នៅតែអាចកើតឡើង។
• មិនមានឯកសារសម្រាប់ការអនុវត្តទេ។

វិធីសាស្រ្តចុងក្រោយមានគុណសម្បត្តិច្រើនជាងគុណវិបត្តិ។ ទោះជាយ៉ាងណាក៏ដោយ ពេលនេះវាមិនមានប្រជាប្រិយភាពខ្លាំងទេ ដោយសារកង្វះឯកសារ ដូច្នេះហើយយើងនឹងបន្តស្វែងយល់ពីវាឱ្យបានលម្អិត។

កម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី

កម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី (UPM) គឺជាឧបករណ៍គ្រប់គ្រងកញ្ចប់។ វាត្រូវបានបន្ថែមនៅក្នុង Unity 2018.1 ហើយត្រូវបានប្រើសម្រាប់តែកញ្ចប់ដែលត្រូវបានបង្កើតឡើងដោយ Unity Technologies ប៉ុណ្ណោះ។ ទោះយ៉ាងណាក៏ដោយ ចាប់ផ្តើមជាមួយនឹងកំណែ 2018.3 វាអាចបន្ថែមកញ្ចប់ផ្ទាល់ខ្លួនបាន។

ចំណុចប្រទាក់កម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី

កញ្ចប់មិនបញ្ចប់នៅក្នុងប្រភពគម្រោង (បញ្ជីទ្រព្យសកម្ម)។ ពួកគេស្ថិតនៅក្នុងថតដាច់ដោយឡែកមួយ។ %projectFolder%/Library/PackageCache ហើយ​មិន​ប៉ះពាល់​ដល់​គម្រោង​ក្នុង​វិធី​ណា​មួយ​ឡើយ ការ​លើក​ឡើង​តែ​មួយ​គត់​របស់​ពួកគេ​ក្នុង​កូដ​ប្រភព​គឺ​នៅ​ក្នុង​ឯកសារ packages/manifest.json.

កញ្ចប់នៅក្នុងប្រព័ន្ធឯកសារគម្រោង

ប្រភពកញ្ចប់

UPM អាចប្រើប្រភពកញ្ចប់ជាច្រើន៖

1. ប្រព័ន្ធឯកសារ។

ប្រុស:

• ល្បឿននៃការអនុវត្ត។
• មិនត្រូវការឧបករណ៍ភាគីទីបីទេ។

គុណវិបត្តិ:

• ភាពលំបាកក្នុងកំណែទម្រង់។
• ការចូលប្រើរួមគ្នាទៅកាន់ប្រព័ន្ធឯកសារគឺត្រូវបានទាមទារសម្រាប់អ្នកគ្រប់គ្នាដែលធ្វើការជាមួយគម្រោង។

2. ឃ្លាំង Git ។

ប្រុស:

• អ្វីដែលអ្នកត្រូវការគឺឃ្លាំង Git ។

គុណវិបត្តិ:

• អ្នកមិនអាចប្តូររវាងកំណែតាមរយៈបង្អួច UPM បានទេ។
• មិនដំណើរការជាមួយឃ្លាំង Git ទាំងអស់។

3. npm ឃ្លាំង។

ប្រុស:

• គាំទ្រយ៉ាងពេញលេញនូវមុខងារ UPM និងត្រូវបានប្រើដើម្បីចែកចាយកញ្ចប់ Unity ផ្លូវការ។

គុណវិបត្តិ:

• បច្ចុប្បន្នមិនអើពើកំណែខ្សែអក្សរទាំងអស់នៃកញ្ចប់លើកលែងតែ "-មើលជាមុន" ។

ខាងក្រោមនេះយើងនឹងពិនិត្យមើលការអនុវត្ត UPM + npm ។ កញ្ចប់នេះមានភាពងាយស្រួល ព្រោះវាអនុញ្ញាតឱ្យអ្នកធ្វើការជាមួយប្រភេទនៃធនធានណាមួយ និងគ្រប់គ្រងកំណែកញ្ចប់ ព្រមទាំងគាំទ្រយ៉ាងពេញលេញនូវចំណុចប្រទាក់ UPM ដើម។

អ្នកអាចប្រើវាជាឃ្លាំង npm Verdaccio. មានព័ត៌មានលម្អិត ឯកសារហើយគ្រាន់តែពាក្យបញ្ជាពីរបីប៉ុណ្ណោះត្រូវបានទាមទារដើម្បីដំណើរការវា។

ការរៀបចំបរិស្ថាន

ដំបូងអ្នកត្រូវដំឡើង node.js.

ការបង្កើតកញ្ចប់មួយ។

ដើម្បីបង្កើតកញ្ចប់អ្នកត្រូវដាក់ឯកសារ package.jsonដែលនឹងពណ៌នាវាទៅកាន់ថតដែលមានមាតិកានៃកញ្ចប់នេះ។ អ្នកត្រូវធ្វើដូចខាងក្រោមៈ

ចូលទៅកាន់ថតគម្រោងដែលយើងចង់បង្កើតកញ្ចប់។

រត់ពាក្យបញ្ជា npm init ហើយបញ្ចូលតម្លៃដែលត្រូវការក្នុងអំឡុងពេលប្រអប់។ សម្រាប់ឈ្មោះ បញ្ជាក់ឈ្មោះក្នុងទម្រង់ដែនបញ្ច្រាស ឧទាហរណ៍ com.plarium.somepackage។
ដើម្បីងាយស្រួលបង្ហាញឈ្មោះកញ្ចប់ សូមបន្ថែមលក្ខណៈសម្បត្តិ displayName ទៅ package.json ហើយបំពេញវា។

ដោយសារ npm គឺ js-oriented ឯកសារមានលក្ខណៈសម្បត្តិសំខាន់ និងស្គ្រីបដែលយើងមិនត្រូវការ ដែល Unity មិនប្រើ។ វាជាការល្អប្រសើរជាងមុនដើម្បីយកពួកវាចេញដើម្បីកុំឱ្យពង្រាយការពិពណ៌នាកញ្ចប់។ ឯកសារគួរតែមើលទៅដូចនេះ៖

1. ចូលទៅកាន់ថតគម្រោងដែលយើងចង់បង្កើតកញ្ចប់។
2. រត់ពាក្យបញ្ជា npm init ហើយបញ្ចូលតម្លៃដែលត្រូវការក្នុងអំឡុងពេលប្រអប់។ សម្រាប់ឈ្មោះ បញ្ជាក់ឈ្មោះក្នុងទម្រង់ដែនបញ្ច្រាស ឧទាហរណ៍ com.plarium.somepackage។
3. ដើម្បីងាយស្រួលបង្ហាញឈ្មោះកញ្ចប់ សូមបន្ថែមលក្ខណៈសម្បត្តិ displayName ទៅ package.json ហើយបំពេញវា។
4. ដោយសារ npm គឺ js-oriented ឯកសារមានលក្ខណៈសម្បត្តិសំខាន់ និងស្គ្រីបដែលយើងមិនត្រូវការ ដែល Unity មិនប្រើ។ វាជាការល្អប្រសើរជាងមុនដើម្បីយកពួកវាចេញដើម្បីកុំឱ្យពង្រាយការពិពណ៌នាកញ្ចប់។ ឯកសារគួរតែមើលទៅដូចនេះ៖

   {
    "name": "com.plarium.somepackage",
    "displayName": "Some Package",
    "version": "1.0.0",
    "description": "Some Package Description",
    "keywords": [
      "Unity",
      "UPM"
    ],
    "author": "AUTHOR",
    "license": "UNLICENSED"
   }

5. បើក Unity ហើយបង្កើតឯកសារ .meta សម្រាប់ package.json (Unity មិនឃើញទ្រព្យសកម្មដោយគ្មានឯកសារ .meta ទេ កញ្ចប់សម្រាប់ Unity ត្រូវបានបើកបានតែអាន)។

ការផ្ញើកញ្ចប់មួយ។

ដើម្បីផ្ញើកញ្ចប់អ្នកត្រូវដំណើរការពាក្យបញ្ជា៖ npm publish --registry *адрес до хранилища пакетов*.

ការដំឡើង និងធ្វើបច្ចុប្បន្នភាពកញ្ចប់តាមរយៈកម្មវិធីគ្រប់គ្រងកញ្ចប់យូនីធី

ដើម្បីបន្ថែមកញ្ចប់មួយទៅគម្រោង Unity អ្នកត្រូវការ៖

1. បន្ថែមទៅឯកសារ manifest.json ព័ត៌មានអំពីប្រភពនៃកញ្ចប់។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវបន្ថែមទ្រព្យសម្បត្តិ scopedRegistries ហើយចង្អុលបង្ហាញវិសាលភាព និងអាសយដ្ឋានប្រភព ដែលវិសាលភាពជាក់លាក់នឹងត្រូវបានស្វែងរក។

   
   "scopedRegistries": [
      {
        "name": "Main",
        "url": "адрес до хранилища пакетов",
        "scopes": [
          "com.plarium"
        ]
      }
    ]
   

2. ចូលទៅកាន់ Unity ហើយបើកបង្អួចកម្មវិធីគ្រប់គ្រងកញ្ចប់ (ការធ្វើការជាមួយកញ្ចប់ផ្ទាល់ខ្លួនគឺមិនខុសពីធ្វើការជាមួយកញ្ចប់ដែលភ្ជាប់មកជាមួយទេ)។
3. ជ្រើសរើសកញ្ចប់ទាំងអស់។
4. ស្វែងរកកញ្ចប់ដែលអ្នកត្រូវការ ហើយបន្ថែមវា។

ធ្វើការជាមួយប្រភព និងការបំបាត់កំហុស

ដើម្បីឱ្យប្រភពភ្ជាប់ជាមួយគម្រោង អ្នកត្រូវបង្កើត និយមន័យសន្និបាត សម្រាប់កញ្ចប់។

ការប្រើប្រាស់កញ្ចប់មិនកំណត់ជម្រើសបំបាត់កំហុសរបស់អ្នកទេ។ ទោះយ៉ាងណាក៏ដោយ នៅពេលធ្វើការជាមួយកញ្ចប់នៅក្នុង Unity អ្នកមិនអាចចូលទៅកាន់ IDE ដោយចុចលើកំហុសនៅក្នុងកុងសូល ប្រសិនបើកំហុសបានកើតឡើងនៅក្នុងកញ្ចប់នោះ។ នេះគឺដោយសារតែការពិតដែលថា Unity មិនឃើញស្គ្រីបជាឯកសារដាច់ដោយឡែកទេ ចាប់តាំងពីពេលប្រើ Assembly Definition ពួកគេត្រូវបានប្រមូលចូលទៅក្នុងបណ្ណាល័យ ហើយបញ្ចូលក្នុងគម្រោង។ នៅពេលធ្វើការជាមួយប្រភពពីគម្រោង ការចុចទៅកាន់ IDE គឺអាចរកបាន។

ស្គ្រីបនៅក្នុងគម្រោងដែលមានកញ្ចប់តភ្ជាប់៖

ស្គ្រីបពីកញ្ចប់ដែលមានចំណុចឈប់ដំណើរការ៖

ការជួសជុលជាបន្ទាន់ចំពោះកញ្ចប់

កញ្ចប់ Unity ដែលបានបន្ថែមទៅគម្រោងគឺបានតែអានប៉ុណ្ណោះ ប៉ុន្តែអាចត្រូវបានកែសម្រួលនៅក្នុងឃ្លាំងសម្ងាត់កញ្ចប់។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវការ:

1. ចូលទៅកាន់កញ្ចប់ក្នុងឃ្លាំងសម្ងាត់កញ្ចប់។

   

2. ធ្វើការផ្លាស់ប្តូរចាំបាច់។
3. ធ្វើបច្ចុប្បន្នភាពកំណែនៅក្នុងឯកសារ package.json.
4. ផ្ញើកញ្ចប់ npm publish --registry *адрес до хранилища пакетов*.
5. ធ្វើបច្ចុប្បន្នភាពកំណែកញ្ចប់ទៅកំណែដែលបានកែតម្រូវតាមរយៈចំណុចប្រទាក់ UPM ។

ជម្លោះ​ការ​នាំចូល​កញ្ចប់

ការប៉ះទង្គិច GUID ខាងក្រោមអាចកើតឡើងនៅពេលនាំចូលកញ្ចប់៖

1. កញ្ចប់ - កញ្ចប់។ ប្រសិនបើនៅពេលនាំចូលកញ្ចប់ វាត្រូវបានគេរកឃើញថាកញ្ចប់ដែលបានបន្ថែមរួចហើយមានទ្រព្យសម្បត្តិដែលមាន GUID ដូចគ្នា ទ្រព្យសម្បត្តិដែលមាន GUIDs ដែលត្រូវគ្នាពីកញ្ចប់ដែលបាននាំចូលនឹងមិនត្រូវបានបញ្ចូលទៅក្នុងគម្រោងនោះទេ។
2. កញ្ចប់គឺជាគម្រោងមួយ។ ប្រសិនបើនៅពេលនាំចូលកញ្ចប់ វាត្រូវបានគេរកឃើញថាគម្រោងមានទ្រព្យសម្បត្តិដែលមាន GUIDs ដែលត្រូវគ្នា នោះទ្រព្យសម្បត្តិពីកញ្ចប់នឹងមិនត្រូវបានបន្ថែមទៅគម្រោងនោះទេ។ ទោះជាយ៉ាងណាក៏ដោយទ្រព្យសម្បត្តិដែលពឹងផ្អែកលើពួកវានឹងចាប់ផ្តើមប្រើប្រាស់ទ្រព្យសម្បត្តិពីគម្រោង។

ការផ្ទេរទ្រព្យសម្បត្តិពីគម្រោងទៅកញ្ចប់មួយ។

ប្រសិនបើអ្នកផ្ទេរទ្រព្យសកម្មពីគម្រោងទៅកញ្ចប់មួយ ខណៈពេលដែល Unity បើក មុខងាររបស់វានឹងត្រូវបានរក្សាទុក ហើយតំណភ្ជាប់នៅក្នុងទ្រព្យសកម្មអាស្រ័យនឹងចាប់ផ្តើមប្រើប្រាស់ទ្រព្យសម្បត្តិពីកញ្ចប់។

សំខាន់៖ នៅពេលចម្លងទ្រព្យសកម្មពីគម្រោងមួយទៅកញ្ចប់មួយ ជម្លោះ "កញ្ចប់ - គម្រោង" ដែលបានពិពណ៌នានៅក្នុងផ្នែកខាងលើនឹងកើតឡើង។

ដំណោះស្រាយដែលអាចកើតមានចំពោះជម្លោះ

1. ការចាត់តាំង GUIDs ឡើងវិញដោយប្រើក្បួនដោះស្រាយផ្ទាល់ខ្លួនរបស់យើងនៅពេលនាំចូលទ្រព្យសម្បត្តិទាំងអស់ដើម្បីលុបបំបាត់ការប៉ះទង្គិច។
2. ការបន្ថែមទ្រព្យសម្បត្តិទាំងអស់ទៅក្នុងគម្រោងមួយ ហើយបន្ទាប់មកបែងចែកវាទៅជាកញ្ចប់។
3. ការបង្កើតមូលដ្ឋានទិន្នន័យដែលមាន GUIDs នៃទ្រព្យសកម្មទាំងអស់ និងដំណើរការសុពលភាពនៅពេលផ្ញើកញ្ចប់។

សេចក្តីសន្និដ្ឋាន

UPM គឺជាដំណោះស្រាយថ្មីមួយសម្រាប់ការចែកចាយធនធានរួមគ្នានៅក្នុង Unity ដែលអាចជាជម្រើសដ៏សក្ដិសមចំពោះវិធីសាស្ត្រដែលមានស្រាប់។ អនុសាសន៍ដែលបានពិពណ៌នានៅក្នុងអត្ថបទគឺផ្អែកលើករណីជាក់ស្តែង។ យើងសង្ឃឹមថាអ្នករកឃើញពួកវាមានប្រយោជន៍។

ប្រភព: www.habr.com