Bài tập lớn lập trình hướng đối tượng thầy cao tuấn dũng phát triển hệ thống phần mềm soạn thảo các câu đố chữ và trò chơi đố chữ
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (319.55 KB, 29 trang )
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI VIỆN CÔNG NGHỆ
THÔNG TIN VÀ TRUYỀN THÔNG ──────── * ───────
BÀI TẬP LỚN
MÔN: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
Đề tài : “Phát triển hệ thống phần mềm soạn thảo
các câu đố chữ và trò chơi đố chữ”
M đề tài: De05A
Sinh viên thực hiện: Nguyễn Huy Đức (Nhóm trưởng)
Phạm Duy Hồn
Giang Tuấn Anh
Dương Tự Cơn
Nhóm sinh viên
:N
Lớp
: ICT-K54
Giáo viên hướng dẫn : TS. Cao Tuấn Dũng
Hà Nội, tháng 04 năm 2012
Mục lục
Lời nói đầu .......................................................................................................................
PH N : T NG QUAN................................................................................................
Kiến thức nền tảng phục vụ cho bài toán:....................................................................
PH
N :PH NTCHTHI TK M CKI NTR
.Mơ tả u cầu bài tốn .....................................................................
.Biểu đồ lớp .....................................................................................
. Biểu đồ tr nh tự ..................................................
PH
N : THI T K CHI TI T VÀ GIẢI PHÁP K
LỚP VÀ CH C N NG CH NH C A N : ...................................................................
.Mô tả lớp thuộc phần chơi ..............................................................
.Mô tả lớp thuộc phần câu đố ............................................................
.Mô tả các giải thuật ..........................................................................
Phần
: Kết luận và đánh giá. ...................................................................
Phân cơng cơng việc nhóm: .........................................................................................
TÀI LIỆU THAM KHẢO .............................................................................................
2
L
u
Có l ai h c cơng nghệ thơng tin đều biết các ngôn ngữ lập tr nh hướng đối tư ng ưu
việt hơn nhiều so với các ngôn ngữ hướng th tục điều này đ đư c kiểm nghiệm và
chứng minh.Nhưng nhờ đâu các nhà thiết kế lại có thể ngh ra ngôn ngữ lập tr nh
hướng đối tư ng có l tên mà ta hay g i cho nó c ng đ bao hàm câu trả lời cho câu h i
trên rồi đối tư ng là một khái niệm khơng hề có trong lập tr nh hướng th tục mà đối tư
ng ch nh là các thực thể trong thế giới thực.Khi mới b t đầu làm quen với lập tr nh
hướng đối tư ng ch ng th cách tiếp cận khá tốt là đi vào các v dụ mà ở đó ranh
giới giữa các đối tư ng r ràng. Giải đốn ơ chữ đang là một trị chơi rất phổ biến trên
các tờ báo hay các gameshow truyền h nh đư c đông đảo m i người theo d i như
Olympia, Chiếc nón kỳ diệu …Ch ng em thấy đây là một trò chơi rất hay và bổ ch
đồng thời c ng khơng khó kh n để xác đ nh các thực thể trong hệ thống trò chơi này v
l do đó nhóm sinh viên b n em lựa ch n đề tài Phát triển hệ thống soạn thảo các câu đố
chữ và trò chơi đố chữ” đề tài thực hiện chương tr nh mơ ph ng trị chơi đố chữ cho
phép người dùng giải các ô chữ hang ngang theo g i và từ đó đốn ơ chữ
khố chính. Chương tr nh đư c viết bởi ngơn ngữ thuần đối tư ng java.
Do mới làm quen với ngôn ngữ Java và việc x l các k thuật trong lập tr nh hướng
đối tư ng nên trong chương tr nh cịn có nhiều hạn chế. Nhóm chúng em mong nhận
đư c các nhận xét c a thầy về đề tài này c a nhóm để nhóm em có thể kh c phục các
hạn chế trong đề tài này để có thể làm tốt hơn trong đề tài khác.
3
PHẦN 1:
Kiến thức nền tảng phục vụ cho bài toán:
+ Phân tích và thiết kế hướng đối tư ng bao gồm :
Tư duy lập tr nh hướng đối tư ng.
- Các nguyên l cơ bản trong lập tr nh hướng đối tư ng (đóng gói, kế
thừa s dụng các giao diện đa h nh chồng phương thức...)
- Biết s dụng ngơn ngữ lập trình java.
- T m hiểu cách thức lập tr nh game bằng phương pháp hướng đối tư ng
- Kiến thức cơ bản về cơ sở dữ liệu và thiết kế cơ sở dữ liệu cho game
-
PH
2:H
HH
2.1 Mô tả u cầu bài tốn
Mơ tả trị chơi ơ chữ: Trị chơi ơ chữ gồm có các phần
Phần : Tạo ơ chữ
• Phần cho phép người dùng soạn thảo câu đố. Giao diện soạn thảo là
giao diện đồ h a tương tác người dùng có thể kéo thả d ch các ô chữ
sang trái phải lên hay xuống. Khi d ch chuyển ô mà ko th a m n tạo
khóa th thao tác thả xuống ko có tác dụng
Phần : Chơi
Cho phép người dùng ch n câu đố và thực hiện giải đố. Phần chơi đư c
giới hạn về thời gian.
2.2 Biểu đồ lớp
4
CrossWord (Lớp Play)
// Dữ liệu của từng hàng
- question, answer, hint1, hint2: String
- x, y: int
// Đồng hồ và điểm
- Clock, point, totalPoint, ran: int
- qColumn, aColumn: Jbutton
- rowButtonQ, rowButtonA: JButton
- cross: Matrix
- table[13]: Row
+ Crossword()
+ actionPerformed(ActionEvent)
+ aColumnActionPerformed(ActionEvent)
+ qColumnActionPerformed(ActionEvent)
+ q1ActionPerformed(ActionEvent)
+ a1ActionPerformed(ActionEvent)
……………………………………………………………….
+ q12ActionPerformed(ActionEvent)
+ a12ActionPerformed(ActionEvent)
+ selectColumn(Event),
compleColumn(Event),
deselectColunm(Event),
+ selectRow(Event), deselectRow(Event),
completeRow(Event)
+ hintActionPerformed(Event),
resetActionPerformed(Event)
+ OkActionPerformed(Event)
+ okKeyTyped(Event)
Matrix (Lớp matrix)
1
- Matrix[12][16] : String
+ Matrix()
1
1
Row (Lớp hàng)
- question, answer, hint1,
hint2 : String
- x, y : int
+ setRow(String, String, String,
String, int, int)
1
1
1
Clock (Lớp đồng hô)
- timeup: boolean
- labelTime: JLabel
- i, j: int
+ Clock(JLabel)
+ Clock(int)
+ Run(), Reset(), timePlay()
Cau_Do(Lớp câu đố)
- butt_Ok : Jbutton
textfield[4] : TextField
Cell[10] : int
- label[] : Jlabel[10]
- num_row : int
- ch[10] : char
-
- count: int
+Cau_Do(int, MouseDrag)
+actionPerformed(ActionEvent)
+ getQuestion()
+ getAnswer()
+ getHint1()
+ getHint2()
+
p
a
r
t
S
p
a
c
e
(
S
t
r
i
n
g
)
+
c
h
e
c
k
K
e
y
(
S
t
r
i
n
g
,
i
n
t
,
S
t
r
i
n
g
,
i
n
t
)
H nh :Biểu đồ
lớp mô tả hệ
thống
HN3:H
6
CHƯƠNG 1. II. Sơ đồ UML
7
class new crossw ...
JPanel
draw Matrix
~
Cell: int ([])
~
ch: char ([]) = new char[10]
~
ch_temp: char ([]) = new char[1]
~
ch_temp1: char ([]) = new char[10]
~
cur_X: int = 0
~
+
~
~
~
~
~
+
an
~
bu
~
bu
~
bu
~
butt3: JBu
~
butt4: JBu
~
butt5: JBu
~
butt6: JBu
cur_Y: int = 0
puzzle: CreatePuzzle
start_X: int = 0
start_Y: int = 0
str_tmp: String
x: int ([])
y: int ([])
~ canDrag: boolean = false
+
drawMatrix(CreatePuzzle, int)
+
paint(Graphics) : void
+matrix
~
ca
+
Ce
~
ce
-conn: Connection = nul l
~
~
Co
Co
~ Continue_key: boolean = false
~
count: int = -1
~
count_db: int = -1
~
cur_X: int
~ cur_Y: int
~
str
~
tm
~
x:
+
x_
+
hint1: String ([]) = new String[10]
+
x_
+
hint2: String ([]) = new String[10]
~
x_
~
key: JButton ([]) = new JButton[10]
~
y:
+
keyAnswer: String
+
y_
+
keyHint1: String
+
y_
+
keyHint2: String
~
y_
+
keyPanel: drawKey
+
keyQuestion: String
+
ac
+
co
~ lock: boolean = false
~
mark: int = -1
+
Cr
+
matrix: drawMatri x
+
in
+ OK: boolean = false
+ insert_key(String, String, String, String, int, int) : voi d
+
question: String ([]) = new String[10]
+
ma
~
row: int = 0
+
mo
~
row_temp: int = 0
+
mo
+
+
mo
mo
~ start_X: int
~ start_Y: int
+
mouseMoved(MouseEvent) : void
+
mousePressed(MouseEvent) : void
+
mouseReleased(MouseEvent) : void
Row
~
~
~
~
~
~
+
answer: String
hint1: String
hint2: String
question: String
x: int
y: int
setRow(String, String, String, String, int, int) : void -table
GamePlay
+
+
+
-
crossword: Crossword = new Crossword(1)
jButtonCreate: javax.swing.JButton
jButtonExit: javax.swing.JButton
jButtonHelp: javax.swing.JButton
jButtonNewgame: javax.swing.JButton
jButtonResume: javax.swing.JButton
jframe: JFrame
jInternalFrame1: javax.swing.JInternalFrame
jLabel1: javax.swing.JLabel
jMenuBar1: javax.swing.JMenuBar
jMenuCreate: javax.swing.JMenuItem
jMenuExit: javax.swing.JMenuItem
jMenuHelp: javax.swing.JMenuItem
jMenuItem1: javax.swing.JMenuItem
jMenuNewGame: javax.swing.JMenu
jMenuResume: javax.swing.JMenuItem
cretate() : void
GamePlay()
GamePlay(String, GraphicsConfiguration)
GamePlay(GraphicsConfiguration)
help() : void
HelpsActionPerformed(java.awt.event.ActionEv
initComponents() : void
jButtonCreateActionPerformed(java.awt.event.
jButtonExitActionPerformed(java.awt.event.Act
-
jButtonNewgameActionPerformed(java.awt.eve
jButtonResumeActionPerformed(java.awt.even
jButtonResumeActionPerformed1(java.awt.eve
jMenuExitActionPerformed(java.awt.event.Acti
jMenuHelpActionPerformed(java.awt.event.Act
jMenuItem1ActionPerformed(java.awt.event.Ac
jMenuNewGameActionPerformed(java.awt.even
jMenuResumeActionPerformed(java.awt.event. + main(String[]) : voi d
newGame() : void
8
Problems and solutions
A. Mơ tả bài tốn
1. Phần chơi
- Khi bắt đầu chơi người chơi chọn chủ đề, dựa vào chủ đề người chơi
chọn thì 1 database tương ứng được kết nối, bắt đầu khởi tạo new
Crossword với tham số truyền vào là topicID(int) và ranID (int).
- Dữ liệu database được load vào table của Crossword bao gồm:
+câu hỏi (String question).
+câu trả lời (String answer).
+gợi ý (String hint1, hint2).
+tọa độ (int x,y).
- Khởi tạo ma trận ô chữ từ table: Sử dụng tọa độ để xác định vị trí
các chữ cái trên ma trận. tách chuỗi (từng chữ cái) phần câu trả lời trong
bảng dữ liệu để lưu vào ma trận.
- Khởi tạo dao diện ô chữ showMatrix: Sử dụng 1 ma trận (mảng 2
chiều) là các JPanel, là 1 ánh xạ từ ma trận crossmatrix.
- Khởi tạo các button chọn câu hỏi va hiển thị câu trả lời tương ứng với ơ
chữ:
Các button được lưu vào 1 mảng có độ dài tương ứng với số dịng của ơ
chữ.
- Khi click vào button câu hỏi hàng (cột) tương úng sẽ đổi màu ( dựa
vào dữ liệu của cross), hiển thị câu hỏi trên textarea, thời gian (clock) bắt
đầu chạy (click vào câu hỏi khác clock sẽ reset). Textarea sẽ lấy thông tin
câu hỏi từ question (lưu trữ câu hỏi hiện tại).
- Click vào button hiện câu trả lời thời gian sẽ dừng lại., câu trả lời
được hiển thị lên ô chữ.
- Khi chọn câu hỏi ngươi chơi sẽ nhập câu trả lời vào textfield, người
chơi được trả lời liên tục cho đến khi đúng hoặc hết giờ. Khi người chơi
nhập câu trả lời sau đó nhấn OK (hoặc phím ENTER). Câu trả lời được so
sánh với dữ liệu trong table, nếu đúng người chơi được cộng điểm (200
đối với hàng ngang, 400 đối với cột dọc), người chơi sẽ bị trừ 25% số
điểm của câu hỏi đó với mỗi lần gợi ý (mỗi câu hỏi có tối đa 2 gợi ý).
- Khi chọn câu hỏi câu trả lời của câu hỏi đó được lưu vào 1 String
answer, khi người chơi nhập câu trả lời sẽ so sánh để đưa ra kết quả
đúng hoặc sai. Ngoài ra khi người chơi chọn gợi ý sẽ có 1 biến đếm để
đếm số lần gợi ý và trừ điểm tương úng với số lần gợi ý.
- người chơi muốn chơi lại ơ chữ thì ấn vào nút reset, trạng thái ô chữ
trở về ban đầu.
- Đổi màu ô chữ, điểm, thời gian trở về như ban đầu.
BI.
2.
-Khi thốt chương trình người chơi sẽ đc hỏi có lưu lại ơ chữ hay
khơng nếu lưu lại thì các trạng thái của ô chữ sẽ được lưu trong file
save.txt. Các thong số lưu lại bao gồm:
+topicID (chủ đề của ô chữ)
+ranID (id của ô chữ trong database)
+totalPoint (điểm của người chơi)
+iscompletete*+ (là 1 mảng lưu trạng thái từng hàng cột có
kiểu dữ liệu boolean, nếu hàng hay cột đã được giải thì có giá trị
true, cịn khơng sẽ có giá trị false.
- Khi load ơ chữ, chương trình sẽ khởi tạo ô chữ theo topicID và ranID
đã lưu trong file save, sau đó sẽ kiểm tra điểm và các trạng thái của hàng
và cột để nạp vào giao diện.
Phần Tạo ô chữ
- Người chơi nhập số lượng hàng đố (số lượng câu đố). Số ô chỉ
được nằm trong khoảng từ 1 đến 10. Nếu khơng nhập gì thì sẽ báo lỗi.
- Nhập số lượng ô cho từng hàng. Số lượng ô cũng chỉ từ 1-10. Nếu
không nhập sẽ báo lỗi.
- Sau khi kết thúc việc nhâp hàng và ô, người dùng có thể kéo thả ơ
chữ (lên xuống, trái phải) tới vị trí mong muốn.
- Bắt đầu việc tạo câu đố. Để tạo câu đố, người chơi sẽ phải nhập đầy
đủ 4 thông tin:
+ Câu hỏi
+ Câu trả lời
+ Hint1 và Hint2
- Để chắc chắn rằng người chơi tạo phần câu đố có nghĩa thì chương
trình sẽ kiểm tra tính hợp lệ của câu đố vừa tạo:
+ Đầu tiên nhập từ khóa. Số lượng từ khóa bằng số hàng
+ Nhập từng thông tin cho từng câu đố và check
Chẳng hạn: Nếu từ khóa là “ANH”. Câu đố đang nhập là câu 1
thì vị trí chứa từ khóa của answer*1+ trùng với chữ ‘A’. Nếu ko
sẽ bị báo lỗi.
- Sau khi nhập xong, nhấn OK để kết thúc.
B. Chi tiết các lớp
1. Lớp matrix
a. Mục đích:
Ma trận Cells là một hình vng gồm các ơ, đó là nền để các ơ hàng
chữ chạy trên đó
b. Thuộc tính:
10
S
Thuộc tính
TT
1
start_X
2
start_Y
3
cur_X
4
cur_Y
5
x[]
6
y[]
7
Cell[]
8
str_tmp
9
ch_temp[]
c. Cácphương thức
+ Phương thức paint(Graphics g)
* Mục đích:
Vẽ ra ma trận ô chữ đồng thời vẽ text lên các ơ chữ. Ma trận
được cấu tạo gồm có ơ màu xám (ô chữ ko chứa text), ô màu vàng
(ô chữ có chứa text), ơ màu đỏ (ơ chữ thuộc từ khóa)
* Giải pháp:
Để vẽ ma trận các ơ như trên, nhóm đã dùng 2 phương thức
chủ yếu : fillRect() và drawRect().
Để print các kí tự ra các ơ chữ, nhóm sẽ chuyển mỗi string câu
trả lời thành mảng kí tự, sau đó chuyển từng kí tự thành một
chuỗi rồi in ra ô chữ sử dụng phương thức: g2D.drawString()
11
Cụ thể như sau:
for (int i = 0; i < 10; i++) {
// Chuyen string answer thanh mang ki tu
if(i >= puzzle.mark && i < puzzle.mark + puzzle.row)
ch = puzzle.answer[i - puzzle.mark].toCharArray();
for (int j = 0; j < 10; j++) {
/ Ve ma tran o g2d.setColor(Color.GREEN);
g2d.draw3DRect(i * 46, j * 46, 43, 43, true);
Ve o mau vang
if (j >= puzzle.x_pos[i] / 46 && j < puzzle.x_pos[i] / 46
+ puzzle.Cell[i]) {
ch_temp[0] = ch[j - puzzle.x_pos[i] / 46];
str_tmp = new String(ch_temp);
g2d.setColor(Color.ORANGE);
g2d.fill3DRect(j * 46 + 1, puzzle.y_pos[i] + 1, 42, 42, true);
/ Ve chu cho tung hang
g2d.setColor(Color.red);
if(str_tmp.equals("I"))
g2d.drawString(str_tmp, j * 46 + 20, puzzle.y_pos[i] +
28);
else
g2d.drawString(str_tmp, j * 46 + 15, puzzle.y_pos[i] +
28);
// Boi Do tu khoa
if (puzzle.lock == true) {
ch_temp1 = puzzle.keyAnswer.toCharArray();
if (j == puzzle.x_key / 46) {
/ Ve O cua tu khoa
g2d.setColor(Color.RED);
g2d.fill3DRect(j * 46 + 1, puzzle.y_pos[i] + 1, 42, 42,
true);
}
// Print chu ra tu khoa
for (int k = puzzle.mark; k < puzzle.row + puzzle.mark;
k++) {
ch_temp[0] = ch_temp1[k - puzzle.mark];
str_tmp = new String(ch_temp);
g2d.setColor(Color.WHITE);
/
12
g2d.drawString(str_tmp, puzzle.x_key - 2, k * 46 +
28);
}
2.
}
Lớp Cau_Do
a. Thuộc tính
S
TT
1
Tên thuộc
tính
Cell
2
butt_Ok
3
count
4
label
5
num_row
6
textfield
b. Mục đích:
Lớp này dùng để cho người dùng tạo câu đố: câu hỏi, câu trả lời,
hint1 và hint2.
c. Phương thức chính:
* actionPerformed(ActionEvent e): tạo sự kiện khi nhấn button OK
* getAnswer(): Lấy câu trả lời từ textField answer.
* getQuestion(): Lấy câu hỏi từ textField question.
* getHint1(): Lấy gợi ý 1 từ textField Hint1.
* getHint2(): Lấy gợi ý 2 từ textField Hint2.
* checkKey(String, int, String, int): Phương thức này sẽ kiểm tra xem
chuỗi answer nhập vào có phù hợp với từ khóa hay khơng. Điều kiện để
phương thức trả về true là kí tự tại vị trí thứ i trong từ khóa phải bằng
trùng với kí tự thứ x_key trong hàng i.
Cụ thể như sau:
public boolean checkKey(String string1, int pos_1, String answer, int
pos_2) {
char[] ch1 = partSpace(string1);
char[] ch2 = partSpace(answer);
if (ch1[pos_1] == ch2[pos_2]) {
return true;
}
return false;
13
3.
}
Lớp drawKey
a. Mục đích:
Lớp drawKey tạo ra một panel có chứa khóa. Người dùng có thể
kéo chọn vị trí của khóa theo mong muốn.
b. Thuộc tính:
S
Tên thuộc
TT
tính
1
cur_X
2
cur_Y
3
start_X
4
start_Y
5
puzzle
c. Các phương thức chính
* mousePressed(): lấy tọa độ của chuột khi nhấp chuột
* paint(): Vẽ hình thìa khóa dựa theo tọa độ hiện thời của khóa
* mouseDrag(): kéo thả chuột
+ Bắt tọa độ của chuột lúc nhấp (start_X) và lúc kéo (cur_X).
+ |cur_X – start_X| >= 35 thì vẽ lại khóa với phương thức repaint()
Solution:
public void mouseDragged(MouseEvent e) {
cur_X = e.getX();
cur_Y = e.getY();
if (start_Y > 30 && start_Y < 60) {
if (start_X >= puzzle.x_key - 20 && start_X <= puzzle.x_key +
30) {
if (puzzle.x_key < 420) {
if (cur_X - start_X >= 35) {
puzzle.x_key += 46;
repaint();
Swap cur and start x, y
start_X = cur_X;
/
}
14
}
if (puzzle.x_key >= 23) {
if (cur_X - start_X <= -46) {
puzzle.x_key -= 46;
repaint();
/ Swap cur and start x, y
start_X = cur_X;
}
}
}
3.
}
Lớp CreatePuzzle
a. Mục đích:
Đây là lớp chính trong phần tạo câu đố. Lớp CreatePuzzle có nhiệm
vụ tạo giao diện cho người dùng khởi tạo ô chữ. Giao diện của một đối
tượng CreatePuzzle gồm có: Panel chứa khóa, panel chứa ơ chữ và panel
chứa các button lựa chọn.
b. Thuộc tính
S
Tên
TT
1
Cell
2
Continue_b
utt2
3
Continue_b
utt4
4
OK
5
answer
6
butt1
7
butt2
8
butt3
9
butt4
9
butt5
1
canDrag
15
0
1
2
3
4
5
6
7
8
9
0
1
cau_do
1
count_db
1
cur_X
1
cur_Y
1
hint1
1
hint2
1
question
1
x_pos
1
y_pos
2
x_key,
y_key
c. Các phương thức chính:
* actionPerformed(ActionEvent e): Lắng nghe sự kiện khi click các
nút
* mousePressed(ActionEvent e): Lấy các tọa độ của chuột khi nhấp
chuột
* mouseDrag(ActionEvent e): Kéo thả các ô chữ
+ Để có thể kéo ơ chữ sang trai hoặc sang phải, ta sẽ bắt tọa
độ start_X và cur_X. Nếu như (cur_X – start_X) >= 35 thì dịch
sang phải bằng cách vẽ lại ma trận ô (repaint).
if (cur_X - start_X >= 35)
{ x_pos[i] +=
46;
/ Ve lai ma tran O
matrix.repaint();
/ Swap currrent and starting Co-ordinates
start_X = cur_X;
start_Y = cur_Y;
}
+ Nếu (start_X – cur_X) < -35 thì ơ chữ dịch sang trái.
16
if ((cur_X - start_X <= -35) && (x_pos[i] > 0))
{ x_pos[i] -= 46;
/ Ve lai ma tran O
matrix.repaint();
/ Swap Cur and Start
start_X = cur_X;
start_Y = cur_Y;
}
+ Để kéo ô lên hoặc xuống, ta sẽ dựa vào tọa độ của start_Y và
cur_Y
+
Nếu (cur_Y - start_Y) >= 43, thì dịch ơ chữ xuống dưới một ô
bằng repaint()
if (y_pos[i] <= 438) {
if (cur_Y - start_Y >= 43) {
int c;
/ swap X
c = x_pos[i];
x_pos[i] = x_pos[i + 1];
x_pos[i + 1] = c;
/ Swap Cell
c = Cell[i];
Cell[i] = Cell[i + 1];
Cell[i + 1] = c;
/ Ve lai ma tran O
matrix.repaint();
/
Swap Cur and Start
start_Y = cur_Y;
}
}
+ Nếu (cur_Y – start_Y) <= -43, thì dịch ơ chữ lên trên
if (cur_Y - start_Y <= -43) {
int c;
// swap X
c = x_pos[i];
x_pos[i] = x_pos[i - 1];
x_pos[i - 1] = c;
/ Swap Cell
c = Cell[i];
Cell[i] = Cell[i - 1];
17
}
Cell[i - 1] = c;
/ Ve lai ma tran O
matrix.repaint();
/ Swap Cur and Start
start_Y = cur_Y;
}
4.
Lớp Row
a. Mục đích:
Là một bản ghi khi nhập dữ liệu từ database, dữ liệu từ database
sẽ được lưu vào mảng table*+, với mỗi phần tử là lớp Row.
b. Thuộc tính
S
Thuộc
TT
tính
1
question
2
answer
3
hint1
4
hint2
5
6
x
y
c. Phương thức
* setRow(String, String, String, String, int, int): Thiết lập dữ liệu cho
hàng
5. Lớp Matrix
a. Mục đích
là ma trận ơ chữ được tạo nên từ dữ liệu trong
table*+ b. Thuộc tính
* Matrix*+*+: mảng 2 chiều kiểu
String. c. Phương thức
* Matrix(): Khởi tạo ma trận string, thiết lập tất cả các phần tử có giá
trị là “a”.
6. Lớp Clock (thừa kế lớp Thread)
18
a. Mục đích
Là đồng hồ đếm thời gian khi giải ô chữ
b. Thuộc tính
S
TT
1
2
3
4
Thuộc
tính
timeLef
timePass
label
end
c. Phương thức
* start(): Bắt đầu đếm thời gian. Sử dụng hàm sleep của Thread của
java là đồng hồ tính thời gian. Cứ mỗi lần sleep 1 giây thì biến đếm
giảm đi 1 cho đến khi biến đếm về 0.
* stop(): Dừng thời gian. Sử dụng hàm stop() có sẵn trong Thread,
khi ngừng hàm run() thì biến đếm sẽ ngừng lại.
* reset(): Khôi phục lại thời gian bằng cách khởi tạo lại biến đếm
về giá trị ban đầu.
7. Lớp CrossWord
a. Mô tả
Lớp này được thừa kế từ lớp Jpanel của java. Đây là lớp chính trong
phần game
Play.
b. Thuộc tính
S
Thuộc
TT
tính
1
conn
2
ran
3
4
5
ranID
table
toatalPoin
t
6
7
8
answer
question
buttons
9
textField_
19
1
showMatr
0
ix
c. Phương thức
* selectRow(int row): Lựa chọn ô cần trả lời. Đổi màu ô chọn dựa vào tọa
độ.
Solution:
private void selectColumn() {
hint.setEnabled(true);
deselectRow();
qColumn.setEnabled(false);
hintNumber = 0;
this.rowSelected = 13;
this.question = table[0].question;
this.answer = table[0].answer.toUpperCase();
this.hint1 = table[0].hint1;
this.hint2 = table[0].hint2;
questionText.setText(this.question);
if (!completeted[0]) {
answerText.setText("");
for (int i = 1; i <= table[0].answer.length(); i++) {
showMatrix[i][table[0].x].setBackground(Color.RED);
}
}
if (clock != null) {
clock.stop();
}
clock = new Clock(time);
clock.reset();
clock.start();
}
* deselectRow(): Đổi màu tất cả các hàng như cũ nếu hàng đó chưa
được giải
Solution:
private void deselectRow() {
for (int i = 1; i <= table[0].answer.length(); i++) {
if (!completeted[i]) {
20
for(int j=table[i].x;j
if (!(j == table[0].x)) {
showMatrix[table[i].y][j].setBackground(Color.YELLOW);
}
}
}
* CompleteRow(int row): Hiện đáp án hàng được chọn
Solution:
void completeRow(int n) {
if ( clock!=null) {
clock.stop();
}
answerText.setText(this.answer);
for (int i = table[n].x; i
showMatrix[table[n].y][i].setBackground(Color.ORANGE);
}
showMatrix[table[n].y][i].setText(""+cross.matrix[table[n].y][i]);
}
completeted[n] = true;
rowButtonQ[n - 1].setEnabled(false);
}
8. Phần tạo cơ sở dữ liệu
a. Phần tạo cơ sở dữ liệu:
Gameplay có 3 chủ đề tương ứng cho người chơi lựa chọn:
Thể thao giải trí
Văn hố xã hội
Chủ đề tự chọn
Trong database sẽ có 3 bảng dành cho các từ khố của các chủ đề tương
ứng gồm có:
Bảng key_question1: dành cho các từ khố thuộc chủ đề thể
thao giải trí
21
