Як працює комунікація між особами?

У мене є два випадки користувача:

1. Як entity_Aнадіслати take-damageповідомлення entity_B?
2. Як би entity_Aзапитувати entity_BHP?

Ось з чим я стикався до цього часу:

• Черга повідомлень
  1. entity_Aстворює take-damageповідомлення та розміщує його у entity_Bчерзі повідомлень.
  2. entity_Aстворює query-hpповідомлення і публікує його entity_B. entity_Bвзамін створює response-hpповідомлення та розміщує його entity_A.
• Опублікувати / Підписатися
  1. entity_Bпідписується на take-damageповідомлення (можливо, з попередньою фільтрацією, тому доставляється лише відповідне повідомлення). entity_Aвиробляє take-damageповідомлення, яке посилається entity_B.
  2. entity_Aпідписується на update-hpповідомлення (можливо, відфільтровано). Кожен кадр entity_Bтранслює update-hpповідомлення.
• Сигнал / Слоти
  1. ???
  2. entity_Aз'єднує update-hpслот для entity_Bросійського update-hpсигналу.

Чи є щось краще? Чи правильно я розумію, як ці схеми комунікації вписуються в сутність системи ігрового двигуна?

Гарне питання! Перш ніж перейти до конкретних питань, які ви задали, я скажу: не варто недооцінювати силу простоти. Тенпн прав. Майте на увазі, що все, що ви намагаєтеся зробити з цими підходами, - це знайти елегантний спосіб відкласти функціональний виклик або від'єднати абонента від виклику. Я можу порекомендувати судові процедури як напрочуд інтуїтивно зрозумілий спосіб полегшити деякі з цих проблем, але це трохи поза темою. Іноді вам краще просто викликати функцію і жити з тим, що сутність A з'єднана безпосередньо з сутністю B. Див. YAGNI.

З цього приводу я використовував і задоволений моделлю сигнал / слот у поєднанні з простою передачею повідомлення. Я використовував його в C ++ та Lua для досить вдалого заголовку iPhone, який мав дуже щільний графік.

Що стосується випадку сигналу / слота, якщо я хочу, щоб об'єкт A зробив щось у відповідь на те, що зробив об'єкт B (наприклад, розблокувати двері, коли щось помирає), я можу мати суб'єкт А підписатися безпосередньо на смерть суб'єкта В. Або, можливо, суб'єкт А підписався на кожну з груп сутностей, збільшивши лічильник на кожну розстріляну подію та відчинивши двері після того, як N з них загинуло. Крім того, "група сутностей" і "N з них", як правило, є дизайнером, визначеним у даних рівня. (Вбік, це одна область, де дійсно можуть світитися супроводи, наприклад, WaitForMultiple ("Помирає", entA, entB, entC); door.Unlock ();)

Але це може стати громіздким, коли мова йде про реакції, які щільно поєднані з кодом C ++, або по суті ефемерними ігровими подіями: нанесення шкоди, перезавантаження зброї, налагодження, ігровий AI-зворотний зв'язок на основі локації. Тут передача повідомлень може заповнити прогалини. По суті, це зводиться до чогось типу, "скажіть усім суб'єктам в цій області отримати пошкодження за 3 секунди" або "щоразу, коли ви завершите фізику, щоб з'ясувати, хто я стріляв, скажіть їм виконувати цю функцію сценарію". Важко зрозуміти, як це зробити красиво, використовуючи публікацію / підписку або сигнал / слот.

Це легко може бути надмірним (порівняно з прикладом tenpn). Це також може бути неефективним здуттям, якщо у вас багато дій. Але, незважаючи на свої недоліки, ці "повідомлення та події" дуже добре підходять до сценарію ігрового коду (наприклад, у Луа). Код сценарію може визначати та реагувати на власні повідомлення та події без коду С ++. І код скрипту може легко надсилати повідомлення, які викликають код C ++, наприклад, зміна рівнів, відтворення звуків або навіть просто надання зброї встановити, скільки шкоди завдає повідомлення TakeDamage. Це врятувало мені багато часу, тому що мені не довелося постійно дурити з луабіндом. І це дозволило мені зберігати весь свій luabind код в одному місці, тому що його було не так багато. При правильному з'єднанні,

Крім того, мій досвід використання справи №2 полягає в тому, що вам краще поводитися з ним як з подією в іншому напрямку. Замість того, щоб запитувати про стан здоров’я суб'єкта господарювання, скасовуйте подію / надсилайте повідомлення щоразу, коли стан здоров'я змінює суттєві зміни.

Що стосується інтерфейсів, то btw, я закінчив три класи, щоб реалізувати все це: EventHost, EventClient та MessageClient. EventHosts створює слоти, EventClients підписуються / підключаються до них, а MessageClients асоціюють делегата з повідомленням. Зауважте, що ціль делегата MessageClient не обов'язково повинен бути тим самим об'єктом, який належить асоціації. Іншими словами, MessageClients можуть існувати виключно для пересилання повідомлень на інші об'єкти. FWIW, метафора хост / клієнт начебто недоречна. Джерело / раковина можуть бути кращими поняттями.

Вибачте, я якось туди проскочив. Це моя перша відповідь :) Сподіваюся, це мало сенс.

// in entity_a's code:
entity_b->takeDamage();

Ви запитали, як це роблять комерційні ігри. ;)

Більш серйозна відповідь:

Я бачив, як дошки використовували багато. Прості версії - це не що інше, як стійки, які оновлюються такими речами, як HP-суть, який потім може запитувати.

Ваші дошки можуть бути або світовим уявленням про цю сутність (запитайте на дошці Б, що таке HP), або поглядом світу на світ (A запитує свою дошку, щоб побачити, на що спрямована мета HP).

Якщо ви оновлюєте дошки лише у точці синхронізації у кадрі, ви зможете прочитати з них пізніше з будь-якої точки, зробивши багатопотоковість досить простою у виконанні.

Більш просунуті дошки можуть бути більше схожі на хештелі, відображення рядків у значення. Це більш рентабельне, але, очевидно, має витрати на виконання часу.

Дошка традиційно є лише односторонньою комунікацією - вона не справляється з пошкодженням шкоди.

Я трохи вивчив це питання і побачив гарне рішення.

В основному це все стосується підсистем. Це схоже на ідею на дошці, яку згадує tenpn.

Суб'єкти складаються з компонентів, але вони є лише майновими сумками. Жодна поведінка не реалізується в самих суб'єктах.

Скажімо, у суб'єктів господарювання є компонент Health та компонент Damage.

Тоді у вас є кілька MessageManager і три підсистеми: ActionSystem, DamageSystem, HealthSystem. В один момент ActionSystem проводить свої обчислення в ігровому світі та генерує подію:

HIT, source=entity_A target=entity_B power=5

Ця подія публікується в Менеджері повідомлень. Зараз в один момент часу MessageManager проходить через очікувані повідомлення і виявляє, що DamageSystem підписалася на повідомлення HIT. Тепер MessageManager доставляє повідомлення HIT до DamageSystem. DamageSystem проходить перелік сутностей, у яких є компонент "Пошкодження", обчислює точки пошкодження залежно від потужності удару або якогось іншого стану обох об'єктів тощо і публікує подію

DAMAGE, source=entity_A target=entity_B amount=7

HealthSystem підписався на повідомлення DAMAGE, і тепер, коли MessageManager публікує повідомлення DAMAGE в HealthSystem, система HealthSystem має доступ до обох суб'єктів ent_A і entitet_B зі своїми компонентами Health, тому знову HealthSystem може робити свої розрахунки (і, можливо, публікувати відповідну подію до Менеджера повідомлень).

У такому ігровому механізмі формат повідомлень є єдиним з'єднанням між усіма компонентами та підсистемами. Підсистеми та утворення абсолютно незалежні і не знають одне одного.

Я не знаю, реалізував цю ідею якийсь справжній ігровий двигун, чи ні, але це здається досить міцним і чистим, і я сподіваюся, що коли-небудь реалізувати його сам для мого ігрового двигуна рівня любителів.

Чому б не мати глобальної черги повідомлень, наприклад:

messageQueue.push_back(shared_ptr<Event>(new DamageEvent(entityB, 10, entityA)));

З:

DamageEvent(Entity* toDamage, uint amount, Entity* damageDealer);

І наприкінці гри цикл / обробка події:

while(!messageQueue.empty())
{
    Event e = messageQueue.front();
    messageQueue.pop_front();
    e.Execute();
}

Я думаю, що це командна схема. І Execute()це чистий віртуальний в Event, де похідні визначають і роблять речі. Тож ось:

DamageEvent::Execute() 
{
    toDamage->takeDamage(amount); // Or of course, you could now have entityA get points, or a recognition of damage, or anything.
}

Якщо ваша гра одиночна, просто використовуйте метод цільових об'єктів (як запропонував tenpn).

Якщо ви (або хочете підтримати) мультиплеєр (мультикліент, щоб бути точним), скористайтеся чергою команд.

• Коли A завдає шкоди B на клієнті 1, просто викладіть в чергу пошкодження.
• Синхронізуйте черги команд через мережу
• Обробляйте команди в черзі з обох сторін.

Я б сказав: Не використовуйте жодного, доки явно не знадобиться миттєвий зворотній зв'язок від пошкодження.

Суб'єкт / компонент, що приймає збитки / що завгодно, повинен підштовхувати події або до локальної черги подій, або до системи на рівні, що містить пошкодження подій.

Тоді повинна бути накладена система з доступом до обох об'єктів, яка вимагає події від об'єкта a та передає їх суті b. Не створюючи загальної системи подій, яка може будь-що використовувати з будь-якого місця для передачі події будь-що в будь-який час, ви створюєте явний потік даних, який завжди полегшує код налагодження, простіше виміряти ефективність, простіше зрозуміти та прочитати і часто призводить до більш продуманої системи загалом.

Просто зателефонуйте. Не робіть запит на hp, наступні за запитом-hp - якщо ви будете слідувати цій моделі, ви будете в світі.

Можливо, ви також хочете ознайомитися і з Mono Continuations. Я думаю, що це було б ідеально для NPC.

Що ж станеться, якщо у нас є гравці A і B, які намагаються влучити один одного в одному і тому ж циклі оновлення ()? Припустимо, що оновлення () для гравця A відбувається, перш ніж оновлення () для гравця B у циклі 1 (або позначте галочку, або як ви її називали). Я можу придумати два сценарії:

1. Негайна обробка через повідомлення:

   • Гравець A.Update () бачить, що гравець хоче вдарити B, гравець B отримує повідомлення про пошкодження.
   • Гравець B.HandleMessage () оновлює точки вбивства гравця B (він помирає)
   • Гравець B.Update () бачить, що гравець B мертвий .. він не може атакувати гравця A

Це несправедливо, гравець A і B повинен ударити по іншому, гравець B помер, перш ніж вдарити A лише тому, що цей суб'єкт / ігровий об'єкт отримав оновлення () пізніше.

1. Черга повідомлення

   • Гравець A.Update () бачить, що гравець хоче вдарити B, гравець B отримує повідомлення про пошкодження і зберігає його в черзі
   • Гравець A.Update () перевіряє свою чергу, вона порожня
   • Гравець B.Update () спочатку перевіряє ходи, щоб гравець B надіслав повідомлення гравцеві A з пошкодженням
   • плеєр B.Update () також обробляє повідомлення в черзі, обробляє збиток від гравця A
   • Новий цикл (2): Гравець A хоче випити зілля для здоров’я, щоб програвач Player A.Update () був викликаний і рухався процес
   • Гравець A.Update () перевіряє чергу повідомлень і обробляє пошкодження від гравця B

Знову це несправедливо. Гравець A повинен приймати точки влучання в той же оборот / цикл / галочку!