เพื่อความสนุกสนานฉันพยายามเขียนเกมกระดานโปรดของลูกชายเป็นซอฟต์แวร์ชิ้นหนึ่ง ในที่สุดฉันคาดหวังว่าจะสร้าง WPF UI ขึ้นมา แต่ตอนนี้ฉันกำลังสร้างเครื่องที่จำลองเกมและกฎของมัน

เมื่อฉันทำเช่นนี้ฉันมักจะเห็นปัญหาที่ฉันคิดว่าเป็นเรื่องธรรมดาของเกมกระดานหลาย ๆ เกมและบางทีคนอื่น ๆ ก็แก้ปัญหาได้ดีกว่าฉัน

(โปรดทราบว่า AI ในการเล่นเกมและรูปแบบรอบ ๆ ประสิทธิภาพสูงนั้นไม่น่าสนใจสำหรับฉัน)

จนถึงตอนนี้รูปแบบของฉันคือ:

• หลายประเภทที่ไม่เปลี่ยนรูปแทนเอนทิตีในกล่องเกมเช่นลูกเต๋าหมากฮอสไพ่กระดานช่องว่างบนกระดานเงินเป็นต้น

• วัตถุสำหรับผู้เล่นแต่ละคนซึ่งมีทรัพยากรของผู้เล่น (เช่นเงินคะแนน) ชื่อของพวกเขา ฯลฯ

• วัตถุที่แสดงถึงสถานะของเกม: ผู้เล่นผู้ที่หันมาใช้เลย์เอาต์ของพีคบนกระดานเป็นต้น

• เครื่องสถานะที่จัดการลำดับการเลี้ยว ตัวอย่างเช่นหลายเกมมีเกมก่อนเกมเล็ก ๆ ที่ผู้เล่นแต่ละคนจะหมุนเพื่อดูว่าใครไปก่อน นั่นคือสถานะเริ่มต้น เมื่อเทิร์นของผู้เล่นเริ่มขึ้นก่อนอื่นพวกเขาจะกลิ้งจากนั้นจึงเคลื่อนที่จากนั้นพวกเขาจะต้องเต้นเข้าที่จากนั้นผู้เล่นคนอื่น ๆ จะเดาว่าพวกเขาเป็นไก่พันธุ์อะไรจากนั้นพวกเขาจะได้รับคะแนน

มีศิลปะก่อนหน้านี้ที่ฉันสามารถใช้ประโยชน์ได้หรือไม่?

แก้ไข:สิ่งหนึ่งที่ฉันเพิ่งรู้เมื่อเร็ว ๆ นี้คือสถานะของเกมสามารถแบ่งออกเป็นสองประเภท:

• รัฐสิ่งประดิษฐ์เกม "ฉันมีเงิน $ 10" หรือ "มือซ้ายของฉันเป็นสีน้ำเงิน"

• รัฐลำดับเกม "ฉันรีดสองเท่าสองครั้งคนต่อไปทำให้ฉันติดคุก" เครื่องของรัฐอาจสมเหตุสมผลที่นี่

แก้ไข:สิ่งที่ฉันกำลังมองหาจริงๆนี่คือวิธีที่ดีที่สุดในการใช้เกมเทิร์นเบสแบบผู้เล่นหลายคนเช่นหมากรุกหรือข่วนหรือการผูกขาด ฉันแน่ใจว่าฉันสามารถสร้างเกมดังกล่าวได้โดยการทำงานตั้งแต่ต้นจนจบ แต่เช่นเดียวกับรูปแบบการออกแบบอื่น ๆ อาจมีบางวิธีที่จะทำให้สิ่งต่าง ๆ ดำเนินไปอย่างราบรื่นมากขึ้นซึ่งไม่ชัดเจนหากไม่มีการศึกษาอย่างรอบคอบ นั่นคือสิ่งที่ฉันหวังไว้

ดูเหมือนว่านี่จะเป็นกระทู้เก่า 2 เดือนที่ฉันเพิ่งสังเกตเห็นตอนนี้ แต่สิ่งที่น่ากลัว ฉันเคยออกแบบและพัฒนากรอบการเล่นเกมสำหรับเกมกระดานเชิงพาณิชย์ในเครือข่ายมาก่อน เรามีประสบการณ์ที่น่าพอใจมากในการทำงานกับมัน

เกมของคุณอาจอยู่ในสถานะ (ใกล้เคียงกับ) จำนวนไม่ จำกัด เนื่องจากการเรียงสับเปลี่ยนของสิ่งต่างๆเช่นผู้เล่น A มีเงินเท่าไหร่ผู้เล่น B มีเงินเท่าไหร่และอื่น ๆ ... ดังนั้นฉันค่อนข้างแน่ใจว่าคุณต้องการ อยู่ห่างจากเครื่องจักรของรัฐ

แนวคิดเบื้องหลังเฟรมเวิร์กของเราคือการแสดงสถานะเกมเป็นโครงสร้างด้วยฟิลด์ข้อมูลทั้งหมดที่รวมกันให้สถานะเกมที่สมบูรณ์ (เช่น: ถ้าคุณต้องการบันทึกเกมลงในดิสก์คุณต้องเขียนโครงสร้างนั้นออก)

เราใช้รูปแบบคำสั่งเพื่อแสดงถึงการกระทำของเกมที่ถูกต้องทั้งหมดที่ผู้เล่นสามารถทำได้ นี่คือตัวอย่างการดำเนินการ:

class RollDice : public Action
{
  public:
  RollDice(int player);

  virtual void Apply(GameState& gameState) const; // Apply the action to the gamestate, modifying the gamestate
  virtual bool IsLegal(const GameState& gameState) const; // Returns true if this is a legal action
};

ดังนั้นคุณจะเห็นว่าในการตัดสินใจว่าการเคลื่อนไหวนั้นถูกต้องหรือไม่คุณสามารถสร้างการกระทำนั้นแล้วเรียกใช้ฟังก์ชัน IsLegal โดยส่งผ่านในสถานะเกมปัจจุบัน หากถูกต้องและผู้เล่นยืนยันการกระทำคุณสามารถเรียกใช้ฟังก์ชัน Apply เพื่อแก้ไขสถานะของเกมได้ ด้วยการตรวจสอบให้แน่ใจว่ารหัสการเล่นเกมของคุณสามารถแก้ไขสถานะเกมได้โดยการสร้างและส่งการดำเนินการทางกฎหมายเท่านั้น (กล่าวอีกนัยหนึ่งกลุ่มวิธีการดำเนินการ :: ใช้เป็นสิ่งเดียวที่แก้ไขสถานะเกมโดยตรง) คุณจึงมั่นใจได้ว่าเกมของคุณ รัฐจะไม่ถูกต้อง นอกจากนี้ด้วยการใช้รูปแบบคำสั่งคุณทำให้สามารถทำให้การเคลื่อนไหวที่ต้องการของผู้เล่นของคุณเป็นอนุกรมและส่งผ่านเครือข่ายเพื่อดำเนินการในสถานะเกมของผู้เล่นคนอื่น

ในที่สุดก็มี gotcha หนึ่งเดียวกับระบบนี้ที่กลายเป็นทางออกที่ค่อนข้างสง่างาม บางครั้งการดำเนินการจะมีสองขั้นตอนขึ้นไป ตัวอย่างเช่นผู้เล่นอาจมีที่ดินใน Monopoly และตอนนี้ต้องตัดสินใจใหม่ สถานะของเกมเป็นอย่างไรระหว่างที่ผู้เล่นทอยลูกเต๋าและก่อนที่พวกเขาจะตัดสินใจซื้อทรัพย์สินหรือไม่? เราจัดการสถานการณ์เช่นนี้โดยนำเสนอสมาชิก "Action Context" ของสถานะเกมของเรา โดยปกติบริบทการดำเนินการจะเป็นโมฆะแสดงว่าขณะนี้เกมไม่ได้อยู่ในสถานะพิเศษใด ๆ เมื่อผู้เล่นทอยลูกเต๋าและการทอยลูกเต๋าถูกนำไปใช้กับสถานะของเกมผู้เล่นจะรู้ว่าผู้เล่นได้ลงจอดในทรัพย์สินที่ไม่ได้เป็นเจ้าของและสามารถสร้าง "PlayerDecideToPurchaseProperty" ใหม่ได้ บริบทการดำเนินการที่มีดัชนีของผู้เล่นที่เรากำลังรอการตัดสินใจ เมื่อการดำเนินการ RollDice เสร็จสิ้นสถานะเกมของเราแสดงว่ากำลังรอให้ผู้เล่นที่ระบุตัดสินใจว่าจะซื้ออสังหาริมทรัพย์ ขณะนี้วิธีการ IsLegal ของการกระทำอื่น ๆ ทั้งหมดเป็นเรื่องง่ายที่จะส่งคืนเท็จยกเว้นการกระทำ "BuyProperty" และ "PassPropertyPurchaseOpportunity" ซึ่งจะถูกต้องตามกฎหมายก็ต่อเมื่อสถานะของเกมมีบริบทการดำเนินการ "PlayerDecideToPurchaseProperty"

ด้วยการใช้บริบทแอ็คชั่นไม่เคยมีจุดใดจุดหนึ่งในช่วงชีวิตของเกมกระดานที่โครงสร้างสถานะของเกมไม่ได้แสดงถึงสิ่งที่เกิดขึ้นในเกม ณ เวลานั้นอย่างสมบูรณ์ นี่เป็นคุณสมบัติที่พึงปรารถนาของระบบเกมกระดานของคุณ การเขียนโค้ดจะง่ายขึ้นมากเมื่อคุณสามารถค้นหาทุกสิ่งที่คุณอยากรู้เกี่ยวกับสิ่งที่เกิดขึ้นในเกมโดยการตรวจสอบโครงสร้างเพียงอย่างเดียว

นอกจากนี้ยังขยายไปยังสภาพแวดล้อมเครือข่ายได้เป็นอย่างดีซึ่งลูกค้าสามารถส่งการกระทำของตนผ่านเครือข่ายไปยังเครื่องโฮสต์ซึ่งสามารถใช้การดำเนินการกับสถานะเกม "อย่างเป็นทางการ" ของโฮสต์แล้วสะท้อนการกระทำนั้นกลับไปยังไคลเอนต์อื่น ๆ ให้พวกเขานำไปใช้กับสถานะเกมจำลองของพวกเขา

ฉันหวังว่านี่จะกระชับและเป็นประโยชน์

โครงสร้างพื้นฐานของเครื่องยนต์เกมของคุณใช้รูปแบบรัฐ ไอเท็มในกล่องเกมของคุณคือเสื้อกล้ามของคลาสต่างๆ โครงสร้างของแต่ละรัฐอาจจะใช้รูปแบบกลยุทธ์หรือวิธีที่แม่แบบ

โรงงานใช้ในการสร้างผู้เล่นที่จะแทรกเข้าไปในรายชื่อของผู้เล่นเดี่ยวอีก GUI ที่จะให้ดูในเครื่องยนต์เกมโดยใช้รูปแบบการสังเกตการณ์และโต้ตอบกับเรื่องนี้โดยใช้หนึ่งในคำสั่งวัตถุหลายสร้างขึ้นโดยใช้รูปแบบคำสั่ง การใช้ Observer และ Command สามารถใช้กับบริบทของPassive View ได้แต่รูปแบบ MVP / MVC สามารถใช้งานได้โดยขึ้นอยู่กับความชอบ เมื่อคุณบันทึกเกมคุณจะต้องคว้าของที่ระลึกเกี่ยวกับสถานะปัจจุบัน

ฉันขอแนะนำให้ดูรูปแบบบางอย่างในไซต์นี้และดูว่ามีรูปแบบใดที่ดึงดูดคุณเป็นจุดเริ่มต้น อีกครั้งหัวใจของบอร์ดเกมของคุณคือเครื่องจักรของรัฐ เกมส่วนใหญ่จะแสดงโดยสองสถานะก่อนเกม / การตั้งค่าและเกมจริง แต่คุณสามารถมีสถานะได้มากกว่านี้หากเกมที่คุณกำลังสร้างโมเดลมีโหมดการเล่นที่แตกต่างกันหลายโหมด รัฐไม่จำเป็นต้องเรียงตามลำดับตัวอย่างเช่น wargame Axis & Battles มีกระดานต่อสู้ที่ผู้เล่นสามารถใช้เพื่อแก้ไขการต่อสู้ได้ ดังนั้นจึงมีสามสถานะก่อนเกมกระดานหลักกระดานต่อสู้โดยเกมจะสลับไปมาระหว่างกระดานหลักและกระดานต่อสู้อย่างต่อเนื่อง แน่นอนว่าลำดับการเลี้ยวสามารถแสดงโดยเครื่องสถานะ

ฉันเพิ่งเสร็จสิ้นการออกแบบและใช้งานเกมตามสถานะโดยใช้ความหลากหลาย

การใช้คลาสนามธรรมพื้นฐานที่เรียกGamePhaseว่ามีวิธีการหนึ่งที่สำคัญ

abstract public GamePhase turn();

สิ่งนี้หมายความว่าทุกGamePhaseวัตถุถือสถานะปัจจุบันของเกมและการเรียกดูที่สถานะปัจจุบันของมันและส่งกลับต่อไปturn()GamePhase

คอนกรีตแต่ละชิ้นGamePhaseมีตัวสร้างที่ยึดสถานะของเกมทั้งหมด แต่ละturn()วิธีจะมีกฎของเกมอยู่ในตัว แม้ว่าสิ่งนี้จะกระจายกฎไปรอบ ๆ แต่ก็ทำให้กฎที่เกี่ยวข้องอยู่ใกล้กัน ผลลัพธ์สุดท้ายของแต่ละรายการturn()เป็นเพียงการสร้างสถานะถัดไปGamePhaseและส่งผ่านในสถานะเต็มไปยังเฟสถัดไป

สิ่งนี้ช่วยให้turn()มีความยืดหยุ่นมาก ขึ้นอยู่กับเกมของคุณสถานะที่กำหนดสามารถแตกแขนงไปยังเฟสประเภทต่างๆได้ ซึ่งจะสร้างกราฟของทุกช่วงของเกม

ในระดับสูงสุดรหัสในการขับเคลื่อนนั้นง่ายมาก:

GamePhase state = ...initial phase
while(true) {
    // read the state, do some ui work
    state = state.turn();
}

สิ่งนี้มีประโยชน์อย่างมากเนื่องจากตอนนี้ฉันสามารถสร้างสถานะ / เฟสของเกมเพื่อทดสอบได้อย่างง่ายดาย

ตอนนี้เพื่อตอบคำถามส่วนที่สองของคุณสิ่งนี้ทำงานอย่างไรในผู้เล่นหลายคน ภายในบางอย่างGamePhaseของที่จำเป็นต้องมีการป้อนข้อมูลของผู้ใช้จากการเรียกร้องturn()จะถามในปัจจุบันPlayerของพวกเขาStrategyได้รับในปัจจุบันรัฐ / เฟส Strategyเป็นเพียงส่วนต่อประสานของการตัดสินใจที่เป็นไปได้ทั้งหมดที่Playerสามารถทำได้ การตั้งค่านี้ยังอนุญาตให้Strategyใช้กับ AI!

Andrew Top ยังกล่าวว่า:

เกมของคุณอาจอยู่ในสถานะ (ใกล้เคียงกับ) จำนวนไม่ จำกัด เนื่องจากการเรียงสับเปลี่ยนของสิ่งต่างๆเช่นผู้เล่น A มีเงินเท่าไหร่ผู้เล่น B มีเงินเท่าไหร่และอื่น ๆ ... ดังนั้นฉันค่อนข้างแน่ใจว่าคุณต้องการ อยู่ห่างจากเครื่องจักรของรัฐ

ฉันคิดว่าคำพูดนั้นทำให้เข้าใจผิดมากในขณะที่มันเป็นความจริงที่มีสถานะของเกมที่แตกต่างกันมากมายมีเฟสเกมเพียงไม่กี่ขั้น เพื่อจัดการกับตัวอย่างของเขาทั้งหมดก็จะเป็นตัวแปรจำนวนเต็มเพื่อก่อสร้างงานคอนกรีตของฉันGamePhases

การผูกขาด

ตัวอย่างของบางส่วนGamePhaseจะเป็น:

• GameStarts
• PlayerRolls
• PlayerLandsOnProperty (FreeParking, GoToJail, Go ฯลฯ )
• ผู้เล่น
• PlayerPurchasesProperty
• ผู้เล่นซื้อบ้าน
• ผู้เล่นซื้อโรงแรม
• PlayerPaysRent
• ผู้เล่นล้มละลาย
• (การ์ด Chance และ Community Chest ทั้งหมด)

และบางรัฐในฐานGamePhaseคือ:

• รายชื่อผู้เล่น
• ผู้เล่นปัจจุบัน (ใครเปิด)
• เงิน / ทรัพย์สินของผู้เล่น
• บ้าน / โรงแรมในอสังหาริมทรัพย์
• ตำแหน่งผู้เล่น

จากนั้นบางขั้นตอนจะบันทึกสถานะของตัวเองตามต้องการเช่น PlayerRolls จะบันทึกจำนวนครั้งที่ผู้เล่นหมุนคู่ติดต่อกัน เมื่อเราออกจากเฟส PlayerRolls เราก็ไม่สนใจเกี่ยวกับการหมุนต่อเนื่องอีกต่อไป

สามารถใช้ซ้ำและเชื่อมโยงกันได้หลายเฟส ตัวอย่างเช่นGamePhase CommunityChestAdvanceToGoจะสร้างเฟสถัดไปPlayerLandsOnGoด้วยสถานะปัจจุบันและส่งคืน ในตัวสร้างของPlayerLandsOnGoผู้เล่นปัจจุบันจะถูกย้ายไปที่ Go และเงินของพวกเขาจะเพิ่มขึ้น 200 เหรียญ

แน่นอนว่ามีแหล่งข้อมูลเกี่ยวกับหัวข้อนี้มากมายหลายรายการหลายรายการ แต่ฉันคิดว่าคุณมาถูกทางที่ถูกต้องในการแบ่งวัตถุและปล่อยให้พวกมันจัดการเหตุการณ์ / ข้อมูลของตัวเองไปเรื่อย ๆ

เมื่อเล่นเกมกระดานแบบเรียงต่อกันคุณจะพบว่าเป็นเรื่องดีที่จะมีกิจวัตรในการแมประหว่างอาร์เรย์บอร์ดและ row / col และ back พร้อมคุณสมบัติอื่น ๆ ฉันจำเกมกระดานเกมแรกของฉันได้ (นานมาแล้ว) เมื่อฉันจัดโครงสร้างด้วยวิธีรับ row / col จาก boardarray 5

1  2  3  
4 (5) 6  BoardArray 5 = row 2, col 2
7  8  9  

ความคิดถึง. ;)

อย่างไรก็ตามhttp://www.gamedev.net/เป็นสถานที่ที่ดีสำหรับข้อมูล http://www.gamedev.net/reference/

เนื้อหาส่วนใหญ่ที่ฉันสามารถหาได้ทางออนไลน์คือรายการข้อมูลอ้างอิงที่เผยแพร่ ส่วนสิ่งพิมพ์ของGame Design Patternsมีลิงก์ไปยังบทความและวิทยานิพนธ์ในเวอร์ชัน PDF หลายลักษณะเหล่านี้เช่นเอกสารทางวิชาการเช่นการออกแบบรูปแบบสำหรับเกม นอกจากนี้ยังมีอย่างน้อยหนึ่งหนังสือที่มีอยู่จาก Amazon รูปแบบในการออกแบบเกม

Three Ringsมีไลบรารี Java ของ LGPL Nenya และ Vilya เป็นห้องสมุดสำหรับสิ่งที่เกี่ยวข้องกับเกม

แน่นอนว่าจะช่วยได้หากคำถามของคุณกล่าวถึงแพลตฟอร์มและ / หรือข้อ จำกัด ด้านภาษาที่คุณอาจมี

ฉันเห็นด้วยกับคำตอบของ Pyrolistical และฉันชอบวิธีการทำสิ่งต่าง ๆ ของเขา (ฉันแค่อ่านคำตอบอื่น ๆ )

บังเอิญฉันใช้การตั้งชื่อ "GamePhase" ของเขาด้วย โดยพื้นฐานแล้วสิ่งที่ฉันจะทำในกรณีของเกมกระดานแบบเทิร์นเบสคือคลาส GameState ของคุณมีวัตถุของ GamePhase ที่เป็นนามธรรมตามที่กล่าวถึงโดย Pyrolistical

ให้บอกว่าสถานะของเกมคือ:

1. ม้วน
2. ย้าย
3. ซื้อ / ไม่ซื้อ
4. คุก

คุณสามารถมีคลาสที่ได้รับที่เป็นรูปธรรมสำหรับแต่ละรัฐ มีฟังก์ชันเสมือนอย่างน้อยสำหรับ:

StartPhase();
EndPhase();
Action();

ในฟังก์ชัน StartPhase () คุณสามารถตั้งค่าเริ่มต้นทั้งหมดสำหรับสถานะได้เช่นปิดการใช้งานอินพุตของผู้เล่นคนอื่นเป็นต้น

เมื่อเรียก roll.EndPhase () แล้วตรวจสอบให้แน่ใจว่าตัวชี้ GamePhase ถูกตั้งค่าเป็นสถานะถัดไป

phase = new MovePhase();
phase.StartPhase();

ใน MovePhase :: StartPhase () นี้คุณจะยกตัวอย่างเช่นตั้งค่าการเคลื่อนไหวที่เหลือของผู้เล่นที่ใช้งานอยู่เป็นจำนวนเงินที่รีดในช่วงก่อนหน้านี้

ขณะนี้ด้วยการออกแบบนี้คุณสามารถแยกแยะปัญหา "3 x double = jail" ของคุณในขั้นตอนการม้วน คลาส RollPhase สามารถจัดการสถานะของตัวเองได้ ตัวอย่างเช่น

GameState state; //Set in constructor.
Die die;         // Only relevant to the roll phase.
int doublesRemainingBeforeJail;
StartPhase()
{
    die = new Die();
    doublesRemainingBeforeJail = 3;
}

Action()
{
    if(doublesRemainingBeforeJail<=0)
    {
       state.phase = new JailPhase(); // JailPhase::StartPhase(){set moves to 0};            
       state.phase.StartPhase();
       return;
    }

    int die1 = die.Roll();
    int die2 = die.Roll();

    if(die1 == die2)
    {
       --doublesRemainingBeforeJail;
       state.activePlayer.AddMovesRemaining(die1 + die2);
       Action(); //Roll again.
    }

    state.activePlayer.AddMovesRemaining(die1 + die2);
    this.EndPhase(); // Continue to moving phase. Player has X moves remaining.
}

ฉันแตกต่างจาก Pyrolistical ตรงที่ควรมีระยะสำหรับทุกอย่างรวมถึงเมื่อผู้เล่นไปที่ Community Chest หรือบางสิ่งบางอย่าง ฉันจะจัดการทั้งหมดนี้ใน MovePhase เนื่องจากหากคุณมีขั้นตอนต่อเนื่องมากเกินไปผู้เล่นจะรู้สึกว่า "ถูกชี้นำ" มากเกินไป ตัวอย่างเช่นหากมีช่วงหนึ่งที่ผู้เล่นสามารถซื้ออสังหาริมทรัพย์ได้แล้วซื้อเฉพาะโรงแรมจากนั้นซื้อบ้านเท่านั้นมันก็เหมือนกับว่าไม่มีอิสระ เพียงใส่ชิ้นส่วนเหล่านั้นทั้งหมดลงใน BuyPhase เดียวและให้อิสระแก่ผู้เล่นในการซื้ออะไรก็ได้ที่เขาต้องการ คลาส BuyPhase สามารถจัดการได้อย่างง่ายดายว่าการซื้อใดถูกกฎหมาย

สุดท้ายมาพูดถึงเกมบอร์ด แม้ว่าอาร์เรย์ 2D จะใช้ได้ดี แต่ฉันขอแนะนำให้มีกราฟกระเบื้อง (โดยที่ไทล์เป็นตำแหน่งบนกระดาน) ในกรณีของ monoppoly มันควรจะเป็นรายการที่เชื่อมโยงกันสองเท่า จากนั้นทุกกระเบื้องจะมี:

1. PreviousTile
2. nextTile

ดังนั้นมันจะง่ายกว่ามากที่จะทำสิ่งต่างๆเช่น:

While(movesRemaining>0)
  AdvanceTo(currentTile.nextTile);

ฟังก์ชัน AdvanceTo สามารถจัดการภาพเคลื่อนไหวทีละขั้นตอนหรืออะไรก็ได้ที่คุณต้องการ และการเคลื่อนไหวที่เหลือลดลงแน่นอน

คำแนะนำของ RS Conley เกี่ยวกับรูปแบบผู้สังเกตการณ์สำหรับ GUI นั้นดี

เมื่อก่อนไม่ค่อยได้โพสต์เท่าไหร่ หวังว่านี่จะช่วยใครบางคนได้

มีศิลปะก่อนหน้านี้ที่ฉันสามารถใช้ประโยชน์ได้หรือไม่?

หากคำถามของคุณไม่ใช่ภาษาหรือเฉพาะแพลตฟอร์ม จากนั้นฉันขอแนะนำให้คุณพิจารณารูปแบบ AOP สำหรับรัฐ Memento คำสั่ง ฯลฯ

.NET ตอบ AOP คืออะไร ???

ลองค้นหาเว็บไซต์เจ๋ง ๆ เช่นhttp://www.chessbin.com