Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 17 kết quả

Đề tài: [Game: HangMan Deluxe v1.0 - by bvKim]

  1. #1
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Angry [Game: HangMan Deluxe v1.0 - by bvKim]

    Mới tập tành OOP được 2-3 hôm thấy nó phê quá nên Kim mày mò nghiên cứu để viết thử 1 game nho nhỏ mà ai cũng biết đấy là game gì

    Project: HangMan Deluxe 1.0
    Author: bvKim
    IDE: VC++ 2k5
    Environment: Console

    Phân tích kĩ thuật:
    - Game được chia làm nhiều phần nhỏ để xử lý và khi chơi được quy lại trong một class bé xíu

    - Những yếu tố liên quan:
    + Vì sử dụng console nên ta sẽ cần sử đụng đến tọa độ 2 chiều, vì thế tạo 1 class lưu trữ thông tin này (class Point)
    + Để hỗ trợ thêm các tính năng phụ mà có thể access trực tiếp từ class vào, tạo nên đặc điểm khách quan của thiết kế game (class Utils)
    + Game cần có khoản về hỗ trợ thiết kế giao diện game (class HangDesign)
    + Game cần có một bộ từ điển chuyên dụng để lưu trữ (class Dictionary)
    + Không gian chính phối toàn bộ khung cảnh vào làm một (class HangMan)
    + Tạo một lớp xử lý chơi game (class Application)

    => Tóm lại: tổng số class cần design là 6 class.

    Đây là giao diện game <chưa hết >

  2. #2
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Angry HangMan: class Point

    Lớp Point trước tiên gồm 2 files

    1. point_class.h
    C++ Code:
    1. /////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: point_class.h
    4. // @date: 16-Nov-2008
    5. // @purpose: class Point determine co-ordinate
    6. // @note: declaration of class 'Point'
    7. /////////////////////////////////////////////////////
    8.  
    9. /****************/
    10. /* Preprocessor */
    11. /****************/
    12. #ifndef __POINT_CLASS_H__
    13. #define __POINT_CLASS_H__
    14.  
    15. #include <iostream>
    16.  
    17. /***************
    18.  * @class Point
    19.  ***************/
    20.  
    21. class Point {
    22.     private:
    23.         int _x;
    24.         int _y;
    25.  
    26.     public:
    27.         /* constructor & destructor */
    28.         Point(); // equavilent : Point() : _x(0), _y(0) { };
    29.         Point(const int, const int);
    30.         Point(const Point&);
    31.         ~Point();
    32.  
    33.         /* operators */
    34.             // binary
    35.         Point  operator+  (const Point&) const;
    36.         Point  operator-  (const Point&) const;
    37.         Point  operator*  (const Point&) const;
    38.             // binary assignment
    39.         Point& operator+= (const Point&);
    40.         Point& operator-= (const Point&);
    41.         Point& operator*= (const Point&);
    42.             // unary
    43.         Point& operator++ ();                   // prefix
    44.         Point  operator++ (int);                // postfix
    45.         Point& operator-- ();                   // prefix
    46.         Point  operator-- (int);                // postfix
    47.             // logical
    48.         bool   operator== (const Point&) const;
    49.         bool   operator!= (const Point&) const;
    50.  
    51.         /* properties */
    52.         void     set_x      (int const&)      ;
    53.         void     set_y      (int const&)      ;
    54.         int      get_x      ()           const;
    55.         int      get_y      ()           const;
    56.  
    57.         /* methods */
    58.         Point    clone      ()           const;
    59.         Point*   clone_ptr  ()           const;
    60. };
    61.  
    62. #endif // __POINT_CLASS_H__

    2. point_class.cpp
    C++ Code:
    1. /////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: point_class.cpp
    4. // @date: 16-Nov-2008
    5. // @purpose: class Point determine co-ordinate
    6. // @note: definition of class 'Point'
    7. /////////////////////////////////////////////////////
    8.  
    9. /****************/
    10. /* Preprocessor */
    11. /****************/
    12. #include "point_class.h"
    13.  
    14. /****************************/
    15. /* constructor & destructor */
    16. /****************************/
    17. Point::Point()
    18. {
    19.     this->_x = this->_y = 0;
    20. }
    21.  
    22. Point::Point(int const __x, int const __y)
    23. {
    24.     this->_x = __x;
    25.     this->_y = __y;
    26. }
    27.  
    28. Point::Point(const Point& __p)
    29. {
    30.     this->_x = __p.get_x();
    31.     this->_y = __p.get_y();
    32. }
    33.  
    34. Point::~Point()
    35. {
    36.  
    37. }
    38.  
    39. /************/
    40. /* operator */
    41. /************/
    42.  
    43. /*
    44.  * @operator +
    45.  * @assoc right-to-left
    46.  * @purpose
    47.  */
    48. Point Point::operator+ (const Point& __p) const
    49. {
    50.     return Point(this->_x + __p.get_x(), this->_y + __p.get_y());
    51. }
    52.  
    53. /*
    54.  * @operator -
    55.  * @assoc right-to-left
    56.  * @purpose
    57.  */
    58. Point Point::operator- (const Point& __p) const
    59. {
    60.     return Point(this->_x - __p.get_x(), this->_y - __p.get_y());
    61. }
    62.  
    63. /*
    64.  * @operator *
    65.  * @assoc right-to-left
    66.  * @purpose
    67.  */
    68. Point Point::operator* (const Point& __p) const
    69. {
    70.     return Point(this->_x * __p.get_x(), this->_y * __p.get_y());
    71. }
    72.  
    73. /*
    74.  * @operator +=
    75.  * @assoc right-to-left
    76.  * @purpose
    77.  */
    78. Point& Point::operator+= (const Point& __p)
    79. {
    80.     this->_x += __p.get_x();
    81.     this->_y += __p.get_y();
    82.  
    83.     return *this;
    84. }
    85.  
    86. /*
    87.  * @operator -=
    88.  * @assoc right-to-left
    89.  * @purpose
    90.  */
    91. Point& Point::operator-= (const Point& __p)
    92. {
    93.     this->_x -= __p.get_x();
    94.     this->_y -= __p.get_y();
    95.  
    96.     return *this;
    97. }
    98.  
    99. /*
    100.  * @operator *=
    101.  * @assoc right-to-left
    102.  * @purpose
    103.  */
    104. Point& Point::operator*= (const Point& __p)
    105. {
    106.     this->_x *= __p.get_x();
    107.     this->_y *= __p.get_y();
    108.  
    109.     return *this;
    110. }
    111.  
    112. /*
    113.  * @operator ++
    114.  * @precedence prefix
    115.  * @purpose
    116.  */
    117. Point& Point::operator++ ()
    118. {
    119.     this->_x++;
    120.     this->_y++;
    121.  
    122.     return *this;
    123. }
    124.  
    125. /*
    126.  * @operator ++
    127.  * @precedence postfix
    128.  * @purpose
    129.  */
    130. Point Point::operator++ (int)
    131. {
    132.     Point __t(*this);
    133.     ++(*this);
    134.     return __t;
    135. }
    136.  
    137. /*
    138.  * @operator --
    139.  * @precedence prefix
    140.  * @purpose
    141.  */
    142. Point& Point::operator-- ()
    143. {
    144.     this->_x--;
    145.     this->_y--;
    146.  
    147.     return *this;
    148. }
    149.  
    150. /*
    151.  * @operator --
    152.  * @precedence postfix
    153.  * @purpose
    154.  */
    155. Point Point::operator-- (int)
    156. {
    157.     Point __t(*this);
    158.     --(*this);
    159.     return __t;
    160. }
    161.  
    162. /*
    163.  * @operator ==
    164.  * @assoc right-to-left
    165.  * @purpose
    166.  */
    167. bool Point::operator== (const Point& __p) const
    168. {
    169.     return ( (this->_x == __p.get_x())
    170.         &&   (this->_y == __p.get_y())
    171.            );
    172. }
    173.  
    174. /*
    175.  * @operator !=
    176.  * @assoc right-to-left
    177.  * @purpose
    178.  */
    179. bool Point::operator!= (const Point& __p) const
    180. {
    181.     return !( (this->_x == __p.get_x())
    182.         &&    (this->_y == __p.get_y())
    183.            );
    184. }
    185.  
    186. /**************/
    187. /* properties */
    188. /**************/
    189. void Point::set_x (int const& __x)
    190. {
    191.     this->_x = __x;
    192. }
    193. void Point::set_y (int const& __y)
    194. {
    195.     this->_y = __y;
    196. }
    197.  
    198. int Point::get_x () const
    199. {
    200.     return this->_x;
    201. }
    202. int Point::get_y () const
    203. {
    204.     return this->_y;
    205. }
    206.  
    207. /***********/
    208. /* methods */
    209. /***********/
    210. /*
    211.  * @method clone()
    212.  * @type Point
    213.  * @param -none
    214.  * @purpose create a copy instance of this instanct
    215.  */
    216. Point Point::clone () const
    217. {
    218.     return Point(this->_x, this->_y);
    219. }
    220.  
    221. /*
    222.  * @method clone_ptr()
    223.  * @type Point
    224.  * @param -none
    225.  * @purpose create pointer to an copy of this instance
    226.  */
    227. Point* Point::clone_ptr() const
    228. {
    229.     return new Point(this->_x, this->_y);
    230. }

  3. #3
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Angry HangMan: class Utils

    Lớp Utils hỗ trợ xử lý console gồm 2 files:

    1. utils_class.h
    C++ Code:
    1. ////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: utils_class.h
    4. // @date: 16-Nov-2008
    5. // @note: declare the class 'Utils'
    6. ////////////////////////////////////////////////////
    7. /****************/
    8. /* Preprocessor */
    9. /****************/
    10. #ifndef __UTILS_CLASS_H__
    11. #define __UTILS_CLASS_H__
    12.  
    13. #include "point_class.h"
    14. #include "color_enum.h"
    15. #include <windows.h>
    16.  
    17. /********************
    18.  * @class Utils *
    19.  ********************/
    20.  
    21. class Utils {
    22.     protected:
    23.  
    24.     private:
    25.  
    26.     public:
    27.         static void     draw_screen            ();
    28.         static void     gotoxy                 (const Point);                                            // done
    29.         static void     gotoxy                 (const int, const int);                                   // done
    30.         static void     put_char               (const Point, const char);                                // done
    31.         static void     put_char               (const Point, const ColorType, const char);               // done
    32.         static void     put_char               (const int, const int, const char);                       // done
    33.         static void     put_char               (const int, const int, const ColorType, const char);      // done
    34.         static void     set_cur_pos            (const Point);                                            // done
    35.         static void     set_cur_pos_x          (const int);                                              // done
    36.         static void     set_cur_pos_y          (const int);                                              // done
    37.         static Point    get_cur_pos            ();                                                       // done
    38.         static int      get_cur_pos_x          ();                                                       // done
    39.         static int      get_cur_pos_y          ();                                                       // done
    40.         static void     set_fgcolor            (const ColorType);                                        // .<test>
    41.         static void     set_txtcolor           (const Point, const ColorType, const int);                // done
    42.         static void     set_bgcolor            (const ColorType);                                        // .<test>
    43.         static void     clear_screen           ();
    44.         //static void     blink                  (const Point);
    45.         //static void     blink                  (const int, const int);
    46. };
    47.  
    48.  
    49. #endif // __UTILS_CLASS_H__

    2. utils_class.cpp
    C++ Code:
    1. ////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: utils_class.cpp
    4. // @date: 16-Nov-2008
    5. // @note: define the class 'Utils'
    6. ////////////////////////////////////////////////////
    7. /****************/
    8. /* Preprocessor */
    9. /****************/
    10. #include "utils_class.h"
    11.  
    12. /*****************/
    13. /* Member define */
    14. /*****************/
    15.  
    16. /*
    17.  * @method draw_screen()
    18.  */
    19.  
    20. void Utils::draw_screen()
    21. {
    22.  
    23. }
    24.  
    25. /*
    26.  * @method gotoxy()
    27.  * @type void
    28.  * @overload 2
    29.  * @param   __p const Point
    30.  * @param   __x const int
    31.  * @param   __y const int
    32.  * @purpose move console cursor to a specific location
    33.  */
    34. void Utils::gotoxy(const Point __p)
    35. {
    36.     COORD coord = { __p.get_x(), __p.get_y() };
    37.     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
    38. }
    39.  
    40. void Utils::gotoxy(const int __x, const int __y)
    41. {
    42.     COORD coord = { __x, __y };
    43.     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
    44. }
    45.  
    46. /*
    47.  * @method put_char()
    48.  * @type void
    49.  * @overload 4
    50.  * @param   __p const Point
    51.  * @param   __c const char
    52.  * @param   __ct const ColorType
    53.  * @param   __x const int
    54.  * @param   __y const int
    55.  * @purpose     put a character to a specific location w/ or w/o color
    56.  */
    57. void Utils::put_char(const Point __p, const char __c)
    58. {
    59.     Utils::gotoxy(__p);
    60.     std::cout.put(__c);
    61. }
    62.  
    63. void Utils::put_char(const Point __p, const ColorType __ct, const char __c)
    64. {
    65.     Utils::gotoxy(__p.get_x(), __p.get_y());
    66.     std::cout.put(__c);
    67.     COORD _coord = { __p.get_x(), __p.get_y() };
    68.     FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), __ct, 1, _coord, NULL);
    69. }
    70.  
    71. void Utils::put_char(const int __x, const int __y, const char __c)
    72. {
    73.     Utils::gotoxy(__x, __y);
    74.     std::cout.put(__c);
    75. }
    76.  
    77. void Utils::put_char(const int __x, const int __y, const ColorType __ct, const char __c)
    78. {
    79.     Utils::gotoxy(__x, __y);
    80.     std::cout.put(__c);
    81.     COORD _coord = { __x, __y };
    82.     FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), __ct, 1, _coord, NULL);
    83.    
    84. }
    85.  
    86. /*
    87.  * @method set_cur_pos()
    88.  * @type void
    89.  * @param   __p const Point
    90.  * @purpose     set cursor postion (==gotoxy())
    91.  */
    92. void Utils::set_cur_pos(const Point __p)
    93. {
    94.     Utils::gotoxy(__p);
    95. }
    96.  
    97. /*
    98.  * @method set_cur_pos_x()
    99.  * @type void
    100.  * @param   __x const int
    101.  * @purpose     set x-coordinate
    102.  */
    103. void Utils::set_cur_pos_x(const int __x)
    104. {
    105.     Utils::gotoxy(__x, Utils::get_cur_pos_y());
    106. }
    107.  
    108. /*
    109.  * @method set_cur_pos_y()
    110.  * @type void
    111.  * @param   __y const int
    112.  * @purpose     set y-coordinate
    113.  */
    114. void Utils::set_cur_pos_y(const int __y)
    115. {
    116.     Utils::gotoxy(Utils::get_cur_pos_x(), __y);
    117. }
    118.  
    119. /*
    120.  * @method get_cur_pos()
    121.  * @type Point
    122.  * @param -none
    123.  * @purpose     get current position of cursor
    124.  */
    125. Point Utils::get_cur_pos()
    126. {
    127.     CONSOLE_SCREEN_BUFFER_INFO _console;
    128.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &_console);
    129.     return Point(_console.dwCursorPosition.X, _console.dwCursorPosition.Y);
    130. }
    131.  
    132. /*
    133.  * @method get_cur_pos_x()
    134.  * @type void
    135.  * @param -none
    136.  * @purpose     get current x-coordinate of cursor
    137.  */
    138. int Utils::get_cur_pos_x()
    139. {
    140.     CONSOLE_SCREEN_BUFFER_INFO _console;
    141.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &_console);
    142.     return _console.dwCursorPosition.X;
    143. }
    144.  
    145. /*
    146.  * @method get_cur_pos_y()
    147.  * @type void
    148.  * @param   -none
    149.  * @purpose     get current y-coordinate of cursor
    150.  */
    151. int Utils::get_cur_pos_y()
    152. {
    153.     CONSOLE_SCREEN_BUFFER_INFO _console;
    154.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &_console);
    155.     return _console.dwCursorPosition.Y;
    156. }
    157.  
    158. /*
    159.  * @method set_fgcolor()
    160.  * @type void
    161.  * @param   __ct const ColorType
    162.  * @purpose     change foreground color
    163.  */
    164. void Utils::set_fgcolor(const ColorType __ct)
    165. {
    166.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), __ct);
    167. }
    168.  
    169. /*
    170.  * @method set_bgcolor()
    171.  * @type void
    172.  * @param   __ct const ColorType
    173.  * @purpose     change background color
    174.  */
    175. void Utils::set_bgcolor(const ColorType __ct)
    176. {
    177.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), __ct);
    178. }
    179.  
    180. /*
    181.  * @method set_txtcolor()
    182.  * @type void
    183.  * @param   __p const Point
    184.  * @param   __ct const ColorType
    185.  * @param   __length const int
    186.  * @purpose     set text color at a specific location
    187.  */
    188. void Utils::set_txtcolor(const Point __p, const ColorType __ct, const int __length)
    189. {
    190.     COORD _coord = { __p.get_x(), __p.get_y() };
    191.     FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), __ct, __length, _coord, NULL);
    192. }
    193. /*
    194.  * @method clear_screen()
    195.  * @type void
    196.  * @param -none
    197.  * @purpose     clear screen
    198.  */
    199. void Utils::clear_screen()
    200. {
    201.     system("cls");
    202. }

  4. #4
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Angry HangMan: class HangDesign

    class HangDesign gồm 2 files cung cấp trang trí

    1. hangdesign_class.h
    C++ Code:
    1. /////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: hangdesign_class.h
    4. // @date: 16-Nov-2008
    5. // @purpose: class HangDesign to support utitlies
    6. // @note: declaration
    7. /////////////////////////////////////////////////////
    8. /****************/
    9. /* Preprocessor */
    10. /****************/
    11. #ifndef __HANGDESIGN_H__
    12. #define __HANGDESIGN_H__
    13.  
    14. #include "point_class.h"
    15. #include "utils_class.h"
    16. #include <string>
    17.  
    18. /******************
    19.  * @enum DyingMan *
    20.  ******************/
    21. enum DyingMan
    22. {
    23.     HEAD = 0x4F,            // 'O'
    24.     BODY = 0x7C,            // '|'
    25.     LHAND = 0x2F,           // '/'
    26.     LFOOT = 0x2F,
    27.     RHAND = 0x5C,           // '\'
    28.     RFOOT = 0x5C
    29. };
    30.  
    31. /********************
    32.  * @enum GameScreen *
    33.  ********************/
    34. enum GameScreen
    35. {
    36.     SZ_TOP      = 0x50, // 80
    37.     SZ_BOTTOM   = 0x50,
    38.     SZ_LEFT     = 0x19, // 25
    39.     SZ_RIGHT    = 0x19
    40. };
    41.  
    42. /*********************
    43.  * @class HangDesign *
    44.  *********************/
    45. class HangDesign {     
    46.     public:
    47.         // draw dying man :D
    48.         static  void    draw_man(const Point, const DyingMan);
    49.         // draw boundaries
    50.         static  void    draw_top(const char);
    51.         static  void    draw_bottom(const char);
    52.         static  void    draw_left(const char);
    53.         static  void    draw_right(const char);
    54.  
    55.         // other utils
    56.         static  void set_banner(const std::string, const Point);
    57.         static  void fill_line(const char, const Point, const int);
    58.         static  void fill_coll(const char, const Point, const int);
    59.         static  void puts(const std::string, const Point); 
    60.  
    61. };
    62.  
    63. #endif // __HANGDESIGN_H__

    2. hangdesign_class.cpp

    C++ Code:
    1. ///////////////////////////////////////////////////////////
    2. // @author: bvKim
    3. // @file: hangdesign_class.cpp
    4. // @date: 16-Nov-2008
    5. // @purpose: class HangDesign to support game decoration
    6. // @note: definition
    7. ///////////////////////////////////////////////////////////
    8. /****************/
    9. /* Preprocessor */
    10. /****************/
    11. #include "hangdesign_class.h"
    12.  
    13. /*
    14.  * @method draw_man()
    15.  * @type void
    16.  * @param   __p const Point
    17.  * @param   __dm const DyingMan
    18.  * @purpose draw dying man body part
    19.  */
    20. void HangDesign::draw_man(const Point __p, const DyingMan __dm)
    21. {
    22.     Utils::put_char(__p, __dm);
    23. }
    24.  
    25. /*
    26.  * @method draw_top()
    27.  * @type void
    28.  * @param   __c const char
    29.  * @purpose draw top bound
    30.  */
    31. void HangDesign::draw_top(const char __c)
    32. {
    33.     for(int i = 1; i < (int)GameScreen::SZ_TOP - 1; ++i) {
    34.         Utils::set_cur_pos(Point(i, 0));
    35.         std::cout.put(__c);
    36.     }      
    37. }
    38.  
    39. /*
    40.  * @method draw_bottom()
    41.  * @type void
    42.  * @param   __c const char
    43.  * @purpose draw bottom bound
    44.  */
    45. void HangDesign::draw_bottom(const char __c)
    46. {
    47.    
    48.     for(int i = 1; i < (int)GameScreen::SZ_BOTTOM - 1; ++i) {
    49.         Utils::set_cur_pos(Point(i, (int)GameScreen::SZ_LEFT - 1));
    50.         std::cout.put(__c);
    51.     }
    52. }
    53.  
    54. /*
    55.  * @method draw_left()
    56.  * @type void
    57.  * @param   __c const char
    58.  * @purpose draw left bound
    59.  */
    60. void HangDesign::draw_left(const char __c)
    61. {
    62.     for(int i = 1; i < (int)GameScreen::SZ_LEFT - 1; ++i) {
    63.         Utils::set_cur_pos(Point(0, i));
    64.         std::cout.put(__c);
    65.     }
    66. }
    67.  
    68. /*
    69.  * @method draw_right()
    70.  * @type void
    71.  * @param   __c const char
    72.  * @purpose draw right bound
    73.  */
    74. void HangDesign::draw_right(const char __c)
    75. {
    76.     for(int i = 1; i < (int)GameScreen::SZ_RIGHT - 1; ++i) {
    77.         Utils::set_cur_pos(Point((int)GameScreen::SZ_TOP - 1, i));
    78.         std::cout.put(__c);
    79.     }
    80. }
    81.  
    82. /*
    83.  * @method set_banner()
    84.  * @type void
    85.  * @param   __gn    const std::string
    86.  * @param   __p     const Point
    87.  * @purpose put banner in a position
    88.  */
    89. void HangDesign::set_banner(const std::string __gn, const Point __p)
    90. {
    91.     Utils::gotoxy(__p.get_x(), __p.get_y());
    92.     std::cout << __gn;
    93. }
    94.  
    95. /*
    96.  * @method fill_line()
    97.  * @type void
    98.  * @param __c   const char
    99.  * @param __p   const Point
    100.  * @param __length const int
    101.  * @purpose fill a line w/ a char at a specific location
    102.  */
    103. void HangDesign::fill_line(const char __c, const Point __p, const int __length)
    104. {
    105.     Utils::gotoxy(__p.get_x(), __p.get_y());
    106.     for(int i = 0; i < __length; ++i)
    107.         std::cout.put(__c);
    108.  
    109. }
    110.  
    111. /*
    112.  * @method fill_coll()
    113.  * @type void
    114.  * @param __c   const char
    115.  * @param __p   const Point
    116.  * @param __length const int
    117.  * @purpose fill a column w/ a char at a specific location
    118.  */
    119. void HangDesign::fill_coll(const char __c, const Point __p, const int __length)
    120. {
    121.     for(int i = __p.get_y(); i < __p.get_y() + __length; ++i) {
    122.         Utils::put_char(Point(__p.get_x(), i), __c);
    123.     }
    124.    
    125. }
    126.  
    127. /*
    128.  * @method puts()
    129.  * @type void
    130.  * @param __s   const std::string
    131.  * @param __p   const Point
    132.  * @purpose put a string at a specific location
    133.  */
    134. void HangDesign::puts(const std::string __s, const Point __p)
    135. {
    136.     HangDesign::set_banner(__s, __p);
    137. }

  5. #5
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Mệt rồi

    mai thiết kế nốt rồi post cho nó hoàn chỉnh giờ em đi ngủ

  6. #6
    Ngày gia nhập
    10 2006
    Nơi ở
    In Your Bugs
    Bài viết
    823

    Mặc định [Game: HangMan Deluxe v1.0 - by bvKim]

    Tốt lắm. Cố lên

  7. #7
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    - Lớp Point toán tử gán và toán tử ++, -- có 1 chút vấn đề. Suy nghĩ thử xem
    - Một số hàm trong class HangMan cũng có vấn đề với tham số truyền vào, cái mà anh đã nhắc đi nhắc lại từ bữa giờ !
    - Vấn đề tương tự cho class Utils.
    C++ Code:
    1. Point::Point()
    2. {
    3.     this->_x = this->_y = 0;
    4. }
    Dùng constructor kiểu này là lãng phí ! Còn cách nào khác không ?

  8. #8
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    - Lớp Point toán tử gán và toán tử ++, -- có 1 chút vấn đề. Suy nghĩ thử xem
    - Một số hàm trong class HangMan cũng có vấn đề với tham số truyền vào, cái mà anh đã nhắc đi nhắc lại từ bữa giờ !
    - Vấn đề tương tự cho class Utils.
    C++ Code:
    1. Point::Point()
    2. {
    3.     this->_x = this->_y = 0;
    4. }
    Dùng constructor kiểu này là lãng phí ! Còn cách nào khác không ?
    - Toán tử ++, -- ý anh prefix hay postfix vì cái này là unary
    - em đã post class HangMan đâu nhỉ :-??
    - class Utils chỉ hỗ trợ xử lý console static class không áp dụng object
    - constructor
    C++ Code:
    1.     public:
    2.         /* constructor & destructor */
    3.         Point(); // equavilent : Point() : _x(0), _y(0) { };
    4.         Point(const int, const int);
    5.         Point(const Point&);
    6.         ~Point();
    Phải chăng là thế này:
    C++ Code:
    1. Point (const int __x = 0, const int __y = 0)
    2. {
    3.     this->_x = __x;
    4.     this->_y = __y;
    5. }

  9. #9
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    - Nếu em chấp nhập syntax này thì ok :
    C++ Code:
    1. int main()
    2. {
    3.     Point p( 3, 4 );
    4.     ++++p;
    5.  
    6.     std::cout << p.get_x() << "\n";
    7.     std::cout << p.get_y() << "\n";
    8.  
    9.     return 0;
    10. }
    - Cho constructor thì em dùng base-initializer sẽ có good-performance hơn assignment operator.
    - ( const any_type_of_data ) nó vẫn là truyền copy, làm sao cho nó truyền địa chỉ để khỏi lãng phí bộ nhớ.
    - *=, += ...nên trả về const ref&.
    - Không nên dùng kiểu C cast style, dùng static_cast, dynamic_cast...
    - Dữ liệu không có dynamic memory không cần viết lại copy constructor, operator = và destructor. Không cần phải clone() gì hết, có dynamic memory đâu mà clone() ?

  10. #10
    Ngày gia nhập
    11 2008
    Bài viết
    186

    Trích dẫn Nguyên bản được gửi bởi rox_rook Xem bài viết
    - Nếu em chấp nhập syntax này thì ok :
    C++ Code:
    1. int main()
    2. {
    3.     Point p( 3, 4 );
    4.     ++++p;
    5.  
    6.     std::cout << p.get_x() << "\n";
    7.     std::cout << p.get_y() << "\n";
    8.  
    9.     return 0;
    10. }
    - Cho constructor thì em dùng base-initializer sẽ có good-performance hơn assignment operator.
    - ( const any_type_of_data ) nó vẫn là truyền copy, làm sao cho nó truyền địa chỉ để khỏi lãng phí bộ nhớ.
    - *=, += ...nên trả về const ref&.
    - Không nên dùng kiểu C cast style, dùng static_cast, dynamic_cast...
    - Dữ liệu không có dynamic memory không cần viết lại copy constructor, operator = và destructor. Không cần phải clone() gì hết, có dynamic memory đâu mà clone() ?
    1. Về cái operator xảy ra trường hợp đó thì thực sự em chưa biết
    2. Em đặt cái base init trong comment; để người dùng dễ hiểu
    3. em vẫn truyền const mà :-??
    4. const ref& mới thấy lần đầu
    5. Em nhớ là em xài casting style của C++ static_cast<type>, trong source cơ mà.
    6. em tạo clone với copy chẳng qua là để cho bác nào code C thì có thể làm việc thôi. Việc tạo thêm method cho class hay không thì cũng phụ thuộc mục đích làm việc và sử dụng thôi, chứ thêm bớt em thấy không ảnh hưởng gì hết.

Các đề tài tương tự

  1. [Help] Cần giúp đỡ về tạo website có game Hangman sử dung SQL Server Database
    Gửi bởi vunguyet trong diễn đàn Nhập môn lập trình C#, ASP.NET
    Trả lời: 1
    Bài viết cuối: 19-04-2013, 10:30 PM
  2. [ Solved ]Hỏi về game HangMan
    Gửi bởi Se7Olutionyg trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 20-11-2008, 07:21 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn