Thiet Ke Phan Mem Giao Duc

Bùi Việt Hà
Viết kịch bản và thiết kế nhân vật

Đạo diễn toàn bộ chương trình
Thiết kế hệ thống thông tin lõi
Sơ đồ thiết kế hệ thống
Hà Nội - 2017
Lời nói đầu
Các bạn đang có trên tay cuốn sách rất đặc biệt về lập trình Scratch. Cuốn sách có
tên THIẾT KẾ PHẦN MỀM VÀ TRÒ CHƠI GIÁO DỤC bằng ngôn ngữ lập
trình Scratch. Cuốn sách này là một phát triển cao hơn nữa của cuốn sách TỰ
HỌC LẬP TRÌNH SCRATCH đã phát hành trước đây.
Đối tượng, mục đích

Đối tượng của cuốn sách này:
- Học sinh, cha mẹ học sinh, và bất kỳ ai muốn học hỏi tìm hiểu sâu hơn về ngôn
ngữ lập trình Scratch theo hướng mong muốn thiết kế các chương trình, phần
mềm, trò chơi hoàn chỉnh phục vụ công việc của mình.
- Giáo viên đang hoặc sẽ giảng dạy môn Tin học trong tương lai muốn tìm hiểu
sâu hơn hướng ứng dụng lập trình Scratch để thiết kế, xây dựng các chương trình
hoàn chỉnh. Việc dùng một ngôn ngữ lập trình cụ thể để thiết kế các phần mềm
hoàn chỉnh chính là hướng giáo dục STEM tốt nhất của môn Tin học.
- Cuốn sách này cũng hướng đến các giáo viên các bộ môn khác hoặc chuyên gia
trong lĩnh vực phần mềm, giáo dục STEM. Có thể nói rằng Scratch, hay các ngôn
ngữ lập trình trực quan là công cụ giáo dục STEM tốt nhất của môn Tin học và
các môn học khác có liên quan.
Môn Tin học trong tương lai sẽ như thế nào?
Môn Tin học của Việt Nam được xây dựng để đưa vào các trường THPT của Việt
Nam vào đầu những năm 1990, nhưng phải đến đợt thay SGK sau 2000 môn Tin
học mới chính thức được đưa vào cấp THPT. Sau đó các chương trình tự chọn của
Tin học và SGK dành cho THCS, Tiểu học dần được thiết lập. Vào khoảng 2008,
môn Tin học trong nhà trường Việt Nam đã hình thành đầy đủ với toàn bộ chương
trình và SGK phủ kín từ lớp 3 đến 12. Tuy nhiên chương trình cho cấp Tiểu học
và THCS là tự chọn, điều đó có nghĩa là không phải tất cả HS đều được học môn
học này liên tục từ lớp 3 đến lớp 12.
Có thể điểm qua toàn bộ các module kiến thức chính của môn Tin học trong
trường phổ thông của Việt Nam cho đến hiện nay (2017) là:
Tiểu học THCS THPT
Cấu trúc máy tính. Máy tính, hệ điều hành. Máy tính, hệ điều hành.
Tập chuột, tập gõ bàn Mạng Internet. Mạng máy tính. Mạng
phím. Soạn thảo văn bản. Internet.
Học vẽ. Bảng tính. Soạn thảo văn bản.
Học nhạc. Trình chiếu. Lập trình Pascal.
Soạn thảo văn bản. Lập trình Pascal. CSDL Access.
LOGO Phần mềm học tập.
Phần mềm học tập.
Môn Tin học ở các nước trên thế giới cùng có 1 lộ trình tương tự. Có thể với tên
gọi khác nhau nhưng nội dung thì cũng gần tương tự của Việt Nam chúng ta.
2|Thiết kế phần mềm

Từ lâu các các chuyên gia giáo dục trên thế giới (ví dụ trong cuốn shutdown or
restart [11]), đã phân tích sự tụt hậu của chương trình môn Tin học ở qui mô toàn
thế giới. Có thể tóm tắt như sau:
- Rời rạc, không liên thông, không liền mạch.
- Không đủ cơ sở vật chất hỗ trợ giảng dạy hoặc rất lạc hậu so với công nghệ hiện
tại.
- Không khoa học hoặc rất khó xác định tính khoa học chặt chẽ và mạch chính của
kiến thức.
- GV dạy không hứng thú, không có động lực để học thêm, đào sâu thêm kiến
thức.
- HS học nhàm chán vì kiến thức công nghệ bị lạc hậu với thực tế.
- Riêng ở Việt Nam, môn Tin học trong suốt thời gian qua là môn phụ, không
được thi ở bất cứ cấp học nào, vì vậy HS và GV càng không có động lực để học,
dạy môn học này.
Do vậy môn Tin học đứng trước thách thức rất lớn là cần thay đổi. Nhưng thay
đổi như thế nào? Theo hướng nào? Thay đổi để làm sao khắc phục được các
khuyết điểm trên? Tất cả những vấn đề đó đều rất rất khó giải quyết. Không phải
các chuyên gia, các nhà giáo không biết những điều trên, họ biết hết nhưng lực bất
tòng tâm. Vấn đề lớn nhất của môn Tin học là công nghê liên quan đến CNTT,
ICT phát triển quá nhanh, trong khi kiến thức khoa học lõi của ngành này lại
không thể hoặc chưa thể đưa xuống dạy cho học sinh từ nhỏ tuổi.
Một trong những tài liệu đầu tiên đề cập tới vấn đề này là cuốn sách Shutdown or
restart mà tôi nhắc đến ở trên. Cuốn này được viết năm 2012 và là tiền đề để
nước Anh là quốc gia đầu tiên thực hiện cuộc cách mạng thay đổi hoàn toàn môn
Tin học trong nhà trường. Trong cuốn sách đó, lần đầu tiên các chuyên gia đã
phân loại chính xác 3 hướng nội dung chính của kiến thức Tin học trong trường
học. Việc phân loại này sẽ giúp các nhà quản lý và chuyên gia GD hiểu rõ hơn và
định hướng được tương lai của môn học này. Phân loại nội dung trong cuốn sách
đó như sau:
Toàn bộ kiến thức cần học của Tin học sẽ được chia làm 3 nhóm chính:
1. CS (computer science): Khoa học máy tính.
2. IT (infomation technology): CNTT và ứng dụng.
3. DL (digital literacy): Học vấn số hóa phổ thông.
Tóm tắt như sau:
CS - Khoa học máy tính: Xử lý số, tư duy giải quyết vấn đề, thiết lập chương
trình, thuật toán, tư duy máy tính.
IT - CNTT và ứng dụng: Sử dụng công nghệ xử lý số, phần mềm để ứng dụng và
tạo ra các sản phẩm số. Ví dụ đồ họa, phim, ảnh, ứng dụng trong các công việc
đời sống.
DL - Học vấn số hóa phổ thông: Các kỹ năng cơ bản, tối thiểu cần có trong thời
đại số hóa, ví dụ: Kỹ năng sử dụng chuột, gõ bàn phím; Soạn thảo văn bản, bảng
tính, trình chiếu; Khai thác Internet. Sử dụng thư điện tử và mạng xã hội.
Theo tôi việc phân loại, định hướng kiến thức của môn Tin học trong nhà trường
theo 3 nhóm như trên là một phát triển đột phá trong việc định hình lại môn Tin
học trong nhà trường. Trong chương trình Giáo dục Phổ thông mới của Bộ GD &
ĐT sau 2018 rất may mắn đã kịp đưa các thay đổi này vào chương trình môn Tin
học. Môn Tin học sẽ là môn học có thay đổi lớn nhất trong Chương trình Giáo dục
Phổ thông mới này.
Như vậy, tương lai. kiến thức môn Tin học trong trường phổ thông sẽ được phân
tách thành 3 hướng kiến thức (phân môn) chính:
1. Khoa học máy tính (CS - Computer Science).
2. CNTT và ứng dụng (IT - Information Technology).
3. Kỹ năng số hóa phổ thông (DL - Digital Literacy).
Khoa học máy tính

CS
Kỹ năng số hóa phổ

Ứng dụng CNTT -
truyền thông
IT DL thông
Trong đó, chắc tất cả đều hiểu: phân môn Khoa học máy tính (CS) sẽ là quan
trọng nhất, đóng vai trò trung tâm, cốt lõi của môn Tin học.
Trong 3 hướng này, IT và DL là những nội dung mà giáo viên Tin học hiện nay
vẫn đang giảng dạy, do đó sẽ không có gì bỡ ngỡ. Riêng hướng CS là hoàn toàn
mới và hoàn toàn khác biệt so với hiện nay.
Có thể tóm tắt hướng đi, phát triển tương lai của 3 nhóm, phân môn của môn Tin
học trong bảng sau:
DL - Học vấn số hóa phổ IT - Ứng dụng CNTT và CS - Khoa học máy tính
thông truyền thông
Các kỹ năng cơ bản, tối Sử dụng công nghệ xử lý số, Lý thuyết và thực hành về xử
thiểu cần có trong thời đại phần mềm để ứng dụng và lý số, tư duy giải quyết vấn
số hóa, ví dụ: Kỹ năng sử tạo ra các sản phẩm số phục đề, thiết lập chương trình,
dụng chuột, gõ bàn phím; vụ yêu cầu. Ví dụ đồ họa, thuật toán, tư duy máy tính.
Soạn thảo văn bản, bảng phim, ảnh, ứng dụng trong
tính, trình chiếu; Khai thác các công việc đời sống.
Internet. Sử dụng thư điện
tử và mạng xã hội.
Đây là những kỹ năng, Mảng kiến thức này sẽ được Lõi của môn học này là khái
năng lực tối thiểu đơn giản phân thành 2 nhóm: niệm tư duy máy tính hay tư
nhất cần có của mọi công duy thuật toán. Đây là kiến
1. Nhóm ứng dụng CNTT,
dân trong thế giới số hiện phần mềm vào các chuyên thức cơ bản nằm bên dưới các
nay. Có thể ví như học khái niệm quen thuộc như
ngành, môn học khác với
đếm trong môn Toán và phần mềm, phần cứng máy
Tin học.
học đánh vần trong môn tính. Đi cùng mô hình tư duy
Tiếng Việt. 2. Nhóm các ứng dụng này là 1 tập hợp các kiến thức
CNTT, truyền thông bên lõi, cơ bản về lý thuyết cũng
trong ICT. như thực hành, kỹ năng, năng

DL - Học vấn số hóa phổ IT - Ứng dụng CNTT và CS - Khoa học máy tính
thông truyền thông
lực phân tích, mô phỏng và
giải quyết vấn đề.
Trong tương lai, những Hướng 1 sẽ được chuyển Đây là định hướng chính, cơ
kiến thức này sẽ chỉ được giao cho các bộ môn chuyên bản nhất và quan trọng nhất
dạy ở cấp Tiểu học và biệt. Môn Tin học chỉ còn của môn Tin học trong tương
được học ngoài giờ học có nhóm 2 và sẽ định hướng lai. Chính hướng này sẽ quyết
chính thức. cho nghề Tin học ứng dụng. định để môn Tin học trở
thành một môn học lõi, có
tính khoa học chặt chẽ, có
tính kế thừa và phát triển liên
tục cho các bậc học tiếp theo.
Có thể mô tả bảng trên theo sơ đồ sau:
DL - Học vấn số IT1- Ứng dụng trong CS - Khoa học máy tính.
hóa phổ thông. các lĩnh vực ngoài
Kiến thức lõi của Tin học:
ICT.
Tin học
Kỹ năng tối thiểu xử lý số, cấu trúc dữ liệu,

cho mỗi công dân lập trình, tư duy máy tính,
trong thời đại số. IT2- Ứng dụng bên giải quyết vấn đề.
trong ICT
Có thể so sánh 3 nhánh kiến thức của môn Tin học theo sơ đồ trên với các sơ dồ
sau của môn Toán và Ngữ văn - tiếng Việt.
Toán học
Học đếm, Cơ sở toán học:

bảng cửu Đo lường số, tập hợp, phép
chương tính tích phân
Ngữ văn
Ngữ pháp, ngôn

Bảng chữ ngữ, cảm thụ
cái, học Đọc hiểu
văn học
đánh vần
CS và IT là 2 mảng kiến thức bắt buộc cần dạy cho HS ngay từ cấp Tiểu học,
ngay từ lớp 1. Hai nhóm kiến thức này là độc lập với nhau, gần như bổ sung cho
nhau và có nhiều cách tiếp cận, định hướng khác nhau hoàn toàn. Giáo viên Tin
học cần hiểu rõ điều này khi giảng dạy. Các chuyên gia thiết kế chương trình môn

Tin học cần vạch rõ những sự khác biệt này giữa 2 hướng trên trong quá trình
thiết kế của mình.
a) So sánh định hướng nội dung giữa CS và IT
CS - Khoa học máy tính IT - CNTT và ứng dụng
1- Là 1 tập hợp ý tưởng, quan niệm 1- Là một tập hợp các ứng độc lập, rời
thống nhất, chặt chẽ, logic của 1 môn rạc của CNTT trong các lĩnh vực khác
học. Ví dụ các quan niệm như Chương nhau của đời sống.
trình; Thuật toán; Cấu trúc dữ liệu;
Kiến trúc hệ thống.
2- Là 1 tập hợp các kỹ thuật, kỹ năng 2- Là 1 tập hợp các kỹ thuật, kỹ năng,
logic chặt chẽ, có phát triển từ thấp năng lực có logic, phát triển từ thấp
đến cao. Ví dụ kỹ thuật lập trình, thuật đến cao, tuy nhiên các kỹ năng này sẽ
toán, kiểm thử, sửa lỗi chương trình. tập trung phục vụ ứng dụng chứ không
phục vụ cho việc giải quyết vấn đề.
3- Có 1 hệ thống tư duy độc lập, riêng 3- Mỗi ứng dụng có những hệ thống tư
biệt của môn học. Ví dụ tư duy máy duy riêng, rời rạc, không thống nhất
tính, tư duy thuật toán, tư duy giải và không định hướng giải quyết vấn
quyết vấn đề, …. đề.
4- Có tính chất bền vững với thời gian. 4 - Hoàn toàn phụ thuộc vào công
Chú ý rằng tính chất này không thể nghệ, dễ thay đổi với thời gian.
đúng với IT vì CNTT phát triển rất
nhanh nên không có 1 hệ thống nào
bền vững với thời gian.
5- Hệ thống lý thuyết độc lập với công 5 - Không có hệ thống lý thuyết độc
nghệ. Ví dụ hệ thống các ngôn ngữ lập lập, tất cả đều phụ thuộc vào công
trình, thuật toán, …. đều độc lập với nghệ.
kỹ thuật và công nghệ cụ thể.
b) So sánh mục đích, đối tượng và yêu cầu năng lực CS và IT

IT - CNTT và ứng dụng CS - Khoa học máy tính
Hệ thống máy Hệ thống máy tính được sử Hệ thống máy tính được hoạt
tính dụng như thế nào. động, làm việc như thế nào.
Đối tượng Con người là trung tâm của Máy tính là trung tâm của
môn học. môn học.
Định hướng Tập trung, quan tâm đến sự Tập trung, quan tâm đến tư
cốt lõi phát triển của hệ thống duy thuật toán, đến cách mà
hướng tới nhu cầu người sử vấn đề có thể phân rã thành
dụng. các bài toán, vấn đề nhỏ hơn
để giải quyết.
Sản phẩm Quan tâm đến việc sử dụng Quan tâm đến việc thiết kế các
các phần mềm, hệ thống đã hệ thống, phần mềm mới.
có để đáp ứng nhu cầu hiện
tại.

IT - CNTT và ứng dụng CS - Khoa học máy tính
Sử dụng sản Nhấn mạnh việc lựa chọn, Nhấn mạnh đến các nguyên lý
phẩm đánh giá sử dụng phần mềm và kỹ thuật của hệ thống, phần
trong công việc. mềm. Lập trình luôn đóng vai
trò trung tâm của các vấn đề
quan tâm.
Tư duy hệ Hệ thống ứng dụng CNTT Các ứng dụng thực tế cần
thống phải hỗ trợ hoạt động của được xây dựng thông qua các
con người hay tự động hóa tư duy của "máy tính". Thông
hoạt động của con người. qua tư duy này chúng ta sẽ
hiểu được thế giới tự nhiên
như bản chất nó có, nhưng
theo cách tư duy riêng của
chúng ta, thông qua máy tính.
Định hướng Định hướng ứng dụng, nghề Định hướng chuyên nghiệp,
chung nghiệp. hàn lâm.
Tư duy máy tính: năng lực tư duy quan trọng nhất của
Khoa học máy tính.
Xuất xứ của khái niệm Tư duy máy tính (computational thinking).
Người đầu tiên nhắc đến cụm từ này là Seymour Papert (29/2/1928 – 31/7/2016),
giáo sư toán đại học MIT đồng thời là tác giả của phần mềm và ngôn ngữ lập trình
LOGO, trong khi muốn đưa việc giảng dạy thuật toán bằng phần mềm này cho
học sinh nhỏ tuổi.
“… the thought processes involved in formulating problems and their solutions
so that the solutions are represented in a form that can be effectively carried out
by an information-processing agent”.
tạm dịch:
"… là các quá trình tư duy bao gồm cả mô tả và lời giải bài toán sao cho lời
giải có thể được thực hiện một cách hiệu quả bởi các tác tử xử lý thông tin".
Tác giả GS Jeannette Wing (hiện là phó chủ tịch Microsoft) là người đầu tiên
đưa ra định nghĩa của khái niệm này (tư duy máy tính), như sau:
“The solution can be carried out by a human or machine, or more generally, by
combinations of humans and machines.”
tạm dịch:
"Lời giải phải (và có thể) được thực hiện bởi con người hoặc máy tính, hoặc
tổng quát hơn, bởi sự kết hợp (đồng thời) con người và máy tính".
Như vậy tư duy máy tính chính là kỹ năng rất cơ bản để chúng ta có thể hiểu,
biết một cách có lý, logic về thế giới xung quanh dựa trên sức mạnh của máy tính.
Phân môn "Khoa học máy tính" là môn học dạy các nguyên tắc lý thuyết và thực
hành cho mô hình tính toán máy tính và các ứng dụng của mô hình này. Lõi của
môn học này là khái niệm tư duy máy tính hay tư duy thuật toán. Đây là mô
hình tư duy lõi, cơ bản nằm bên dưới các khái niệm quen thuộc như phần mềm,
phần cứng máy tính. Mô hình tư duy này sẽ cung cấp các khung kiến thức để giải
quyết các bài toán, vấn đề nảy sinh. Đi cùng mô hình tư duy này là 1 tập hợp các
kiến thức lõi, cơ bản về lý thuyết cũng như thực hành, kỹ năng, năng lực phân
tích, mô phỏng và giải quyết vấn đề.
Khoa học máy tính đi sâu vào tìm hiểu cách làm việc và vận hành của máy tính và
các hệ thống máy tính, tìm hiểu các máy tính và chương trình được thiết kế và lập
trình như thế nào. Học sinh sẽ được tiếp cận với các hệ thống tính toán theo mọi
khía cạnh, có thể cần hoặc không cần có máy tính. "Tư duy máy tính" sẽ có ảnh
hưởng đến cả các lĩnh vực khoa học khác như sinh học, hóa học, ngôn ngữ, tâm lý
học, kinh tế và thống kê. Cũng chính tư duy đó sẽ giúp học sinh có thể giải các bài
toán, giải quyết vấn đề, thiết kế hệ thống, sản phẩm và hiểu được sức mạnh cũng
như giới hạn, hạn chế của con người và máy móc. Chính tư duy đó sẽ là yêu cầu
kỹ năng, năng lực mà mỗi học sinh cần hiểu và nắm bắt được dù chỉ một phần của
nó. Nếu có các kỹ năng, tư duy, suy luận như "máy tính" thì các học sinh này sẽ
hiểu tốt hơn và có nhiều cơ hội hơn trong việc tiếp thu các công nghệ "dựa trên
máy tính" (computer-based technology) và sẽ được chuẩn bị tốt hơn khi trở thành
công dân tương lai trong xã hội hiện đại.
Khoa học máy tính là môn học thực hành, trong đó rất khuyến khích sự dũng cảm
và sáng tạo. Học sinh được học các nguyên tắc, lý thuyết hàn lâm của môn học và
khuyến khích ứng dụng sáng tạo để hiểu và mô phỏng được thế giới thực xung
quanh các em. Sự kết hợp hài hòa giữa lý thuyết, thực hành và sáng tạo sẽ làm cho
môn học này trở nên vô cùng hấp dẫn, giúp các học sinh có thể tạo ra được các
sản phẩm vừa có ích ("Nó chạy rồi!") vừa trí tuệ ("Nó quá đẹp!").
Tư duy máy tính ở đây cần được hiểu là nói về khả năng con người có thể làm,
chứ không phải máy tính có thể làm. Ví dụ khi nhắc đến tư duy máy tính người ta
thường nhắc đến các khả năng suy nghĩ và làm việc logic, có tính (tối ưu) thuật
toán, có thể lặp lại và có thể trừu tượng hóa.
Trong mô hình phân môn Khoa học máy tính của Tin học, tư duy máy tính cần
được trang bị cho học sinh ngay từ cấp Tiểu học.
Các năng lực, kỹ năng cơ bản của tư duy máy tính bao gồm Trừu tượng hóa và
Lập trình.
Tin học và vai trò của các ngôn ngữ lập trinh trực quan
Chúng ta cùng xem lại các mốc sự kiện công nghệ quan trọng với môn Tin học và
ngành CNTT, ICT nói chung.
1945. Ra đời máy tính điện tử, ra đời ngành CNTT, khoa học máy tính.
1970x. Xuất hiện các máy tính mainframe, nhỏ hơn nhiều so với những chiếc máy
tính thế hệ đầu tiên. Ngành Khoa học máy tính, CNTT chính thức được hình
thành và giảng dạy trong các trường đại học.
1980. Máy tính cá nhân (PC) ra đời, đưa các ứng dụng của CNTT đến từng gia
đình. Lần đầu tiên môn Tin học (chỉ bao gồm học các ứng dụng) được đưa xuống
nhà trường cho học sinh các lớp cuối cấp.
1990-2000. Bùng nổ Internet các ứng dụng mạng trên qui mô toàn cầu. Môn Tin
học được đưa xuống cấp 1, nhưng chỉ dừng lại ở việc học các ứng dụng cụ thể, rời
rạc.
2005-7. Xuất hiện điện thoại thông minh, sau đó là các ứng ụng IoT, len lỏi vào
khắp các ngành công nghiệp và dịch vụ. Xuất hiện các khoa học mới như tự động
hóa, khoa học dữ liệu, trí tuệ nhân tạo có ứng dụng cụ thể hàng ngày. CMCN 4.0
xuất hiện.

2010-2016. Xuất hiện các ngôn ngữ lập trình trực quan, lập trình kéo thả, ví dụ
Scratch. Cơ hội để đưa phân môn Khoa học máy tính xuống dạy cho học sinh từ
cấp Tiểu học.
Như vậy Ngôn ngữ lập trình trực quan, ví dụ như Scratch, đóng vai trò vô cùng
quan trọng trong sự phát triển của môn Tin học. Có thể so sánh đây là 1 cuộc cách
mạng lớn về giáo dục, lần đầu tiên, học sinh có thể học lập trình, tư duy máy tính,
thuật toán, khoa học máy tính ngay từ lớp 1.
Scratch và giáo dục STEM
Gần đây, cùng với từ khóa CMCN 4.0, STEM cũng trở thành 1 cụm từ rất hot.
Nhà nhà nói STEM, người người nói STEM.
Vậy STEM là gì? nó có phải là một môn học? hay một phương pháp giảng dạy
mới? hay là một công nghệ giáo dục mới của thế giới?
Câu trả lời là không phải như vậy. STEM không phải là môn học, cũng không
phải là một phương pháp giảng dạy, cũng không phải là một công nghệ gì mới.
STEM là 4 chữ cái đầu của các từ Kỹ nghệ (Engineering), Toán học
(Mathematics), Khoa học (Science) và Công nghệ (Technology).
Bản thân STEM được các nhà khoa học và giáo dục đưa ra chỉ để muốn nhấn
mạnh đến tầm quan trọng đặc biệt của 4 chuyên ngành trên trong sự phát triển
khoa học kỹ thuật và ứng dụng hiện nay.
Trên thực tế những phát minh công nghệ, khoa học, ứng dụng mới rất nhiều là
một tích hợp công nghệ từ những chuyên ngành trên. Do vậy các nhà khoa học
mới đưa ra 4 chữ cái trên, như một slogan để khuyến khích việc học tập, nghiên
cứu xung quanh các môn học này và các tích hợp giữa chúng.
Tuy nhiên có 1 chuyên ngành nữa mà ai cũng biết đóng vai trò then chốt nhất, tích
hợp giữa các hướng trên, đó chính là Tin học, hay nói chính xác hơn là khoa học
máy tính trong tin học.
Khoa học máy tính là môn học mang đặc tính STEM rõ nhất, môn học này có
nhiều điểm chung nhất với đồng thời các thành phần khác của STEM như Kỹ
nghệ (Engineering), Toán học (Mathematics), Khoa học (Science) và Công nghệ
(Technology). Sau đây là một vài lý giải cho mệnh đề trên.
- Hướng kiến thức này dựa trên một hệ thống cơ sở lý luận toán học chặt chẽ,
logic và khoa học.
- Trọng tâm của Khoa học máy tính là "tư duy máy tính", có cơ sở lý luận hàn
lâm nền tảng kết hợp thực nghiệm và đánh giá, đo đạc số liệu một cách khoa
học.
- Lõi của Khoa học máy tính là phần kiến thức lập trình, một kỹ năng đòi hỏi quá
trình thiết kế, xây dựng, kiểm thử và đánh giá dựa trên các tiêu chuẩn kỹ thuật.
- Khoa học máy tính yêu cầu và có liên quan rất nhiều đến sự hiểu biết, ứng dụng,
đánh giá các công nghệ của nhiều chuyên ngành khác nhau.

Hơn nữa Khoa học máy tính còn có ứng dụng rất sâu trong tất cả các lĩnh vực
STEM khác như chúng ta vẫn biết rõ điều đó. Có thể nói tư duy máy tính, các
nguyên tắc cơ bản của tính toán, các cơ sở lý thuyết giải quyết vấn đề dựa trên
máy tính là chìa khóa dẫn đến thành công của các nhánh khoa học khác như kỹ
nghệ, kinh doanh và thương mại trong thế kỷ 21.
Do vậy mô hình hay cái gọi là STEM cần được thể hiện lại chính xác hơn như
hình sau.
STEM bắt buộc phải gắn liền với Tin học, với Khoa học máy tính, chúng tuy 2
nhưng là 1 thực thể thống nhất, không thể tách rời. Khoa học máy tính là nền tảng
lý thuyết và công nghệ kết nối các chuyên ngành khác nhau trong mô hình STEM.
Scratch là môi trường lập trình hỗ trợ giáo dục STEM tốt
nhất.
Vì sao lại có thể khẳng định Scratch là môi trường lập trình hỗ trợ giáo dục STEM
tốt nhất?
Như chúng ta đã biết, điểm cốt lõi cơ bản nhất của giáo dục STEM là vừa học vừa
làm, thực hành làm ra các sản phẩm cụ thể, từ đó nâng cao sự đam mê, yêu thích
môn học của mình.
Với cách hiểu trên thì với môn Tin học, tinh thần giáo dục STEM chính là khuyến
khích làm ra các sản phẩm cụ thể từ chính các kiến thức môn học của mình.
Ngôn ngữ lập trình Scratch rất trực quan, dễ dàng tạo ra các sản phẩm, chương
trình, phần mềm hay đơn giản là một trò chơi. Đây chính là điểm mạnh nhất của
Scratch mà các ngôn ngữ lập trình bậc cao khác không thể làm được, vì qui trình
làm ra một sản phẩm hoàn chỉnh bằng các ngôn ngữ lập trình bậc cao khác là khá
phức tạp.
Cuốn sách này được viết nhằm mục đích chính tăng cường giáo dục STEM của
môn Tin học.
Giới thiệu nhanh các chủ đề cuốn sách
Sau đây là giới thiệu nhanh nội dung cuốn sách.
Sách sẽ có 8 chương. Mỗi chương là một chủ đề độc lập, định hướng vào công
nghệ, kỹ thuật làm phần mềm hoặc định hướng nội dung phần mềm. Các chủ đề
đều có thể đọc độc lập. 3 chủ đề đầu tiên là định hướng công cụ, 5 chủ đề sau là
định hướng nội dung thiết kế phần mềm.
Sau mỗi chủ đề là một số bài tập nhỏ. Chúng tôi sẽ liên tục bổ sung thêm các bài
tập, mở rộng này trong tương lai.
10 | T h i ế t k ế p h ầ n m ề m
Chủ đề 1. Một số nguyên tắc và qui trình thiết kế phần mềm
Mục tiêu:
- Giới thiệu một số nguyên tắc thiết kế phần mềm, trò chơi trên Scratch.
- Mô tả các bước thiết kế 1 chương trình phần mềm hoàn chỉnh.
Chủ đề 1 sẽ trình bày một số nguyên tắc, và đặc biệt trình bày, đưa ra 1 qui trình
thiết kế phần mềm bằng Scratch. Có 4 qui trình quan trọng nhất của việc thiết kế
phần mềm là:
- Viết kịch bản phần mềm.
- Thiết kế nhân vật.
- Thiết kế bộ dữ liệu hệ thống.
- Lập trình.
Để có thể lập trình dễ dàng, không mắc lỗi, cần xây dựng và vẽ được Sơ đồ thiết
kế - hoạt động của chương trình. Sơ đồ này càng được vẽ cẩn thận, chính xác bao
nhiêu thì việc cài đặt, lập trình sẽ càng dễ dàng bấy nhiêu.
Chủ đề 2. Clone và một số kỹ thuật xử lý Clone
Mục tiêu:
- Giới thiệu nhanh khái niệm và một số kỹ thuật lập trình với Clone trong Scratch.
- Ứng dụng kỹ thuật Clone trong việc thiết kế phần mềm, trò chơi giáo dục.
Chủ đề này nhắc lại các kiến thức, kỹ thuật chính liên quan đến Clone (phân
thân). Clone có lẽ đóng vai trò trung tâm nhất của toàn bộ quá trình thiết kế phần
mềm. Nội dung của chủ đề này được lấy chủ yếu từ cuốn sách TỰ HỌC LẬP
TRÌNH SCRATCH mà tôi đã viết trước đây.
Chủ đề 3. Các công cụ và kỹ thuật thiết kế phần mềm
Mục tiêu:
- Một số kỹ thuật chính khi thiết kế phần mềm thực sự so sánh với việc chỉ viết
chương trình theo yêu cầu của người khác.
- Một vài kỹ thuật và đặc thù chính của một phần mềm hay trò chơi.
Chủ đề này trình bày một số kỹ thuật và công cụ hay dùng trong khi viết các
chương trình phần mềm cụ thể. Các công cụ này rất cần thiết cho mọi người muốn
tự học thiết kế phần mềm. Ví dụ các công cụ đã trình bày trong chủ đề này:
- Kỹ thuật đếm điểm số, do thời gian.
- Kỹ thuật hiển thị số lần chơi.
- Kỹ thuật hiển thị số hoặc chữ lớn.
- Một số cách thiết kế và thuật toán sinh ngẫu nhiên.
Chủ đề 4. Thiết kế một số phần mềm quen thuộc
Mục tiêu:
- Thiết kế một số phần mềm giáo dục quen thuộc, từ dễ đến khó để rèn luyện các
kỹ năng cơ bản thiết kế phần mềm.
Chủ đề này sẽ bắt đầu thực sự thiết kế chi tiết một số phần mềm quen thuộc và
tiêu biểu. Hầu hết các phần mềm trong chủ đề này đều đã được giới thiệu trong
cuốn sách trước của tôi, nhưng trong cuốn sách này, các phần mềm này sẽ được
mô tả hoàn toàn chi tiết đến mức lập trình.
Các phần mềm được mô tả trong chủ đề này là:
- Bút vẽ tự do và nâng cao.
- Flappy Bird.
- Kỹ thuật bắn súng.
- Tham quan bảo tàng.
- Trò chơi đoán từ Hangman.
- Trò chơi mưa từ.
- Trò chơi Luyện trí nhớ.
- Trò chơi Ô chữ.
Chủ đề 5. Phần mềm tập chuột, bàn phím
Mục tiêu:
- Các phương pháp điều khiển nhân vật bằng chuột và bàn phím.
- Một số kỹ thuật xử lý chuột.
- Phần mềm tập chuột, bàn phím cho học sinh.
Chủ đề này bắt đầu bằng việc mô tả các kỹ thuật điều khiển bàn phím, chuột và kỹ
năng nhận biết điều khiển chuột.
Các thao tác chuột sau được mô tả chi tiết trong chủ đề:
- Di chuyển chuột.
- Nháy chuột.
- Kéo thả chuột.
- Nháy đúp chuột.
Phần mềm Mouse Skills dùng để luyện các thao tác với chuột được thiết kế chi
tiết trong phần này.
Ngoài ra một phần mềm học gõ bàn phím bằng 10 ngón cũng được thiết kế, mô tả
trong chủ đề này.
Chủ đề 6. Phần mềm hỗ trợ học khoa học máy tính
Mục tiêu:
- Một số thuật toán chính biến đổi số trong các hệ đếm khác nhau.
- Thiết kế phần mềm, trò chơi liên quan đến biến đổi số trong các hệ đếm khác
nhau.
- Một số phần mềm khác hỗ trợ giảng dạy khoa học máy tính trong trường phổ
thông.
Chủ đề này tập trung mô tả một số chương trình ứng dụng có liên quan đến phân
môn khoa học máy tính của môn Tin học. Các chủ đề cụ thể bao gồm:
- Các thuật toán và bài toán mô tả việc chuyển đổi giữa các hệ đếm thập phân, nhị
phân và hexa.
- Các thuật toán sắp xếp và phần mềm mô phỏng sắp xếp.
- Các trò chơi có liên quan đến sắp xếp số.
Chủ đề 7. Phần mềm hỗ trợ học toán
Mục tiêu:
- Thiết kế một số phần mềm hỗ trợ học và dạy môn Toán.
- Một số thuật toán sinh dãy số ngẫu nhiên, sinh các bài toán đầu vào cho các phần
mềm học Toán.
Chủ đề này tập trung mô tả các phần mềm ứng dụng học và giải toán. Các dạng
toán trắc nghiệm và điền số trực tiếp được mô tả trong chủ đề này.
Một lớp các bài toán điền số vào dãy được thiết kế dữ liệu cẩn thận và mô tả chi
tiết trong chủ đề này.
Chủ đề 8. Phần mềm hỗ trợ học khoa học
Mục tiêu:
- Thiết lập các dạng bài toán mô tả các hiện tượng thực tế, có tính chính xác và
khoa học.
- Thiết kế một số phần mềm đơn giản cho môn Khoa học tự nhiên.
Chủ đề này chỉ bao gồm những ví dụ nhỏ ban đầu của hướng phần mềm dành cho
nhóm các môn học khoa học. Đặc điểm của các ứng dụng này là tính chính xác
khoa học của các mô phỏng.
Chủ đề bao gồm 1 số chương trình, ứng dụng mô phỏng lịch tháng và đồng hồ số,
mô phỏng viên đạn bắn ra khỏi nòng súng, mô phỏng chuyển động của bánh xe,
chuyển động của quả bóng trong trò chơi bi-a.
Chủ đề này sẽ có có rất nhiều phát triển trong tương lai.
MỤC LỤC
Lời nói đầu ................................................................................................................... 2
Đối tượng, mục đích ................................................................................................ 2
Môn Tin học trong tương lai sẽ như thế nào? ................................................... 2
Tư duy máy tính: năng lực tư duy quan trọng nhất của Khoa học máy tính. .. 7
Tin học và vai trò của các ngôn ngữ lập trinh trực quan .................................. 8
Scratch và giáo dục STEM ..................................................................................... 9
Scratch là môi trường lập trình hỗ trợ giáo dục STEM tốt nhất..................... 10
Giới thiệu nhanh các chủ đề cuốn sách ................................................................ 10
Chủ đề 1. Một số nguyên tắc và qui trình thiết kế phần mềm ........................ 11
Chủ đề 2. Clone và một số kỹ thuật xử lý Clone ............................................ 11
Chủ đề 3. Các công cụ và kỹ thuật thiết kế phần mềm ................................... 11
Chủ đề 4. Thiết kế một số phần mềm quen thuộc ........................................... 11
Chủ đề 5. Phần mềm tập chuột, bàn phím ....................................................... 12
Chủ đề 6. Phần mềm hỗ trợ học khoa học máy tính ....................................... 12
Chủ đề 7. Phần mềm hỗ trợ học toán ............................................................... 13
Chủ đề 8. Phần mềm hỗ trợ học khoa học ....................................................... 13
Chủ đề 1. Một số nguyên tắc và qui trình thiết kế phần mềm ............................... 19
Nội dung chính ...................................................................................................... 19
1. Ai là người thiết kế phần mềm? ................................................................... 19
2. Các bước thiết kế phần mềm ........................................................................ 20
3. Sơ đồ thiết kế phần mềm .............................................................................. 21
4. Ví dụ 1: Tìm hiểu các con vật ...................................................................... 22
5. Ví dụ 2: Math Board ..................................................................................... 27
Câu hỏi - Bài tập - Mở rộng .................................................................................. 34
Chủ đề 2. Clone và một số kỹ thuật xử lý Clone .................................................... 36
Nội dung chính ...................................................................................................... 36
1. Khái niệm phân thân - clone trong Scratch ................................................. 36
2. Rừng hoa........................................................................................................ 39
3. Hai chú mèo sinh đôi .................................................................................... 40
4. Thuộc tính của nhân vật................................................................................ 41
5. Biến nhớ riêng là thuộc tính của nhân vật ................................................... 45
6. Clone kế thừa thuộc tính nhân vật ............................................................... 46
7. Giao tiếp người dùng - clone, clone - clone ................................................ 50
Chủ đề 3. Các công cụ, kỹ thuật thiết kế phần mềm .............................................. 54
Nội dung chính ...................................................................................................... 54
1. Một số đặc điểm của phần mềm trò chơi..................................................... 54
2. Kỹ thuật đếm ngược...................................................................................... 56
3. Mô phỏng lượt chơi cho các nhân vật ......................................................... 57
4. Kỹ thuật tính điểm số cho người chơi ......................................................... 59
5. Thể hiện số và đếm số .................................................................................. 60
6. Thể hiện chữ, tên người, nhân vật................................................................ 65
7. Kỹ thuật sinh ngẫu nhiên trong các trò chơi và phần mềm ........................ 66
8. Thuật toán sinh ngẫu nhiên 1 bộ đáp án, trong đó có 1 đáp án đúng ........ 70
9. Ví dụ: trò chơi điều khiển bóng ................................................................... 72
Chủ đề 4. Thiết kế một số phần mềm quen thuộc .................................................. 79
Nội dung chính ...................................................................................................... 79
1. Chương trình Bút vẽ màu hoàn chỉnh .......................................................... 79
2. Trò chơi, phần mềm, kỹ thuật bắn súng ...................................................... 83
3. Flappy Bird .................................................................................................... 92
4. Trình diễn trong bảo tàng ........................................................................... 101
5. Bút vẽ nâng cao và bài toán vẽ hình mẫu .................................................. 109
6. Trò chơi hangman ....................................................................................... 116
7. Trò chơi mưa từ........................................................................................... 127
8. Trò chơi luyện trí nhớ ................................................................................. 133
9. Trò chơi Ô chữ ............................................................................................ 146
Câu hỏi - Bài tập - Mở rộng ................................................................................ 166
Chủ đề 5. Phần mềm tập chuột, bàn phím ............................................................ 168
Nội dung chính .................................................................................................... 168
1. Điều khiển nhân vật bằng bàn phím .......................................................... 168
2. Điều khiển nhân vật bằng chuột ................................................................. 168
3. Mô phỏng di chuyển chuột ......................................................................... 171
4. Mô phỏng tập nháy chuột ........................................................................... 173
5. Mô phỏng tập kéo thả chuột ....................................................................... 175
6. Mô phỏng tập nháy đúp chuột .................................................................... 178
7. Phần mềm tập gõ bàn phím ........................................................................ 181
8. Ví dụ: phần mềm Mouse Skills .................................................................. 189
Chủ đề 6. Phần mềm hỗ trợ học Khoa học máy tính............................................ 198
Nội dung chính .................................................................................................... 198
1. Thuật toán biến đổi số thập phân, nhị phân và hexa ................................. 198
2. Phần mềm hiển thị và biến đổi giữa số thập phân, nhị phân và hexa ...... 203
3. Mô phỏng sắp xếp (loại 1) .......................................................................... 204
5. Biểu diễn nhị phân ...................................................................................... 219
6. Mô phỏng sắp xếp (loại 3). Trò chơi xếp số trong hình vuông ................ 224
Chủ đề 7. Phần mềm hỗ trợ học Toán ................................................................... 242
Nội dung chính .................................................................................................... 242
1. Trò chơi điền số vào dãy, vào bảng ........................................................... 242
2. Trò chơi tìm số ............................................................................................ 255
3. Trò chơi bắn súng giải toán ........................................................................ 269
Chủ đề 8. Phần mềm hỗ trợ học Khoa học ........................................................... 282
Nội dung chính .................................................................................................... 282
1. Mô phỏng đồng hồ và lịch .......................................................................... 282
2. Các bánh xe quay ........................................................................................ 292
3. Bánh xe lăn trên đường thẳng .................................................................... 294
4. Bánh xe quay trong vòng tròn .................................................................... 296
5. Bánh xe lăn trên đường cong bất kỳ .......................................................... 299
6. Mô phỏng bắn súng..................................................................................... 305
7. Mô phỏng Bi-a ............................................................................................ 312
PHỤ LỤC: CÁC TẬP LỆNH SCRATCH............................................................. 322
1. Nhóm câu lệnh Move ...................................................................................... 322
2. Nhóm câu lệnh Look ....................................................................................... 323
3. Nhóm câu lệnh Sound ..................................................................................... 325
4. Nhóm câu lệnh Pen ......................................................................................... 326
5. Nhóm câu lệnh Variable ................................................................................. 327
6. Nhóm câu lệnh Event ...................................................................................... 328
7. Nhóm câu lệnh Control ................................................................................... 330
8. Nhóm câu lệnh Sensing .................................................................................. 331
9. Nhóm câu lệnh Operators ............................................................................... 334
10. Nhóm lệnh More Blocks ............................................................................... 335
Tài liệu tham khảo ................................................................................................... 337
Chủ đề 1.
Một số nguyên tắc và qui trình thiết kế phần mềm
Mục tiêu:
- Giới thiệu một số nguyên tắc thiết kế phần mềm, trò chơi trên Scratch.
- Mô tả các bước thiết kế 1 chương trình phần mềm hoàn chỉnh.
Nội dung chính
Nhắc lại rằng những điều được viết ra trong bài học này, cũng như quyển sách
này, chỉ có ý nghĩa trong phạm vi môi trường lập trình kéo thả Scratch. Tuy nhiên
nó có ích cho tất cả những ai đã và đang làm trong ngành CNTT, đặc biệt là lập
trình và thiết kế phần mềm.
1. Ai là người thiết kế phần mềm?
Người thiết kế phần mềm bằng lập trình Scratch phải là người đóng các vai trò
sau (4 trong 1).
A. Người viết kịch bản và thiết kế nhân vật
Như chúng ta đều biết, cái đầu tiên cần có của mọi bộ phim, vở diễn hay bất cứ sụ
kiện trình diễn nào đó chính là kịch bản. Kịch bản ở đây được hiểu là cốt truyện,
nội dung chính của truyện, lời thoại, hoạt động của các nhân vật chính. Kịch bản
còn có thông tin như mục đích, yêu cầu, đối tượng muốn hướng đến của câu
chuyện.
Với phần mềm cũng vậy, cái cần đầu tiên và số 1 là kịch bản của phần mềm. Hay
cái mà chúng ta vẫn thường gọi là yêu cầu cụ thể của bài toán.
Điều này cũng đúng với Scratch.
Người viết kịch bản và thiết kế nhân vật của phần mềm Scratch chính là người
đầu tiên và quan trọng nhất phác thảo ra yêu cầu, nội dung, kịch bản và hoạt động
cụ thể của các nhân vật trong phần mềm.
Trên thực tế người viết kịch bản và thiết kế nhân vật cho 1 chương trình
Scratch thực hiện những công việc sau:
- Thiết kế yêu cầu cụ thể và chi tiết của phần mềm bao gồm các hoạt động chính,
các chức năng chính, nêu được mục đích và đối tượng sử dụng của chương trình.
- Thiết kế các nhân vật chính, các nút lệnh chính của chương trình.
- Mô tả các chức năng, hoạt động chi tiết của từng nhân vật, từng nút lệnh trong
chương trình.
B. Đạo diễn chính toàn bộ hoạt động của phần mềm
Đạo diễn là người tổng chỉ huy việc thiết kế toàn bộ chương trình từ khi có kịch
bản cho đến khi kết thúc, hoàn thiện chương trình.
Đối với chương trình, phần mềm Scratch, công việc của đạo diễn là:
- Xác định công nghệ chính sẽ được sử dụng trong chương trình. Chú ý rằng 1 bài
toán, 1 kịch bản có thể có nhiều cách làm khác nhau, dựa vào các công nghệ, kỹ
thuật khác nhau. Ví dụ trong kịch bản sẽ có 3 nhân vật A, B, C. Đạo diễn sẽ là
người quyết định thiết lập 3 nhân vật độc lập hay chỉ dùng 1 nhân vật với 3 clone
để thể hiện.
- Thiết kế toàn bộ giao diện đồ họa của chương trình bao gồm nhân vật, nền sân
khấu và các nút lệnh.
- Tìm kiếm âm thanh sẽ được sử dụng trong chương trình.
- Quản trị toàn bộ chương trình, kiểm tra, kiểm thử, sửa lỗi trong suốt quá trình
thiết kế chi tiết và lập trình.
- Quyết định thời điểm chương trình hoàn thành và nghiệm thu.
C. Người thiết kế hệ thống thông tin: tổng quát và chi tiết
Sau khi đã có kịch bản và thiết kế nhân vật, xác định xong công nghệ lõi thực hiện
thì bước tiếp theo là thiết kế hệ thống thông tin tổng quát và chi tiết. Các công
việc chính của người thiết kế hệ thống thông tin bao gồm:
- Thiết kế các biến nhớ và dữ liệu tổng thể.
- Phân rã chương trình.
- Tổng quát hóa và trừu tượng hóa các mô hình: nhân vật, sự kiện, hành động.
- Thiết kế sơ đồ quan hệ giữa các nhân vật và nền sân khấu.
- Chuẩn bị các thuật toán cần thiết cho các bài toán con đã được phân rã.
D. Người lập trình (coding) cụ thể
Cuối cùng là người lập trình (coding) cụ thể. Người lập trình sẽ phải tuân thủ tất
cả các đề nghị, yêu cầu và kiểm soát bởi 3 người phía trên.
2. Các bước thiết kế phần mềm
Trong mục này sẽ mô tả chi tiết các bước cần thực hiện của công việc thiết kế
phần mềm. Các công việc này là nhiệm vụ của người đạo diễn (B) và người thiết
kế hệ thống (C) ở phần trên.
2.1. Chuẩn bị công nghệ xử lý và giải quyết bài toán
Đây là bước thiết kế đầu tiên sau khi đã có kịch bản, yêu cầu chi tiết của chương
trình. Chúng ta đều biết rằng một bài toán Tin học sẽ có cách giải, nhiều cách tiếp
cận với các công nghệ khác nhau. Người thiết kế phần mềm phải quyết định điều
này.
Thông thường ở bước này, cần đưa ra các quyết định sau cho 1 chương trình, phần
mềm trên Scratch.
- Với từng nhân vật, nhóm nhân vật, có dùng Clone hay không? Nếu dùng Clone
thì sẽ triển khai như thế nào?
- Thiết kế bộ dữ liệu chính của chương trình. Thường bước này là việc thiết kế các
mảng dữ liệu chính sẽ dùng trong chương trình.
- Chuẩn bị và thiết kế các thuật toán chính sẽ dùng trong phần mềm.
2.2. Thiết kế nhân vật, nền sân khấu
Đây là bước vẽ, thiết kế chi tiết hình ảnh nhân vật, trang phục nhân vật, vẽ các
hình sân khấu, vẽ các nút lệnh chính của chương trình.
2.3. Thiết lập các biến nhớ hệ thống và dữ liệu quan trọng
Đây là bước rất quan trọng: thiết kế các biến nhớ hệ thống và các bộ dữ liệu quan
trọng của chương trình. Tại bước này nếu thiết kế không tốt sẽ ảnh hưởng đến
toàn bộ quá trình viết chương trình về sau. Người thiết kế chương trình tốt là
người cần có quan sát tổng thể, có tầm nhìn xa để nhìn thấy cần thiết kế các biến
dữ liệu một cách hợp lý nhất.
Nguyên tắc chung của việc thiết kế dữ liệu hệ thống là vừa đủ, tiết kiệm.
2.4. Sơ đồ thiết kế hệ thống
Sơ đồ thiết kế hệ thống là Sơ đồ mô tả quan hệ giữa các nhân vật chính và trình tự
các hoạt động chính của phần mềm.
Thiết kế Sơ đồ thiết kế hệ thống là một trong những bước quan trọng nhất của quá
trình thiết kế chương trình và phần mềm.
2.5. Coding - Lập trình chi tiết
Cuối cùng, tất nhiên, là công việc lập trình cụ thể. Trong quá trình lập trình có thể
quay lại bất cứ bước nào ở phía trên.
Một trong những công việc rất quan trọng trong quá trình lập trình là kiểm thử,
tìm lỗi và sửa lỗi.
3. Sơ đồ thiết kế phần mềm
Sơ đồ thiết kế phần mềm là một trong những tài liệu quan trọng nhất của quá trình
thiết kế phần mềm trong Scratch. Không có 1 định nghĩa chính xác của Sơ đồ thiết
kế này nhưng có thể xác định các yếu tố sau cần có trong Sơ đồ này.
- Trong Sơ đồ này phải hiển thị tất cả các nhân vật (và sân khấu nếu có tham gia
vào chương trình).
- Mô tả chi tiết quan hệ giữa các nhân vật và nền sân khấu thông qua thông điệp
và biến nhớ hệ thống.
- Mô tả các hoạt động chính của nhân vật, nền sân khấu liên quan đến các sự kiện
thông điệp.
- Các thông tin quan trọng khác nếu có.
Nhìn vào sơ đồ này, người lập trình sẽ hiểu rõ cần phải tiến hành các bước lập
trình cụ thể như thế nào.
Dưới đây là hình ảnh 2 Sơ đồ thiết kế tương ứng với 2 ví dụ thiết kế phần mềm
của bài học này.
Tìm hiểu con vật Math Board
4. Ví dụ 1: Tìm hiểu các con vật
Chúng ta bắt đầu từ một bài toán, chương trình đơn giản: Tìm hiểu các con vật.
Kịch bản của chương trình bắt nguồn từ 1 bộ dữ liệu gốc trong bảng sau:
Hình ảnh Tên con vật Mô tả
mèo Loài vật nuôi trong nhà rất phổ biến trong mọi gia
đình.
khủng long Loài vật khổng lồ nhất trên trái đất, đã tuyệt chủng
từ cách đây hàng triệu năm.
chó Loài vật nuôi có tác dụng giữ nhà rất phổ biến.
voi Con vật 4 chân lớn nhất hiện nay. Voi sống nhiều
ở châu Phi và châu Á.
ngựa Loài vật thường dùng để kéo xe, chở đồ, rất phổ
biến.
sư tử Loài vật được mệnh danh là chúa rừng xanh.
khỉ Loài vật gần với người nhất về bề ngoài, hay leo
trèo trên cây.
cáo Loài vật giống chó nhưng sống trong rừng, chuyên
ăn thịt các động vật khác.
cánh cụt Loài chim sống phổ biến ở châu Nam Cực, có
cánh ngắn.
cá mập Loài cá có răng sống dưới biển, chuyên ăn thịt các

loại cá khác.
Ý tưởng chính của bài toán là cần sinh ngẫu nhiên các câu hỏi trắc nghiệm từ bộ
dữ liệu trên, đối tượng là các bạn học sinh nhỏ tuổi. Câu hỏi kiểm tra có thể là một
trong các dạng sau:
- Quan sát hình ảnh đoán tên con vật.
- Đọc mô tả đoán tên con vật.
- Ghép nối hình ảnh và tên con vật.
Kịch bản cụ thể của phần mềm được thiết kế trong ví dụ này được thiết kế theo
mô hình câu hỏi trắc nghiệm thứ nhất ở trên.
Mô tả kịch bản, yêu cầu chương trình.
- Cần 1 nhân vật đóng vai Giáo viên sẽ liên tục đưa ra các câu hỏi "Đây là con
gì?". Chính giữa màn hình sẽ xuất hiện hình ảnh con vật cần xác định tên.
- Bên dưới sẽ hiện 4 đáp án trong đó có 1 đáp án đúng.
- Người dùng cần làm bài bằng cách nháy chuột lên một trong các nút có chữ A,
B, C, D ở phía dưới mỗi đáp án.
- Nếu làm đúng, Giáo viên sẽ thông báo "Đúng rồi" (có thể có âm thanh kèm theo)
và sau đó Giáo viên hiển thị thông tin mô tả con vật này để người chơi biết thêm
thông tin. Sau khi dừng 2 giây, Giáo viên sẽ hỏi câu tiếp theo.
- Nếu làm sai, Giáo viên thông báo "Sai rồi" (có thể có âm thanh kèm theo) và sau
2 giây sẽ tiếp tục hỏi câu hỏi mới.
Tất cả nội dung các câu hỏi đều phải là ngẫu nhiên để người chơi không thể học
thuộc lòng các đáp án.
Hình ảnh mô tả của phần mềm có thể hình dung như sau.
Tim hieu con

vat.sb2
Giáo viên, người hướng dẫn
chương trình.
Hình ảnh con vật chính của

câu hỏi trắc nghiệm.
Các phương án cần chọn.
Nút lựa chọn đáp án.
(1) Chuẩn bị công nghệ xử lý bài toán

Điểm mấu chốt công nghệ của chương trình là ở chỗ cần thiết kế 1 nhân vật (có
tên Animal) với các trang phục là hình ảnh các con vật khác nhau. Như vậy đáng
lẽ cần thiết kế mỗi con vật là 1 nhân vật thì chúng ta sẽ chỉ cần 1 nhân vật là đủ.
Hệ thống trang
phục của nhân
vật này tương
thích với 2 bảng
dữ liệu chính:
Animal và
Animal_list.
Hệ thống sân khấu và nhân vật

tham gia hoạt động trong bài toán
này: nhân vật chính, thầy giáo, 4
nút phương án và sân khấu
(2) Thiết kế nhân vật, nền sân khấu
Danh sách nhân vật được thiết kế trong chương trình.
Nhân vật Ý nghĩa Ghi chú thêm
Nhân vật này là trung tâm và Chú ý tên của trang phục
tham gia như một nguồn dữ liệu (costume name) cần phải
hình ảnh chính. Mỗi hình ảnh trùng với tên con vật
con vật sẽ là 1 trang phục của trong dãy (list) Animals.
nhân vật này.
Nhân vật Giáo viên chính, đóng
vai trò MC của chương trình.
Các nút lệnh, mỗi nút lệnh là 1

nhân vật.
(3) Thiết kế biến nhớ hệ thống và các dữ liệu chung

Danh sách các biến nhớ hệ thống của chương trình.
Kiểu Tên biến nhớ Ý nghĩa Ghi chú
Biến Aname, Lưu 4 thông tin đáp án của câu Giá trị được lấy từ bảng
đơn Bname, hỏi trắc nghiệm. Animals.
Cname, Dname
PA_correct Lưu chỉ số của đáp án đúng Giá trị nhận được từ 1 đến
trong số 4 đáp án được xếp có 4.
thứ tự A, B, C, D của các biến
nhớ trên.
choice Biến nhớ ghi lại đáp án do người Nhận giá trị từ 1 đến 4. Vậy
dùng lựa chọn khi làm bài. người dùng làm bài đúng
khi và chỉ khi choice =
PA_correct.
List Animals, Bộ dữ liệu gốc của chương trình. Độ dài của 2 dãy này bằng
Animal_list nhau và bằng số trang phục
Animals: dãy tên các con vật.
Dãy tên này trùng với dãy tên của nhân vật Animal của
chương trình.
các trang phục của nhân vật
chính Animal của chương trình. Hoàn toàn có thể mở rộng
dữ liệu bằng cách bổ sung
Animal_list: dãy thông tin mô
tả các con vật. Dãy này tương vào 2 bảng này và bổ sung
trang phục tương ứng cho
ứng với Animals.
Animal.
PA_list Dãy 4 phẩn tử chỉ ra 4 chỉ số PA_list được sinh ngẫu
được lấy ngẫu nhiên từ mảng nhiên bằng cách lấy ra 4 chỉ
Animals dùng làm dữ liệu cho số ngẫu nhiên trong khoảng
câu hỏi trắc nghiệm. 1->length(Animalss).
(4) Sơ đồ thiết kế hệ thống
Sơ đồ thiết kế và hoạt động của chương trình thể hiện trong mô hình sau.
Chọn ngẫu nhiên 4 phương án, gán

vào các biến nhớ Aname, Bname,
Cname, Dname; sinh ngẫu nhiên 1
Next phương án đúng, hiển thị trang phục
theo phương án đúng.
Hiển thị câu
hỏi: Đây là Khi người dùng click chuột, nạp
con gì? lựa chọn vào biến nhớ choice và
Kiểm tra
choice và gửi thông điệp Done.
đáp án đúng,
hiện thông Done
báo Đúng
rồi, hoặc Sai
rồi. Chờ 2
giây và gửi Next
thông điệp Click chuột
Next.
Có thể mô tả bằng lời Sơ đồ thiết kế hoạt động của chương trình như sau:
- Thông điệp Next có ý nghĩa bắt đầu 1 phiên làm việc mới của chương trình.
Công việc cụ thể sau lệnh Next là:
+ Sinh ngẫu nhiên bộ dữ liệu câu hỏi trắc nghiệm bao gồm các biễn nhớ
PA_list, PA_correct, Aname, Bname, Cname, Dname.
+ MC ra câu hỏi: đây là con gì.
+ Nhân vật Animal chuyển trang phục sang số thứ tự con vật tương ứng.
- Sau khi hiển thị bài toán, chương trình chờ người chơi nháy chọn đáp án bằng
cách nháy lên 1 trong các nút A, B, C, D. Khi người dùng nháy, hệ thống cập nhật
biến choice và ra thông điệp Done.
- Thông điệp Done có ý nghĩa đã chọn xong đáp án. Giáo viên nhận thông điệp
này sẽ xử lý đáp án, thông báo đúng, sau.
- Sau đó Giáo viên gửi thông điệp Next để bắt đầu lại câu hỏi mới.
(5) Coding chương trình
1. Việc lập trình bắt đầu từ sân khấu, thực hiện 1 lệnh duy nhất là gửi thông điệp
Next.
2. Xứ lý thông điệp Next.
Các công việc quan trọng là thiết lập bộ dữ liệu đầu vào cho câu hỏi trắc nghiệm.
Cụ thể như sau.
- Thiết lập mảng 4 dữ liệu PA_list. Bảng này sẽ lấy ngẫu nhiên 4 giá trị từ dãy các
số tự nhiên 1, 2, 3, …. (độ dài = length(Animals). Thuật toán sử dụng là sinh ngẫu
nhiên 1 tập con của 1 dãy số cho trước. Trong chương trình sau, dãy Temp_list
được tạo ra để lưu trữ dãy các số 1, 2, 3, …. (độ dài = length(Animals), từ đó sẽ
lấy ra 4 phần tử ngẫu nhiên đưa vào PA_list.
Chương trình sinh bảng PA_list như sau.
Init: xóa các bản ghi của 2

dãy PA_list, Temp_list.
Thiết lập và điền số 1, 2,

3, … vào Temp_list.
Lần lượt lấy ra 1 phần tử

ngẫu nhiên của Temp_list,
đưa vào PA_list, sau đó xóa
đi khỏi dãy Temp_list.
- Thiết lập dữ liệu cho các biến PA_correct, Aname, Bname, Cname, Dname.
Chương trình sinh bộ đáp án bao gồm PA_correct, Aname, Bname, Cname,
Dname.
PA_correct lấy ngẫu nhiên
từ 1 đến 4.
Các biến Aname, Bname,
Cname, Dname lần lượt lấy
tên của các con vật có chỉ số
lấy từ PA_list.
- Sau khi sinh xong các bộ dữ liệu trên thì việc tiếp theo là hiển thị con vật giữa
màn hình cho đúng câu hỏi.
3. Lập trình cho các nút phương án A, B, C, D.

Khi người dùng nháy lên 1 trong các nút này, biến choice được gán và thông điệp
Done được gửi đi.
(A) (B) (C) (D)
4. Xử lý thông điệp Done.
Cuối cùng là xử lý thông điệp Done. Giáo viên là người xử lý thông điệp này.
- Nếu đúng, GV thông báo đúng rồi, sau đó hiển thị thông tin mô tả của con vật
tương ứng.
- Nếu sai, GV thông báo sai rồi.
Đợi 1 thời gian ngắn, GV sẽ gửi thông điệp Next để bắt đầu một câu hỏi mới.
5. Ví dụ 2: Math Board
Ý tưởng của chương trình này là xây dựng một mô hình mô phỏng các bài học
môn Toán đơn giản dành cho học sinh nhỏ tuổi. Trong ví dụ cụ thể, các bài toán
chỉ là phép tính cộng, trừ đơn giản trong phạm vi 3-4 chữ số.
Kịch bản tưởng tượng của chương trình như hình sau.
Chương trình
Math Board
Math Board.sb2
Yêu cầu các bước thực hiện của chương trình như sau:
Chương trình sẽ tự động sinh các phép toán cộng, trừ số đơn giản. Phép tính được
hiện trên màn hình với các số thể hiện bằng đồ họa.
Người dùng nhập trực tiếp từ bàn phím đáp án. Khi người dùng nhập xong, đáp án
do người dùng nhập sẽ hiện trên phép tính ở màn hình. Khi nó nút Check xuất
hiện. Nháy nút này để kiểm tra đúng hay sai.
Nếu sai, chương trình sẽ hiện thông báo Sai rồi và hiện đáp án đúng bên dưới.
Đồng thời xuất hiện nút Next. Nháy lên nút này để bắt đầu 1 phép tính mới.
Nếu đúng, chương trình sẽ xuất hiện thông báo Đúng rồi. Đồng thời xuất hiện nút
Next. Nháy lên nút này để bắt đầu 1 phép tính mới.
(1) Chuẩn bị công nghệ xử lý bài toán
Đặc điểm công nghệ chính của chương trình này là yêu cầu hiển thị số, phép toán
bằng hình ảnh lớn để HS dễ quan sát. Phần mếm sẽ cần sử dụng hai nhân vật:
Number để hiển thị số và Operation để hiện thị phép toán.
(2) Thiết kế nhân vật, nền sân khấu
Bảng các nhân vật của chương trình như sau, chú ý 2 nhân vật đầu tiên.
Tên nhân Nhân vật Mô tả ý nghĩa
vật, nút
lệnh
Number Nhân vật này có nhiệm vụ hiển thị số trên màn hình
theo hình ảnh lớn để học sinh dễ quan sát. Đây là
công nghệ chính, quan trọng nhất của chương trình
này. Nhân vật sẽ có 10 trang phục, có tên lần lượt
là 0, 1, 2, …, 9. Để hiển thị hình ảnh trên màn hình
sẽ dùng lệnh Stamp.
Operation Nhân vật này sẽ có 3 trang phục tương ứng với dấu
cộng (+), dấu trừ (-) và dấu bằng (=).Để hiển thị
hình ảnh trên màn hình sẽ dùng lệnh Stamp.
Chú ý: hoàn toàn có thể mở rộng cho các phép tính
nhân, chia trong tương lai.
Check Nút dùng để thực hiện lệnh Check - kiểm tra đúng,
sai.
Next Nút thực hiện thông điệp Next, chuyển sang bài
toán tiếp theo.
Đúng - Nút thể hiện thông báo Đúng / Sai trên màn hình.
Sai
(3) Thiết kế biến nhớ hệ thống và các dữ liệu chung

Biến nhớ Ý nghĩa Ghi chú thêm
N1, N2 Giá trị 2 số tự nhiên là đầu Các số đầu vào của bài
vào của phép tính cần thực toán sẽ được sinh ngẫu
hiện của phần mềm. nhiên.
Biến nhớ Ý nghĩa Ghi chú thêm
op Giá trị mô tả phép toán. Tham số này có thể mở
= 1, phép cộng. rộng lên cho cả các phép
tính nhân, chia.
= 2, phép trừ.
Solution Đáp số của phép tính gốc.
UserNumber Đáp số do người dùng nhập.
Checked Kết quả làm bài của học sinh. Giá trị này được tính tự
= 1, làm đúng. động như sau:
= 0, làm sai. If UserNumber =

Solution then Checked =
1 else Checked = 0.
(4) Sơ đồ thiết kế hệ thống
Hiển thị đáp

án đúng bên
Hiển thị phép dưới.
toán, các số N1,
Next N2 trên màn
hình.
Sinh ngẫu nhiên op, sinh

ngẫu nhiên N1, N 2, tính Start WaitCheck
toán Solution. Hiển thị đáp án
của người dùng Hiển thị nút
nhập. Check
Yêu cầu người dùng nhập
đáp số của phép toán, kết InputDone
quả đưa vào UserNumber.
Ẩn nút
CheckDone
ShowCorrect
Kiểm tra Đúng/ Sai và Nếu sai, gửi thông

hiển thị trang phục điệp ShowCorrect.
tương ứng.
Có thể mô tả Sơ đồ thiết kế trên theo bảng sự kiện sau.
Stt Sự kiện - Người thực Công việc cần thực hiện
Thông điệp hiện
1 Next Sân khấu, nút - Sinh ngẫu nhiên bộ dữ liệu phép toán gốc:
Next op, N1, N2.
- Gửi thông điệp Start.
2 Start Sân khấu - Hiện thị hình ảnh phép toán và dấu =.
- Hiển thị các số N1, N2 bằng chữ số lớn trên
màn hình.
- Bắt đầu cho người dùng nhập đáp số của
phép tính, lưu vào biến nhớ UserNumber.
- Khi người dùng nhập xong thì gửi thông
điệp InputDone.
3 InputDone Sân khấu - Hiển thị số người dùng đã nhập lên phép
tính trên màn hình.
- Gửi thông điệp WaitCheck.
4 WaitCheck Numbers - Xuất hiện nút Check.
- Khi người dùng nháy nút Check thì gửi
thông điệp CheckDone.
5 CheckDone Nút Check Kiểm tra kết quả đúng hay sai.
- Nếu Sai, hiển thị nút Sai và gửi thông điệp
ShowCorrect.
- Nếu Đúng, hiển thị nút Đúng.
- Hiển thị nút Next. Nếu nháy nút Next sẽ gửi
thông điệp Next.
6 ShowCorrect Nút Đúng-Sai Hiển thị đáp án đúng bên dưới số người dùng
đã nhập.
(5) Coding - lập trình cụ thể

1. Công cụ hiển thị số bằng hình ảnh to trên màn hình.
Thiết lập thủ tục ShowNumber (n) tại vị trí X, Y.
Thủ tục được thiết lập cho

nhân vật Number.
Chuyển đến vị trí đầu tiên

có tọa độ X, Y
Lần lượt lấy các chữ số của n từ

trái sang phải; chuyển trang phục
đến tên chữ số hiện thời; thực hiện
lệnh Stamp; sau đó chuyển sang
phải 30 bước (là độ rộng của chữ
số này).
2. Hoạt động của sân khấu khi bắt đầu khởi động chương trình: thiết lập thông
điệp Next.
3. Xử lý thông điệp Next.

Khi nhận được thông điệp Next, sân khấu sẽ khởi động việc sinh bộ dữ liệu tính
toán gốc bao gồm N1, N2, op và Solution. Trong ví dụ này chúng ta sẽ thiết lập
mô hình bài toán đơn giản là phép + hoặc -, các số N1, N2 được sinh ngẫu nhiên
trong khoảng từ 10 đến 999. Việc tổng quát hóa bài toán sẽ nằm trong các bài tập.
Biến op sẽ nhận ngẫu nhiên 1 hoặc 2, tương ứng vớp phép tính + và -.
Biến op nhận giá trị 1 hoặc 2.
Sinh ngẫu nhiên N1, N2 sao

cho N1 + N2 < 1000.
Sinh ngẫu nhiên N1 trong khoảng

[200, 900], N2 từ [50, N1-50] do đó
N1-N2 sẽ luôn > 50.
Chú ý: Dữ liệu N1, N2 được sinh trong ví dụ trên là các bài tập tính +, - bất kỳ (có
nhớ) trong phạm vi 3 chữ số).
4. Xử lý thông điệp Start.
Sau khi bộ dữ liệu gốc ban đầu đã được thiết lập (các biến N1, N2, op, Solution),
thông điệp Start được gửi đi thông báo bắt đầu quá trình làm bài của người dùng.
Các xử lý tiếp theo sau thông điệp Start bao gồm:
- Các chữ số và phép tính được thể hiện trên màn hình.
Đoạn chương trình của nhân vật

Operation thể hiện phép tính (+ hoặc -)
và dấu = sau phép tính.
Đoạn chương trình thể hiện 2 số N1, N2 trên màn hình:
- Đồng thời, sân khấu gửi lời yêu cầu nhập đáp số phép tính. Dữ liệu người dùng
nhập sẽ được đưa vào biến nhớ UserNumber, sau đó gửi thông điệp InputDone.
5. Xử lý thông điệp InputDone.

Sau khi người dùng nhập xong, thì đáp án của người dùng sẽ hiển thị trên màn
hình bên phải dấu =. Sau đó thông điệp WaitCheck được gửi đi để chờ người
dùng kiểm tra đúng, ai.
6. Xử lý thông điệp WaitCheck.

Nút Check sẽ hiển thị sau thông điệp WaitCheck và chờ người dùng nháy chuột
sẽ kiểm tra. Cửa sổ lệnh của nút Check như sau.
Nút chỉ hiển thị khi nhận thông điệp

WaitCheck.
Khi người dùng nháy chuột lên nút

thì xử lý, kiểm tra đúng hay sai và
gán vào biến Checked.
Checked = 1, đúng.
Checked = 0, sai.
Sau đó ẩn đi và gửi thông điệp
CheckDone để kích hoạt nút thông
báo Đúng/Sai.
7. Xử lý thông điệp CheckDone.

Nút lệnh Đúng-Sai sẽ xử lý thông điệp CheckDone, chuyển trang phục để thông
báo đúng, sai. Nếu người dùng làm sai thì thông điệp ShowCorrect sẽ được gửi đi
để nhân vật Number hiển thị đáp án đúng phía dưới đáp án sai.
Câu hỏi - Bài tập - Mở rộng
1. Hoàn thiện 2 chương trình Tìm hiểu con vật và Math Board đã thiết kế trong
bài học.
2. Mở rộng chương trình Tìm hiểu con vật theo hướng sau: bổ sung thêm 1 dạng
câu hỏi nữa.
Giáo viên khi hỏi sẽ đưa ra nội dung câu hỏi = mô tả con vật + "Đó là con gì?", ví
dụ 1 câu hỏi như sau:
Loài vật nuôi trong nhà rất phổ biến trong mọi
gia đình. Đó là con gì?
Người dùng vẫn trả lời bằng cách nháy lên một trong các nút A, B, C, D. Nếu
người dùng làm đúng, hình ảnh con vật sẽ hiện trên màn hình.
Phần mềm sẽ tự động sinh ngẫu nhiên một trong hai loại câu hỏi như trên.
3. Mở rộng phần mềm Math Board thành 4 phép toán +, -, x, : như sau:
- Phần mềm sẽ sinh bài toán ngẫu nhiên với các phép tính cộng, trừ, nhân, chia.
- Với các phép toán, bộ dữ liệu ban đầu được sinh ngẫu nhiên như sau:
+ Phép cộng: sinh 2 số ngẫu nhiên có 2 hoặc 3 chữ số, nhưng tổng số < 1000.
+ Phép trừ: trừ 2 số tự nhiên ngẫu nhiên có 2 hoặc 3 chữ số.
+ Phép nhân: nhân 1 số có 2, 3 chữ số với số có 1 chữ số, tích < 1000.
+ Phép chia: số bị chia (N1) có 2 hoặc 3 chữ số, số chia có 1 chữ số, phép chia
phải là chia hết.
4. Thiết kế phần mềm Con gì ăn gì? theo kịch bản sau.
Trên màn hình bên trái là các con Mèo, Khỉ, Ngựa. Bên phải là Táo, Chuối và
Cỏ. Mỗi con chỉ ăn 1 thứ mà thôi: Khỉ ăn Chuối, Mèo ăn Táo, Ngựa ăn Cỏ.
Chương trình chơi như sau:

Người dùng lần lượt phải dùng chuột kéo thả các con vật ở bên trái sang đúng vị
trí thức ăn của nó ở bên phải.
- Nếu kéo thả không đúng (chưa tới hoặc nhầm) thì con vật sẽ kêu "Ối ối" và chạy
về chỗ cũ.
- Nếu kéo thả đúng vị trí thì con vật sẽ dính vào thức ăn của mình và kêu "Ngon
quá".
- Trò chơi kết thúc khi người chơi kéo thả đúng cả 3 con Mèo, Khỉ, Ngựa.
5. Mở rộng chương trình Con gì ăn gì? theo hướng sau:
- Chỉ cần 2 nhân vật chính là Con thú và Thức ăn.
- Mỗi nhân vật này có 1 dãy các trang phục tương ứng với các con vật và thức ăn
của chúng. Giao diện chương trình tương tự bài trên nhưng các con vật và thức ăn
lấy ngẫu nhiên từ dãy các trang phục của 2 nhân vật chính trên. Quá trình thực
hiện trò chơi tương tự bài trên.
Chủ đề 2.
Clone và một số kỹ thuật xử lý Clone
Mục tiêu:
- Giới thiệu nhanh khái niệm và một số kỹ thuật lập trình với Clone trong Scratch.
- Ứng dụng kỹ thuật Clone trong việc thiết kế phần mềm, trò chơi giáo dục.
Nội dung chính
Clone - phân thân là 1 công nghệ rất đặc biệt của Scratch và có rất nhiều ứng dụng
trong các bài toán thiết kế phần mềm, trò chơi trong Scratch.
1. Khái niệm phân thân - clone trong Scratch
Tất cả các nhân vật trong Scratch đều có thể "phân thân", tức là tạo ra các nhân
vật khác là song sinh với chính bản thân mình. Các nhân vật được phân thân đó
gọi là Clone.
Chúng ta cùng xem 1 chương trình ngắn để bước đầu làm quen và phân biệt được
2 khái niệm: nhân vật chính (gốc) và phân thân (clone) của nhân vật này.
Nhân vật chính, gốc
Khái niệm Clone
(phân thân). Nhân vật được phân thân, là song
sinh của nhân vật gốc. Nhân vật
này được gọi là clone của nhân
vật chính.
Chúng ta cùng xem đoạn chương trình của nhân vật chính con mèo.
Đoạn chương trình điều

khiển clone.
Đoạn chương trình khởi

tạo clone.
Bảng sau mô tả nhanh sự giống nhau và khác nhau giữa nhân vật bình thường và
phân thân của nhân vật (clone).
Nhân vật bình thường Clone (phân thân)
Có là nhân vật Có Có
không?
Cửa sổ lệnh Có Không. Dùng chung cửa sổ lệnh
riêng? với nhân vật gốc.
Chịu sự điều Có Có
khiển của các
lệnh Scratch
Nhân vật gốc và Clone
Mèo con Clone
Clone được khởi tạo từ 1 nhân vật

gốc. Clone là 1 phân thân của nhân
vật gốc và có mọi thuộc tính của nhân
vật gốc.
Khi bắt đầu khởi tạo, clone kế thừa
Nhân vật gốc là khái niệm Nhân vật toàn bộ tính chất, thuộc tính của nhân
(Sprite) mà chúng ta vẫn biết từ trước vật gốc. Tuy nhiên sau khi ra đời, có
đến nay trong môi trường Scratch. thể điều khiển clone bằng tất cả các
Mỗi nhân vật khi được tạo ra sẽ có lệnh của Scratch như 1 nhân vật bình
các tính chất, thuộc tính riêng như thường. Điểm khác biệt chỉ ở chỗ:
hình ảnh, tọa độ x, y, hướng quay, - Các chương trình điều khiển Clone
trang phục, âm thanh, kích thước, các bắt buộc nằm trong lệnh sự kiện
biến nhớ riêng. Mỗi nhân vật có 1 cửa when I start as a clone.
sổ lệnh riêng của mình.
- Bản thân clone có thể xóa chính
Mỗi nhân vật có thể tạo ra các phân mình.
thân (clone) của riêng mình.
Bảng sau liệt kê các thông tin nhanh liên quan đến nhân vật gốc và clone.
Nhân vật gốc Clone
Mô tả Là nhân vật hoạt động chính Là nhân vật phân thân từ 1 nhân
nhanh trên sân khấu cho người sử vật gốc, được khởi tạo bởi lệnh
dụng khởi tạo, hoạt động create clone of. Clone sau khi
vĩnh viễn. được tạo ra sẽ có đầy đủ tính
chất như 1 nhân vật bình thường
và kế thừa mọi thuộc tính từ
nhân vật gốc của mình. Clone
không hoạt động vĩnh viễn.
Khởi tạo Nhân vật chính dùng lệnh
Clone
để
tạo Clone. Có thể tạo Clone
của mình hoặc của các nhân
vật khác.
Chú ý: Sân khấu cũng có
quyền tạo Clone cho mọi
nhân vật.
Điều khiển Clone sau khi được tạo ra sẽ
Clone chịu sự điều khiển của câu lệnh
sự kiện
. Cho phép nhiều chương trình
cùng điều khiển 1 Clone.
Nhân vật gốc Clone
Xóa Clone Clone tự xóa bản thân mình
bằng lệnh .
Thời gian Vĩnh viễn Chỉ hoạt động trong thời gian
sống chạy chương trình.
Chúng ta cùng xét 1 ví dụ sau. Ví dụ này minh họa cho quan hệ giữa nhân vật
chính và các phân thân - clone của chính mình.
Tạo 1 biến nhớ riêng có tên CloneID

của nhân vật chính. Chương trình sẽ lần
lượt tạo ra 3 clone, và trước mỗi lần tạo
sẽ gán giá trị CloneID lần lượt là 1, 2,
3. Các clone này sẽ kế thừa biến nhớ
CloneID cho riêng mình với các giá trị
lần lượt là 1, 2, 3. Khi tạo ra, các clone
sẽ di chuyển ngẫu nhiên, tự do trên màn
hình và luôn hiện giá trị CloneID của
riêng mình để phân biệt với các clone
khác.
Chương trình cụ thể trên Scratch như sau:
Chương trình chính: Chương trình cho mỗi

Clone:
Sau mỗi giây, tăng CloneID lên 1 đơn
vị và tạo 1 Clone mới của Mèo. Clone Khi được sinh ra, mỗi Clone
mới này sẽ mang giá trị biến CloneID sẽ đọc CloneID của riêng
tương ứng bằng 1, 2, 3. Giá trị này sẽ mình và sau đó chạy xung
gắn với từng Clone và không thay đổi quanh sân khấu, sau mỗi 0.1
nữa. Sau khi tạo xong 3 Clone thì nói giây thì thay đổi màu áo của
"tôi không là Clone". mình.
Clone có ý nghĩa gì trong các ứng dụng thực tế của Scratch, chúng ta cùng tìm
hiểu các hoạt động tiếp theo.
2. Rừng hoa
Chương trình đơn giản sau cho em hiểu thêm hoạt động của clone.
Rung hoa.sb2 Chương trình đơn giản này chỉ có đúng 1
nhân vật là bông hoa, nhưng với nhiều
hình ảnh đẹp mắt khác nhau.
Mục đích của chương trình là tạo ra 1 rừng
hoa với nhiều màu sắc sặc sỡ.
Để làm như vậy, em cần sưu tầm nhiều
hình ảnh hoa với màu sắc đa dạng khác
nhau và đưa vào thành các trang phục của
nhân vật này.
Chương trình được xây dựng đơn giản như sau:
- Nhân vật chính bông hoa cần tạo ra nhiều hình ảnh khác nhau nhưng có kích
thước gần giống nhau làm trang phục. Ví dụ:
Thiết lập các hình bông hoa có

kích thước gần giống nhau và
màu sắc đa dạng khác nhau.
Dãy các trang phục (costume)
được đánh số từ 1
- Trong mạch chương trình chính, em cho bông hoa lần lượt tạo ra 50 clone của
chính mình.
Lệnh này sẽ tạo ra 50 bản clone của nhân vật

chính. Các phân thân clone này khi tạo ra có
trang phục và khuôn dạng giống với nhân vật
chính và ở tại đúng vị trí của nhân vật chính
(nhưng nằm phía dưới).
- Mỗi phân thân, clone sẽ di chuyển nhanh tới 1 vị trí ngẫu nhiên trên màn hình
với thể hiện trang phục ngẫu nhiên.
3. Hai chú mèo sinh đôi
Giả sử chúng ta có 1 chương trình mà Mèo mẹ sinh ra 1 cặp mèo sinh đôi. Hai chú
mèo này, một có tên "Mèo vàng", một có tên "Mèo đen". Chương trình sử dụng
công nghệ Clone để từ 1 nhân vật ban đầu tạo ra 2 Clone tương ứng với cặp mèo
sinh đôi như hình dưới đây.
Hai chu meo

sinh doi.sb2 Yêu cầu của chương trình: khi
nháy chuột lên nhân vật thì
nhân vật sẽ nói và kêu lên, ví
dụ: Tôi là Mèo vàng / Mèo đen.
Thiết lập thêm 2 trang phục

cho nhân vật chính của chương
trình với tên Mèo vàng, Mèo
đen.
Giả sử chúng ta cần thiết lập 2 clone của nhân vật Mèo mẹ này, nhân vật 1 (ID=1)
có tên là Mèo vàng, nhân vật 2 (ID=2) có tên là Mèo đen. Để thực hiện được
những việc trên chúng ta sẽ thiết lập 2 biến riêng (local) của nhân vật chính là ID
và Name. ID dùng để chỉ số thứ tự các clone, biến Name để lưu trữ tên của các
Clone được khởi tạo. Khi bắt đầu chương trình, các biến nhớ riêng được gán giá
trị ban đầu là ID = 0, Name = (empty). Đoạn chương trình sau sẽ tạo Clone đầu
tiên.
Đoạn chương trình tạo Clone đầu tiên, đặt ID = 1 và

Name = Mèo vàng.
Chú ý khi Clone đầu tiên tạo ra sẽ kế thừa và có giá trị ID = 1 và Name = "Mèo
vàng".
Sau đây là các đoạn chương trình thiết lập ban đầu.
Khởi tạo và thiết lập 2
clones. Đoạn chương trình
thiết lập trạng thái ban
đầu của 2 chú mèo
sinh đôi - 2 clones.
Mỗi clone sẽ đổi trang
phục của mình và
dịch chuyển đến 1 vị
trí của riêng mình.
Đoạn chương trình chính điều khiển clone nói tên của mình như sau:
Sự kiện thực hiện khi click chuột vẫn
là lệnh when this sprite clicked
nhưng bên trong mỗi clone sẽ được
điều khiển riêng bởi câu lệnh if <ID
= ..> then.
Đây là lệnh điều khiển cho clone đầu
tiên.
4. Thuộc tính của nhân vật

Thuộc tính của nhân vật là gì? Chúng ta đã được làm quen với rất nhiều thông tin
thuộc tính (hoặc các thông tin có liên quan khác) nhưng chưa bao giờ trả lời một
cách chính xác câu hỏi này.
Thuộc tính nhân vật thông qua hộp hội thoại thuộc tính.
Các thuộc tính bao gồm: Tên nhân vât; tọa độ hiện thời (x, y); hướng; kiểu xoay
(rotation style); có thể dịch chuyển bằng chuột trong khi chạy chương trình;
hiện/ẩn trên màn hình.
Trong Scratch, các thuộc tính quan trọng nhất của nhân vật được lưu cùng nhân
vật thông qua các biến nhớ hệ thống và có thể truy cập bởi các nhân vật khác
(hoặc sân khấu) thông qua 1 hàm thuộc tính nằm trong nhóm Cảm biến.
Danh sách thuộc tính của nhân vật có thể truy cập từ hàm số trên như sau:
Stt Tên thuộc tính nhân vật Mô tả ý nghĩa
1 x position Tọa độ X hiện thời của nhân vật.
Stt Tên thuộc tính nhân vật Mô tả ý nghĩa
2 y position Tọa độ Y hiện thời của nhân vật.
3 direction Hướng hiện thời của nhân vật.
4 costume # Số thứ tự trang phục của nhân vật (tính từ
1).
5 costume name Tên trang phục hiện thời của nhân vật.
6 size Tỉ lệ kích thước hiện thời của nhân vật (tính
theo %, 100% = kích thước thật).
7 volume Tỉ lệ âm lượng âm thanh hiện thời của nhân
vật (tính theo %, 100% = âm thanh thực).
Tương tự đối với sân khẩu, các thuộc tính của sân khấu cũng có thể lấy các thuộc
tính từ hàm số.
Danh sách thuộc tính của sân khấu được ghi trong bảng sau:
Stt Tên thuộc tính sân khấu Mô tả ý nghĩa
1 backrop # Số thứ tự nền sâu khấu hiện thời (tính từ 1
theo DS nền sân khấu đang có).
2 backdrop name Tên nền sân khấu hiện thời.
3 volume Tỉ lệ âm lượng âm thanh hiện thời của sân
khấu (tính theo %, 100% = âm thanh thực).
Sau đây là một số ví dụ ngắn sử dụng tính chất nêu trên.

1) Mèo đuổi chuột
Mèo lười nên cứ sau mỗi 2 giây mới

Meo duoi quan sát, định hướng chuột và chạy
chuot.sb2 thẳng một mạch đển vị trí của chuột
để bắt. Chuột nhanh nhẹn hơn, sau
mỗi 0.2 giây, chuột đều cảnh giác
quan sát vị trí của Mèo và thay đổi
hướng để chạy ra xa nhất có thể. Tất
nhiên khi gặp tường thì bị bật lại.
Các đoạn chương trình sau mô tả hoạt động đuối bắt của Mèo và chạy của Chuột.
Mèo và Chuột luôn phải xác định tọa độ và hướng đi của đối phương, do đó phải
sử dụng hàm lấy thuộc tính.
Mèo Chuột
2) Bắn máy bay bằng đạn thông minh
Ban may
bay.sb2 Chương trình mô phỏng bắn
máy bay, tuy nhiên yêu cầu của
chương trình là khi viên đạn
được bắn ra khỏi nòng sẽ tự tìm
hướng đến máy bay (viên đạn
thông minh).
Chúng ta sẽ cùng thiết kế trò chơi đơn giản này như sau:
Nhân vật của chương trình.
Máy bay có 2 Đạn cũng có

hình ảnh lúc 2 trang phục
bình thường lúc bình
và khi trúng thường và
đạn bị nổ. khi đạn nổ.
Thiết kế, điều khiển chương trình như sau:

- Súng canon: Người dùng sẽ điều khiển nòng súng bằng các phím Phải, Trái để
xoay nòng súng hướng lên máy bay. Nhấn phím Space để bắn ra 1 viên đạn theo
hướng nòng súng.
- Máy bay: Máy bay sẽ luôn bay ngang trên bầu trời từ trái sang phải. Khi gặp bờ
phải, máy bay sẽ xuất hiện lại từ bên trái.Nếu gặp đạn thì máy bay sẽ nổ tung,
biến thành ngọn lửa và rơi xuống đất. Khi chạm đất chương trình kết thúc.
- Đạn: Khi bắn, viên đạ sẽ bay ra khỏi nòng theo hướng nòng súng, Nhưng ngay
sau đó đạn sẽ điều chỉnh hướng bay, luôn hướng về máy bay. Khi trúng máy bay,
viên đạn cũng sẽ nổ tung và rơi xuống đất cùng máy bay.
Lưu ý: với loại đạn thông minh này, mỗi viên đạn sẽ hạ một máy bay.
- Đoạn chương trình sau điều khiển súng Canon.
Thiết lập vị trí ban đầu và hướng nòng

súng.
Điều khiển nòng súng bằng các phím

Left, Right.
- Với nhân vật Đạn, chúng ta có 2 đoạn chương trình, một điều khiển việc tạo
clone để viên đạn hình thành và một điều khiển viên đạn bay hướng đến máy bay.
Đoạn chương trình điều khiển tạo clone cho viên đạn.
Khi nhấn phím Space, đạn sẽ truy cập

thông tin tọa độ của súng, di chuyển
đến vị trí đó và tạo Clone sẵn sàng cho
1 viên đạn bay ra khỏi nòng súng. Chú
ý nhân vật gốc này đang ở chế độ
không hiển thị.
Đoạn chương trình điều khiển hướng bay của viên đạn.
Clone - viên đạn sẽ hiện và bay theo

hướng nòng súng 1 đoạn (40 bước).
Sau đó viên đạn sẽ luôn bay hướng về

máy bay, nếu gặp cạnh sân khấu thì tự
biến mất. (khả năng gặp cạnh ít xảy ra.
Nếu gặp máy bay, viên đạn sẽ nổ tung

bằng cách thay đổi hình ảnh sang viên
đạn nổ.
- Đoạn chương trình điều khiển máy bay.
Thiết lập thông số ban đầu của
máy bay.
Máy bay sẽ bay ngang từ trái sang

phải, nếu gặp cạnh phải thì sẽ xuất
hiện lại từ bên trái.
Nếu gặp đạn, máy bay sẽ nổ tung

(thay đổi hình ảnh), sau đó sẽ rơi
thẳng xuống bằng lệnh glide, khi
rơi xuống đất thì phát thông điệp
Stop để kết thúc.
5. Biến nhớ riêng là thuộc tính của nhân vật

Một tính chất rất quan trọng của Scratch cần nhớ là toàn bộ các biến nhớ riêng
(local) của nhân vật sẽ được coi là thuộc tính nhân vật và có thể truy xuất tương tự
như theo cách trên.
Trong hình sau chúng ta thấy danh sách các thuộc tính trong hàm truy xuất đã
được mở rộng cho các biến nhớ riêng của nhân vật.
Các biến nhớ riêng của nhân vật sẽ được coi

là thuộc tính và có thể được truy cập bằng
hàm lấy thuộc tính từ nhóm Cảm biến.
Xét 1 ví dụ mô phỏng bài toán điểm danh học sinh trong lớp.
Diem danh
lop.sb2 Thầy giáo lần lượt đọc tên từng bạn
trong lớp. Khi đọc đến tên ai thì học
sinh đó đáp "Có em", lần lượt cho
đến khi kết thúc. Yêu cầu của chương
trình là tên phải được khai báo là
thuộc tính riêng của từng học sinh.
Chúng ta sẽ thiết lập chương trình với 6 nhân vật là Giáo viên và 5 học sinh như
hình trên. 5 nhân vật học sinh có tên là HS1, HS2, HS3, HS4, HS5. Với mỗi nhân
vật học sinh này, cần tạo 1 biến nhớ riêng với tên Name dùng để lưu Họ tên của
từng nhân vật này.
Giáo viên sẽ lần lượt thực hiện 5 nhóm lệnh sau, mỗi nhóm lệnh có tác dụng gọi
tên 1 học sinh và đợi HS này trả lời.
GV gọi tên học sinh thông qua hàm lấy thông

số Name.
Sau đó GV gửi thông điệp thông báo cho HS
này và chờ trả lời của HS để gọi tiếp.
Còn đây là đoạn chương trình của một học sinh (ví dụ HS1), với các học sinh
khác lệnh hoàn toàn tương tự.
Lệnh gán trực tiếp họ tên HS vào biến

Name khi bắt đầu chương trình.
HS trả lời "có em" khi nghe GV

gọi tên của mình.
6. Clone kế thừa thuộc tính nhân vật

Mỗi Clone được tạo ra sẽ được coi như 1 nhân vật hoàn chính và kế thừa toàn bộ
các thuộc tính của nhân vật gốc của mình.
Khi một clone được tạo ra,

clone này sẽ tiếp nhận và
kế thừa tất cả các thuộc
tính từ nhân vật gốc. Sau
khi được tạo ra, chúng ta
có thể thay đổi các thuộc
tính này.
Nhân vật gốc. Nhân vật clone -

phân thân.
Chúng ta đã được làm quen với các bài toán sinh và xử lý hàng loạt các clone của
mình. Clone - phân thân của nhân vật có một đặc điểm là chỉ có 1 cửa sổ lệnh chia
sẻ chung với nhân vật gốc. Do đó bài toán xử lý và điều khiển riêng rẽ các clone
có lẽ là một bài toán khó. Các vấn đề cụ thể của bài toán này được ghi trong bảng
sau.
Stt Câu hỏi, vấn đề Các câu hỏi bổ sung
1 Làm cách nào để có thể thực hiện các lệnh
điều khiển riêng rẽ từng Clone sau khi
chúng được khởi tạo. Ví dụ sau khi tạo ra 2
clone của 1 con chim, làm thế nào để điều
Stt Câu hỏi, vấn đề Các câu hỏi bổ sung
khiển chúng, 1 con bay lên, 1 con bay
xuống?
2 Các lệnh truyền thông điệp có cách nào có
thể truyền thông tin đến từng phân thân
riêng rẽ?
3 Muốn thực hiện hội thoại giữa người dùng
với một Clone cụ thể thì làm cách nào?
4 Muốn truyền thông tin từ các chức năng
cảm biến, ví dụ nhấn phím, cảm biến va
chạm, màu sắc, … đến với từng Clone thì
làm cách nào?
5 Có thể hay không thực hiện hội thoại giữa
các clone với nhau? Bằng cách nào?
Chúng ta cùng xét lại ví dụ chương trình điểm danh lớp học. Chúng ta sẽ thiết kế
lại chương trình này sử dụng clone để mô tả các học sinh của lớp học.
Yêu cầu của chương trình tương tự như ví dụ bài điểm danh lớp học ở trên, nhưng
điểm khác cơ bản là bài tập này sẽ yêu cầu chỉ sử dụng 1 nhân vật HS gốc, các
học sinh khác trong lớp phải được sinh ra bằng Clone.
Diem danh
lop 2.sb2 Giao diện chương trình hoàn
toàn tương tự: Giáo viên sẽ
lần lượt điểm danh từng học
sinh trong lớp. Khi thầy gọi
đến tên ai thì học sinh đó nói
"Có em". Cứ như vậy đến hết.
Yêu cầu của chương trình: chỉ
có 2 nhân vật: giáo viên và
học sinh.
Nhân vật học sinh sẽ có 5

trang phục tương ứng với hình
ảnh các bạn HS trong lớp.
Thiết kế sơ bộ chương trình như sau:

(1) Giáo viên sẽ thiết lập một mảng tên HS trong lớp NameHS và thu âm trước
gọi tên của từng HS trong lớp.
Thiết lập dãy các âm thanh gọi tên

HS.
Thiết lập mảng NameHS lưu dãy

các họ tên HS.
(2) Nhân vật HS sẽ có 2 biến nhớ riêng là ID (mã hóa Clone) và Name (tên của
từng Clone - HS trong lớp).
Đoạn chương trình thực hiện khởi tạo 5 Clone của HS tương ứng với các học sinh
trong lớp.
Thiết lập các thông số ban đầu cho
nhân vật HS gốc.
Với mỗi vòng lặp, tăng ID lên 1,

gán DS họ tên HS vào biến Name
và khởi tạo Clone, dịch chuyển đến
vị trí xếp hàng của lớp. Như vậy
mỗi Clone sẽ có một ID và Name
riêng đúng theo danh sách tên HS
trong mảng NameHS.
Đây là đoạn chương trình GV lần lượt đọc tên HS và chờ để từng HS trả lời. Chú
ý đặc biệt đến lệnh truyền thông điệp của GV. Sau mỗi lần đọc tên HS, GV sẽ
thực hiện lệnh và đợi HS trả lời. Chú ý đến biến nhớ
Stt có thể đưa được vào lệnh này. Khi nhận thông điệp, Clone tương ứng sẽ nhận
và thực hiện bằng lệnh . Chú ý lệnh này không đưa biến Stt
vào được mà phải nhập trực tiếp tên của thông điệp.
Thiết lập các thông số ban đầu, GV

đợi 3 giây để lớp học thiết lập xếp
hàng (HS tạo 5 clones).
Bắt đầu quá trình gọi tên từng HS,

gửi thông điệp và đợi từng HS trả
lời.
Khi điểm danh xong, GV khen và

chương trình kết thúc.
Đoạn chương trình điều khiển HS trả lời. Chú ý các HS này là Clone của nhân vật
gốc HS. Đoạn chương trình này có 1 số đặc biệt sau:
- Sự kiện nhận thông điệp cần gõ trực tiếp số thứ tự thông điệp tại ô thông số của
lệnh.
- Sử dụng lệnh kiểm tra rẽ nhánh:
để điều khiển cho Clone với giá trị riêng ID cụ thể sẽ thực hiện khi nhận thông
điệp này. Đoạn chương trình nhận thông điệp của Clone thứ nhất như sau:
Tương tự với các Clone khác.

7. Giao tiếp người dùng - clone, clone - clone
Tổng kết các câu hỏi, vấn đề liên quan đến điều khiển các Clone độc lập trong
bảng sau.
Stt Câu hỏi, vấn đề Cách giải quyết
1 Làm cách nào để có thể Nhân vật gốc cần thiết lập các biến nhớ
thực hiện các lệnh điều riêng dùng để phân biệt Clone, ví dụ ID
khiển riêng rẽ từng Clone dùng để mã hóa, Name dùng để đặt tên
sau khi chúng được khởi riêng. Trước khi khởi tạo Clone cần gán các
tạo. Ví dụ sau khi tạo ra 2 tham số riêng này để Clone được kế thừa.
clone của 1 con chim,
làm thế nào để điều khiển
chúng, 1 con bay lên, 1
con bay xuống?
2 Các lệnh truyền thông Lệnh truyền thông điệp được thực hiện như
điệp có cách nào có thể bình thường, điểm khác biệt chỉ ở lệnh nhận
truyền thông tin đến từng thông điệp. Câu lệnh rẽ nhánh If …. then
phân thân riêng rẽ? cần đưa vào để xác định đúng Clone cần trả
lời thông điệp.
3 Muốn thực hiện hội thoại Bản thân Clone cũng có thể ra thông điệp
giữa người dùng với một hoặc thực hiện tất cả các lệnh giao tiếp như
Clone cụ thể thì làm cách một nhân vật bình thường. Để lập trình cho
nào? một Clone cụ thể chúng ta có thể dùng nhóm
lệnh sau:
4 Muốn truyền thông tin từ Tất cả các lệnh cảm biến đều có thể thực
các chức năng cảm biến, hiện đối với riêng rẽ các Clone độc lập bên
ví dụ nhấn phím, cảm trong lệnh If …. then …. như sau.
biến va chạm, màu sắc,
… đến với từng Clone thì
làm cách nào?
Stt Câu hỏi, vấn đề Cách giải quyết
5 Có thể hay không thực Hoàn toàn có thể. Các Clone thực hiện lệnh
hiện hội thoại giữa các truyền thông điệp bằng cách sử dụng nhóm
clone với nhau? Bằng lệnh:
cách nào?
Cách Clone độc lập nhận thông điệp đã trình

bày trong mục 2.
1. Một Clone có thể tạo cho mình các Clone nữa hay không? Em hãy thử và cho
nhận xét về câu hỏi này.
2. Giả sử nhân vật A gửi một thông điệp, ví dụ có tên "Start". Nhân vật B hiện
có rất nhiều clone đang hoạt động. Khi đó lệnh When I receive <Start> trong cửa
sổ lệnh của B sẽ được thực hiện bởi các loại nào của B?
A. Nhân vật B gốc.
B. Các clone của B.
C. Cả nhân vật gốc và clone cùng thực hiện các lệnh này.
3. Viết chương trình tổng quát chương trình Rừng hoa ở trên. Các bông hoa khi
xuất hiện sẽ rất nhỏ và sẽ lớn dần lên, đồng thời xoay tròn và thay đổi màu sắc
lộng lẫy.
4. Viết chương trình hoạt động như sau:

Chương trình gốc chỉ có 2 nhân vật Mèo và Chuột.
Mèo sẽ sinh ra 5 phân thân có tên là Mèo 1, Mèo 2, …, Mèo 5.
Chuột sẽ sinh ra 5 phân thân đặt tên là Chuột 1, Chuột 2, …, Chuột 5.
Khi bắt đầu chương trình các phân thân Mèo và Chuột di chuyển ngẫu nhiên trên
màn hình.
Nếu một chú Mèo va chạm với 1 chú Chuột thì 2 con sẽ dừng lại và chào hỏi
nhau:
Mèo sẽ nói, ví dụ, tôi là Mèo 1 đây; Chuột sẽ nói, ví dụ, tôi là Chuột 1 đây.
Sau 2 giây các con vật này lại tiếp tục di chuyển.
5. Viết chương trình Scratch mô phỏng chương trình, trò chơi Chọn màu đúng
dành cho các em nhỏ mẫu giáo như sau.
Nhân vật của chương trình:
Thầy Tùng và Hình tròn.
- Chương trình có 2 nhân vật chính là Thầy Tùng và Hình tròn. Nhân vật hình tròn
do em tự thiết kế và có tối thiểu 10 trang phục với màu sắc khác nhau, ví dụ các
màu có thể vẽ: đỏ, vàng, nâu, cam, xanh lá cây, xanh da trời, xanh thẫm, đen, tím,
hồng.
- Khi chơi, thầy Tùng sẽ đưa ra câu hỏi, ví dụ: Em hãy nháy lên hình tròn màu
xanh lá cây. Bên dưới sẽ hiển thị 3 hình tròn với các màu sắc khác nhau được sinh
ngẫu nhiên từ danh sách các màu của nhân vật Hình tròn. Câu hỏi được sinh với
đáp án ngẫu nhiên.
- Người chơi nháy chuột lên hình tròn có màu tương ứng. Thầy giáo sẽ lập tức
thông báo "Đúng rồi" nếu làm đúng hoặc "Sai rồi" nếu làm sai. Chương trình sẽ
nghỉ 2 giây là lại tiếp tục sinh câu hỏi mới.
Chủ đề 3.
Các công cụ, kỹ thuật thiết kế phần mềm
Mục tiêu:
- Một số kỹ thuật chính khi thiết kế phần mềm thực sự so sánh với việc chỉ viết
chương trình theo yêu cầu của người khác.
- Một vài kỹ thuật và đặc thù chính của một phần mềm hay trò chơi.
Nội dung chính
1. Một số đặc điểm của phần mềm trò chơi
Sau đây là 1 số đặc điểm, hay thuộc tính thường có của các trò chơi hay phần
mềm.
(a) Có đồng hồ tính thời gian thực.
Đồng hồ tính thời gian thực thường dùng với các mục đích sau:
- Dùng để đếm ngược thời gian, ví dụ đếm từ 100 về 0 thì kết thúc trò chơi.
- Dùng đểm đếm xuôi thời gian, tính toán thời gian đã chơi của người chơi.
Có nhiều cách tạo các "đồng hồ" thời gian như vậy.
1. Ví dụ sử dụng 1 biến nhớ có tên TimeCounter dùng để đếm ngược thời gian.
Giả sử, giá trị của biến này được gán 60 ngay từ lúc bắt đầu chương trình và nó sẽ
được giảm đi sau mỗi giây, do vậy sau đúng 60 giây thì giá trị này sẽ bằng 0, hay
đồng hồ sẽ được đếm ngược về 0.
Đoạn chươnng trình ngắn với biến nhớ này có thể như sau:
2. Một cách khác là dùng hàm thời gian hệ thống timer .

Đoạn chương trình sau cho phép chương trình chờ đúng 60 giây để kết thúc
chương trình hoặc chuẩn bị thực hiện 1 sự kiện tiếp theo. Chương trình sẽ đặt giá
trị timer = 0 và sau đó chờ cho đến khi giá trị này tăng trở lại = 60.
(b) Tương tác người chơi và máy tính chặt chẽ.

Tương tác với người chơi là đặc điểm quan trọng nhất của mọi phần mềm hay trò
chơi. Các tương tác này rất đa dạng, tạo ra sự hấp dẫn của phần mềm. Có thẻ chỉ
ra các loại tương tác sau:
1. Tương tác bằng bàn phím. Khi người dùng nhấn 1 phím sẽ tạo ra 1 sự kiện tác
động lên chương trình, tạo ra 1 tương tác với phần mềm. Câu lệnh tạo sự kiện
tương tác bàn phím trong Scratch là:
2. Tương tác bằng chuột.
Tương tác bằng chuột cũng đóng vai trò rất quan trọng trong mọi chương trình
phần mềm. Ví dụ đối với Scratch thì tương tác bằng chuột có thể như sau:
- Sự kiện khi người chơi nháy chuột lên 1 nhân vật.
- Sự kiện khi người chơi nháy chuột lên 1 vị trí bất kỳ của màn hình, sân khấu.
- Hàm cảm biến khi nhận ra người dùng nháy chuột, và có thể tính toán được vị trí
chính xác của con trỏ chuột tại thời điểm nháy chuột đó.
- Hàm tính toán khoảng cách từ nhân vật đến vị trí con trỏ chuột.
- Lệnh cho phép nhân vật luôn dính chặt với con trỏ chuột.
- Lệnh cho phép nhân vật luôn xoay về hướng con trỏ chuột.
3. Tương tác giữa các nhân vật của phần mềm.

Tương tác giữa các nhân vật được thể hiện trong Scratch có 2 loại:
- Tương tác gián tiếp thông qua thông điệp.
- Tương tác trực tiếp thông qua lệnh cảm ứng va chạm.
4. Tương tác thông qua các thông tin cảm biến khác
(c) Tính điểm để đánh giá người chơi.
Dùng điểm số để kích thích người chơi, xếp hạng người chơi. Cũng có thể dùng
điểm để làm phần thưởng như tăng lượt chơi, tặng quà, …
Cách làm đơn giản nhất là dùng 1 biến nhớ để lưu trữ điểm số. Biến nhớ này sẽ
gia tăng hoặc giảm bớt giá trị tùy theo các điều kiện cụ thể của trò chơi.
Thông thường điểm số sẽ luôn được thể hiện trên màn hình để người chơi quan sát
được điểm của mình.
(d) Khái niệm lượt chơi thay thế cho thời gian đếm ngược.
Đây là một kỹ thuật rất hay được sử dụng trong các trò chơi, phần mềm, làm tăng
độ hấp dẫn khi chơi.
Ví dụ trò chơi thả bóng, có thể qui định người chơi được 6 lượt chơi, mỗi lần để
bóng rơi xuống phía dưới sẽ mất 1 lượt. Nếu mất hết toàn bộ 6 lượt thì thua.
(e) Mức khó, dễ của cách chơi
Hầu hết các trò chơi đều có khái niệm mức độ khó dễ. Theo thời gian chơi, phần
mềm sẽ tự động tăng các mức khó, dễ này để người chơi sẽ cảm thấy khó chơi
hơn. Thông thường cần tạo 1 biến nhớ chung để lưu mức độ này, ví dụ gamelevel.
Tham số này sẽ bắt đầu từ 0 hoặc 1 và sẽ được tăng dần theo thời gian hoặc điểm
số, đánh giá người chơi.
(f) Tương tác đối kháng các người chơi.
Tương tác đối kháng là việc mô phỏng đối kháng trực tiếp giữa 2 nhân vật trong
trò chơi, ví dụ chơi cờ, đấu súng, … Có 2 loại đối kháng sau:
1) Đối kháng giữa 1 người chơi và 1 nhân vật do phần mềm tự mô phỏng. Tương
tác đối kháng này thực chất là người đấu với máy tính.
2) Tương tác giữa 2 người chơi. Kỹ thuật này xử lý khó hơn trường hợp trên.
2. Kỹ thuật đếm ngược
Chúng ta cùng thực hiện kỹ thuật này thông qua trò chơi Thả bóng.
Tha bong
Cách chơi vẫn không có gì thay
extended.sb2 đổi. Bổ sung 1 đồng hồ thời
gian để đếm ngược. Nếu sau 60
giây hoặc nếu người chơi để
bóng rơi xuống phía dưới thì
thua.
Khi thua, màn hình sẽ hiện
dòng chữ "Game Over". Để làm
việc này sẽ bổ sung thêm 1
nhân vật Game Over nữa như
hình bên.
Cách xử lý kỹ thuật như sau:

- Thiết lập 1 biến nhớ chung là TimeCounter, biến nhớ này sẽ đóng vai trò đồng
hồ ngược. Giá trị ban đầu là 60, sau mỗi giây giá trị biến này giảm đi 1. Khi giảm
về 0, từ sân khấu sẽ gửi đi thông điệp End để thông báo kết thúc.
Chương trình chạy trên nền sân khấu để

điều khiển biến nhớ hệ thống
TimeCounter.
Luôn kiểm tra, nếu biến nhớ

TimeCounter < 1 thì ra thông điệp
End.
- Nhân vật Game Over sẽ xử lý việc này. Khi nhận được thông điệp End, nút
Game Over sẽ hiển thị (nút này được ẩn đi khi bắt đầu chương trình) và ra lệnh
dừng toàn bộ bằng lệnh Stop All.
Khi bắt đầu chương trình thì

ẩn đi.
Khi nhận thông điệp End thì hiện và ra
lệnh dừng toàn bộ chương trình.
- Chương trình của Bóng như sau, chú ý cách xử lý khi bóng rơi xuống phía dưới
thì cũng gửi đi thông điệp End.
Nếu bóng rơi xuống phía dưới thì

lập tức gửi thông điệp End để dừng
chương trình.
3. Mô phỏng lượt chơi cho các nhân vật

Tha bong Kỹ thuật mô phỏng lượt chơi có rất nhiều trong các phần mềm dạng trò chơi.
extended 2.sb2 Chúng ta sẽ mô phỏng chúng trong chương trình thả bóng sau đây.
Để mô phỏng lượt chơi, ngoài dùng 1 biến nhớ, chúng ta sẽ sử dụng công cụ
Clone để thể hiện lượt chơi này. Chú ý đến nhân vật Star (ngôi sao) của chương
trình.
Chương trình thả bóng quen thuộc.

Mỗi người chơi có 5 lượt chơi. Mỗi
lần bóng bị rơi xuống đất thì mất 1
lượt, khi hết tất cả các lượt thì sẽ bị
thua.
Chương trình sẽ bổ sung thêm nhân
vật Star (ngôi sao) để thể hiện lượt
chơi còn lại ở phía trên màn hình.
Trên màn hình luôn thể hiện số ngôi
sao = số lượt chơi còn lại.
Chúng ta bắt đầu phân tích nhân vật ngôi sao của chương trình này. Việc thể hiện
các ngôi sao từ đầu chương trình sẽ dùng tính năng phân thân, Clone của Scratch.
Như vậy khi bắt đầu chương trình, nhân vật ngôi sao sẽ phải phân thân thành 5
ngôi sao khác, được đánh số từ 1 đến 5 tính từ phải sang trái như hình sau.
5 4 3 2 1
Để đánh số các clone, chúng ta dùng biến nhớ CloneID - là biến riêng của nhân
vật này.
Biến nhớ dùng chung StarNumber dùng để tính số ngôi sao còn lại trên màn hình,
đây chính là số lượt chơi còn lại của người chơi. Biến nhớ này sẽ được gán giá trị
ban đầu = 5.
Đoạn chương trình sinh các phân thân và thể

hiện các clone của ngôi sao trên màn hình, Mỗi
ngôi sao mang 1 giá trị CloneID riêng của mình,
đánh số từ 1 đến 5.
Đoạn chương trình sau mô tả hoạt động của bản thân các clone của ngôi sao. Đây
là đoạn chương trình quan trọng nhất và là "key" của toàn bộ kỹ thuật dùng nhân
vật thể hiện lượt chơi trên màn hình.
Chương trình có dùng 1 biến nhớ chung là StarChange có ý nghĩa như sau: biến
nhớ này mô tả trạng thát chuyển số lượng của nhân vật ngôi sao. StarChange bình
thường có giá trị = 0, nhưng tại thời điểm có biến động, giá trị của nó được thiết
lập = 1 để thông báo đến thời điểm giá trị StarNumber sẽ giảm đi 1 đơn vị. Đoạn
chương trình điều khiển clone này như sau:
Hàm kiểm tra CloneID =

StarNumber để đảm bảo
clone phía trái ngoài cùng
sẽ bị xóa trước.
Còn đây là chương trình chính điều khiển bóng.
Đoạn chương trình kiểm tra khi bóng rơi
xuống dưới. Nếu số lượt còn lại > 0 thì
chuyển StarChage = 1 để giảm số lượt,
ngược lại nếu đã hết lượt thì thông báo
End để kết thúc.
4. Kỹ thuật tính điểm số cho người chơi

Tính điểm số cho người chơi là một trong những đặc tính phổ biết nhất cho tất cả
các phần mềm trò chơi vì nó sẽ tạo ra sự kích thích, hứng thú của người chơi.
Trong hoạt động này chúng ta sẽ minh họa kỹ thuật này thông qua chương trình
thả bóng quen thuộc.
Thiết lập 1 biến nhớ Diem_so để

Tha bong
lưu trữ điểm số cho người chơi. Khi
extended 4.sb2
bắt đầu chương trình, giá trị này sẽ
được gán = 0. Biến nhớ sẽ được
hiển thị online ngay trên màn hình.
Để cho chương trình hấp dẫn sẽ bổ
sung thêm tính năng thưởng lượt
chơi.
Cách tính điểm số qui định như sau:

- Mỗi khi người dùng làm bật quả bóng lên trên bởi thanh ngang thì được cộng
thêm 5 điểm.
- Điểm thưởng thêm: cứ sau mỗi 15 giây chơi, người dùng được tặng thêm 3
điểm.
Các đoạn chương trình tương ứng như sau:
Khi bóng chạm được thanh ngang thì Mỗi khi thời gian chơi của người chơi
bật lên và tăng điểm số thêm 5. vượt qua khoảng 15 giây thì điểm sẽ
được tăng lên 3.
Thưởng lượt chơi. Qui định như sau: mỗi khi điểm số của ngưởi chơi vượt quá
200, 400, … (bội của 200) thì được thưởng thêm 1 lượt chơi. Trên màn hình sẽ
xuất hiện thêm 1 ngôi sao.
Để thực hiện được yêu cầu trên chúng ta thiết lập thêm 1 biến nhớ để điều khiển
việc thưởng lượt chơi, biến có tên iBonus và được gán giá trị ban đầu = 0. Thuật
toán như sau:
Mỗi khi kiểm tra thấy Diem_so > 200*iBonus thì gửi thông điệp Bonus để tăng
lượt và tăng iBonus lên 1 đơn vị. Nhân vật Ngôi sao sẽ nhận thông điệp Bonus
và xử lý để bổ sung thêm lượt chơi.
Đoạn chương trình của sân khấu điều khiển điểm số như sau:
Kiểm tra nếu Diem_so > 200*iBonus thì

gửi thông điệp Bonus, sau đó tăng iBonus
lên 1 đơn vị để chờ lần gửi Bonus tiếp
theo.
Việc xử lý thông điệp Bonus của nhân vật Ngôi sao sẽ phức tạp hơn vì hiện tại
trên màn hình có cả nhân vật Ngôi sao gốc và các Clone của mình. Các Clone
cũng nhận được thông điệp Bonus. Do vậy cần lập trình để phân biệt được nhân
vật gốc và các Clone. Chỉ có nhân vật gốc mới nhận Bonus và xử lý. Chúng ta
phải sử dụng lại biến riêng CloneID để phân biệt nhân vật gốc và Clone của ngôi
sao. Nhân vật gốc sẽ có CloneID = 0.
Đoạn chương trình xử lý thông điệp Bonus như sau:
Kiểm tra nhân vật gốc mới được

xử lý thông điệp này.
Chuyển đến vị trí cần thiết.
Tăng số lượng sao, đặt lại

CloneID và khởi tạo Clone mới
(tăng lượt).
Đặt lại ClodeID = 0 cho nhân vật

gốc.
5. Thể hiện số và đếm số

Hiện số, đếm số theo thời gian là các đặc thù thường xuyên của các trò chơi hay
phần mềm nói chung. Cách đơn giản nhất là thiết lập 1 biến nhớ và cho biến nhớ
hiển thị trên màn hình.
Ví dụ sử dụng biến nhớ Time, đặt chế độ hiển thị biến nhớ này trên màn hình.
Chúng ta có 2 cách sau để cho biến nhớ tự động đếm theo thời gian là giây.
Cách 1. Sử dụng hàm hệ thống Cách 2. Dùng vòng lặp vô hạn, sau
timer, luôn gán Time cho timer. mỗi 1 giây nghỉ bằng lệnh wait thì
tăng Time lên 1 đơn vị.
Biến nhớ hệ thống timer cũng có chế độ hiển thị online . Em hãy so
sánh cách hiển thị của biến nhớ này với hiển thị biến nhớ Time do người dùng tạo
ra.
Cách thể hiện trên có 1 nhược điểm là chữ số quá bé, không gây ấn tượng. Trong
các phần mềm hoặc trò chơi cần các kỹ thuật để thể hiện số to hơn, rõ ràng hơn,
chúng ta sẽ cùng nhau tìm hiểu các bài toán này.
(a) Thể hiện số bằng hình ảnh nhân vật
Kỹ thuật thể Chúng ta sẽ cùng xây dựng chương trình và thuật toán thể hiện số bằng hình ảnh
hiện số bằng lớn trên sân khấu. Kỹ thuật này rất hay được sử dụng trong các trò chơi và phần
hình ảnh trên mềm.
màn hình.
Ý tưởng của kỹ thuật này là sử
dụng lệnh stamp của Scratch để
hiển thị chữ số lớn bằng hình ảnh.
Show
Numbers.sb2 Thiết lập 1 nhân vật có tên
Number bao gồm đúng 10 trang
phục được đánh số từ 1 đến 10,
trang phục 1 là số 0, trang phục 2
là số 1, …., trang phục 10 là số 9.
Thuật toán sẽ dựa trên các trang
phục này để hiển thị chữ số trên
màn hình.
Giá trị 2 biến mảng chính liên quan đến thuật toán này (Numbers và Width) như
sau:
- Bảng Numbers chứa 10 phần tử là 0, 1, 2,
3, 4, 5, 6, 7, 8, 9. Như vậy phần tử thứ k
chính là chữ số k-1, tương ứng trang phục
thứ k của nhân vật.
- Bảng Width lưu độ rộng của các trang
phục tương ứng. Phần tử thứ k chính là độ
rộng của trang phục số k-1.
ch Thuật toán hiển thị số bằng hình ảnh:

Trong 1 vòng lặp độ dài length(n), bắt đầu
45930
từ vị trí index=1, lấy ra chữ số ch. Chuyển
trang phục cho nhân vật, thực hiện lệnh
stamp, sau đó chuyển sang phải theo độ dài
Vị trí bắt bằng độ rộng của số ch+1 lấy từ bảng
đầu của index = 3
Width.
nhân vật
Thuật toán trên được mô tả bằng lệnh Scratch như sau:
Ví dụ đoạn chương trình hiển thị số trên màn hình đếm lùi từ 1000 như sau:
Em hãy hoàn thiện thủ tục Show Number thể hiện 1 số bắt đầu từ 1 vị trí cho
trước trên màn hình.
(b) Kỹ thuật thể hiện đếm số tự động bằng hình ảnh
Thuật toán sử dụng trong phần trên có 1 nhược điểm là mỗi lần thể hiện phải xóa
Kỹ thuật thể tất cả để vẽ lại từ chữ số của số cần thể hiện. Chúng ta sẽ làm tốt hơn kỹ thuật trên
hiện việc đếm đối với bài toán thể hiện đếm (tăng dần hoặc giảm dần) trên màn hình.
bằng hình ảnh
trên màn hình. Ý tưởng chính của thuật toán này là sau mỗi lần tăng hoặc giảm số, không cần vẽ
lại toàn bộ các chữ số, mà chỉ cần vẽ lại những chữ số cần vẽ lại.
Chúng ta cùng xét 1 ví dụ thể hiện phép đếm tăng số, bắt đầu từ 1 giá trị nào đó.
Quá trình này được xét kỹ hơn khi chuyển thể hiện số n sang n+1.
Ví dụ với số n = 3587 thì số tiếp theo chỉ cần thay 7  8.
Ví dụ với số n = 456999 thì số cần thể hiện tiếp theo là 457000.
Rõ ràng cần tìm ra chữ số đầu tiên < 9 tính từ bên phải của số n.
CurrIndex = 3 LastNumber = 6999
n= 456999 456999
Lastch = 6
Thuật toán được mô tả như sau:

Thiết lập 3 biến nhớ: CurrIndex, LastNumber và Lastch.
Bắt đầu từ vị trí cuối cùng của số n, thiết lập CurrIndex = length(n), Lastch
= LastNumber = chữ số cuối cùng của n.
Đi lùi về bên trái cho đến khi gặp chữ số đầu tiên < 9 hoặc CurrIndex = 1.
Tính toán lại giá trị LastNumber.
LastNumber có độ dài = Length(n) - CurrIndex + 1. (Nếu CurrIndex = 1
thì LastNumber = n).
Tăng LastNumber và n lên 1 đơn vị.
Thực hiện việc thể hiện lại số LastNumber bắt đầu từ vị trí hiện thời.
Thủ tục chính của thuật toán trên là Counting from <n> at <X> <Y> sẽ hiện
máy đếm số tăng liên tục bắt đầu từ n.
Trong thủ tục này có sử dụng 1 thủ tục khác là New Show Number <n>. Thủ tục
này có chức năng thể hiện 1 số <n> tính từ vị trí hiện thời của nhân vật, nhưng
không xóa màn hình trước khi thể hiện chữ. Thủ tục này dùng để thể hiện liên tục
số LastNumber trong thuật toán trên.
Chúng ta cùng phân tích thủ tục đếm số tăng này.
Thể hiện số gốc n trên màn hình,
thiết lập CurrNumber = n.
Bắt đầu vòng lặp chính tăng n để đếm

Thiết lập các biến chính vào
đầu mỗi vòng lặp:
lengh, Lastch, CurrIndex,
LastNumber.
Vòng lặp lùi CurrIndex về trái

để tìm chữ số đầu tiên < 9.
Mỗi lần lùi sẽ đồng thời lùi vị
trí nhân vật số sang trái theo
độ dài 1 chữ số.
Lùi vị trí nhân vật sang trái

thêm 1 chữ số nữa, tăng
LastNumber và CurrNumber
lên 1 đơn vị. Thể hiện số
LastNumber từ vị trí hiện thời.
Bây giờ chúng ta quay lại thủ tục New Show Number, chỉ ra 1 vị trí thay đổi duy
nhất nhưng quan trọng của thủ tục này so với Show Number. Bổ sung vào các
trang phục số 1 trang phục empty nữa để xóa 1 chữ số đã có trên màn hình.
Thủ tục New Show

Number chỉ có 1
sự khác biệt duy
nhất là trước khi vẽ
1 chữ số thì xóa vết
của chữ số trước
đó. Việc xóa này
được thực hiện bởi
trang phục empty.
Trên đây là bài toán thể hiện phép đếm số tăng dần. Thuật toán thể hiện phép đếm
giảm dần hoàn toàn tương tự.
Bài tập: thiết lập thuật toán tương tự để xử lý bài toán đếm số giảm dần. Thủ tục
tương ứng sẽ có tên Counting down <n> at <X>, <Y>.
6. Thể hiện chữ, tên người, nhân vật
Kỹ thuật thể Bài toán thể hiện chữ trong các phần mềm, trò chơi cũng tương tự như việc thể
hiện chữ bằng hiện số. Chúng ta có thể dùng biến nhớ thể hiện ngay trên màn hình.
hình ảnh. Để thể hiện các chữ bằng hình ảnh trên màn hình, chúng ta sẽ thiết lập nhân vật
Char có các trang phục chính là dãy các chữ cái của bảng chữ cái ngôn ngữ đang
sử dụng. Về lý thuyết thủ tục thể hiện Show Word có thể làm tương tự như Show
Number trong ví dụ trên. Nhưng chúng ta sẽ đi theo cách khác trong hoạt động
này.
Minh họa kỹ thuật hiển thị từ, tên người, tên sự vật được thể hiện trong chương
trình sau:
Thiết lập nhân vật có tên Char với

26 trang phục tương đương bảng
chữ cái tiếng Anh.
- Nhân vật chính là bộ chữ cái đầy đủ, ví dụ bộ 26 chữ cái tiếng Anh. Nhân vật
trong chương trình của chúng ta tên là Char và có 26 bộ trang phục theo bảng chữ
cái.
- Bộ dữ liệu chính bao gồm 2 bảng Alphabet và AlphabetWide. Alphabet là dãy
26 chữ cái tương ứng đúng với dãy các trang phục của Char. AlphabetWide là
dãy các chiều rộng của các trang phục của Char trên sân khấu.
- Để thiết lập thuật toán theo yêu cầu chúng ta cần thêm 2 bảng nữa, WList và
Wkc để lưu kết quả của từ, chữ cần thể hiện trên màn hình.
Hai bảng Wlist và Wkc sẽ lưu kết quả

trung gian liên quan đến từ cần thể hiện
trên màn hình. WList lưu dãy các chữ cái
của từ và Wkc là thông tin độ rộng tương
ứng của chữ cái này.
Giả sử từ cần thể hiện bằng hình ảnh trên màn hình là Word, thuật toán chính
được mô tả như sau.
Bước 1 (Init). Phân tích và tách từng chữ cái của từ Word, đưa vào bảng WList,
chỉ lấy các chữ cái có trong bảng Alphabet tương ứng. Bảng Wkc lưu thông tin
tương ứng lấy từ bảng AlphabetWide.
Bước 2 (Show Word). Lần lượt lấy các chữ cái từ bảng WList, chuyển trang phục
cho chữ cái này, dùng lệnh stamp để vẽ chữ cái trên màn hình, sau đó chuyển vị
trí nhân vật sang phải theo 1 khoảng cách bằng đúng độ rộng của chữ cái này. Quá
trình này lặp lại cho đến khi đi hết bảng WList.
Bước 1 được gọi là quá trình Init (chuẩn bị), bước 2 là quá trình thực sự thể hiện
từ trên màn hình.
Phần lõi của bước 1, Init, được thể hiện bằng lệnh Scratch như sau.
Vòng lặp ngoài

lấy từng chữ ch
của Word.
Kiểm tra xem ch có

nằm trong bảng chữ cái
Alphabet không, nếu
có bổ sung chữ này vào
WList và lấy độ rộng
tương ứng đưa vào
Wkc.
Phần lõi của bước 2 được thể hiện như sau:
Lấy từng ký tự trong bảng WList,

chuyển trang phục sang ký tự này,
thực hiện lệnh stamp, sau đó
chuyển tọa độ X sang phải 1 giá trị
bằng độ dài trong Wkc tương ứng.
2 thủ tục cần thiết kế cho kỹ thuật trên là:
Em hãy hoàn thiện 2 thủ tục Init và Show Word cho thuật toán trên.
random 7. Kỹ thuật sinh ngẫu nhiên trong các trò chơi và phần
algorithms mềm
Kỹ thuật sinh ngẫu nhiên rất hay được sử dụng trong tất cả các phần mềm, trò
chơi, ví dụ cần sinh 1 bộ câu hỏi trắc nghiệm từ 1 ngân hàng câu hỏi cho trước.
Có rất nhiều bài toán cụ thể liên quan đến kỹ thuật này, chúng ta cùng tìm hiểu 1
số thuật toán như vậy.
(a) Thuật toán sinh ngẫu nhiên 4 số trong 1 dãy số dạng List.
Xét bài toán sau: cho trước 1 dãy số NumList. Dãy này được minh họa bằng biểu
diễn: a1, a2, ….., aN.
Cần lấy ra ngẫu nhiên 4 phần tử khác nhau từ dãy này, kết quả được đưa vào 4
biến nhớ pA, pB, pC, pD và thể hiện trên màn hình. Chú ý dãy ban đầu NumList
cần được bảo toàn sau thuật toán.
Phân tích.
Ý tưởng thực hiện bài toán này rất đơn giản, chỉ cần lần lượt lấy ra 4 phần tử ngẫu
nhiên của dãy NumList, sau mỗi lần lấy ra thì xóa phần tử gốc khỏi dãy ban đầu.
Nhưng bài toán yêu cầu bảo toàn dãy gốc nên cần thực hiện trên 1 dãy tạm. Như
vậy cần thiết lập thêm 1 biến nhớ dạng list nữa là TempList, cần thực hiện việc
chuyển toàn bộ dữ liệu từ NumList sang TempList và tiến hành thuật toán sinh dữ
liệu từ TempList này.
Đây là đoạn chương trình tạo dữ liệu ban đầu cho TempList.
Thuật toán sao chép toàn bộ dữ liệu

từ dãy NumList sang dãy
TempList.
Đoạn chương trình sau thực hiện việc sinh ngẫu nhiên phần tử từ dãy TempList,
đưa vào pA và xóa phần tử này từ dãy TempList.
Tương tự thực hiện như vậy với 3 phương án còn lại pB, pC, pD.
Bài tập: em hãy viết hoàn chỉnh thủ tục mô tả thuật toán trên.
(b) Thuật toán sinh ngẫu nhiên 1 xâu con 4 ký tự của 1 xâu bất kỳ
Bài toán: cho trước 1 xâu ký tự bất kỳ Str. Cần lấy ra ngẫu nhiên 4 ký tự khác
nhau từ xâu này, kết quả được đưa vào 4 biến nhớ pA, pB, pC, pD và thể hiện trên
màn hình.
Phân tích.
Bài toán này gần tương tự hoàn toàn bài toán trên, điểm khác duy nhất là dữ liệu
gốc không là dãy, mà là 1 xâu ký tự. Có 2 cách thực hiện như sau:
Cách 1: tạo 1 biến xâu tạm thời TempStr, sao chép Str sang TempStr và thực hiện
thuật toán lấy 4 phần tử ngẫu nhiên từ TempStr, sau mỗi lần lấy ra thì xóa ký tự ở
xâu gốc.
Cách 2: tạo 1 dãy TempList, lấy từng ký tự từ xâu Str chuyển vào TempList, sau
đó lấy ra 4 phần tử ngẫu nhiên tương tự thuật toán (a) đã nêu ở trên.
Với cách 1 của thuật toán này, sau đây là đoạn chương trình sao chép Str sang
TempStr và lấy đi 1 phần tử ngẫu nhiên đầu tiên gán vào pA.
Tiếp theo cần xóa đi ký tự với chỉ số index của xâu TempStr. Vì Scratch không có
lệnh xóa 1 ký tự trong xâu, nên chúng ta phải thực hiện "mẹo" bằng cách chuyển
toàn bộ TempStr sang 1 xâu trung gian nữa, Temp1, sau đó cần gán ngược lại vào
xâu gốc TempStr. Chú ý khi chuyển từ TempStr  Temp1 thì bỏ qua ký tự với
chỉ số index. Đoạn chương trình trên như sau:
Thuật toán xóa 1 ký tự

chỉ số index trong 1 xâu
cho trước TempStr.
Bài tập: hoàn thiện nốt thuật toán này.

(c) Thuật toán sinh hoán vị ngẫu nhiên của 1 xâu ký tự
Bài toán: cho trước 1 xâu ký tự bất kỳ Str. Cần sinh ra 1 hoán vị ngẫu nhiên của
xâu này, kết quả đưa vào biến StrOut.
Phân tích.
Nếu để ý 1 chút, chúng ta sẽ thấy bài toán này suy từ bài toán sinh 4 phần tử ngẫu
nhiên ở trên. Chúng ta sử dụng 1 xâu đệm có tên TempStr. Thuật toán được mô tả
như sau:
Gán TempStr = Str. Gán StrOut = rỗng.
Thực hiện vòng lặp độ dài = length(Str)
Lấy ra 1 phần tử ngẫu nhiên của TempStr.
Đưa phần tử này vào cuối của StrOut.
Xóa phần tử này khỏi TempStr.
(cách xóa: sao chép tất cả các ký tự từ
TempStr sang Temp1 trừ ra phần tử trên, sau
đó gán ngược lại vào TempStr).
Đoạn chương trình trong Scratch như sau:
Vòng lặp chính.
Sinh giá trị ngẫu nhiên index,
lấy ra phần tử ch và đưa vào
cuối của StrOut.
Xóa phần tử của TempStr tại vị

trí index. Cách thực hiện: sao
chép tất cả các ký tự từ
TempStr sang Temp1 trừ ra
phần từ có chỉ số index. Sau đó
gán lại TempStr = Temp1.
Em hãy viết 1 thủ tục hoàn thiện thuật toán trên.

(d) Thuật toán sinh hoán vị ngẫu nhiên của 1 dãy số
Bài toán: cho trước 1 dãy số (hoặc dãy xâu ký tự) NList (WList). Cần sinh ra 1
hoán vị ngẫu nhiên của dãy số (xâu) này, kết quả đưa vào dãy (xâu) NListOut
(WListOut).
Phân tích.
Chúng ta sẽ thiết kế thuật toán trên dãy số NList, hoàn toàn tương tự với dãy xâu
WList. Thuật toán này khá đơn giản như sau.
Thiết lập 1 dãy tạm TempList. Sao chép toàn bộ NList sang TempList.
Thiết lập vòng lặp độ dài = length(NList)
Lấy 1 phần tử ngẫu nhiên của TempList, đưa vào cuối của NListOut.
Xóa phần tử này khỏi dãy TempList.
Mô tả thuật toán trên bằng lệnh Scratch như sau:
Sao chép toàn bộ dãy NList

sang dãy TempList.
Sinh 1 hoán vị ngẫu nhiên

của TempList và đưa kết
quả vào dãy NListOut.
8. Thuật toán sinh ngẫu nhiên 1 bộ đáp án, trong đó có 1
đáp án đúng
Trong hoạt động này chúng ta sẽ làm quen với 1 số các thuật toán hay dùng khi
sinh ngẫu nhiên các câu hỏi trắc nghiệm trong các phần mềm giáo dục. Chúng ta
nhớ lại rằng câu hỏi trắc nghiệm luôn bao gồm 4 đáp án (có thể nhiều hơn), trong
đó có 1 đáp án đúng. Trên thực tế có rất nhiều bài toán như vậy, chúng ta sẽ chỉ
tìm hiểu 1 vài trong chúng.
Để mô phỏng các bài toán sinh ngẫu nhiên câu hỏi trắc nghiệm chúng ta dùng các
bộ dữ liệu sau:
(a) Bộ các biến nhớ độc lập để lưu các phương án pA, pB, pC, pD và bộ 4 trạng
thái để mô tả phương án đúng sai: pAstatus, pBstatus, pCstatus, pDstatus. Các giá
trị status có ý nghĩa = 0 nếu phương án sai, = 1 nếu phương án đúng. Một phương
án khác là chỉ cần 1 biến nhớ pCorrect có ý nghĩa là chỉ số của phương án đúng
trong số các phương án A, B, C, D.
(b) 2 mảng dữ liệu có độ dài 4 phần tử: pList và statusList.
pList[k], k=1, 2, 3, 4 là các phương án A, B, C, D.
sList[k], k=1, 2, 3, 4 là các trạng thái = 0, nếu sai, = 1, nếu đúng.
Như vậy bộ dữ liệu sẽ cần được cập nhật đồng thời cho các mảng pList, sList và
các biến nhớ pA, pB, pC, pD, pAstatus, pBstatus, pCstatus, pDstatus.
Xét các bài toán cụ thể sau:
Giả sử cho trước 1 dãy số (hoặc xâu ký tự). Cần lấy ra ngẫu nhiên 4 giá trị của dãy
trên dùng làm 4 phương án, sau đó lại lựa chọn ngẫu nhiên 1 trong số các giá trị
này để làm phương án đúng.
Chúng ta sẽ cùng thực hiện bài toán trên thông qua 1 ví dụ cụ thể sau.
Giả sử có 2 mảng dữ liệu: dsQG và dsThudo như hình dưới đây.
Cho trước 2 mảng xâu ký tự:

dsQG: danh sách các quốc gia trên
thế giới.
dsThudo: danh sách tên thủ đô
tương ứng.
Cần sinh ngẫu nhiên các câu hỏi trắc nghiệm như sau, ví dụ:
Tirana là thủ đô của quốc gia nào dưới đây:

A. Angola B. Albani C. Vietnam D. Japan (đáp án đúng: B)
Thuật toán sinh bộ dữ liệu đơn giản như sau:
Lần lượt sinh 4 giá trị ngẫu nhiên lấy từ bảng dsQG (đồng thời dsThudo) và đưa
vào các biến pA, pB, pC, pD, sau đó lựa chọn 1 giá trị ngẫu nhiên trong 4 số này
lấy làm phương án đúng để sinh câu hỏi dạng như trên.
Minh họa thuật toán trên bằng chương trình sau dùng để kiểm tra kiến thức môn
Địa lý cho học sinh phổ thông.
Random Chương trình sẽ sinh tự động các
multiple câu hỏi trắc nghiệm theo mẫu trên
choice.sb2 và thể hiện như hình bên.
Người dùng sẽ trả lời bằng cách
nhập đáp án bằng số như 1, 2, 3, 4.
Ngay sau khi nhập đáp án, chương
trình sẽ thông báo đúng, sai và
sinh tiếp câu hỏi.
Chương trình sẽ dừng khi người
chơi chỉ nhấn Enter mà không
nhập số.
Thủ tục Init có nhiệm vụ thiết lập bộ dữ liệu đệm của chương trình.
Bộ dữ liệu đệm NList được khởi

tạo mỗi lần cần sinh câu hỏi trắc
nghiệm. Bộ dữ liệu này bao gồm 1
dãy số tự nhiên 1, 2, 3, … có độ
dài đúng bằng độ dài của mảng
dsQG.
Thủ tục Process dùng để khởi tạo ngẫu nhiên 1 bộ

dữ liệu câu hỏi trắc nghiệm.
Sinh ngẫu nhiên 4 giá trị từ dãy NList,

tức là 4 giá trị ngẫu nhiên từ danh sách
các quốc gia. Các chỉ số này sẽ lưu
trong mảng pList, sau đó gán tên quốc
gia cho các biến pA, pB, pC, pD.
Trong số này sẽ chọn ra 1 chỉ số ngẫu
nhiên đóng vai trò phương án đúng. Chỉ
số của phương án đúng lưu trong biến
pCorrect. Sau đó sinh câu hỏi lưu vào
xâu Str.
Chương trình chính sẽ có dạng đơn giản như sau:
Trong vòng lặp vô hạn, sau khi

thực hiện 2 thủ tục Init,
Process, sẽ thực hiện yêu cầu
người sử dụng trả lời câu hỏi
trắc nghiệm vừa được tạo ra.
Có thể tóm tắt thuật toán sinh ngẫu nhiên câu hỏi trắc nghiệm như sau:
- Sinh ngẫu nhiên 4 giá trị chỉ số khác nhau từ 1 đến độ dài dsQG. Các giá trị này
sẽ lưu vào 4 phần tử của dãy pList.
- Sinh ngẫu nhiên giá trị pCorrect từ 1 đến 4 để lưu phương án đúng.
- Gán tên các quốc gia đã chọn vào các biến pA, pB, pC, pD để hiện trên màn
hình.
- Sinh câu hỏi trắc nghiệm, lấy tên thủ đô của đáp án đúng lồng ghép trong nội
dung câu hỏi.
- Lặp lại quá trình trên cho mỗi lần sinh câu hỏi.
Em hãy hoàn thiện chương trình trên.
9. Ví dụ: trò chơi điều khiển bóng
Chúng ta sẽ hoàn thiện phần mềm trò chơi thả bóng đã được nêu ra trong các hoạt
động của bài học này, bổ sung thêm các yêu cầu mới.
Tha bong Các nhân vật chính bao gồm

extended 5.sb2 Bóng, Thanh ngang, Star,
Number và nút Game Over.
Mỗi lần bóng chạm thanh ngang
được tăng 5 điểm. Nếu thời gian
chơi vượt qua mỗi số là bội của
15 thì tăng điểm 3 điểm. Nếu
điểm số vượt ngưỡng 200, 400,
600, … thì thưởng lượt chơi.
Điểm số hiện to trên màn hình.
Nếu bóng rơi xuống phía dưới thì
mất 1 lượt. Nếu hết lượt thì xuất
hiện Game Over và trò chơi kết
thúc.
Chương trình được thiết kế với các nhân vật và dữ liệu chính sau:
- Nhân vật chính: Bóng; Thanh ngang, Ngôi sao (Star), Chữ số (Number) và nút
Game Over.
- Các biến nhớ chính:
TimeCounter: Tổng thời gian chơi. Chơi càng lâu sẽ được thưởng điểm và
thưởng lượt chơi.
Diem_so: Điểm số của người chơi.
StarNumber: Số lượt chơi thể hiện bằng các ngôi sao trên màn hình.
Sơ đồ hoạt động của phần mềm được mô tả trong hình sau.
0 0 5
Thiết lập các giá trị Thiết lập StarNumber = 5,
ban đầu như điểm hiển thị 5 ngôi sao Clone
số, thời gian hệ
trên màn hình.
thống.
Bóng rơi tự do xuống Thiết lập tăng
Begin
phía dưới, gặp thanh StarNumber lên +1, và
ngang thì bật lên. bổ sung thêm 1 sao
Kiểm soát thời gian clone trên màn hình.
chơi TimeCounter.
Bóng gặp thanh ngang 
Mỗi lần thời gian vượt tăng điểm số +5. Clone
qua bội của 15 thì tăng
điểm số + 3.
Bóng rơi xuống Giảm StarNumber -1 và
Mỗi lần điểm số vượt dưới, mất 1 lượt xóa 1 Clone bên trái trên
quá 200, 400, … thông chơi. màn hình.
báo tặng lượt chơi
bằng thông điệp Bóng rơi xuống dưới,
Bonus. nếu hết lượt thì thông Thể hiện giá trị
báo End kết thúc điểm số bằng chữ
Bonus cuộc chơi. tại góc trái màn
hình.
End
Mặc định ở chế

độ ẩn, không Chuyển động ngang theo
hiện trên màn điều khiển bàn phím của
hình. người chơi.
Nhận thông điệp End thì

hiển thị, phát âm thanh
Game Over và ra lệnh
dừng tất cả cuộc chơi.
Sau đây là phần mô tả chi tiết chương trình.
Chương trình của sân
khấu.
Thiết lập các giá trị ban đầu cho

Điểm số, Thời gian hệ thống,
truyền thông điệp Begin để bắt
đầu trò chơi.
Sau đó điều hành các tham số
này, thưởng điểm và tăng lượt
chơi cho người dùng.
- Nếu thời gian chơi vượt qua
các bội của 15 thì tăng điểm số
+3.
- Nếu điểm số vượt quá 200,
400, … thì thông báo thưởng
lượt chơi bằng cách truyền thông
điệp Bonus.
Chương trình của Bóng sau khi nhận

thông điệp Begin.
Bóng rơi từ phía trên xuống, nếu

gặp thanh ngang thì bật lên.
- Nếu gặp thanh ngang thì tăng
điểm lên 5.
- Nếu bóng bị rơi xuống phía
dưới:
+ Nếu còn lượt thì sẽ thông báo
giảm lượt chơi thông qua 1 biến
nhớ StarChange.
+ Nếu hết lượt thì truyền thông
điệp End để kết thúc chương
trình.
Chương trình gốc của Ngôi sao
(Star).
Thiết lập các giá trị ban đầu như

StarNumber.
Sau đó sẽ khởi tạo quá trình tạo
5 Clone và thể hiện các ngôi sao
clones này trên màn hình tại góc
phải trên.
Các ngôi sao clone được thiết
lập và qui định bởi biến riêng
CloneID.
Ngôi sao gốc có CloneID = 0,
các ngôi sao clone có CloneID >
0.
Chương trình của Ngôi sao

(Star) khi gặp sự kiện Bonus.
Nếu gặp thông điệp Bonus

(tăng lượt), kiểm tra và tăng
StarNumber lên 1 đơn vị.
Sau đó khởi tạo 1 clone mới
có CloneID = StarNumber
và thể hiện clone này trên
màn hình.
Chương trình Clone của

Clone
Ngôi sao (Star).
Luôn kiểm tra nếu có thông

tin về giảm lượt (nếu
StarChange = 1) thì tìm đến
Clone có CloneID cao nhất
và xóa Clone này trên màn
hình, sau đó giảm
StarNumber đi -1.
Chương trình điều khiển Thanh Chương trình của nút Game Over.
ngang.
1. Giả sử có 2 biến nhớ Time và Timer cùng để đo thời gian theo giây. Hai biến
này cùng được thiết lập như sau.
Nhưng 2 biến nhớ này được đi bằng 2 cách khác nhau như 2 đoạn chương trình
sau.
Hỏi biến nhớ nào đo thời gian chính xác hơn?

2. Đoạn chươn trình sau có chức năng tạo các phân thân của nhân vật chính khi
nhận được thông điệp Start Game. Biến nhớ riêng CloneID để phân biệt nhân vật
chính với CloneID = 0 và các phân thân với CloneID > 0.
Chương trình trên đúng hay sai, nếu sai thì sai ở đâu và cần sửa như thế nào?
3. Thiết kế dữ liệu và viết chương trình ngắn mô tả các thuật toán sinh dữ liệu
ngẫu nhiên sau:
a. Sinh 1 bộ k phần tử ngẫu nhiên lấy từ N số {1, 2, 3, …, N}.
b. Tương tự bài trên, sinh ngẫu nhiên bộ k phần tử (a1, a2, …, ak) từ N số {1, 2, 3,
…, N} sao cho thỏa mãn:
a1 < a2 < …. < ak.
c. Sinh k cặp số khác nhau từng đôi một:
(a1, b1 ), (a2 , b2), …, (ak , bk) từ bộ N số {1, 2, 3, …, N}. Điều kiện để thực hiện
thuật toán này là k < N/2.
d. Tương tự bài trên, sinh k cặp số khác nhau từng đôi một
(a1, b1 ), (a2 , b2), …, (ak , bk) từ bộ N số {1, 2, 3, …, N} với điều kiện:
a1 < b1 < a2 < b2 < … < ak < bk.
4. Thiết kế dữ liệu và viết chương trình mô tả các thuật toán, bài toán sau.
a. Input: N; Output: thông báo N có phải là số nguyên tố hay không.
b. Input: N; Output: P, ở đây P là số nguyên tố nhỏ nhất > N.
c. Input: N; Output: Khai triển N thành tích các ước số nguyên tố,
Ví dụ N = 12, Output: 2.2.3.
d. Input: dãy n số a1, a2, …, a n. Gọi dãy này là dãy A.
Output: Giá trị số maximun của dãy A.
e. Input: dãy n số a1, a2 , …, a n. Gọi dãy này là dãy A.
Output: Dãy con liên tục đơn điệu tăng lớn nhất của A.
f. Input: dãy n số a1, a2, …, a n. Gọi dãy này là dãy A.
Output: Dãy con không cần liên tục đơn điệu tăng lớn nhất của A.
5. Viết 1 thủ tục với nhân vật Number (như trong phần 5 của chủ đề này):
Show Number <N> center at <X, Y>.
Thủ tục này sẽ hiển thị bằng hình ảnh số N tại vị trí (X, Y) nhưng lấy điểm này
làm tâm của số được thể hiện.
Ví dụ Show Number <12345> center at <0, 0> sẽ thể hiện số 12345 tại vị trí
(0,0) như sau:
12345
Tọa độ (0, 0) sẽ ở vị trí
tâm của số 12345.
Chủ đề 4.
Thiết kế một số phần mềm quen thuộc
Mục tiêu:
- Thiết kế một số phần mềm giáo dục quen thuộc, từ dễ đến khó để rèn luyện các
kỹ năng cơ bản thiết kế phần mềm.
Nội dung chính
1. Chương trình Bút vẽ màu hoàn chỉnh
Thiết lập chương trình mô tả chức năng vẽ bằng bút vẽ tự do với bảng màu cho
trước. Chương trình này sẽ mở rộng và tổng quát hóa các ví dụ mô phỏng bút vẽ
mà chúng ta đã học.
Butvetudo.sb2
Yêu cầu ban đầu cho chương trình.

- Chương trình mô phỏng bút vẽ tự do, nhưng yêu cầu thao tác vẽ là nhấn giữ và
rê chuột.
- Có bảng màu và 1 nút hiện màu hiện thời đang vẽ.
- Có nút xóa màn hình vẽ lại.
- Có nút điều khiển độ rộng của bút vẽ.
Thiết kế các nhân vật chính.
Hình s
au mô tả các nhân vật tối thiểu, ban đầu của chương trình.
Các nhân vật của chương trình. Có thể chia

thành các nhóm sau:
- Bút vẽ.
- Các nút dùng để thiết lập màu (tròn).
- Nút màu hiện thời (hình vuông).
- Nút Clear dùng để xóa màn hình.
Chú ý:
- Nhân vật Bút vẽ cần có tâm nằm tại vị trí đầu bút.
- Riêng nhân vật ColorButton sẽ có 8 trang phục tương ứng với 8 màu của các
nhân vật màu Color1, …, Color8.
Nhân vật ColorButton có đúng 8

trang phục có màu sắc trùng với các
nút - nhân vật Color1, Color2, ….,
Color8. Đặt tên các trang phục này
đúng với tên nhân vật tương ứng.
Điều khiển rê chuột, kéo thả chuột trên màn hình.

Để mô tả việc đặt bút vẽ khi rê chuột chúng ta dùng 2 hàm, biểu thức logic
và để xác định thời điểm hạ bút và nhấc bút.
Đoạn chương trình mô tả bút vẽ tự do trên màn

hình, sử dụng các sự kiện cho hạ
bút và để nhấc bút.
Sơ đồ hoạt động.
Sơ đồ hoạt động của chương trình này khá đơn giản như sau:
Thông điệp Clear,

thục hiện lệnh
Thông điệp Color, Clear - xóa màn
thiết lập màu bút hình vẽ.
vẽ.
Thông điệp Colorx, Đồng bộ pen size

thiết lập trang phục Rê chuột để với giá trị biến nhớ
theo màu tương vẽ tự do. Width.
ứng.
Thay đổi
trang phục.
Nhận xét: đây là một chương trình khá đơn giản nhưng có nhiều ý nghĩa thực tế.
Lập trình chi tiết.
- Điều khiển các nút bảng màu.
Khi nháy chuột lên một nút màu, nút này sẽ gửi thông điệp tương ứng để bút vẽ
đổi màu vẽ. Chương trình điều khiển, ví dụ nút Color1 như sau:
Lệnh này sẽ làm cho các nút này

luôn hiển thị ở lớp trên cùng.
- Nút ColorButton khi nhận các thông điệp này sẽ chuyển trang phục tương ứng.
Đưa nút lên lớp trên cùng,

thiết lập màu mặc định.
Nhận được các thông điệp sẽ

thay đổi trang phục có màu
sắc tương ứng.
- Khi nháy lên nút Clear, thông điệp Clear sẽ được gửi đi để bút vẽ xử lý làm
sạch màn hình.
Lệnh này sẽ làm cho nút này luôn

hiển thị ở lớp trên cùng.
Lập trình chi tiết điều khiển bút vẽ.

- Thiết lập chế độ pen up, pen down dựa vào cảm biến kéo thả chuột trên màn
hình.
Kỹ thuật nhận
biết sự kéo thả
chuột trên màn
hình.
- Thiết lập các giá trị ban đầu:
Thiết lập bút vẽ ở lớp

dưới.
Thiết lập màu và độ rộng

bút vẽ mặc định.
- Điều khiển bút vẽ luôn gắn với con trỏ chuột, di chuyển cùng chuột máy tính.
Kích thước bút vẽ sẽ luôn đồng bộ với biến nhớ Width.
Thiết lập bút vẽ luôn gắn

với con trỏ chuột.
Thiết lập độ rộng bút vẽ

luôn bằng Width.
- Xử lý các thông điệp khi nhận được, bao gồm các thông điệp thay đổi màu sắc
và thông điệp làm sạch màn hình.
2. Trò chơi, phần mềm, kỹ thuật bắn súng
Phần mềm - trò chơi bắn súng đơn giản sau sẽ giúp em hình thành các tư duy ban
đầu của việc thiết kế các trò chơi loại này. Kỹ thuật trọng tâm của chương trình là
bắn súng.
Bansung.sb2
Giao diện tượng trưng
của chương trình. Nhân
vật chính là khẩu súng
và các con chim đen.
Nhiệm vụ của người
chơi là bắn đạn trúng
càng nhiều chim đen
càng tốt. Nếu súng bị va
vào chim đen thì thua.
Phần lõi chính của chương trình là qui trình "bắn súng". Mô tả như sau: khi bấm
phím Space, viên đạn sẽ bay ra từ nòng súng và đi thẳng. Người chơi cần điều
khiển súng sao cho hướng đến đúng các con chim đen xuất hiện trước mặt.
Hình ảnh súng, viên

đạn được bắn ra từ
đầu nòng súng và
chim đen.
Yêu cầu cụ thể của chương trình như sau:

- Người dùng sẽ dùng phím để điều khiển súng chuyển động lên, xuống, phải, trái
trên màn hình.
- Nhấn phím Space báo hiệu Shot (bắn). Đạn sẽ bắn ra từ đầu nòng súng về phía
phải màn hình. Nếu gặp chim đen thì nổ tung và tăng điểm lên 10 (chim + đạn sẽ
biến mất). Nếu đạn gặp máy bay sẽ bị trừ 20 điểm, máy bay sẽ bị rơi xuống đất.
- Máy bay xuất hiện ngẫu nhiên từ bên trái và bay sang bên phải (với vận tốc nhỏ
hơn vận tốc của đạn).
- Nếu để súng chạm vào chim đen sẽ thua, gửi thông điệp Over để kết thúc
chương trình. Khi đó nút Game Over sẽ xuất hiện.
- Các tòa nhà được sắp xếp xuất hiện ngẫu nhiên. Mây sẽ xuất hiện ngẫu nhiên và
trôi từ phải sang trái trên màn hình.
Các nhân vật của

chương trình.
Thiết kế nhân vật.
Sau đây là danh sách chi tiết các nhân vật của chương trình.
Hình ảnh Tên nhân vật Mô tả ý nghĩa Ghi chú
Đạn Đạn được bắn ra từ nòng súng khi Viên đạn
bấm phím Space. Sử dụng kỹ cần bắn ra
thuật clone để điều khiển việc bắn từ vị trí đầu
súng này. Mỗi lần bắn được nòng súng.
thưởng 1 điểm.
Súng Người chơi sẽ điều khiển súng Chú ý vị trí
lên, xuống, sang phải, trái trên tâm của
màn hình để tránh chim đen và để súng chính
bắn trúng chim đen càng nhiều là vị trí xuất
càng tốt. phát của
viên đạn.
Máy bay Máy bay sẽ bay từ trái sang phải
(ariplane) màn hình một cách ngẫu nhiên và
có tốc độ chậm hơn đạn.
Nếu đạn bắn trúng máy bay thì
máy bay sẽ đâm đầu rơi xuống đất
và bị trừ 20 điểm.
Chim đen Chim đen sẽ xuất hiện ngẫu nhiên Sử dụng kỹ
từ bên phải và bay sang bên trái. thuật clone
Nếu chim đen va chạm vào súng để xử lý
thì chương trình lập tức dừng lại chim đen.
và hiện nút Game Over.
Tòa nhà Các tòa nhà xuất hiện và đứng im Sử dụng
(building) trên màn hình. lệnh stamp
để vẽ các
tòa nhà này.
Mây (clouds) Các đám mây xuất hiện ngẫu Sử dụng kỹ
nhiên từ bên phải và bay sang bên thuật clone
trái màn hình. để xử lý
mây.
Nút Game Khi súng va vào chim đen thì nút Khi bắt đầu
Over. Game Over xuất hiện và chương chương
trình kết thúc. trình nút
này sẽ ẩn
đi.
Sơ đồ thiết kế chương trình như sau:
Shot
Đạn bắn ra từ
đầu nòng Chim xuất hiện
Thiết lập thông Nếu bấm phím súng. liên tục và bay từ
số ban đầu Space, gửi thông phải sang trái.
scoring = 0 điệp Shot.
Nhận thông điệp Nếu va chạm Nếu va chạm

Over  stop all. với chim đen với đạn thì
thì tăng điểm. tăng điểm.
Máy bay xuất hiện
liên tục và bay từ
trái sang phải. Nếu va chạm
với máy bay
Mây xuất hiện thì trừ điểm và
liên tục và bay từ gửi thông điệp Nếu va chạm
phải sang trái. Máy bay đâm đầu Crash. với súng thì
rơi xuống đất gửi thông điêp
Crash
Over.
Over
Hiển thị nút
Game Over.
Kỹ thuật mô phỏng viên đạn bắn ra từ nòng súng.

Để mô tả được viên đạn sẽ bắn ra từ đầu nòng súng chúng ta cần sử dụng hàm lấy
thuộc tính các nhân vật trong nhóm Cảm biến: . Cần thiết
lập tâm của súng nằm gần đầu nòng súng như hình sau:
Vị trí tâm của súng.
Khi đối tượng đạn chuẩn bị tạo clone, cần 2 lệnh sau để thiết lập đạn sẽ luôn bắn
ra từ đầu nòng súng.
Đoạn chương trình điều khiển viên đạn khi có thông điệp Shot như sau:

a) Điều khiển súng
- Điều khiển súng lên, xuống, sang trái, phải bằng các phím mũi tên.
- Điều khiển khi gặp chim đen thì gửi Game Over và nếu bấm Space thì gừi
thông điệp Shot.
Thông điệp Shot gửi

cho Đạn để mô tả bắn
súng.
Thông điệp Game Over

gửi cho sân khấu.
b) Xử lý thông điệp Game Over
Khi nhận thông điệp Game Over

thì phát âm thanh "Game Over" và
dừng toàn bộ chương trình.
c) Điều khiển thể hiện các tòa nhà
Dùng lệnh stamp vẽ 5 hình ảnh

tòa nhà trên màn hình tại các vị trí
ngẫu nhiên.
d) Điều khiển xuất hiện các đám mây.

Các đám mây sẽ xuất hiện từ bên phải và chuyển động ngẫu nhiên sang cạnh trái.
Có nhiều cách lập trình để thực hiện việc này. Dưới đây là một cách, sử dụng
clone.
Sau mỗi 4 giây, các đám mây Các đám mây clone này sẽ
sẽ được tạo clone tại 1 vị trí được gán vận tốc ngẫu nhiên
ngẫu nhiên bên phải màn và chuyển động sang trái. Nếu
hình. gặp cạnh trái thì tự xóa.
e) Điều khiển bắn đạn

Đạn sẽ được bắn ra từ nòng súng khi nhận được thông điệp Shot. Sử dụng công
nghệ clone để sinh ra các viên đạn bắn ra từ nòng súng.
Biến nhớ riêng ID dùng để phân biệt nhân vật gốc và viên đạn clone. Nhân vật
gốc có ID = 0, viên đạn clone có ID = 1. Chỉ có viên đạn gốc mới tạo ra được đạn
clone để bắn ra từ nòng súng.
Trạng thái ban đầu của nhân vật: ẩn đi, gán ID = 0 và sẵn sàng cho việc bắn súng.
- Nhận được thông điệp Shot, lập tức sinh clone tại vị trí đầu nòng súng. Chú ý chỉ
có nhân vật với ID = 0 mới có quyền sinh clone.
Chỉ viên đạn gốc mới thực

hiện lệnh này.
Thiết lập vị trí tại đầu nòng

súng (tâm của súng).
Thiết lập ID = 1 cho viên đạn.
Phát tiếng nổ và sinh clone.
Thưởng 1 điểm vì đã bắn súng.

Trả lại ID = 0.
- Điều khiển viên đạn bắn ra khỏi nòng với vận tốc cố định về phía trước. Nếu gặp
cạnh thì tự xóa.
- Nếu gặp chim đen thì kêu "pop", chờ 0.3 giây sau mới tự xóa. Thời gian chờ đủ
để chim đen cũng cảm biến được va chạm với đạn để tự chết.
Thời gian 0.3 giây đủ để viên đạn

đi tiếp để chim đen cũng cảm biến
được va chạm này và tự chết.
- Nếu gặp máy bay, lập tức gửi thông điệp Crash, giảm 20 điểm và tự xóa.
Chú ý: có thể lập trình theo hướng khác không cần thông điệp, cho máy bay cảm
biến va chạm với viên đạn.
Ở đây sử dụng cách dùng thông điệp Crash, kết quả sẽ có ngay tức thì.
Nếu viên đạn gặp máy bay thì lập
tức gửi thông điệp Crash, giamr 20
điểm và tự xóa clone.
f) Điều khiển chim đen và xử lý khi bắn trúng chim đen.

- Điều khiển chim đen xuất hiện bằng công cụ Clone.
Sau mỗi 5 giây, chim đen được khởi tạo tại 1 vị trí ngẫu nhiên bên phải màn hình.
Chim đen luôn xuất hiện

ở bên phải màn hình, tại
1 vị trí ngẫu nhiên. Sau
mỗi 5 giây sẽ được khởi
tạo 1 lần bằng clone.
- Chim đen khi xuất hiện sẽ vỗ cánh và chuyển động chậm sang trái. Nếu gặp
cạnh trái thì tự xóa clone.
Trong khi bay chim đen sẽ liên tục vỗ cánh và tự chuyển màu.
Tốc độ chuyển động của chim đen.
Luôn luôn vỗ cánh và đổi màu.
Nếu gặp cạnh trái thì tự xóa.
- Xử lý chim đen khi va chạm với đạn. Nếu gặp đạn thì phát ra tiếng kêu, tăng
điểm số lên 10 và lập tức xóa clone.
Việc tạm dừng 0.3 giây ở đây
cũng có ý nghĩa tương tự: chờ
cho viên đạn cũng cảm nhận
được sự va chạm với chim đen
để cả 2 đều tự xóa khi va chạm
nhau.
g) Điều khiển máy bay

- Máy bay sẽ xuất hiện sau mỗi 5 giây. Xuất phát từ 1 vị trí ngẫu nhiên phía trái,
má bay sẽ
Ẩn đi và thiết lập vị trí ban đầu ở

bên trái.
Chờ 5 giây.
Hiện và bắt đầu bay sang phải

với vận tốc nhỏ hơn viên đạn.
Gặp cạnh phải thì ẩn đi.
Thiết lập lại vị trí ngẫu nhiên bên

cạnh trái và hiện lại sau 5 giây.
h) Xử lý khi đạn bắn trúng máy bay

Khi máy bay trúng đạn (nhận thông điệp Crash) sẽ quay đầu xuống và lao xuống
đất trong 1 giây bởi lệnh glide to. 5 giây sau máy bay sẽ lại xuất hiện ở cạnh bên
trái.
Máy bay lao đầu xuống đất trong

1 giây.
Máy bay ẩn đi sau 5 giây và xuất

hiện trở lại ở cạnh trái màn hình.
3. Flappy Bird
Trò chơi Flappy Bird đã nổi tiếng toàn thế giới.
Trong hoạt động này, em sẽ cùng suy nghĩ để thiết kế 1 phương án đơn giản của
phần mềm này.
Flappy Bird.sb2
Giao diện ban đầu của

trò chơi.
Nháy phím Space để
bắt đầu.
Kịch bản, mô tả trò chơi.

- Trò chơi được bắt đầu khi người dùng bấm phím Space. Trước đó là màn hình
ban đầu của Flappy Bird.
- Tiếp theo, người chơi sẽ phải điều khiển con chim bằng cách nhấn phím Space
để đưa chim đi qua các khe hở của các ống.
- Các ống sẽ lần lượt xuất hiện chuyển động từ phải sang trái màn hình. Tuy nhiên
người chơi sẽ có cảm giác điều khiển chim bay về phía trước.
- Mỗi lần nhấn phím Space, chim lại bay lên và đi được 1 đoạn. Người chơi cần
khéo léo điều khiển chim.
- Nếu chim chạm vào 1 ống khói bất kỳ thì trò chơi kết thúc, xuất hiện dòng chữ
Game Over.
- Điểm số được tính như sau: mỗi khi chim vượt qua được 1 ống khói sẽ tăng 10
điểm, mỗi khi chim bay lên được tăng 1 điểm, nếu chim sống qua được các
khoảng thời gian bội của 30 giây thì sẽ được tăng điểm tỉ lệ thuận với thời gian.
Nhân vật chính của chương trình.
Các nhân vật của chương trình, trong đó chỉ có 2 nhân vật chính là chim (bird) và
ống khói (pipe).
Các nhân vật phụ bao gồm:

Hình Game Over. Nhân vật này chi xuất hiện thì kết thúc chương trình, tức là khi
chim va chạm với ống khói.
Hình Start. Hình ảnh này xuất hiện ngay từ đầu. Sẽ ẩn đi khi bắt đầu chơi, khi
người dùng bấm phím Space.
Hình FappyBird. Hình ảnh này xuất hiện ngay từ đầu. Sẽ ẩn đi khi bắt đầu chơi,
khi người dùng bấm phím Space.
Chú ý:
Ống khói và Chim nên tìm và chọn nhân vật có nhiều trang phục khác nhau.
Với ống khói, mỗi trang phục là 1 hình ảnh ống khói dài từ dưới lên trên và chỉ hở
1 khoảng ngẫu nhiên ở giữa, ví dụ như hình sau. Khoảng trống ở giữa chính là vị
trí cần điều khiển chim bay qua.
Mỗi hình ảnh ống khói có 1

khoảng trống ở giữa để chim
cần bay qua.
Ống khói có nhiều trang phục

khác nhau tương ứng với hình
ảnh trò chơi của chương trình.
Hình ảnh nhân vật Bird có nhiều trang phục hỗ trợ mô tả chim vỗ cánh.
Nhân vật chính Bird có nhiều

trang phục để mô phỏng vỗ
cánh khi bay.
Sơ đồ thiết kế chương trình.
Sơ đồ thiết kế và hoạt động của phần mềm tương đối đơn giản như sau:
Thiết lập các thông

số ban đầu.
Score = 0.
Nếu nhấn Space,

Nhấn phím Space sẽ điều
gửi thông điệp
Start khiển chim bay lên, nếu
Start.
không chim sẽ tự động rơi Tạo Clone với
xuống (chạm cạnh dưới thì trang phục ngẫu
dừng). nhiên, dịch chuyển
sang trái. Nếu gặp
Điểm sổ tăng mỗi khi trạng thái Death
bay lên hoặc qua ống của chim thì dừng.
Hiển thị ngay trên khói.
màn hình. Nếu chạm ống khói thì
kêu Ối, rơi xuống đất
và ra thông điệp Game
Hiển thị trên màn
Ẩn (hide) trên màn Over.
hình khi nhận
hình. thông điệp Game
Game Over
Over.
Điều khiển hoạt động của nhân vật chính (bird) thông qua tham số
Gravity
Chúng ta sẽ thiết lập 1 biến nhớ riêng của nhân vật bird với tên Gravity (dịch:
trọng lực). Tham số này điều khiển khả năng bay lên của chim khi chúng ta bấm
phím Space. Để tạo hiệu ứng mỗi khi em bấm Space, chim sẽ bay lên, sau đó sẽ
từ từ bị rơi xuống, thuật toán như sau:
- Mỗi lần nhấn Space sẽ thiết lập Gravity 1 giá trị cố định > 0 (ví dụ = 5).
- Chim sẽ liên tục thay đổi giá trị tọa độ Y theo Gravity. Như vậy nên Gravity > 0.
chim sẽ bay lên, Gravity < 0, chim sẽ rơi xuống.
- Theo thời gian giá trị của Gravity sẽ liên tục giảm, cho đến khi người chơi bấm
Space thì quá trình giảm kết thúc và Gravity được đặt lại > 0.
Nếu người dùng nhấn Chỉ sau 0.2 giây ban Trong suốt thời gian
phím Space thì lập tức đầu, giá trị Gravity sẽ chơi, chim sẽ thay đổi
gán Gravity = 5. liên tục giảm. Điều này liên tục độ cao (tọa độ
sẽ yêu cầu người chơi Y) theo Gravity. Vậy
phải bấm Space liên tục nếu Gravity > 0 thì
nếu không chim sẽ rơi chim bay lên, nếu
xuống đất. Gravity < 0 thì chim rơi
xuống dưới.
Điều khiển nhân vật chim khi va chạm với ống khói
Nếu va chạm với ống khói, chim kêu "ối" và lập tức rơi thẳng xuống đất. Khi
chạm đất thì ra lệnh dừng toàn bộ chương trình bằng thông điệp Game Over.
Nếu va chạm ống khói, chim kêu ối, dừng tất

cả các đoạn chương trình khác của nhân vật
này.
Đoạn chương trình này mô tả

chim rơi thằng xuống đất, sau
đó sẽ thông báo Game Over và
dừng chương trình.
Tạo dáng cho nhân vật chim bay

Các lệnh sau có tác dụng phụ, làm cho nhân vật chim thêm nổi bật.
Trong khi bay chim luôn thay

đổi trang phục của mình tạo
hiệu ứng vẫy cánh.
Đoạn chương trình này
mô tả dáng điệu của
chim trong khi bay. Tùy
thuộc vào Gravity mà
chim sẽ hướng lên trên,
hướng ngang hoặc hướng
xuống dưới trong khi
bay.
Điều khiển hoạt động của ống khói (pipe)

Chúng ta sẽ sử dụng 1 biến nhớ riêng Death để chỉ trạng thái trước và sau khi va
chạm với chim. Giá trị ban đầu của Death = 0.
Đoạn chương trình chính của

nhân vật ống khói, tự động
sinh clone của mình sau
khoảng mỗi 2-5 giây.
Để mô tả chuyển động các ống khói Nếu ống khói va chạm với chim thì
(clone), có nhiều cách. Ở đây chúng ta lập tức thiết lập lại trạng thái Death
dùng lệnh glide, chuyển động sẽ được = 1 và dừng toàn bộ các chương
mô tả mượt hơn. trình trong cửa sổ này.
Thiết kế biến nhớ hệ thống của chương trình.
Tên biến nhớ Mô tả ý nghĩa Ghi chú
Death Biến nhớ này ghi lại trạng thái của Ban đầu gán Death
chim. Chim sẽ chết nếu Death = 1. = 0.
Ready Biến nhớ mô tả trạng thái của trò chơi. Ban đầu gán
Khi bắt đầu thì Ready = 0. Khi bắt đầu Ready = 0.
chơi (người dùng bấm Space) thì
Score Điểm số của người chơi. Điểm số này Ban đầu gán Score
được tính theo cách sau (phù hợp với = 0.
nguyên bản của trò chơi này).
- Mỗi lền chim bay lên (bấm Space)
được tặng 1 điểm.
- Mỗi khi đi qua được 1 ống khói, được
tặng 10 điểm. Người chơi giữ
được chim sống
- Mỗi lần sống qua được các mốc thời
sót, càng về sau
gian 30 giây thì được tăng số điểm là
càng được nhiều
10*he_so_K. điểm.
he_so_K Biến nhớ này ban đầu gán = 1. nhưng sẽ
tăng 1 đơn vị mỗi khi thời gian trôi đi
được 30 giây.
Gravity Biến nhớ rất quan trọng, mô tả gia tốc
lực hút của trái đất với nhân vật Chim.
timer Biến nhớ hệ thống lưu thời gian chạy Cần có lệnh Reset
của đồng hồ máy tính, tính theo đơn vị timer để tính lại
giây. biến nhớ này.
Lập trình chi tiết

a) Bắt đầu chương trình
Khi bắt đầu chương trình, các biến nhớ hệ thống được thiết lập như sau (tại cửa sổ
của sân khấu). Màn hình chỉ hiện hình ảnh nút Start và hình ảnh flappyBird.
b) Bắt đầu trò chơi, khi người chơi bấm Space.
Chương trình điều khiển như sau:
Nếu Ready = 0 thì thực hiện:

- Thiết lập Ready = 1.
- Reset timer để biến timer bắt đầu tính
thời gian chơi.
- Gửi thông điệp Start.
Trong suốt quá trình chơi, đoạn chương trình sau sẽ điều khiển biến nhớ timer và
kiểm tra nếu thời gian chơi là bội của 30 giây thì tăng điểm cho người chơi.
Nếu thời gian chơi vượt quá các mốc là bội

của 30 giây thì sẽ:
- Thưởng điểm là bội của 10, theo số lần
vượt 30 (càng về sau điểm càng cao).
- Tăng hệ số thưởng lên 1.
c) Lập trình cho Bird

- Khi bắt đầu chương trình, thiết lâp Gravity = 2 và vị trí ban đầu của chim tại tâm
ssan khấu = (0, 0).
- Khi nhận được thông điệp Start, bắt đầu chơi.
Mỗi khi người dùng bấm

Space, thiết lập Gravity = 2
để chim bay lên, đồng thời
thưởng 1 điểm cho người
chơi.
Chim luôn vỗ cánh. Chim sẽ bay lên hay bị Giá trị Gravity luôn bị
rơi xuống phụ thuộc vào giảm liên tục, chim sẽ bị
giá trị Gravity. hút rơi xuống đất.
- Đoạn chương trình sau điều khiển hướng bay của chim tùy theo giá trị của
Gravity. Khi bay lên, đầu chim hướng lên trên, khi bay, rơi xuống đầu chim
hướng xuống dưới.
- Đoạn chương trình điều khiển khi chim va vào ống khói.
Chim sẽ kêu Ối 1 tiếng

rồi quay đầu xuống rơi
thẳng xuống đất.
Khi chạm đất thì gửi
thông điệp Game
Over để kết thúc
chương trình.
d) Điều khiển ống khói
Có nhiều cách để thể hiện các ống khói chuyển động từ phải sang trái màn hình.
Trong chương trình này chúng ta sử dụng kỹ thuật clone để tạo ngẫu nhiên các
ống khói và cho chúng chạy sang cạnh trái bằng lệnh glide to.
- Ngay sau khi bắt đầu phần chính của chương trình (nhận được thông điệp Start),
chương trình sẽ tạo liên tục các clone của ống khói (sau 1 khoảng ngẫu nhiên thời
gian), cho đến khi giá trị Death = 1 thì dừng.
- Các chương trình sau điều khiển ống khói sau khi được tạo ra.
Ống khói sẽ được đặt ở vị trí bên phải, Nếu va chạm với chim thì lập tức gán
chuyển trang phục ngẫu nhiên và chạy Death = 1 và dừng chương trình
sang bên trái trong 5 giây bằng lệnh không sinh clone ống khói nữa.
glide to. Nếu đi được về bên trái, tức
là chim đã bay qua thì tăng 10 điểm.
4. Trình diễn trong bảo tàng
Trong phần này này chúng ta sẽ cùng thiết kế một mô hình chương trình được sử
dụng rất nhiều trong giáo dục, văn hóa, đó là việc mô phỏng trình diễn, giới thiệu
theo trang trí của bảo tàng, triển lãm, nhà văn hóa, …. Một bảo tàng (hay di tích
văn hóa) có nhiều phòng, cảnh. Trong mỗi phòng lại có nhiều hiện vật. Cần có 1
chương trình giúp người dùng có thể tham quan tất cả các phòng, gian hàng và
hiện vật trong bảo tàng này.
Bao tang.sb2
Hình ảnh bản tàng cần
tham quan.
2 em bé là người dẫn
chương trình.
Nhân vật của chương trình là người dẫn chương trình và các hiện vật trong bảo
tàng đó.
Sân khấu chính là các gian phòng của bảo tàng, là nơi chúng ta cần giới thiệu cho
người tham quan.
Cảnh 1 Cảnh 2 Cảnh 3 Cảnh 4
Cảnh 5 Cảnh 6 Cảnh 7 Cảnh 8
Ví dụ trong chương trình cụ thể này, các nền sân khấu đánh số từ 2 đến 8 chính là
các gian phòng chính của bảo tàng. Các hiện vật (nhân vật) được thể hiện bên
trong các phòng này.
Yêu cầu chương trình.
- Bắt đầu chương trình là lời thuyết minh welcome trước khi bắt đầu thời gian
tham quan triển lãm, bảo tàng.
- Trong suốt quá trình khi tham quan qua các phòng, người dùng có thể nháy
chuột lên các hiện vật hoặc vị trí hình ảnh trên màn hình để xem hoặc nghe giải
thích chi tiết.
- Muốn chuyển phòng cần nháy lên 2 em bé người dẫn chương trình để xem
hướng dẫn. Khi xuất hiện các nút Next, Previous thì nháy lên các nút này để
chuyển phòng. Chú ý khi chuyển sang 1 phòng mới thì các nút này không xuất
hiện.
- Qui định cụ thể mỗi hiện vật chỉ xuất hiện đúng tại 1 vị trí trong 1 gian phòng cụ
thể. Như vậy mỗi nhân vật đóng vai trò hiện vật chỉ được phép xuất hiện trên 1
nền sân khấu xác định.
Chú ý: Chương trình này chỉ có thời điểm bắt đầu và không có kết thúc. Người
tham quan có thể khám phá bảo tàng bao lâu tùy thích.
Sơ đồ thiết kế và hoạt động của chương trình như sau:
Nếu click chuột, Nếu click chuột,

gửi thông điệp gửi thông điệp
Do Previous. Do Next.
Phát lời thuyết Do Previous Do Next
minh bảo tàng.
Làm hiển thị các
nút tương ứng.
Chuyển về sân
khấu trước.
Chuyển sân Mỗi khi click chuột, thông

khấu sau. báo hướng dẫn, gửi thông Next
điệp Next.
Click chuột lên
vùng màn hình,
hoặc gửi thông Nhận thông điệp sẽ hiển
điệp, hoặc có lời thị thông tin chi tiết của
thuyết minh trực hiện vật trên màn hình.
tiếp.
Ẩn hoặc hiển thị tùy theo

hình nền sân khấu. Mỗi nhân vật sẽ được điều khiển hiển
thị chỉ trên 1 nền sân khấu.
Kịch bản cụ thể của chương trình.
Một số yêu cầu chung:
- Nhân vật 2 em bé sẽ hiển thị trên tất cả các cảnh nhưng mỗi cảnh sẽ xuất hiện ở
những vị trí khác nhau.
- Mỗi nhân vật (trừ ra 2 em bé) sẽ chỉ hiển thị trên 1 cảnh sân khấu duy nhất, được
mô tả trong bảng sau. Các nhân vật này đóng vai trò là những hiện vật trong bảo
tàng.
- Nháy lên các nhân vật sẽ hiển thị thông tin tương ứng về hiện vật đó.
- Ngoài ra trên mỗi cảnh sẽ có các vị trí mà nếu nháy lên sẽ hiển thị thông tin
tương ứng, ví dụ 1 bức tranh treo trên tường. Bảng sau sẽ mô tả chi tiết các vị trí
đó.
Nhân vật Nền sân khấu Kịch bản
Nhân vật này (Boy and Girl) sẽ phải xuất
hiện ở tất cả các cảnh sân khấu, mỗi cảnh tại
các vị trí cố định khác nhau. Khi nháy lên
nhân vật này thì nhận được thông báo:
Các bạn hãy nháy chuột lên các nút Next,
Previous để xem tiếp.
Cảnh 1 (Khi đó các nút Next, Previous sẽ xuất hiện).
Khi bắt đầu chương trình thì sẽ có âm thanh
giọng nói welcome thể hiện.
Trên cảnh này có 3 vị trí liên kết thông tin là
3 bức tranh.
Tranh bên trái: Đây là bức tranh nhỏ của họa
sĩ Markel từ giữa thế kỷ 16.
Tranh bên phải: Đây là bức tranh phong
cảnh nổi tiếng của họa sĩ Levitan, vẽ đầu thế
Cảnh 2 kỷ 19.
Tranh giữa: thông tin là âm thanh:
Tranh_1_P2.
Nháy lên nhân vật sẽ hiện thông tin: Xe ngựa
cổ các gia đình quí tộc thường dùng.
bức tranh lớn có thông tin như sau:
Đây là bức tranh của tác giả Leonardo da
Vinci, trường phái tân hiện thực thế kỷ 16.
Nháy lên nhân vật sẽ hiện thông tin: Tàu hỏa
chạy than.
Cảnh 3
Nhân vật Nền sân khấu Kịch bản
cái thuyền trắng. Thông tin như sau:
Một mẫu thuyền cổ thế kỷ 15.
Nháy lên nhân vật sẽ hiện thông tin: Thuyền
cổ. Giai cấp quí tộc sử dụng thuyền buồm
này khám phá thế giới biển.
Cảnh 4
bức tranh lớn giữa phòng. Thông tin như sau:
Đây là bức tranh nổi tiếng của danh họa nổi
tiếng thế giới Edouard Manet.
Nháy lên nhân vật sẽ hiện thông tin: Mẫu tàu
hỏa đầu tiên trên thế giới.
Cảnh 5
Một bức tranh nổi tiếng không rõ tác giả của
thể kỷ 15.
Nháy lên nhân vật sẽ hiện thông tin: Mẫu ô
tô đầu tiên.
Cảnh 6
2 người nông dân. Thông tin như sau:
Trang phục người nông dân của châu Âu thế
kỷ 17.
Nháy lên nhân vật sẽ hiện thông tin: Mẫu
trang phục của quí tộc Anh quốc thế kỷ 17.
Cảnh 7
Đây là bức tranh rất quí của danh họa
Picasso.
Nháy lên nhân vật sẽ hiện thông tin: Ô tô cổ,
xuất hiện đầu thế kỷ.
Cảnh 8
Nút này sẽ hiển thị khi người dùng nháy
chuột lên nhân vật 2 em bé. Chỉ hiện ở các
cảnh từ 1 đến 7. (cảnh 8 không hiện).
Nút này sẽ hiển thị khi người dùng nháy
chuột lên nhân vật 2 em bé. Chỉ hiện ở các
cảnh từ 2 đến 8. (cảnh 1 không hiện).
a) Thông điệp Next được gửi khi nào
Thông điệp Next được gửi mỗi khi người chơi nháy chuột lên MC của chương
trình là nhân vật 2 em bé. Thông điệp này có ý nghĩa người dùng muốn chuyển
xem phòng khác của bảo tàng. Có thể xem phòng tiếp theo hoặc quay về phòng
trước đó.
Đoạn lệnh điều khiển 2 em bé gửi thông điệp Next như sau.
b) Điều khiển các nút mũi tên Next, Previous

Nút Next
Toàn bộ chương trình điều khiển nút Next như sau:
Bắt đầu chương trình

luôn ẩn đi.
Nháy chuột lên  gửi
thông điệp Do Next.
Nhận được thông điệp Next

(khi người dùng nháy lên 2
em bé) sẽ hiện lên trừ ra
Cảnh 8.
Khi chuyển cảnh sẽ luôn

ẩn đi.
Nút Previous
Tương tự với nút Previous.

luôn ẩn đi.
Nháy chuột lên  gửi thông

điệp Do Previous.
Nhận được thông điệp Next
(khi người dùng nháy lên 2
em bé) sẽ hiện lên trừ ra
Cảnh 1.
Khi chuyển cảnh sẽ luôn

ẩn đi.
b) Điều khiển các nhân vật đóng vai trò hiện vật
Theo kịch bản trên, mỗi nhân vật (trừ ra 2 em bé) sẽ chỉ hiện ở 1 nền sân khấu.
Chương trình điều khiển các nhân vật này là tương tự nhau.
Sau đây là chương trình điều khiển nhân vật Xe ngựa, nhân vật này sẽ hiện ở
Cảnh 2.
Tự động ẩn đi nếu sân

khấu không là Cảnh 2.
Nhân vật Xe
ngựa.
Hiện lên nếu là Cảnh 2.
Hiện thông tin chi tiết

nếu bị nháy chuột lên.
Với các nhân vật khác lập trình hoàn toàn tương tự.
c) Điều khiển nhân vật 2 em bé (Boy and Girl)
Nhân vật 2 em bé này đóng vai trò MC của chương trình, sẽ hiển thị ở tất cả các
cảnh của bảo tàng.
- Khi bắt đầu chương trình là đoạn âm thanh giới thiệu chung về bảo tàng cần
tham quan, coi như lởi chào mừng (welcome) của chương trình.
- Tại mỗi cảnh (phòng) bảo tàng, nháy lên nhân vật này sẽ làm hiển thị 2 nút mũi
tên để người tham quan chuyển sang phòng khác. Việc này được thực hiện bởi
thông điệp Next. Xem thêm cách xử lý thông điệp Next của 2 nhân vật mũi tên
phía trên.
- Cuối cùng là đoạn chương trình chỉ ra vị trí cụ thể của nhân vật này trong tất cả
các cảnh, nền sân khấu của chương trình.
Sử dụng hàm cảm biến . Hàm này sẽ trả lại số thứ tự của
nền sân khấu (trong danh sách) đang thể hiện trên màn hình. Số thứ tự này được
đánh số từ 1.
Ví dụ, nếu nền sân khấu
là Cảnh 1 thì vị trí của
nhân vật này sẽ phải là
(0, -100).
Điều khiển nhân

vật tại các nền sân
khấu từ 2 đến 7.
Nếu nền sân khấu là

Cảnh 8 thì vị trí của
nhân vật này sẽ phải là
(-150, -100).
- Khi người dùng nháy lên một vùng của phòng triển lãm (nháy lên 1 vị trí màn
hình xác định trước), chương trình sẽ gửi 1 thông điệp tương ứng. Nhân vật MC
sẽ nhận thông điệp và thông báo.
d) Điều khiển nền sân khấu

- Bắt đầu chương trình với nền sân khấu 1, màn hình welcome.
- Xử lý các thông điệp Do Next (chuyển sang cảnh sau) và Do Previous (chuyển
về cảnh trước). Xử dụng các lệnh next backdrop và switch backdrop to <#
number> tương ứng.
Chuyển sang nền sân

khấu sau.
Chuyển về nền sân khấu

trước.
- Đặc biệt nền sân khấu xử lý các liên kết khi người chơi nháy chuột lên 1 vùng
màn hình (trong 1 cảnh sân khấu nào đó) để muốn xem thêm thông tin. Sân khấu
cảm nhận vị trí của con trỏ chuột, kiểm tra và gửi thông điệp tương ứng.
1. Nhận cảm biến 2. Kiểm tra số thứ tự của

nháy chuột. cảnh sân khấu.
4. Gửi thông điệp 3. Kiểm tra tọa độ nháy

tương ứng. chuột trên màn hình.
Thực hiện hoàn toàn tương tự với các liên kết khác.
5. Bút vẽ nâng cao và bài toán vẽ hình mẫu
Chúng ta quay trở lại chương trình Bút vẽ tự do ở trên. Trong chương trình của
bài học trước, chúng ta đã mô phỏng 1 bút vẽ tự do với màu sắc và độ rộng bút có
thể chọn ngay trên màn hình.
Bây giờ chúng ta sẽ mở rộng ra để bổ sung thêm 1 chức năng đặc biệt: vẽ theo các
hình mẫu có sẵn.
Như vậy chương trình sẽ có 2 chế độ làm việc độc lập. Biến nhớ Pain_Type dùng
để phân biệt 2 chế độ này.
- Với Paint_Type = 1, chế độ vẽ tự do như em đã biết trong bài học trước.
- Với Pain_Type = 2, sẽ chuyển sang chế độ vẽ theo hình mẫu. Trên màn hình,
khu vực công cụ, các màu vẽ sẽ được thay thế bằng các hình mẫu. Nháy chuột lên
1 hình mẫu, sau đó nháy lên màn hình để thực hiện vẽ theo hình mẫu đã chọn.
Ve nang cao.sb2
Chế độ vẽ tự do với bút vẽ và Chế độ vẽ theo các mẫu hình có

màu sắc, PaintType=1. sẵn, PaintType=2.
Các hình mẫu sẽ được bổ sung vào chương trình như các nhân vật. Chúng ta cần 1
nút lệnh (nhân vật) nữa để chuyển đổi giữa 2 chế độ vẽ (vẽ tự do và vẽ theo mẫu)
của chương trình.
Các nút lệnh chọn màu trong

chế độ vẽ tự do.
Nút lệnh (nhân vật có tên

PaintType) dùng để chuyển
đổi giữa 2 chế độ vẽ.
Các nút lệnh hình mẫu dùng

trong chế độ vẽ theo mẫu.
Đoạn chương trình sau mô tả đoạn chương trình của nhân vật Paint_Type dùng để
chuyển đổi giữa 2 chế độ vẽ. Nháy chuột lên nút này để thay đổi chế độ vẽ.
Các thông điệp Type1 và Type2 có tác

dụng làm cho các nhân vật tương ứng
với 2 chế độ vẽ này tự động ẩn, hiện
đúng lúc.
Kỹ thuật vẽ hình theo mẫu - nhân vật

Chúng ta sẽ mô tả nhanh kỹ thuật vẽ theo hình mẫu là 1 nhân vật như sau.
Bước 2: nháy chuột lên màn

hình để vẽ hình này. Có thể vẽ
liên tục nhiều hình.
Bước 1: nháy chuột lên

nhân vật để xác định hình
muốn vẽ.
- Khi nháy chuột lên nhân vật, đoạn chương trình sau sẽ gán cho biến tổng thể
Object-Selected 1 giá trị duy nhất xác định đúng ID của nhân vật này.
Khi nháy chuột lần tiếp theo trên màn hình 2 đoạn chương trình sau sẽ thực hiện
việc vẽ đúng nhân vật này bằng lệnh stamp.
Khi nháy chuột

lên màn hình
sẽ ghi lại tọa
độ vị trí chuột
vào biến X, Y.
Gửi thông điệp cho Chương trình của nhân vật

nhân vật tương ứng. hình vẽ: di chuyển tới điểm
(X, Y) và thực hiện stamp.
Chương trình của nhân
vật Bút vẽ (Pencil).
Mô tả chi tiết chương trình Bút vẽ nâng cao.
Chương trình Bút vẽ tự do nâng cao sẽ có 2 chế độ vẽ: (1) vẽ tự do và (2) vẽ theo
mẫu. Có 1 nút (nút PaintType) dùng để thay đổi giữa 2 chế độ vẽ này.
Chế độ vẽ tự do. Chế độ vẽ theo mẫu.
Chế độ vẽ tự do (hoạt động như đã mô tả của chương trình 1: Bút vẽ tự do):

- Bảng màu bao gồm 8 màu và 1 nút (hình vuông) mô tả màu hiện thời.
- Nút Clear và biến nhớ Width có thể thay đổi giá trị là độ rộng của bút vẽ.
- Đầu bút luôn gắn với con trỏ chuột.
- Kéo thả chuột để tiến hành vẽ tự do.
- Dùng phím phải, trái có thể thay đổi giá trị biến nhớ Width.
Chế độ vẽ theo mẫu:
- 8 hình mẫu nằm phía dưới.
- Nút Clear và biến nhớ Size có thể thay đổi giá trị là độ đo kích thước (theo %)
của hình muốn vẽ.
- Đầu bút luôn gắn với con trỏ chuột.
- Dùng phím phải, trái có thể thay đổi giá trị biến nhớ Size.
- Thao tác vẽ mẫu như sau: nháy chuột lên hình mẫu phí dưới, sau đó nháy chuột
lên vùng vẽ phía trên để vẽ hình này.
Thiết kế nhân vật của chương trình.
Nhân vật bút vẽ chính.
Các nhân vật tương ứng với chức năng vẽ tự do

(Paint_Type=1).
Các nhân vật là 8 hình ảnh mẫu tương ứng với

chức năng vẽ hình mẫu (Paint_Type=2).
Nút Clear. Nháy lên sẽ xóa, làm sạch màn hình.
Nhân vật PaintType. Nhân vật này có 2 trang
phục tương ứng với 2 chế độ vẽ. Nháy chuột lên
nhân vật sẽ chuyển đổi giữa 2 chế độ này.
Biến nhớ hệ thống.
Tên biến nhớ Mô tả ý nghĩa Ghi chú thêm
Paint_Type Biến nhớ lưu trạng thái của chương
trình.
= 1, trạng thái vẽ tự do.
= 2, trạng thái vẽ theo mẫu.
Width Biến nhớ lưu độ rộng của bút vẽ. Nhận giá trị từ 1
đến 50.
Size Biến nhớ lưu kích thước (%) dùng để vẽ Nhận giá trị từ 5
mẫu đang thực hiện. đến 100.
Object-selected Dùng trong chế độ vẽ mẫu. Chỉ ra số Mặc định gán = 0
thứ tự của mẫu hình đang vẽ. (chưa chọn).
CurrSize Dùng trong chế độ vẽ mẫu. Dùng làm
biến trung gian khi tiến hành vẽ 1 mẫu.
X, Y, X- Các biến nhớ trung gian sử dụng khi vẽ
current, Y- mẫu.
current
Sơ đồ thiết kế hệ thống.
PType1 PType2
Gửi thông điệp Click chuột. Click chuột. Gán đối tượng đã
ColorX, bút sẽ chọn cho biến
nhận và chọn màu. Object-Selected.
Click chuột.
Gửi thông điệp
PaintNOW. Nhân
Kéo thả chuột  vật tương ứng sẽ vẽ
vẽ tự do với màu stamp tại vị trí đã
đã chọn và độ click chuột với kích
rộng bút lấy từ thước lấy từ biến
biến Width. Size.
Dùng phím phải, trái để thay
đổi giá trị các biến nhớ này.
(a) Điều khiển nhân vật PaintType.
Bắt đầu chương trình thiết

lập chế độ PType1, chế độ
vẽ tự do.
Khi người dùng nháy

chuột lên nhân vật này thì
thực hiện chuyển đổi giữa
2 chế độ vẽ của chương
trình, đồng thời thay đổi
trang phục của nhân vật.
(b) Điều khiển bút vẽ

- Thiết lập chế độ mặc định là vẽ tự do.
- Chuyển đổi giữa 2 chế độ vẽ.
Chuyển sang chế độ

PType2, hiển thị biến
Size, ẩn biến Width.
Chuyển sang chế độ

PType1, hiển thị biến
Width, ẩn biến Size.
- Điều khiển bút vẽ trong chế độ vẽ tự do.
Chỉ ở chế độ Paint_Type =

1 mới gán đầu bút với con
trỏ chuột.
Cảm biến với kéo thả chuột. Khi kéo thả chuột sẽ pen down để tiến hành vẽ.
Không cho phép vẽ ở

vùng phía dưới chỗ bảng
màu.
(c) Điều khiển vẽ theo mẫu

Khi nháy chuột lập tức gửi thông điệp PaintNOW.
Khi nháy chuột, lập tức

lưu vị trí chuột vào biến
X, Y và gửi thông điệp
PaintNOW.
Chú ý: nhân vật hình mẫu
sẽ nhận và xử lý thông
điệp này.
- Điều khiển nhân vật hình mẫu. Tất cả các nhân vật hình mẫu đều có điều khiển
gần như giống nhau.
Nếu nháy lên hình mẫu
này thì gán biến nhớ
Object-Selected.
- Xử lý thông điệp PaintNOW.
- Kiểm tra xem đúng là nhân vật

đang chọn hay không.
- Lưu vị trí hiện thời của hình
mẫu vào 2 biến trung gian: X-
current, Y-currrent.
- Di chuyển đến vị trí (X, Y).
- Thay đổi kích thước theo Size,
thực hiện stamp.
- Trả lại kích thước cũ và quay
nhanh về vị trí ban đầu trước khi
vẽ.
6. Trò chơi hangman
Chúng ta sẽ quay lại 1 trò chơi rất nổi tiếng mà em đã làm quen trong bài học 15
(xử lý xâu ký tự 2), đó là trò chơi Tìm từ Hangman.
Lần này chúng ta sẽ thiết kế trò chơi tổng quát hơn và cho phép người thiết kế có
thể mở rộng nhiều trong tương lai.
Giao diện chương trình mới Hangman lần này sẽ có dạng như hình sau:
Hangman.sb2 Giao diện và cách chơi trò chơi

này tương tự như các phần mềm
Hangman khác, điểm khác là:
- Sử dụng các hình vuông che
khuất chữ bên dưới.
- Độ dài của từ cần tìm có thể
tùy ý.
Các nhân vật sử dụng trong

chương trình.
Các yêu cầu cụ thể của chương trình.

- Chương trình sẽ liên tục sinh tự động bộ dữ liệu cho trò chơi hangman.
- Khi chơi, máy tính sẽ liên tục yêu cầu người chơi nhập 1 chữ cái, nếu chữ cái đó
có trong từ cần tìm, phần mềm sẽ thông báo, ví dụ: "Có 2 chữ cái q" và chương
trình sẽ tự động xóa 2 ô vàng để hiển thị chữ cái q bên dưới.
- Nếu người chơi nhập chữ cái đã đoán thì thông báo "Chữ cái này đã nhập rồi".
- Nếu người chơi nhập chữ cái không có trong từ thì thông báo "Chữ cái này
không đúng".
- Nếu nhập xong toàn bộ các chữ cái của từ, chương trình thông báo chiến thắng
và sau đó lặp lại quá trình chơi từ đầu.
Phân tích thiết kế.
Một vài nhận xét, phân tích ban đầu về chương trình.
-
Danh sách nhân vật.
Hình ảnh Tên nhân vật Ý nghĩa Ghi chú
Square Hình vuông. Hình này có chức Mỗi hình
năng che phủ các chữ cái của từ có kích
cần đoán. Đoán chữ tới đâu, các thướv
hình này sẽ biến mất dần tới đó. 48x48.
Char Nhân vật này có 26 trang phục Có thể mở
tương ứng với 26 chữ cái dùng rộng ra
trong việc thể hiện từ đoán chữ. các chữ
cái và số
khác.
Giáo viên Giáo viên đóng vai trò MC, người
dẫn của chương trình.
Danh sách biến nhớ hệ thống.

Các biến nhớ chính của chương trình.
Stt Tên biến nhớ Ý nghĩa Chú ý
1 Word Biến nhớ lưu từ khóa chính cần (biến nhớ)
tìm của trò chơi. Từ này sẽ được
lấy ngẫu nhiên từ nguồn dữ liệu
WList.
2 WList Mảng dữ liệu chính là nguồn các (list)
từ gốc sẽ được lấy ra sử dụng cho
chương trình.
3 XList Dãy các tọa độ theo trục X để (list)
hiển thị nhân vật Square (hình
vuông) che khuất từ cần tìm.
4 HWList Mảng dữ liệu là dãy các thông tin (list)
gợi ý của các từ cần đoán trong
dãy WList.
Các biến nhớ sau được dùng khi xử lý quá trình đoán từ của
phần mềm.
5 num_char Số lượng các vị trí chữ trong từ (biến nhớ)
Word đúng với chữ người dùng
đã nhập. Biến nhớ này dùng trong
quá trình tương tác đoán từ.
6 num_char_solve Số lượng các chữ đã đoán đúng. (biến nhớ)
7 W-Array Mảng này sẽ lưu các chữ cái (list)
tương ứng của từ Word chính.
Bảng này được tự động tạo ra
ngay sau khi sinh từ khóa Word.
8 Ch-Array Mảng này dùng để kiểm tra xem (list)
các chữ cái tương ứng của Word
đã tìm được chưa trong quá trình
chơi. Bảng này có số phần tử
bằng W-Array và bằng độ dài từ
Word.
Mỗi phần từ của bảng này có ý
nghĩa sau:
= ? nếu ký tự tương ứng chưa
được tìm ra.
= 1 ký tự cụ thể (khác ?) nếu ký tự
tương ứng đã được tìm thấy.
Bảng này được tự động tạo ra
ngay sau khi sinh từ khóa Word.
Ban đầu bảng này bao gồm toàn
các phần tử = ?
9 D-Array Bảng này lưu các chỉ số của các (list)
ký tự khi người dùng đoán đúng 1
chữ cái, các vị trí này sau đó sẽ
được mở ô hình vuông (thông qua
thông điệp DeleteNOW.
Ví dụ nếu người dùng nhập chữ
cái a, trong từ Word có 2 chữ a ở
các vị trí 2, 5 thì bảng D-Array sẽ
có 2 phần tử {2, 5}.

Sơ đồ hoạt động của các nhân vật như sau:
Reset Vẽ giao diện chính

Thiết lập bộ dữ liệu
của chương trình bằng
chính của chương
các hình vuông.
trình.
Paint
Start
Thực hiện tương tác
với người chơi trò Làm ẩn (xóa clone)
chơi. của các chữ cái vừa
Nếu người chơi đoán đoán đúng.
đúng 1 chữ cái.
Delete NOW
Nếu người chơi đoán đúng

Hiển thị từ cần tìm
tất cả các chữ cái của từ,
Reset bên dưới các hình
thông báo chiến thắng và
vuông.
gửi thông điệp Reset.
Kỹ thuật vẽ dãy các ô vuông.
Vì kích thước màn hình bị hạn chế, chúng ta sẽ thiết kế ô vuông có kích thước
48x48, do đó chiều ngang của màn hình chỉ có thể hiển thị được 1 từ 10 ký tự.
Tọa độ các tâm của lưới thể hiện từ khóa có tọa độ theo trục X như sau:
Dãy XList có dữ liệu sau:
-216 -168 -120 -72 -24 24 72 120 168 216
Dãy các hình vuông được tạo ra bằng công cụ clone của nhân vật Square. Dãy các
hình này sẽ được đánh số từ 1 tính từ bên trái.
Để đánh số các clone này chúng ta sẽ sử dụng biến nhớ riêng của Square với tên
biến là CloneID.
Đoạn chương trình mô tả vẽ lưới ô vuông tương ứng với từ khóa Word bằng việc
tạo clone cho nhân vật Square. Kỹ thuật dùng clone để vẽ lưới các hình vuông
lần đầu tiên được sử dụng trong chương trình này và còn được sử dụng trong
nhiều chương trình khác của Scratch.
Đoạn chương trình của nhân vật Char hiển thị dãy các chữ cái của từ Word theo
lưới (nằm dưới các ô vuông) như sau, sử dụng lệnh vẽ stamp.
Thuật toán xử lý chính của trò chơi khi tương tác với người chơi.
Thuật toán này sẽ sẽ sử dụng bộ dữ liệu sau để thực hiện.
1 W-Array Mảng này sẽ lưu các chữ cái tương Dãy này sẽ có
ứng của từ Word chính. Bảng này nhiều dài đúng
được tự động tạo ra ngay sau khi bằng độ dài của
sinh từ khóa Word. từ Word.
2 Ch-Array Mảng này dùng để kiểm tra xem Dãy này cũng
các chữ cái tương ứng của Word đã sẽ có nhiều dài
tìm được chưa trong quá trình chơi. đúng bằng độ
Bảng này có số phần tử bằng W- dài của từ
Array và bằng độ dài từ Word. Word.
Mỗi phần từ của bảng này có ý
nghĩa sau:
= ? nếu ký tự tương ứng chưa được
tìm ra.
= 1 ký tự cụ thể (khác ?) nếu ký tự
tương ứng đã được tìm thấy.
Bảng này được tự động tạo ra ngay
sau khi sinh từ khóa Word. Ban
đầu bảng này bao gồm toàn các
phần tử = ?
3 D-Array Bảng này lưu các chỉ số của các ký (list)
tự khi người dùng đoán đúng 1 chữ
cái, các vị trí này sau đó sẽ được
mở ô hình vuông (thông qua thông
điệp DeleteNOW.
Ví dụ nếu người dùng nhập chữ cái
a, trong từ Word có 2 chữ a ở các vị
trí 2, 5 thì bảng D-Array sẽ có 2
phần tử {2, 5}.
Thuật toán sau mô tả các bước thực hiện khi người chơi nhập 1 chữ cái từ bàn
phím để đoán tiếp từ hiện thời. Giả sử ký tự người dùng nhập là Ch.
- Kiểm tra Ch có trong bảng W-Array hay không? Nếu không có thì thông báo
"Chữ đã nhập không đúng",
- Nếu Ch có trong W-Array mà tại vị trí đó phần tử tương ứng của Ch-Array
không là "?" thì thông báo "Chữ này đã nhập rồi".
- Nếu Ch có trong W-Array mà tại vị trí đó phần tử tương ứng của Ch-Array bằng
? thì thực hiện tiếp như sau:
+ Kiểm tra, lăp theo bảng W-Array xem tại những vị trí nào có giá trị = Ch, tại
các vị trí đó sẽ bổ sung chỉ số tìm thấy vào bảng D-Array.
+ Thông báo, ví dụ "Đã tìm thấy <k> chữ a", với k là độ dài của mảng D-Array
(chính là giá trị biến nhớ num_char), sau đó gửi thông điệp DeleteNOW để nhân
vật hình vuông sẽ thực hiện việc xóa clone để mở ra các vị trí tương ứng với các
chỉ số có trong bảng D-Array.
Đoạn chương trình của nhân vật Square khi xử lý thông điệp DeleteNOW như
sau:
Thực hiện lệnh lặp

theo mảng D-Array,
kiểm tra nếu
CloneID = chỉ số
trong bảng này thì
xóa clone tương ứng.

a) Sân khấu là nơi ra thông điệp Reset đầu tiên
b) Giáo viên xử lý thông điệp Reset, thực hiện các công việc chuẩn bị dữ liệu gốc
Thủ tục Init.Hangman có chức năng chuẩn bị dữ liệu gốc như sau:
- Sinh ngẫu nhiên Word lấy từ mảng WList.
- Gán HWord cho thông tin trợ giúp tương ứng của từ Word.
- Thiết lập mảng W-Array chứa tất cả các chữ cái của từ Word. Mảng này có độ
dài bằng chính độ dài của từ Word.
- Thiết lập mảng Ch-Array có độ dài bằng độ dài Word và chứa mặc định ban
đầu toàn các dấu ?. Phần tử của mảng Ch-Array này chỉ ra chữ cái tương ứng của
Word đã được đoán chưa, nếu = ? có nghĩa là chưa được đoán ra.
Chương trình chi tiết của thủ tục này như sau:
Sinh Word và
HWord. Word lấy
ngẫu nhiên từ mảng
WList.
Thiết lập các giá trị

ban đầu của 2 mảng
W-Array và Ch-
Array.
Đoạn chương trình mô tả giáo viên nhận và xử lý thông điệp Reset như sau. Ngay
sau khi thực hiện thủ tục Init.Hangman thì gửi thông điệp Paint và thông báo
người dùng sẵn sàng cho việc đoán từ.
Thông báo của Giáo

viên chuẩn bị bắt đầu
trò chơi đoán từ
Hangman.
c) Nhận được thông điệp Paint, nhân vật Square sẽ tiến hành tạo các hình vuông
chuẩn bị cho chương trình đoán từ Hangman.
Vẽ xong hình sẽ gửi thông điệp Start.
Chúng ta sẽ dùng kỹ thuật Clone để tạo ra các hình vuông này. Các clone này
được đánh số từ 1 đến 10 tính từ bên trái. Biến nhớ riêng CloneID dùng để đánh
số thứ tự riêng này.
Nhân vật gốc sẽ có CloneID = 0.
Các hình vuông trên màn hình đều là Clone sẽ có CloneID đánh số từ 1, 2, 3, ….
Khi nhận được thông điệp Paint (khi đó trên màn hình đã hết sạch các Clone),
nhân vật Square gốc sẽ sinh ra các Clone và hiện trên màn hình tại dãy các vị trí
xác định bởi mảng XList.
Đoạn chương trình hiện các hình vuông như sau.
Gán CloneID = 0 cho nhân
vật gốc.
Sinh các hình vuông clone, mỗi

hình vuông gán CloneID riêng từ
1 đến 10, tại các vị trí của dãy
XList. Số lượng Clone bằng độ
dài từ Word.
Gán CloneID = 0 lại cho nhân vật

gốc và gửi thông điệp Start.
d) Nhận được thông điệp Start, nhân vật Char sẽ vẽ các chữ cái của từ lên màn
hình, nằm bên dưới các hình vuông. Nhân vật này luôn ẩn trên màn hình.
Tại các vị trí tương ứng

với tọa độ của XList,
chuyển trang phục đến chữ
cái tương ứng và thực hiện
lệnh stamp để vẽ chữ.
e) Nhận được thông điệp Start, Giáo viên bắt đầu tiên hành tương tác cho cuộc
chơi đoán từ. Đây là phần lõi và phức tạp nhất của chương trình.
Sơ đồ thuật toán của phần tương tác này nhu sau:
Đặt num_char_solve = 0
Thuật toán
xử lý quá Lặp lại cho đến khi num_char_solve = độ dài Word.
trình tương Cho người dùng nhập 1 chữ cái. (Init.Hangman)
tác đoán từ Xử lý chữ cái đó. (Process.Hangman).
của trò
chơi Nếu đoán đúng thì xóa các ô vuông tương ứng (bằng
cách gửi thông điệp DeleteNOW.
Hangman.
Kết thúc lặp.
Thông báo đã đoán xong từ cần tìm. Gửi thông điệp Reset
để bắt đầu 1 bài mới.
Đoạn chương trình xử lý chính như sau.
Thủ tục Init.Hangman.

Khi nhập 1 chữ cái Ch từ bàn phím chỉ có thể xảy ra 3 trường hợp sau:
(1) Chữ cái Ch không có trong Word.
(2) Chữ cái Ch có trong Word nhưng đã được lật rồi (đoán rồi).
(3) Chữ cái Ch có trong Word và chưa được lật.
Thủ tục Init.Hangman sẽ xử lý các trường hợp (1), (2). thủ tục
Process.Hangman sẽ xử lý nốt trường hợp (3).
(1) Ch không có trong W-

Array, thông báo nhập chữ
sai, cần nhập lại.
(2) Ch có trong Ch-Array,

tức là đã được nhập rồi,
thông báo đã nhập rồi, cần
nhập lại chữ khác.
Thủ tục Process.Hangman.
Thủ tục này xử lý trường hợp (3): (3) Chữ cái Ch có trong Word và chưa được lật.
Điều kiện (3) tương đương với: Ch có trong W-Array nhưng vị trí tương ứng
trong bảng Ch-Array là ?.
Cách xử lý như sau:
Liệt kê tất cả các vị trí trong W-Array mà xảy ra (3), với mỗi trường hợp như vậy
thì cập nhật giá trị tương ứng trong Ch-Array bằng Ch và cập nhật số thứ tự này
vào mảng D-Array.
Tính giá trị Num_Char = số các chữ cái đã tìm thấy cho trường hợp (3).
Thuật toán này có thể viết dưới dạng giả code đơn giản như sau:
Xóa làm sạch mảng D-Array.
Thuật toán xử
lý khi chữ cái Gán lại Num_char = 0.
người dùng Lặp theo chiều dài mảng W-Array, theo từng vị trí
nhập (Ch) thỏa index, tính từ 1.
mãn điều kiện
Nếu vị trí tương ứng chỉ số index trong W-Array là
(3).
Ch và Ch-Array là ? thì
Thay thế ký tự ? bằng Ch trong Ch-Array.
Tăng Num_Char lên 1.
Tăng Num_Char_Solve lên 1.
Bổ sung index vào bảng D-Array.
Kết thúc Nếu.
Kết thúc lặp.
Chương trình Scratch mô tả thuật toán trên.
d) Square xử lý thông điệp DeleteNOW.
Khi nhận thông điệp DeleteNOW, nhân vật Square sẽ tiến hành xóa tất cả các
Clone có CloneID trùng với các chỉ số có trong mảng D-Array.
Chương trình đơn giản như sau.
Kiểm tra CloneID

nếu trùng với số
trong D-Array thì xóa
Clone.
7. Trò chơi mưa từ
Trong hoạt động này chúng ta sẽ cùng thiết kế 1 trò chơi giáo dục đơn giản nhưng
có nhiều ý nghĩa dành cho các bé nhỏ tuổi, trò chơi Mưa từ (Word Rain).
Mua tu.sb2
Giao diện của chương trình
và danh sách các nhân vật
chính. Nhân vật chính là 1
hình vuông (tên Square) có
các trang phục nhiều màu
sắc khác nhau.
Các nhân vật chính của

chương trình.
Mô tả hoạt động, yêu cầu của chương trình.

- Màn hình khởi động của chương trình.
- Chương trình bắt đầu chạy khi người dùng bấm phím Space hoặc nháy chuột bất
kỳ trên màn hình.
- Từ phía trên của màn hình, các hình vuông với màu sắc khác nhau sẽ rơi xuống,
mỗi hình kèm theo 1 từ (vì vậy chúng ta gọi là mưa từ). Các từ này có thể giống
nhau và được lấy ngẫu nhiên từ 1 từ điển từ cho trước.
- Người chơi phải quan sát và ngăn không cho các hình này rơi xuống phía dưới.
Nếu bị xuống thì bị trừ đi 5 điểm.
- Người dùng có thể thực hiện 1 trong 2 cách sau:
(a) Nháy chuột nhanh lên các hình vuông để chúng biến mất. Cách này được 1
điểm.
(b) Gõ nhanh từ đang rơi trên màn hình. Nếu gõ đúng 1 từ, từ và hình tương ứng
sẽ biến mất, điểm số sẽ tăng cao hơn, 25 điểm.
Để mô phỏng các từ được rơi xuống cùng hình ảnh nhân vật Square, chúng ta sử
dụng kỹ thuật clone. Để cho từ có thể gắn kết liền với hình, chúng ta tạo 1 biến
nhớ riêng của nhân vật này với tên Word để lưu trữ các từ này. Khi hình rơi
xuống cùng với từ, chúng ta sẽ có cảm giác mưa từ.
CloneID - chỉ số riêng của hình.

Word - từ luôn đi kèm hình.
Bộ dữ liệu chính của chương trình:

Stt Tên biến Ý nghĩa Chú ý
nhớ
1 WList Mảng, bộ từ điển các từ gốc dùng (list)
trong chương trình. Các từ được sinh
ngẫu nhiên từ danh sách này.
2 Word Biến nhớ này sẽ lưu trữ từ được sinh ra Biến nhớ riêng
(lấy từ WList) và gán cứng với clone của nhân vật hình
hiện thời. vuông (Square)
3 CloneID Biến nhớ riêng của Square dùng để gán Biến nhớ riêng
cho các clone khi sinh ra. của nhân vật hình
vuông (Square)
Các đoạn chương trình chính xử lý nhân vật Square khi tạo clone và rơi xuống
như sau.
Sau mỗi 3 giây 1 clone lại được khởi Trong suốt quá trình rơi xuống, lệnh
tạo. Clone này trước khi xuất hiện sẽ say <Word> luôn được thực hiện đảm
được chuyển màu sắc và gán từ Word bảo từ này luôn được gắn với hình
được sinh ngẫu nhiên từ từ điển trong suốt quá trình mưa từ.
WList.
Sơ đồ thiết kế.
Sơ đồ hoạt động của chương trình như sau:
Nếu người dùng bấm

Liên tục yêu Space hoặc nháy chuột
Bắt đầu sinh liên tục thì gửi thông điệp
cầu người chơi
clone và rơi xuống phía Start Game.
nhập nhanh các
dưới màn hình. Nếu
từ. Khi nhập Start Game
chạm đáy thì biến mất và
xong 1 từ, gửi
bị trừ 5 điểm.
thông điệp
QuickDone để Nhận được thông điệp
yêu cầu kiểm Start Game thì ẩn khỏi
tra. màn hình.
QuickDone Nếu người dùng nháy
lên hình và từ đang
rơi thì cũng xóa clone
và tăng 1 điểm. Nhận được thông điệp
Start Game thì ẩn khỏi
Kiểm tra nếu từ đã
màn hình.
nhập là đúng thì xóa
clone tương ứng trên
màn hình, tăng 25 Nhận được thông điệp Game
điểm. Over thì hiện trên sân khấu, thực
hiện stop all, dừng chương trình.
Đồng hồ thời gian (biến
nhớ Timing) luôn chạy,
nếu quá 2 phút thì gửi Game Over
thông điệp Game Over và
dừng chương trình.

a) Bắt đầu chương trình.
Sân khấu.
Thiết lập các giá trị ban đầu

cho điểm số (Score) và thời
gian (Timing).
Hình vuông.
Thiết lập CloneID = 0 cho

nhân vật gốc.
Nút Title, banner chính.
Khi người dùng nháy chuột bất kỳ hoặc bấm Space thì bắt đầu chơi bằng cách gửi
thông điệp Start Game.
Lệnh này có nhiệm vụ làm

cho chương trình đợi chậm
lại 1 giây. Khi nháy lên nút
lá cờ thì bắt đầu chương
trình nhưng chưa Start
Game.
b) Sau thông điệp Start Game.

Nhân vật hình vuông khi nhận được thông điệp này sẽ bắt đầu sinh liên tục các
Clone của mình.
Hình vuông gốc liên tục

tạo ra các clone của mình
với: CloneID tăng dần từ 1,
Word lấy ngẫu nhiên từ từ
điển WList, có trang phục
ngẫu nhiên và vị trí xuất
phát ngẫu nhiên từ phía
trên.
Chương trình sau điều khiển hoạt động bình thường của các hình vuông - clone
sau khi được sinh ra. Các hình vuông này sẽ rơi xuống phía dưới. Sau 1 giây sẽ
xuất hiện các từ kèm theo hình vuông.
Hình vuông - clone sẽ rơi 1 giây

xuống vị trí y = 150 và hiện từ bằng
lệnh say.
Các hình vuông sau đó sẽ

rơi xuống từ từ. Nếu rơi
xuống phía dưới thì người
chơi bị trừ đi 5 điểm và
hình vuông tự biến mất.
Khi người dùng nháy lên hình vuông thì hình sẽ biến mất và chỉ được thưởng 1
điểm.
c) Sân khấu nhận liên tục tương tác với người chơi cùng thông điệp QuickDone.
Đây là đoạn hay nhất của chương trình. Sân khấu sẽ liên tục yêu cầu người chơi
nhập 1 từ từ bàn phím. Khi nhập xong 1 từ (từ người dùng nhập lưu vào biến nhớ
CWord), lập tức gửi thông điệp QuickDone để Hình vuông kiểm tra xem từ này
có mặt trên màn hình hay không.
Hình vuông sẽ lâpk tức kiểm tra xem trên màn hình có hình vuông nào có từ
Word trùng với CWord hay không. Nếu trùng (người chơi gõ chính xác 1 từ), lập
tức tăng 25 điểm và xóa hình vuông này khỏi màn hình.
Lệnh này sẽ được xử lý

đồng thời bởi tất cả các
clone hiện có trên màn
hình, do vậy tốc độ rất
nhanh.
d) Xử lý thời gian kết thúc chương trình.

Sân khấu sẽ xử lý khâu cuối cùng này.
Thời gian bắt đầu chạy khi Sau 2 phút thì gửi thông
Start Game. điệp Game Over.
Nút Game Over sẽ hiện và thực hiện lệnh stop all để dừng toàn bộ chương trình.
Ẩn khi bắt đầu chương

trình.
Hiện khi Game Over.
8. Trò chơi luyện trí nhớ
Chúng ta sẽ cùng nhau phát triển và thiết kế 1 trò chơi giáo dục rất quen thuộc đối
với học sinh: trò chơi luyện trí nhớ.
Memory.sb2
Giao diện trò chơi rất đơn

giản: trên màn hình là 12
mảnh ghép, bên dưới mỗi
mảnh ghép (hình vuông) là 1
nội dung nào đó (bằng chữ
hoặc hình ảnh). Người chơi
cần nháy chuột để lật tất cả
các mảnh ghép trên màn
hình.
Mô tả yêu cầu chương trình.

Bắt đầu chương trình. Giao diện khi đang chơi.
- Giao diện của trò chơi bao gồm 12 mảnh ghép (mỗi mảnh là 1 hình vuông). Bên
dưới các mảnh ghép là 1 nội dung (chữ hoặc hình ảnh), có 6 cặp thông tin giống
nhau. Nhiệm vụ người chơi là lật được tất cả các mảnh ghép bằng cách nháy
chuột lên các mảnh ghép.
- Qui tắc lật như sau: người chơi sẽ lật được 2 mảnh ghép liên tục nếu 2 mảnh đó
chứa nội dung giống nhau.
- Ví dụ: lần đầu nháy và lật được 1 mảnh ghép, khi nháy lật lần thứ 2, nếu nội
dung mảnh sau trùng với mảnh trước thì 2 mảnh đó sẽ được mở vĩnh viễn, nếu nội
dung mảnh sau khác mảnh trước thì 2 mảnh đó sẽ đóng lại và người chơi phải
thực hiện lại từ đầu.
- Qui tắc tính điểm như sau: mỗi khi lật được vĩnh viễn 2 mảnh có nội dung giống
nhau thì tăng 1 điểm, khi hoàn thành 1 lần chơi mở tất cả các mảnh ghép sẽ được
tăng 20 điểm.
Thiết kế nhân vật chính của chương trình.
Hình ảnh Tên nhân vật Mô tả nhân vật
Giáo viên Giáo viên đóng vai trò MC của chương trình.
Square Nhân vật hình vuông dùng để tạo lưới ô vuông

cho trò chơi.
Char Nhân vật bao gồm các chữ cái thường dùng để
cung cấp thông tin nội dung cho các mảnh
ghép.
Alphabet Nhân vật bao gồm các chữ cái hoa dùng để
cung cấp thông tin nội dung cho các mảnh
ghép.
Animal Nhân vật bao gồm các hình ảnh con thú vật
dùng để cung cấp thông tin nội dung cho các
mảnh ghép.
Một số nhận xét và thiết kế sơ bộ.

1) Để mô tả các mảnh ghép chúng ta dùng hình ảnh nhân vật hình vuông có kích
thước 80 x 80. Tọa độ các tâm của hình vuông thể hiện trên lưới 3 x 4 trên màn
hình được xác định bởi 2 mảng tọa độ XList (tọa độ theo X) và YList (tọa độ theo
Y).
1 2 3 4
-120 -40 40 120
7  (2, 3)
1 60 1 2 3 4
-20 5 6 7 8 11  (3, 3)
2
-100 9 10 11 12
3
Mỗi mảnh ghép chính là 1 clone của nhân vật Square có giá trị CloneID được ghi
trong các ô của bảng trên, đánh số từ 1 đến 12. Thuật toán sau tính được chỉ số
theo hàng X-index và chỉ số theo cột Y-index theo giá trị n = số thứ tự mảnh
ghép.
Gán X-index:= n mod 4;
Nếu X-index = 0 thì gán
X-index:=4;
Gán Y-index:= n div 4 + 1 (làm
tròn)
Nếu n mod 4 = 0 thì gán
Y-index := Y-index - 1;
2) Để mô tả nội dung hiện bên dưới các mảnh ghép, chúng ta dùng các nhân vật
sau: chữ cái thường, chữ cái in hoa và hình ảnh con vật.
Mỗi nhân vật có nhiều trang phục như mô tả trong hình sau:
Nội dung của mỗi mảnh ghép cũng được thể hiện là 1 số tự nhiên. Nội dung 12 ô
mảnh ghép được lưu trong mảng Memory.List. Chú ý mảng này sẽ lưu ngẫu
nhiên 6 cặp số tự nhiên, mỗi cặp là 2 số giống nhau.
3) Các mảnh ghép thể hiện trên màn hình chính là các phân thân, clone của nhân
vật Square.
Nhân vật này được thiết kế với biến nhớ riêng CloneID. Biến nhớ này sẽ lưu trữ
ID của mảnh ghép, chính là số thứ tự của mảnh ghép trong mô tả trên của trò chơi.
CloneID - biến nhớ riêng mô tả số

thứ tự của mảnh ghép.
Như vậy khi người dùng nháy lên 1 mảnh ghép, giá trị CloneID sẽ được dùng để
chỉ số thứ tự của mảnh ghép, còn giá trị số tương ứng trong mảng Memory.List
sẽ được tính là nội dung bên dưới mảnh ghép đó.
4) Phần trọng tâm, khó nhất của chương trình là mô tả quá trình tương tác để mở
được 1 cặp mảnh ghép giống nhau. Thuật toán này sẽ cần 2 biến nhớ quan trọng:
Last.Square và Last.Square.Content.Ý nghĩa các biến nhớ này như sau:
- Last.Square chỉ ra trước đó đã mở tạm thời 1 mảnh ghép hay chưa. Nếu chưa
thì Last.Square = 0, ngược lại Last.Square chính là số thứ tự của mảnh ghép đã
mở trước đó.
- Nếu Last.Square > 0 (tức là đã có 1 mảnh ghép đang mở) thì
Last.Square.Content sẽ chính là nội dung của mảnh ghép đang mở.
Phần tương tác chính để của trò chơi Luyện trí nhớ được mô tả như sau:
Khi nháy chuột lên 1 mảnh ghép để mở. Gọi mảnh ghép này
Thuật toán mô là hiện thời.
tả quá trình Nếu Last.Square = 0 thì mở mảnh ghép này, gán
tương tác mở Last.Square cho ID của mảnh ghép này và gán
mảnh ghép của Last.Square.Content cho nội dung bên dưới của mảnh ghép
trò chơi Luyện này.
trí nhớ.
Nếu Last.Square > 0 thì
So sánh nội dung của mảnh ghép hiện thời với
Last.Square.Content.
Nếu trùng nhau thì
Mở tiếp mảnh ghép hiện thời.
Gán lại: Last.Square = 0; Last.Square.Content
= 0.
Nếu không trùng nhau thì
Tại vị trí của Last.Square cho hiện lại mảnh
ghép (đã mở ra trước đó).
Gán lại: Last.Square = 0; Last.Square.Content
= 0.
Nếu còn mảnh ghép chưa mở thì làm tiếp. Ngược lại kết
thúc trò chơi.
4) Mô tả sơ bộ hoạt động của toàn bộ chương trình như sau:

1. Khi bắt đầu chương trình, sân khấu sẽ ra thông điệp Reset để thực hiện các
công việc chuẩn bị ban đầu cho trò chơi. Các công việc chuẩn bị này bao gồm:
a) Hiện 12 hình vuông trên lưới để che khuất thông tin bên dưới. Sử dụng công
nghê Clone áp dụng cho nhân vật Square để thực hiện công việc này.
b) Thiết lập bộ dữ liệu gốc ban đầu của chương trình bao gồm:
+ Sinh ngẫu nhiên MType (= 1, 2 hoặc 3, tương ứng với 3 kiểu hình ảnh nằm bên
dưới các ô vuông, tương ứng với 3 nhân vật cung cấp hình ảnh này).
+ Dãy Number.List. Dãy này bao gồm các số thứ tự 1, 2, …, K = số lượng trang
phục tương ứng của nhân vật cung cấp hình ảnh.
+ Dãy Memory.List bao gồm 12 số bao gồm 6 cặp số giống nhau. Dãy này sẽ
quyết định những thông tin nào nằm bên dưới các hình vuông.
Sau khi thực hiện xong 2 công việc trên thì gửi thông điệp Make Content.
2. Bước tiếp theo là vẽ các nội dung hình ảnh bên dưới các ô vuông. Thực hiện
xong gửi thông điệp Start Game để bắt đầu trò chơi.
3. Bắt đầu tương tác của trò chơi. Các biến nhớ hệ thống cần thiết lập ban đầu là:
Last.Square = 0
Last.Square.Content = 0
num_square_solve = 0
Chờ người chơi nháy chuột lên các mảnh ghép để xử lý.
Khi người dùng nháy chuột lên một mảnh ghép (hình vuông):
- Nếu chưa có mảnh ghép nào mở (Last.Square=0) thì tiến mở mảnh ghép này và
cập nhật các giá trị Last.Square, Last.Square.Content, tăng num_square_solve
lên 1
- Nếu đã có 1 mảnh ghép đang mở ((Last.Square>0), thì kiểm tra mảnh ghép vừa
mở hiện thời với Last.Square.Content.
+ Nếu không trùng thì thực hiện thông báo RestoreLast. Thực hiện công việc
hiện lại mảnh ghép đã xóa mất của bước trước đây, khôi phục clone và giảm
num_square_solve xuống 1.
+ Nếu trùng nhau, thì mở luôn mảnh hiện thời, tăng num_square_solve lên 1, nếu
giá trị này = 12 thì thông báo End Game.
4. Kết thúc 1 lần chơi. Thông báo chiến thắng và gửi thông điệp Reset để tiếp tục
chơi lại từ đầu.
Thiết kế bộ dữ liệu hệ thống.

Thiết kế bộ dữ liệu cho chương trình. Các biến nhớ chính được ghi trong bảng
sau:
1 XList Dãy các tọa độ X theo chiều ngang (list)
từ trái sang phải (4 giá trị).
2 YList Dãy các tọa độ Y theo chiều dọc từ (list)
trên xuống dưới (3 giá trị).
3 MType Kiểu của dữ liệu hiển thị trên ô (biến nhớ)
lưới.
= 1, hiển thị chữ cái thường (theo
nhân vật Char).
= 2, hiển thị chữ cái hoa (theo nhân
vật Alphabet).
= 3, hiển thị các con vật (theo nhân
vật Animal).
4 GameType Biến nhớ chỉ trạng thái của trò (biến nhớ)
chơi:
= 0, đang chuẩn bị, không thể chơi.
= 1, đang chơi.
5 NumList Dãy số tự nhiên 1, 2, 3, … có độ (biến nhớ)
dài = số lượng trang phục của nhân
vật tương ứng với MType. Bộ dữ
liệu này dùng để sinh ngẫu nhiên
bộ dữ liệu chính thể hiện nội dung
trên lưới.
6 Memory.List Đây là bảng dữ liệu chính của (list)
chương trình, được sinh ra cho mỗi
lần chơi. Bảng này 12 số, bao gồm
6 cặp giống nhau, mỗi số sẽ tương
ứng với 1 giá trị của nội dung thể
hiện trên lưới. Các phần tử của
bảng này được lấy ngẫu nhiên từ
bảng NumList.
7 num_square_solve Biến nhớ được dùng trong quá (biến nhớ)
trình tương tác với người chơi, chỉ
ra hiện đã có bao nhiêu mảnh ghép
đã được lật. Nếu
num_square_solve = 12 thì việc
chơi kết thúc.
8 Last.Square Biến nhớ này dùng để chỉ trạng (biến nhớ)
thái người chơi nháy chuột lên 1
mảnh ghép.
= 0 nếu trước đó chưa có mảnh
ghép nào được lật.
= k > 0 nếu trước đó mảnh ghép
thứ k đã được lật.
9 Last.Square.Content Biến này có ý nghĩa khi (biến nhớ)
Last.Square > 0, chỉ ra nội dung
của ô mảnh ghép đã được lật trước
đó. Như vậy khi người chơi lật 1
mảnh ghép, nếu nội dung của ô bên
dưới = Last.Square.Content và
Last.Square > 0 thì chứng tỏ đã
nháy đúng 2 mảnh ghép giống
nhau.
10 CloneID Biến nhớ riêng của nhân vật biến nhớ
Square dùng để mô tả số thứ tự của riêng của
mảnh ghép được khởi tạo. Square.
Sơ đồ hoạt động của chương trình.
Reset Thực hiện các công việc thiết

lập bộ dữ liệu gốc bao gồm
Thực hiện công việc NumList, Memory.List, sau
vẽ 12 mảnh ghép cho đó gửi thông điệp Make
ô chữ, sử dụng kỹ Content.
thuật clone.
Make Content
Chờ người chơi nháy chuột lên các mảnh ghép để
xử lý. Khi người dùng nháy chuột: Start Game
1. Nếu chưa có mảnh ghép nào mở
(Last.Square=0) thì tiến mở mảnh ghép này và
cập nhật các giá trị Last.Square,
Last.Square.Content, tăng num_square_solve Thông báo chiến thắng,
lên 1 chờ 5 giây và gửi lại thông
2. Nếu đã có 1 mảnh ghép đang mở điệp Reset.
((Last.Square>0), thì kiểm tra mảnh ghép vừa mở Reset
hiện thời với Last.Square.Content.
+ Nếu không trùng thì thực hiện thông báo
RestoreLast.
RestoreLast
+ Nếu trùng nhau, thì mở luôn mảnh hiện thời,

tăng num_square_solve, nếu giá trị này = 12 thì
thông báo End Game.
Thể hiện nội dung trên
End Game ô lưới bên dưới các
mảnh ghép, sử dụng
lệnh vẽ stamp. Phản
Thực hiện công việc hiện lại mảnh ghép đã hồi lại cho GV để
xóa mất của bước trước đây, khôi phục clone chuẩn bị bắt đầu chơi.
và giảm num_square_solve xuống 1.

a) Sân khấu là nơi thông báo thông điệp Reset đầu tiên.
Chương trình điều khiển Giáo viên đóng vai trò như 1 MC trước khi nhận thông
điệp Reset.
b) Chương trình sau của Giáo viên khi nhận được thông điệp Reset mô tả tổng thể
toàn bộ các bước thực hiệ chương trình.
1. Thiết lập các thông số

ban đầu.
2. Chuẩn bị bộ dữ liệu
Number.List.
3. Chuẩn bị bộ dữ liệu
Memory.List.
4. Gửi thông điệp MakeContent

để vẽ nội dung bên dưới các mảnh
ghép. Đợi cho việc này thực hiện
xong.
5. Gửi thông điệp Start Game để bắt
đầu tiến hành tương tác với người chơi.
Chúng ta sẽ lần lượt lập trình cho các bước trên.

- Trước tiên Number.List sẽ chứa dãy số sẽ là nội dung của mảng dữ liệu chính
Memory.List.
Number.List sẽ lấy dữ liệu từ một trong 3 nhân vật sau.
26 phần tử 26 phần tử 32 phần tử
Như vậy Number.List sẽ chứa dãy các số tự nhiên hoặc 26, 26 hoặc 32 tùy thuộc
vào 1 biến nhớ MType dùng để chọn nguồn ảnh. Cách làm này có thể tổng quát
mở rộng cho nhiều bộ dữ liệu khác nữa.
c) Chuẩn bị bộ dữ liệu Number.List.
Chọn ngẫu nhiên 1 trong 3
bộ dữ liệu, tương ứng với 3
nhân vật dùng để sinh dữ liệu
cho các ô lưới bên dưới các
mảnh ghép.
d) Chuẩn bị bộ dữ liệu Memory.List.
Thiết lập 2 mảng rỗng ban đầu.
Đưa dãy 1..12 vào mảng tạm.
Đưa 6 cặp
số trùng
nhau của
Number.List
vào mảng
tạm.
Hoán vị mảng tạm 1 lần

nữa và đưa vào mảng
chính thức Memory.List.
e) Thiết lập các hình vuông (mảnh ghép) sau thông điệp Reset.
Chương trình sau của Square sẽ sinh 12 clone là 12 mảnh ghép và sẽ hiển thị tại
đúng vị trí của lưới 4 x 3 = 12 ô vuông của trò chơi.
Số thứ tự của các mảnh ghép chính là giá trị lưu trong biến nhớ CloneID.
Gán CloneID = 0 cho nhân vật gốc.
Chuẩn bị sinh 12 clone tạo thành 12

mảnh ghép.
Tính tọa độ của

clone sẽ được
sinh ra.
Trả lại CloneID = 0 cho nhân vật gốc.
Thủ tục này có đầu

vào n, đầu ra là X-
index, Y-index là tọa
độ của mảnh ghép
thứ n của trò chơi.
f) Vẽ nội dung bên dưới các mảnh ghép sau thông điệp MakeContent.
Khi nhận thông điệp MakeContent, cả 3 nhân vật Char, Alphabet và Animal
đều thực hiện cùng 1 chương trình để thể hiện nội dung bên dưới các mảnh ghép.
Nếu HType =1 thì Nếu HType =2 thì Nếu HType =3 thì

thực hiện thực hiện thực hiện
MakeContent. MakeContent. MakeContent.
Ví dụ chương trình sau của nhân vật Char.
Kiểm tra điều
kiện thực hiện.
Bắt đầu vẽ nội dung

cho 12 mảnh ghép.
Tính tọa độ
cho mảnh ghép
có số thứ tự
index.
Di chuyển đến tọa

độ và chuyển
trang phục tương
ứng.
Thực hiện lệnh
stamp để vẽ.
g) Chuẩn bị cho tương tác chính của trò chơi.

Chuẩn bị cho tương tác được thực hiện ngay sau thông điệp Reset. Biến nhớ
GameType được đưa vào có ý nghĩa: chỉ khi GameType =1 mới cho phép thực
hiện tương tác của trò chơi.
Thiết lập các giá trị ban đầu của biến nhớ Sau khi có thông điệp Start Game
hệ thống, trong đó có GameType = 0. (bắt đầu chơi) thì đặt lại GameType
= 1.
h) Mô tả các tương tác chính

Tương tác 1: Mở 1 mảnh ghép đầu tiên.
Kiểm tra điểu kiện

là mở mảnh ghép
đầu tiên.
Gán các tham số tương tác
như Last.Square,
Last.Square.Content, tăng
num_square_solve và xóa
mảnh ghép này.
Tương tác 2: mở mảnh ghép thứ 2.
Kết quả là hoặc thành công, hoặc thất bại thì phải trả lại mảnh ghép của tương tác
1 bằng cách gửi thông điệp RestoreLast.
Mở mảnh
ghép thứ 2.
Nếu thành công

thì xóa clone và
đặt lại các biến
nhớ hệ thống.
Nếu đã mở
hết thì End
Game.
Nếu không thành công thì mở ra 0.5

giây và gửi thông điệp RestoreLast để
đóng cả 2 mảnh ghép.
i) Chương trình điều khiển RestoreLast.

Chương trình này sẽ khôi phục lại clone với số thứ tự Last.Square đã bị xóa
trước đó, sau đó thiết lập lại giá trị mặc định ban đầu cho các biến nhớ hệ thống.
Kiểm tra để chỉ thực hiện lệnh trên

nhân vật gốc.
Thiết lập 1
clone mới với
CloneID =
Last.Square.
Trả lại
CloneID = 0
và đặt lại các
biến nhớ hệ
thống.
j) Giáo viên
và thông điệp End Game.
Giáo viên sẽ thông báo hoàn thành trò chơi, tăng điểm số lên 20 điểm, đặt lại
gameType = 0 và chuẩn bị cho bài tiếp theo bằng thông điệp Reset.
9. Trò chơi Ô chữ
Chúng ta sẽ cùng thiết kế trò chơi Ô chữ (Crosswords), một trò chơi rất quen
thuộc và nổi tiếng và là chương trình phức tạp nhất của chủ đề này. Trò chơi này
rất nổi tiếng và đã có rất nhiều phần mềm mô phỏng trò chơi này.
O chu.sb2
Giao diện chương

trình giải ô chữ. Vì
chiều rộng màn hình
bị hạn chế nên từ
khóa chính theo hàng
dọc sẽ được thể hiện
bằng các ô màu xanh
trên màn hình và
không cần thẳng
hàng.
Nhân vật của chương trình.
(a) Yêu cầu chương trình

- Chức năng chính của chương trình là cho phép người chơi giải các ô chữ. Mỗi ô
chữ sẽ bao gồm: 1 từ khóa chính hàng dọc (main key) và nhiều từ khóa hàng
ngang (key word). Quan hệ giữa các từ khóa hàng ngang với từ khóa chính hàng
dọc: từ khóa hàng ngang thứ k sẽ phải chứa chữ cái thứ k của tư khóa chính hàng
dọc.
- Vì cửa sổ sân khấu của Scratch có hạn nên chương trình chỉ thiết kế với mô hình
các từ với hạn chế sau:
+ Các từ khóa hàng ngang có độ dài <= 11.
+ Từ khóa chính hàng dọc có độ dài <= 8.
+ Từ khóa hàng dọc không thể được xếp thẳng hàng, do đó các ô tương ứng với từ
khóa hàng dọc sẽ được tô màu xanh (xem hình trên).
- Việc giải ô chữ như sau:
+ Giải các từ hàng ngang bằng cách nháy lên các nút tròn màu hồng tương ứng ở
bên trái màn hình.
+ Giải từ khóa chính bằng cách nháy lên nút tên của chương trình.
+ Người chơi sẽ thắng nếu giải được tất cả các từ hàng ngang hoặc giải được từ
khóa chính hàng dọc.
- Yêu cầu của chương trình là các bộ dữ liệu ô chữ phải được sinh tự động, ngẫu
nhiên từ một CSDL được nạp sẵn trong chương trình.
(b) Một vài nhận xét sơ bộ về thiết kế chương trình.
1. Một trong những điểm khó thiết kế nhất của chương trình này chính là bộ dữ
liệu gốc dùng để mô tả chương trình.
Bảng sau mô tả bộ dữ liệu gốc được thiết kế của chương trình.
Tên biến nhớ Ý nghĩa
MKey (biến nhớ) Từ khóa chính của ô chữ hiện thời, theo chiều dọc
thẳng đứng.
Cách tính: lấy ngẫu nhiên 1 từ từ dãy MKeyList.
MKey.Description (biến Mô tả, gợi ý của từ khóa chính.
nhớ)
KeyWList (list) Các từ khóa theo chiều ngang của ô chữ hiện thời.
Cách tính: lấy từ dãy WList và thỏa mãn chứa các
chữ cái tương ứng của MKey.
KeyWList.Description Các mô tả của các từ khóa theo chiều ngang.
(list)
KeyWList.index (list) Dãy các chỉ số, vị trí của từ trong dãy KeyWList
chứa ký tự khóa.
Trên màn hình, các ô chứa ký tự khóa chính sẽ đổi
màu xanh.
WList (list) Bộ từ điển dữ liệu các từ có thể làm từ khóa theo
chiều ngang. Các từ này phải có độ dài <=11.
WList.Description (list) Bộ từ điển mô tả của các từ trong dãy WList.
MKeyList (list) Từ điển dữ liệu gốc các từ có thể làm khóa chính.
Các từ này phải có độ dài <=8.
MKeyList.Desctiption Mô tả của các từ trong dãy MKeyList.
(list)
KeyWList.solve (list) Dãy các số chỉ ra từ khóa hàng ngang nào đã được
dự đoán, từ nào chưa. Nếu từ đã đoán xong thì giá
trị số tương ứng = 1, ngược lại = 0.
2. Một trong những đặc điểm khó nữa của chương trình này là cách vẽ, thể hiện
lưới các ô vuông trên màn hình.
Chúng ta sẽ sử dụng 1 nhân vật có tên Square để thể hiện lưới này. Kỹ thuật
Clone sẽ được dùng để thể hiện các ô vuông này trên màn hình.
(c) Thiết kế nhân vật
Nhân vật và vai trò trong chương trình.
Biểu tượng Tên nhân vật Vai trò trong thiết kế
Giáo viên Giáo viên sẽ đóng vai trò người hướng dẫn
chính của chương trình với người chơi. Đồng
thời tất cả các hoạt động chính, thuật toán, các
lệnh chính đều xuất phát từ nhân vật này.
Hình vuông Nhân vật này có 1 nhiệm vụ duy nhất là thực

hiện việc che các chữ cái của các từ theo hàng
ngang của ô chữ. Nhân vật này có 2 trang phục:
màu vàng và màu xanh.
Bảng chữ cái Nhân vật Char dùng để thể hiện các từ khóa
của ô chữ. Việc thể hiện sẽ sử dụng lệnh vẽ
stamp của nhân vật này. Nhân vật sẽ có 26
trang phục tương ứng với 26 chữ cái tiếng Anh.
Tên của trang phục trùng với tên chữ cái, ví dụ:
a, b, c, d, e, f, ….
Chú ý: chương trình chỉ dùng các hình ảnh chữ
cái tiêng Anh thường, không có chữ hoa, do đó
tất cả các các từ khóa của chương trình đều
phải viết bằng chữ thường.
Vòng tròn có Nhân vật này là hình tròn, có 8 trang phục
số tương ứng với các hình có số từ 1 đến 8. Nhiệm
vụ của nhân vật này là hiện thành các nút ở cột
bên trái dùng để cho người chơi đoán các từ
khóa hàng ngang.
Nút / tên của Nút này có 2 ý nghĩa:
chương trình. - Hiện phía trên của màn hình làm tiêu để cho
phần mềm.
- Dùng là nút lệnh cho người chơi đoán từ khóa
chính hàng học.
(c) Sơ đồ hoạt động của chương trình.
Nhãn, đoạn Hoạt động chính Vai trò và nhiệm vụ của Các chú ý
chương nhân vật khác
trình
Bắt đầu Bắt đầu chương trình. Các nhân vật sẽ thiết lập Nền sân khấu
trạng thái ban đầu của mỗi sẽ phát thông
nhân vật. điệp Reset.
Reset Bắt đầu quá trình chính của trò - Nhân vật GV sẽ thực hiện Khi GV thực
chơi. Tại bước này sẽ thực hiện tất cả các hoạt động của hiện xong tất
các nhiệm vụ sau: bước này. cả các công
việc sinh dữ
trình
- Thiết lập các giá trị mặc định, liệu, sẽ phát
ban đầu cho chương trình. thông điệp
Paint để yêu
- Sinh ngẫu nhiên 1 bộ dữ liệu cho
trò chơi ô chữ, bao gồm: cầu vẽ giao
diện cho trò
+ 1 Từ khóa chính (theo hàng chơi.
dọc). MainKey.
+ Dãy các từ khóa theo hàng
ngang. KeyWord. Mỗi từ khóa
hàng ngang phải chứa ký tự tương
ứng theo thứ tự của từ khóa chính.
Ví dụ nếu Main Key =
"computer" thì từ khóa thứ nhất
phải có chữ c, từ thứ 2 phải chứa
chữ o, ….
Paint Thực hiện việc vẽ các giao diện - Nhân vật Char thực hiện Khi vẽ xong
của chương trình. vẽ giao diện các chữ cái thể thì phát thông
hiện các từ hàng ngang. điệp Start để
bắt đầu quá
- Nhân vật Square thực
hiện vẽ giao diện là các trình tương
tác của người
hình vuông đè lên các chữ
dùng với
cái để che khuất. Các hình
vuông tương ứng với từ phần mềm.
khóa chính sẽ có màu xanh.
- Nhân vật Circle sẽ vẽ
giao diện là dãy 8 hình tại
cột bên trái.
Start Bắt đầu chơi đoán ô chữ. Nhân vật GV sẽ thực hiện Đây là bước
các hoạt động chính của phức tạp nhất
- Muốn đoán 1 từ khóa hàng ngay,
bước này, các nhân vật của chương
nháy nút hình tròn tương ứng ở
đầu mỗi từ khóa. khác phối hợp thực hiện. trình.
- Muốn đoán ngay từ khóa chính - Khi người dùng nháy lên
nút hình tròn tương ứng với
nháy lên nút tên chương trình (có
từ chưa tìm ra, nhân vật
chữ Crosswords).
Circle sẽ gửi thông điệp
- Nếu đoán đúng 1 từ khóa hàng Tim_hang_ngang cho GV.
ngang thì các hình vuông che
- Khi ngưởi dùng nháy lên
khuất từ trên hàng ngay này sẽ
nút Crosswords, nhân vật
mất đi, để hiện ra từ khóa này.
này sẽ gửi thông điệp
- Trò chơi kết thúc khi người chơi Tim_hang_doc cho GV.
hoặc đã đoán đúng được toàn bộ
- Khi người dùng đoán
các từ hàng ngang hoặc đoán đúng
đúng 1 từ hàng ngang, GV
được từ hàng dọc.
sẽ gửi thông điệp
Khi kết thúc sẽ dừng chương trình OpenSquare cho nhân vật
hoặc quay lại bước Reset.
trình
Square để mở hình cho từ
hàng ngang này.
(d ) Thiết kế sơ bộ dữ liệu cho chương trình.

Các biến nhớ chính và dữ liệu của chương trình.
1 MKey Từ khóa chính của ô chữ hiện (biến nhớ)
thời, theo chiều dọc thẳng đứng.
Cách tính: lấy ngẫu nhiên 1 từ
từ dãy MKeyList.
2 MKey.Description Mô tả, gợi ý của từ khóa chính. (biến nhớ)
3 KeyWList Các từ khóa theo chiều ngang (list)
của ô chữ hiện thời.
Cách tính: lấy từ dãy WList và
thỏa mãn chứa các chữ cái
tương ứng của MKey.
4 KeyWList.Description Các mô tả của các từ khóa theo (list)
chiều ngang.
5 KeyWList.index Dãy các chỉ số, vị trí của từ (list)
trong dãy KeyWList chứa ký tự
khóa.
Trên màn hình, các ô chứa ký tự
khóa chính sẽ đổi màu xanh.
6 WList Dữ liệu các từ có thể làm từ (list)
khóa theo chiều ngang. Các từ
này phải có độ dài <=11.
7 WList.Description Mô tả của các từ trong dãy (list)
WList.
8 MKeyList Dữ liệu gốc các từ có thể làm (list)
khóa chính.
Các từ này phải có độ dài <=8.
9 MKeyList.Desctiption Mô tả của các từ trong dãy (list)
MKeyList.
10 XList Dãy tọa độ các ô lưới theo trục (list)
X, tính từ trái sang phải.
11 YList Dãy tọa độ các ô lưới theo trục (list)
Y, tính từ trên xuống dưới.
12 main_key_solve Chỉ ra Main Key (từ khóa (biến nhớ)
chính) đã được tìm ra chưa.
= 0, chưa tìm được.
= 1, đã tìm được.
13 num_key_solve Số lượng các từ khóa theo chiều (biến nhớ)
ngang đã được tìm thấy.
14 KeyWList.solve Dãy các số chỉ ra từ khóa hàng (list)
ngang nào đã được dự đoán, từ
nào chưa. Nếu từ đã đoán xong
thì giá trị số tương ứng = 1,
ngược lại = 0.
(e) Sơ đồ hoạt động chi tiết
Thể hiện các từ

Reset khóa hàng ngang,
mỗi ô là 1 chữ cái.
Thể hiện các hình

Sinh ngẫu nhiên bộ dữ
vuông che lập các từ
liệu gốc của chương
khóa. Các ô tương ứng
trình. Gửi thông điệp
Paint từ khóa chính có màu
Paint.
xanh.
Thông báo cho người chơi giải từ
khóa ngang. Nếu giải đúng, gửi Mở các hình vuông
thông điệp: Open Square. Open Square chứa từ khóa hàng
Nếu giải được tất cả các từ ngang, ngang vừa giải
thông báo chiến thắng. Gửi thông đúng.
điệp: Reset. Reset
Thông báo cho người chơi giải từ
khóa chính (dọc). Nếu giải đúng,
thông báo chiến thắng. Gửi thông Reset
điệp: Reset.
Thể hiện các hình
Nếu bị nháy lên, tròn ở đầu mỗi
gửi thông điệp hàng ngang.
Tim_hang_doc.
Nếu bị nháy lên, gửi
Tim_hang_doc Tim_hang_ngang thông điệp
Tim_hang_ngang.
(f) Thiết kế chi tiết
1) Sinh ngẫu nhiên bộ dữ liệu ô chữ
Khi nhận được thông điệp Reset, nhân vật GV sẽ thực hiện các lệnh sinh ngẫu
nhiên bộ dữ liệu ô chữ. Các lệnh này sẽ được chia thành 2 thủ tục: Init.MainKey
sinh từ khóa chính và Init.WordKeys sinh dãy các từ khóa hàng ngang.
Thủ tục Init.MainKey:
Từ khóa chính Mkey được

lấy ngẫu nhiên từ mảng
MKeyList. Thông tin giải
nghĩa MKey.Description
được lấy từ bảng
MKeyList.Description
tương ứng. Chú ý chỉ lấy
các từ khóa chính có độ dài
<=8.
Thủ tục Init.WordKeys. Thủ tục này sẽ xuất phát từ từ khóa chính MKey đã có,
sẽ tìm lần lượt các từ khóa hàng ngang có chứa lần lượt các chữ cái trong MKey.
Trong thủ tục này sẽ gọi 1 thủ tục khác Find char <ch> in <Word>, kết quả là vị
trí của chữ cái <Ch> trong từ <Word>, giá trị này lưu trong biến nhớ tổng thể
found.index.
Xóa để làm lại từ đầu các

dãy dữ liệu cần tìm.
Bắt đầu tìm từ vị trí index, lấy

ra chữ cái Ch của vị trí index từ
MKey.
Cách tìm: lấy ngẫu nhiên

các từ từ kho dữ liệu
WList, cho đến khi chứa
chữ cái Ch và có độ dài
<=11 thì dừng lại.
Tìm xong, gán các giá trị đã

tìm được vào các dãy cần
tìm.
Còn đây là thủ tục Find char <ch> in <Word>. Kết quả của thủ tục này sẽ lưu
trong biến nhớ tổng thể found.index.
2) Thiết kế tọa độ màn hình ô chữ

Bước tiếp theo là thiết kế giao diện để thể hiện ô chữ trên màn hình. Do hạn chế
của kịch thước sân khấu Scratch nên chúng ta sẽ thiết kế mỗi ô vuông của các con
chữ là 1 hình vuông 40 x 40. Toàn bộ màn hình sẽ được chia thành 1 lưới ô vuông
kích thước 12 x 8.
Do cột bên trái ngoài cùng phải dành cho dãy nút tròn nên vùng lưới chứa ô chữ
sẽ chỉ là 11 x 8.
Tọa độ các tâm hình vuông theo chiều ngang (trục X), tính từ trái sang phải, được
lưu trong dãy XList.
Tọa độ các tâm hình vuông theo chiều dọc (trục Y), từ trên xuống dưới, được lưu
trong dãy YList.
Giá trị các bảng XList, YList thể hiện trong hình sau, đồng thời thể hiện thiết kế
của lưới ô chữ của chương trình.
dãy YList dãy XList

-220 -180 -140 -100 -60 -20 20 60 100 140 180 220
120
80
40
0
-40
-80
-120
-160
(20, -40)
(-100, 0)
Hình ảnh 2 mảng số XList và YList trong chương trình.
Chú ý: dãy XList được thiết

kế chỉ có 11 phần tử ứng
với các ô vuông màu vàng
của lưới ô chữ.
3) Thể hiện (paint) giao diện ô chữ: các hàng chữ hàng ngang
Nhân vật Char sẽ có nhiệm vụ thể hiện các từ hàng ngang của ô chữ.
Chúng ta sử dụng kỹ thuật thể hiện chữ đã được đưa trong bài học
21. Nhân vật Char sẽ có các trang phục trùng với bảng chữ cái của
ngôn ngữ hiện thời và có tên trang phục chính là chữ cái đó.
Trong chương trình này chúng ta sẽ thực hiện trên ngôn ngữ tiếng
Anh với 26 chữ cái viết thường.
Chú ý: muốn mở rộng ra chữ hoa hoặc bổ sung thêm các ký tự khác
hay ngôn ngữ khác thì chỉ cần mở rộng số lượng trang phục của nhân
vật. Thuật toán sẽ không thay đổi.
Chú ý: Cần xác định tâm của trang phục nằm ở chính giữa hình ảnh
chữ cái.
Đoạn chương trình thể hiện các từ hàng ngang trên lưới ô chữ của nhân vật Char
như sau:
Vòng lặp ngoài,

theo độ dài
MKey.
Vòng lặp trong,

theo độ dài của từng
từ hàng ngang
KeyWList.
Chuyển trang phục

và vẽ bằng lệnh
stamp.
4) Thể hiện (paint) giao diện ô chữ: các hình vuông
Để thực hiện công việc này, chúng ta sẽ sử dụng kỹ thuật tạo clone quen thuộc của
Scratch cho nhân vật Square (hình vuông). Để lưu trữ và tìm kiếm nhanh được vị
trí của các hình vuông clone trên màn hình chúng ta bổ sung thêm 2 biến riêng
cho hình vuông là Row - tọa độ theo X và Column - tọa độ theo Y.
CloneID: ID của clone. Các biến nhớ

Row: tọa độ hàng (theo trục X). riêng (local) của
nhân vật
Column: tọa độ cột (theo trục Y). Square.
Đoạn chương trình sinh clone của nhân vật Square phủ lưới ô vuông ô chữ như
sau:
Đoạn chương trình sẽ bao

gồm 2 vòng lặp, vòng ngoài
có độ dài của từ khóa chính
length(Mkey) bước, vòng lặp
trong theo độ dài của từng từ
hàng ngang.
Nếu ký tự thuộc từ
khóa chính thì chuyển
màu xanh.
Sau khi tạo xong clone thì trả

lại các giá trị ban đầu của các
biến riêng của nhân vật.
5) Thể hiện (paint) giao diện ô chữ: cột tròn bên trái đầu các hàng ngang
Thể hiện cột tròn bên trái các hàng ô chữ là nhân vật Circle. Cách thực hiện cũng
dùng kỹ thuật clone. Nhân vật này sẽ có 8 trang phục tương ứng với các hình tròn
có các chữ số từ 1 đến 8. Đoạn chương trình vẽ cột đầu tiên như sau.
Sử dụng biến nhớ riêng CloneID để đánh
số các clone được khởi tạo.
Với mỗi clone với CloneID, lệnh:
sẽ tạo 1 clone tại đúng vị trí của mình và

có hình ảnh mang đúng số.
6) Tương tác giải từ hàng ngang

Khi người chơi nháy chuột lên 1 nút đỏ, biến nhớ tổng thể Curr_index sẽ lưu lại
chỉ số của từ hàng ngang cần đoán.
Đoạn chương trình gửi thông điệp Tim_hang_ngang của Circle như sau.
Kiểm tra xem từ hàng ngay này đã được

tìm thấy trước đó hay chưa, thông tin này
lưu trong dãy KeyWList.solve.
Biến nhớ Curr_index sẽ được gán trước
khi gửi thông điệp.
GV sẽ thực hiện chương trình tạo tương tác để người chơi nhập từ hàng ngang
tương ứng. Nếu người chơi nhập đúng thì gửi thông điệp OpenSquare cho nhân
vật Square để làm ẩn (xóa) các clone có trên hàng tương ứng.
Đoạn chương trình xử lý của nhân vật hình vuông đơn giản, kiểm tra xem nếu giá
trị Column = Curr_index thì xóa clone tương ứng:
7) Tương tác giải từ hàng dọc

Khi người dùng nháy lên nút tên của chương trình, nhân vật này sẽ kiểm tra xem
từ khóa chính đã giải được chưa, nếu chưa thì gửi thông điệp Tim_hang_doc cho
GV thực hiện các bước để người chơi thực hiện việc đoán từ khoa chính.
Đoạn chương trình này đơn giản như sau, chú ý rằng biến nhớ main_key_solve
dùng để kiểm soát xem từ khóa chính đã đoán được hay chưa.
a) Sân khấu là nơi phát thông điệp Reset đầu tiên.
b) Giáo viên nhận được Reset sẽ thực hiện công việc sinh bộ dữ liệu gốc cho ô
chữ.
Giáo viên thực hiện việc sinh dữ liệu gốc,

chia làm 3 bước:
1. Sinh MainKey (từ khóa chính).
2. Sinh các KeyWord (các từ khóa ngang).
3. Thiết lập ban đầu bộ dữ liệu để giải.
Sau đó sẽ gửi thông điệp Paint để vẽ màn
hình.
b.1. Thủ tục Init.MainKey.

Thủ tục này sinh ngẫu nhiên từ khóa chính (MKey) từ mảng dữ liệu từ điển
MKeyList. Các từ này yêu cầu có độ dài không vượt quá 8.
- Từ khóa chính MKey lấy từ MKeyList.
- Mô tả từ khóa chính MKey.Description lấy từ bảng MKeyList. Description
tương ứng.
b.2. Thủ tục Init.WordKeys.

Thủ tục này sẽ sinh đúng n các từ khóa hàng ngang (KeyWord), với n = độ dài
của từ khóa chính và từ khóa hàng ngang thứ k phải chứa ký tự thứ k của từ khóa
chính (MKey).
Các từ khóa hàng ngang được sinh và đưa vào bảng KeyWList.
Thứ tự các chỉ số của ký tự khóa chính trong từ khóa hàng ngang được lưu trong
bảng KeyWList.index.
Các mô tả sẽ được đưa vào bảng KeyWList.Description tương ứng.
Thiết lập các mảng dữ liệu

chính ban đầu = rỗng.
Lặp theo độ dài từ khóa chính.

Với mỗi ký tự
Ch của MKey.
Tìm từ khóa
hàng ngang
Word (lấy từ
WList) có chứa
Ch tương ứng.
Nạp thông tin từ

hàng ngang vừa
tìm được vào các
bảng chính.
Chú ý: Trong chương trình trên có sử dụng thủ tục Find char <ch> in <Word>.
Thủ tục này được mô tả ngay dưới đây.
b.3. Thủ tục Find char <ch> in <Word>.

Cho trước 1 ký tự ch và 1 từ Word.
Thủ tục Find char <ch> in <Word> sẽ kiểm tra và tìm vị trí của ch trong Word.
Nếu không tìm thấy, trả lại kết quả trong biến nhớ found.index = 0.
Nếu tìm thấy, giá trị found.index > 0 sẽ là vị trí đầu tiên của ch trong Word.
b.4. Thủ tục Init.Solve.
Thủ tục này thiết lập các giá trị ban đầu cho 1 số biến nhớ hệ thống dùng cho việc
giải ô chữ ở bước sau.
Đặt các biến:

num_key_solve = 0.
main_key_solve = 0.
Thiết lập bảng KeyList.solve gồm toàn số
0 ban đầu. Bảng này cho biết từ hàng
ngang nào đã được tìm ra (số 1) và chưa
tìm ra (số 0).
c) Xử lý thông điệp Paint.

Công việc cần thực hiện của thông điệp Paint bao gồm 3 việc sau:
- Thiết lập lưới ô vuông chính của trò chơi.
- Thiết lập dãy các hình tròn bên trái để giải các từ hàng ngang.
- Thể hiện nội dung các từ khóa bên dưới lưới ô vuông. Việc này người dùng sẽ
không được nhìn thầy.
c.1. Thiết lập lưới ô vuông.

Lưới ô vuông được thiết lập bằng kỹ thuật Clone cho nhân vật Square. Mỗi Clone
sẽ chứa 3 thuộc tính quan trọng sau (là các biến nhớ riêng của nhân vật này).
- CloneID: số thứ tự của clone.
- Row: vị trí hàng trên lưới.
- Column: vị trí cột trên lưới.
Chương trình sinh lưới ô vuông như sau:
Lặp theo chiều dọc của độ dài từ

khóa chính.
Lặp theo
chiều ngang.
ô vuông ứng
với chữ cái của
từ khóa chính sẽ
là màu xanh.
Sau khi thiết lập

xong trả lại các giá
trị cho nhân vật
gốc.
Cuối cùng gửi thông điệp Paint.
c.2. Thiết lập dãy các vòng tròn đánh số bên trái các từ khóa.
Các vòng tròn đánh số bên trái các từ khóa được thiết lập từ nhân vật Circle bằng
kỹ thuật Clone. Có tất cả 8 clone này, đánh số từ 1 đến 8 bởi biến nhớ riêng
CloneID. Chương trình đơn giản sau tạo ra 8 hình tròn này.
Các clone này được

sắp xếp ở các tọa độ X
= -220 và Y theo bảng
YList.
c.3. Thể hiện dãy các từ khóa bên dưới lưới ô vuông.
Dãy các từ khóa được thể hiện bằng lệnh stamp bên dưới lưới ô vuông. Cách thực
hiện gần tương tự như việc thiết kế lưới ô vuông.
d) Bắt đầu quá trình tìm ô chữ.

Quá trình tìm, giải ô chữ được thực hiện thông qua 2 kiểu thao tác sau:
- Tìm 1 từ hàng ngang bằng cách nháy chuột lên nút hình tròn bên trái từ khóa
này.
- Tìm từ khóa chính (màu xanh) hàng dọc bằng cách nháy chuột lên nút
Crossword màu xanh phía trên màn hình.
d.1. Giáo viên thông báo.
Màn hình thể hiện thông báo của Giáo viên như sau:
d.2. Xử lý tìm từ hàng ngang

Khi người dùng nháy chuột lên 1 hình tròn bên trái 1 từ hàng ngang, chương trình
điều khiển sự kiện này như sau.
- Kiểm tra xem từ hàng ngang này đã được đoán hay chưa.
- Nếu chưa thì gán biến nhớ Curr_index cho số thứ tự của từ khóa hàng ngang cần
đoán.
- Gửi thông điệp Tim_hang_ngang để Giáo viên sẽ là nhân vật xử lý công việc
tiếp theo.
Kiểm tra nếu từ

khóa hàng ngang
chưa tìm ra thì …
Gửi thông điệp

Tim_hang_ngang.
Khi nhận được thông điệp Tim_hang_ngang Giáo viên sẽ là người xử lý thông
điệp này. Qui trình thực hiện như sau:
- Yêu cầu người chơi nhập từ cần đoán từ bàn phím.
- Tiến hành kiểm tra xem từ đã nhập có đúng với từ hàng ngang cần đoán hay
không.
Nếu đúng thì:
Thông báo đã đoán đúng, cập nhật các thông tin cần thiết và xóa tất cả các mảnh
ghép của hàng ngang này.
Nếu sai thì:
Cập nhận thông tin và thông báo đã đoán sai.
Chương trình cụ thể như sau.
Thông báo và
yêu cầu người
chơi nhập từ
hàng ngang cần
tìm.
Nếu tìm đúng,

thông báo đúng
rồi, cập nhập các
thông số tương
ứng và …

OpenSquare để
mở các ô này.
Nếu từ này là
cuối cùng thì
thông báo chiến
thắng, gửi Reset.
Nếu đoán sai

thì thông báo
sai rồi.
Xử lý thông điệp OpenSquare, xóa tất cả các ô hàng ngang tại vị trí
Currr_index rất đơn giản bằng chương trình sau.
Chú ý: tất cả các Clone trên lưới đều nhận được và cùng thực hiện chương trình
này nhưng chỉ những Clone tương ứng với từ vừa tìm thấy mới bị xóa.
d.2. Xử lý tìm từ hàng dọc

Người chơi muốn đoán từ khóa chính hàng dọc (tương ứng các ô màu xanh) cần
nháy lên nhân vật Crossword đóng vai trò Tên của trò chơi.
Đoạn chương trình điều khiển này đơn giản như sau:
- Kiểm tra xem từ khóa chính đã được giải chưa, nếu chưa thì gửi thông điệp
Tim_hang_doc để Giáo viên sẽ là người nhận xử lý thông điệp này.
Giáo viên nhận được thông điệp Tim_hang_doc sẽ xử lý như sau.
Thông báo và yêu

cầu người chơi
nhập từ hàng dọc
cần tìm.
Nếu đúng, thông

báo chúc mừng và
Reset để bắt đầu
bài chơi mới.
Nếu sai, thông báo

sai rồi.
1. Viết chương trình mô tả chương trình, trò chơi Chim bay sau.
Trò chơi Chim bay có các màn hình ban đầu và trong thời gian chơi như 2 hình
sau:
Hình ảnh ban đầu của chương trình. Hình ảnh trong thời gian chơi.
- Chương trình có 3 nhân vật chính: chim, ngôi sao và ma trắng. Bấm 1 phím bất
kỳ để bắt đầu chơi. Ban đầu người chơi được ngay 10 điểm.
- Chim sẽ luôn vỗ cánh và bay. Em điều khiển chim bay bằng các phím lên, phải,
trái. Khi bấm phím phải, trái, chim sẽ quay về hướng phải, trái và bay 1 đoạn
ngắn. Khi bấm phím lên, chim sẽ cố gắng bay lên. Tuy nhiên do cánh chim quá
nặng nên chim sẽ luôn bị hút rơi xuống. Nếu rơi xuống mặt đất, điểm số sẽ luôn bị
trừ đi 1 điểm trong suốt thời gian ở mặt đất. Do vậy người chơi cần điều khiển
nhanh để chim bay lên.
- Trên màn hình sẽ xuất hiện ngẫu nhiên các ngôi sao và ma trắng, chuyển động từ
trái sang phải hoặc từ phải sang trái màn hình. Ngôi sao xuất hiện nhiều hơn và
chuyển động nhanh hơn, ma trắng xuất hiện ít hơn và chuyển động chậm hơn.
- Nếu gặp ngôi sao, người chơi được thưởng 50 điểm.
- Nếu gặp ma trắng, lập tức điểm số bị đặt bằng 0, chim rơi xuống đất và trò chơi
kết thúc.
- Có 1 biến nhớ thời gian luôn hiện trên màn hình và sẽ chạy khi bắt đầu chơi. Sau
đúng 1 phút (60 giây), trò chơi kết thúc.
Để chơi trò chơi này, người chơi cần khéo léo điều khiển con chim sao cho đạt
nhiều điểm nhất khi kết thúc chương trình, tránh va chạm với con ma trắng.
2. Mở rộng chương trình Bút vẽ nâng cao (mục 5) như sau:
Không cho phép vẽ, in hình vẽ vào khu vực phía dưới màn hình, khu vực có các
công cụ vẽ.
Chú ý chương trình trong mục 5 không thỏa mãn hoàn toàn yêu cầu này. Chương
trình chỉ cấm được bút vẽ từ bên trong khu vực "cấm" ra ngoài, chứ chưa ngăn
được việc đưa bút vẽ từ ngoài vào bên trong vùng "cấm".
Không cho
phép vẽ hình
trong khu vực
này.
3. Mở rộng trò chơi Luyện trí nhớ cho các lưới ô vuông 4 x 4 và 4 x 5.
4. Mở rộng chương trình, trò chơi Ô chữ với các chức năng sau:
- Bấm các phím 1, 2, 3, …. sẽ cho phép nhập từ hàng ngang thư 1, 2, 3, ….
- Bấm phím Space sẽ cho phép nhập từ hàng dọc (từ khóa chính).
5. Hãy thiết kế bộ dữ liệu và thủ tục có chức năng thể hiện được các từ tiếng Việt
hoàn chỉnh trên màn hình.
Ví dụ thủ tục cần thiết kế có dạng: Show Word <W> at <X, Y>.
Ví dụ lệnh Show Word <việt nam> at <0,0> sẽ thể hiện từ "việt nam" trên màn
hình sân khấu.
Chủ đề 5.
Phần mềm tập chuột, bàn phím
Mục tiêu:
- Các phương pháp điều khiển nhân vật bằng chuột và bàn phím.
- Một số kỹ thuật xử lý chuột.
- Phần mềm tập chuột, bàn phím cho học sinh.
Nội dung chính
1. Điều khiển nhân vật bằng bàn phím
Trong Scratch có 2 cách điều khiển nhân vật bằng bàn phím, 1 cách điều khiển
cứng và 1 cách điều khiển mềm bằng cảm ứng.
Điều khiển cứng Điều khiển mềm
Đây là cách điều khiển cứng, khi đã

áp đặt lệnh trong chương trình thì Đây là cách điều khiển mềm sử dụng cảm
không thể thay đổi. biến bàn phím. Cách này có ưu điểm là
có thể can thiệp trong quá trình thực hiện
chương trình, nhược điểm là tốc độ điều
khiển có thể bị ảnh hưởng.
2. Điều khiển nhân vật bằng chuột

Có rất nhiều cách, kỹ thuật điều khiển chuyển động của nhân vật bằng chuột, mỗi
cách đều có ưu nhược điểm và được sử dụng trong những hoàn cảnh khác nhau.
Chúng ta cùng tìm hiểu các kỹ thuật điều khiển nhân bật bằng chuột này.
2.1. Điều khiển nhân vật bằng cách di chuyển chuột. Mức 0.
Đây là các phương pháp điều khiển nhân vật tức thời bằng cách di chuyển chuột
(không và chưa cần đến nháy chuột). Có 2 cách như mô tả trong bảng sau.
CM1 Khi di chuyển chuột, nhân vật luôn dính
chặt tại vị trí con trỏ chuột.
Đây là cách điều khiển nhân vật bằng
chuột đơn giản nhất. Ví dụ điều khiển
bút vẽ tự do.
CM2 Khi di chuyển chuột, nhân vật luôn xoay
hướng về phía con trỏ chuột và dịch
chuyển chậm (hoặc nhanh) về phía con
trỏ chuột.
Đây là cách điều khiển khá hay. Do con
người có thể dịch chuyển nhanh chuột,
nhân vật sẽ luôn bám đuổi theo hướng đi
chuyển của chuột.
2.2. Điều khiển nhân vật bằng cách nháy chuột. Mức 1, đơn giản
Ở mức 1, việc điều khiển nhân vật sẽ được kích hoạt mỗi khi người dùng nháy
chuột. Khi không nháy chuột nữa thì việc điều khiển sẽ dừng lại. Các cách điều
khiển nãy cũng rất thuận tiện vì người điều khiển sẽ hoàn toàn chủ động khi dùng
chuột điều khiển nhân vật.
CM3 Mỗi khi người dùng nháy chuột, nhân
vật sẽ xoay về hướng con trỏ chuột và
dịch chuyển nhanh về hướng đó 1 số
bước nhất định.

dịch chuyển từ từ (sau 1 thời gian định
trước) về vị trí con trỏ chuột (tại thời
điểm nháy chuột).

dịch chuyển tức khắc về vị trí con trỏ
chuột (tại thời điểm nháy chuột).
2.3. Điều khiển nhân vật bằng cách nháy chuột. Mức 2, phức tạp hơn
Ở mức này cách điều khiển chuột sẽ phức tạp hơn 1 chút nhưng cũng rất hiệu quả
và tạo cảm giác rất chuyên nghiệp. Tính năng cơ bản nhất của cách điều khiển
bằng chuột này là thông qua 1 biến nhớ trạng thái (ví dụ biến FolowOn), ý nghĩa
của biến này như sau.
Khi FolowOn = 1 thì trạng thái điều khiển chuột được kích hoạt, khi đó chuột sẽ
bắt đầu điều khiển nhân vật.
Khi FolowOn = 0, trạng thái điều khiển nhân vật sẽ không có tác dụng nữa.
Người dùng sẽ nháy chuột để thay đổi trạng thái của biến nhớ FolowOn này.
Đoạn chương trình sau mô tả công nghệ mấu chốt của cách điều khiển chuột mức
2 này.
Khi người dùng nháy chuột, hàm (biến) cảm ứng được kích hoạt
và nhận giá trị True (hay 1). Nhưng người dùng khi nháy chuột sẽ có 1 thời gian
rất ngắn vẫn giữ tay trên chuột, do đó giá trị sẽ luôn giữ giá trị
True 1 thời gian ngắn. Do vậy muốn đảm báo tính chính xác của phương pháp
tính giá trị FolowOn này cần đưa vào 1 lệnh cho chương trình tạm nghỉ 1/10 giây,
tức lệnh , nó sẽ đảm bảo cho người dùng cảm nhận chính xác sự
thay đổi của FolowOn sau mỗi lần nháy chuột. Đoạn chương trình điều khiển như
sau:
Bắt đầu nhận sự kiện nháy chuột.
Chờ 0.1 giây để hệ thống không nhận thêm

bất kỳ thông tin nháy chuột nào nữa.
Xử lý biến hệ thống
FolowOn
Sau đây là các khả năng, cách thực hiện điều khiển nhân vật bằng chuột, mức 2.
CM6 Dùng nháy chuột để bật tắt chế độ
điều khiển bằng chuột.
Khi chế độ bật, phương pháp CM2
sẽ được kích hoạt: Nhân vật luôn
xoay về phía con trỏ chuột và
chuyển động chậm (hoặc nhanh) về
phía con trỏ chuột.
sẽ được kích hoạt: Nhân vật luôn
dính chặt với con trỏ chuột.

sẽ được kích hoạt: Nhân vật sẽ luôn
xoay về hướng con trỏ chuột và
dịch chuyển từ từ (sau 1 thời gian
định trước) về vị trí con trỏ chuột
(tại thời điểm nháy chuột).
3. Mô phỏng di chuyển chuột
Phân biệt 2 trường hợp mô phỏng di chuyển chuột. Chương trình cần nhận biết
được thời điểm con trỏ chuột đi qua 1 nhân vật.
1) Chủ thế là nhân vật chính
Trường hợp lập trình điều khiển nhân vật chính, lập trình trên cửa sổ lệnh của
nhân vật. Khi đó biểu thức (hàm số) tính khoảng cách từ nhân vật đến vị trí con
trỏ chuột sẽ được sử dụng. Trong ví dụ sau mỗi khi di
chuyển chuột đi qua gần tâm của nhân vật (khoảng cách < 5) thì nhân vật sẽ
2) Chủ thể là sân khấu

Trường hợp lập trình trên cửa sổ lệnh của sân khấu. Khi đó không có hàm số tính
trực tiếp khoảng cách đến tâm nhân vật nên phải dùng 1 biểu thức tính toán như
trong đoạn chương trình sau:
Bài toán luyện kỹ năng di chuyển chuột

Chúng ta sẽ thiết kế chương trình (phần mềm) dành cho học sinh luyện kỹ năng di
chuyển chuột chính xác. Xét 1 phương án, kịch bản như sau.
Mỗi bài luyện, một quả bóng sẽ xuất hiện ngẫu nhiên trên màn hình. Người dùng
cần di chuyển chuột chính xác qua quả bóng này. Nếu thực hiện đúng, quả bóng
sẽ ẩn đi và hiện trở lại tại 1 vị trí ngẫu nhiên khác với kích thước nhỏ đi. Quá trình
này lặp lại 20 lần thì kết thúc 1 bài luyện.
Sau mỗi bài luyện, chương trình sẽ hiện 1 biển hiệu thông báo. Nháy lên biển hiệu
này để thực hiện lại bài luyện.
Danh sách các biến nhớ hệ thống quan trọng của chương trình:
Tên biến Ý nghĩa Ghi chú thêm
Move_status Mô tả trạng thái của việc di chuyển chuột Biến này có tác
của bài luyện. dụng đếm số lượt
của việc luyện kỹ
Move_status = 0, đang di chuyển, chưa tìm
thấy đích. năng di chuyển
chuột.
Move_status = 1, đã tìm thấy đích.
OriginSize Tham số mô tả kích thước gốc, ban đầu
của quả bóng. Trong quá trình luyện tập,
quả bóng chính sẽ nhỏ dần để tăng độ khó
của việc di chuyển chuột tới đích.
KC Giá trị dùng để xác định tiêu chuẩn di Giá trị này cũng
chuyển tới đích: khi khoảng cách từ vị trí sẽ giảm dần.
con trỏ chuột tới tâm quả bóng < KC.
Các nhân vật chính:

Hình ảnh Tên nhân vật Ý nghĩa
Ball Nhân vật chính của chương trình dùng để
luyện kỹ năng di chuyển chuột. Người dùng
phải luyện kỹ năng di chuyển chuột đi qua
nhân vật (quả bóng) này.
Banner Biển hiệu thông báo giữa 2 lần luyện tập.
Sơ đồ thiết kế chương trình đơn giản như sau:
Mo phong Reset
tap di chuyen
chuot.sb2 Thực hiện liên tục 20 bài
Reset luyện kỹ năng di chuyển
chuột. Sau mỗi lần, quả
bóng bé đi và yêu cầu khó
Hiện khi nhận thông điệp Reset. hơn. Khi kết thúc gừi thông
Đợi người dùng nháy chuột thì điệp Reset.
ẩn đi và gửi thông điệp Start.
Start
Sơ đồ làm việc của chương trình khá đơn giản. Phần lõi của chương trình nằm ở
quả bóng khi tiếp nhận thông điệp Start. Thông điệp Reset chỉ có tác dụng hiển
thị bảng thông báo giữa 2 lần luyện tập.
Lập trình
Đây là đoạn chương trình điều khiển quả bóng xuất hiện 20 lần cho mỗi bài luyện
tập di chuyển chuột.
Thiết lập các tham số ban đầu. Time
là tham số đếm lượt quả bóng còn lại
cần luyện tập.
Phần xử lý chính cho 20 lần luyện

tập. Ta thấy ra biến Move_status chỉ
có giá trị đếm số lượt.
Kết thúc bài luyện trả lại kích thước ban

đầu quả bóng, gửi thông điệp Reset và
dừng chương trình điều khiển.
Đoạn chương trình sau xử lý khi di chuyển chuột lên quả bóng.
Điều kiện thế nào là di

chuột lên quả bóng.
Xử lý ngay khi chuột đi qua

quả bóng: bóng chuyển qua
chỗ khác, kích thước nhỏ
đi, KC giảm đi.
4. Mô phỏng tập nháy chuột

Chúng ta sẽ thiết kế chương trình luyện nháy chuột đơn giản sau: chương trình sẽ
là 1 dãy các bài luyện liên tục được chia làm nhiều mức (biến level). Mỗi mức là 1
bài luyện như sau: 1 quả bóng sẽ phân thân thành 20 quả và chuyển động ngẫu
nhiên trên màn hình, mức càng cao càng chuyển động nhanh. Khi người dùng
nháy lên 1 quả thì quả này biến mất. Xóa được toàn bộ 20 quả thì chương trình sẽ
tự động chuyển sang mức tiếp theo. Sẽ có 1 biển hiệu hiện để thông báo chuyển
sang mức tiếp theo.
Danh sách biến nhớ hệ thống:
Level Mức của chương trình. Giá trị này Khi bắt đầu chương
càng cao, luyện tập càng khó. trình level=0.
Score Điểm số của người chơi.
luyện kỹ năng nháy chuột.
Banner Biển hiệu thông báo giữa 2 mức luyện tập.
Mo phong Next
tap nhay
chuot.sb2
Thực hiện sinh 20 clone của
Next quả bóngđể luyện kỹ năng
nháy chuột. Nháy lên quả
bóng sẽ làm bóng biến mất.
Hiện khi nhận thông điệp Next. Đợi Khi đã hết bóng gừi thông
người dùng nháy chuột thì ẩn đi, tăng điệp Next.
biến nhớ Level và gửi thông điệp Start.
Start
Lập trình cho nền sân khấu:
Nhiệm vụ của sân khấu là thiết

lập các thông số ban đầu và ra
thông điệp Next để chuẩn bị bắt
đầu chương trình. Biến thời gian
để hiển thị thời gian đã chơi.
Lập trình cho Banner:
Nhiệm vụ của sân khấu là thiết

lập các thông số ban đầu và ra
thông điệp Next để chuẩn bị bắt
đầu chương trình. Biến thời gian
để hiển thị thời gian đã chơi.
Lập trình cho quả bóng:
Chương trình Chương trình cho mỗi quả Khi ngừoi dùng nháy
chính: sinh 20 bóng clone. lên 1 quả bóng.
quả bóng clone.
Sinh liên tục 20 Mỗi quả bóng clone sau khi sinh Khi nháy lên 1 quả
clone và sau đó ra sẽ chuyển hướng ngẫu nhiên bóng thì quả bóng này
chờ đến khi kết và chuyển động với vận tốc tỉ lệ bị xóa đi.
thúc sẽ gửi thông thuận với level (cụ thể = 2 x
điệp Next. level).
5. Mô phỏng tập kéo thả chuột

Biến nhớ hệ
Chúng ta sử dụng biến nhớ hệ thống drag để mô tả trạng thái của việc kéo thả
thống drag dùng
chuột.
để mô tả trạng
thái kéo thả
Ý nghĩa biến drag như sau:
chuột.
drag = 1, nếu đang trong tình
trạng kéo thả chuột.
drag = 0, không trong tình
trạng kéo thả chuột.
Bài toán luyện kỹ năng kéo thả chuột

Chúng ta sẽ thiết kế chương trình (phần mềm) dành cho học sinh luyện kỹ năng
kéo thả chuột chính xác. Kịch bản của chương trình này gần giống kịch bản
chương trình luyện kỹ năng nháy chuột.
Mỗi bài luyện, quả bóng sẽ xuất hiện ngẫu nhiên trên màn hình. Người dùng cần
kéo thả chuột chính xác đến 1 hình tròn nhỏ bên trái màn hình. Nếu thực hiện
đúng, quả bóng sẽ ẩn đi và hiện trở lại tại 1 vị trí ngẫu nhiên khác, hình tròn nhỏ
cũng hiện lại ở 1 vị trí khác với kích thước nhỏ đi. Quá trình này lặp lại 20 lần thì
kết thúc 1 bài luyện. Như vậy càng về sau việc kéo thả càng khó. Sau mỗi bài
luyện, chương trình sẽ hiện 1 biển hiệu thông báo. Kéo thả biển hiệu này ra khỏi
sân khấu đề để thực hiện lại bài luyện.
drag Biến nhớ hệ thống chính mô tả trạng thái
của chuột: kéo thả hay không.
drag_status Mô tả việc kéo thả đã thành công hay
chưa.
drag_number Số lần thực hiện kéo thả ở mỗi bài luyện. Mặc định = 20.
Times Biến đếm số lần còn lại cần kéo thả.
Thời gian Thời gian cho mỗi bài luyện kéo thả.
luyện kỹ năng kéo thả chuột. Người dùng
cần kéo thả quả bóng đến vị trí Circle.
Circle Nhân vật dùng làm đích của việc kéo thả.
Mo phong Reset
tap keo tha
chuot.sb2
Thực hiện liên tục 20 bài
Reset luyện kỹ năng kéo thả. Sau
mỗi lần, vòng tròn đích bé
đi và yêu cầu khó hơn. Khi
Hiện khi nhận thông điệp Reset. Đợi kết thúc gừi thông điệp
người dùng kéo thả ra đến cạnh thì Reset.
ẩn đi và gửi thông điệp Start.
Start
quả bóng và vòng tròn khi tiếp nhận thông điệp Start. Thông điệp Reset chỉ có
tác dụng hiển thị bảng thông báo giữa 2 lần luyện tập.
Lập trình cho sân khấu:
Đoạn chương trình lõi Thiết lập các thông số Đoạn chương trình hiển thị
thiết lập tham số drag. ban đầu và gửi thông thời gian trên màn hình khi
điệp Reset. bắt đầu luyện tập.
Lập trình cho quả bóng.
Đoạn chương trình ban đầu, chờ cho quá trình luyện tập kết thúc và gửi thông
điệp Reset.
Thiết lập các thông số ban đầu:

Times=20, trạng thái drag_status = 0,
hiển thị ngẫu nhiên trên sân khấu.
Sau đó chờ cho đến khi Times = 0, tức
là khi đã luyện tập xong 20 bài kéo thả
thì gửi thông điệp Reset để kết thúc bài
luyện.
Sau đây là đoạn chương trình chính điều khiển quá trình kéo thả quả bóng đến
đích, chương trình này được kích hoạt khi người dùng bắt đầu nháy chuột để tiến
hành kéo thả quả bóng đến vòng tròn.
Sau khi người chơi nháy

chuột lên quả bóng thì bắt
sự kiện kéo thả, chờ cho
đến khi nhả chuột (hết kéo
thả) thì thực hiện tiếp.
Nếu kéo thả chính xác:

Chuyển nhanh đến vị trí đích,
chờ 1 giây, sau đó khởi động
lại lần tập tiếp theo: thay đổi
các tham số Times,
drag_status, trang phục và hiển
thị ngẫu nhiên tại vị trí khác.
Nếu kéo thả sai:

Chuyển động về vị trí ban
đầu để làm lại.
Lập trình cho vòng tròn đích (nhân vật Circle).
Thiết lập 20 vòng lặp để xử
lý từng bài luyện kéo thả.
Hiển thị tại 1 vị trí ngẫu
nhiên bên trái màn hình.
Khi người chơi thực hiện xong 1 thao tác

kéo thả (drag_status = 1) thì thiết lập lại
trạng thái biến nhớ này, chuyển trang
phục và làm nhỏ kích thước của mình.
Lập trình cho Banner.

Banner sẽ chỉ xuất hiện khi nhận được thông điệp Reset và có tác dụng nghỉ giải
lao giữa 2 bài luyện.
Để phù hợp với bài luyện, yêu cầu người chơi cần kéo thả biển báo hiệu này ra
ngoài cạnh sân khấu để bắt đầu bài luyện chính thức.
Đây là đoạn chương trình điều khiển kéo thả Banner ra cạnh sân khấu.
Biển hiệu Banner sẽ xuất

hiện giữa 2 bài luyện tập.
Muốn thực hiện tiếp cần
kéo thả biển hiệu này ra
gặp cạnh sân khấu.
Nếu kéo thả sai thì phải

kéo thả lại.
6. Mô phỏng tập nháy đúp chuột

Nháy đúp chuột là sự kiện khó mô phỏng nhất trong Scratch.
Để mô tả được sự kiện nháy đúp chuột, cần bắt được 2 thời điểm sát nhau của
nháy chuột, đủ gần nhau để coi là 1 lần nháy đúp.
Để bắt được 2 thời điểm nháy chuột nhanh này, chúng ta
Biến nhớ hệ thống Mô tả ý nghĩa Ghi chú thêm
DoubleClick Tham số chỉ trạng thái đã thực = 1 nếu thực hiện thành
hiện thành công hay chưa công nháy đúp chuột.
nháy đúp chuột.
t1, t2 2 thông số thời gian ghi lại 2
lần nháy chuột sát nhau để tạo
thành 1 cuộc nháy đúp
(doubleclick).
Sau đây mô tả thuật toán có thể thiết lập trạng thái nháy đúp chuột thông qua biến
DoudbleClick.
Thủ tục Init thiết lập trạng thái ban đầu. Chú ý rằng sau khi thiết lập được trạng
thái DoudbleClick = 1, cần có thời gian (khoảng 0.5 đến 1 giây) chờ trước khi
chạy lại Init.
Thủ tục
Init
Thủ tục Init
Thuật toán chính kiểm tra và nhận biết nháy đúp chuột như trong chương trình
sau:
Thuật toán
kiểm tra Lần bắt thứ nhất của nháy
nháy đúp chuột. Đặt đồng hồ cho t1
chuột. và đặt t2 = 0.
Thời gian giữa 2 lần nháy

chuột (rất quan trọng!)
Lần bắt thứ hai của nháy
chuột. Đặt đồng hồ cho t2 và
kiểm tra khoảng cách giữa 2
lần nháy.
Sau khi thiết lập DoubleClick
=1 cần thời gian chờ từ 0.5
đến 1 giây trước khi Init.
Thiết kế phần mềm mô phỏng tập nháy đúp chuột.

Chương trình này cũng được thiết kế đơn giản như các phần mềm mô phỏng các
thao tác với chuột ở trên. Bài luyện chính sẽ bao gồm 10 lần thực hiện đúng nháy
đúp chuột lên quả bóng. Giữa các bài luyện sẽ hiện biển thông báo. Nháy đúp lên
biển hiệu này để thực hiện lại bài luyện chính.
DoubleClick Tham số chỉ trạng thái đã thực hiện thành = 1 nếu thực hiện
công hay chưa nháy đúp chuột. thành công nháy
đúp chuột.
t1, t2 2 thông số thời gian ghi lại 2 lần nháy
chuột sát nhau để tạo thành 1 cuộc nháy
đúp (doubleclick).
DClick_Num Số lần cần thực hiện thao tác nháy đúp. Mặc định = 10.
Timing Thời gian chơi cho mỗi bài luyện tập.
luyện kỹ năng nháy đúp chuột. Người
dùng cần thực hiện thao tác nháy đúp
chuột lên quả bóng này.

Mo phong
tap nhay Reset
dup
chuot.sb2
Thực hiện liên tục DClick-
Reset Num (20) bài luyện kỹ năng
kéo thả. Khi kết thúc gừi
thông điệp Reset.
Hiện khi nhận thông điệp Reset. Đợi
người dùng nháy đúp chuột thì ẩn đi
và gửi thông điệp Start.
Start
quả bóng khi tiếp nhận thông điệp Start. Thông điệp Reset chỉ có tác dụng hiển
thị bảng thông báo giữa 2 lần luyện tập.
Lập trình cho sân khấu.
Sân khấu là nơi thực hiện công việc chính: nhận biết trạng thái nháy đúp chuột
của người dùng tại bất cứ thời điểm nào. Sân khấu cũng là nơi gửi thông điệp
Reset đầu tiên.
Đoạn chương
trình này hiển thị
thời gian chạy
trong khi luyện
tập.
Đoạn chương
trình chính nhận
biết trạng thái
nháy đúp chuột
của người dùng.
Lập trình cho Banner.
Banner có nhiệm vụ chính hiển thị giữa 2 bài luyện tập. Nháy đúp chuột lên biển
hiệu này để vào bài luyện tập chính.
Đoạn chương trình kiểm tra việc

nháy đúp trên biển hiệu này để
chuyển sang chế độ luyện tập.
Lập trình cho quả bóng.

Ý tưởng như sau: sau khi nhận biết được thao tác nháy đúp chuột đã hoàn tất thì
kiểm tra vị trí con trỏ chuột có nằm trên quả bóng hay không.
Lặp lại 20 lần thao tác luyện nháy

đúp chuột.
Chờ cho đến khi thực hiện xong 1

thao tác nháy đúp chuột.
Kiểm tra xem có nháy trên quả

bóng hay không?
Nếu đúng, thông báo đã hoàn
thành, nếu sai, thông báo đã nháy
đúp sai vị trí.
Kết thúc, gửi thông điệp Reset.
7. Phần mềm tập gõ bàn phím

Chúng ta sẽ cùng thiết kế 1 phần mềm mô phỏng luyện gõ bàn phím.
Mô phỏng tập Đây là 1 chương trình tương

gõ 10 ngón đối khó và phức tạp. Yêu cầu
trên bàn tối thiểu là phải mô tả được quá
phím. trình gõ từng ký tự, chữ cái trên
màn hình. Nếu có minh họa
bằng hình ảnh các ngón tay phụ
trách thì càng tốt.
Chúng ta cùng phân tích và thiết kế chương trình này.
1) Mô tả kịch bản
Đầu vào của chương trình là 1 dãy các từ (xâu ký tự) cần cho HS luyện gõ bàn
phím. Để có thể hiện chính xác và to trên màn hình, sẽ yêu cầu hạn chế độ dài của
các từ này, ví dụ hạn chế độ dài mỗi xâu không quá 10 ký tự (kể cả dấu cách).
Phần mềm sẽ hiện lần lượt từng từ (xâu) trên màn hình và yêu cầu HS tập gõ.
Trong quá trình gõ bàn phím, gõ tới đâu sẽ có 1 thanh ngang nhỏ chỉ ra vị trí đang
gõ và phía dưới hiện bàn tay có ngón tay phụ trách phím cần gõ.
Mô hình mô phỏng như vậy sẽ hoàn toàn tương tự như phần lõi của các chương
trình luyện gõ bàn phím trên thế giới.
2) Phân tích thuật toán thể hiện xâu chữ trên màn hình
Trong thiết kế phần mềm này có lẽ khâu khó nhất là cách thể hiện một từ, xâu ký
tự lên màn hình bằng hình ảnh đồ họa (chứ không phải bằng biến nhớ hay lời hội
thoại nhân vật).
Như vậy cần thiết kế các nhân vật có hình ảnh là bộ chữ cái cần thể hiện.
abcd mn
Độ rộng của 1 Khoảng cách từ tâm chữ c đến tâm chữ d sẽ
chữ cái, ký tự = ((độ rộng c) + (độ rộng d))/2
Để hiện thị xâu ký tự trên màn hình bằng hình ảnh lớn chúng ta sử dụng lệnh vẽ
stamp với dãy các nhân vật ứng với từng chữ cái đó. Nhân vật Char sẽ đóng vai
trò trung tâm của phần mềm thể hiện dãy các ký tự cần luyện gõ bàn phím. Vì
Scratch không nhận biết được các ký tự đặc biệt (ví dụ . , : ; / ) nên bộ trang phục
của Char sẽ chỉ hạn chế trong bảng chữ cái tiếng Anh, các chữ số từ 0 đến 9 và
dấu cách (space). Bộ trang phục của Char như sau:
1 2 3 4 5 6 7 8 9 10
a b c d e f g h i j
11 12 13 14 15 16 17 18 19 20
k l m n o p q r s t
21 22 23 24 25 26 27 28 29 30
u v w x y z 0 1 2 3
31 32 33 34 35 36 37
4 5 6 7 8 9 space
3) Mô tả nhân vật
Hình ảnh Tên nhân Ý nghĩa Ghi chú thêm
vật
Char Nhân vật chính của phần mềm Đi với nhân vật
có nhiệm vụ thể hiện các từ, dãy này sẽ có nhiều
ký tự bằng hình ảnh trên màn dãy dữ liệu quan
hình. Nhân vật này có 37 trang trọng.
phục. Chú ý tên của trang phục
trùng với tên chữ cái (trừ ra
trang phục số 37 có tên space).
Paddle Thanh ngang có nhiệm vụ hiện
tại vị trí bên dưới ký tự đang cần
gõ phím.
GV GV đóng vai trò MC của chương
trình, hướng dẫn HS thực hiện
bài luyện gõ bàn phím.
Fingers Hình ảnh 2 bản tay dùng để Nhân vật này có

minh họa ngón tay phụ trách. 9 trang phục,
Khi gõ đến phím nào thì hình đánh số từ 1 đến
ảnh bàn tay này sẽ hiện đúng 9.
ngón tay phụ trách phím đó.
Trang phục của nhân vật Finger. Chú ý tên của trang phục bắt buộc trùng với số
thứ tự của bảng này.
1 2 3 4 5
6 7 8 9
4) Biến nhớ hệ thống tổng thể

Word_List (list) Dãy các từ gốc đầu vào của chương
trình. Phần mềm sẽ lần lượt cho HS
luyện gõ phím các từ trong bảng này,
mỗi từ 1 lần thể hiện trên màn hình.
Word Biến nhớ này sẽ lưu 1 từ lấy từ 1 hàng
của bảng Word_List để thể hiện trên
màn hình cho bài luyện.
CharList (list) Dãy các chữ cái lấy từ Word.
CharKc (list) Dãy các độ rộng tương ứng các chữ cái
trong Word.
CharFinger (list) Dãy các số tương ứng ngón tay phụ
trách tương ứng với các chữ cái của
Word.
Keyboard_Practice Biến nhớ hệ thống chỉ ra là đã thực
hiện xong phần luyện gõ của xâu ký tự
Word chưa.
Char Biến nhớ lưu các ký tự của Word.
keypressed Biến nhớ lưu giá trị phím đã gõ. Vậy
nếu Char = keypressed thì đã gõ đúng.
5) Biến nhớ riêng cho Char dùng để thể hiện xâu chữ trên màn hình
Các biến nhớ này là biến nhớ riêng của nhân vật Char, có nhiệm vụ hỗ trợ thể hiện
1 từ, xâu ký tự trên màn hình.
Bảng, dãy dữ liệu gốc, hệ thống.
Alphabet (list) Bảng, dãy các chữ cái tương ứng với
trang phục của Char. Bảng này có
37 phần tử.
AlphabetWide Độ rộng (tính bằng point) của các ký
(list) tự trang phục tương ứng của nhân vật
Char.
AlphabetFinger Bảng lưu giá trị tương ứng với trang Bảng này cũng có
(list) phục của nhân vật Finger chỉ ra ngón 37 giá trị.
tay phụ trách của ký tự hiện thời. Ví
dụ phần tử thứ 37 của bảng này có
giá trị 5.
Bảng, dãy dữ liệu dùng để lưu trữ thông tin tạm thời
trong quá trình thể hiện trên màn hình một từ, xâu ký
tự Word.
WList (list) Dãy các ký tự lấy ra từ Word. Bảng này lấy
thông tin từ
Alphabet
WKc (list) Dãy các độ rộng của các ký tự từ Bảng này lấy
Word. thông tin từ
AlphabetWide
WFList (list) Dãy các tham chiếu ngón tay phụ Bảng này lấy
trách của các ký tự lấy từ Word. thông tin từ
AlphabetFinger
6) Sơ đồ thiết kế hệ thống
Tap go ban Hiển thị trên màn hình

phim.sb2 xâu Word. Gửi thông
điệp Start.
Chuẩn bị bộ dữ liệu theo
từng dòng của Start
Word_List. Lấy ra 1
dòng đưa vào biến nhớ
Word. Gửi thông điệp
Reset. Chờ người dùng gõ 1
Reset phím, kiểm tra xem
Đợi làm xong 1 từ sẽ đúng không. Gửi thông
chuyển sang từ tiếp theo Thông báo người điệp ShowFinger.
của Word List và lại gửi dùng bắt đầu gõ
thông điệp Reset. phím ShowFinger
Chờ người dùng thực Thông báo bài

hiện xong tất cả các bài luyện đã kết
luyện (tương ứng tất cả thúc.
các dòng của Word_List Thay đổi trang
thì gửi thông điệp phục tương ứng.
Finish.
Finish
Có thể mô tả nhanh Sơ đồ trên như sau:

- Trên trang của nhân vật Char đã có sẵn thủ tục tổng quát thể hiện 1 từ, xâu bất
kỳ trên màn hình tại 1 tọa độ (X, Y) cho trước. Thủ tục này có tên Show Word
<Word> at X, Y. Thủ tục này đồng thời nạp dữ liệu đầy đủ cho 3 mảng dữ liệu
WList, WFList và Wkc. WList lưu các chữ cái của Word, WFList lưu các thông
số ngón tay phụ trách tương ứng, Wkc lưu độ rộng của các chữ cái này.
- Chương trình bắt đầu từ mảng Word_List bao gồm 1 dãy các từ cần tập gõ bản
phím. Sân khấu sẽ làm nhiệm vụ này: lần lượt lấy ra từng phần tử của Word_List,
đưa vào biến nhớ Word và chuyển điều khiển bằng thông điệp Reset. Sau khi
người dùng thực hiện xong tất cả các từ của Word_List thì thông báo kết thúc
bằng thông điệp Finish.
- Khi nhận thông điệp, Char sẽ hiển thị từ Word trên màn hình, sau đó sao chép
bộ dữ liệu riêng WList, WFList, Wkc sang bộ dữ liệu chung CharList,
CharFinger và CharKc, sau đó gửi thông điệp Start để bắt đầu bài luyện.
- Nhân vật Paddle nhận thông điệp Start bắt đầu nhận sự kiện gõ phím của người
dùng theo từng ký tự của dãy CharList. Sau mỗi 1 ký tự gõ đúng, thanh ngang sẽ
chuyển sang phần tử tiếp theo. Mỗi khi hiển thị xong thanh ngang, sẽ gửi thông
điệp ShowFinger để báo cho nhân vật Finger hiển thị đúng hình 2 bàn tay.
Khi gõ xong từ này thì gán Keyboard_Practice = 1 để thông báo cho sân khấu
chuyển từ tập gõ tiếp theo.
7) Lập trình
7.1. Thủ tục hiển thị xâu ký tự bằng hình ảnh trên màn hình (nhân vật Char)
Thủ tục Init <Word>
Thủ tục này có chức năng thiết lập các bộ dữ liệu ban đầu như WList, WFList,
Wkc.
Thiết lập ban đầu: xóa các

mảng dữ liệu cần thiết lập.
Với mỗi ký tự ch trong Word

kiểm tra chỉ số của ký tự này
trong bảng Alphabet.
Nếu có thì cập nhật thông tin

tương ứng của ký tự này vào
các bảng WList, WFList và
Wkc.
Thủ tục chính: Show Word <Word> at <X>, <Y>

Thủ tục này đóng vai trò trung tâm của toàn bộ chương trình. Công nghệ chính
hiển thị 1 chữ to trên màn hình là lệnh stamp. Sau đây là chương trình chi tiết cho
thủ tục Show Word.
Lấy từ ký tự từ WList.
Chuyển trang phục sang tên ch. Nếu

là dấu cách thì điều kiển riêng,
chuyển sang trang phục space.
Chuyển sang
vị trí bên phải
của ký tự tiếp
theo.
7.2. Lập trình cho sân khấu
Đoạn chương trình sau của sân khấu mô tả toàn bộ hoạt động chính của chương
trình.
Vòng lặp với từng từ trong

Word_List.
Với mỗi phần từ trong Word_List,
gán vào Word, gửi thông điệp
Reset để Char hiển thị và đợi người
dùng gõ xong từ này sẽ làm tiếp.
Cuối cùng gửi thông điệp Finish để
kết thúc.
7.3. Lập trình cho Char

Khi nhận được Reset, nhân vật Char sẽ thể hiện từ Word trên màn hình và sao
chép bộ dữ liệu chính sang các mảng chung: CharList, Charkc, CharFinger.
Sau khi hiển thị xong gửi thông điệp Start để bắt đầu quá trình người dùng luyện
gõ phím.
Thể hiện Word trên màn hình.
Xóa, thiết lập ban đầu các bảng

CharList, Charkc, CharFinger
Sao chép toàn bộ dữ liệu từ các

bảng riêng WList, Wkc, WFList
sang các bảng chung CharList,
Charkc, CharFinger
Gửi thông điệp Start.
7.4. Lập trình cho Paddle

Khi nhận được thông điệp Start, Paddle sẽ triển khai nhận sự kiện gõ bàn phím
của người dùng để xử lý.
Thủ tục WhatKey có nhiệm vụ nhận dạng phím do người dùng gõ và gán vào
biến nhớ keypressed.
WhatKey là thủ tục rất dài vì phần mềm phải xử lý tất cả các phím cần nhận biết.
Có tất cả 37 block lệnh trong thủ tục này.
Dưới đây là 1 phần đầu của thủ tục WhatKey.
Giá trị ban đầu của
keypressed được gán là ?
Nếu nhận được phím gõ thì

lập tức gán keypressed và
dừng thủ tục.
Sau đây là đoạn chương trình của nhân vật Paddle khi nhận thông điệp Start.
Mục đích: dịch chuyển thanh ngang bên dưới các ký tự sẽ yêu cầu người dùng gõ
phím. Nếu gõ đúng chuyển sang ký tự bên phải, cứ như vậy cho đến cuối từ.
Hiện ở ký tự đầu tiên.
Yêu cầu Finger hiện

hình ảnh ngón tay phụ
trách ký tự này.
Đợi người dùng gõ phím

thông qua WhatKey.
Chuyển sang ký tự tiếp
theo, dịch chuyển thanh
ngang sang bên dưới ký tự
tiếp theo.
Cuối cùng gán
Keyboard_practice =1.
7.5. Lập trình cho Finger
Nhiệm vụ của Finger là thay đổi

trang phục đến đúng số thứ tự được
chỉ ra trong bảng CharFinger.
7.6. Lập trình cho Giáo viên
Ví dụ 1 cách lập trình cho Giáo viên.
8. Ví dụ: phần mềm Mouse Skills
Chúng ta sẽ thiết kế một phần mềm gộp tất cả các tính năng tập luyện chuột (đã
mô tả ở trên) vào trong một chương trình.
Mouse Skills.sb2
Phần mềm sẽ có 4 chế độ tập

luyện với chuột, nháy lên 1 nút sẽ
vào chế độ luyện tập tương ứng.
Ý tưởng kịch bản phần mềm được mô tả trong hình trên, cụ thể như sau:
- Phần mềm sẽ có 4 chế độ luyện tập: di chuyển chuột, nháy chuột, kéo thả chuột
và nháy đúp chuột. Nháy lên 1 nút lệnh sẽ vào chức năng tương ứng. Khi thực
hiện xong bài luyện, phần mềm lại quay trở lại trạng thái chờ có 4 nút lệnh như
hình trên.
- Chế độ di chuyển chuột (Move):
Trên màn hình xuất hiện quả bóng tại vị trí ngẫu nhiên. Người dùng cần di chuột
lên quả bóng này, quả bóng sẽ ẩn đi và xuất hiện tại 1 vị trí khác với kích thước
nhỏ đi. Quá trình cứ như vậy, sau 10 lần thì kết thúc.
- Chế độ nháy chuột (Click):
Trên màn hình xuất hiện đồng thời 10 quả bóng chuyển động ngẫu nhiên. Người
chơi cần náy chuột lên các quả bóng để làm chúng biến mất. Khi đã làm biến mất
tất cả 10 quả bóng thì bài luyện kết thúc.
- Chế độ kéo thả chuột (Drag):
Trên màn hình xuất hiện quả bóng tại vị trí ngẫu nhiên. Người dùng cần kéo thả
quả bóng này đến 1 vị trí cố định bên trái màn hình. Nếu kéo thả không chính xác
quả bóng sẽ quay về vị trí cũ yêu cầu làm lại từ đâu. Bài luyện kết thúc sau khi
thực hiện kéo thả thành công 10 lần.
- Chế độ nháy đúp chuột chuột (DoubleClick):
Trên màn hình xuất hiện quả bóng tại vị trí ngẫu nhiên. Người dùng cần nháy đúp
chuột lên quả bóng này, quả bóng sẽ ẩn đi và xuất hiện tại 1 vị trí khác. Cần thực
hiện đúng thao tác này 10 lần.
Danh sách nhân vật chính:
luyện kỹ năng chuột. Tùy thuộc vào từng
chức năng, cách sử dụng và thao tác với
quả bóng sẽ khác nhau.
Giáo viên. Đóng vai trò MC của chương trình.
Move; Các nút lệnh chính dùng để vào các chế độ

luyện tập chính của chương trình.
Click;
Drag;
DoubleClick.
Danh sách biến nhớ hệ thống:

Move_Mode; Nhóm biến nhớ mô tả chế độ Tại một thời điểm
Click_Mode; đang luyện tập của chương trình. chỉ có thể 1 biến nhớ
Drag_Mode; Ví dụ: Move_Mode = 1 có nghĩa của nhóm này = 1,
DoubleClick_Mode là đang ở chế độ luyện tập di các biến còn lại phải
chuyển chuột. = 0.
Reset Ý nghĩa như sau: Như vậy: nếu Reset
= 0, tất cả các nút
Reset = 1, đang có 1 chế độ
lệnh sẽ hiện ra; nếu
luyện tập làm việc.
Reset = 1, tất cả các
Reset = 0, chế độ chờ chưa có nút lệnh sẽ phải ẩn
nút lệnh nào được nháy. đi.
drag Biến nhớ mô tả trạng thái kéo thả
(tổng quát) của chuột.
= 1, đang ở trạng thái kéo thả.
= 0, không ở trạng thái kéo thả.
move_status Biến nhớ mô tả trạng thái di
chuyển chuột.
= 1, người dùng vừa di chuyển
chuột lên quả bóng.
= 0, ngược lại với ý nghĩa trên.
DoubleClick Biến nhớ mô tả trạng thái nháy
đúp chuột của người dùng.
= 1, người dùng vừa thực hiện
xong 1 thao tác nháy đúp chuột
đúng.
= 0, ngược lại với ý nghĩa trên.
Timing Thời gian được tính từ khi bắt Giá trị thời gian luôn
đầu 1 bài luyện tập, thời gian sẽ hiện trên màn hình.
dùng lại khi bài luyện tập kết HS cần thực hiện các
thúc.
bài luyện với thời
gian ngắn nhất.
Ngoài ra còn 1 số biến nhớ hệ thống nhưng dùng riêng cho từng chế độ luyện tập
chuột không nêu ra ở đây.
Sơ đồ thiết kế (tóm lược)
Reset
MoveMode ClickMode DragMode DoubleClickMode
Xử lý theo từng chức năng. Mỗi chức năng là 1 bài luyện tập chuột.
Thực hiện xong các bài luyện thì gửi thông điệp Finish.
Finish
Mô tả ngắn gọn Sơ đồ thiết kế như sau:

- Bắt đầu chương trình, sân khấu sẽ gửi thông điệp Reset cho tất cả. Khi đó các
nút lệnh chính sẽ hiển thị trên màn hình. GV thông báo để người dùng nháy chuột
lên các nút để bắt đầu bài luyện tương ứng.
- Khi người dùng nháy lên 1 trong 4 nút, thì nút này sẽ gửi thông điệp có tên
tương ứng với chế độ luyện tập. Khi đó cả 4 nút sẽ ẩn đi và bắt đầu chế độ luyện
tập tương ứng.
- Ở mỗi chế độ luyện tập, người dùng thao tác chuột theo sự điều khiển của các
lệnh của quả bóng và nền sân khấu.
- Khi thực hiện xong 1 bài luyện, quả bóng sẽ gửi thông điệp Finish. GV sẽ nhận
thông điệp, thông báo bài luyện kết thúc và gửi thông điệp Reset để bắt đầu lại từ
đâu.
Mô tả phần lập trình
Phần mô tả lập trình cho phần mềm này chỉ giới thiệu các chế độ luyện tập chính,
các phần khác bạn đọc cần hoàn thiện trong phần bài tập. Chúng ta sẽ xét từng
chức năng luyện tập của phần mềm.
Chế độ luyện tập di chuyển chuột MoveMode.
Chế độ di chuyển
Có 2 đoạn chương trình mô tả chức năng này.
chuột. MoveMode.
1. Đoạn chương trình mô tả và thiết lập thời điểm người chơi di chuyển chuột lên
đúng vị trí quả bóng, biến nhớ Move_status sẽ lập tức được gán giá trị 1. Chú ý là
sau mỗi lần thực hiện, quả bóng sẽ bé đi, khi kết thúc bài luyện, quả bóng sẽ lấy
lại kích thước ban đầu.
Tiêu chuẩn để chuột "đi qua" quả

bóng là khoảng cách đến tâm quả
bóng < 5. Khi đã đi qua thì thiết
lập Move_status=1, giảm kích
thức đi 7% và cho quả bóng xuất
hiện tại 1 vị trí khác.
Điều kiện để chương trình này

dừng lại là Reset = 0.
2. Đoạn chương trình sau là chương trình chính mô tả chức năng luyện tập di
chuyển chuột của phần mềm.
Thiết lập các giá trị ban đầu.
Vòng lặp 10 lần thực hiện thao tác

di chuyển chuột chính xác qua quả
bóng.
Sau khi thực hiện xong, thiết lập

kích thước bóng như cũ, đặt Reset
= 0 và gửi thông điệp Finish.
Chế độ nháy chuột. Chế độ luyện tập nháy chuột ClickMode.

ClickMode. Bài luyện ở chế độ này như sau: phần mềm sẽ sinh ra 10 clone của quả bóng, các
clone này sẽ chuyển động ngẫu nhiên trên màn hình. Nếu người dùng nháy lên 1
quả, quả này sẽ biến mất. Bài luyện kết thúc khi tất cả các quả bóng Clone đã
được nháy trúng và biến mất hết trên màn hình.
1. Đoạn chương trình chính: sinh Clone và đợi khi bài luyện tập kết thúc.
Số lượng quả bóng của bài

luyện = 10.
Tạo 10 clone bóng với trang

phục khác nhau.
Chờ cho đến khi bài luyện kết

thúc, gán Reset = 0 và gửi
thông điệp kết thúc Finish.
2. Đoạn chương trình ngắn điều khiển các quả bóng clone chuyển động ngẫu
nhiên trên màn hình.
3. Đoạn chương trình xử lý khi người dùng nháy chuột lên các quả bóng clone.
Khi người dùng nháy chuột lên quả bóng

clone, sau khi kiểm tra xem có đúng đang
trong chế độ luyện tập nháy chuột hay
không, thực hiện giảm giá trị Click_Num và
xóa Clone này.
Chế độ kéo thả Chế độ luyện tập kéo thả chuột DragMode.
chuột. DragMode. Việc kiểm soát trạng thái kéo thả chuột được thực hiện thông qua biến nhớ drag.
Đoạn chương trình này được viết trong cửa sổ lệnh của sân khấu.
1, Đoạn chương trình chính kiểm soát bài luyện kéo thả chuột như sau:
Thiết lập giá trị ban đầu

Drag_Num = số thao tác kéo thả
của bài luyện = 10.
Hiển thị quả bóng ngẫu nhiên.

Sau đó chờ cho đến khi kết thúc
bài luyện. Gán Reset = 0 và gửi
thông điệp kết thúc Finish.
2. Đoạn chương trình xử lý chính khi người dùng bắt đầu quá trình kéo thả trên
quả bóng.
Phần lõi của việc xử lý là đoạn chương trình sau. Khi người dùng nháy chuột lên
quả bóng, nếu kiểm tra thấy drag = 1 (đồng thời drag_mode = 1) thì bắt luôn sự
kiện này, gắn nhân vật với con trỏ chuột trong suốt thời gian kéo thả (cho đến khi
drag = 0 thì dừng lại). Sau đó sẽ tiến hành các bước kiểm tra tiếp theo.
Kiểm tra xem có ở trong chế độ kéo thả

chuột và bắt đầu đã kéo thả chuột hay chưa.
Trong suốt thời gian kéo thả, dùng lệnh Go

to mouse-pointer để gắn kết quả bóng với
đầu con trỏ chuột.
Toàn bộ đoạn chương trình xử lý thao tác kéo thả chuột trên quả bóng như sau:
Chú ý rằng trong ví dụ này, người dùng cần kéo thả quả bóng đến đúng vị trí 1
hình tròn có tọa độ (-172, 0). Điều kiện đế coi việc kéo thả thành công là vị trí quả
bóng khi dừng kéo thả phải cách tọa độ (-172, 0) không quá 5.
Kiểm tra nếu

kéo thả đúng
thì thực hiện
các lệnh này.
Nếu kéo thả

sai thì đưa
bóng về vị trí
ban đầu.
Chế độ nháy đúp Chế độ luyện tập nháy đúp chuột DoubleClickMode.
chuột. Thao các nháy đúp chuột luôn được kiểm soát bởi sân khấu và thông qua biến hệ
DoubleClickMode. thống DoubleClick. Nếu DoubleClick = 1 tức là người dùng vừa nháy đúp chuột
thành công (không liên quan đến vị trí nháy đúp của chuột). Đoạn chương trình
kiểm soát chung nháy đúp chuột như sau (đã được giới thiệu trong mục 6 của
chương này.
Đoạn chương trình chính xử lý bài luyện nháy đúp chuột.
Thiết lập giá trị DClick_Num =

10, số bài luyện nháy đúp chuột.
Trong mỗi vòng lặp, thiết lập vị

trí ngẫu nhiên và chờ cho đến khi
người dùng nháy đúng đúp chuột
để kiểm tra, xử lý tiếp.
Nếu nháy đúp đúng trên quả

bóng thì giảm giá trị
DClick_Num và hiện âm thanh
Correct.
Nếu nháy đúp sai vị trí chỉ hiện
âm thanh NotCorrect.
Kết thúc bài luyện, đặt Reset = 0

và gửi thông điệp kết thúc.
1. Hãy hoàn thiện phần mềm Mouse Skills theo thiết kế đã mô tả.
2. Mở rộng phần mềm Tập gõ bàn phím thành 1 chương trình hoàn chỉnh có
những bài học như sau:
- Bài luyện gõ phím ở hàng phím cơ sở.
- Bài luyện gõ phím hàng phím trên.
- Bài luyện gõ phím hàng phím dưới.
- Luyện gõ phím hàng phím số.
3. Mở rộng, thiết kế phần mềm luyện tập nháy chuột (phần 4) theo hướng sau:
Phần mềm sẽ có nhiều mức (level), mức càng cao càng khó và điểm số sẽ cao
hơn. Các mức được thiết kế mở rộng như sau:
- Hạn chế thời gian chơi cho mỗi mức, càng lên cao thời gian chơi càng ít đi.
Người chơi phải hoàn thành nháy chuột xóa hết các quả bóng trước khi hết thời
gian, nếu quá thời gian thì bị thua.
- Tăng số lượng quả bóng sau mỗi mức.
4. Viết chương trình mô tả luyện kéo thả chuột như sau:
Trên màn hình sẽ xuất hiện 5 quả bóng và 5 hình tròn ngẫu nhiên như hình dưới
đây.
- Các hình tròn và quả bóng có màu sắc tương tự nhau: vàng, xanh da trời, xanh lá
cây, hồng, tím.
- Các hình tròn sẽ đứng yên, còn các quả bóng chuyển động tự do trên màn hình
(gặp cạnh thì bật lại).
Nhiệm vụ của người chơi là nháy nhanh lên 1 quả bóng và kéo thả quả bóng này
về vị trí hình tròn cùng màu. Phải nháy chính xác và chuyển kéo thả ngay thì quả
bóng mới dính vào con trỏ chuột để có thể kéo thả.
Nếu thực hiện xong cả 5 quả bóng thì chiến thẳng.
5. Viết chương trình mô tả tương tự luyện tập nháy chuột nhưng dùng để kiểm tra
nháy đúp chuột. Nếu người chơi nháy đúp chuột đúng lên 1 quả bóng thì quả này
sẽ biến mất. Ban đầu các quả bóng này sẽ chuyển động ngẫu nhiên trên màn hình.
Chủ đề 6.
Phần mềm hỗ trợ học Khoa học máy tính
Mục tiêu:
- Một số thuật toán chính biến đổi số trong các hệ đếm khác nhau.
- Thiết kế phần mềm, trò chơi liên quan đến biến đổi số trong các hệ đếm khác
nhau.
- Một số phần mềm khác hỗ trợ giảng dạy khoa học máy tính trong trường phổ
thông.
Nội dung chính
1. Thuật toán biến đổi số thập phân, nhị phân và hexa
Trong phần này chúng ta sẽ thiết kế một loạt các thuật toán biến đổi số thể hiện
trong các hệ đếm khác nhau như nhị phân (binary), thập phân (decimal) và hệ 16
(hexadecimal).
Hệ nhị phân sẽ chỉ sử dụng 2 số 0, 1.
Hệ thập phân sử dụng 10 chữ số thông thường 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
Hệ hexa sử dụng 16 chữ số: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
1.1. Chuyển số nhị phân sang thập phân
Bài toán: cho 1 số nhị phân anan-1….a1 a0 (binary), cần chuyển đổi số này sang hệ
thập phân.
Chúng ta quan sát qui luật biểu diễn số dưới dạng nhị phân và tìm ra qui luật tổng
quát cho việc chuyển đổi số viết theo hệ nhị phân sang hệ thập phân.
100  100 = 1.22 + 0.2 + 0 = 4 (hệ thập phân)
111  111 = 1.22 + 1.2 + 1 = 7 (hệ thập phân)
Tổng quát chúng ta thấy:
anan-1….a1a0 (binary) = an.2n-1 + an-1.2n-2 + …. + a1.2 + a0 (decimal)
Nhìn vào công thức trên chúng ta chưa hình dung được thuật toán cần thực hiện
trên máy tính. Chúng ta sẽ viết lại quá trình tính toán theo từng bước nhỏ để tính
được số thập phân.
an
2.an + a n-1
2.( 2.an + a n-1) + a n-2
2.( 2.( 2.a n + a n-1) + a n-2) + an-3
……
2.(an.2n-3 + an-1.2n-4 + …. + a0) + a1
2.(an.2n-2 + an-1.2n-3 + …. + a1) + a0.
Như vậy sau đúng n+1 bước thì quá trình tính trên kết thúc và kết quả thu được số
thập phân cần tìm.
Số nhị phân ban đầu được đưa vào biến nhớ Binary. Số thập phân là kết quả đuọc
lưu trong biến nhớ Decimal. Các biến nhớ trung gian bao gồm index, len và ch.
Gán ban đầu: Decimal = 0, index = 1
Thuật toán len = độ dài xâu Binary
biến đổi số
Thực hiện vòng lặp với độ dài len
nhị phân sang
thập phân. ch = chữ số tương ứng chỉ số index của Binary
Decimal = 2.Decimal + ch
Tăng index lên 1
Đoạn chương trình mô tả thuật toán biến đổi hệ nhị phân sang thập phân Binary
 Decimal như sau.
Bắt đầu vòng lặp độ dài len

Lấy ra ký tự tương ứng của xâu
Binary
Thay đổi Decimal = 2*Decimal +
ch
Tăng index lên 1
1.2. Chuyển số thập phân sang nhị phân

Bài toán: cho trước số thập phân, hãy biểu diễn số này sang hệ nhị phân.
Bài toán này giải quyết vấn đề ngược lại so với bài toán trên.
Để tìm được cách làm bài này, chúng ta lại quan sát công thức:
anan-1….a1a0 (binary) = an.2n-1 + an-1.2n-2 + …. + a1.2 + a0 (decimal)
Gọi số thập phân ban đầu là D, chúng ta sẽ phân tích quá trình tính toán để tính
được lần lượt các số a0, a1 , …., a n-1, a n như sau.
Số thập phân ban đầu: D
a0 = D mod 2 (tính số dư); a n.2 n-2 + a n-1 .2n-3 + …. + a1 = D/2 (làm tròn số); (gán D
= D/2).
a1 = D mod 2; D = D/2.
…….
an-1 = D mod 2, D = D/2.
an = D mod 2, D/2 = 0, kết thúc.
Như vậy qui trình trên sẽ dừng lại khi D = 0.
Số thập phân đầu vào lưu trong biến nhớ Decimal. Xâu nhị phân đầu ra lưu trong
biến nhớ Binary. Biến ch dùng để tính các giá trị trung gian ai. Thuật toán
chuyển đổi ở trên được viết tường minh như sau:
Thuật toán Gán Binary = rỗng
biến đổi số Thực hiện lặp cho đến khi Decimal = 0
thập phân Đặt ch = Decimal mod 2;
sang nhị phân.
Decimal = Decimal / 2 (làm tròn xuống)
Bổ sung ch vào bên trái của Binary
Đoạn chương trình mô tả thuật toán chuyển đổi số Nhị phân sang Thập phân trên
được viết trong Scratch như sau:
Gán Binary = rỗng.

Vòng lặp chính với điều kiện dừng
Decimal = 0
Tính ch = số dư Decimal chia 2
Giảm Decimal khi chia cho 2
Bổ sung ch vào bên trái của
Binary
1.3. Chuyển đổi số nhị phân sang hexa

Bảng sau được thiết lập mô tả quan hệ 1-1 giữa các số nhị phân có 4 ký tự và dãy
16 ký tự cơ sở của hệ đếm hexa.
Bin Hexa Bin Hexa Bin Hexa Bin Hexa
0000 0 0100 4 1000 8 1100 C
0001 1 0101 5 1001 9 1101 D
0010 2 0110 6 1010 A 1110 E
0011 3 0111 7 1011 B 1111 F
Bảng HexaList chứa dãy các ký tự từ 0 đến F

là các chữ số cơ bản của hệ đếm Hexa.
Bảng HexaBinList chứa dãy các số nhị phân
có độ dài 4 là giá trị nhị phân tương ứng của
bảng HexaList.
Ví dụ: phần tử thứ 14 của 2 bảng này là D và
1101.
Tóm tắt ý tưởng thuật toán chuyển đổi số nhị phân sang hexa như sau:
Nhóm các nhóm 4 chữ số liền nhau của số nhị phân và chuyển đổi sang hexa
thông qua bảng biến đổi trên.
Sơ đồ thuật
toán biến đổi
001101101101
số nhị phân
0011 0110 1101
3 6 D
Viết chi tiết hơn thuật toán này như sau:
Input: Binary; Output: Hexa.
Thuật toán Bổ sung vào phía trước của Binary các chữ số 0 sao cho
biến đổi nhị tổng chiều dài của Binary chia hết cho 4.
phân sang
hexa. Lặp cho đến khi hết độ dài Binary:
Lần lượt lấy các nhóm 4 chữ số của Binary, tính từ
trái sang phải.
Với mỗi nhóm gán gr = nhóm 4 ký tự này.
Kiểm tra với bảng Bin-Hex trên (cụ thể là tìm kiểm
trong 2 dãy HexaBinList và HexaList để gán ký tự
hexa tương ứng gr vào biến ch.
Bổ sung ch vào phía phải Hexa.
Thuật toán này được cài đặt trên Scratch như sau:
Chương Gán giá trị ban đầu hexa =
trình chi rỗng.
tiết biến đổi
Binary sang Bổ sung vào bên trái của
Hexa. Binary các chữ số 0 sao cho
chiều dài của Binary chia
hết cho 4.
Bắt đầu vòng lặp của từng

nhóm 4 chữ số của Binary.
4 chữ số liên tục của Binary

được gom lại đưa vào biến
gr.
Tìm chỉ số của gr trong

bảng HexaBinList sau đó
lấy ký tự tương ứng của
HexaList đưa vào Hexa.
1.4. Chuyển đổi hexa sang nhị phân
Thuật toán biến đổi số từ hexa sang nhị phân hoàn toàn ngược lại so với thuật toán
trên.
Sơ đồ thuật
36D
toán biến đổi
số hexa sang
nhị phân. 0011 0110 1101
1101101101
Có thể viết lại chi tiết thuật toán trên như sau:
Input: Hexa; Output: Binary.
Thuật toán
biến đổi số Lặp theo chiều dài của xâu Hexa, chạy từ trái sang
hexa sang nhị phải:
phân. Gọi ch là ký tự tương ứng của Hexa.
Kiểm tra chỉ số của ch trong bảng HexaList.
Lấy giá trị xâu nhị phân tương ứng chỉ số trên
trong bảng HexaBinList, và đưa vào bên phải của
Binary.
Cài đặt của thuật toán trên trong Scratch như sau:
Chương trình Gán giá trị ban đầu Binary = rỗng.

biến đổi số
hexa sang nhị Bắt đầu vòng lặp theo chiều
dài của Hexa.
phân.
Gán ch = 1 ký tự của Hexa.
Kiểm tra chỉ số của ch

trong bảng HexaList, sau
đó gán xâu nhị phân
tương ứng của
HexaBinList vào biến gr.
Đưa gr vào bên phải của

Binary.
Chú ý: Kết quả của thuật toán trên, xâu nhị phân Binary có thể có 1 số chữ số 0
thừa ở bên trái. Cần xóa các chữ số 0 này. Trong ví dụ được minh họa ở trên, 2
chữ số 0 ở đầu Binary đã được xóa.
1.5. Chuyển đổi số thập phân sang hexa và ngược lại

Việc chuyển đổi giữa các số thập phân và hexa sẽ thông qua trung gian là số nhị
phân.
Số thập phân Số Hexa
Số nhị phân
Ví dụ muốn chuyển đổi 1 số thập phân Decimal sang số hexa, chúng ta thực hiện
qua 2 bước sau:
Decimal  Binary  Hexa.
Ngược lại muốn chuyển đổi 1 số hexa Hexa sang thập phân sẽ thực hiện như sau:
Hexa  Binary  Decimal.
2. Phần mềm hiển thị và biến đổi giữa số thập phân, nhị
phân và hexa
Chúng ta sẽ thiết kế 1 chương trình đơn giản có thể thực hiện tất cả các biến đổi
số giữa 3 hệ đếm: thập phân, nhị phân và hexa như đã trình bày ở phần trên.
Kịch bản của phần mềm có thể đơn giản như hình ảnh sau.
Chuyen doi thap

phan nhi phan
hexa.sb2
Chương trình sẽ có 6 nút lệnh tương ứng với 6 chức năng chuyển đổi số từ hệ đếm
này sang hệ đếm khác. Khi nháy lên 1 nút lệnh, MC là giáo viên sẽ yêu cầu nhập
từ bàn phím 1 số tương ứng, sau đó Giáo viên sẽ thông báo kết quả là số đã được
đổi hệ đếm. Phần mềm sẽ sử dụng 3 biến nhớ hệ thống là Decimal, Binary và
Hexa dùng để lưu các số cần chuyển đổi.
Các thuật toán chuyển đổi đã được mô tả chi tiết trong phần trên, bạn đọc sẽ được
giao bài tập để hoàn thiện chương trình này.
3. Mô phỏng sắp xếp (loại 1)

Bài toán sắp xếp thứ tự số hoặc đồ vật rất phổ biến trong môn Tin học, là một
trong những bài toán cơ bản. Trong mục này sẽ mô tả, thiết kế một số phần mềm
mô phỏng sắp xếp số quen thuộc đó.
Bài toán mô phỏng sắp xếp loại 1.
Sắp xếp là một trong những bài toán, mô hình quan trọng của môn Khoa học máy
tính. Trong phần này và các phần sau chúng ta sẽ cùng nhau thiết kế các chương
trình mô phỏng bài toán này. Điểm cốt lõi, chung nhất của các bài toán này là cần
sắp xếp lại theo thứ tự (tăng dần hoặc giảm dần) một dãy số cho trước.
Dạng 1 của bài toán này như sau:
13 10 7 2 20
Cần dịch chuyển các số ở hàng dưới lên hàng trên (các vị trí được đánh dấu đỏ)
sao cho dãy mới thu được sẽ được sắp xếp tăng dần (hoặc giảm dần).
Chúng ta sẽ thiết kế chương trình sắp xếp loại 1 theo kịch bản đơn giản sau:
Sap xep L1 - xuc

sac.sb2 Giao diện dự kiến của chương
trình. Phía trên là Giáo viên -
MC của chương trình. Phía
dưới là 2 hàng: hàng trên là
dãy điểm đỏ, hàng dưới là dãy
6 mặt xúc sắc được xếp thứ tự
ngẫu nhiên.
Phần mềm sẽ liên tục đưa ra giao diện chơi trên hình trên. Nhiệm vụ người chơi là
kéo thả các hình xúc sắc lên hàng trên, nhưng phải sắp xếp theo thứ tự tăng dần.
Nếu kéo thả sai vị trí thì quân xúc sắc sẽ tự động quay trở lại vị trí ban đầu. Khi đã
kéo thả xong toàn bộ xúc sắc chương trình sẽ thông báo ngay là đúng hay sai.
Phân tích, nhận xét
Điểm công nghệ mấu chốt của bài toán này là chúng ta sẽ dùng clone để mô tả các
mặt hình xúc sắc. Như vậy chỉ cần 1 nhân vật xúc sắc và 1 nhân vật điểm màu đỏ
để thiết kế giao diện cho chương trình.
Thiết kế nhân vật chính
Hình ảnh Tên nhân vật Mô tả ý nghĩa Ghi chú thêm
Dice (xúc sắc) Phần tử chính của chương Tên các trang
trình. Nhân vật này có 6 trang phục này chính
phục tương ứng với 6 mặt của là 1, 2, 3, 4, 5, 6.
xúc sắc.
Point Nhân vật dùng để hiện dãy Người dùng sẽ
điểm đỏ trên màn hình. kéo thả xúc sắc
lên các vị trí
điểm đỏ này.
GV Giáo viên, đóng vai trò MC
Thiết kế bộ dữ liệu chính

Biến nhớ Biến nhớ Ý nghĩa Ghi chú thêm
chung riêng
XList (list) Dãy các tọa độ X để thể hiện các điểm Dãy này có 6
đỏ và xúc sắc. Dãy này được xác định phần tử.
trước và luôn cố định, không thay đổi.
DiceList (list) Dãy các giá trị gốc của các xúc sắc. Xúc Dựa vào dãy
sắc sẽ thể hiện ban đầu theo thứ tự của này, các xúc
dãy này. Dãy này được sinh là 1 hoán vị sắc clone sẽ
ngẫu nhiên của dãy 1, 2, …, 6. thể hiện hình
ảnh tương ứng.
New_DicePlace Vị trí mới của dãy xúc sắc sau khi được Ban đầu các
(list) dịch chuyển lên hàng trên. phần tử của
dãy này = 0.
ID, Value Các tham số riêng của xúc sắc dùng để
chỉ giá trị thể hiện mặt xúc sắc.
Draged Tham số riêng của xúc sắc chỉ ra clone
này đã được chuyển lên hàng trên chưa.
Draged = 1 nếu đã được chuyển rồi,
ngược lại = 0.
Drag Biến nhớ hệ thống chung chỉ ra trạng
thái kéo thả của chuột.
= 0, chưa ở trạng thái kéo thả.
Y-Dice Tọa độ Y của dãy các hình ảnh xúc sắc,
Y-Point Tọa độ Y của dãy các điểm đỏ.
index-out Khi người dùng kéo thả 1 xúc trắc trên Giá trị này
màn hình, biến nhớ index-out dùng để dùng để kiểm
ghi lại vị trí (số thứ tự) của điểm đỏ mà tra xem vị trí
đích khi kéo
chung riêng
người dùng đã kéo thả clone xúc sắc đến thả xúc sắc
đó. còn rỗng hay
đã có 1 xúc sắc
khác rồi.
Check-Result Biến nhớ dùng để kiểm tra (sau khi đã
kéo thả xong) việc kéo thả đã chính xác
hay chưa.
Sơ đồ thiết kế
Thể hiện 6 điểm đỏ

trên màn hình.
Reset Thông báo

luật chơi.
Thể hiện 6 hình xúc

sắc trên màn hình.
Kiểm tra sắp xếp

Người sử dụng kéo thả chuột lên xúc sắc để các xúc sắc tại vị
di chuyển lên các điểm màu đỏ phía trên. trí mới, thông
Khi đã chuyển xong toàn bộ 6 hình thì gửi báo đúng/sai.
thông điệp PlsCheck cho GV kiểm tra. Sau đó gửi thông
điệp Reset.
PlsCheck
Giải thích nhanh Sơ đồ thiết kế

- Sau khi nhận được thông điệp Reset, các nhân vật sẽ được điều khiển hoạt động
như sau:
Point (điểm màu đỏ).
Thể hiện 6 clone của nhân vật trên 1 hàng dọc theo các tọa độ được chỉ ra của dãy
XList.
Dice (xúc sắc).
Thể hiện 6 clone của xúc sắc với trang phục là 1 hoán vị ngẫu nhiên của {1, 2, 3,
4, 5, 6}, các clone nầy thể hiện trên 1 hàng dọc theo các tọa độ được chỉ ra của
dãy XList.
- Khi người dùng kéo thả các xúc sắc lên hàng trên. Đây là phần chương trình
phức tạp nhất của phần mềm. Khi kéo thả đúng chỗ, clone xúc sắc sẽ định vị
chính xác, ngược lại xúc sắc sẽ trôi về vị trí gốc. Khi đã kéo thả xong chương
trình sẽ tự động kiểm tra và gửi thông điệp PlsCheck sang bên GV để tiến hành
kiểm tra.
- Khi nhận thông điệp PlsCheck, GV tiến hành kiểm tra sắp xếp dãy các xúc sắc,
thông báo đúng/sai trên màn hình.
Lập trình
1) Thiết lập vị trí ban đầu cho dãy các xúc sắc.
Thủ tục Init thực hiện việc khởi tạo và gán giá trị ban đầu cho 2 bảng DiceList và
NewDice_Place. Bảng DiceList sẽ chứa 1 hoán vị ngẫu nhiên của dãy {1, 2, 3, 4,
5, 6}, còn bảng NewDice_Place sẽ chứa toàn số 0 (vì chưa có xúc sắc nào được
dịch chuyển). Thủ tục này chính là triển khai thuật toán sinh 1 hoán vị ngẫu nhiên
của 1 dãy số cho trước.
1. Xóa, làm rỗng các dãy số ban

đầu, kể cả 1 dãy phụ (temp_list).
2. Thiết lập dãy số tuần tự 1, 2, 3,

4, 5, 6 cho temp_list.
3. Thiết lập hoán vị ngẫu nhiên từ

dãy gốc temp_list và đưa vào dãy
Dice_list.
4. Gán toàn 0 cho dãy

NewDice_Place.
Đoạn chương trình sau sinh 6 clone của nhân vật xúc sắc và thể hiện chính xác
trên màn hình theo đúng thứ tự lấy từ bảng DiceList.
Chú ý 3 biến nhớ: ID, Value, Draged là các biến nhớ riêng của nhân vật xúc sắc
nên chúng sẽ được thừa kế xuống cho từng clone của mình. Ý nghĩa cúa các biến
này là: ID - chỉ số thứ tự của clone, Value - giá trị số trên mặt xúc sắc, Draged
chỉ ra clone này đã được dịch chuyển chưa.
Thiết lập các giá trị ban
đầu.
Quá trình sinh 6 clone.

ID đánh số từ 1. Value
được gán cho giá trị thứ ID
của bảng DiceList, chuyển
trang phục thứ Value và
sinh Clone.
2) Xử lý thao tác kéo thả chuột trên dãy các xúc sắc.
Đây là phần chương trình chính của phần mềm. Chú ý rằng biến nhớ hệ thống
Drag luôn hoạt động để bắt được sự kiện khi người dùng bắt đầu kéo thả chuột
trên màn hình. Về cách điều khiển biến nhớ Drag đã được mô tả trong chương về
điều khiển bàn phím và chuột.
Nếu có dấu hiệu kéo thả và Clone

này vẫn ở hàng dưới thì gắn dính
xúc sắc với con trỏ chuột, bắt đầu
quá trình kéo thả.
Khi kết thúc kéo thả, ghi nhớ lại

vị trí con trỏ chuột (X,Y) và chạy
2 thủ tục DragProcess(X,Y) và
Check.
Thủ tục DragProcess (X,Y) có nhiệm vụ:

(1) kiểm tra tọa độ (X,Y) có gần sát với một trong những vị trí điểm đỏ ở hàng
trên hay không. Nếu có, vị trí này sẽ được gán cho biến nhớ index-out. Xem đoạn
chương trình (1). Nếu không tìm được index-out thì xúc sắc được kéo thả sẽ quay
lại vị trí cũ.
(2) Kiểm tra xem tại vị trí index-out đã có xúc sắc chưa. Nếu chưa có thì đưa
Clone đang xét đến đúng vị trí index-out đó và gán Draged = 1 và giá trị Value
cho phần tử thứ index-out của dãy NewDice_Place. Nếu ngược lại không tìm
được index-out hoặc tại vị trí đó đã có 1 xúc sắc khác thì đưa xúc sắc đang kéo
thả trở về vị trí cũ (bằng lệnh glide).
1
Thủ tục Check kiểm tra xem tất cả các xúc sắc ở hàng dưới đã được chuyển lên
hàng trên chưa, nếu chuyển xong rồi thì gửi thông điệp PlsCheck để Giáo viên
tiến hành kiểm tra kết quả sắp xếp.
3) GV tiến hành kiểm tra.

Giáo viên sẽ tiến hành kiểm tra dãy các giá trị của bảng NewDice_Place đã được
xếp thứ tự tăng dần chưa. Nếu đã được xếp thứ tự thì chứng tỏ người chơi đã hoàn
thành bài sắp xếp, ngược lại, người chơi đã làm sai.
Đoạn chương trình kiểm tra như sau:
Từ thiết kế của chương trình trên, chúng ta sẽ cùng mở rộng và thiết kế 1 chương
trình sắp xếp khác tổng quát hơn cho các số bất kỳ (chứ không hạn chế chỉ là 6
mặt xúc sắc như bài trên).
Giao diện của chương trình mới sẽ tương tự như bài trên, nhưng thay bằng các
mặt xúc sắc là 1 dãy số bất kỳ.
Giao diện của chương trình mới.
Sap xep L1 -
number.sb2
Chương trình này hoàn toàn tương tự như chương trình trên ở phần thiết kế, các
biến nhớ hệ thống. Điểm khác biệt duy nhất là chúng ta sẽ sử dụng nhân vật
Number thay thế cho xúc sắc trong bài trên. Nhân vật Number sẽ được thiết kế
với số lượng các trang phục không hạn chế (như trong hình trên số trang phục là
30 tương ứng với dãy số cần lấy ra từ 1, 2, …., 30).
Toàn bộ thiết kế chương trình cho phần mềm ở mục trên có thể áp dụng cho
chương trình mới này, ngoại trừ thủ tục sinh bộ dữ liệu ban đầu cho bảng
DiceList. Thủ tục Init của chương trình này sẽ thay đổi như sau:
Thiết lập các dãy số
rỗng ban đầu.
Dãy temp_list nhận 30 giá

trị số ban đầu tương ứng với
dãy số trang phục nhân vật
Number.
Sinh dãy số của bảng

DiceList và
NewDice_Place hoàn toàn
tương tự chương trình trên.
Em hãy hoàn thiện chương trình này.

Bài toán sắp xếp sử Chúng ta sẽ xét một bài toán mô phỏng sắp xếp khác, gần với thực tế hơn. Đó là
dụng đổi vị trí 2 số mô phỏng thao tác thay đổi vị trí của 2 số trong dãy số. Xét 1 ví dụ trong hình sau
hạng bất kỳ của khi thực hiện việc đổi vị trí 2 số có thứ tự 2 và 4.
dãy số.
Chuyển đổi vị trí 2  4
Người dùng kéo thả số 2
13 10 7 2 20 sang vị trí số 10 và nhả
chuột, số 10 sẽ từ từ di
chuyển về vị trí số 2 cũ.
Với cách sắp xếp trên, chúng ta có thể liệt kê các bước biến đổi để đưa dãy số ban
đầu về dạng tăng dần.
Stt Chuyển đổi vị trí a1 a2 a3 a4 a5
13 10 7 2 20
1 Chuyển a2 - a4 13 2 7 10 20
2 Chuyển a2 - a1 2 13 7 10 20
3 Chuyển a2 - a1 2 7 13 10 20
4 Chuyển a3 - a4 2 7 10 13 20
Kịch bản chương trình sắp xếp loại 2 được mô tả nhanh trong 2 hình dưới đây.
Sap xep L2 -
number.sb2
H1. Trạng thái ban đầu. Phía dưới H2. Trạng thái khi sắp xếp xong,
dãy số cần sắp xếp là các chỉ số chương trình thông báo và hiện nút
thứ tự của dãy. Next (tiếp theo).
- Dãy số ban đầu được sắp xếp ngẫu nhiên và hiện trên màn hình (như Hình 1).
- Người dùng sẽ lần lượt thực hiện các phép biến đổi 2 số như sau: dùng chuột di
chuyển 1 số sang 1 vị trí khác, số đó sẽ được chuyển sang vị trí mới, số ở vị trí
đich sẽ tự động chuyển lại về vị trí gốc để hoàn thiện chuyển đổi.
- Khi người dùng thực hiện thao tác không chính xác thì số đó sẽ quay lại vị trí cũ.
- Khi dãy số đã được sắp xếp xong, giáo viên (đóng vai trò MC) sẽ thông báo dãy
các biến đổi đã thực hiện. Nháy vào nút Next để tự động chuyển sang bài tiếp
theo.
Thiết kế nhân vật chính
Hình ảnh Tên nhân vật Mô tả ý nghĩa Ghi chú thêm
Number Nhân vật chính của chương Tên các trang
trình. Nhân vật này có các phục này chính
trang phục là hình ảnh các chữ là 1, 2, 3, ….
số bắt đầu từ 1.
GV Giáo viên, đóng vai trò MC
Index Dùng để hiện dãy chỉ số bên Tên các trang

dưới dãy số chính. Nhân vật phục này là 1, 2,
này sẽ có 6 trang phục đánh số 3, 4, 5, 6.
từ 1 đến 6.
Next Nút Next chỉ xuất hiện khi
người dùng làm xong bài thực
hành. Nháy lên nút này để tự
động chuyển sang bài tập tiếp
theo.
Thiết kế bộ dữ liệu chính
chung riêng
XList (list) Dãy các tọa độ X để thể hiện các số cần Dãy này có 6
sắp xếp. Dãy này được xác định trước phần tử.
và luôn cố định, không thay đổi.
DiceList (list) Dãy các giá trị gốc của dãy số hiện trên Dựa vào dãy
màn hình. Dãy này được sinh ngẫu này, clone sẽ
nhiên của dãy số gốc tương ứng với số thể hiện hình
lượng trang phục của Number. Cụ thể ảnh trang phục
trong ví dụ là: 1, 2, …, 30. tương ứng.
Dice_Place Vị trí mới (hiện thời) của các chỉ số của Ban đầu dãy
(list) dãy số ban đầu. Sau mỗi lần dịch Dice_Place
chuyển vị trí 2 số, dãy này sẽ được cập đồng nhất với
nhật lại. dãy 1-2-3-4-5-
6.
HistoryChange Dãy này lưu lịch sử các lần chuyển đổi Ban đầu dãy
(list) do người dùng thực hiện. Ví dụ người này rỗng.
dùng chuyển đổi vị trí ai  aj thì
thông tin i-j được bổ sung vào bảng này.
ID, Value Các tham số riêng của nhân vật
Number dùng để chỉ giá trị thể hiện số
(theo trang phục).
Drag Biến nhớ hệ thống chung chỉ ra trạng
thái kéo thả của chuột.
= 0, chưa ở trạng thái kéo thả.
Y-Point Tọa độ Y của dãy các hình ảnh dãy số Giá trị hiện
của Number. thời = -20.
Y-Index Tọa độ Y của dãy các số index bên dưới Giá trị hiện
dãy số. thời = -130.
index-in Vị trí, chỉ số của số gốc khi người dùng
bắt đầu thực hiện kéo thả.
index-out Vị trí, chỉ số đích mà người dùng đã kéo
thả đến.
Check-Result Biến nhớ dùng để kiểm tra (sau khi đã
kéo thả xong) dãy đã được sắp xếp đúng
theo thứ tự tăng dần chưa.
Thể hiện 6 chỉ số

bên dưới dãy số.
Reset Thông báo

luật chơi.
Thể hiện dãy 6 số

ngẫu nhiên.
Người sử dụng kéo thả chuột 1 số trong dãy Thông báo dãy
đến vị trí mới để thay đổi vị trí 2 số, nếu các biến đổi đã
thành công, số ở đích sẽ quay về vị trí gốc. thực hiện. Sau
Cứ như vậy. Nếu sắp xếp xong thì gửi thông đó gửi thông
điệp Done. điệp Reset.
Done
Giải thích nhanh Sơ đồ thiết kế

Trong Sơ đồ này có lẽ phần lập trình phức tạp nhất là nhân vật Number. Có thể
mô tả ngắn gọn hoạt động của Number như sau:
1. Khi nhận được thông điệp Reset.
Khởi tạo các biến nhớ chính và thể hiện dãy số ngẫu nhiên trên màn hình.
2. Bắt đầu quá trình thay đổi vị trí 2 số trong dãy.
Khi người dùng kéo thả 1 số thì quá trình này bắt đầu. Đây là phần phức tạp nhất
3. Kiểm tra trạng thái của dãy hiện thời.
Kiểm tra xem dãy đã được sắp xếp lại đúng chưa.
Lập trình
A. Lập trình cho sân khấu.
Sân khấu sẽ luôn giữ kiểm soát biến nhớ Drag và thực hiện gửi thông điệp Reset.
Thiết lập 2 giá trị ban đầu

cho Y-Point và Drag.
Kiểm soát biến nhớ

Drag.
B. Lập trình cho Index..
Các chỉ số (index) được thiết lập đơn giản bằng lệnh vẽ stamp trên màn hình.
Dãy các chỉ số được thể

hiện bằng lệnh stamp
dọc theo các tọa độ XList
và Y-index.
C. Lập trình cho giáo viên

Giáo viên chỉ đóng vai trò MC và được điều khiển đơn giản như sau:
- Khi nhận Reset thì thông báo thể lệ bài luyện tập.
- Khi nhận thông điệp Done thì thông báo dãy các bước biến đổi của người dùng
đã thực hiện. Tất cả các bước này đã được lưu trong bảng HistoryChange.
D. Lập trình cho Number.

1. Thiết lập các bảng dữ liệu chính và trạng thái ban đầu của dãy số.
Công việc này được tiến hành theo 2 bước: 1- Init và 2- thiết lập dãy clone các số
và thể hiện trên màn hình.
Thủ tục Init có nhiệm vụ thiết lập các bảng dữ liệu hệ thống như DiceList và
Dice_Place. Nhắc lại: DiceList là dãy giá trị số ban đầu cần sắp xếp và
Dice_Place là dãy các chỉ số của dãy số hiện tại. Như vậy DiceList sẽ được thiết
lập đúng 1 lần ban đầu, còn Dice_Place sẽ được thiết lập và thay đổi thường
xuyên trong quá trình.
Xóa, làm sạch dữ liệu
của các bảng chính.

của Dice_Place, bao gồm
dãy chỉ số ban đầu là 1,
2, 3, 4, 5, 6.

cho Temp_list bao gồm
30 phần tử từ 1 đến 30.

cho DiceList là 1 dãy
ngẫu nhiên 6 số lấy từ
Temp_list.
Đoạn chương trình chính hiển thị dãy các số bằng cách sinh 6 clone của Number
như sau:
Các biến nhớ riêng ID, Value

của Number có ý nghĩa sau:
ID chính là chỉ số gốc của số
trong dãy.
Value là giá trị của số này.
Khi 1 clone được khởi tạo, ID
chính là số thứ tự của dãy,
Value chính là giá trị lấy từ
bảng DiceList.
2. Xử lý khi người dùng bắt đầu kéo thả một số trên dãy.
Đoạn chương trình sau bắt đầu xử lý khi người dùng nháy chuột lên một số trong
dãy.
Bắt đầu với sự kiện người dùng nháy

chuột lên hình ảnh 1 phần tử của dãy.
Tính toán index-in.
Bắt sự kiện kéo thả chuột, gán

cứng clone với con trỏ chuột.
Kết thúc kéo thả chuột. Xác định

tọa độ (X,Y) của vị trí này, tiến
hành xử lý dữ liệu thông qua 2 thủ
tục DragProcess(X,Y) và Check.
Thủ tục DragProcess(X,Y) như sau:
1. Tính
toán
index-out
2. Nếu tìm
được đích
chính xác.
3. Nếu không
tìm được
đích.
Mục đích của thủ tục này là:

- Tính toán index-out là chỉ số của số đích khi di chuyển chuột đến. Vậy index-
out = 0 nếu không tìm được đích. (đoạn 1)
- Nếu không tìm được đích thì việc kéo thả là vô nghĩa và số được kéo thả sẽ quay
về vị trí ban đầu. (đoạn 3)
- Nếu index-out > 0 và index-out khác với index-in thì sẽ xử lý tiếp như sau (đoạn
2, tìm thấy đích):
1
2
3
4
1. Chuyển số này chính xác tới vị trí đích (có chỉ số index-out).
2. Gửi thông điệp GoBack để yêu cầu clone đang ở vị trí đich (index-out) chuyển
lại về vị trí gốc (index-in). Chú ý tại đây bắt buộc phải dùng thông điệp vì không
thể điều khiển trực tiếp clone khác khi đang nằm trong cửa sổ lệnh của nhân vật
hiện thời.
3. Thay đổi chỉ số đầu và đích của bảng Dice_Place thông qua thủ tục Change-
Value(in, out).
4. Bổ sung thông tin chuyển đổi vào bảng HistoryChange.
Thông điệp GoBack được thực hiện như sạu:
Tìm ra clone của vị

trí đich (index-out).
Chuyển lên lớp trên
và nhảy lên 1 đoạn.
Di chuyển về vị trí
gốc (index-in).
Thủ tục Check sẽ kiểm tra xem dãy số hiện thời đã được sắp xếp đúng chưa. Nếu
đúng thì gửi thông điệp Done. Kết quả lưu vào biến Check_Result. Dãy mới đã
được sắp xếp xong khi Check_Result =1.
Em hãy hoàn thiện toàn bộ chương trình này.
5. Biểu diễn nhị phân
Chúng ta sẽ cùng thiết kế một chương trình, phần mềm đơn giản mô phỏng việc
chuyển đổi số thập phân sang nhị phân, nhưng dưới dạng một trò chơi. Giao diện
dự kiến của chương trình sẽ như hình sau:
Binary Nút Check kiểm tra

presentation. kết quả.
sb2
Số thập phân cần biểu diễn
thành nhị phân.
Dãy bit
Kịch bản như sau:

- Trên màn hình sẽ tự động sinh ngẫu nhiên các số thập phân trong khoảng từ 0
đến 255.
- Bên dưới là dãy 8 hình ảnh bít được xếp theo 1 hàng ngang. Nhiệm vụ người
chơi là nháy lên các hình ảnh này để chuyển đổi từ số 0 sang số 1 và ngược lại để
tạo ra được một số nhị phân tương ứng số thập phân trên.
- Khi đã thực hiện xong việc tạo số nhị phân, người dùng sẽ nháy lên nút Check
màu vàng phía trên, phần mềm sẽ kiểm tra và thông báo đúng hay sai. Chờ một
vài giây, trò chơi lại tiếp tục.
- Góc trái trên màn hình là điểm số của người chơi, nếu làm đúng được thưởng 1
điểm, nếu làm sai bị trừ 1 điểm.
Nhận xét, phân tích bài toán
Bài toán này khá đơn giản, phần khó nhất nằm ở 2 vị trí:
- Thể hiện số thập phân bằng hình ảnh.
- Thể hiện dãy bit bằng công nghệ Clone.
Chúng ta sẽ cùng thiết kế chi tiết trò chơi này.
Thiết kế nhân vật
Hình ảnh Tên nhân Mô tả ý nghĩa Ghi chú thêm
vật
Switch Nhân vật có 2 trang phục là hình Đặt tên trang
ảnh chữ số 0 và 1. Đây là nhân phục là 0 và 1.
vật chính của chương trình, có
nhiệm vụ thể hiện một dãy bit là
biểu diễn nhị phân cần thiết lập.
Number Nhân vật này dùng để thể hiện Kỹ thuật và thuật
số thập phân bằng hình ảnh lớn toán biểu diễn số
trên màn hình. Nhân vật này có bằng hình ảnh đã
10 trang phục với tên gọi lần được trình bày
lượt là 0, 1, …, 9. trong chương 3.
Hình ảnh Tên nhân Mô tả ý nghĩa Ghi chú thêm
vật
Check Nhân vật này sẽ có 3 trang phục Các trang phục
tương ứng với 3 trạng thái: khác của Check
là:
- Check: kiểm tra đúng / sai.
- True: hiển thị khi làm đúng.
- False: hiển thị khi làm sai.
Danh sách biến nhớ hệ thống

Biến nhớ Biến nhớ Mô tả ý nghĩa Ghi chú
chung riêng thêm
n Số thập phân chính của chương
trình. Số này sẽ được sinh ngẫu
nhiên trong khoảng 0 đến 255.
Bitlist (list) Dãy bit dùng để lưu kết quả xử
lý của người dùng. Dãy này
chính là thể hiện của dãy các
hình ảnh 0/1 trên màn hình.
CheckNumber Biến nhớ lưu kết quả là số thập
phân tính theo Bitlist. Như vậy
người dùng sẽ làm đúng chỉ khi
CheckNumber = n.
Nhân vật ID, Value Biến nhớ riêng của Switch dùng
Switch để gán riêng cho từng clone -
hình ảnh bit khi thể hiện dãy bit
trên màn hình.
Nhân vật Width, 2 mảng quan trọng của Number
Number Numlist lưu lại danh sách các số và độ
(list) rộng ban đầu của hình ảnh số
này.
Nhân vật Size Biến nhớ riêng của Number dùng Đây là số %
Number để thể hiện kích thước số trên so với kích
màn hình. thước thật.
Score Biến nhớ lưu điểm số của người
chơi.
Các biến nhớ ID, Value của Switch có ý nghĩa được mô tả trong hình ảnh sau:
8 7 6 5 4 3 2 1 Chỉ số ID của Switch
0 0 0 0 0 0 0 0 Giá trị Value của Switch
Kiểm tả đúng hay sai,

thông báo và chuyển
Thể hiện số n trên màn
Reset trang phục thể hiện
hình.
đúng/sai. Gửi thông
Sinh ngẫu nhiên n, gửi
điệp Reset.
thông điệp Start.
Nháy chuột
Start Nháy chuột
Thiết lập Bitlist và

thể hiện dãy bit 0
Chuyển đổi thể hiện 0-1,
trên màn hình.
tính toán giá trị
CheckNumber.
Lập trình
1. Sân khấu
2. Lập trình cho Number, thể hiện số n bằng hình ảnh trên màn hình.
Thiết lập Size kích thước Khi nhận thông điệp Start, sinh ngẫu
thể hiện số so với hình ảnh nhiên giá trị n và thể hiện số thập phân n
gốc của nhân vật. thông qua thủ tục
Show Number <n> at (X, Y).
Thủ tục Show Number được xây dựng dựa trên lệnh stamp và thông tin độ rộng
của các số trong bảng Width. Cách tính khoảng cách từ 1 số này sang số tiếp the
như sau:
Độ rộng (width) Độ rộng (width)

chữ số 7 chữ số 4
Khoảng cách từ tâm chữ số 4 đến tâm chữ số
7 được tính = (độ rộng (4) + độ rộng (7))/2.
Thủ tục Show Number như sau:
Trong đoạn chương trình trên chú ý đến lệnh chuyển tọa độ X để vẽ thẻ bit tiếp
theo. Giá trị chuyển là (độ rộng (ch) + độ rộng (ch-next))/2 được nhân với
Size/100 là hệ số thay đổi kích thước nhân vật trên màn hình.
3. Lập trình cho Switch, thể hiện dãy bits.
Đoạn chương trình sinh dãy Bitlist và sinh các clone của nhân vật Switch để hiện
8 thẻ bit trên màn hình.
Thiết lập các giá trị ban đầu cho ID,

Value và Bitlist.
Thiết lập 8 clone của nhân vật với

cùng các giá trị Value = 0, ID được
gán lần lượt các giá trị 1, 2, …, 9.
Bảng Bitlist được gán 8 số 0.
Tất cả các clone đều có trang phục
ban đầu là bit 0.
4. Khi nháy chuột lên 1 thẻ bít, cần lập trình để xử lý sự kiện này.
Các công việc cần thực hiện khi người dùng nháy chuột lên 1 clone - thẻ bit.
- Chuyển đổi trang phục của thẻ bít này từ 0 sang 1 và ngược lại.
- Cập nhật giá trị tương ứng vào bảng Bitlist.
- Tính toán và cập nhật CheckNumber.
Đoạn chương trình như sau:
Thay đổi giá trị của

Value và chuyển đổi
trang phục cho clone.
Cập nhật Value vào

danh sách Bitlist.
Init: tính CheckNumber.
Thủ tục Init có chức năng duy nhất là cập nhật tính toán CheckNumber từ bảng
Bitlist. CheckNumber chính là giá trị số thập phân được tính từ dãy bit nhị phân
của Bitlist.
Thuật toán tính

CheckNumbeir như sau:
Với mỗi chỉ số của dãy bít
cần tính trọng số Radix,
chính là 2index.
Giá trị Check Number =
tổng các Radix nhân với
giá trị tương ứng của
Bitlist.
5. Lập trình cho Check.

Nút Check có nhiệm vụ kiểm tra và thông báo người dùng đã làm đúng hay sai,
đồng thời thay đổi trang phục về dạng thể hiện đúng (true) hoặc sai (false) tương
ứng.
Nếu đúng, tăng điểm số lên 1,
chuyển trang phục về True,
đợi 5 giây và gửi thông điệp
Reset.
Nếu sai, trừ điểm số đi 1,

chuyển trang phục về False,
đợi 5 giây và gửi thông điệp
Reset.
6. Mô phỏng sắp xếp (loại 3). Trò chơi xếp số trong hình
vuông
Chúng ta sẽ thiết kế 1 chương trình mô phỏng trò chơi xếp số trong hìhn vuông,
một dạng khác của bài toán sắp xếp dãy số. Cho một hình vuông N x N bao gồm
N2 ô vuông nhỏ, lưu các số từ 1 đến N2. Nhiệm vụ của chúng ta là sắp xếp các số
này theo thứ tự tăng dần. Công cụ để sắp xếp lại các số là 1 Khung (frame) vuông
chứa được 4 hình vuông. Chúng ta có thể dịch chuyển Khung này bên trong hình
vuông. Bên trong Khung có thể xoay các hình vuông theo chiều kim đồng hồ hoặc
ngược kim đồng hồ.
Xep so trong hinh

Frame bao gồm khung vuông
vuong 4.sb2
có 4 hình vuông nhỏ.
Có thể xoay các hình vuông
bên trong Frame theo hoặc
ngược chiều kim đồng hồ để
sắp xếp lại bảng số.
Đây là một trò chơi khá nổi tiếng với các mức khó dễ khác nhau phụ thuộc vào
kích thước hình vuông. Các mức từ dễ đến khó tương ứng với N = 3, 4, 5.
Phân tích kịch bản và chuẩn bị thiết kế chương trình
Trước khi thiết kế cụ thể cần định nghĩa một vài khái niệm và qui định cách đánh
chỉ số của các đối tượng trong chương trình. Chúng ta cùng quan sát hình sau:
- Dãy các ô vuông sẽ đánh dấu từ 1 đến 16 như trong hình sau (các số màu đen tại
tâm các hình vuông). Ban đầu dãy các hình vuông này được thiết lập với giá trị
ngẫu nhiên. Ví dụ trong hình trên, hình vuông số 4 có giá trị 8.
- Frame (Khung) là đối tượng rất quan trọng của chương trình. Mỗi Khung sẽ là 1
hình vuông lớn phủ lên đúng 4 hình vuông nhỏ. Vị trí của Frame cũng được đánh
số từ 1 đến 9 (trong hình dưới các vị trí này là số có khung tròn, nằm tại tâm các
Frame. Số thứ tự của Frame được ký hiệu FrameID.
- Mỗi Frame có 4 hình vuông được đánh số 1, 2, 3, 4 theo chiều kim đồng hồ (các
chữ số màu đỏ trong hình dưới). Ví dụ trong hình dưới Frame có FrameID = 1 sẽ
có các hình vuông 1, 2, 3, 4 tương ứng với các ô vuông 1, 2, 6, 5.
- Ký hiệu XList, YList là dãy tọa độ X, Y của tâm các hình vuông chính.
- Ký hiệu Frame-XList, Frame-YList là dãy các tọa độ X, Y của tâm các Frame.
- CurrSqList là dãy các giá trị của các ô vuông hiện thời trên màn hình. Dãy nãy
luôn có 16 phần tử và được cập nhật thường xuyên trong quá trình tương tác với
người dùng.
- FrameChange là bảng 4 phần tử ghi lại số thứ tự của các hình vuông nhỏ tương
ứng với các vị trí 1, 2, 3, 4 của Frame hiện thời.
Hình ảnh Frame hiện Số thứ tự các ô

thời màu đỏ (trên hình vuông bên trong
ảnh này FrameID=1). 1 Frame.
2 Đây là vị trí tâm của các

1
Frame, được đánh số từ 1
1 2 3 4 đến 9.
4 1 3 2 3
5 6 7 8
4 5 6 Các ô vuông chính trên lưới
được đánh số từ 1 đến 16
9 10 11 12 như hình bên.
7 8 9
13 14 15 16
Danh sách nhân vật

Hình ảnh Tên nhân Mô tả ý nghĩa Ghi chú
vật thêm
Quare Nhân vật chính. Nhân vật này có 16
trang phục tương ứng với các hình
vuông với dãy số 1, 2, .., 16.
Frame Hình ảnh Khung (Frame) trên màn Chú ý phần
hình. Người dùng sử dụng phím up, bên trong
down, left, right để điều khiển khung này là
Khung này chuyển động. rỗng.
Banner Banner chỉ hiện khi sắp xếp xong
toàn bộ hình vuông.
Biến nhớ Biến nhớ Mô tả ý nghĩa Ghi chú
chung riêng thêm
XList, YList 2 bảng lưu dãy các tọa độ X, Y 2 bảng này
(list) của các ô vuông trên màn hình. có chiều dài
= 4, độ dài
hình vuông.
CurrSqList Dãy các giá trị của các ô vuông
(list) hiện thời trên màn hình.
Nhân vật ID, Value Số thứ tự và giá trị gốc của các
Square ô vuông khi được sinh ra (như
1 clone). Các giá trị này cập
nhật 1 lần và bao giờ thay đổi.
CurrID Số thứ tự hiện thời của ô
vuông. Chú ý giá trị này sẽ
được cập nhật sau mỗi lần xoay
Frame.
Xpos, Ypos Tọa độ X, Y của 1 ô vuông
hiện thờ. Các tọa độ này
Frame-XList, Dãy các tọa độ (X, Y) của các 2 bảng này
Frame-YList Khung. có độ dài =
(list) 3.
FrameID Chỉ số của Khung (Frame) hiện
thời.
FrameChange Bảng này có 4 phần tử chỉ ra số
(list) thứ tự của các ô vuông hiện
nằm trong Khung (Frame) hiện
thời, xếp theo chiều kim đồng
hồ.
z x
Thiết lập dãy các hình
Reset vuông ban đầu bằng Khi người dùng bấm z, x
clone. tiến hành quay các hình
vuông theo hoặc ngược kim
đồng hồng. Gừi các thông
Cập nhật lại bảng dữ điệp Update 1-2 tương ứng
liệu CurrSqList, để cập nhật dữ liệu.
kiểm tra nếu đã sắp
xếp xong thì gửi Update 1, 2
thông điệp Finish.
Thiết lập giá trị

Finish
ban đầu và thể
hiện Frame.
Khi người dùng bấm phím điều khiển,
dịch chuyển Frame và cập nhật
FrameChange và các dữ liệu khác.
Nhận thông điệp Finish thì

hiển thị, chờ người dùng
nháy chuột thì ẩn đi và gửi
Lập trình
1. Thiết lập các hình vuông ban đầu và dữ liệu cho bảng CurrSqList
Thủ tục Init thiết lập bộ dữ liệu ban đầu cho CurrSqList là 1 hoán vị ngẫu nhiên
của dãy số {1, 2, …, 16}. Đây chính là trạng thái đầu tiên của các ô vuông. Chú ý:
khi các clone của nhân vật Square được tạo ra, số thứ tự và giá trị của dãy
CurrSqList sẽ được gán cho biến nhớ ID và Value. Biến nhớ CurrID ở trạng thái
đầu tiên đồng nhất với ID.
Thiết lập các bảng rỗng ban

đầu.
Bảng tạm TempList gán dãy

1, 2, …, 16.
Sinh 1 hoán vị ngẫu nhiên từ

TempList và đưa vào
CurrSqList.
Đoạn chương trình chính như sau:
Thiết lập 3 giá trị riêng ban

đầu ID, CurrID, Value = 0.
Init: thiết lập bảng
CurrSqList.
Sinh 16 clone của nhân

vật Square, lần lượt gán
ID, CurrID và Value
cho các clone này từ
bảng CurrSqList.
Đồng thời gán tọa độ
XPos, YPos cho từng
hình ảnh clone, chuyển
trang phục tương ứng
theo Value.
Trả lại giá trị 0 cho nhân

vật gốc.
2. Thiết lập dữ liệu ban đầu và thể hiện Khung (Frame)
Khung đầu tiên được thiết lập có ID = 5, tức là ở tâm của hình vuông.
Thiết lập Khung đầu tiên có chỉ số 5 và

định vị tại tâm hình vuông (0, 0).
Cập nhật bảng FrameChange bằng thủ

tục CalculateFrChange(id).
Thủ tục cập nhật bảng FrameChange từ Thủ tục cập nhật ngay các biến
ID của Frame này. nhớ n1, n2, n3, n4, v1, v2, v3, v4
sẽ được dùng khi xoay các hình
vuông.
3. Xử lý dịch chuyển Frame trên các ô vuông

Các Khung sẽ được dịch chuyển sang trái, phải, lên, xuống khi người dùng bấm
các phím điều khiển tương ứng trên bàn phím.
Ví dụ đoạn chương trình sau mô tả dịch chuyển Khung sang phải. Có rất nhiều
phương án thực hiện lệnh này, sau đây chỉ là 1 minh họa đơn giản.
Dịch chuyển tọa độ Frame, thay đổi ID

của Frame và cập nhật bằng thủ tục
CalculateFrChange(id).
Cả 4 đoạn mô tả chi tiết việc dịch chuyển này như sau. Chú ý là sau khi dịch
chuyển cần cập nhật ngay các thông số của bảng FrameChange và các thông số
khác bằng thủ tục CalculateFrChange(id).
Điều khiển dịch

chuyển Khung
(Frame) lên,
xuống, sang trái,
phải.
4. Xử lý xuay các ô vuông trong Khung (Frame)
Việc xử lý xoay được

thực hiện bới 2 thủ tục
Xoay-phai và
Xoay-trai.
Mô hình xoay các ô vuông trong Frame được mô tả trong các sơ đồ sau:
Xoay phải Xoay trái
Xử lý xoay phải
V1 V2 V1 V2
và trái các ô
vuông trong
Khung là phức
tạp nhất. V4 V3 V4 V3
Cập nhật dữ liệu theo chiều Cập nhật dữ liệu theo chiều
mũi tên 1  2  3  4  1. mũi tên 1  4  3  2  1.
Các tham số cần thay đổi: Các tham số cần thay đổi:
CurrID, Value, Xpos, YPost CurrID, Value, Xpos, YPost
và clone cần dịch chuyển trên và clone cần dịch chuyển trên
màn hình theo các mũi tên. màn hình theo các mũi tên.
Thủ tục Xoay phải được triển khai cụ thể như sau:
Thủ tục Xoay-

phai.
V1 V2
V4 V3
Tương tự cài đặt cho thủ tục Xoay trái.

Chú ý: các biến nhớ v1, v2, v3, v4 luôn được cập nhật trong quá trình dịch chuyển
Khung.
5. Cập nhật dữ liệu sau khi xoay ô vuông
Sau khi thực hiện việc xoay các khối ô vuông, công việc quan trọng tiếp theo là
cần cập nhật lại bảng CurrSqList.
Việc cập nhật này được thực hiện bởi sân khấu sau khi nhận được các thông điệp
Update-1 cho xoay phải và Update-2 cho xoay trái.
Chú ý quan trọng:

Vì sao không thể thực hiện việc cập nhật này ngay trong cửa sổ lập trình của
Square?
Quan trọng !
Vì cửa sổ Square thực chất là các lệnh điều khiển đồng thời 16 clone của nhân vật
Square, do đó nếu đưa các hàm cập nhật này sang Square sẽ lập tức có lỗi.
Sau đây là thủ tục Update-1 dành cho việc cập nhật lại bảng CurrSqList sau khi
đã thực hiện việc xoay phải. Nhiệm vụ của thủ tục này là cập nhật các chỉ số n1,
n2, n3, n4 của CurrSqList theo chiều kim đồng hồ như sau:
Nội dung n1  Nội dung n2  Nội dung n3  Nội dung n4  Nội dung n1
Sau đó cập nhật lại các giá trị v1, v2, v3, v4.
Thiết lập n1, n2, n3,

n4 hiện thời của
CurrSqList
Cập nhật các phần tử

n1  n2  n3  n4
 n1 của bảng
CurrSqList.
Cập nhật lại v1, v2,

v3, v4 hiện thời của
CurrSqList
6. Kiểm tra và kết thúc phần chơi sắp xếp

Cuối cùng là việc kiểm tra xem bảng ô vuông đã được sắp xếp đúng chưa. Việc
này được thực hiện bởi thủ tục Check.
Nếu việc sắp xếp đã xong, biến nhớ Check_result sẽ được gán = 1 và thông điệp
Finish được gửi cho Banner thực hiện công việc cuối cùng.
Trong phần này chúng ta cùng thiết kế một chương trình sắp xếp khác, loại 4, sắp
xếp dãy số trong hình vuông.
Bài toán này như sau: Dãy các hình vuông đánh số từ 1 đến 15 được xếp ngẫu
nhiên trong 1 hình vuông 4 x 4, trong đó có 1 ô trống (empty). Người dùng có thể
dịch chuyển các ô có số sang vị trí ô trống bằng cách nháy lên ô này. Bằng các
thao tác như vậy cần sắp xếp lại các số trong hình vuông theo thứ tự tăng dần.
Xep so trong hinh

vuong L4 - 4.sb2
Người chơi sẽ nháy chuột lên

các ô bên cạnh ô trống để đổi
chỗ cho ô trống và sắp xếp lại
bảng số.
Bài toán này đơn giản hơn bài toán trên (loại 3). Thiết kế nhanh như sau.
Danh sách nhân vật
Hình ảnh Tên nhân Mô tả ý nghĩa Ghi chú
vật thêm
Quare Nhân vật chính. Nhân vật này có 16
trang phục tương ứng với các hình
vuông với dãy số 1, 2, .., 16.
Banner Banner chỉ hiện khi sắp xếp xong
toàn bộ hình vuông.

Biến nhớ chung Biến nhớ Mô tả ý nghĩa Ghi chú
riêng thêm
XList, YList 2 bảng lưu dãy các tọa độ X, Y 2 bảng này
(list) của các ô vuông trên màn hình. có chiều dài
= 4, độ dài
hình vuông.
CurrSqList Dãy các giá trị của các ô vuông Khi sinh lần
(list) hiện thời trên màn hình. Dãy đầu tiên, vị
này có 16 phần tử, trong đó có trí
1 phần tử = rỗng chính là chỉ EmptyID
số của ô rỗng (empty cell). phải là ngẫu
nhiên.
ID, Value Số thứ tự và giá trị gốc của các
ô vuông khi được sinh ra (như
Biến nhớ chung Biến nhớ Mô tả ý nghĩa Ghi chú
riêng thêm
Nhân vật 1 clone). Các giá trị này cập
Square nhật 1 lần và bao giờ thay đổi.
CurrID Số thứ tự hiện thời của ô
vuông. Chú ý giá trị này sẽ
được cập nhật sau mỗi lần
chuyển đổi ô trống.
Xpos, Ypos Tọa độ X, Y của 1 ô vuông
hiện thờ. Các tọa độ này
EmptyID Chỉ số của ô vuông rỗng trên
hình vuông.
EmptyXpos, Tọa độ X, Y của ô rỗng.
EmptyYpos
Empty-Xindex, Chỉ số theo hàng, cột của ô
Empty-Yindex rỗng.
Thiết lập dãy các hình

Reset vuông ban đầu bằng Khi người dùng nháy chuột
clone. lên các hình bên cạnh ô
trống, chương trình sẽ đổi
Sau khi chuyển đổi chỗ ô này và ô rỗng. Sau đó
với ô rỗng thì cập tiến hành kiểm tra, nếu sắp
nhật lại bảng dữ liệu xếp đúng thì gửi thông điệp
CurrSqList. Finish.
Finish
Nhận thông điệp Finish thì

hiển thị, chờ người dùng
nháy chuột thì ẩn đi và gửi
Lập trình
1. Một số công cụ hỗ trợ tính toán ban đầu
Thủ tục Init có chức năng sinh tự động bảng CurrSqList. Dãy này sẽ phải là 1
hoán vị ngẫu nhiên của dãy {1, 2, …, 15} và phải chứa 1 phần tử rỗng, vị trí phần
tử rỗng cũng phải ngẫu nhiên.
Chương trình của thủ tục Init như sau:
Xóa, tạo các mảng rỗng

templist, CurrSqList.
Tạo bảng templist với dãy

15 số tự nhiên 115.
Tạo bảng CurrSqList với

dãy hoán vị ngẫu nhiên của
15 số 115.
Sinh ngẫu nhiên EmptyID và

chèn phần tử rỗng vào vị trí
EmptyID của CurrSqList.
Thủ tục Calculate XY(emptyID) sẽ tính các tọa độ X, Y của ô vuông rỗng trên
màn hình và cập nhật vào các biến nhớ hệ thống EmptyXpos, EmptyYpos,
Empty-Xindex, Empty-Yindex.
2. Thể hiện ô vuông với ô trống ngẫu nhiên trên màn hình
Chương trình sinh các ô vuông trên màn hình bằng công nghệ Clone cũng tương
tự như các chương trình đã nêu trong các phần trước. Điểm khác biệt duy nhất ở
chỗ chú ý đến vị trí Empty (ô rỗng) thì bỏ qua không sinh Clone tại đó nữa.
Thiết lập các giá trị ban

đầu của nhân vật gốc.
Vòng lặp tạo 15 clone.
Kiểm tra và chỉ tạo clone

tại các vị trí không trùng
với Empty.
Trả lại các giá trị ban

đầu của nhân vật gốc.
3. Xử lý chuyển đổi ô vuông với ô rỗng bên cạnh
Điều kiện cần và đủ để 1 ô vuông với

chỉ số ID liền kề với ô rỗng có chỉ số
EmptyID là:
| ID - EmptyID | = 1 hoặc = 4.
Đoạn chương trình sau xử lý khi người dùng nháy lên 1 ô số nằm cạnh bên trái
của ô rỗng.
Điều kiện liền

kề bên trái.
Thay đổi giá trị 2 vị trí

CurrID và EmptyID của
CurrSqList.
Cập nhận các tham số tương

ứng của ô số và ô rỗng.
Kiểm tra sắp xếp.

Dừng scrip này.
4. Kiểm tra sắp xếp số trên màn hình

Thủ tục kiểm tra xem các số trong bảng CurrSqList đã được sắp xếp tăng dần
chưa. Vì dãy này có chứa 1 phần tử rỗng nên trước khi kiểm tra cần sao chép các
số > 0 của dãy này sang 1 dãy tạm Templist sau đó tiến hành kiểm tra trên dãy
tạm này.
Sao chép toàn bộ các số khác

rỗng của dãy CurrSqList
sang dãy TempList.
1. Hoàn thiện chương trình biến đổi số giữa các hệ đếm đã nêu trong phần 2.
2. Thiết kế và viết chương trình sắp xếp loại 1 (chương trình 2) nhưng với hình
ảnh nhân vật có các kích thước khác nhau. Tiêu chuẩn sắp xếp theo theo thứ tự to
nhỏ của hình ảnh nhân vật.
Nhân vật trong chương trình có nhiều trang phục khác nhau tương ứng với các đồ
vật, con vật khác nhau.
Người chơi kéo thả các hình ảnh phía dưới lên các hình tròn đỏ phía trên.
3. Thiết kế và viết chương trình sắp xếp loại 2 (chương trình 3) nhưng với hình
ảnh nhân vật có các kích thước khác nhau. Tiêu chuẩn sắp xếp theo theo thứ tự to
nhỏ của hình ảnh nhân vật.
Nhân vật trong chương trình có nhiều trang phục khác nhau tương ứng với các đồ
vật, con vật khác nhau.
Người chơi kéo thả các hình ảnh phía dưới sang các vị trí của nhau để sắp xếp lại
các hình này theo thứ tự theo yêu cầu.
4. Viết các chương trình mô tả trò chơi sắp xếp theo loại 3 nhưng với số lượng
hình vuông khác nhau.
Trường hợp n = 3 Trường hợp n = 5.
5. Viết các chương trình mô tả trò chơi sắp xếp theo loại 4 nhưng với số lượng
hình vuông khác nhau.
Trường hợp n = 3. Trường hợp n = 5.
6. Viết chương trình mô tả một cách sắp xếp khác, được mô tả trong hình sau.
Người chơi chỉ được quyền di chuyển 1 con số từ phía bên phải sang 1 vị trí bất
kỳ ở bên trái.
Trong ví dụ sau, giả sử chúng ta di chuyển số 5 sang vị trí số 1.
6 1 4 2 5 3
6 5 1 4 2 3
Khi số 5 được chèn vào vị trí số 1, thì các mảnh ghép 1, 4, 2 nằ, giữa 2 vị trí 5 và
1 sẽ được dịch chuyển sang phải để chiếm vị trí của số 5 vừa được chuyển đi.
Chủ đề 7.
Phần mềm hỗ trợ học Toán
Mục tiêu:
- Thiết kế một số phần mềm hỗ trợ học và dạy môn Toán.
- Một số thuật toán sinh dãy số ngẫu nhiên, sinh các bài toán đầu vào cho các phần
mềm học Toán.
Nội dung chính
1. Trò chơi điền số vào dãy, vào bảng
Một trong các trò chơi, bài toán vui hay gặp nhất là bài toán tìm số trong dãy hoặc
bảng. Cho trước 1 dãy (hoặc bảng) số có qui luật, trong đó có 1 vị trí trống, cần
tìm số còn thiếu này. Cách làm là lựa chọn 1 trong số các đáp án có sẵn (trắc
nghiệm).
Dien so vao
day.sb2
Giao diện đơn giản của
chương trình.
Dãy số hiện ở giữa màn hình,
các đáp án trắc nghiệm phía
dưới. Người dùng cần nháy
lên 1 trong các nút A, B, C, D
để giải (chơi).
Nhân vật chính của chương trình.
Các nhân vật của chương

trình.
Kịch bản, yêu cầu cụ thể của chương trình.

- Chương trình sẽ tự động sinh (ngẫu nhiên) các bài toán cho trò chơi. Mỗi bài
toán sẽ bao gồm 1 dãy 5 số được thể hiện chính giữa màn hình. và 4 phương án
chọn đáp án đúng.
Giáo viên là người ra các thông
báo hướng dẫn chính của chương
trình.
Dãy số bao gồm 5 số, vị trí có

dấu ? là còn thiếu 1 số cần tìm.
Người chơi cần nháy vào các nút

A, B, C, D để làm bài.
- Người chơi làm bài bằng cách nháy chuột lên 1 trong các nút A, B, C, D bên
dưới các đáp án có sẵn. Chương trình sẽ lập tức sẽ thông báo đúng / sai và số hạng
tiếp theo của dãy sẽ hiện ngay trên màn hình. Đồng thời xuất hiện nút Next (xem
hình dưới).
Đáp số sẽ hiện tại đây ngay sau

khi nháy chuột làm bài.
Nút lệnh Next xuất hiện để làm

tiếp.
- Nháy lên nút Next để tự động chuyển sang bài toán tiếp theo. Trò chơi cứ như
vậy mãi mãi.
Phân tích yêu cầu của chương trình.
Bộ dữ liệu chính mô tả yêu cầu và hoạt động của chương trình.
1 N1, N2, N3, 5 biến nhớ tổng thể lưu 5 giá trị đầu tiên (biến nhớ)
N4, N5 của dãy. Bài toán chính là tìm phần tử
tiếp theo (một cách hợp lý) của dãy trên.
2 pA, pB, pC, 4 phương án của bài toán. Trong 4 (biến nhớ)
pD phương án này sẽ có 1 phương án đúng.
3 pCorrect Biến nhớ chỉ ra số thứ tự của phương án (biến nhớ)
đúng trong số 4 phương án trên. Biến nhớ
này không hiện trên màn hình.
4 Choice Biến nhớ ghi lại phương án lựa chọn của (biến nhớ)
người dùng. Như vậy nếu
Choice=pCorrect thì làm đúng, ngược lại
là sai.
5 Score Điểm số của người chơi. Nếu giải đúng sẽ (biến nhớ)
được tặng 10 điểm, nếu làm sai sẽ bị trừ 1
điểm.
Vấn đề chính, bài toán chính của trò chơi này là tự động thiết lập các bài toán và
cập nhập vào bộ dữ liệu đã nêu trên.
Có rất nhiều thuật toán có thể viết để thiết lập các bài toán cụ thể cho chương
trình. Mỗi thuật toán chỉ ra cách thiết lập 1 dãy các số có quan hệ logic. Bảng sau
ghi lại 1 vài thiết kế như vậy (sẽ được viết trong chương trình).
Stt Mô tả qui luật dãy số Ví dụ
1 Dãy số chẵn liên tục 2 4 6 8 10 12 14 16
2 Dãy số lẻ liên tục 1 3 5 7 9 11 13 15 17 19
3 Dãy số nguyên tố liên tục 2 3 5 7 11 13 17 19 23
4 Dãy số Fibonaci 1 1 2 3 5 8 13 21
5 Dãy số chính phương 1 4 9 16 25 36
6 Dãy số lập phương 1 8 27 64 125
7 Dãy các số tạo thành 1 cấp số 1 4 7 10 13 16 19 22
cộng.
8 Dãy số tạo thành 1 cấp số nhân. 3 6 12 24 48
Bộ dữ liệu sau dùng để lưu trữ dữ liệu cho tất cả các thuật toán trên. Bộ dữ liệu
này được thiết kế trong đối tượng Math của chương trình.

1 pNumber Số lượng phần tử của dãy sẽ được (biến nhớ)
sinh tự động. Giá trị có trong
chương trình là pNumber = 6.
2 NumList Dãy số chính (gốc) được sinh tự (list)
động của thuật toán.
3 pList Dãy 4 phương án được sinh tự (list)
động. Đây chính là các giá trị ứng
với các phương án A, B, C, D.
4 sList Dãy 4 giá trị chỉ ra phương án (list)
nào đúng, phương án nào sai.
Theo qui định giá trị = 0 (sai), = 1
(đúng).
Sơ đồ thiết kế dữ liệu chính của chương trình.
Các thuật toán thiết Cập nhật dữ Chuyển đổi

liệu vào 1 bộ Thể hiện trên
lập dãy cụ thể: sang bộ dữ
dữ liệu chính giao diện màn
- Dãy số chẵn liệu chính
hình của
- Dãy số nguyên tố của các thuật của chương
chương trình.
- ….. toán. trình.
Thiết kế nhân vật chính của chương trình.

Các nhân vật của chương trình được thiết kế trong bảng sau:
Biểu tượng Tên nhân vật Chức năng và hoạt động Các chú ý khác
Đối tượng Math Đối tượng này được xây dựng Bộ dữ liệu chính
đặc biệt để lưu trữ tất cả các dữ lưu dữ liệu của
liệu và thuật toán sinh tự động các thuật toán sẽ
các bài toán và dữ liệu của là dữ liệu riêng
chương trình. (local) của đối
tượng này.
Giáo viên Giáo viên đóng vai trò là người
dẫn chương trình và thực hiện
giao tiếp với ngưởi chơi.
Các nút A, B, C, Các nút dành cho người chơi Nháy lên nút này
D lựa chọn đáp án của trò chơi. sẽ sinh ra thông
Mỗi lần chỉ được nháy chuột 1 điệp Done.
lần lên 1 nút lệnh này.
Nút Câu hỏi Nhân vật này chỉ có nhiệm vụ

(Question) hiển thị như 1 dấu hỏi tại vị trí
cần điền số. Khi người dùng đã
chọn đáp án, hình ảnh này sẽ ẩn
đi, và tại vị trí này sẽ hiện đáp
án đúng của bài toán.
Nút Next Nút này sẽ chỉ hiện khi người Nháy lên nút này
chơi đã làm xong 1 bài. Khi sẽ sinh ra thông
người dùng nháy lên nút này thì điệp Reset.
sẽ bắt đầu 1 bài toán tiếp theo.
Đối tượng Nhân vật này có nhiệm vụ hiển Đối tượng này có
Number thị đáp số của bài toán sau khi 10 trang phục với
người dùng nháy chuột nhập hình ảnh các số từ
đáp án. Sử dụng kỹ thuật hiển 0 đến 9. Tên của
thị số bằng chữ số đã có trong trang phục cũng
bài học 21 (một số kỹ thuật là 0 đến 9.
thiết kế games),
Reset
Thực hiện việc sinh dữ
liệu bài toán chính của
Gửi thông
chương trình.
điệp Reset
Math.Done
Thông báo yêu cầu Kích hoạt các nút này
bài toán. làm việc.
Kiểm tra và thông
báo đúng / sai.
Nếu người dùng nháy

chuột, gửi thông điệp
Ẩn
Done.
Ẩn Hiển thị
đáp số Done
Hiện Hiện
Nếu nháy lên, gửi

Reset
Các thuật toán sinh dữ liệu chính.
Sau đây là mô tả chi tiết 8 thuật toán sinh ngẫu nhiên các bộ dữ liệu đầu vào của
bài toán. Tất cả các thuật toán này đều nạp dữ liệu vào các biến nhớ sau:
1. pNumber. Số lượng số của dãy số.
2. NumList. Dãy số chính.
3. pList. Dãy 4 phương án.
4. sList. Dãy mô tả phương án đúng.
Tên Mô tả thuật toán Chương trình

Dãy số chẵn Đặt k = ngẫu nhiên từ 1 đến 10.
liên tục
Đặt i = 2*k.
Lặp pNumber lần.
Đưa i vào mảng NumList.
i=i+2
Thiết lập 2 mảng 4 phần từ pList và
sList. pList bao gồm các số lấy ngẫu
nhiên từ 5 đến 100 và không = phần
tử thứ pNumber của NumList. sList
bao gồm toàn số 0.
Đặt k = ngẫu nhiên từ 1 đến 4.
Thay thế phần tử thứ k trong pList
với phần tử cuối cùng của NumList.
Thay thế phần tử thứ k của sList
bằng 1.
Dãy số lẻ liên Đặt k = ngẫu nhiên từ 1 đến 10.
tục
Đặt i = 2*k + 1.
i=i+2
bằng 1.
Dãy số chính Đặt i = ngẫu nhiên từ 1 đến 5.
phương Lặp pNumber lần.
Đưa i*i vào mảng NumList.
i=i+1
nhiên từ 10 đến 1000 và không =
phần tử thứ pNumber của NumList.
sList bao gồm toàn số 0.
bằng 1.
Dãy số lập Đặt i = ngẫu nhiên từ 1 đến 5.
phương Lặp pNumber lần.
Đưa i*i*i vào mảng
NumList.
i=i+1
nhiên từ 20 đến 5000 và không =
phần tử thứ pNumber của NumList.
sList bao gồm toàn số 0.
bằng 1.
Dãy các số Đặt i = ngẫu nhiên từ 1 đến 5.
tạo thành 1
Đặt d = ngẫu nhiên từ 2 đến 10.
cấp số cộng.
i=i+d
bằng 1.
Dãy số tạo Đặt i = ngẫu nhiên từ 2 đến 10.
thành 1 cấp
Đặt p = ngẫu nhiên từ 2 đến 5.
số nhân.
i = i *p
bằng 1.
Dãy số Đặt p = ngẫu nhiên trong các số 2, 3, Chương trình này sử dụng thủ tục
nguyên tố 5, 7, 11 Next Primary (number) để tìm ra số
liên tục Lặp pNumber lần. nguyên tố đầu tiên > number. Kết quả lưu
vào biến nhớ Next.Primary.Math.
Đưa p vào mảng NumList.
Tính p = số nguyên tố đầu
tiên tiếp theo.
bằng 1.
Thuật toán kiểm tra 1 số p có là Thủ tục Is Primary <p>.
nguyên tố hay không. Kết quả lưu
vào biến kq. Số p là nguyên tố nếu
kq = 1.
Đặt kq = 0, k = 2.
Nếu p = 1 thì Exit.
Lặp liên tục cho đến khi p chia hết
cho k hoặc k > p-1.
k=k+1
kết thúc lặp.
Nếu k = p thì đặt kq = 1. Thủ tục Next Primary <n> sẽ tìm số
nguyên tố nhỏ nhất > n, kết quả đưa vào
biến nhớ Next.Primary.Math.
Dãy số Đặt a = ngẫu nhiên trong các số 1, 2,

Fibonaci 3, 5
Đặt b = số tiếp theo của a trong dãy
Fibonaci.
Đặt c = a + b.
Đưa a vào mảng NumList.
Gán a = b, b = c, c = a + b
bằng 1.

1 pNumber Số lượng phần tử của dãy sẽ được Gán mặc định =
(biến nhớ) sinh tự động. Giá trị có trong chương 6.
trình là pNumber = 6.
2 NumList (list) Dãy số chính (gốc) được sinh tự Dãy này có
động của thuật toán. pNumber phần
tử.
3 pList (list) Dãy 4 phương án được sinh tự động. Dãy có 4 phần
Đây chính là các giá trị ứng với các từ.
phương án A, B, C, D.
4 sList (list) Dãy 4 giá trị chỉ ra phương án nào Dãy có 4 phần
đúng, phương án nào sai. Theo qui từ, trong đó có
định giá trị = 0 (sai), = 1 (đúng). đúng phần tử =
1, còn lại = 0.
5 N1, N2, N3, 5 biến nhớ tổng thể lưu 5 giá trị đầu
N4, N5 (biến tiên của dãy. Bài toán chính là tìm
nhớ) phần tử tiếp theo (một cách hợp lý)
của dãy trên.
6 pA, pB, pC, 4 phương án của bài toán. Trong 4
pD (biến nhớ) phương án này sẽ có 1 phương án
đúng.
7 pCorrect (biến Biến nhớ chỉ ra số thứ tự của phương
nhớ) án đúng trong số 4 phương án trên.
Biến nhớ này không hiện trên màn
hình.
8 Choice (biến Biến nhớ ghi lại phương án lựa chọn
nhớ) của người dùng. Như vậy nếu
Choice=pCorrect thì làm đúng,
ngược lại là sai.
9 Score (biến Điểm số của người chơi. Nếu giải
nhớ) đúng sẽ được tặng 10 điểm, nếu làm
sai sẽ bị trừ 1 điểm.
10 Time_to_solve Tham số ghi lại trạng thái của Chỉ khi tham số
(biến nhớ) chương trình qui định thời gian này = 1 mới cho
người chơi làm bài. phép người
dùng nháy lên
= 0, không là thời gian chơi.
các nút đáp án
= 1, đang là thời gian chơi. A, B, C, D.
a) Sân khấu thiết lập các tham biến ban đầu và gửi thông điệp Reset.
Đặt Time_to_solve = 0 tại

thời điểm này để không cho
phép người dùng nháy chuột
lên các nút đáp án A, B, C, D.
b) Khi nhận thông điệp Reset, nhân vật Math sẽ sinh 1 bộ dữ liệu cho bài toán.
Thủ tục này sinh 1 bộ dữ liệu

đầu vào cho bài toán.
Nạp dữ liệu cho các

biến nhớ chính.
Nạp dữ liệu cho

phương án đúng.
Sau khi sinh xong dữ liệu
thì gửi thông điệp
Math.Done.
c) Nhận được thông điệp Math.Done, Giáo viên sẽ thông báo cho người chơi bắt
đầu được làm bài. Lúc này sẽ thiết lập Time_to_solve = 1 để người chơi có thể
thao tác nháy chuột lên các nút đáp án A, B, C, D.
d) Đồng thời, các nút A, B, C, D sẽ chờ người chơi làm bài bằng cách nháy chuột
lên các nút này.
Sau đây là chương trình điều khiển cho nút A, chương trình cho các nút khác hoàn
toàn tương tự.
Ngay sau khi nháy chuột làm bài, nút lệnh sẽ gán giá trị cho biến nhớ Choice và
gửi thông điệp Done thể thông báo đã làm bài.
Chương trình cho nút A.
Chỉ xử lý khi
Time_to_solve = 1.
Gán Choice =1 cho nút A.

Gửi thông điệp Done.
e) Giáo viên lại là nhân vật nhận thông điệp Done để xử lý tiếp.
- Đặt lại Time_to_solve = 0.
- Kiểm tra người dùng làm đúng hay sai. Nếu đúng tăng 20 điểm, nếu sai trừ 1
điểm.
- Thông báo đúng/ sai.
Xử lý nếu làm
đúng.
Xử lý nếu làm
sai.
f) Đồng thời khi nhận được thông điệp Done thì nhân vật Number sẽ hiện đáp án
đúng ngay bên cạnh dãy số chính. Giá trị của đáp án đúng được lưu trong biến
nhớ Number.Answer. Nhân vật Number sẽ dùng thủ tục Show Number <n> at
<X, Y> để hiện đáp số này bằng hình ảnh số.
Thủ tục Show

Number thể
hiện đáp số
lên màn hình.
Thủ tục Show Number <n> at <X, Y> được mô tả như chương trình sau.
Thủ tục này

đã được mô tả
trong chủ đề
1 của cuốn
sách này.
g) Nút Next sẽ chỉ xuất hiện khi người dùng nhập xong bài toán. Khi đó nháy lên
nút này sẽ khởi động thông điệp Reset để bắt đầu 1 bài toán mới.
Chương trình điều khiển nhân vật Next như sau:
Hiển thị sau khi có thông

điệp Done (người dùng
nháy đáp án xong).
Nếu nháy lên nút này thì

ẩn đi và gửi thông điệp
Reset.
h) Cuối cùng là nhân vật hình câu hỏi. Nhân vật này sẽ hiển thị sau thông điệp
Reset và ẩn đi sau thông điệp Done.
Hiển thị ngay sau khi có thông

điệp Reset.Tiến hành xóa màn
hình của câu hỏi trước đó.
Khi nhận được thông điệp Done

(người dùng nháy đáp án xong)
thì ẩn đi.
2. Trò chơi tìm số
Trong mục này chúng ta cùng làm quen và thiết kế 1 chương trình, trò chơi khác
nhưng cũng dựa trên việc sinh tự động các bài toán. Điểm khác biệt quan trọng là
trong chương trình này, việc giải toán chỉ cần nhập 1 đáp án (là số) duy nhất.
Ý tưởng giao diện chương trình này nằm ở hình ảnh con RÙA. Gần đến ngày thi
cử, chúng ta vẫn thấy các thí sinh đến Văn Miếu Quốc Tử Giám để xoa đầu rùa
lấy may. Trong chương trình này, người dùng khi giải toán gặp khó khăn sẽ nháy
chuột lên con RÙA để xem thêm gợi ý, hướng dẫn.
Các dạng bài toán của chương trình này cũng là 1 tổng quát hơn ví dụ trong phân
trước của chủ đề. Dạng bài toán cần tìm đáp số chính xác là rất điển hình trong
ứng dụng toán học.
Tim so.sb2
Chương trình (thông
qua giáo viên) sẽ liên
tục đưa ra bài toán,
người chơi nhập đáp số
thông qua hộp hội thoại
nhập số. Con rùa xuất
hiện để hỗ trợ người
chơi.
Nhân vật của chương

trình.
Kịch bản chương trình.

Yêu cầu chức năng của chương trình như sau:
- Chương trình sẽ liên tục sinh và đưa ra màn hình bài toán, yêu cầu người chơi
nhập 1 đáp số duy nhất. Giáo viên luôn hiện đề bài trên màn hình. Người chơi
tương tác với chương trình thông qua dòng nhập số ở phía dưới.
- Trên màn hình có hình con rùa. Nháy lên con rùa để xem gợi ý.
- Người chơi phải nhập liên tục đáp số cho đến khi đúng thì thôi. Nếu nhập sai bị
trừ 1 điểm, nếu đúng được thưởng 15 điểm.
- Nếu nhập đúng, GV sẽ thông báo ngay là đúng, nút Next xuất hiện. Bấm vào nút
Next để tiếp tục bài toán khác.
Khi làm bài, giáo viên sẽ
luôn đưa ra nội dung, yêu
cầu của bài toán. Sân khấu
thực hiện lệnh tương tác
yêu cầu nhập đáp số. Nháy
lên con rùa để xem hướng
dẫn, gợi ý. Quá trình này
dừng lại khi người chơi
nhập đáp án đúng.
Khi người chơi nhập đáp

số đúng, nút Next sẽ hiện
lên. Nháy lên nút này để
chuyển bài tiếp theo.
Chú ý lúc này nếu nháy
lên con rùa sẽ không có
tác dụng gì.
Một số nhận xét ban đầu.

Tương tự như chương trình Điền số vào dãy (mục 1), chúng ta sẽ đưa tất cả các
thuật toán sinh đề bài vào trong 1 nhân vật có tên là Math. Các thuật toán này sẽ
được lập trình theo từng dạng. Ví dụ.
Các bài toán có thể đưa vào trò chơi này.
Stt Tên bài toán Diễn dải bài toán
1 Tính ước số chung lớn nhất. Hãy tìm ước số chung lớn nhất của các số
<N1> và <N2>.
2 Tính bội số chung nhỏ nhất. Hãy tìm bội số chung nhỏ nhất của các số
<N1> và <N2>.
3 Đếm số các ước số thực sự. Đếm số các ước số thực sự (kể cả 1) của
số <N>
4 Tính nhanh 1 phép toán +, - Ví dụ:
đơn giản. Tính nhanh tổng của 3 số <N1>, <N2>,
<N3>.
Tính nhanh tích của 2 số <N1> và <N2>.
Stt Tên bài toán Diễn dải bài toán
5 Tính phần tử tiếp theo của 1 Tìm phần tử tiếp theo của dãy số sau:
dãy số có qui luật. <N1>, <N2>, <N3>, <N4>.
6 Chuyển đổi số thập phân Hãy chuyển đổi số thập phân sau <N>
sang nhị phân. sang số nhị phân.
7 Chuyển đổi số nhị phân sang Hãy chuyển đổi số nhị phân sau <N> sang
thập phân. số thập phân.
8 Tìm giá trị Max, Min của 1 Tìm giá trị lớn (nhỏ) nhất của dãy số sau:
dãy số cho trước. <N1> <N2> ….. <Nk>.
Bộ dữ liệu sau dùng để lưu trữ dữ liệu cho tất cả các thuật toán trên. Bộ dữ liệu
này được thiết kế trong đối tượng Math của chương trình.
1 Problem.Content Nội dung bài toán. (biến nhớ)
2 Problem.Hint Gợi ý của bài toán. (biến nhớ)
3 Problem.Answer Đáp số của bài toán. (biến nhớ)
Chú ý: Các bài toán sinh dãy số trong ví dụ ở phần trước hoàn toàn có thể được sử
dụng lại trong bài này. Đoạn chương trình sau mô tả cách chuyển đổi dữ liệu đã
sinh bài toán điền số vào dãy số dạng trắc nghiệm sang dạng bài toán có 1 đáp số
duy nhất.
Cách chuyển đổi như sau:

Problem.Hint: nhập trực tiếp lời gợi ý cách giải bài toán.
Problem.Answer = giá trị phần tử cuối cùng của dãy NumList.
Problem.Content = "Tìm phần tử tiếp theo của dãy số sau: " + dãy các phần tử
của NumList.
Thiết kế theo Cách thiết kế nhân vật Math trong 2 ví dụ trên, trong nhân vật này chứa tất cả
module các thuật toán sinh dữ liệu của các bài toán chính, được gọi là thiết kế theo
module. Chúng ta có thể gọi là Math module.
Danh sách các nhân vật chính.
Biểu tượng Tên nhân vật Chức năng và hoạt động Các chú ý khác
Đối tượng Đối tượng này được xây dựng Bộ dữ liệu chính
Math đặc biệt để lưu trữ tất cả các dữ lưu dữ liệu của
liệu và thuật toán sinh tự động các thuật toán sẽ
các bài toán và dữ liệu của là dữ liệu riêng
chương trình. (local) của đối
tượng này.
Giáo viên. Giáo viên đóng vai trò MC của
chương trình.
Rùa Rùa đóng vai trò trợ giúp.

Trong suốt quá trình làm bài,
nháy lên con rùa sẽ hiện thông
tin trợ giúp giải bài toán này.
Next. Nháy lên nút này sẽ chuyển Nút này chỉ xuất
sang bài tập, câu hỏi tiếp theo. hiện khi đã làm
xong 1 câu hỏi.
Thiết lập bộ dữ
Reset liệu cho bài toán.
Hiển thị và nêu yêu
Start
Yêu cầu người cầu bài cần giải.
dùng nhập đáp án.
Nếu nhập sai, gửi
Thông báo SAI rồi và nêu
thông điệp Sai rồi.
yêu cầu bài cần giải.
Sai rồi
Thông báo ĐÚNG rồi và
nêu yêu cầu bài cần giải.
Nếu nhập đúng,
Done. Cho phép thông
Done báo hướng dẫn nếu
nháy chuột lên.
Hiển thị.
Nháy chuột lên thì
ẩn đi và gửi thông
điệp Reset.
` Reset

1 Score (biến nhớ) Điểm số của người chơi.
2 Input (biến nhớ) Biến nhớ này dùng để lưu trữ các
giá trị do người dùng nhập trực tiếp
từ bàn phím.
3 TimeStart (biến Ý nghĩa biến nhớ này như sau:
nhớ) = 0, không là thời gian làm bài.
Nháy chuột lên con rùa sẽ không có
tác dụng.
= 1. thời gian làm bài. Nháy chuột
lên con rùa sẽ hiện hướng dẫn, gợi
ý của bài toán đang làm.
Các biến nhớ và mảng sau là biến riêng của nhân vật Math. Các
biến này được dùng để sinh các bài toán của chương trình.
1 Problem.Content Nội dung bài toán.
(biến nhớ)
2 Problem.Hint (biến Gợi ý của bài toán.
nhớ)
3 Problem.Answer Đáp số của bài toán.
(biến nhớ)
4 pNumber (biến nhớ) Số lượng phần tử của dãy sẽ được Gán mặc
sinh tự động. Giá trị có trong định = 6.
chương trình là pNumber = 6.
5 NumList (list) Dãy số chính (gốc) được sinh tự Dãy này có
động của thuật toán. pNumber
phần tử.
6 N1, N2, N3, N4, N5 5 biến nhớ tổng thể lưu 5 giá trị đầu
(biến nhớ) tiên của dãy. Bài toán chính là tìm
phần tử tiếp theo (một cách hợp lý)
của dãy trên.
Một số thuật toán sinh dữ liệu.
Tên bài Thuật toán thực hiện Chương trình mô tả

toán
Tính ước Đặt:
số chung
n1 = ngẫu nhiên từ 2 đến 100.
lớn nhất
của 2 số. n2 = ngẫu nhiên từ 2 đến 100.
N1 = n1; N2 = n2;
Lặp cho đến khi N1 = N2
Nếu N1 < N2 thì N2 = N2 - N1;
nếu không thì: N1 = N1 - N2;
kết thúc lặp.
Problem.Answer = N1.
Problem.Hint = Hãy liệt kê các ước số
của 2 số này.
Problem.Content = Tìm ước số chung
lớn nhất của 2 số <n1> và <n2>.
Tính bội số Đặt:
chung nhỏ
n1 = ngẫu nhiên từ 2 đến 100;
nhất của 2
số. n2 = ngẫu nhiên từ 2 đến 100;
k = n1*n2;
N1 = n1; N2 = n2;
Lặp cho đến khi N1 = N2
Nếu N1 < N2 thì N2 = N2 - N1;
nếu không thì: N1 = N1 - N2;
kết thúc lặp.
Problem.Answer = k/N1.
Problem.Hint = Hãy liệt kê các bội số
của 2 số này.
Problem.Content = Tìm bội số chung
nhỏ nhất của 2 số <n1> và <n2>.
toán
Đếm số các Đặt k = ngẫu nhiên từ 10 đến 100.
ước số
Đặt count = 0, i = 1.
thực sự.
Thực hiện lặp k - 1 lần.
Nếu k mod i = 0 thì tăng count
lên 1.
Tăng i lên 1.
kết thúc lặp.
Problem.Answer =
Problem.Hint =
Problem.Content =
Chuyển Biến đổi số thập phân decimal sang nhị Vì các số decimal hoặc binary sẽ phải được sinh
đổi số thập phân binary. ngẫu nhiên, do đó thủ tục chính có thể trình bày
phân sang theo thuật toán biến đổi từ decimal  binary
Gán binary = rỗng
nhị phân. hoặc ngược lại đều được.
Thực hiện lặp cho đến khi decimal = 0
Chương trình sau mô tả ch decimal sinh ngẫu
Đặt ch = Decimal mod 2; nhiên, tính binary sau.
decimal = decimal / 2 (làm tròn
xuống)
Bổ sung ch vào bên trái của
binary.
kết thúc lặp.
Problem.Answer = binary.
Problem.Hint = Hãy mở sách về thuật
toán biểu diễn nhị phân để xem lại.
Problem.Content = Biến đổi và tìm
dạng nhị phân của số sau <decimal>,
Chuyển Biến đổi số nhị phân binary sang thập Vì các số decimal hoặc binary sẽ phải được sinh
đổi số nhị phân decimal. ngẫu nhiên, do đó thủ tục chính có thể trình bày
phân sang theo thuật toán biến đổi từ decimal  binary
Gán ban đầu: decimal = 0, index = 1
thập phân. hoặc ngược lại đều được.
len = độ dài xâu binary.
Chương trình sau mô tả ch decimal sinh ngẫu
Thực hiện vòng lặp với độ dài len nhiên, tính binary sau.
ch = chữ số tương ứng chỉ số
index của binary
decimal = 2*decimal + ch
Tăng index lên 1
kết thúc lặp.
Problem.Answer = decimal.
toán
Problem.Hint = Hãy mở sách về thuật
toán biểu diễn nhị phân để xem lại.
Problem.Content = Hãy biến đổi sang
dạng thập phân của số nhị phân sau
<binary>.
Tìm giá trị Đặt pNumber = ngẫu nhiên tư 6 đến 20.

Max của 1
Đặt max = -1000.
dãy số cho
trước. Lặp pNumber bước
k = ngẫu nhiên -100 đến 100.
Đưa k vào mảng NumList.
Nếu max < k thì đặt max = k.
kết thúc lặp.
Problem.Answer = max.
Problem.Hint = Hãy so sánh các số và
tìm ra số lớn nhất.
Problem.Content = Tìm phần tử lớn
nhất của các số sau: <NumList>
Tìm giá trị Đặt pNumber = ngẫu nhiên tư 6 đến 20.
Min của 1 Đặt min = 1000.
dãy số cho
trước. Lặp pNumber bước
k = ngẫu nhiên -100 đến 100.
Đưa k vào mảng NumList.
Nếu min > k thì đặt max = k.
kết thúc lặp.
Problem.Answer = min.
Problem.Hint = Hãy so sánh các số và
tìm ra số nhỏ nhất.
Problem.Content = Tìm phần tử nhỏ
nhất của các số sau: <NumList>
toán
Dãy số Đặt k = ngẫu nhiên từ 1 đến 10.
chẵn liên
Đặt i = 2*k.
tục. Tìm số
tiếp theo. Lặp lại pNumber lần.
Tăng i lên 2.
kết thúc lặp.
Problem.Answer = Phần tử cuối cùng
của dãy NumList.
Problem.Hint = Các số trong dãy đều
là số chẵn.
Problem.Content = Tìm phần tử tiếp
theo của dãy số sau: <NumList>.
Dãy số lẻ. Đặt k = ngẫu nhiên từ 1 đến 10.
Tìm số tiếp
Đặt i = 2*k + 1.
theo.
Lặp lại pNumber lần.
Tăng i lên 2.
kết thúc lặp.
của dãy NumList.
là số lẻ.
Dãy số Đặt p = ngẫu nhiên trong các số 2, 3, 5, Chương trình này sử dụng thủ tục
nguyên tố 7, 11 Next Primary (number) để tìm ra số nguyên tố
liên tục. đầu tiên > number. Kết quả lưu vào biến nhớ
Tìm số tiếp Next.Primary.Math.
theo. Đưa p vào mảng NumList.
Tính p = số nguyên tố đầu tiên
tiếp theo.
kết thúc lặp.
của dãy NumList.
là số nguyên tố.
toán
Chú ý: trong thuật toán trên có sử dụng
2 thủ tục hay thuật toán con.
Thủ tục Is Primary <p> kiểm tra xem số p có
- Thủ tục kiểm tra 1 số có phải là phải là nguyên tố hay không. Kết quả trả về vào
nguyên tố hay không. biến nhớ kq.math.
- Thủ tục tính số nguyên tố tiếp theo
nhỏ nhất sau 1 số tự nhiên cho trước.
Is Primary <p>
1. Thủ tục kiểm tra 1 số có phải là
nguyên tố hay không.
Thuật toán kiểm tra 1 số p có là nguyên
tố hay không. Kết quả lưu vào biến kq.
Số p là nguyên tố nếu kq = 1.
Đặt kq = 0, k = 2.
Nếu p = 1 thì Exit.
Lặp liên tục cho đến khi p chia hết cho
k hoặc k > p-1.
k=k+1
kết thúc lặp.
Nếu k = p thì đặt kq = 1.
Thủ tục Next Primary <n> sẽ tìm số nguyên tố
nhỏ nhất > n và trả kết quả vào biến nhớ
2. Thủ tục tính số nguyên tố tiếp theo Next.Primary.Math.
sau số n.
(xem hình bên).
Dãy số Đặt i = ngẫu nhiên từ 1 đến 5.

chính
phương
liên tục. Đưa i*i vào mảng NumList.
Tìm số tiếp i=i+1
theo.
kết thúc lặp.
của dãy NumList. (Phần tử thứ
pNumber).
toán
Problem.Hint = Các số trong dãy này
là các bình phương đúng liên tục.

a) Sân khấu là nơi gửi thông điệp Reset đầu tiên.
Sân khấu.
Sân khấu gửi thông điệp Reset

ngay sau khi bắt đầu chương trình.
Sân khấu sẽ kiểm soát biến nhớ Input.

Thiết lập = rỗng mỗi khi Reset.
Giáo viên.
Giáo viên sẽ kiểm soát 2 biến nhớ hệ

thống: Score và TimeStart.
b) Nhân vật Math sẽ nhận thông điệp Reset, sinh 1 bộ dữ liệu của bài toán và gửi
thông điệp Start để bắt đầu một bài toán của chương trình.
Thủ tục Generate Problem có chức năng

sinh 1 bộ dữ liệu cho bài toán chính. Sinh
xong thì gửi thông điệp Start để bắt đầu quá
trình giải toán.
Thủ tục Generate Problem sẽ gọi

ngẫu nhiên 1 trong các thủ tục con
sinh một dạng toán cụ thể. Các thuật
toán và chương trình cụ thể này dã
được mô tả trong phần trên.
Nhận được thông điệp Start, hệ thống bắt đầu hoạt động hết công suất của
mình.
c) Giáo viên thông báo nội dung bài toán.
Problem.Content là Giáo viên thông báo nội dung bài

biến nhớ riêng của toán, đặt TimeStart = 1 để sẵn sàng
Math nên không thể cho tương tác giải toán.
truy cập trực tiếp.
d) Sân khấu liên tục yêu cầu người chơi nhập đáp số của bài toán hiện thời.
Đồng thời, sau thông điệp

Start, sân khấu sẽ liên tục
yêu cầu người chơi nhập
đáp số của bài toán, nhập
cho đến khi đúng thì thôi.
- Nếu nhập sai, gửi thông
điệp Sai rồi.
- Nếu nhập đúng, gửi thông
điệp Done.
e) Người chơi nháy lên con rùa để xem hướng dẫn, gợi ý.
Nếu ggười chơi nháy chuột lên

rùa trong thời gian làm bài
(TimeStart = 1) thì rùa sẽ
thông báo gợi ý của bài toán.
f) Xử lý thông điệp Sai rồi.

Giáo viên sẽ xử lý khi người chơi nhập sai như sau:
Giáo viên thông báo "Sai rồi",

sau đó hiện lại nội dung bài
toán, đồng thời trừ 1 điểm cho
người làm bài.
g) Xử lý thông điệp Done.

Giáo viên xử lý khi người chơi nhập đúng đáp số như sau.
Giáo viên thông báo "Đúng
rồi", tăng 15 điểm cho người
làm bài và đặt lại TimeStart
= 1.
h) Điều khiển nút Next.
Khi bắt đầu chương

trình thì ẩn đi.
Khi người chơi làm

đúng thì hiện lên.
Người chơi nháy lên thì

lại ẩn đi và gửi thông
điệp Reset.
3. Trò chơi bắn súng giải toán
Ý tưởng vừa Chúng ta sẽ cùng thiết kế thêm 1 trò chơi "giải toán" nữa nhưng theo một cách
chơi vừa học. khác, hấp dẫn hơn. Người chơi sẽ được "chơi" trước khi phải "giải toán". Ý tưởng
chung của tất cả các phần mềm kiểu này là "vừa chơi, vừa học", hay cụ thể hơn là:
trong khi chơi, để vượt qua các chướng ngại vật, người chơi bắt buộc phải giải
toán. Chúng ta sẽ hiện thực hóa ý tưởng phần chơi là "bắn súng", còn phần học là
"giải toán có đáp số" như trong ví dụ trên.
Mô hình các chương trình, phần mềm dạng "vừa chơi, vừa học" có dạng chung
như sau:
StartGame StartMath
Trò chơi Học, giải toán
StartMath = 0 StartMath = 1
Nguyên tắc hoạt động của các hệ thống chương trình dạng như thế này:
- Chương trình sẽ phân chia thành 2 giai đoạn, hay 2 trạng thái tách biệt hoàn
toàn: trạng thái "trò chơi" và trạng thái "học toán". Phân biệ giữa 2 trạng thái này
có thể là 1 biến nhớ hệ thống, ví dụ StartMath, hoặc là các sự kiện, ví dụ
StartGame đánh dấu bắt đầu "trò chơi", còn StartMath đánh dấu bắt đầu "học
toán".
- Giữa 2 module này có sự quan hệ với nhau. Ví dụ muốn đạt điểm của trò chơi
cần giải xong 1 bài toán. Muốn chơi thì phải giải toán thật nhanh.
Ban sung giai

toan.sb2
Ý tưởng thiết kế của
chương trình là:
Người chơi cần bắn súng
trúng vào các bao tải tiền
để được thưởng điểm,
nhưng muốn có điểm thì
phải giải 1 bài toán đúng
đã.
Module Math được thiết
kế tương tự như các ví dụ
đã biết.
Giao diện của chương trình được chia làm 2 giai đoạn (2 pha): chơi và học.
Phần chơi của chương trình: cần bắn Phần giải toán của chương trình: cần
súng trúng vào các bao tải tiền. Bao nhập đáp số đúng cho bài toán mà GV
tải càng nhỏ, điểm số sẽ càng cao. đang yêu cầu làm trên màn hình.
Mô tả hoạt động của chương trình.

- Chương trình bắt đầu từ trạng thái "chơi" (StartMath = 0, sự kiện StartGame).
Người dùng điều khiển súng bằng các phím phải, trái để quay hướng nòng. Bấm
phím Space để bắn.
- Từ phía trên các bao tải tiền (có ký hiệu π) rơi xuống với kích thước khác nhau.
Kích thước càng nhỏ, càng khó bắn trúng sẽ có điểm thưởng cao hơn. Nếu bị đạn
bắn trúng, lập tức toàn bộ chương trình chuyển sang chế độ "giải toán" (StartMath
=1, sự kiện StartMath), các nhân vật như súng, đạn, bao tải sẽ biến mất. Người
dùng bấm phím Space để bắn súng, mỗi lần bắn sẽ bị trừ 1 điểm.
- Khi chuyển sang chế độ giải toán, xuất hiện 1 bảng đen, GV sẽ xuất hiện để điều
khiển tương tác với người chơi. GV thể hiện yêu cầu bài toán ngay trên bảng.
- Người chơi cần nhập đáp số của bài toán, nhập liên tục cho đến khi đúng thì
thôi. Nếu nhập sai sẽ bị trừ 1 điểm. Nếu nhập đúng, sẽ được thưởng số điểm =
CurrMathPoint, khi đó xuất hiện nút Next. Bấm vào nút này sẽ chuyển về chế độ
chơi.
Một số biến nhớ quan trọng của chương trình.

Stt Tên biến nhớ Ý nghĩa
1 StartMath Biến nhớ chỉ ra trạng thái hoạt động chính của
chương trình.
= 0, trạng thái "chơi", bắn súng vào bao tải.
= 1, trạng thái giải toán.
2 CurrMathPoint Biến nhớ dùng để lưu giá trị điểm số sẽ được
thưởng. Khi người chơi bắn trúng 1 bao tải, giá trị
này được xác định và lưu trữ lại. Khi người chơi
giải được bài toán thì mới thưởng điểm.
Thiết kế danh sách nhân vật.
Stt Biểu tượng Ý nghĩa, hoạt động của nhân vật
1 Súng thần công. Khi người dùng nhấn phím Space thì sẽ
phát thông điệp Shot.
2 Đạn. Khi nhận thông điệp Shot sẽ xuất hiện tại đầu nòng
súng như 1 clone và dịch chuyển theo hướng nòng súng
cho đến khi gặp cạnh màn hình hoặc nếu nhận thông
điệp StartMath thì tự xóa.
3 Bao tải tiền. Bao tải tiền xuất hiện như các clone với
kích thước = size là % so với gốc. Giá trị size sẽ lấy ngẫu
nhiên từ 10-50%. Nếu va chạm với đạn thì lập tức tính
toán CurrMathPoint, gửi thông điệp StartMath, thiết
lập biến nhớ StartMath = 0 và xóa tất cả các clone trên
màn hình.
4 Đối tượng này được xây dựng đặc biệt để lưu trữ tất cả
các dữ liệu và thuật toán sinh tự động các bài toán và dữ
liệu của chương trình. Bộ dữ liệu của module Math như
sau:
Problem.Hint: Gợi ý bằng lời cách giải bài toán.
Problem.Answer: Đáp số duy nhất của bài toán.
Problem.Content: Nội dung bằng lời của bài toán.
5 Giáo viên. Giáo viên xuất hiện khi nhận được thông điệp
StartMath, sau đó sẽ điều khiển tương tác với người
chơi để giải toán.
6 Nút lệnh Next. Nút này xuất hiện khi nhận thông điệp
Đúng rồi. Khi nháy lên nút này sẽ phát thông điệp
Reset.
7 Bảng làm toán. Bảng này xuất hiện khi nhận thông điệp
StartMath. Bảng sẽ ẩn đi nếu nhận thông điệp Reset.
Phân tích 1 số đặc thù và công nghệ của chương trình.

- Việc tự động sinh các bài toán có dạng nhập đáp số hoàn toàn tương tự chương
trình Tìm số trong bài học trước, chúng ta sẽ không nhắc lại trong bài học này
nữa.
- Các bao tải sẽ xuất hiện ngẫu nhiên ở phía trên và rơi xuống với vận tốc nhanh.
Sử dụng clone để thể hiện các bao tải này.
- Viên đạn sẽ bắn ra từ đầu nòng súng. Sử dung công cụ clone để thể hiện các viên
đạn này.
- Thiết kế tâm của nòng súng tại điểm gốc của nòng súng, như sau:
Tâm của súng tại vị trí
này.

1 Score (biến nhớ) Điểm số của người chơi. Cách tính điểm như sau:
- Mỗi lần bắn súng trừ 1 điểm.
- Nếu bắn trúng bao tải thì được thưởng điểm tỉ lệ
nghịch với kích thước bao tải. Nhưng điểm này chỉ
được cộng vào khi làm đúng bài toán sau đó.
- Mỗi lần làm bài sai bị trừ 1 điểm.
2 Input (biến nhớ) Biến nhớ dùng để lưu đáp án do người dùng nhập
khi giải toán.
3 StartMath (biến Biến nhớ chỉ ra trạng thái hoạt động chính của
nhớ) chương trình.
= 0, trạng thái "chơi", bắn súng vào bao tải.
= 1, trạng thái giải toán.
4 CurrMathPoint Biến nhớ dùng để lưu giá trị điểm số sẽ được
(biến nhớ) thưởng. Khi người chơi bắn trúng 1 bao tải, giá trị
này được xác định và lưu trữ lại. Khi người chơi
giải được bài toán thì mới thưởng điểm.
Các biến nhớ và mảng sau là biến riêng của nhân vật Math. Các biến này được
dùng để sinh các bài toán của chương trình.
1 Problem.Content Nội dung bài toán.
(biến nhớ)
2 Problem.Hint Gợi ý của bài toán.
(biến nhớ)
3 Problem.Answer Đáp số của bài toán.
(biến nhớ)
4 pNumber (biến Số lượng phần tử của dãy sẽ được sinh tự động.
nhớ) Giá trị có trong chương trình là pNumber = 6.
5 NumList (list) Dãy số chính (gốc) được sinh tự động của thuật
toán.
6 N1, N2, N3, N4, 5 biến nhớ tổng thể lưu 5 giá trị đầu tiên của dãy.
N5 (biến nhớ) Bài toán chính là tìm phần tử tiếp theo (một cách
hợp lý) của dãy trên.
Biến nhớ riêng của nhân vật Đạn.
1 CloneID ID của nhân vật. = 0 nếu là nhân vật gốc, > 0 nếu
là clone.
Biến nhớ riêng của nhân vật Bao tải.
1 CloneID ID của nhân vật. = 0 nếu là nhân vật gốc, > 0 nếu
là clone.
2 Size Kích thước (tính theo %) của nhân vật thể hiện.
Tạo clone bắn ra từ nòng

StartGame Người dùng điều khiển súng. Nếu StartMath = 1
hướng nòng súng. Nếu thì xóa tất cả clone.
Liên tục yêu cầu người chơi bấm Space thì gửi Shot.
nhập đáp số bài toán. Nếu Shot
sai, gửi thông điệp Sai rồi,
nếu đúng, gửi thông điệp
Đúng rồi.
Sinh 1 bài toán ngẫu
Sai rồi nhiên. Gửi thông điệp
Start.
Đúng rồi Tạo clone rơi xuống. Nếu
gặp đạn thì gửi thông Start
điệp StartMath.
StartMath
Nếu StartMath = 1 thì

Hiện xóa tất cả clone.
Hiển thị thông tin
Ẩn bài toán.
Thông báo đúng/
Hiện Nếu người dùng sai và tăng, giảm
nháy lên, gửi thông điểm cho người
điệp Reset và ẩn đi. chơi.
StartGame
Pha 1: Game.
a) Sân khấu là nơi gửi thông điệp StartGame đầu tiên.
Nhận được thông điệp StartGame, các nhân vật sẽ chuẩn bị cho Game bắn súng.
b) Chương trình điều khiển súng sẽ sẵn sàng cho việc bắn đạn. Súng lúc này mới
xuất hiện, còn trước đó thì ẩn đi.
c) Các bao tải sẽ rơi ngẫu nhiên từ phía trên với kích thước ngẫu nhiên.
Chương trình sinh clone của nhân vật Bao tải như sau. Chú ý nhân vật gốc phải có
CloneID = 0, các phân thân sẽ có CloneID > 0.
Khi nhận thông điệp StartGame, chương trình điều khiển Bao tải như sau.
Kiểm tra chỉ thực hiện khi nhân

vật là gốc có CloneID = 0.
Đoạn chương trình sinh clone:

- Tăng CloneID lên 1.
- Thiết lập vị trí X ngẫu nhiên.
- Đặt kích thước ngẫu nhiên từ
10%  50%.
- Sau mỗi 3 giây sinh 1 clone.
Chú ý:
- Trong suốt quá trình tạo ra clone, nhân vật gốc của Bao tải vẫn ẩn, không hiện
trên màn hình.
- Các bao tải có kích thước khác nhau. Người chơi bắn trúng bao tải càng nhỏ
càng được điểm cao.
Bao tải khi được tạo ra (bằng clone) sẽ rơi xuống đất với tốc độ khá nhanh và biến
mất khi rơi xuống đất.
d) Điều khiển súng bắn.

Đoạn chương trình sau điều khiển việc bắn súng. Chú ý là chỉ sau thông điệp
StartGame, súng mới hiện trên màn hình để điều khiển được.
Điều khiển nòng súng quay trái, phải

bằng các phím mũi tên.
Khi người chơi bấm Space thì gửi

thông điệp Shot (đồng thời có âm
thanh tiếng nổ lớn).
e) Điều khiển viên đạn bắn ra.

Viên đạn sẽ bắn ra từ tâm súng khi nhận được thông điệp Shot. Mỗi lần bắn súng
sẽ bị trừ 1 điểm.
Kiểm tra chỉ thực hiện với nhân

vật gốc có CloneID = 0.
Di chuyển tới vị trí

tâm và hướng của
súng, cho chạy 40
bước ra đầu nòng thì
tạo clone, hiển thị
thành viên đạn.
Sau khi tạo clone thì trả lại giá trị

gốc CloneID = 0 cho nhân vật
gốc.
Các chương trình sau điều khiển viên đạn sau khi ra khỏi nòng súng.
- Luôn chuyển động với vận tốc cố định về 1 hướng.
- Nếu gặp cạnh thì tự xóa clone.
Nếu gặp cạnh

thì tự xóa
clone.
Chú ý: Không có và không cần chương trình điều khiển đạn khi gặp bao tải vì
điều này sẽ được lập trình bởi bao tải.
f) Khi viên đạn bắn trúng Bao tải, lập tức chuyển sang chế độ Học toán.
Đoạn chương trình điều khiển khi đạn bắn trúng Bao tải như sau:
Nếu va chạm
với Đạn
Đặt StartMath = 1; gửi thông

điệp StartMath, gán điểm số tạm
thời bằng 100-Size và xóa
clone.
Điểm số tạm thời CurrMathPoint không được thưởng ngay mà đợi khi người
chơi làm xong 1 bài toán mới thực hiện. Điểm số này = 100 - Size, do đó điểm
càng cao nếu kích thước bao tải càng nhỏ.
Pha 1: Giải toán.

a) Ngay sau thông điệp StartMath, tất cả các loại clone đều bị xóa hết. Đoạn
chương trình sau có trong cửa sổ lệnh của nhân vật Đạn và Bao tải.
b) Nhân vật Math nhận thông điệp StartMath sẽ tiến hành sinh ngẫu nhiên 1 bộ
dữ liệu
Thủ tục Generate Problem hoàn toàn

tương tự các ví dụ khác của chủ đề này.
Thủ tục sẽ sinh ngẫu nhiên 1 bộ dữ liệu
cho bài toán cần giải.
c) Giáo viên khi nhận được thông điệp Start sẽ xuất hiện và thông báo nội dung
bài toán cần làm.
Đồng thời sân khấu sẽ liên tục sẽ yêu cầu người chơi nhập đáp số cho bài toán.
Nếu người dùng nhập sai thì gửi thông điệp Sai rồi và yêu cầu nhập tiếp, nếy
đúng rồi thì kết thúc và gửi thông điệp Đúng rồi.
Lặp cho đến khi làm

đúng thì thôi.
Kết quả nhập của người

chơi đưa vào Input.
Kiểm tra kết quả làm bài

và gửi thông điệp tương
ứng.
d) Giáo viên xử lý 2 thông điệp Sai rồi và Đúng rồi như sau.
Nếu sai, thông báo sai

rồi và hiện lại nội dung
đề bài.
Nếu đúng, tăng điểm với số điểm

bằng CurrMathPoint của lần
chơi trước đó.
e) Khi người chơi làm đúng bài toán, nút Next xuất hiện để chuẩn bị cho công
việc tiếp theo.
Nháy lên nút này sẽ gửi thông điệp StartGame và quay trở lại trạng thái trò chơi.
Toàn bộ chương trình điều khiển nút Next như sau.
thì ẩn.
Xuất hiện sau khi nhận

thông điệp Đúng rồi.
Khi người dùng nháy lên thì gửi

thông điệp StartGame để bắt đầu
chế độ chơi.
f) Cuối cùng là nhân vật Bảng đen, chỉ xuất hiện khi làm toàn.

1. Viết và cài đặt chương trình cho các thuật toán sau:
a. Cho trước 1 số, kiểm tra xem có phải là hợp số hay không.
b. Cho trước số n, tìm hợp số nhỏ nhất > n.
c. Cho trước số n, tính và liệt kê tất các các ước số nguyên tố (khác nhau) của n.
Ví dụ nếu n = 12, thì cần liệt kê 2, 3.
d. Cho trước số tự nhiên n, tính và liệt kê tất cả các số nhỏ hơn n và nguyên tố
cùng nhau với n.
e. Cho trước 2 số tự nhiên m, n. Tính và liệt kê tất cả các ước số chung của 2 số
này.
f. Cho trước 3 số tự nhiên m, n. p. Tính ước số chung lớn nhất của 3 số này.
g. Cho trước 3 số tự nhiên m, n. p. Tính bội số chung nhỏ nhất của 3 số này.
2. Mở rộng chương trình Điền số vào dãy, thể hiện các dãy số gốc và đáp án bằng
hình ảnh các số như trong hình sau:
3. Mở rộng, thay đổi phần mềm Bắn súng giải toán theo yêu cầu sau:
Khi chơi, người chơi sẽ được chơi thoải mái cho đến khi nào bị một bao tải rơi
xuống đất thì phải chuyển sang làm toán. Làm đúng 1 bài toán sẽ được quay lại
chơi bắn súng. Điểm số luôn được cộng vào khi bắn trúng 1 bao tải.
4. Phân loại các dạng toán có thể số hóa.
Bảng sau phân loại các dạng toán điền số vào dãy có thể thực hiện. Hãy viết các
thuật toán và thủ tục cho các bài toán này để áp dụng vào các chương trình đã mô
tả trong chủ đề này.
Stt Name Công thức
Dãy số theo công thức
1. Dãy số chẵn liên tục 2*N
2. Dãy số lẻ liên tục 2*N-1
3. Dãy số chính phương liên tiếp N*N
4. Dãy số liên tục là bội của 3 3*N
5. Dãy số liên tục là bội của 5 5*N
6. Dãy số liên tục là chính phương cộng 1 N*N+1
7. Dãy số liên tục là chính phương trừ 1 N*N-1
8. Dãy số liên tục là lập phương đúng N*N*N
9. Dãy số liên tục là lập phương đúng cộng 1 N*N*N+1
10. Dãy số liên tục là lập phương đúng trừ 1 N*N*N-1
11. Dãy số liên tục theo qui luật có dạng tổng quát là Q*N+R
Q*N+R, với 0<R<Q<10 (Q, R được sinh ngẫu
nhiên)
Dãy số theo qui luật logic chặt (sử dụng hàm để tạo
dãy)
12. Dãy các số nguyên tố liên tục MakePrime(N)
13. Dãy các số hợp số liên tục MakeCom(N)
14. Dãy số Fibonaci (*) Fibonaci(N)
15. Dãy số liên tục chỉ có ước nguyên tố là 2 và 3 Make23(N)
16. Dãy số liên tục chỉ có ước nguyên tố là 2, 3 và 5 Make235(N)
17. Dãy số có dạng n + F(n) - tổng của dãy số tự nhiên MakeGFi(N)
và dãy Fibonaci (*)
18. Dãy số sinh theo qui luật (+N,-M), số hạng đầu Make07(N)
tiên là bất kỳ, N, M là các số tự nhiên bất kỳ.
19. Dãy số sinh theo qui luật (+N1,+N2,-M1,-M2), số Make08(N)
hạng đầu tiên bất kỳ, N1, N2, M1, M2 là các số tự
nhiên.
Dãy số theo qui luật logic lỏng (sử dụng thủ tục sinh
phần tử tiếp theo)
20. Dãy đơn điệu tăng An < An+1
21. Dãy đơn điệu giảm An > An+1
22. Dãy chỉ bao gồm các số chẵn An mod 2 = 0
23. Dãy chỉ bao gồm các số lẻ An mod 2 = 1
24. Dãy là một cấp số cộng An+1=
2*An -An-1
25. Dãy là một cấp số nhân An+1=
An*An/An-1
26. Dãy bao gồm các số > 0 An > 0
27. Dãy bao gồm các số < 0 An < 0
28. Dãy chỉ bao gồm các số nguyên tố MakePNext()
29. Dãy chỉ bao gồm các số chính phương MakeSQ()
30. Dãy chỉ bao gồm các số là hợp số MakeC()
31. Dãy chỉ bao gồm các số chia hết cho 10 MakeTen()
32. Dãy chỉ bao gồm các số chia hết cho 4 MakeFour()
33. Dãy chỉ bao gồm các số chia hết cho 5 MakeFive()
34. Dãy số có tính chất hiệu hai số bất kỳ đều chia hết DiffDFive()
cho 5.
Dãy số đặc biệt (dùng thủ tục hoặc hàm số sinh dãy)
35. Dãy số thập phân của PI PISeq(N)
314159265358979323846264338
32795
36. Dãy số thập phân của căn 2 (*) SQRT2(N)
141421356237309504880168872
42097
37. Dãy chữ số của các số tự nhiên <100 viết liền NaturalSeq(N)
nhau
12345678910111213141516171819202122...
38. Dãy chữ số của các số tự nhiên chẵn <100 viết EvenSeq(N)
liền nhau
246810121416182022242628303234363840..
39. Dãy chữ số của các số tự nhiên lẻ <100 viết liền OddSeq(N)
nhau
13579111315171921232527293133....
40. Dãy số sắp xếp theo thứ tự từ điển Việt Nam VNAlphabet(N)
3 4 7 9 2 0 1 10 5 6 8
5. Mở rộng chương trình điền số vào dãy bằng giao diện điền số vào 1 ô trống của
một ma trận, ví dụ, kích thước 3 x 3. Chương trình này thực chất là mở rộng của
bài toán trên với số lượng phần tử của dãy pNumber = 9.
Chủ đề 8.
Phần mềm hỗ trợ học Khoa học
Mục tiêu:
- Thiết lập các dạng bài toán mô tả các hiện tượng thực tế, có tính chính xác và
khoa học.
- Thiết kế một số phần mềm đơn giản cho môn Khoa học tự nhiên.
Nội dung chính
1. Mô phỏng đồng hồ và lịch
Chúng ta cùng thiết kế bài toán mô phỏng lịch bàn, có dạng như hình sau.
Thời gian chạy online Ngày hiện Tháng, năm hiện

đến từng giây. thời. thời.
Lịch chi tiết của

tháng hiện thời.
a) Phân tích bài toán

Bài toán trên có thể phân tích và tách thành những yêu cầu nhỏ hơn như sau:
- Bài toán thể hiện thời gian chạy online của đồng hồ hệ thống.
- Bài toán thể hiện các thông số như ngày - tháng - năm bằng chữ số lớn trên màn
hình.
- Bài toán thể hiện lịch tháng chính xác.
- Bài toán vẽ khung lưới của lịch tháng.
Chúng ta sẽ cùng phân tích và giải quyết các bài toán trên.
b) Các hàm cảm biến thời gian của Scratch
Trong Scratch, nhóm cảm biến có 1 hàm duy nhất liên quan đến thời gian. Chúng
ta cần phải học và bắt đầu từ hàm này.
Dưới đây là mô tả chi tiết lệnh (hàm) cảm biến thời gian của Scratch.
Hàm cảm biến thời gian của Scratch.
year: năm hiện thời, ví dụ: 2017.
month: tháng hiện thời, ví dụ: 8
date: ngày (trong tháng) hiện thời, ví dụ: 10
day of week: ngày trong tuần, tính bắt đầu từ CN.
CN: 1, thứ 2: 2, …., thứ 7: 7.
hour: giờ hiện thời, tính từ 0 đến 23.
minute: phút hiện thời, tính từ 0 đến 59.
second: giây hiện thời, tính từ 0 đến 59.
c) Vẽ lưới của lịch tháng

Công việc đầu tiên là cần vẽ lưới và chuẩn bị dãy tọa độ để thể hiện lịch tháng.
Mô hình cụ thể sẽ là 1 lưới chữ nhật kích thước 7 x 7. Mỗi ô lưới sẽ có kích thước
60 x 40.
Vị trí gốc để vẽ lưới, có tọa

độ (-210, 100). Hàng tiêu đề của
lịch tháng.
Vị trí tâm của các ô

lưới này sẽ là tọa độ
để hiển thị ngày trong
tháng.
Dãy tọa độ của tâm các ô lưới của lịch được lưu trong 2 dãy số XList và YList
như sau:
XList -180 -120 -60 0 60 120 180
YList 80 40 0 -40 -80 -120 -160
Ví dụ tọa độ tâm của ô lưới đầu tiên (góc trái trên) là (-180, 80). Từ đó suy ra tọa
độ điểm góc trái trên của lưới vẽ lịch tháng có tọa độ là (-210, 100). Tọa độ này
được gán cho cặp biến nhớ XPos, YPos.
Để tổng quát, chúng ta sẽ viết chương trình vẽ lưới kích thước m x n với các biến
nhớ m và n được gán trước = 7.
Đoạn chương trình gốc chuẩn bị cho vẽ lưới như sau, trong đó thủ tục vẽ lưới
chính là Draw-Latice.
Thiết lập thông số màu sắc và

kích thước bút vẽ.
Thiết lập các biến nhớ ban đầu: m, n: kích

thước lưới; Xpos, Ypos: tọa độ điểm trái trên.
Thủ tục vẽ chính.
Thủ tục vẽ lưới chính như sau.
Vẽ các đường kẻ ngang của

bảng (m + 1 đường ngang).
Vẽ các đường kẻ dọc của bảng

(n + 1 đường dọc)
d) Thiết kế biến nhớ hệ thống

Sau đây là danh sách các biến nhớ hệ thống được dùng cho chương trình này. Có
thể chia thành các nhóm sau:
- Nhóm thông tin thời gian hiện thời (ngày, tháng, năm, giờ, phút, giây, …..).
- Nhóm thông tin tham chiếu.
- Nhóm các dữ liệu hệ thống khác.
Tên biến nhớ Ý nghĩa Ghi chú
Year Biến nhớ ghi số năm của lịch. Mặc định là năm hiện
thời.
Month Biến nhớ ghi số tháng của lịch (từ Mặc định là tháng
1 đến 12). hiện thời.
Date Biến nhớ ghi ngày của tháng (từ 1 Mặc định là ngày
đến 31). hiện thời.
Hour Biến nhớ ghi giờ của ngày (từ 0 Mặc định là giờ hiện
đến 24). thời.
Minute Biến nhớ ghi phút của giờ (từ 0 Mặc định là phút
đến 59). hiện thời.
Second Biến nhớ ghi giây của phút (từ 0 Mặc định là giây hiện
đến 59). thời.
leap-year Tham số này dùng để kiểm tra Giá trị này cần được
xem năm với giá trị year có phải tính toán dựa trên
là nhuận hay không. year.
CurrDay Ngày trong tuần của Date hiện Giá trị này chính là
thời (từ 1 đến 7 tương ứng với CN hàm:
 thứ 7).
FirstDay Ngày trong tuần của ngày mùng 1 Giá trị này cần tính
của tháng. toán.
DayOfMonth Mảng 12 số lưu lại số ngày của
(list) các tháng tương ứng của năm hiện
thởi. Ví dụ với năm nhuận, dãy
này có giá trị như sau:
31, 29, 31, 30, 31, 30, 31, 31, 30,
31, 30, 31.
DayList (list) Dãy tên tiếng Việt của các ngày
trong tuần, bắt đầu từ "Chủ nhật",
"Thứ 2", …., "Thứ 7".
MonthList Dãy tên tiếng Việt của các tháng
trong năm, bắt đầu từ "Tháng
Giêng", "Tháng 2", …. , "Tháng
Chạp".
XList, YList Dãy các tọa độ X, Y của tâm các ô
lưới của lịch tháng.
e) Sơ đồ hoạt động hệ thống
Sơ đồ hoạt động của chương trình này rất đơn giản. Điều quan trọng nhất là tất cả
các thông số, biến nhớ hệ thống cần được kích hoạt, tính toán trước khi thực hiện
các công việc thể hiện lịch và đồng hồ hệ thống trên màn hình.
Thay đổi thông số

hệ thống (nếu có). Thể hiện thông tin
Gán các thông số hệ trên màn hình.
thống ban đầu.
Reset Tính toán các giá trị hệ

Start
thống có liên quan.
Giải thích các hoạt động trong sơ đồ trên như sau:

Gán các thông số hệ Thiết lập các thông tin hệ thống ban đầu như Year,
thống ban đầu. Month, Date, CurrDay.
Tính toán các giá trị hệ Tính toán và thiết lập các thông tin hệ thống tiếp
thống có liên quan. theo như FirtDay, leap-year, …
Thể hiện thông tin trên Phần chính: thể hiện lịch tháng và các thông số
màn hình. khác trên màn hình theo yêu cầu.
Thay đổi thông số hệ Thay đổi thông tin ngày - giờ nếu có. Đây là các
thống (nếu có). chức năng bổ sung sẽ mô tả trong các phần sau.
f) Lập trình thiết lập các thông số hệ thống
Đầu tiên là việc thiết lập các thông số hệ thống ban đầu, lấy từ các hàm cảm biến
của Scratch.
Gán các tham số hệ

thống liên quan đến
thời gian hiện thời, sau
đó gửi thông điệp
Reset để bắt đầu tính
toán.
Tiếp theo là tính toán các thông số hệ thống dựa trên các giá trị đã được gán ở
bước trên.
- Tính toán năm nhuận.
Định nghĩa Năm year là nhuận nếu:
năm nhuận. year chia hết cho 4 trừ ra trường hợp year chia hết cho 100 và
không chia hết cho 400.
Thủ tục sau nhận giá trị đầu vào là year, kiểm tra xem có phải là năm nhuận
không và gán kết quả cho biến leap-year.
- Bước tiếp theo cần tính ngày trong tuần chính xác của ngày mùng 1 của tháng
hiện thời.
Đầu vào: Date, CurrDay. Đầu ra cần tính: FirstDay.
Tính toán này quan trọng vì nó xác định vị trí đặt ngày mùng 1 của tháng trên ô
lưới.
Thủ tục sau sẽ tính toán giá gtrị FirstDay. Thuật toán này khá đơn giản có thể mô
tả như sau:
Gọi N1 là số cùng ngày của Date trong khoảng 1..7. N1

Thuật toán có thể tính như sau:
tính N1 = Date mod 7. Nếu N1 = 0 thì gán N1 = 7.
FirstDay -
tính ngày Nếu CurrDay > N1 thì
trong tuần FirstDay = CurrDay - N1 + 1
của mùng 1.
nếu không thì
FirstDay = CurrDay + 7 - N1 + 1.
Đoạn chương trình cụ thể như sau:
Đây là chương trình tính toán các thông số hệ thống sau khi nhận được thông điệp
Reset, trước khi gửi thông điệp Start.
Tính FirstDay.
Tính năm nhuận: leap-year.
Cập nhật số ngày tháng 2 dựa

trên tính toán năm nhuận.
Gửi thông điệp Start.
f) Lập trình hiện thông tin trên lịch tháng

Thông tin trên lưới của lịch tháng có 2 phần: (1) tiêu đề ngày trong tuần và (2) các
ngày trong tháng. Có 2 công nghệ có thể được thực hiện: sử dụng lệnh stamp để
vẽ lại hình và clone để hiện nhân vật. Chúng ta sẽ sử dụng cả 2 công nghệ này.
Sử dụng lệnh stamp để

viểt các chữ này tại
dòng tiêu đề của lịch.
Sử dụng công nghệ

clone để thể hiện các
đối tượng số này trên
lưới.
Cần thiết kế 2 nhân vật có tên, ví dụ, Ngày - Tuần và Ngày - Tháng để thực hiện
các công việc trên.
Nhân vật này có các trang

phục là các hình ảnh chữ CN,
Th 2, Th 3, …, Th 7.
Nhân vật này có các trang

phục là các hình ảnh số từ 1
đến 31.
Đoạn chương trình sau sẽ thể hiện các ngày trong tuần tại dòng tiêu đề của lịch, sử
dụng lệnh stamp. Nhân vật Ngày - Tuần sẽ có đúng 7 trang phục, tương ứng với
hình ảnh của các chữ CN, Th 2, …., Th 7.
Nhân vật Ngày - Tháng có 31 trang phục tương ứng với các chữ số từ 1 đến 31
được tạo ra để thể hiện các số của lịch tháng. Có thể sử dụng lệnh stamp để vẽ
các số này trên lịch như trên.
Nhưng ở đây chúng ta sẽ dùng công nghệ Clone để thực hiện công việc này. Mỗi
giá trị số trên lịch tháng là một phân thân của nhân vật Ngày - Tháng. Cách làm
này về hiệu ứng thể hiện giống như trên nhưng có thể phát triển nhiều tính năng
mở rộng sau này, ví dụ khai thác thêm thông tin của từng ngày trong tháng.
Cần thiết lập các biến nhớ riêng của Ngày - Tháng như sau:
ID Biến nhớ này sẽ lưu trữ số thứ tự hay chính là ngày
(date) trong tháng (từ 1 đến 31).
DayID Biến nhớ này lưu trữ ngày trong tuần của date (ID)
hiện thời của nhân vật. Giá trị nhận từ 1 (CN) đến 7
(thứ 7).
Đoạn chương trình sau mô tả cách sinh các clone và phân bổ chúng trên lưới của
lịch tháng hiện thời.
g) Lập trình hiện thông tin ngày, tháng, năm
Để thể hiện thông tin ngày, tháng, năm và thời gian chúng ta sẽ sử dụng nhân vật
Number bao gồm trang phục là các số từ 0 đến 9.
Cần thiết lập các chương trình thể hiện phần phía trên của lịch tháng như sau.
Cần thiết lập 1 thủ tục chung Show Number (n, X, Y) để thể hiện số n bắt đầu từ
vị trí tọa độ (X, Y) như sau.
Thủ tục này gần tương tự thủ tục hiện số bằng hình ảnh đã được trình bày trong
các chủ đề trước nhưng ở đây được thiết kế đơn giản hơn.
Để đơn giản, trong thủ tục
này cố định độ rộng các chữ
số thể hiện.
Đây là đoạn chương trình hiển thị Ngày hiện thời và Tháng, Năm hiện thời trên
màn hình, phía trên lịch tháng.
Tháng luôn thể hiện bằng 2

chữ số, ví dụ tháng 1 sẽ thể
hiện là 01.
Ngày hiện thời thể hiện

bằng kích thước gấp rưỡi
bình thường.
h) Lập trình hiện đồng hồ điện tử

Đồng hồ điện tử sẽ được thiết lập để chạy online trên màn hình. Các thông số như
giờ, phút, giây được cập nhật liên tục.
Đoạn chương trình sau sẽ thể hiện đồng hồ điện tử chạy online trên màn hình.
Thể hiện thông số giờ (hour)

bằng 2 chữ số.
Thể hiện thông số phút

(minute) bằng 2 chữ số.
Thể hiện thông số giây

(second) bằng 2 chữ số.
2. Các bánh xe quay

Trong phần tiếp theo chúng ta sẽ mô phỏng các bánh xe quay. Nhân vật của chúng
ta là hình có dạng tròn hoàn chỉnh, có tâm trùng với tâm hình tròn. Các đồ vật
thực tế có rất nhiều ví dụ bánh xe đạp, xe máy, ô tô, các bánh xe răng cưa trong
đồng hồ hoặc trong các máy móc cơ khí.
Ở mức đơn giản, việc mô tả các bánh xe này quay chỉ là 1 lệnh quay trái (hoặc
phải) 1 góc nào đó, và lệnh này được lặp nhiều lần.
Tuy nhiên muốn mô phỏng các bánh xe này quay đúng như trên thực tế thì bài
toán trở nên khó hơn nhiều, yêu cầu các tính toán chính xác, khoa học.
Chúng ta cùng tìm hiểu các bài toán bánh xe quay trong phần này.
Giả sử vòng tròn có bán kính R và được quay 1 góc bằng α, khi đó cung tròn
tương ứng sẽ có độ dài như công thức sau đây.
Công thức tính độ

Độ dài cung tròn này được tính theo
dài cung tròn. công thức sau:
𝝅
𝒅 = 𝑹. 𝜶.
𝟏𝟖𝟎
Nếu 2 vòng tròn có bán kính R1, R2 tiếp xúc với nhau như hình sau. Nếu vòng tròn
thứ nhất quay 1 góc α thì vòng tròn thứ 2 sẽ quay theo chiều ngược lại 1 góc β
thỏa mãn đẳng thức: R1.α = R2.β. Điều này suy từ công thức tính độ dài cung
tròn trong hình trên.
R1.α = R2.β Khi 2 vòng tròn quay

và trượt lên nhau, các
điều kiện sau cần tuân
thủ:
Quan hệ giữa bán - Vòng quay ngược

kính và góc quay nhau.
của các bánh xe - Tốc độ quay vòng
trượt. phải thỏa mãn công
thức:
R1.α = R2.β
Bây giờ chúng ta thiết kế 1 chương trình đơn giản, mô phỏng 2 bánh xe quay
ngược chiều và tiếp xúc với nhau. Yêu cầu là phải mô phỏng chính xác, khoa học.
Banh xe 2.sb2
Trong chương trình này, 2 nhân vật bánh xe sẽ được đặt tên là R1, R2 với 2 bán
kính gốc = R1, R2. Hai vòng tròn sẽ quay ngược chiều nhau với các giá trị góc
tương ứng là alpha và beta.
Cần thiết lập quan hệ giữa alpha và beta. Giá trị alpha sẽ được thiết lập ngẫu
nhiên, beta sẽ được tính phụ thuộc vào alpha.
Đoạn chương trình sau mô tả việc tính toán ban đầu. Chú ý rằng R1, R2 là độ dài
gốc bán kính của 2 nhân vật vòng tròn. Trên màn hình 2 vòng tròn này được thể
hiện có thể đã có thay đổi kích thước, do vậy cần đưa thêm vào 2 biến nhớ Size1
và Size2 để tính toán kích thước chính xác của 2 bánh xe này.
Công thức tính

beta như sau:
beta =
R1.Size1.alpha/
(R2.Size2).
Chú ý: trong mô hình trên, bán kính thực sự của vòng tròn trên màn hình được
tính bằng công thức sau:
𝑆𝑖𝑧𝑒
𝐵𝑅 = 𝑅.
100
Ở đây:
R = bán kính vòng tròn của hình ảnh gốc nhân vật.
Size = tỉ lệ kích thước của nhân vật so với gốc (tính theo %).
BR = bán kính thực tế của vòng tròn trên màn hình.
3. Bánh xe lăn trên đường thẳng
Trong phần này chúng ta sẽ tiếp tục mô tả chuyển động của các bánh xe tròn,
nhưng không phải quay tròn tại 1 vị trí, mà quay (lăn) chuyển động trên một
đường thẳng. Có rất nhiều mô phỏng thực tế của mô hình này, ví dụ chuyển động
của các phương tiện giao thông trên đường phố.
Nguyên tắc bánh

xe quay trên Khi vòng tròn quay xuôi kim đồng
đường thẳng. hồ một góc α thì vòng tròn sẽ
chuyển động sang phải một khoảng
cách bằng:
𝜋
𝑑 = 𝑅. 𝛼.
180
Bài toán được đặt ra trong hình sau:
Mô tả 3 cái bánh xe lăn với vận tốc quay ban đầu khác nhau (sinh ngẫu nhiên) trên
một đường thẳng từ trái sang phải.
Nháy nút Start để điều khiển

3 banh xe duong các bánh xe chay. Nút Stop
thang.sb2 để tạm dừng lại.
Chương trình có 3 nhân vật

chính là Bánh xe 1, 2, 3 đều
có dạng hình tròn.
Thông tin của 3 bánh xe này được ghi trong các biến nhớ sau:
R1, R2, R3 Bán kính gốc các bánh xe (kích thước gốc ban đầu)
Size1, Size2, Size3 Kích thước hiện thời của các nhân vật bánh xe.
BR1, BR2, BR3 Bán kính hiện thời của các bánh xe trên màn hình.
alpha, beta, gamma Các góc quay của bánh xe tương ứng.
Các thông số trên được tính toán trong chương trình như sau:
Bán kính gốc của các bánh xe (lấy

từ thông tin kích thước nhân vật.
Thông tin kích thước hiện thời của

3 nhân vật bánh xe.
Bán kính hiện thời trên màn hình

của các bánh xe.
Góc quay của 3 bánh xe được thiết

lập ngẫu nhiên.
Các chương trình điều khiển, ví dụ, bánh xe 1 sẽ như sau:
- Thiết lập vị trí ban đầu.
- Thiết lập vòng quay ngẫu nhiên. Khi bấm vào nút Start mới bắt đầu cho bánh xe
quay và chạy.
- Chuyển động theo chiều ngang từ trái sang phải.
Đây chính là công thức:

𝜋
𝑑 = 𝑅. 𝛼.
180
đã trình bày ở trên.
Hoàn toàn tương tự với 2 bánh xe còn lại.

4. Bánh xe quay trong vòng tròn
Chúng ta sẽ mô phỏng một bánh xe tròn lăn, trượt bên trong một vòng tròn lớn
khác. Bài toán được mô tả trong hình sau.
Hai đoạn dây cung này phải bằng

nhau và bằng:
𝜋
Mô phỏng 1 vòng
𝑑 = 𝑅. 𝛽.
180
tròn nhỏ quay và 𝜋
trượt bên trong 𝑑 = 𝑅1 . 𝛼.
một vòng tròn 180
lớn hơn. Từ 2 công thức trên suy ra:
𝑅1 . 𝛼
𝛽=
𝑅
Như vậy lời giải của bài toán trên như sau:
- Trong khi cho vòng tròn với bán kính R1 quay xung quanh mình 1 góc α (ngược
kim đồng hồ).
- Đồng thời bản thân nhân vật vòng tròn này sẽ quay xung quanh điểm O, theo quĩ
đạo tròn bán kính R - R1, với vận tốc quay tương ứng là β.
Chương trình cần thiết lập sẽ mô phỏng 3 bánh xe chuyển động và trượt bên trong
1 hình tròn lớn bán kính R. Các nhân vật bánh xe này có tốc độ quay ban đầu sinh
ngẫu nhiên.
3 banh xe đi
tron.sb2
Các biến nhớ và thông số chính của chương trình.

R Bán kính vòng tròn đỏ ngoài cùng.
Các bán kính này được tính theo công thức:
BR1 = R1.Size1 / 100.
alpha-1, beta-1, Tốc độ quay tương ứng của các nhân vật bánh xe
gamma-1 xung quang tâm O. Các góc này được tính theo
công thức:
𝑩𝑹𝟏 . 𝒂𝒍𝒑𝒉𝒂
𝒂𝒍𝒑𝒉𝒂_𝟏 =
𝑹
TR1, TR2, TR3 Bán kính các vòng tròn mà các bánh xe phải quay
xung quanh tâm O.
TR1 = R - BR1; TR2 = R - BR2; TR3 = R - BR3.
Đoạn chương trình thiết lập và tính toán các thông số hệ thống như sau:
Bán kính các vòng tròn gốc.
Kích thước thực tế trên màn

hình của các bánh xe.
Bán kính thực tế của các bánh

xe.
Khoảng cách từ tâm các bánh

xe đến tâm O của vòng tròn
lớn.
Góc quay ngẫu nhiên của các

bánh xe bên trong vòng tròn
lớn.
Vận tốc quay của các bánh xe

xung quanh tâm O.
Điều khiển các bánh xe này gần tương tự nhau. Sau đây là các chương trình điều
khiển Bánh xe 1.
Bánh xe sẽ tự quay tròn

với vận tốc quay =
alpha
Thiết lập vị trí ban đầu cho

bánh xe.
Bánh xe sẽ quay xung

quanh tâm O, bán kính
TR1 với góc quay
alpha-1
Còn đây là đoạn chương trình dùng để vẽ vòng tròn lớn bán kính R. Vòng tròn
này cần được vẽ trước khi thực hiện các công việc khác.
5. Bánh xe lăn trên đường cong bất kỳ

Bây giờ chúng ta sẽ cùng mô phỏng bài toán khó nhất: cho các bánh xe chuyển
động dọc theo các đường cong bất kỳ.
3 banh xe đi
cong.sb2
Hàm số y = f(x)
Bài toán cần mô phỏng như sau:

Cho đồ thị hàm số y = f(x), x chạy trên 1 đoạn thẳng [a, b] cố định. Ở đây đoạn
thẳng [a, b] chính là chiều ngang của màn hình sân khấu Scratch, tức là [-240,
240].
Chương trình sẽ mô tả 3 bánh xe quay tròn và lăn trên đồ thị y = f(x). Cần mô tả
chính xác sự chuyển động này.
Chúng ta cùng quan sát hình sau để phân tích các thực hiện bài toán này.
Mô phỏng bài
toán bánh xe
chuyển động trên
1 đường cong bất
kỳ.
Giả sử tại thời điểm hiện thời, vị trí bánh xe tại điểm A (tâm tại O).
A = (X0, Y0), Y0 = f(X0).
Ở thời điểm tiếp theo, khi bánh xe quay 1 góc α, bánh xe đi đến điểm B (tâm đến
O1).
B = (X1, Y1), Y1 = f(X1).
Cần tính toán chính xác tọa độ điểm B và tâm O1 .
Khi góc quay α khá nhỏ, có thể coi đoạn AB chính là cung AB, do đó AB được
tính theo công thức mà chúng ta đã biết:
𝜋
𝑑 = 𝑅. 𝛼.
180
Đặt AC = dx, BC = dy.
Với α khá bé thì có thể tính xấp xỉ: dy = dx. f'(X0).
Do đó ta có đẳng thức:
𝑑 = √𝑑𝑥 2 + 𝑑𝑦 2 = 𝑑𝑥√1 + 𝑓′(𝑋0 )2

Từ đó suy ra:
𝑑
𝑑𝑥 =
√1 + 𝑓′(𝑋0 )2
hay:
𝜋 1
Công thức tính 𝑑𝑥 = 𝑅. 𝛼. .
gia số dx 180 √1+ 𝑓′(𝑋0 )2
Vậy ta có:
𝜋 1
Công thức tính X1 = X0 + 𝑅. 𝛼. .
180 √1+ 𝑓′(𝑋0 )2
X1, Y1.
Y1 = f(X1)
Bây giờ chúng ta sẽ tính tọa độ điểm O1 .
Vector tiếp tuyến với đồ thị hàm số y = f(x) tại điểm B có hướng là:
υ = (1, f'(X1))
do đó vector vuông góc với υ và hướng vào tâm sẽ có hướng:
η = (-f'(X1), 1)
Do đó vector BO1 sẽ được tính theo công thức:
1
(−𝑅. 𝑓 ′ (𝑋1 ), 𝑅)
√1 + 𝑓′(𝑋1 )2
Tọa độ của tâm O1 sẽ được tính như sau:
𝑅.𝑓′(𝑋1)
Xt = X1 -
Công thức tính √1+ 𝑓′(𝑋1 )2
tọa độ tâm O1. 𝑅
Yt = Y1 +
√1+ 𝑓′(𝑋1 )2
Thuật toán kết nối từ (X0, Y 0) đến (X1, Y 1) như sau:
Thuật toán di Lặp lại liên tục các bước sau:

chuyển bánh xe
trên đồ thị hàm X0, Y0 = f(X0)
số tổng quát. 𝜋 1
𝑑𝑥 = 𝑅. 𝛼. .
180 √1+ 𝑓′(𝑋0 )2
X1 = X0 + dx
Y1 = f(X1)
𝑅.𝑓′(𝑋1)
Xt = X1 -
√1+ 𝑓′(𝑋1)2
𝑅
Yt = Y1 +
√1+ 𝑓′(𝑋1 )2
Goto (Xt, Yt)
Bây giờ chúng ta sẽ thiết kế chương trình cụ thể với 3 bánh xe chạy trên đồ thị
hàm số dạng ax2 + b.
Trong ví dụ cụ thể sau, a = 0.003, b = -150.
Thiết lập các biến nhớ hệ thống của chương trình.
a hằng số tham gia vào định nghĩa của hàm f(x)
Các bán kính này được tính theo công thức:
BR1 = R1.Size1 / 100.
X1, Y1, X2, Y2. X3, Y3 Tọa độ các điểm trên đồ thị là điểm tiếp xúc của
bánh xe tương ứng.
dx1, dx2, dx3 Các số gia tương ứng trên trục X của mỗi bước lặp.
n1, n2, n3 Các biến nhớ phụ lưu trữ giá trị tính toán trung
gian.
1
√1 + 𝑓′(𝑋)2
BX1, BY1, BX2, BY2, Tọa độ các tâm bánh xe tương ứng với các điểm
BX3, BY3 tiếp xúc X1, Y1, X2, Y2. X3, Y3.
Đoạn chương trình thiết lập các thông số ban đầu của chương trình.
Bán kính gốc của các bánh xe (lấy

từ thông tin kích thước nhân vật.
Thông tin kích thước hiện thời của

3 nhân vật bánh xe.
Bán kính hiện thời trên màn hình

của các bánh xe.
Góc quay của 3 bánh xe được thiết

lập ngẫu nhiên.
Sau đây là phần điều khiển bánh xe 1. Hoàn toàn tương tự cho các bánh xe còn
lại.
Thiết lập vị trí ban đầu của bánh xe. Có thể đặt ở bất kỳ vị trí nào trên đồ thị.
Vị trí gốc trên

đồ thị: x, f(x)
Tọa độ tâm
bánh xe.
Thiết lập vị trí
ban đầu.
Chương trình điều khiển bánh xe luôn quay với vận tốc quay alpha.
Đây là đoạn chương trình chính điều khiển bánh xe chuyển động trên đồ thị hàm
số y = f(x), từ trái sang phải, gặp cạnh phải sẽ xuất hiện lại bên cạnh trái.
Cài đặt thuật

toán di chuyển
bánh xe trên đồ Thuật toán
thị hàm số tổng chính tính
quát. điểm cần
chuyển tới tiếp
theo.
Khi gặp cạnh

phải, bánh xe
sẽ xuất hiện lại
ở cạnh trái.
Đây là đoạn chương trình vẽ đồ thị hàm số y = f(x) trên mặt phẳng sân khấu.
6. Mô phỏng bắn súng
Chúng ta sẽ thiết kế trò chơi mô tả bắn súng đại bác tiêu diệt mục tiêu cho trước.
Yêu cầu của chương trình là mô phỏng đường đi của viên đạn chính xác gần như
thực tế. Giao diện của trò chơi sẽ như hình sau.
2 thông số quan trọng: góc quay

Phao binh.sb2 (Angle) của súng và vận tốc đạn
(Speed) có thể điều chỉnh trực tiếp.
Mục tiêu cần bắn trúng.
Vị trí của súng và đạn.
Danh sách nhân vật của trò chơi.
Mô tả chi tiết nhân vật.

Stt Biểu tượng Ý nghĩa, hoạt động của nhân vật
1 Súng đại bác. Người dùng điều khiển góc
(hướng) và vận tốc ban đầu của đạn bằng phím và
nút lệnh ngay trên màn hình. Bấm Space để ra
lệnh bắn (Fire).
2 Đạn. Đạn được điều khiển theo 1 chương trình đặc
biệt để mô phỏng chính xác quĩ đạo bay của viên
đạn. Nếu đạn rơi trúng mục tiêu thì chiến thẳng,
được tăng 50 điểm, nếu trượt thì bị trừ 7 điểm.
3 Mục tiêu tác chiến. Nhân vật này có nhiều trang
phục. Nếu đạn bay gặp mục tiêu thì phát ra tiếng
nổ, đạn biến thành gọn lửa.
4 Bánh xe. Bánh xe chỉ có ý nghĩa trang trí. Chú ý
tâm của bánh xe chính là tâm quay của súng và là
vị trí xuất phát của viên đạn.
5 Nút nhập trực tiếp vận tốc.
6 Nút nhập trực tiếp góc.
Mô tả hoạt động của chương trình.
- Chương trình sẽ tự động thiết lập màn hình nền và vị trí của mục tiêu trên màn
hình.
- Người dùng được điều chỉnh vận tốc đạn và góc quay của súng, có thể điều
chỉnh trực tiếp trên thanh trượt của biến nhớ hoặc nháy nút để nhập chính xác 1
số.
- Bấm phím Space để thực hiện lệnh bắn (Fire).
- Viên đạn sẽ bắn ra khỏi nòng súng và bay trên 1 quĩ đạo chính xác trên màn
hình.
- Nếu trúng mục tiêu sẽ nghe tiếng nổ và viên đạn bốc lửa như hình sau.
- Nếu bắn trượt bị trừ 7 điểm, nếu bắn trúng được thưởng 50 điểm.
Như vậy thuật toán quan trọng nhất của trò chơi này là thiết lập quĩ đạo chính xác
của viên đạn khi ra khỏi nòng súng.
Quĩ đạo viên đạn
Mô tả quĩ đạo chuyển động của viên đạn là phần khó nhất của chương trình này.
2 tham số quan trọng của chương trình: Góc hướng súng, Angle = α và Vận tốc
viên đạn, Speed = υ (m/s).
Đường đi - quĩ đạo

υ của viên đạn khi ra
υy khỏi nòng súng.
α
υx
Vận tốc ban đầu được phân bổ thành 2 thành phần υx và υy .
υx = υ.cos(α); υy = υ.sin(α)
quĩ đạo chuyển động của viên đạn tính theo thời gian t như sau:
𝒈.𝒕𝟐
x(t) = υx.t; y(t) = υy.t -
𝟐
Ở đây t tính bằng giây (s), g = 9.8 m/s2 ; vận tốc tính bằng m/s.
Từ các công thức trên chúng ta sẽ tính được tọa độ và vẽ được đường đi của viên
đạn với vận tốc ban đầu = Speed (υ) và góc ban đầu = Angle (α).
Mô tả viên đạn bắn ra khỏi nòng sẽ dùng công nghệ lập trình Clone của Scratch.
Thiết kế biến nhớ hệ thống.
Biến nhớ chung, hệ thống.
Score Biến nhớ ghi điểm số của người chơi.
Speed Vận tốc bắn ra của súng (ký hiệu V).
Angle Góc của súng pháo binh (ký hiệu α).
Length Độ dài nòng súng đại bác.
Biến nhớ riêng cho nhân vật viên đạn. Viên đạn sẽ được sinh bởi công cụ
Clone, do vậy mỗi phân thân sẽ có 1 bộ thông số riêng như sau:
ID ID để phân biệt nhân vật gốc và clone. Viên đạn clone sẽ có ID
= 1, viên đạn gốc sẽ có ID = 0.
Vx, Vy Các thành phần vector vận tốc của viên đạn hiện thời.
dx, dy, xPos, Các biến nhớ riêng dùng để mô tả quĩ đạo chuyển động của
yPos, t viên đạn.
Sơ đồ hoạt động của chương trình
Thiết lập Score

Mô phỏng đường đi viên
= 0, lựa chọn Người dùng điều khiển đạn bắn ra.
ngẫu nhiên nền góc và vận tốc của đạn.
sân khấu. Bấm Space thì gửi thông Nếu gặp cạnh màn hình,
điệp Fire. trừ 7 điểm.
Reset Nếu gặp mục tiêu, tăng 50
Fire điểm, đổi trang phục
Cho phép người
thành ngọn lửa và gửi
dùng nhập trực thông điệp Reset.
tiếp Góc và Vận
tốc. Reset
Tự thiết lập ngẫu nhiên vị

trí và trang phục trên màn
hình.
Get Angle Nếu nháy lên gửi thông

điệp Get Angle hoặc Get
Get Speed Speed.
Một số chú ý khi viết chương trình chi tiết.
(a) Chú ý giá trị góc Angle.
Trong Scratch qui định hướng thẳng đứng lên trên là góc 0 độ, nhưng góc Angle
của bài toán mô phỏng là góc so với trục ngang X, do vậy khi thực hiện các thao
tác với số đo góc này cần thực hiện như hình sau.
Các chương trình của

nhân vận Súng Canon.
Góc của lệnh Point in Phím trái sẽ tăng Angle lên 1 độ,
direction phải là phím phải sẽ giảm Angle xuống 1
90-Angle. độ.
(b) Vị trí xuất phát của viên đạn.

Trước tiên cấn xác định vị trí xuất phát của viên đạn.
Thiết lập vị trí súng, bánh xe và tâm của súng như hình sau, chú ý tâm của súng
chính là vị trí xuất phát của viên đạn.
Đây là tâm của nhân vật súng

đại bác và chính là vị trí xuất
phát của viên đạn.
Theo phân tích trên thì vị trí viên đạn sẽ xuất phát từ điểm (-220, -156) tức là từ
gốc của nòng súng (tâm bánh xe). Chúng ta có thể mô phỏng viên đạn phóng ra từ
đầu nòng súng. Cách làm như sau:
Gọi độ dài nòng súng là Length, khi đó tọa độ điểm đầu của nòng súng sẽ được
mô tả như trong hình sau.
Vị trí này có tọa độ là:

X = -220 + Length.cos(α)
Y = - 156 + Length.sin(α)
Khi đó các đoạn chương trình mô phỏng vị trí xuất phát của viên đạn sẽ được sửa
lại như sau:
(c) Điều khiển quĩ đạo viên đạn
Viên đạn sẽ được lập trình chuyển động khi người dùng bấm phím Space, thông
điệp Fire được gửi từ nhân vật Canon.
Đoạn chương trình thiết lập các tham số ban đầu của viên đạn bao gồm các vận
tốc thành phần (υx, υy) và thời gian t = 0.
Thiết lập vị trí ban đầu của

viên đạn ở đầu nòng súng.
Thiết lập các vector thành phần

của vận tốc υx, υy.
Âm thanh tiếng nổ ở đầu nòng súng.
Quĩ đạo của viên đạn sẽ được mô tả theo thuật toán sau:
Thiết lập vị trí ban đầu.

Thuật toán mô
tả quĩ đạo của Lặp lại liên tục.
viên đạn. dx = υx.t
𝒈.𝒕𝟐
dy = υx.t - υy.t -
𝟐
xPos = -220 + Length.cos(α) + dx
yPos = -156 + Length.sin(α) + dy
thể hiện viên đạn tại vị trí (xPos, yPos)
t = t + dt
Kết thúc lặp
Đoạn chương trình chính điều khiển viên đạn bắn ra khỏi nòng súng trên Scratch
như sau, chú ý các hệ số (480/100) và (360/100) là hệ số đơn vị chiều dàii trên sân
khấu Scratch.
(a) Điều khiển súng đại bác
Toàn bộ các chương trình điều khiển súng như sau:
(b) Điều khiển các biến nhớ Angle và Speed.

Biến nhớ Angle Speed
Lệnh trên
các nút
Sân khấu
thực hiện
(c) Sân khấu sẽ thiết lập trạng thái ban đầu và gửi thông điệp Reset để bắt đầu
cuộc chơi.
Nhận được Reset, sân khấu sẽ thay đổi nền và mục tiêu tác chiến sẽ hiển thị ngẫu
nhiên trên màn hình.
Mục tiêu tác chiến: Sân khấu:
(d) Điều khiển đạn.
Đây là phần khó nhất của chương trình.
Viên đạn sẽ có 2 trạng thái thể hiện là (1) hình viên đạn, sẽ được thể hiện với 8%
kích thước gốc và (2) hình ngọn lửa khi rơi trúng đích sẽ được thể hiện với 33%
kích thước gốc. Cần tìm hoặc thu âm 2 âm thanh: Fire khi bắt đầu bắn đạn ra khỏi
nòng và BigFire khi bắn trúng đích.
Trang phục
Âm thanh cần có. Fire BigFire

Kích thước cần thể hiện. 8% 33%
Khi bắt đầu chương trình, thiết lập ID = 0 cho nhân vật gốc và ẩn không hiện trên
màn hình.
Khi nhận thông điệp Fire, sẽ tiến hành phân thân, tạo ra 1 viên đạn Clone tại đầu
nòng súng. Chương trình như sau:
Kiểm tra chỉ thực

hiện đối với nhân vật
gốc.
Thiết lập ID = 1 để
gán cho các clone giá
trị này.
Thiết lập vị trí ban

đầu của viên đạn.
Tạo 1 clone.
Trả lại ID = 0 cho

nhân vật gốc.
Chương trình điều khiển quĩ đạo viên đạn như sau:
Vòng lặp chính

mô phỏng quĩ đạo
viên đạn tính từ
đầu nòng súng.
Khi gặp cạnh thì

giảm 7 điểm, và tự
xóa clone.
Nếu gặp mục tiêu:

- Phát âm thanh nổ lớn.
- Tăng 50 điểm.
- Chuyển trang phục thành ngọn lửa to.
- Chờ 3 giây.
- Gửi thông điệp Reset và tự xóa clone.
7. Mô phỏng Bi-a
Chúng ta đều biết qui luật đánh bóng của trò chơi Bi-a. Trong Scratch cũng có 1
lệnh mô tả 1 nhân vật khi va chạm vào cạnh sân khấu thì sẽ bị bật lại như thế nào,
đó là lệnh . Lệnh này mô tả chính xác chuyển động của quả

bóng trong trò chơi Bi-a.
Bây giờ chúng ta sẽ thiết kế chương trình Scratch mô tả chính xác đánh bóng kiểu
trò chơi Bi-a.
Màn hình ban đầu của chương trình như hình bên dưới. Nhân vật chính của
chương trình là quả bóng. Trên màn hình thể hiện 1 hình chữ nhật màu đỏ.
Bi-a.sb2
Khi nháy chuột quả bóng bắt đầu chuyển động với vận tốc trung bình và hướng
đến vị trí đã nháy chuột. Khi gặp cạnh hình chữ nhật bóng sẽ bật lại theo đúng
nguyên tắc của trò chơi bi-a.
Bóng chạm cạnh và bật

trở lại với góc đối xứng.
Bất cứ lúc nào em nháy chuột sẽ làm đổi hướng bóng: bóng sẽ chuyển động về
hướng con trỏ chuột. Khi gặp cạnh sẽ có 1 tiếng kêu nhỏ phát ra.
Chú ý: Khung hình chữ nhật đỏ có thể là hình ảnh nền sân khấu, có thể là 1 nhân
vật Scratch, có thể là hình vẽ do chính quả bóng vẽ ra khi chạy chương trình.
Giả sử khung đỏ chữ nhật có tọa độ các đỉnh trái dưới là (X1, Y1), đỉnh đối diện
phải trên là (X2, Y2), tọa độ tâm là (X0, Y0).
Khi đó cần lập trình nhận biết và xử lý 8 trường hợp bóng va vào cạnh khung chữ
nhật như hình dưới đây.
2
6 5
Tọa độ (X2, Y2)
3 Tọa độ (X0, Y0)

1
8
7
4
Tọa độ (X1, Y1)
Trong đó:
- Các trường hợp 1, 2, 3, 4 là va vào các cạnh phải, trên, trái, dưới của khung.
- Các trường hợp 5, 6, 7, 8 là đi vào chính giữa các góc của chữ nhật.
Sử dụng cảm biến màu sắc để xử lý từng trường hợp trên.
Bảng sau mô tả chi tiết các trường hợp cần xử lý.
Vị trí Hình ảnh mô tả Điều kiện và lệnh thực hiện
1 Va chạm cạnh phải của khung.
Điều kiện:
X > X0 và | X-X2| < |Y-Y1| và |
X-X2| < |Y-Y2|
Xử lý:
Quay trái 2α.
Gọi α là góc của hướng bóng khi va đập

vào cạnh.
2 Va chạm cạnh trên của khung.
Điều kiện:
Y > Y0 và | Y-Y2| < |X-X1| và |
Y-Y2| < |X-X2|
Xử lý:
Gọi α là góc của hướng bóng khi va đập Nếu α > 0 thì
vào cạnh. Quay phải 180o - 2α
Nếu không thì
Quay trái 180o - |2α|
3 Va chạm cạnh trái của khung.
Điều kiện:
X < X0 và | X-X1| < |Y-Y1| và |
X-X1| < |Y-Y2|
Xử lý:
Quay phải -2α
Gọi α là góc của hướng bóng khi va đập

vào cạnh.
4 Va chạm cạnh dưới của khung.
Điều kiện:
Y < Y0 và | Y-Y1| < |X-X1| và |
Y-Y1| < |X-X2|
Xử lý:
Gọi α là góc của hướng bóng và khi đập Nếu α > 0 thì
vào cạnh.
Quay trái 2α - 180o
Nếu không thì:
Vị trí Hình ảnh mô tả Điều kiện và lệnh thực hiện
Quay phải |2α| - 180o
5 Hướng thẳng giữa vào góc phải
trên.
Điều kiện: |X-X2| = |Y-Y2|
Trường hợp này α = 45o
Xử lý: quay trái 180 độ.
6 Hướng thẳng giữa vào góc trái
trên.
Trường hợp này α = - 45o Điều kiện: |X-X1| = |Y-Y2|

7 Hướng thẳng giữa vào góc trái
dưới.
Trường hợp này α = - 135o
8 Hướng thẳng giữa vào góc phải
dưới.
Trường hợp này α = 135o
Chúng ta sẽ phân tích từng trường hợp trên.

Gọi alpha = α = góc hướng của quả bóng. Trong Scratch, góc này được cho bởi
hàm . Theo định nghĩa, góc này được thiết lập như sau:
Nếu hướng góc về phía Nếu hướng góc về phía

trái tại 1 nửa vòng tròn phải tại 1 nửa vòng tròn
này, góc α sẽ có giá trị: này, góc α sẽ có giá trị:
-180o <= α <= 0o 0o <= α <= 180o
Giả sử bóng xuất phát từ điểm A, va vào cạnh tại điểm B và bật lại tại điểm A'.
Gọi A'' là điểm đối xứng của A' qua cạnh.
1. Bóng gặp cạnh phải
Khi bóng va đập vào cạnh phải của hình chữ nhật đỏ, có 2 khả năng xảy ra:
- Bóng di chuyển hướng lên trên. Khi đó ta có 0 <= α <= 90o.
- Bóng di chuyển hướng xuống dưới, khi đó: Trường hợp 90o <= α <= 180o.
Chúng ta cùng quan sát và phân tích 2 trường hợp này.
Trường hợp 0 <= α <= 90o Trường hợp 90o <= α <= 180o
B' B'
B'' B''
Hướng bóng (AA") sẽ quay trái 2 lần Hướng bóng AA'' sẽ quay phải 2 lần
góc A''BB' chính bằng α. Do vậy góc A''BB'' = 180 - α. Do đó kết quả là
trường hợp này kết quả là: quay phải 1 góc = 2(180 - α) = 360 -
Quay trái 1 góc 2α. 2α. Đây chính là quay trái 1 góc 2α.
Kết quả là:
Quay trái 1 góc 2α.
2. Bóng gặp cạnh trên

Phân biệt 2 trường hợp, bóng hướng lên trên bên phải hay hướng lên trên bên trái.
Chú ý khi hướng của bóng lên trên bên trái thì giá trị góc α sẽ < 0.
Trường hợp 0 <= α <= 90o Trường hợp -90o <= α <= 0o
B' B'' B' B''
Hướng bóng AA'' sẽ quay phải 2 lần (chú ý: số đo góc α < 0). Hướng bóng
góc A''BB"" = 90 - α. Do đó kết quả AA'' sẽ quay trái 1 góc bằng 2 lần góc
là: A''BB' = 90 - |α|. Do đó kết quả là:
Quay phải 1 góc 180 - 2α. Quay trái 1 góc 180 - |2α|
3. Bóng gặp cạnh trái

Phân biệt 2 trường hợp khi bóng va cạnh trái từ dưới lên hay từ trên xuống. Chú ý
trường hợp này góc α < 0 trong cả 2 trường hợp.
Trường hợp -90o <= α <= 0o Trường hợp -180o <= α <= -90o
B' B'
B'' B''
(chú ý: số đo góc α < 0). Hướng bóng (chú ý: số đo góc α < 0). Hướng AA''
AA'' sẽ quay phải 1 góc bằng 2 lần góc sẽ quay trái 1 góc bằng 2 lần góc
A''BB' = |α|. Vậy kết quả là: A''BB'' = 180 - |α|. Kết quả là quay trái
1 góc = 360 - |2α| hay chính là quay
Quay phải 1 góc |2α|. phải 1 góc |2α|.
Quay phải 1 góc |2α|.
4. Bóng gặp cạnh dưới

Phân biệt 2 trường hợp bóng va chạm cạnh dưới theo hướng phải - dưới hay
hướng trái - dưới.
Trường hợp 90o <= α <= 180o Trường hợp -180o <= α <= -90o
B' B'' B' B''
Hướng bóng AA'' sẽ quay trái 1 góc bằng

2 lần góc A''BB'' = 90 - (180 - α) = α - 90. Chú ý: góc α < 0. Hướng bóng AA'' sẽ quay
Do đó kết quả là quay trái 1 góc = 2α - phải 1 góc bằng 2 lần góc A''BB' = 90 - (180 -
180. |α| = |α| - 90. Do đó kết quả là quay phải 1 góc
= |2α| - 180.
Quay trái 1 góc 2α - 180.
Quay phải 1 góc = |2α| - 180.
5. Các trường hợp còn lại: 5, 6, 7, 8.

Tất cả các trường hợp này đều có cùng 1 kết quả xử lý là quay trái (hoặc phải 180
độ).
a) Thiết lập trạng thái ban đầu của chương trình, vẽ khung chữ nhật đỏ, xác định
các đỉnh bằng cách gán giá trị cho các biến nhớ X1, Y1, X2, Y2.
b) Thiết lập chế độ điều khiển quả bóng.

Mỗi khi nháy chuột, quả bóng sẽ hướng về vị trí con trỏ chuột.
Lần đầu tiên nháy chuột sẽ làm cho quả bóng chuyển động và chuyển động mãi
mãi.
Lệnh này có tác dụng làm chậm 1

nhịp cho quả bóng. Khi chạy
chương trình bằng cách nháy lên
lá cờ thì quả bóng không chuyển
động ngay mà chờ lần nháy chuột
tiếp theo.
c) Điều khiển quả bóng bật lại khi gặp cạnh hình chữ nhật.
Dùng cảm biến màu sắc để điều khiển quá trình này của quả bóng.
Mỗi khi gặp cạnh hình chữ nhật đỏ, đoạn chương trình sau sẽ được chạy để thiết
lập chế độ chuẩn bị "bật lại".
Nếu gặp cạnh đỏ thì ….
Thiết lập ngay các thông số

tọa độ X, Y và góc alpha.
Các chương trình kiểm tra
sẽ sau lệnh này.
Đây là nhóm các lệnh kiểm tra điều kiện quả bóng gặp cạnh, các trường hợp 1, 2,
3, 4 đã nêu trong các phần trên.
gặp cạnh phải.
gặp cạnh trái.
gặp cạnh trên.
gặp cạnh dưới.
Đoạn chương trình xử lý các trường hợp 5, 6, 7, 8, đi thẳng vào các góc hình chữ
nhật. Tất cả đều được xử lý bằng 1 lệnh là quay trái 180 độ.
1. Mở rộng chương trình xem đồng hồ và lịch như sau:
Bổ sung 2 nút Next, Previous có tính năng sau: nháy lên các nút này sẽ chuyển
lịch sang tháng sau (nút Next) và tháng trước đó (nút Previous).
2. Trong chương trình lịch và đồng hồ, thay đồng hồ số bằng đồng hồ chạy kim.
3. Trong chương trình 3, nếu chúng ta thay, ví dụ với bánh xe 1, đoạn chương
trình sau:
bằng đoạn chương trình sau:
thì điều gì sẽ xảy ra?

4. Viết chương trình mô tả chuyển động chính xác của 3 ô tô như hình sau, các ô
tô này đều chuyển động từ trái qua phải màn hình, gặp cạnh thì xuất hiện lại tại
bên trái.
5. Mô tả 1 bánh xe chuyển động trong 1 hình chữ nhật như hình sau.
PHỤ LỤC: CÁC TẬP LỆNH SCRATCH
1. Nhóm câu lệnh Move
Câu lệnh Ý nghĩa
Dịch chuyển nhân vật <10> bước theo
hướng hiện thời. Chú ý: mỗi bước = 1
pixel.
Xoay nhân vật <15> độ theo chiều kim
đồng hồ.
Xoay nhân vật <15> độ ngược chiều kim
đồng hồ.
Quay nhân vật theo hướng được xác định
(trong hình: 90 độ). Các hướng chính:
Up (trên): 0o
Right (phải): 90o
Left (trái): -90o
Down (xuống): 180o
Chú ý: lệnh này sẽ xoay nhân vật theo
tâm của mình. Mỗi nhân vật sẽ có 1 tâm
duy nhất. Có thể dùng chức năng tinh
chỉnh đồ họa đề thay đổi vị trí tâm của
nhân vật.
Xoay nhân vật theo hướng của 1 nhân vật
khác. hoặc vị trí con trỏ chuột.
Di chuyển nhân vật đến vị trí có tọa độ X,

Y tương ứng. Lệnh này tương đương với
việc thực hiện đồng thời 2 lệnh Set X to
và Set Y to.
Chú ý: lệnh này có tác dụng tức thời.

Chuyển đến vị trí của con trỏ chuột, một
nhân vật khác hoặc 1 ví trí ngẫu nhiên
trên màn hình thông qua bảng chọn.
Di chuyển đến vị trí (X, Y) trong khoảng

thời gian nhất định tính bằng giây. Thời
gian có thể nhập là số thập phân, ví dụ
1.5 là 1 giây rưỡi.
Thay đổi tọa độ X của nhân vật theo giá
trị cho trong lệnh. Giá trị có thể là số
dương hoặc số âm. Nếu giá trị > 0 thì
nhân vật chuyển động sang phải, nếu giá
trị < 0 thì nhân vật chuyển động sang trái.
Thiết lập giá trị tọa độ X của nhân vật.
Giá trị tham số của lệnh trong khoảng -
240 đến 240.
Thay đổi tọa độ Y của nhân vật theo giá
trị cho trong lệnh. Giá trị có thể là số
dương hoặc số âm. Nếu giá trị > 0 thì
nhân vật chuyển động lên trên, nếu giá trị
< 0 thì nhân vật chuyển động xuống dưới.
Thiết lập giá trị tọa độ Y của nhân vật.
Giá trị tham số của lệnh trong khoảng -
180 đến 180.
Nếu gặp cạnh màn hình, quay lại.
Đây là lệnh rất quan trọng. Lệnh sẽ điều
khiển nhân vật khi di chuyển gặp cạnh
của màn hình thì nhân vật sẽ "bật" trở lại
theo nguyên tắc đối xứng gương.
Thiết lập kiểu quay của nhân vật (ví dụ
khi gặp cạnh màn hình). Có 3 kiểu quay:
trái - phải (right-left), không quay (do not
rotate), quay tròn (all around).
(hàm) trả lại giá trị tọa độ X của nhân vật.
(hàm) trả lại giá trị tọa độ Y của nhân vật.
(hàm) trả lại giá trị của hướng nhân vật

tính bằng số đo góc.
2. Nhóm câu lệnh Look

Thể hiện dòng chữ "Hello" trong 1
khoảng thời gian <2> giây. Trong
thời gian đó chương trình sẽ tạm
dừng.
Thể hiện dòng chữ "Hello" trong khi
chương trình vẫn chạy bình thường.
Thể hiện dòng chữ suy nghĩ
"Hmm…" trong 1 khoảng thời gian
<2> giây. Trong thời gian đó chương
trình sẽ tạm dừng.
Thể hiện dòng chữ suy nghĩ
"Hmm…" trong khi chương trình
vẫn chạy bình thường.
Hiện nhân vật trên màn hình.
Ẩn (không hiện) nhân vật trên màn

hình.
Thay đổi kiểu trang phục của nhân

vật sang dạng <costume2> được hiện
trong danh sách bên phải.
Thay đổi kiểu trang phục của nhân
vật sang dạng tiếp theo (trong danh
sách).
Thay đổi sân khấu nền sang dạng
<backdrop1> trong danh sách chọn
bên phải.
Thay đổi hiệu ứng <màu sắc> bên
ngoài của nhân vật theo giá trị <25>
cho trước. Các hiệu ứng được chọn
trong danh sách, như color, fisheye,..
Thiết lập giá trị của hiệu ứng bên

ngoài của nhân vật theo giá trị cho
trước. Các hiệu ứng được chọn trong
danh sách, như color, fisheye,…
Hủy tất cả hiệu ứng thể hiện của

nhân vật, quay trở về trạng thái ban
đầu.
Thay đổi kích thước của nhân vật
theo giá trị <10> % cho trước so với
kích thước hiện thời. Giá trị có thể là
số dương hoặc âm.
Thiết lập kích thước của nhân vật là
<100>% so với kích thước gốc.
Chuyển nhân vật lên lớp trên cùng.
Chuyển nhân vật xuống dưới <1>

lớp.
(hàm) trả lại số thứ tự của trang phục
hiện thời của nhân vật.
(hàm) trả lại tên của nền sân khấu
hiện thời.
(hàm) trả lại kích thức hiện thời của
nhân vật.
Các lệnh riêng cho sân khấu
<backdrop1> trong danh sách chọn
bên phải.
trong danh sách chọn bên phải và
chờ thực hiện các lệnh của lệnh điều
khiển sau:
Chuyển nền sân khấu sang kiểu tiếp

theo.
Thay đổi hiệu ứng bên ngoài của sân
khấu theo giá trị <25> cho trước. Các
hiệu ứng được chọn trong danh sách,
như color, fisheye, …
Thiết lập giá trị của hiệu ứng bên
ngoài của nền sân khấu theo giá trị
cho trước. Các hiệu ứng được chọn
trong danh sách, như color, fisheye,
…
Hủy tất cả hiệu ứng thể hiện của sân
khấu, quay trở về trạng thái ban đầu.
(hàm) trả lại số thứ tự của nền sân

khấu hiện thời trong danh sách.
(hàm) trả lại tên của nền sân khấu
hiện thời.
3. Nhóm câu lệnh Sound

Bật âm thanh <meow> theo âm thanh
trong danh sách bên phải và không
dừng chạy chương trình.
Bật âm thanh <meow> theo âm thanh
trong danh sách bên phải, chương trình
sẽ dừng lại đợi kết thúc âm thanh này.
Tắt tất cả âm thanh.
Đánh trống với tốc độ <0.25> (1/4) của

nhịp trống. Lựa chọn kiểu trống trong
danh sách được đánh số.
Tạm nghỉ đánh trống trong thời gian
<0.25> (1/4) nhịp trống.
Chơi nốt nhạc <60> (nốt C) trong danh
sách trong thời gian <0.5> nhịp trống.
Chọn công cụ chơi nhạc <1> trong
danh sách.
Thay đổi độ lớn âm thanh theo tỉ lệ <-
10> phần trăm so với hiện thời. Cho
phép nhập số dương và âm.
Thiết lập độ lớn âm thanh theo mức
<100> phần trăm của loa hệ thống
(máy tính).
(hàm) trả lại độ lớn âm thanh hiện thời
của loa hệ thống.
Thay đổi nhịp trống, tăng lên (hoặc
giảm đi) <20> nhịp trống trong mỗi
phút.
Thiết lập nhịp trống theo <60> nhịp
đập của trống trong 1 phút.
(hàm) trả lại giá trị nhịp trống hiện thời
là số lượng nhịp trống trong 1 phút.
4. Nhóm câu lệnh Pen

Xóa tất cả các hình đồ họa được vẽ trước đó bới
bút (pen).
In (hiển thị) hình ảnh nhân vật trên màn hình
(chú ý: hình ảnh này không nằm trong sân
khấu).
Đặt chế độ hạ bút để bắt đầu vẽ theo vết chuyển
động của nhân vật.
Đặt chế độ nhấc bút không vẽ nữa.
Đặt màu sắc cho bút theo mẫu màu. Dùng chuột
nháy chọn vị trí để chọn màu.
Thay đổi màu của bút theo giá trị <10> được
nhập trực tiếp. Cho phép giá trị âm hoặc dương.
Giá trị màu được thiết lập theo hiệu ứng màu sắc
(color effect).
Thiết lập màu cho bút theo giá trị màu.
Màu sắc có giá trị từ 0 đến 200 phân bổ như sau:
Thay đổi độ mờ của bút theo giá trị <10>.

Độ mờ được đo bởi các giá trị từ 0 (màu chuẩn,
thẫm nhất, đến 100, mờ nhạt nhất).
Thiết lập độ mờ của bút theo giá trị <50>.

Độ mờ được đo bởi các giá trị từ 0 (màu chuẩn,
thẫm nhất, đến 100, mờ nhạt nhất).
Thay đổi kích thước của bút theo <1> pixel. Giá
trị thay đổi có thể dương hoặc âm.
Thiết lập kích thước bút theo giá trị <1> pixel.
5. Nhóm câu lệnh Variable

Tạo một biến nhớ mới.
(hàm) trả lại giá trị hiện thời của biến

nhớ.
Lựa chọn có hiển thị hay không giá
trị biến nhớ trên màn hình. Thể hiện
của biến nhớ có dạng sau:
Gán 1 giá trị cụ thể cho biến nhớ "a".

Giá trị có thể là số hoặc chữ.
Thay đổi biến nhớ "a" theo giá trị số
(1) được nhập trực tiếp tại ô phía
phải.
Chú ý: giá trị bắt buộc phải là số, có
thể dương hoặc âm.
Nếu nhập sai thì lỗi sẽ được thông
báo bởi "NaN".
Hiện giá trị biến nhớ "a" trên màn

hình.
Ẩn không hiện giá trị biến nhớ "a"

trên màn hình.
Tạo một danh sách (mảng) giá trị

mới.
(hàm) trả lại giá trị của biến nhớ "b"
là một dãy số hoặc văn bản.
Bổ sung giá trị <"thing"> vào cuối

của mảng "b". Giá trị có thể là số
hoặc chữ.
Xóa phần tử thứ <1> khỏi mảng "b".
Chèn giá trị <"thing"> vào mảng "b"

tại vị trí trước phần tử thứ <1>.
Mảng "b" sẽ tăng thêm 1 phần tử. Giá
trị có thể là số hoặc chữ.
Thay thế phần tử thứ <1> của mảng
"b" bằng giá trị mới <"thing">. Giá
trị này có thể là số hoặc chữ.
(hàm) trả lại giá trị của phần tử thứ
<1> của mảng "b".
(hàm) trả lại giá trị là số phần tử hiện
có của mảng "b".
(hàm logic) trả lại giá trị đúng nếu
mảng "b" chứa phần tử có giá trị
<"thing">.
Thể hiện mảng "b" trên màn hình.
Ẩn không hiện mảng "b" trên màn

hình.
6. Nhóm câu lệnh Event

Đây là lệnh "bắt đầu chương
trình". Chương trình (nhóm lệnh)
sẽ chạy khi nháy lên lá cờ xanh.
Lệnh điều khiển bàn phím. Nhóm
lệnh sẽ chạy khi phím tương ứng
<Space> được bấm.
Lệnh điều khiển chuột. Nhóm
lệnh sẽ chạy khi nháy chuột lên
nhân vật.
Lệnh điều khiển theo sân khấu.
Nhóm lệnh sẽ chạy khi nền sân
khấu thay đổi sang <backdrop1>.
Lệnh điều khiển phụ thuộc vào
độ âm (loudness), thời gian
(timer) và tốc độ của chuyển
động (video motion). Khi các
điều kiện trên thỏa mãn thì nhóm
lệnh sẽ chạy.
Lệnh điều khiển thông điệp.
Nhóm lệnh sẽ được thực hiện khi
nhân vật nhận được thông điệp
<message1>.
Lệnh gửi thông điệp cụ thể
<message1>. Lệnh "when I
receive the message" có tác dụng
trả lời cho thông điệp này. Các
lệnh khác vẫn chạy bình thường.
Chú ý: trong lệnh này có chức
năng tạo 1 thông điệp mới.
Lệnh gửi thông điệp cụ thể
<message1>. Khi gửi thông điệp
chương trình sẽ tạm dừng và chờ
cho đến khi tất cả các nhân vật
khác thực hiện xong các lệnh khi
nhận thông điệp này. Sau đó
chương trình sẽ quay lại thực
hiện các lệnh tiếp theo.
Chú ý: trong lệnh này cũng có
chức năng tạo 1 thông điệp mới.
Ví dụ:
Trong ví dụ trên: nếu người dùng

nháy phím Space, nhóm trên sẽ
gửi thông điệp <meow> và chờ
cho đến khi nhóm thứ 2 nhận
thông điệp và thể hiện <Meow!>
trong 2 giây. Sau đó nhóm thứ
nhất thực hiện tiếp lệnh "hide".
7. Nhóm câu lệnh Control

Chương trình sẽ tạm dừng trong <1> giây.
Nhóm lệnh trong khung sẽ được thực hiện lặp

lại <10> lần.
Nhóm lệnh trong khung sẽ được thực hiện lặp

lại vô hạn lần.
Lệnh điều khiển có điều kiện If. Nếu điều kiện

trong biểu thức lệnh là Đúng thì nhóm lệnh
trong khung sẽ được chạy.
Lệnh điều khiển rẽ nhánh If-then-else. Nếu

điều kiện trong biểu thức lệnh là Đúng thì
nhóm lệnh trong khung trên sẽ được chạy,
ngược lại nếu điều kiện trong biểu thức lệnh là
Sai thì nhóm lệnh trong khung dưới (else) sẽ
được chạy.
Lệnh "dừng cho đến khi". Chương trình sẽ
tạm dừng cho đến khi điều kiện trong biểu
thức lệnh trả lại giá trị Đúng.
Lệnh "lặp cho đến khi". Nhóm lệnh trong
khung sẽ được thực hiện lặp lại cho đến khi
điều kiện trong biểu thức lệnh trả lại giá trị
Đúng. Lệnh này kiểm tra điều kiện trước, nếu
đúng mới thực hiện nhóm lệnh. Lệnh này
tương đương lệnh While … do của các ngôn
ngữ bậc cao khác.
Lệnh "dừng chạy". Lệnh này sẽ dừng chạy
theo các khả năng lựa chọn từ ô bên phải. Có
thể chọn "all" - dừng tất cả các chương trình;
"this script" - chỉ dừng chương trình hiện tại;
"other scripts in sprite" - dừng tất cả các
chương trình tương ứng với nhân vật hiện
thời.
Lệnh "khi tôi bắt đầu là một bản sao". Các
lệnh trong khối này sẽ được thực hiện khi
nhân vật bản sao (phân thân) được tạo ra.
Lệnh thực hiện việc tạo ra 1 bản sao (phân
thân) của 1 nhân vật. Nhân vật sẽ được tạo
bản sao (phân thân) có thể chọn từ danh sách.
"itself" là tạo phân thân cho chính mình. Có
thể tạo phân thân cho nhân vật khác.
Lệnh xóa đi 1 bản sao (phân thân) hiện thời.
8. Nhóm câu lệnh Sensing

Điều kiện cảm biến va chạm. Có thể
chọn vật thể va chạm từ danh sách là
các nhân vật, con trỏ chuột hay cạnh
màn hình. Nếu có va chạm thì hàm giá
trị sẽ trả lời giá trị Đúng.
Điều kiện cảm biến va chạm màu sắc.
Màu được chọn bằng cách nháy chuột
lên vị trí có màu muốn chọn. Hàm trả
lại giá trị đúng khi nhân vật va chạm với
màu sắc đã chọn.
Điều kiện cảm biến màu sắc va chạm
màu sắc. Màu sắc có thể chọn bằng
cách nháy chuột lên vị trí màu. Hàm sẽ
trả lại giá trị Đúng khi 2 màu này va
chạm nhau.
Hàm số trả lại khoảng cách từ (tâm)
nhân vật hiện thời đến 1 nhân vật khác,
hoặc đến vị trí con trỏ chuột.
Lệnh "hỏi và chờ". Nhân vật sẽ thể hiện

câu hỏi <What's your name> và chờ
nhập dữ liệu từ bàn phím. Giá trị được
nhập từ bàn phím (số hoặc chữ) sau khi
bấm Enter sẽ được lưu trong biến nhớ
"answer".
Hình ảnh thể hiện khi thực hiện lệnh
này.
Nếu lệnh được thực hiện bởi nền sân

khấu thì giao diện nhập như sau:
Biến nhớ "Answer" dùng để lưu giá trị

nhập dữ liệu từ bàn phím của lệnh trên.
Cảm biến bàn phím. Hàm này sẽ trả lại
giá trị true (Đúng) nếu phím tương ứng
<Space> được bấm, ngược lại trả lại giá
trị false (Sai)
Cảm biến chuột. Hàm sẽ trả lại giá trị
đúng nếu chuột được nhấn (chuột trái).
(hàm) trả lại tọa độ X của vị trí chuột
hiện thời.
(hàm) trả lại tọa độ Y của vị trí chuột
hiện thời.
(hàm) trả lại giá trị hiện thời của âm
thanh vào micro của máy tính. Hàm này
dùng để đo cảm biến âm thanh, dùng
âm thanh điều khiển hành vi nhân vật.
Hàm này nhận giá trị từ 1 đến 100.
Lệnh bật / tắt camera của máy tính.
Camera sẽ dùng để điều khiển hoạt
động và nhân vật trên màn hình.
Lệnh thiết lập độ trong suốt của video
camera trên màn hình. Giá trị có thể
thiết lập từ 0% đến 100%. Vậy video có
độ trong suốt = 100% sẽ không hiện
trên màn hình.
(hàm) trả lại giá trị là các tham số cảm
biến liên quan đến video camera hiện
thời đang bật. Tham số này chỉ hoạt
động khi lệnh turn video là on.
Các tham số của lệnh:
a) Phạm vi cảm biến của video tác động
lên lệnh:
1. this sprites.
Phạm vi là phần video phía dưới vị trí
nhân vật hiện thời.
2. Stage.
Phạm vi là toàn bộ không gian của
video.
b) Dữ liệu cảm biến sẽ nhận được:
1. motion.
Số lượng chuyển động trên video tính
theo thang số từ 0 đến 100.
2. direction.
Hướng chuyển động trên video, giá trị
tính theo góc từ -180 đến 180.
(hàm) trả lại giá trị thời gian bằng giây
tính từ lúc chương trình bắt đầu chạy
hoặc từ khi thực hiện lệnh reset timer.
Lệnh có tác dụng đặt lại tham số "timer"
về 0.
(hàm) trả lại giá trị các tham số là thuộc
tính riêng của nhân vật được chọn tại ô
bên phải lệnh.
Các tham số có thể trả lại giá trị bao
gồm:
- x position: tọa độ X
- y position: tọa độ Y
- direction: hướng
- costume #: số thứ tự của trang phục
hiện thời.
- costume name: tên của trang phục hiện
thời.
- size: kích thước nhân vật hiện thời trên
màn hình.
- volume: độ lớn của âm thanh hiện thời
của nhân vật.
Chú ý: các biến nhớ riêng của nhân vật
sẽ nằm trong danh sách thuộc tính và có
trong lệnh này.
Chú ý: không có tên các biến nhớ dùng
chung trong danh sách này. Các biến
nhớ chung sẽ có trong thuộc tính của
sân khấu (xem lệnh tiếp theo).
(hàm) trả lại các giá trị tham số thuộc
tính của sân khấu và các biến nhớ
chung.
backdrop #: số thứ tự của nền sân khấu
hiện thời,
backdrop name: tên của nền sân khấu
hiện thời.
- volume: độ lớn của âm thanh nền sân
khấu hiện thời.
(hàm) trả lại giá trị thời gian hiện thời
được tính theo tham số chọn trong ô của
lệnh:
- year: năm (ví dụ: 2016)
- month: tháng (ví dụ: 3, 112)
- date: ngày của tháng (ví dụ: 20,
131)
- day of week: ngày của tuần (ví dụ: 2,
17)
- hour: giờ hiện thời (ví dụ: 14, 023)
- minute: phút hiện thời (ví dụ: 56.
059)
- second: giây hiện thời (ví dụ: 59.
059)
(hàm) trả lại số ngày của thế kỷ 21, tính
từ năm 2000.
(hàm) trả lại tên tài khoản người dùng
trên trang scratch.mit.edu.
9. Nhóm câu lệnh Operators

(hàm) phép cộng 2 số
(hàm) phép trừ 2 số
(hàm) phép nhân 2 số
(hàm) phép chia 2 số, kết quả thập phân.

Chú ý: nếu 2 số là nguyên, muốn tính phép chia
nguyên thì sử dụng biểu thức:
(hàm) trả lại số ngẫu nhiên giữa 2 giá trị số.
Biểu thức logic mô tả quan hệ giữa 2 số. Biểu

thức trả lại giá trị Đúng nến số thứ nhất < số thứ
2.
thức trả lại giá trị Đúng nến số thứ nhất > số thứ
2.
thức trả lại giá trị Đúng nến số thứ nhất = số thứ
2.
Biểu thức logic "and" (và).
Biểu thức logic "or" (hoặc)
Biểu thức logic phủ định "not".
(hàm) toán tử nối 2 xâu ký tự.
(hàm) trả lại ký tự thứ <1> của xâu ký tự

<world>
(hàm) trả lại độ dài của xâu ký tự <world>
(hàm) phép toán tính số dư của phép chia số

nguyên "mod".
(hàm) phép tính làm tròn số số nguyên gần nhất
có thể.
(hàm) trả lại giá trị là kết quả của các hàm toán
học của 1 số. Hàm toán học được chọn từ danh
sách trên dòng lệnh.
abs: trị tuyệt đối
floor: làm tròn xuống
celling: làm tròn lên
sqrt: căn bậc 2
sin: hàm lượng giác sin.
cos: hàm lượng giác cosin.
tan: hàm lượng giác tan.
asin: : hàm lượng giác arcsin.
acos: : hàm lượng giác arccos.
atan: : hàm lượng giác arctang.
ln: logarit cơ số e.
log: logarit cơ số 10.
e^: hàm mũ e.
10^: hàm mũ 10.
10. Nhóm lệnh More Blocks

Lệnh khởi tạo một thủ tục (block)
mới.
Lệnh mở thêm các nhóm lệnh mở
rộng của các thiết bị được nhúng
trong Scratch, ví dụ Lego, mạch
arduino hoặc các Robot khác.
Giao diện định nghĩa một thủ tục
mới.
- Tên thủ tục, ghi ngay trong hộp chữ
nhật đầu tiên.
- Các tham số có thể bổ sung bao
gồm:
+ number input: tham số là số.
+ string input: tham số là chữ.
+ boolean input: tham số là biểu
thúc logic.
+ label text: bổ sung chữ xen kẽ
giữa các vị trí tham số.
Tài liệu tham khảo
[1]. Computing in the national curriculum. A guide for primary teachers.
[2]. Computing in the national curriculum. A guide for secondary teachers.
[3]. Learn to Program with Scratch. Majed Marji.
[4]. Scratch 2.0 Game Development. Sergio van Pul, Jessica Chiang.
[5]. Computer Science Concepts in Scratch. Michal Armoni and Moti BenAri,
2013.
http://stwww.weizmann.ac.il/g-cs/scratch/scratch-14-textbook-1-0-one-side.pdf
[6]. Program or be Programmed: Ten Commands for a Digital Age. Rushkoff, D.

OR Books, 2009.
[7]. CS unplugged. Giảng dạy khoa học máy tính không cần máy tính.
http://www.csunplugged.org
[8]. Chương trình, chuẩn kiến thức môn Tin học. NXBGD, Hà Nội, 2000.
[9]. Chương trình giáo dục phổ thông tổng thể trong chương trình giáo dục phổ
thông mới. Tài liệu chính thức Bộ Giáo dục và Đào tạo, 2015.
[10]. Computing in the national curriculum A guide for primary teachers.

Tài liệu dành cho GV cấp Tiểu học Anh quốc dạy môn Tin học.
http://www.computingatschool.org.uk/data/uploads/CASPrimaryComputing.pdf
[11]. Shut Down or Restart.
https://royalsociety.org/topics-policy/projects/computing-in-schools/report/
https://royalsociety.org/~/media/education/computing-in-schools/2012-01-12-
computing-in-schools.pdf
[12]. Trang chính của Scratch.
https://scratch.mit.edu/
[13]. Computing at School, The Raspberry Pi Education Manual (CAS, 2012).
http://pi.cs.man.ac.uk/download/Raspberry_Pi_Education_Manual.pdf
[14]. Scratch Programming For Teens. Jerry Lee Ford, Jr.
[15]. Super Scratch Programming Adventure! The LEAD Project
[16]. Starting from Scratch.

An Introduction to Computing Science. Jeremy Scott.
[17]. Computational thinking. A guide for teachers. Andrew Csizmadia, Simon

Humphreys, National Coordinator, Computing At School.
[18]. Computer Science: A curriculum for schools.
http://www.computingatschool.org.uk/
[19]. K12-Computer Science Framework.
https://k12cs.org/wp-content/uploads/2016/09/K%E2%80%9312-Computer-
Science-Framework.pdf.
[20]. Lịch sử phát triển môn Tin học ở Việt Nam. CS4S số 3 (2017).
[21]. Đề cương khung chương trình môn Tin học của Anh quốc (bản mới). CS4S
số 1 (2017).
[22]. Hiểu và đi trong cách mạng công nghiệp lần thứ tư. Hồ Tú Bảo. 2017.
[23]. Tự học lập trình Scratch. Bùi Việt Hà.
[24]. Scratch for beginners. Bùi Việt Hà.
[25]. 20 bài tập lập trình Scratch. Bùi Việt Hà.
[26]. Introduction to Algorithms. Thomas H. Cormen, Charles E. Leiserson,
Ronald L. Rivest, and Clifford Stein.
[27].
[28].
[29].
[30].

Thiet Ke Phan Mem Giao Duc

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Thiet Ke Phan Mem Giao Duc

Uploaded by

Copyright:

Available Formats

Bùi Việt Hà

Viết kịch bản và thiết kế nhân vật

Đối tượng, mục đích

2|Thiết kế phần mềm

Khoa học máy tính

Kỹ năng số hóa phổ

4|Thiết kế phần mềm

Có thể mô tả bảng trên theo sơ đồ sau:

Kỹ năng tối thiểu xử lý số, cấu trúc dữ liệu,

Học đếm, Cơ sở toán học:

Ngữ pháp, ngôn

5|Thiết kế phần mềm

b) So sánh mục đích, đối tượng và yêu cầu năng lực CS và IT

6|Thiết kế phần mềm

8|Thiết kế phần mềm

9|Thiết kế phần mềm

Tìm hiểu con vật Math Board

sư tử Loài vật được mệnh danh là chúa rừng xanh.

cá mập Loài cá có răng sống dưới biển, chuyên ăn thịt các

Tim hieu con

Hình ảnh con vật chính của

Các phương án cần chọn.

Nút lựa chọn đáp án.

(1) Chuẩn bị công nghệ xử lý bài toán

Hệ thống sân khấu và nhân vật

Các nút lệnh, mỗi nút lệnh là 1

(3) Thiết kế biến nhớ hệ thống và các dữ liệu chung

Chọn ngẫu nhiên 4 phương án, gán

Init: xóa các bản ghi của 2

Thiết lập và điền số 1, 2,

Lần lượt lấy ra 1 phần tử

3. Lập trình cho các nút phương án A, B, C, D.

(3) Thiết kế biến nhớ hệ thống và các dữ liệu chung

= 0, làm sai. If UserNumber =

(4) Sơ đồ thiết kế hệ thống

Hiển thị đáp

Sinh ngẫu nhiên op, sinh

Kiểm tra Đúng/ Sai và Nếu sai, gửi thông

Có thể mô tả Sơ đồ thiết kế trên theo bảng sự kiện sau.

(5) Coding - lập trình cụ thể

Thủ tục được thiết lập cho

Chuyển đến vị trí đầu tiên

Lần lượt lấy các chữ số của n từ

3. Xử lý thông điệp Next.

Biến op nhận giá trị 1 hoặc 2.

Sinh ngẫu nhiên N1, N2 sao

Sinh ngẫu nhiên N1 trong khoảng

Đoạn chương trình của nhân vật

Đoạn chương trình thể hiện 2 số N1, N2 trên màn hình:

5. Xử lý thông điệp InputDone.

6. Xử lý thông điệp WaitCheck.

Nút chỉ hiển thị khi nhận thông điệp

Khi người dùng nháy chuột lên nút

7. Xử lý thông điệp CheckDone.

Chương trình chơi như sau:

Đoạn chương trình điều

Đoạn chương trình khởi

Mèo con Clone

Clone được khởi tạo từ 1 nhân vật

Tạo 1 biến nhớ riêng có tên CloneID

Chương trình cụ thể trên Scratch như sau:

Chương trình chính: Chương trình cho mỗi

Thiết lập các hình bông hoa có

Lệnh này sẽ tạo ra 50 bản clone của nhân vật