ओओपी desing, जावा स्विंग, शतरंज खेल, उदाहरण

Question

ठीक है, मैं एक साधारण जावा स्विंग शतरंज खेल बनाने की प्रक्रिया में हूँ। यह प्रश्न ओओपी डिज़ाइन के बाद जावा स्विंग के बारे में अधिक है।

मैं निम्नलिखित है:

• मैं एक पैनल वर्ग कि JPanel लागू करता है। प्यादा, राजा, बिशप आदि है कि मेरे टुकड़े वर्ग

से विस्तार अपने मुख्य में:

मैं तो एक अमूर्त वर्ग टुकड़ा है कि

तो मैं अलग टुकड़े के लिए मेरे श्रेणियां होती हैं मेरी पैनल वर्ग तक फैली हुई है ChessGame कक्षा:

• मैं पैनल की एक सरणी का उपयोग कर रहा है उस पर कोई टुकड़े के साथ बोर्ड स्थानों के लिए, मेरे बोर्ड
• तो सरणी स्टोर करेगा, पैनल वस्तुओं के लेआउट स्टोर करने के लिए।
• और यह स्टोर करेगा, इस तरह के प्यादा, रानी, ​​बिशप आदि (टुकड़े के साथ बोर्ड स्थानों)

तो, ऊपरी बाएं वर्ग (0,0) myArray के लिए नक्शे के रूप में उपवर्गों [0] [0]

 if(panels[x][y] instanceof Piece){ 
      ((Piece)panels[x][y]).makeMove(); 
     } 

क्या मैं पूछ रहा हूँ इस भयानक डिजाइन है:

मेरे समस्या यह है कि, अगर जगह खाली है या उस में शतरंज के मोहरे है मैं उपयोग करने के लिए जाँच करने के लिए है? मुझे पता है कि मुझे कोशिश करनी चाहिए और उदाहरण से दूर रहना चाहिए। बेहतर दृष्टिकोण क्या होगा?

धन्यवाद।

Answer 1

पैनल को 8x8 छोटे पैनलों में विभाजित करने के बजाय, आपको बोर्ड और टुकड़ों को कैनवास पर खींचना होगा। बाद में खिलाड़ियों को बोर्ड पर टुकड़े स्थानांतरित करने के लिए खींच जाएगा। इसके अलावा आप शतरंज गेम में बिटबोर्ड प्रेजेंटेशन की तलाश कर सकते हैं, हालांकि यह प्रस्तुति केवल शतरंज इंजनों के लिए जरूरी है जो तेजी से गणना के लिए "सोचने" में सक्षम हैं, यह तब भी उपयोगी है जब आपको यह जांचना पड़े कि खिलाड़ी जो कदम उठा रहा है वह है या नहीं सही बात।

Posible Bitboard:

public class BitBoard 
{ 
    public static final int P = 0; 
    public static final int N = 2; 
    public static final int B = 4; 
    public static final int R = 6; 
    public static final int Q = 8; 
    public static final int K = 10; 

    public static final int p = 1; 
    public static final int n = 3; 
    public static final int b = 5; 
    public static final int r = 7; 
    public static final int q = 9; 
    public static final int k = 11; 

    // empty field 
    public static final int empty = 12; 

    // number of pieces , squares 
    public static final int nPieces = 12; 
    public static final int nSquares = 64; 

    public static final int whitePieces = 12; 
    public static final int blackPieces = 13; 
    public static final int nBoards = 14; 

    public static long squareBits[]; 

    // static member initialization 
    static 
    { 
     squareBits = new long[64]; 
     long square = 1; 
     square = square << 8 * 8 - 1; 
     for (int i = 0; i < 64; i++) { 
      squareBits[i] = square >>> i; 
     } 
    } 

    long bitBoards[]; 

    public BitBoard() { 
     bitBoards = new long[nBoards]; 
    } 

    public boolean initBoard() 
    { 
     // Put the pieces on the board 
     EmptyBoard(); 
     addPiece(0, r); 
     addPiece(1, n); 
     addPiece(2, b); 
     addPiece(3, q); 
     addPiece(4, k); 
     addPiece(5, b); 
     addPiece(6, n); 
     addPiece(7, r); 
     for (int i = 8; i < 16; i++) { 
      addPiece(i, p); 
     } 

     for (int i = 48; i < 56; i++) { 
      addPiece(i, P); 
     } 
     addPiece(56, R); 
     addPiece(57, N); 
     addPiece(58, B); 
     addPiece(59, Q); 
     addPiece(60, K); 
     addPiece(61, B); 
     addPiece(62, N); 
     addPiece(63, R); 

     return true; 
    } 

    public boolean addPiece(int whichSquare, int whichPiece) 
    { 
     bitBoards[whichPiece] |= squareBits[whichSquare]; 
     bitBoards[nPieces + (whichPiece % 2)] |= squareBits[whichSquare]; 
     return true; 
    } 

    private boolean removePiece(int whichSquare, int whichPiece) 
    { 
     bitBoards[whichPiece] ^= squareBits[whichSquare]; 
     bitBoards[nPieces + (whichPiece % 2)] ^= squareBits[whichSquare]; 
     return true; 
    } 

    private boolean EmptyBoard() 
    { 
     for (int i = 0; i < nBoards; i++) 
     { 
      bitBoards[i] = 0; 
     } 
     return true; 
    } 
} 

Answer 2

आपकी समस्या पर विचार, और समस्या डोमेन जानने के बाद, मैं वास्तव में सुझाव है कि निम्नलिखित ...

अपनी कक्षा Panel में एक समारोह int hasMass() लागू इस प्रकार हैं .. ।

public int hasMass() { 
    return 0; 
} 

अपनी कक्षा Piece ओवरराइड में इस प्रकार है कि के रूप में कार्य ...

public int hasMass() { 
    if (isWhite()) // white pieces are negative. 
    return -1; 
    return 1; // black pieces positive. 
} 

अब आप जांच सकते हैं कि वर्ग में एक टुकड़ा है या नहीं, क्या कोई और टुकड़ा इसे ले सकता है ... (क्योंकि उनके विपरीत ध्रुवीयता है) ... उदा। द्रव्यमान + द्रव्यमान == 0 का मतलब है कैप्चर,! = 0 का मतलब है कि पैनल खाली था। और निश्चित रूप से 2 (द्रव्यमान के लिए) का एक पूर्ण मूल्य यह होगा कि कदम अवैध था।

Answer 3

आपको व्यू कोड (जेननेल) के साथ मॉडल कोड (टुकड़ा) को गठबंधन नहीं करना चाहिए।यदि आप कभी भी बदलना चाहते हैं कि बोर्ड कैसे प्रदर्शित होता है तो आपको बदलना होगा कि टुकड़े कैसे संग्रहीत किए जाते हैं!

पीस को जेननेल से अलग करने के लिए एक बेहतर डिज़ाइन हो सकता है। फिर आप टुकड़े के मैट्रिक्स को प्रदर्शित करने के लिए एक जेपीनेल का उपयोग कर सकते हैं: Pieces[8][8]।

मेरे समस्या यह है कि, अगर जगह खाली है या उस में शतरंज के मोहरे है मैं उपयोग करने के लिए जाँच करने के लिए है:

आप एक मैट्रिक्स का उपयोग करते हैं, तो आप सिर्फ एक अशक्त सेल है या Null Object उपयोग कर सकते हैं एक "खाली" टुकड़ा रखने के लिए पैटर्न।

संपादित

टुकड़ा मैट्रिक्स में प्रत्येक कोशिका बोर्ड में एक वर्ग तो piece[0][0] बोर्ड (ए 8) के शीर्ष कोने होगा।

बोर्ड को पेंट करने के लिए paintComponent() विधि को इस मैट्रिक्स पर फिर से चालू करना होगा और प्रत्येक सेल को उचित रूप से आकर्षित करना होगा।

1. आप instanceof टुकड़ा के प्रत्येक प्रकार के आकर्षित करने के लिए अलग तरह से

2. एक नया मध्यवर्ती "रंग रणनीति" वस्तु रणनीति पद्धति का उपयोग कर बनाने की जाँच के लिए एक समान करने के लिए की आवश्यकता होगी: इस लागू करने के लिए कई तरीके हैं। इसके लिए टुकड़े की वस्तुओं के बजाय रणनीति वस्तुओं की एक मैट्रिक्स की आवश्यकता हो सकती है। आपको अभी भी चेक का उदाहरण करने की आवश्यकता हो सकती है, लेकिन शायद रणनीति ऑब्जेक्ट्स बनाने के लिए केवल एक बार।

Answer 4

मैं प्रस्तुत बोर्ड से अलग टुकड़ों की संरचना रखूंगा।

उदाहरण के लिए, मैं शतरंज के टुकड़े शुद्ध मॉडल w/o को हिट के ज्ञान के बारे में जानकारी देता हूं।

Pieces (baseclass) 
+- Pawn 
+- Knight 
+- King 
+- Queen 
+- ..etc 

यह आपको केवल टुकड़े की सरणी रखने की अनुमति देगा, जहां खाली वर्ग शून्य हैं।

Peices[][] board = new Pieces[8][8]; 

(निश्चित रूप से एक प्रारंभ विधि अपने 'बोर्ड' पार और बोर्ड डब्ल्यू/प्रारंभिक पदों को भरने के लिए)

:

सादगी के लिए, मैं सिर्फ peices के एक मैट्रिक्स होगा

तब मेरे पास जेपीनेल का एक दृश्य बोर्ड होगा; खेल का प्रबंधन करने के लिए "शतरंज" नामक एक वर्ग; और चाल समारोह में टाइल/पैनल की वास्तविक प्रतिपादन। कल्पना कीजिए:

// what a move might look like when initializing your panels 
piece = board [0][0]; 
Chess.move(piece, 0 ,0); //responsible for clearing the old panel and rendering the panel at target location. 

उपयोगकर्ता आदान प्रदान करेगा तो w/अपने game..they क्लिक करें अपने panels..which आप दे देंगे पैनल समन्वय करता है। आप यह निर्धारित करने के लिए क्या टुकड़ा is..how यह आदि स्थानांतरित कर सकते हैं ..

कुछ इस तरह ...

मैं सिर्फ खेल बोर्ड वस्तुओं का उपयोग कर का प्रतिनिधित्व करते हैं/अपने 'बोर्ड' एक ही निर्देशांक डब्ल्यू का उपयोग करें। ..सरलता के लिए। समझने के लिए सबसे आसान..और इसके अलावा। Computers अब बहुत तेज हैं।

Answer 5

ठीक है, यह पता लगाने के लिए शून्य की सेटिंग को दूर करने से बीमार शुरू होता है कि यह जगह खाली है (आप इसे कर सकते हैं लेकिन Empty कक्षा का उपयोग करना एक तरह से 'बेहतर' है)।

तो मान लीजिए कि आप है Panel रों की सरणी अपने खेल बोर्ड का प्रतिनिधित्व करते हैं: ilustration के लिए

Panel[][] board; 

अब, अपने वर्ग पदानुक्रम कैसा नज़र आ सकता है जैसे:

abstract class Panel extends JPanel { ... } 

class Empty extends Panel { ... } 

abstract class Piece extends Panel { ... } 

class Pawn extends Piece { ... } 

... 

मेरे पैनल वर्ग है मेरी खाली कक्षा यह नहीं है?

सुनिश्चित नहीं हैं कि अगर मैं आप समझते हैं, लेकिन चलो एक नज़र क्या पर extends वास्तव में इसका मतलब है चलो: शो Nmodel में हर टुकड़ा भी एक पैनल या हर प्यादा है यह भी एक टुकड़ा है, इसलिए हर प्यादा कर सकते हैं टुकड़ा के रूप में सभी चीजें करें (उदाहरण के लिए, 4 जटिल संख्या के साथ-साथ प्राकृतिक संख्या या वास्तविक संख्या भी है, इसलिए आप कह सकते हैं कि वास्तविक संख्या जटिल संख्या बढ़ाती है, क्योंकि प्रत्येक वास्तविक संख्या भी एक जटिल है संख्या)

तो अब आप कुछ प्राप्त कर सकते हैं PanelEmpty कक्षा में और सभी Piece उप-वर्गों में, और Panel ड्राइंग करते समय,में घोषित अच्छा सार getTexture() विधि, आपको यह देखने की आवश्यकता नहीं है कि यह खाली है या नहीं।

Answer 6

प्रत्येक टुकड़ा (रूक, Pawn, रानी इत्यादि) के लिए लगभग समान वर्ग बनाने (मुझे लगता है) बनाने के बजाय, आप केवल मूल Piece कक्षा को रख सकते हैं, इसे गैर सार बना सकते हैं और PieceType फ़ील्ड जोड़ सकते हैं। PieceType सिर्फ enum है जो बताता है कि किस प्रकार का टुकड़ा (यदि कोई है) वहां रखा गया है। instanceof का उपयोग करने के बजाय, अब आप panels[i][j].getType() == PieceType.ROOK का उपयोग करके जांच सकते हैं। कम से कम यही है कि मैं अपने कार्यान्वयन में क्या कर रहा हूं :)

मैं अपने 8x8 बोर्ड के लिए JPanel के बजाय JLabel का भी उपयोग कर रहा हूं।