كيفية تطبيق واستخدام قائمة انتظار الرسائل في اللعبة

() translation by (you can also view the original English article)

لعبة عادة ما تتكون من عدة كيانات مختلفة التي تتفاعل مع بعضها البعض. هذه التفاعلات تميل إلى أن تكون حيوية جداً وعميق متصل باللعب. ويغطي هذا البرنامج التعليمي مفهوم وتنفيذ نظام قائمة انتظار الرسائل التي يمكن توحيد التفاعلات بين الكيانات، مما يجعل التعليمات البرمجية الخاصة بك سهلة الصيانة كما أنه ينمو في التعقيد ويمكن التحكم فيها.

مقدمة

قنبلة يمكن أن تتفاعل مع حرف قبل انفجارها والتسبب في الضرر، يمكن أن تلتئم مجموعة مسعف كيان، مفتاح يمكن أن يفتح باب، وهلم جرا. التفاعلات في لعبة لا نهاية لها، ولكن كيف يمكننا أن نبقى رمز اللعبة يمكن التحكم فيها في حين لا تزال قادرة على التعامل مع جميع هذه التفاعلات؟ وكيف نكفل يمكن تغيير التعليمات البرمجية ومواصلة العمل عندما تنشأ تفاعلات جديدة وغير متوقعة؟

Interactions in a game tend to grow in complexity very quickly — التفاعلات في لعبة تميل إلى النمو في التعقيد بشكل سريع جداً.

كما تتم إضافة التفاعلات (وخصوصا منها غير متوقع)، التعليمات البرمجية الخاصة بك ستبدو تشوش أكثر وأكثر. بسرعة سيؤدي تنفيذ السذاجة أن تسأل أسئلة مثل:

"هذا هو الكيان، لذلك ينبغي أن أدعو ()damage الأسلوب، الحق؟ أو هل هو ()damageByItem؟ ربما هذا الأسلوب ()damageByWeapon هو حق واحد؟ "

تخيل أن الفوضى التبعثر يمتد إلى جميع الكيانات اللعبة الخاصة بك، نظراً لأنهم جميعا تتفاعل مع بعضها البعض بطرق مختلفة وغريبة. لحسن الحظ، هناك طريقة أفضل وأسهل، وأكثر قابلية للإدارة للقيام بذلك.

قائمة انتظار الرسائل

أدخل قائمة انتظار الرسائل. والفكرة الأساسية وراء هذا المفهوم هو تنفيذ جميع التفاعلات لعبة كنظام اتصالات (ولا يزال قيد الاستخدام اليوم): تبادل الرسائل. وقد أبلغت الشعب عبر رسائل (رسائل) لعدة قرون لأنه نظام فعال وبسيط.

في عالمنا الحقيقي وظيفة الخدمات، يمكن أن تختلف محتويات كل رسالة، ولكن الطريقة التي فعلياً إرسال وتلقى لا يزال هو نفسه. مرسل يضع المعلومات في مغلف، ويعالج ذلك بوجهة. يمكن الرد الوجهة (أو لا) باتباع الآلية نفسها، مجرد تغيير في "من وإلى" حقول على المغلف.

Interactions made using a message queue system — التفاعلات التي تتم باستخدام نظام قائمة انتظار الرسائل.

بتطبيق هذه الفكرة على اللعبة الخاصة بك، يمكن اعتبار كل التفاعلات فيما بين الكيانات الرسائل. إذا كان يريد كيان لعبة للتفاعل مع آخر (أو مجموعة منها)، كل ذلك القيام به هو إرسال رسالة. سيتم التعامل مع الوجهة أو الرد على الرسالة استناداً إلى المحتوى الخاص به والذي المرسل.

في هذا النهج، يصبح الموحدة للاتصالات فيما بين الكيانات اللعبة. جميع الكيانات ويمكن إرسال رسائل وتلقيها. بغض النظر عن كيف يتم معقدة أو غريبة التفاعل أو الرسالة، قناة الاتصال دائماً لا يزال هو نفسه.

في المقاطع التالية، سوف أصف كيف يمكن فعلا تنفيذ هذا النهج في قائمة انتظار الرسائل في اللعبة الخاصة بك.

تصميم مغلف (رسالة)

دعونا نبدأ بتصميم المغلف، الذي هو العنصر الأساسي في نظام قائمة انتظار الرسائل.

ويمكن وصف مغلف كما في الشكل أدناه:

الحقول الأول والثاني (المرسل والوجهة) هي إشارات إلى الكيان الذي تم إنشاؤها والجهة التي ستقوم بتلقي هذه الرسالة، على التوالي. استخدام هذه الحقول، كل من المرسل والمتلقي معرفة أين ستكون الرسالة ومن أين جاء.

الحقلين الآخرين (نوع والبيانات) العمل معا لضمان معالجة الرسالة بشكل صحيح. حقل نوع توضح ما هذه الرسالة حول؛ على سبيل المثال، إذا كان النوع "الضرر"، المتلقي سوف تتعامل مع هذه الرسالة كأمر إنقاص نقاطها الصحية؛ إذا كان النوع "متابعة"، اعتبر المتلقي كتعليمات لمتابعة شيء – وهلم جرا.

حقل البيانات متصل مباشرة إلى حقل النوع. استخدام الأمثلة السابقة، إذا كان نوع الرسالة "الضرر"، فسيحتوي حقل البيانات عدد – أقول، 10 – الذي يصف مقدار الضرر المتلقي ينبغي أن تنطبق على مراكز الصحة له. إذا كان نوع الرسالة "متابعة"، سوف تحتوي على بيانات كائن تصف الهدف الذي يجب تحقيقه.

يمكن أن يحتوي حقل البيانات على أي معلومات، مما يجعل المغلف وسيلة مرنة للاتصال. يمكن وضع أي شيء في هذا المجال: الإعداد الصحيحة والعوامات والسلاسل وكائنات أخرى حتى. وبحكم التجربة أن المتلقي يجب أن تعرف ما هو في حقل البيانات على أساس ما هو في حقل النوع.

يمكن ترجمة جميع تلك النظرية إلى فئة بسيطة جداً باسم الرسالة. يحتوي على الخصائص الأربعة، واحد لكل حقل:

Message = function (to, from, type, data) {
    // Properties
    this.to = to;        // a reference to the entity that will receive this message
    this.from = from;    // a reference to the entity that sent this message
    this.type = type;    // the type of this message
    this.data = data;    // the content/data of this message
};

كمثال لذلك في استخدام، إذا كان كيان A ما للتي تريد إرسال رسالة "ضرر" للكيان B، كل ذلك القيام به هو إنشاء مثيل كائن فئة الرسالة، قم بتعيين الخاصية to إلى B، تعيين الخاصية من نفسه (الكيان A) ، تعيين نوع "الضرر"، وأخيراً، تعيين البيانات إلى بعض رقم (10، على سبيل المثال):

// Instantiate the two entities
var entityA = new Entity();
var entityB = new Entity();

// Create a message to entityB, from entityA,
// with type "damage" and data/value 10.
var msg = new Message();

msg.to = entityB;
msg.from = entityA;
msg.type = "damage";
msg.data = 10;

// You can also instantiate the message directly
// passing the information it requires, like this:
var msg = new Message(entityB, entityA, "damage", 10);

الآن أن لدينا طريقة لإنشاء رسائل، حان الوقت للتفكير في الفئة التي سيتم تخزينها وتسليمها.

تنفيذ قائمة انتظار

سيتم استدعاء الفئة المسؤولة عن تخزين وتسليم الرسائل MessageQueue. فإنه سيعمل كمكتب للبريد: يتم تسليم كافة الرسائل لهذه الفئة، مما يضمن أنها ستوفد إلى وجهتهم.

الآن، سيكون الفئة MessageQueue هيكل بسيط جداً:

/**
 * This class is responsible for receiving messages and
 * dispatching them to the destination.
 */
MessageQueue = function () {
    this.messages = [];  // list of messages to be dispatched
};

// Add a new message to the queue. The message must be an
// instance of the class Message.
MessageQueue.prototype.add = function(message) {
    this.messages.push(message);
};

رسائل الملكية هي صفيف. سيقوم بتخزين كافة الرسائل الموجودة على وشك تسليمها بواسطة MessageQueue. يتلقى الأسلوب add () كائنًا من الفئة الرسالة كمعلمة ، ويضيف ذلك الكائن إلى قائمة الرسائل.

هنا كيف مثالنا السابق كيان A كيان مراسلة B حول الأضرار التي سيعمل استخدام فئة MessageQueue:

// Instantiate the two entities and the message queue
var entityA = new Entity();
var entityB = new Entity();
var messageQueue = new MessageQueue();

// Create a message to entityB, from entityA,
// with type "damage" and data/value 10.
var msg = new Message(entityB, entityA, "damage", 10);

// Add the message to the queue
messageQueue.add(msg);

ولدينا الآن وسيلة لإنشاء وتخزين الرسائل في قائمة انتظار. لقد حان الوقت لجعلها تصل إلى وجهتها.

تسليم الرسائل

من أجل جعل الفئة MessageQueue فعلا إرسال الرسائل التي تم نشرها، أولاً نحن بحاجة إلى تحديد كيف سيتم التعامل مع الكيانات وتلقى الرسائل. أن أسهل طريقة عن طريق إضافة أسلوب المسمى ()onMessage لكل كيان قادراً على تلقي الرسائل:

/**
 * This class describes a generic entity.
 */
Entity = function () {
    // Initialize anything here, e.g. Phaser stuff
};

// This method is invoked by the MessageQueue
// when there is a message to this entity.
Entity.prototype.onMessage = function(message) {
    // Handle new message here
};

وسوف الفئة MessageQueue استدعاء الأسلوب ()onMessage لكل كيان من الكيانات التي يجب أن تتلقى رسالة. تمرير المعلمة إلى أن الأسلوب هو الرسالة التي يجري بها نظام قائمة الانتظار (والتي يتلقاها الوجهة).

الفئة MessageQueue سترسل الرسائل الموجودة في قائمة الانتظار في كل مرة، في أسلوب ()dispatch:

/**
 * This class is responsible for receiving messages and
 * dispatching them to the destination.
 */
MessageQueue = function () {
    this.messages = [];  // list of messages to be dispatched
};

MessageQueue.prototype.add = function(message) {
    this.messages.push(message);
};

// Dispatch all messages in the queue to their destination.
MessageQueue.prototype.dispatch = function() {
    var i, entity, msg;

    // Iterave over the list of messages
    for(i = 0; this.messages.length; i++) {
        // Get the message of the current iteration
        msg = this.messages[i];

        // Is it valid?
        if(msg) {
            // Fetch the entity that should receive this message 
            // (the one in the 'to' field)
            entity = msg.to;

            // If that entity exists, deliver the message.
            if(entity) {
                entity.onMessage(msg);
            }

            // Delete the message from the queue
            this.messages.splice(i, 1);
            i--;
        }
    }
};

هذا الأسلوب بالتكرار عبر كافة الرسائل في قائمة الانتظار، وعن كل رسالة، لحقل to يستخدم لجلب إشارة إلى المتلقي. ثم يتم استدعاء الأسلوب ()onMessage للمتلقي، مع الرسالة الحالية كمعلمة، والرسالة التي تم تسليمها ثم إزالة من قائمة MessageQueue. وتتكرر هذه العملية حتى يتم إرسال كافة الرسائل.

باستخدام قائمة انتظار الرسائل

لقد حان الوقت لمشاهدة كافة تفاصيل تنفيذ هذا العمل معا. دعونا استخدام نظامنا قائمة انتظار الرسائل في عرض بسيط جداً يتألف من نقل بعض الكيانات التي تتفاعل مع بعضها البعض. توخياً للبساطة، سوف نعمل مع ثلاثة كيانات: الشافي وعداء والصياد.

ويضم حانة صحة العداء والتحركات عشوائياً. المعالج سوف تلتئم الشافي أي عداء يمر قريبة؛ من ناحية أخرى، سوف الصياد ضررا بأي عداء القريبة. سيتم التعامل مع جميع التفاعلات باستخدام نظام قائمة انتظار الرسائل.

إضافة قائمة انتظار الرسائل

دعونا نبدأ من خلال إنشاء playState الذي يحتوي على قائمة بالكيانات (المعالجين والعدائين والصيادين) ومثيل لفئة MessageQueue:

var PlayState = function() {
    var entities;  	// list of entities in the game
	var messageQueue;	// the message queue (dispatcher)

	this.create = function() {
		// Initialize the message queue
		messageQueue = new MessageQueue();

		// Create a group of entities.
		entities = this.game.add.group();
	};

	this.update = function() {
		// Make all messages in the message queue
    	// reach their destination.
		messageQueue.dispatch();
	};
};

في لعبة التكرار الحلقي، ممثلة بواسطة الأسلوب ()update ، يتم استدعاء الأسلوب ()dispatch لقائمة انتظار الرسائل، حيث يتم تسليم كافة الرسائل في نهاية كل إطار اللعبة.

مشيراً إلى العدائين

الفئة عداء له البنية التالية:

/**
 * This class describes an entity that just
 * wanders around.
 */
Runner = function () {
    // initialize Phaser stuff here...
};

// Invoked by the game on each frame
Runner.prototype.update = function() {
    // Make things move here...
}

// This method is invoked by the message queue
// to make the runner deal with incoming messages.
Runner.prototype.onMessage = function(message) {
    var amount;

    // Check the message type so it's possible to
    // decide if this message should be ignored or not.
    if(message.type == "damage") {
        // The message is about damage.
        // We must decrease our health points. The amount of
        // this decrease was informed by the message sender
        // in the 'data' field.
        amount = message.data;
        this.addHealth(-amount);

    } else if (message.type == "heal") {
        // The message is about healing.
        // We must increase our health points. Again the amount of
        // health points to increase was informed by the message sender
        // in the 'data' field.
        amount = message.data;
        this.addHealth(amount);

    } else {
        // Here we deal with messages we are not able to process.
        // Probably just ignore them :)
    }
};

الجزء الأهم هو الأسلوب ()onMessage، يتم استدعاؤه بواسطة قائمة انتظار الرسائل في كل مرة هناك رسالة جديدة لهذا المثيل. كما هو موضح سابقا، يتم استخدام نوع الحقل في الرسالة أن تقرر ما كل شيء عن هذه الاتصالات.

استناداً إلى النوع الرسالة، يتم تنفيذ الإجراء الصحيح: إذا كان نوع الرسالة "الضرر "، انخفضت نقاط صحية؛ إذا كان نوع الرسالة "الشفاء"، يتم زيادة نقاط صحية. ويعرف عدد النقاط الصحية لزيادة أو إنقاص بالمرسل في حقل البيانات من الرسالة.

في playState، نضيف بعض العدائين إلى قائمة الكيانات:

var PlayState = function() {
    // (...)

	this.create = function() {
		// (...)

		// Add runners
		for(i = 0; i < 4; i++) {
			entities.add(new Runner(this.game, this.game.world.width * Math.random(), this.game.world.height * Math.random()));
		}
	};

	// (...)
};

والنتيجة أربع عداءات يتحرك عشوائياً:

إضافة الصياد

يحتوي صنف الصياد على البنية التالية:

/**
 * This class describes an entity that just
 * wanders around hurting the runners that pass by.
 */
Hunter = function (game, x, y) {
    // initialize Phaser stuff here
};

// Check if the entity is valid, is a runner, and is within the attack range.
Hunter.prototype.canEntityBeAttacked = function(entity) {
    return  entity && entity != this &&
            (entity instanceof Runner) &&
            !(entity instanceof Hunter) &&
            entity.position.distance(this.position) <= 150;
};

// Invoked by the game during the game loop.
Hunter.prototype.update = function() {
    var entities, i, size, entity, msg;

    // Get a list of entities
    entities = this.getPlayState().getEntities();

    for(i = 0, size = entities.length; i < size; i++) {
        entity = entities.getChildAt(i);

        // Is this entity a runner and is it close?
        if(this.canEntityBeAttacked(entity)) {
            // Yeah, so it's time to cause some damage!
            msg = new Message(entity, this, "damage", 2);

            // Send the message away!
            this.getMessageQueue().add(msg); // or just entity.onMessage(msg); if you want to bypass the message queue for some reasong.
        }
    }
};

// Get a reference to the game's PlayState
Hunter.prototype.getPlayState = function() {
    return this.game.state.states[this.game.state.current];
};

// Get a reference to the game's message queue.
Hunter.prototype.getMessageQueue = function() {
    return this.getPlayState().getMessageQueue();
};

الصيادين أيضا التحرك، بل أنها سوف تسبب ضررا لجميع المتسابقين التي قريبة. وينفذ هذا السلوك في الأسلوب ()update، حيث يتم تفتيش جميع الكيانات اللعبة والعدائين هي بعث برسالة حول الأضرار.

يتم إنشاء الرسالة الأضرار على النحو التالي:

1	msg = new Message(entity, this, "damage", 2);

تحتوي الرسالة على معلومات حول الوجهة (الكيان، في هذه الحالة، وهو الكيان الذي يجري تحليله في التكرار الحالي)، المرسل (هذا، الذي يمثل الصياد الذي يتم تنفيذ الهجوم)، ونوع الرسالة ("الضرر") مقدار الضرر (2، وفي هذه الحالة، تم تعيينها لحقل البيانات من الرسالة).

ثم يتم نشر الرسالة إلى الوجهة عن طريق (this.getMessageQueue().add(msg الأوامر، التي تضيف الرسالة التي تم إنشاؤها حديثا إلى قائمة انتظار الرسائل.

وأخيراً، نضيف الصياد إلى قائمة الكيانات playState:

var PlayState = function() {
    // (...)

    this.create = function() {
		// (...)
        
		// Add hunter at position (20, 30)
    	entities.add(new Hunter(this.game, 20, 30));
	};

	// (...)
};

والنتيجة هي بعض العدائين يتحرك، وتلقى رسائل من الصياد كما أنها تحصل على مقربة من بعضها البعض:

وأضفت المغلفات تحلق كمساعدات البصرية للمساعدة في إظهار ما يحدث.

إضافة المعالج

فئة الشفاء بالبنية التالية:

/**
 * This class describes an entity that is
 * able to heal any runner that passes nearby.
 */
Healer = function (game, x, y) {
    // Initializer Phaser stuff here
};

Healer.prototype.update = function() {
    var entities, i, size, entity, msg;

    // The the list of entities in the game
    entities = this.getPlayState().getEntities();

    for(i = 0, size = entities.length; i < size; i++) {
        entity = entities.getChildAt(i);

        // Is it a valid entity?
        if(entity) {
            // Check if the entity is within the healing radius
            if(this.isEntityWithinReach(entity)) {
                // The entity can be healed!
                // First of all, create a new message regaring the healing
                msg = new Message(entity, this, "heal", 2);

                // Send the message away!
                this.getMessageQueue().add(msg); // or just entity.onMessage(msg); if you want to bypass the message queue for some reasong.
            }
        }
    }
};

// Check if the entity is neither a healer nor a hunter and is within the healing radius.
Healer.prototype.isEntityWithinReach = function(entity) {
    return !(entity instanceof Healer) && !(entity instanceof Hunter) && entity.position.distance(this.position) <= 200;
};

// Get a reference to the game's PlayState
Healer.prototype.getPlayState = function() {
    return this.game.state.states[this.game.state.current];
};

// Get a reference to the game's message queue.
Healer.prototype.getMessageQueue = function() {
    return this.getPlayState().getMessageQueue();
};

التعليمات البرمجية وهيكل مشابهة جداً للفئة هنتر، باستثناء عدد قليل من الاختلافات. وبالمثل للتنفيذ للصياد، تتكرر الأسلوب ()update للمعالج على قائمة الكيانات في اللعبة، والمراسلة أي كيان داخل نطاقه الشفاء:

1	msg = new Message(entity, this, "heal", 2);

كما تحتوي الرسالة على وجهة (كيان)، مرسل (هذا، وهو المعالج يقوم بتنفيذ الإجراء)، اكتب رسالة ("شفاء") وعدد النقاط الشفاء (2، تم تعيينها في حقل البيانات من الرسالة).

نقوم بإضافة الشفاء إلى قائمة الكيانات playState بنفس الطريقة فعلنا مع الصياد، والنتيجة مشهد مع المتسابقين وصياد من معالج:

وهذا كل شيء! ولدينا ثلاثة كيانات مختلفة تتفاعل مع بعضها البعض عن طريق تبادل الرسائل.

مناقشة حول المرونة

نظام قائمة الانتظار هذه الرسائل طريقة مرنة لإدارة التفاعلات في لعبة. التفاعلات تتم عبر قناة اتصال موحد وله واجهة واحدة سهلة الاستخدام وتنفيذ.

مع ازدياد في تعقيد اللعبة الخاصة بك، قد تكون هناك حاجة تفاعلات جديدة. قد يكون بعضها غير متوقع تماما، حيث أنك يجب أن تكيف التعليمات البرمجية الخاصة بك للتعامل معها. إذا كنت تستخدم نظام قائمة انتظار الرسائل، وهذا مدعاة لإضافة رسالة جديدة في مكان ما، والتعامل مع الأمر في مكان آخر.

على سبيل المثال، تخيل تريد جعل الصياد تتفاعل مع الشفاء؛ لديك فقط لجعل الصياد إرسال رسالة مع التفاعل الجديد — على سبيل المثال، "الفرار" – والتأكد من أن الشفاء يمكن التعامل معها في onMessage:

// In the Hunter class:
Hunter.prototype.someMethod = function() {
    // Get a reference to a nearby healer
    var healer = this.getNearbyHealer();
    
    // Create message about fleeing a place
    var place = {x: 30, y: 40};
    var msg = new Message(entity, this, "flee", place);

    // Send the message away!
    this.getMessageQueue().add(msg);
};

// In the Healer class:
Healer.prototype.onMessage = function(message) {
    if(message.type == "flee") {
        // Get the place to flee from the data field in the message
        var place = message.data;
        
        // Use the place information
        flee(place.x, place.y);
    }
};

لماذا لا مجرد إرسال رسائل مباشرة؟

على الرغم من أن تبادل الرسائل بين الكيانات يمكن أن تكون مفيدة، كنت قد يكون التفكير لماذا هناك حاجة MessageQueue بعد كل. لا يمكنك فقط استدعاء الأسلوب ()onMessage للمتلقي نفسك بدلاً من الاعتماد على MessageQueue، كما في التعليمات البرمجية أدناه؟

Hunter.prototype.someMethod = function() {
    // Get a reference to a nearby healer
    var healer = this.getNearbyHealer();
    
    // Create message about fleeing a place
    var place = {x: 30, y: 40};
    var msg = new Message(entity, this, "flee", place);

    // Bypass the MessageQueue and directly deliver
    // the message to the healer.
    healer.onMessage(msg);
};

يمكن بالتأكيد تنفيذ نظام لرسالة مثل هذه، ولكن استخدام MessageQueue بعض المزايا.

على سبيل المثال، بإضفاء الطابع المركزي ديسباتشمينت الرسائل، يمكنك تنفيذ بعض الميزات الرائعة مثل تأخر الرسائل، القدرة على رسالة مجموعة من الكيانات، ومعلومات التصحيح البصرية (مثل المغلفات الطيران المستخدمة في هذا البرنامج التعليمي).

هناك مجالاً للإبداع في الفئة MessageQueue، والأمر متروك لكم ومتطلبات اللعبة الخاصة بك.

الاستنتاج

معالجة التفاعلات بين الكيانات اللعبة باستخدام نظام قائمة انتظار رسالة وسيلة للحفاظ على التعليمات البرمجية الخاصة بك المنظمة والاستعداد للمستقبل. تفاعلات جديدة يمكن بسهولة وبسرعة إضافة، حتى الأفكار الأكثر تعقيداً، طالما أنها هي مغلفة كرسائل.

كما تمت مناقشته في البرنامج التعليمي، يمكنك تجاهل استخدام قائمة انتظار الرسالة المحورية ومجرد إرسال رسائل مباشرة إلى الكيانات. يمكن أيضا مركزة الاتصال باستخدام برقية (الفئة MessageQueue في حالتنا) لإفساح المجال للميزات الجديدة في المستقبل، مثل تأخر الرسائل.

أرجو أن يجد هذا النهج مفيداً وإضافته إلى حزام أداة مطور اللعبة الخاصة بك. الأسلوب الذي قد يبدو وكأنه مبالغة للمشاريع الصغيرة، ولكن من المؤكد سيوفر لك بعض الصداع في الأجل الطويل للألعاب أكبر.