Ung dung tri tue nhan tao trong game

TRƯỜNG ĐẠI HỌC KHOA HỌC TỰ NHIÊN
KHOA CÔNG NGHỆ THÔNG TIN
BỘ MÔN CÔNG NGHỆ TRI THỨC
NGUYỄN THANH PHONG
ỨNG DỤNG TRÍ TUỆ NHÂN TẠO
TRONG XÂY DỰNG GAME
KHÓA LUẬN CỬ NHÂN TIN HỌC
TP. HCM, 2005

TRƯỜNG ĐẠI HỌC KHOA HỌC TỰ NHIÊN
KHOA CÔNG NGHỆ THÔNG TIN
BỘ MÔN CÔNG NGHỆ TRI THỨC
NGUYỄN THANH PHONG - 0112191
ỨNG DỤNG TRÍ TUỆ NHÂN TẠO
TRONG XÂY DỰNG GAME
KHÓA LUẬN CỬ NHÂN TIN HỌC
GIÁO VIÊN HƯỚNG DẪN
TH.S BÙI TIẾN LÊN
NIÊN KHÓA 2001-2005

NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................

NHẬN XÉT CỦA GIÁO VIÊN PHẢN BIỆN
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................
......................................................................................................

LỜI CẢM ƠN
Em sẽ không thể hoàn thành luận văn nếu không có sự hướng dẫn và chỉ
bảo tận tình của thầy Bùi Tiến Lên. Em xin chân thành cảm ơn sự chỉ bảo của
thầy.
Em cũng rất cảm ơn các thầy cô trong khoa Công nghệ Thông tin trường
Đại học Khoa học Tự nhiên Tp.Hồ Chí Minh đã tận tình giảng dạy, truyền đạt
những kiến thức quý báu và tạo điều kiện cho em hoàn thành luận văn này.
Xin chân thành cảm ơn sự giúp đỡ, động viên của của tất cả các bạn trong
quá trình thực hiện luận văn.
Em cũng muốn cảm ơn những người thân trong gia đình đã động viên, giúp
đỡ và tạo điều kiện để hoàn thành luận văn.
Mặc dù đã cố gắng hoàn thành luận văn với tất cả sự nổ lực của bản thân,
nhưng luận văn chắc chắn không tránh khỏi những thiếu xót. Em rất mong
nhận được sự thông cảm và chỉ bảo tận tình của các thầy cô và các bạn.
Tp.HCM 7/2005
Sinh viên thực hiện
Nguyễn Thanh Phong

Mục lục
MỤC LỤC
Chương 1 GIỚI THIỆU ................................................................................... 1
1. Lý do chọn đề tài....................................................................................... 1
1.1. Các ngôn ngữ lập trình game............................................................ 1
1.2. Phân loại game.................................................................................. 2
1.2.1. Game hành động....................................................................... 2
1.2.2. Game nhập vai.......................................................................... 3
1.2.3. Game đua xe............................................................................. 3
2. Mục đích của đề tài ................................................................................... 3
Chương 2 CÁC THUẬT TOÁN TÌM ĐƯỜNG ĐI ....................................... 4
1. Mô tả các thủ tục tìm kiếm rộng, sâu và sâu dần ...................................... 6
2. Thuật giải tìm đường đi có giá thành nhỏ nhất AT
................................... 7
3.Tìm kiếm với tri thức bổ sung.................................................................... 8
4.Tìm đường đi trên đồ thị tổng quát ............................................................ 9
Chương 3 GAME ENGINE ........................................................................... 12
I. WED editor:................................................................................................... 13
1. Những khái niệm cơ bản ......................................................................... 13
a. Giao diện người dùng......................................................................... 13
b. Thanh Icon......................................................................................... 15
c. Mode .................................................................................................. 15
d. Thiết kế một khung cảnh ................................................................... 14
e. Hướng đối tượng................................................................................ 16
f. Cửa sổ dự án....................................................................................... 18
2. Các lệnh trong WED ............................................................................... 19
2.1.Các lệnh trong các thực đơn ............................................................ 19
2.1.1. Thực đơn file.......................................................................... 20
2.1.2. Thực đơn edit: ........................................................................ 24
i

Mục lục
2.1.3. Thực đơn mode ...................................................................... 25
2.1.4. Thực đơn Object..................................................................... 29
2.1.5. Thực đơn Texture................................................................... 32
2.1.5. Thực đơn View....................................................................... 33
2.1.6. Thực đơn help ........................................................................ 34
2.2 Giao diện sử dụng............................................................................ 35
2.3. Cửa sổ dự án ................................................................................... 36
2.3.1. Tab đối tượng......................................................................... 36
2.3.2. Tab Views .............................................................................. 38
2.3.3. Tab Texture ............................................................................ 38
2.3.4. Tab Resource.......................................................................... 41
2.4. Cửa sổ Bookmark ........................................................................... 41
2.5. Thuộc tính của khối ........................................................................ 41
2.6. Thuộc tính của thực thể .................................................................. 43
3. Thiết kế một map..................................................................................... 45
4. Thực thể................................................................................................... 46
4.1. Thực thể mô hình............................................................................ 46
4.2. Thực thể Sprite................................................................................ 47
4.3. Thực thể Map.................................................................................. 47
4.4. Thực thể Địa hình (terrain)............................................................. 48
4.5. Bóng................................................................................................ 48
4.5. Thuộc tính trong suốt...................................................................... 49
II. CÁCH SỬ DỤNG MED.............................................................................. 50
1. Trình thiết kế ........................................................................................... 50
1.1. Các thực đơn................................................................................... 50
1.1.1. Thực đơn File ......................................................................... 50
1.1.2. Thực đơn Edit......................................................................... 53
1.1.3. Thực đơn View....................................................................... 55
ii

Mục lục
1.1.4. Thực đơn Options................................................................... 56
1.1.5. Thực đơn Help........................................................................ 57
1.2. Toolbars................................................................................................ 58
1.2.1. Toolbar File............................................................................ 58
1.2.2. Toolbar Edit............................................................................ 58
1.2.3. Toolbar Select ........................................................................ 60
1.2.4. Toolbar Mesh ......................................................................... 60
1.2.5. Toolbar các đối tượng cơ sở................................................... 61
1.2.6. Toolbar view .......................................................................... 62
1.2.7. Toolbar Frame........................................................................ 63
1.2.8. Thanh trạng thái ..................................................................... 64
2.Trình thiết kế Skin.................................................................................... 64
2.1. Các thực đơn................................................................................... 65
2.1.1. Thực đơn File ......................................................................... 65
2.1.2. Thực đơn Edit......................................................................... 66
2.1.3. Thực đơn View....................................................................... 67
2.2. Các Toolbar..................................................................................... 68
2.2.1. Toolbar Skin........................................................................... 68
2.2.2. Toolbar Edit............................................................................ 68
2.2.3. Toolbar Paint.......................................................................... 69
III. SED, C-Script editor................................................................................... 70
1. Giao diện sử dụng.................................................................................... 71
2. Soạn thảo................................................................................................. 72
2.1. Lệnh Insert...................................................................................... 72
2.2. Dòng chú thích................................................................................ 72
2.3. Nhảy đến một đoạn mã................................................................... 72
2.4. Sử dụng danh sách các thành phần................................................. 73
2.5. Kiểm tra cú pháp............................................................................. 73
iii

Mục lục
2.6. Soạn thảo thông minh ..................................................................... 73
3. Cấu hình .................................................................................................. 74
4. Thực đơn.................................................................................................. 75
4.1. Thực đơn File.................................................................................. 75
4.2. Thực đơn Edit ................................................................................. 76
4.3. Thực đơn Options ........................................................................... 76
4.4. Thực đơn Tools............................................................................... 77
4.5. Thực đơn Debug ............................................................................. 77
IV. Giao tiếp với các DLL ................................................................................ 79
1. Bắt đầu với SDK ..................................................................................... 79
2. Sử dụng đối tượng C-Script trong một DLL........................................... 82
3. Sử dụng các hàm API.............................................................................. 83
4. Lập trình một game trong C++................................................................ 87
Chương 4 CÀI ĐẶT........................................................................................ 89
I. Người chơi..................................................................................................... 89
1. Chuyển động vật lý.................................................................................. 89
a. Gia tốc, quán tính và lực ma sát......................................................... 89
b. Rơi từ trên xuống............................................................................... 93
2. Cách di chuyển camera theo người chơi ................................................. 97
2.1. Tầm nhìn của người thứ nhất.......................................................... 97
2.2. Quay tự do tầm nhìn của người thứ 3........................................... 101
2.3. Cách để cho camera tránh chạm vào tường.................................. 106
II. Xe tự động.................................................................................................. 108
Tránh chướng ngại vật trên đường đi........................................................ 108
iv

Chương 1: Giới thiệu
Chương 1
GIỚI THIỆU
1. Lý do chọn đề tài
Ngày nay, do nhu cầu đời sống của con người ngày càng được nâng cao,
trong đó nhu cầu giải trí của con người được quan tâm đến rất nhiều. Trong đó
việc giải trí bằng Game máy tính ngày càng phát triển nhanh và lan rộng ra do
sự lôi cuốn rất mạnh mẽ của nó. Hầu như ai đã sử dụng máy tính đều đã giải trí
bằng một số game nào đó trên máy tính. Có thể nói Game là một thể loại phóng
phú nhất trong tất cả các loại chương trình trên máy tính.
Mặc dù các chương trình Game rất nhiều, nhưng để có thể viết ra được một
game hay, có thể chơi được quả là một điều không dễ. Tuy vậy, với niềm đam
mê về game máy tính, em cũng muốn tiếp cận với lĩnh vực này.
1.1. Các ngôn ngữ lập trình game
Có rất nhiều chương trình hỗ trợ cho việc viết game: các ngôn ngữ lập trình
như C++, Visual C++, Delphi, Dark Basic Pro, 3D Game Studio.
Nhưng với các ngôn ngữ lập trình C++, Visual C++, DelPhi… có thể là
những ngôn ngữ rất mạnh, có thể viết ra được những game có quy mô lớn. Đây
là những ngôn ngữ lập trình có thể hoạt động trong nhiều lĩnh vực: với cơ sở dữ
liệu, lập trình hệ thống, hoặc viết game…Do đó sự hỗ trợ của nó trong việc viết
game là rất ít. Để có thể viết được một game bằng những ngôn ngữ lập trình
này mà không sử dụng một thư viện nào, đòi hỏi phải bỏ ra rất nhiều công sức.
Với engine Dark Basic Pro, đây là loại engine rất đơn giản và dễ sử dụng, là
một ngôn ngữ Script theo họ Basic. Nó chỉ thích hợp với các game nhỏ.
Tại sao lại sử dụng ngôn ngữ 3D Game Studio để viết game?
3D Game Studio là chương trình chuyên dụng dùng để tạo ra game 3D.
1

Với hàng trăm game đã được phát hành, 3D Game Studio xứng đáng là một
ngôn ngữ lập trình game lớn. Với 3D Game Studio, chúng ta có thể:
- Tạo ra một game đơn giản từ những script mẫu có sẵn.
- Tạo ra các game thương mại viết bằng ngôn ngữ script.
- Có thể sử dụng VisualC++ hoặc Delphi để kết hợp với 3D Game Studio
để viết game.
Có rất nhiều tài liệu hướng dẫn lập trình game bằng 3D Game Studio. Ngay
cả với những người chưa có kiến thức về lập trình, nhưng nếu theo từng bước
hướng dẫn tạo một game hành động đơn giản thì cũng có thể hoàn thành nó
trong một thời gian ngắn.
Theo Dr.Dobb's Journal: “Đây là bộ công cụ tuyệt vời để nhanh chóng tạo
ra mẫu ban đầu và phát triển ứng dụng 3D”. Chúng ta có thể sử dụng ngôn ngữ
script trong 3D Game Studio để viết và phân phối một game thương mại. Dưới
đây là những game thương mại được làm bằng 3D Game Studio:
1.2. Phân loại game
Thể loại của game thì rất phong phú và đa dạng, ở đây chúng ta chỉ xét các
thể loại game thường thấy nhất là:
1.2.1. Game hành động
Game hành động xuất hiện rất nhiều trong cả game 3D và game 2D. Game
loại này có đặc điểm chúng là tính co giật trong game, như trong game bắn
2

súng. Game hành động thường đơn giản hơn tất cả các loại game khác bởi vì
những người bình thường dễ dàng biết cách chơi và chơi hay game này .
1.2.2. Game nhập vai
Game nhập vai thường có hai đặc trưng là: sự thay đổi, phát triển nhân vật
và một câu chuyện mà trong đó nhân vật sẽ trải qua.
1.2.3. Game thể thao
Game thể thao là sự thách thức cho các nhà thiết kế game. Không giống như
hầu hết các thể loại game khác, người chơi biết rất ít về nó, trong game thể thao
người chơi biết rất rõ vì nó mô phỏng một môn thể thao có sẵn trong thực tế.
1.2.3. Game đua xe
Game đua xe tạo ra cảm giác giống như người chơi đang lái xe bên ngoài
thế giới thực.
Tuy trong đề tài của em không thể nói là viết ra được một game chơi được
như một game đua xe, mà đây chỉ là một chương trình ở mức độ mô phỏng
giao thông trên đường phố.
2. Mục đích của đề tài
Tìm hiểu ngôn ngữ lập trình game trong 3D GameStudio:
- Tìm hiểu về WED, một chương trình thiết kế khung cảnh trong game.
- Tìm hiểu về MED, một chương trình thiết kế các mô hình trong game.
- Tìm hiểu về SED, trình soạn thảo dùng để viết các câu lệnh script để kết
nối các mô hình được tạo ra trong MED, các khung cảnh được tạo ra trong
WED và sử dụng những hàm có sẵn trong SED hoặc trong các DLL khác để
tạo ra một game.
Sử dụng thuật toán cổ điển A* tìm kiếm đường đi để một đối tượng có thể
chuyển động theo một hướng mong muốn nào đó.
3

Chương 2: Các thuật toán tìm đường đi
Chương 2
CÁC THUẬT TOÁN TÌM
ĐƯỜNG ĐI
Hầu hết các bài toán hoặc vấn đề đều có thể phát biểu dưới dạng “từ một
trạng thái xuất phát hãy tìm đường dẫn đến một trạng thái kết thúc mong
muốn”
Việc tìm “đường dẫn” từ trạng thái xuất phát (S0) đến trạng thái kết thúc
(Sn) gồm có một số bước sau đây:
− Chọn không gian tìm kiếm thích hợp.
− Tiến hành tìm kiếm có hệ thống và hiệu quả trong không gian tìm kiếm.
− Sử dụng triệt để các nguồn tri thức liên quan trong quá trình tìm kiếm
tương ứng với miền đối tượng cụ thể.
Không gian tìm kiếm của một vấn đề cần giải trên máy tính thường được
biểu diễn bằng đồ thị hay một dạng đặt biệt của đồ thị là cây. Đồ thị là một tập
hợp giữa các đỉnh và các cung nối giữa các đỉnh. Các cung có thể được định
hướng hoặc không định hướng, gán giá trị hoặc không gán giá trị.
Cây là đồ thị định hướng đặt biệt có duy nhất một đỉnh mà không có cung
nào hướng đến (gốc của cây), và mỗi đỉnh khác của cây chỉ có duy nhất một
cung hướng đến.
Sau khi bài toán hoặc vấn đề được biểu diễn lại dưới dạng đồ thị hoặc cây:
− Mỗi đỉnh là một trạng thái của quá trình giải bài toán.
− Mỗi cung là tác động biến đổi quá trình từ giai đoạn này sang giai đoạn
khác.
Như vậy, việc giải quyết một bài toán cũng chỉ là tìm đường đi từ trạng thái
ban đầu đến trạng thái mong muốn được biểu diễn qua hai đỉnh nào đó của đồ
4

thị hoặc cây tìm kiếm. Nhiều bài toán phức tạp nếu giải quyết bằng phương
pháp tìm kiếm ngẫu nhiên thì hầu như vô vọng vì số đường đi có thể sẽ tăng lên
theo hàm mũ của số đỉnh. Chính ở đây biểu lộ toàn bộ bản chất của trí tuệ nhân
tạo khi giải quyết các vấn đề: Đó là nghệ thuật xử trí với các vấn đề lớn bằng
cách giảm số lượng tìm kiếm.
Các thủ tục tìm kiếm điển hình bao gồm:
− Tìm kiếm rộng: đường đi được tìm theo mọi hướng có thể ở mỗi bước.
− Tìm kiếm sâu: đường đi sâu mãi theo một hướng đến khi nào không tiếp
tục được nữa mới chuyển sang hướng khác.
− Tìm kiếm sâu dần: kết hợp tìm kiếm rộng và tìm kiếm sâu trên cơ sở cho
trước mức sâu n rồi tìm kiếm rộng ứng với mức sâu đó.
− Tìm kiếm cực tiểu hóa giá thành: mỗi cung của cây (đồ thị) được gán giá
thành và hướng tìm kiếm được xác định bởi việc cực tiểu hóa giá thành
đường đi.
− Tìm kiếm với tri thức bổ sung: hướng tìm kiếm được xác định với tri
thức bổ sung ở mỗi bước.
Trước hết các thủ tục tìm kiếm rộng, sâu và sâu dần sẽ được mô tả qua một
ví dụ. Sau đó một số thuật giải tìm kiếm cực tiểu hóa giá thành và bổ sung tri
thức sẽ được trình bày chi tiết.
5

1. Mô tả các thủ tục tìm kiếm rộng, sâu và sâu dần
Tìm kiếm rộng: quá trình tìm kiếm sẽ lần lượt là A, B, C, D, E, F, G, H, I,
J, K, L, M, N, O, P, Q, R, S, T, U, V…
Tìm kiếm sâu: quá trình tìm kiếm sẽ lần lượt là A, E, K, O, Q, S, T, U, V,
…B, F,… C, G, L, H, M, … D, I, J, N, P, R.
Chú ý: nếu nhánh dưới v dài vô hạn thì quá trình tìm kiếm sẽ không bao giờ
đến được mục tiêu.
Tìm kiếm sâu dần: ứng với mức sâu 2: (A,E), (B,F), (C,G), (C,H), (D,I),
(D,J).
R
V
U
T
S
Q
PO
K L M N
JIHGFE
A
B C
D
1
1
1
1
11
1
1
1
10
100 1
17
1 10 12 1
1 1 1
1
1
Trạng thái mong muốn
6

ứng với mức sâu 3: (A,E,K), (B,F), (C,G,L), (C,H,M), (D,I), (D,J,N).
2. Thuật giải tìm đường đi có giá thành nhỏ nhất
AT
(Algorithm for Trees) với mỗi đỉnh n tương ưng số g(n) là giá thành
đường đi từ đỉnh đầu tới n. (g(n) có thể chưa xác định đối với các đỉnh thuộc
phần cây chưa hướng đến). Mỗi đỉnh n có thể là:
− Đỉnh đóng: nghĩa là đỉnh đã được xem xét;
− Đỉnh mở: là đỉnh giả định sẽ được xem ở bước sau;
− Đỉnh ẩn: là đỉnh mà hàm g(n) tương ứng chưa được tính đến và chưa
được xem xét đến.
Thuật giải AT
gồm các bước sau:
Bước 1: Đầu tiên, mọi đỉnh n và mọi giá trị g(n) đều là ẩn. Mở đỉnh đầu tiên
(coi đỉnh đầu tiên là đỉnh mở và đặt giá trị g tương ứng bằng 0).
Bước 2: Chọn đỉnh mở với giá thành g tương ứng nhỏ nhất. Gọi đỉnh này là
N, nếu N là đỉnh mục tiêu thì đường dẫn tới N là đường đi có giá thành nhỏ
nhất g(n) và vấn đề đã được giải. Nếu không còn đỉnh mở nào thì cây biểu
diễn vấn đề không có đường đi tới mục tiêu. Nếu có từ 2 đỉnh trở lên cùng
giá trị g nhỏ nhất thì kiểm tra trong số đó có đỉnh mục tiêu không? Nếu có
thì chọn đỉnh mục tiêu đó và quá trình giải kết thúc. Nếu không thì chọn tùy
ý một đỉnh trong số đó và gọi là N.
Bước 3: Đóng đỉnh N và mở các đỉnh sau N (có cùng hướng đến N), với
mỗi đỉnh sau N gọi là s, ta tính:
g(s)=g(N)+(giá thành cung từ N tới s)
Bước 4: Quay trở lại bước 2.
Thuật giải AT
đã được chứng minh là luôn luôn tìm được đường đi với giá
thành nhỏ nhất nếu như tồn tại đường đó trên đồ thị và là thuật giải tối ưu theo
nghĩa số đỉnh đóng trong quá trình tìm kiếm là ít nhất.
7

3. Tìm kiếm với tri thức bổ sung
Thuật giải AT
là thuật giải tìm kiếm đường đi tốt nhất đối với các cây chỉ có
thông tin về đỉnh, cung và giá thành cung. Nhưng trong nhiều trường hợp việc
tìm kiếm đường đi sẽ được định hướng rõ thêm nếu sử dụng các tri thức thu
được dựa trên những hiểu biết về tình huống vấn đề ở mỗi bước. Các thủ tục
tìm kiểm dựa trên 3 cách tiếp cận:
− Không tính đến các tri thức bổ sung ngoài thông tin về đỉnh, cung, giá
thành.
− Sử dụng tri thức bổ sung để tìm cách giải riêng biệt cho vấn đề mà bỏ
qua việc xây dựng cây biểu diễn cho vấn đề.
− Xây dựng biểu diễn vấn đề dưới dạng cây có tính đến tri thức bổ sung
trong cấu trúc cây hoặc giá thành các cung.
Ngoài ra có có cách tiếp cạn theo hướng xây dựng các thuật giải “vạn
năng”, tìm kiếm đường đi với tri thức bổ sung. Họ thuật giải này mang tên là
AKT
(Algorithm for knowledgeable Tree search). Tri thức bổ sung ở mỗi đỉnh
được tương ứng một giá trị . Chẳng hạn đó là ước lượng giá thành đường
đi từ n đến mục tiêu (như vậy là ước lượng giá thành đường đi con chương
biết đến).
)(nh
∧
∧
h
Thuật giải AKT
gồm các bước sau:
a) Đầu tiên, mọi đỉnh cũng như giá trị g, , là chưa biết. Mở đỉnh đầu
tiên (o) và gán g(0), sử dụng tri thức bổ sung để ước tính h(0) và tính
.
∧
h
∧
f
)0()0()0(
∧∧
+= hgf
b) Chọn đỉnh mở có giá trị nhỏ nhất. Gọi đỉnh này là N. Nếu
N là mục tiêu thì đường tới N là đường đi có giá thành nhỏ nhất g(N). Nếu
không tồn tại đỉnh mở nào thì cây không tồn tại đường đi tới mục tiêu. Nếu có
)()( nhngf
∧∧
+=
8

từ 2 đỉnh mở trở lên cùng giá trị nhỏ nhất, hãy kiểm tra trong các đỉnh này
có chứa mục tiêu không? Nếu một trong các đỉnh này là mục tiêu thì vấn đề đã
được giải quyết, còn không thì chọn tùy ý một trong các đỉnh này là N.
∧
f
c) Đóng đỉnh N, mở đỉnh sau N. Với mỗi đỉnh S sau N ta tính
g(s)=g(N)+(giá thành cung từ N đến S). Sử dụng tri thức bổ sung ở bước này,
ước lượng và gán cho f(s) giá trị .)(sh
∧
)()()( shsgsf
∧∧
+=
d) Quay về bước 2.
Giải thích ý nghĩa AKT
: giả sử h(n) là giá thành nhỏ nhất được biết chính
xác từ n đến mục tiêu. Như vậy h(n) chỉ là ước lượng gần đúng về h(n). nếu
thì A)()( nhnh ≡
∧
KT
là thủ tục hoàn toàn tuyệt đối (các đỉnh đóng đúng là các
đỉnh nằm trên đường đi ngắn nhất đến mục tiêu). Trong trường hợp không có
tri thức bổ sung, và A0)( =
∧
nh KT
suy biến thành AT
. Ta thấy rõ ràng rằng giữa
và sẽ tồn tại các thuật giải với mức độ hiệu quả rất thú vị. Nếu
(với mọi n), A
0=
∧
h hh =
∧
hh ≤
∧
KT
sẽ bảo đảm tìm ra được đường đi giá thành nhỏ nhất và
tối ưu theo nghĩa sử dụng số đỉnh đóng ít nhất so với mọi thuật giải cũng chỉ
làm việc với các tri thức như vậy.
Nếu (với mọi n, hoặc với một số đỉnh). Ahh >
∧
KT
không bảo đảm tìm được
đường đi giá thành nhỏ nhất nhưng đường đi mà AKT
tìm ra vẫn dùng được
trong nhiều trường hợp thực tiễn giải quyết vấn đề.
4. Tìm đường đi trên đồ thị tổng quát
Các phần trên đã trình bày thuật giải tìm đường đi trên đồ thị dạng cây. Tuy
nhiên biểu diễn dạng cây nhiều khi sẽ lặp lại quá nhiều một trạng thái. Điều đó
sẽ tăng thêm thời gian tim kiếm. Để khắc phục cần nới bỏ điều kiện mỗi đỉnh
chỉ có một cung hướng đến và do vậy phải nghiên cứu thuật giải tìm đường đi
9

trên một đồ thị dạng tổng quát. Ta cũng có thể mở rộng thuật giải AKT
thành
thuật giải tổng quát A*
như sau:
Bước 1: Đầu tiên, mọi đỉnh và các giá trị g, , đều xem như chưa biết,
mở đỉnh đầu tiên 0, gán cho g(0)=0, ước lượng và gán .
∧
h
∧
f
)0(
∧
h )0()0(
∧∧
= hf
Bước 2: Chọn đỉnh mở với giá trị nhỏ nhất và gọi là N. Nếu N là
mục tiêu thì đường dẫn tới N đã tìm được và g(N) là giá thành của đường đi đó.
Nếu không tồn tại đỉnh mở thì đồ thị đó không tồn tại đường đi đến mục tiêu.
Nếu có từ 2 đỉnh mở trở lên cùng giá trị và 1 trong 2 đỉnh đó là mục tiêu thì
quá trình tìm đường đi cũng kết thúc, còn không thì chọn tùy ý một trong 2
đỉnh đó là N.
∧∧
+= hgf
∧
f
Bước 3: Đóng đỉnh N và đối với mỗi đỉnh sau đó, ta tính +=′ )()(g Ngs (giá
thành cung từ N đến S). Nếu đỉnh S đã mở và )(gg(s) s′≤ thì bỏ qua S. Ngược
lại ta mở S và đặt )(gg(s) s′= , tính và .)(sh
∧
)()()( shsgsf
∧∧
+=
Bước 4: Quay về bước 2.
Bây giờ chúng ta có thể dùng A* để tìm đường đi ngắn nhất giữa 2 thành
phố dựa theo bản đồ giao thông với tri thức bổ sung có thể là khoảng cách
đường chim bay từ điểm (thành phố) n tới mục tiêu (thành phố cần đến). Do
khoảng cách đường chim bay bao giờ cũng nhỏ hơn khoảng cách đường giao
thông nên với mọi n. Thuật giải A* với tri thức bổ sung như
trên sẽ tìm được đường đi ngắn nhất (hoặc giá thành nhỏ nhất) với mức độ hiệu
quả càng cao nếu càng gần h(n).
)(nh
∧
)()( nhnh ≤
∧
)(nh
∧
)(nh
∧
Trong thuật giải A*, ta đặc ở đây vai trò của g và được xem là
như nhau. Nhưng tùy theo trường hợp, có thể xét với w1, w2
∧∧
+= hgf
∧
h
∧∧
+= hwgwf .2.1
10

là các trọng số cho biết vai trò của g và tham gia trong quá trình giải. Ngoài
ra cũng cần thêm các ước lượng về giá thành (độ phức tạp) của việc xác định
và tập đỉnh đóng để có cơ sở đánh giá hiệu quả của thuật giải một cách đầy đủ.
∧
h
∧
h
11

Chương 3: Game Engine
Chương 3
GAME ENGINE
Có thể định nghĩa engine như một loại máy móc làm cho xe chạy, nó hoạt
động bên trong, như chuyển năng lượng động lực vào trục xe làm xe chuyển
động. Người lái xe không quan tâm đến những gì xảy ra bên trong.
Một engine 3D cũng được định nghĩa như vậy. Khi chúng ta gọi một hàm
khởi động và gởi một mô hình 3D đến graphic adapter (GA), engine 3D sẽ giao
tiếp với GA và hiển thị mô hình 3D lên màn hình
Công việc của engine là làm những việc khó chịu ở cấp thấp như: giao tiếp
với card đồ họa, biến đổi các mô hình, làm việc với các phép toán khó hiểu như
phép biến đổi ma trận…
Các nhà lập trình game cũng giống như người lái xe, khi sử dụng một
engine, họ không cần quan tâm một engine thực sự làm việc như thế nào, họ
chỉ cần xác định đưa vào những gì, và engine sẽ đưa ra kết quả.
Có rất nhiều định nghĩa khác nhau về engine. Các nguyên lý tổng quát mà 1
engine phải có :
1. Quản lý dữ liệu trong vùng mà nó chịu trách nhiệm.
2. Tính toán dữ liệu theo nhiệm vụ của nó.
3. Xử lý dữ liệu đến instance sau của nó, nếu cần thiết.
4. Nhận dữ liệu để quản lý và tính toán từ các instance có trước.
3D GameStudio cũng là một game engine. Nó bao gồm 3 thành phần sau:
WED editor, MED, C-Script editor. Chúng ta cùng tìm hiểu cách sử dụng của 3
bộ phận của 3D GameStudio.
12

Chương 3: Game Engine – Cách sử dụng WED
I. WED editor
WED là một trình biên soạn. Lập trình viên có thể sử dụng nó để tạo ra một
thế giới ảo của game. WED là công cụ để kết hợp lại toàn bộ các thành phần:
level (được tạo ra bởi WED), các mô hình (được tạo ra bởi MED) và các mã
lệnh (được viết trong SED) tạo ra sản phẩm cuối cùng.
Với WED, chúng ta có thể tạo ra được một khung cảnh 3D hết sức dễ dàng
mà không cần phải có bất cứ kinh nghiệm gì về việc tạo hình 3D. Với cả những
người mới bắt đầu và những nhà thiết kế chuyên nghiệp, WED cũng sẽ là một
công cụ rất cần thiết có thể tạo ra một khung cảnh 3D chuyên nghiệp một cách
đơn giản và nhanh chóng.
1.Những khái niệm cơ bản
a. Giao diện sử dụng
Khi mở WED, màn hình giao diện sau sẽ xuất hiện:
13

Đây chính là môi trường mà chúng ta sẽ làm việc để tạo ra một game trong
3D GameStudio. Tạo ra một game 3D, tức là đưa những đối tượng vào môi
trường 3D này, và gắn các thuộc tính và hành vi mà chúng ta đã lập trình vào
chúng, hoặc chọn từ một danh sách các hành vi đã được tạo sẵn.
Đầu tiên, chúng ta cần chú ý đến 4 cửa sổ 2D và 3D. Mỗi cửa sổ tượng
trưng cho một khung nhìn ở mỗi góc khác nhau trong lúc thiết kế game. Có thể
cuộn một cửa sổ bằng cách click và rê chuột phải, và có thể phóng to, thu nhỏ
bằng nút lăn.
Khung nhìn 3D sẽ cho chúng ta thấy trước một game sẽ được thể hiện như
thế nào. Chúng ta có thể chuyển khung nhìn 3D sang các dạng khung lưới,
đặc, kết cấu. Trong mục Preferences chúng ta có thể chọn cách biểu diễn đồ
họa trong khung nhìn 3D. Mục cuối cùng dùng để điều chỉnh độ sáng nền để
cho ra một quang cảnh giống thực, nhưng vẫn không hoàn giống với sản phẩm
cuối cùng.
14

Khi click phải vào khung nhìn 3D và chọn GXL Properties, thì các đặc
điểm như độ sáng và tầm nhìn có thể được thay đổi.
Chúng ta có thể tìm thấy thanh bar ở phía trên, phía dưới là dòng trạng thái và
phía trái là cửa sổ dự án. Nó chứa các cửa sổ Objects, Views, Textures và
Resources.
b. Thanh Icon
Thanh bar này chứa những hàm thường dùng trong các menu, và chúng ta
có thể gọi một hàm bằng cách nhấp chuột. Khi rê chút đến một Icon sẽ xuất
hiện một dòng chữ gần con chuột để giải thích ý nghĩa của nút này. Có thể cho
hiển thị hay ẩn đi các thanh bar File, Edit và View bằng cách chọn vào menu
View/Toolbar. Ngoài ra, chúng ta có thể di chuyển từng thanh bar đến bất cứ
đâu trên cửa sổ. Mặc định, sau đây là thứ tự của các nút trên thanh bar:
New, Open, Save, Copy, Paste, Undo, Build, Run, Select, Move, Rotate, Scale,
Vertex Move, Edge Move, Face Move, Add Object, Delete Object, Snap on/off,
Snap Mode, Snap Size, Axis Restriction, Eye Move, Eye Rotate, Eye Zoom,
Camera Move, Camera Walkthru, Scope Up, Scope Down.
c. Mode
Chế độ Select: Nếu chế độ này được chọn, khi nhấn
nút trái chuột thì một khối, nhóm hoặc một đối tượng
nào đó sẽ được chọn. Nếu không chọn được đối tượng
mong muốn, có thể là nó đang được phủ bởi một đối
tượng khác, vì thế chỉ cần nhấn nút chuột trái tiếp đến
khi nào chọn được thì thôi. Chúng ta có thể chọn nhiều
đối tượng bằng cách kéo rê một hình chữ nhật xung
15

quanh chúng, hoặc giữ phím [CTRL] trong khi chọn các đối tượng.
Chế độ Move: Nếu chế độ này được chọn, thì có thể di chuyển một đối
tượng bằng cách nhấn nút trái chuột và rê nó đến vị trí mong muốn. Hãy nhìn
vào các khung nhìn để kiểm tra xem đối tượng có đến được nơi mong muốn
hay không. Cũng có thể di chuyển các đối tượng bằng các phím di chuyển.
Chế độ Rotate: Nếu chế độ này được chọn, ta có thể quay các khối và các
nhóm được chọn bằng cách nhấn nút trái chuột và rê trái hoặc phải tùy theo ý
muốn. Trong mỗi khung nhìn, chúng ta chỉ có thể quay một đối tượng theo
một hướng nào đó. Cũng có thể quay các đổi tượng bằng các phím di chuyển.
Chế độ Scale: nhấn và rê nút trái chuột để thay đổi kích thướt của khối và
nhóm đã chọn. Nếu rê lên thì chiều cao của khối sẽ tăng lên, rê qua trái thì
chiều rộng của khối sẽ được tăng lên. Nếu giữ [CTRL] trong khi thay đổi kích
thướt thì kích thướt theo chiều dọc và chiều ngang sẽ cùng thay đổi một lượng
bằng nhau. Khối sẽ được phồng ra hay co vào một cách đối xứng, vì thế chúng
ta cần phải di chuyển khối trở lại đúng vị trí sau khi thay đổi kích thướt của nó.
d.Thiết kế một khung cảnh
Có hai thành phần chính trong một khung cảnh 3D là khối (block) và thực
thể (entity). Khối chỉ đơn giản là một đối tượng cấu trúc đặc có dạng lồi. Một
khung cảnh 3D được cấu thành từ có khối đặc và các đối tượng là sự kết hợp
của nhiều khối. Ví dụ, để tạo ra một cái phòng có hình lập phương, chúng ta sẽ
cần 6 khối bao quanh một không gian trống rỗng: 1 khối là trần nhà, một khối
là nền đất, 4 khối là 4 bức tường.
Thành phần thứ 2 là thực thể, thực thể gồm 4 loại sau đây: terrain, map,
model và sprite. Mỗi loại được sử dụng cho những mục đích khác nhau.
e. Hướng đối tượng
16

WED xem tất cả mọi thứ đều là đối tượng. Một
đối tượng có thể là một thực thế, một khối, hoặc
một nhóm các đối tượng. Việc nhóm các đối tượng
lại cho phép chúng ta xây dựng nên các cấu trúc
như: cầu thang, một chiếc vòm, một chiếc cầu,
hoặc một chiếc ghế từ những khối đơn giản. Việc
nhóm các đối tượng sẽ giúp chúng ta tạo ra được
những căn phòng phức tạp và tạo ra một khung
cảnh (level) một cách nhanh chóng từ các cấu trúc
đó. Như vậy, một khung cảnh sẽ được cấu tạo từ
những cấu trúc phức tạp như các căn phòng trên,
được tạo thành từ những cấu trúc đơn giản hơn, vì
chính những cấu trúc này được tạo ra từ những đối
tượng nhỏ hơn nữa hay chỉ ra từ các khối.
Phương pháp thiết kế hướng đối tượng này sẽ
dấu đi những thông tin không cần thiết với người
dùng. Với nó, chúng ta có thể xây dưng một khung cảnh từ những đối tượng có
thực mà không cần phải sử dụng hàng ngàn các khối và đỉnh. Phương pháp này
có tính dễ điều chỉnh và dễ mang chuyển. Người sử dụng có thể tạo ra các cấu
trúc khác nhau một cách độc lập, để từ đó tạo ra một thư viện các đối tượng
phức tạp để có thể sử dụng lại sau này. Vì thế chúng ta sẽ không phải mất thời
gian để xây dựng lại những đối tượng tương tự nhau. Điều này gợi ra một
hướng khác là cách sử dụng các cấu trúc và đối tượng đã được tạo sẵn trong
các thư viện.
Với thực đơn Object, chúng ta có thể chèn một khối cơ sở (có nhiều loại
khác nhau), một đối tượng 3D đã được tạo sẵn, hoặc chèn vào các tài nguyên
17

ánh sáng (light) hoặc âm thanh (sound), camera, vị trí (positon), địa hình
(terrain), mô hình 3D (model), các sprite 2D, các đường dẫn (path).
f. Cửa sổ dự án
Hình ở bên là cửa sở làm việc với 4 tùy chọn Object, Views, Texture và
Resources.
Object: Đây là một danh sách tất cả các nhóm, đối tượng và khối trong toàn
cảnh thiết kế. Nhấp double chuột để chọn một đối tượng. Nhấp phải chuột vào
một đối tượng sẽ hiện ra một thực đơn và chọn Properties sẽ có thể thay đổi
được thuộc tính của các đối tượng. Nếu nhấn vào dấu “+” các đối tượng trong
nhóm này sẽ được mở ra, vì thế các đối tượng này có thể được chọn và sửa
đổi một cách riêng biệt. Đối tượng có thể bị khóa lại bằng cách nhấn phải chuột
và chọn Render Style/Disable.
Views: nhấp phải chuột vào Views List vị trí các cửa sổ có thể được chọn,
lưu và gọi lại.
Texture: Để tạo ra một khung cảnh trong đó các bức tường có một kết cấu
xác định, chúng ta cần phải mở tập tin *.WAD chứa nhiều kết cấu khác nhau.
Chọn thực đơn Texture / Texture Manager / Add WAD (hoặc nhấp phải vào kết
cấu mặc định và chọn Texture Manager / Add WAD ). Chúng ta có thể chọn
nhiều tập tin WAD cùng lúc, và cũng có thể thêm một kết cấu nào đó đến vào
một tập tin WAD. Hình ảnh của các kết cấu trong tập tin WAD sẽ xuất hiện
dưới thanh WAD tương ứng và có thể được cuộn lên bằng thanh cuộn được đặt
ở phía bên phải. Nếu nhấp vào một thanh WAD nào đó, thì hình ảnh của tập tin
WAD tương ứng sẽ được mở ra hoặc đóng lại.
Khi nhập double chuột vào một kết cấu của một WAD thì kết cấu này sẽ
được gắn vào đối tượng đang chọn.
18

Nhấp phải chuột vào một kết cấu trong một WAD, một thực đơn xuất hiện,
lúc này chúng ta có thể xóa kết cấu này khỏi WAD hoặc đổi tên của nó, và
cũng có thể thay đổi các thuộc tính của nó. Với thực đơn này chúng ta có thể
thêm một kết cấu mới vào WAD từ các ảnh có dạng PCX, BMP hoặc TGA, và
cũng có thể đánh dấu các kết cấu thường dùng vào bookmarks, lưu WAD hoặc
mở texture manager.
Cửa sổ Object sẽ hiển thị kết cấu của một đối tượng được chọn. Trong cửa
sổ Texture chúng ta sẽ luôn luôn thấy hình ảnh và tên của một kết cấu mà con
chuột đang chỉ đến nó trong WAD. Nếu đóng WAD lại hoặc di chuyển chuột ra
ngoài cửa sổ project, thì kết cấu được chọn cuối cùng vẫn được giữ trong cửa
sổ này.
Kích thướt của các cửa sổ có thể được thay đổi bằng cách kéo rê chuột ở
cạnh bên dưới của cửa sổ.
Resources: danh sách tất cả các tập tin có liên quan đến việc thiết kết game.
Nếu nhấp double vào một hành vi, thì mã nguồn sẽ được hiện thị ở một cửa sổ
khác.
2. Các lệnh trong WED
2.1. Các lệnh trong các thực đơn
Sau đây là những giải thích ngắn gọn cho từng lệnh và hàm trong WED.
Một vài lệnh khá đơn giản, và đòi hỏi ít hoặc không cần phải giải thích.
• File
• Edit
• Mode
• Object
19

• Texture
• View
• Help
Chúng ta sẽ bắt đầu với thực đơn file.
2.1.1. Thực đơn file
New
Open
Close
Save
Save As
Exit
Giao tiếp với những loại tập tin
mà nó có hỗ trợ. Chúng ta có thể
mở tập tin .MAP và .QLE và các
tập tin trung gian $$M, và lưu
chúng với định dạng .WMP.
Trong phiên bản chuyên nghiệp, chúng có thể
được lưu trữ trong định dạng MAP.
Map properties: mở cửa sổ thuộc tính map.
Add script: đưa những đoạn mã mẫu vào đoạn mã main.
Build WMB: trước khi có thể sử dụng các khung cảnh được thiết kế trong
WED, phải chuyển từ định dạng thiết kế (WMP) đến định dạng WMB, là
định dạng mà engine có thể hiểu được. Lệnh này đưa ra một hộp thoại cho
phép chọn lựa những tùy chọn khác nhau để biên dịch tập tin thiết kế
(WMP).
Run level: bắt đầu engine và kết hợp mã nguồn với khung cảnh thiết kế.
Chúng ta có thể chọn chế độ cửa sổ hoặc chế độ fullscreen, chế độ D3D
hoặc không. Hoặc chúng ta có thể khởi động engine trực tiếp (chạy file
ACKNEX.EXE) và kiểm tra level của mình. Nó nằm ở thư mục BIN, và
20

chúng ta có thể tạo ra một đường tắt trên desktop để khởi động và gọi level
của mình.
Starter: Trong phiên bản chuyên nghiệp nó tạo ra một tập tin có định dạng
ACKNEX.WDF cho đoạn mã hiện tại. ACKNEX.WDF xác định các thuộc
tính bắt đầu của ứng dụng trước khi chuyển đến chế độ fullscreen: hiển thị
một biểu tượng, hiển thị thông tin biên dịch…
Resource: Trong phiên bản chuyên nghiệp: tạo ra một thư mục con .CD
trong thư mục WORK. Bên trong có chứa một tập tin tài nguyên .WRS đây
là tập tin nén và mã hóa tất cả các tập cần thiết cho game, một tập tin .EXE
để khởi động nó, và tập tin WEDS.EXE cùng với một vài tập tin khác. Tất
cả các tập tin trong thư mục .CD có thể được phân phối tự do. Nếu sự phân
phối trình soạn thảo level là không được phép, WEDS.EXE,
WWMP2WMB.EXE và WEDS.DAT trong thư mục .CD cần được xóa đi.
Bằng không, các tập tin WMP và WAD trong game phải được kèm theo cho
người dùng cuối. WEDS là một phiên bản có giới hạn của WED. Nó chỉ
được dùng để biên soạn level trong lúc phân phối game – nó không thể
được dùng như là một phần mềm riêng biệt. Nó sử dụng tất cả các thực thể
và hành vi tìm thấy trong tập tin tài nguyên. Các đoạn mã trong các tập tin
script không thể thay đổi được – đó luôn luôn là tập tin có chứa đoạn mã
chính. Các tập tin WAD có thể được gọi đến như là thành phần bên ngoài,
nhưng không thể sửa lại được. RESOURCE, PUBLISH và STARTER thì
không được hoạt động. Tất cả những đặc điểm còn lại WED có thể sử dụng
được. Tất cả những tập tin nằm trong dấu ngoặc góc (<>) trong mã nguồn,
và tất cả các tập tin nằm trong level được đưa ra bởi câu lệnh khai báo level
đều được đưa vào tài nguyên. Tuy nhiên có một vài tập tin vẫn phải tuân
theo các quy luật hiện tại và không thể được truy xuất từ tập tin tài nguyên:
21

các tập tin DLL, âm thanh và bất kì tập tin nào được truy xuất bằng lệnh
file_ đều phải được đưa vào bằng tay trong lúc phân phối game.
Publish: tạo ra một thư mục con .CD trong thư mục WORK, và sao chép tất
cả các tập tin cần thiết cho game vào đó. Một tập tin EXE để bắt đầu game
cũng được tạo ra, và có thể tự do phân phối. Chú ý rằng tập tin EXE đã bị
khóa – nó không thể bắt đầu một game khác hoặc với một đoạn mã đã bị
thay đổi. Toàn bộ thư mục .CD có thể được chép vào CD-ROM để phân
phối. Tất cả các tập tin được gọi đến cùng với dấu ngoặc góc (<>), và cùng
với dòng khai báo level, đều được đưa vào thư mục .CD.
Recent Files: hiển thị 4 tập tin map gần nhất để có thể mở nhanh hơn.
Preferences: lệnh này để cho chúng ta có thể thay đổi một vài tùy chọn
trong WED. Tùy chọn khác có thể được thay đổi trong tập tin
OPTIONS.SCR trong thư mục data.
Map Properties
Mở một cửa sổ thuộc tính
map, ở đây chúng ta có thể
chọn hoặc tạo ra một tập tin
script, chọn lựa màu, và chọn
lựa kích thướt quan hệ (Nexus)
với engine cho map. Tập tin
script phải nằm trong cùng thư mục với tập tin map. Một tập tin script mới
có thể được tạo bằng cách nhấn vào nút New. Kích thướt của nexus tùy
thuộc vào level lớn nhất trong game, và phải được tăng lên nếu thông điệp
nexus too small xuất hiện. Bảng màu được đưa ra từ một tập tin PCX hoặc
BMP 8 bit hoặc từ một tập tin RAW được phát sinh trong qua trình build.
Tất cả các kết cấu 8 bit cũng phải được sửa lại để phù hợp với nó. Một bảng
22

màu thì luôn luôn rất cần thiết ngay cả khi màu của các kết cấu sử dụng là
các màu thật, để duy trì khả năng của engine để chạy trong chế độ 8-bit. Tất
cả các màu là các giá trị RGB có phạm vi giá trị từ 0..255. Ánh sáng bầu
trời được phát ra bởi hộp bầu trời bao quanh level.
Khi nhấn chuột vào nút new script,
một hộp thoại mới xuất hiện cho phép
chọn lựa bất cứ loại script mẫu nào tìm
thấy trong thư mục template_6, hoặc
một script trống rỗng. Theo phương
pháp này chúng ta có thể chọn lựa
những script mẫu cũ hay là mới hoặc
thêm vào các mẫu script mặc định.
Các script mẫu cũ được sử dụng trong hướng dẫn này. Chúng chỉ dành
cho những game bắn súng đơn giản, và không được đề nghị trong các game
thương mại.
Các script mẫu mới thì mềm dểo và mạnh hơn, có thể dễ dàng kết hợp
với mã nguồn riêng của chúng ta và thích hợp với các game thương mại.
Để thay đổi 4 màu sương mù
(fog). Có thể thay đổi nó bằng
cách thay đổi biến fog_color
trong tập tin script.
23

Để thay đổi ánh sáng mặt trời
(sunlight), màu sắc ở xung
quanh (ambient), vòm trời
(sun azimuth), độ cao của
mặt trời (sun elevation).
2.1.2. Thực đơn edit
undo: quay lại bước sau cùng
cut: cắt phần đang chọn
copy: sao chép phần đang chọn
paste: dán
Select_None: bỏ chọn
Delete: xóa phần đang chọn
Duplicate: Tạo ra một bản sao của đối tượng được
chọn. Các đối tượng cũng có thể được nhân đôi bằng cách giữ phím [SHIFT]
và rê chuột, hoặc nhấn phím [INS] trong khi rê chuột.
Hollow Block: hàm này chỉ dành cho các khối. Nó làm trống rỗng đi một khối
đặc, phân ra nhiều khối mỏng hơn bao quanh một khu vực trống rỗng bên
trong. Lệnh này thường được sử dụng để tạo ra một căn phòng được cấu thành
từ nhiều khối hình lập phương.
CSG Subtract: làm việc giống như một vật để cắt một cái bánh. Nó khoét lỗ
bên trong các khối đặc bằng cách sử dụng đối tượng được chọn như là vật để
cắt. Nó xóa đi những phần của các khối khác mà giao với đối tượng được chọn.
Kết cấu của vật cắt được gán cho mặt phẳng bị cắt. Hàm này được sử dụng để
chặt đứt các mảnh từ các khối, hoặc tạo ra một lỗ trống giữa 2 căn phòng để
24

làm một cửa đi. Hàm này chỉ có tác dụng cho các khối và không có tác dụng
trên các nhóm và thực thể.
Chế độ Object: chỉ những loại đối tượng có thể chọn và thay đổi được.
All Objects: tất cả các đối tượng đều có thể được chọn và thay
đổi
Group: chỉ các nhóm đối tượng mới được chọn và thay đổi
Block: chỉ các khối mới có thể được chọn và thay đổi
Entity:chỉ các thực thể mới có thể được chọn và thay đổi
Start: chỉ những vị trí mới có thể được chọn và thay đổi
Light: chỉ những nguồn sáng mới có thể được chọn và thay đổi
Model: chỉ những mô hình mới có thể được chọn và thay đổi
Sound: chỉ những đối tượng âm thanh mới có thể được chọn và thay đổi
Path: chỉ những đối tượng đường dẫn (path) mới có thể được chọn và thay đổi
Find Object: Hàm này cho phép xác định một khối nào đó, mà là nguyên nhân
của một thông điệp lỗi hoặc cảnh báo trong quá trình BUILD. Chỉ tiến đến khối
có số được phát sinh ra trong quá trình build. Nếu khối đó được chứa trong một
nhóm thì tất cả nhóm sẽ được đánh dấu, và chúng ta có thể sử dụng lệnh scope
down và lặp lại lệnh Find Object để tìm kiếm lại khối này.
2.1.3. Thực đơn mode
Một chế độ trong WED đưa ra cách thức hoạt động
mặc định khác nhau của các nút chuột. Có 11 chế độ soạn
thảo khác nhau, đó là:
• Object Select
25

• Object Move
• Object Rotate
• Object Scale
• Vertex Move
• Edge Move
• Face Move
• Eye Move
• Eye Rotate
• Eye Zoom
• Walk-thru
WED luôn luôn ở trong một trong những chế độ hoạt động này. Dưới đây là sự
giải thích sự khác nhau của các chế độ này.
Object Select: chế độ này cho phép chọn một đối tượng để nhận một hành động
tiếp theo. Để chọn đối tượng, đặt con chuột trên một đối tượng và nhấn nút
chuột trái vào đối tượng cho đến khi đối tượng chuyển sang màu đỏ. Quá trình
chọn đối tượng đi từ đối tượng gần nhất đến đối tượng xa nhất nằm ở vị trí
dưới con trỏ. Chúng ta có thể chọn nhiều đối tượng bằng cách rê một hình chữ
nhật xung quanh các đối tượng đó, hoặc giữ phím [CTRL] trong khi nhấn trái
chuột vào các đối tượng. Chế độ chọn đối tượng cũng được đưa vào trong các
chế độ Object Move, Object Rotate và Object Scales. Để chọn các đối tượng
trong các chế độ này, hãy nhấn trái chuột và không di chuyển chuột.
Object Move: Chế độ này cho phép thay đổi các đối tượng được chọn. Để di
chuyển một đối tượng, nhấn trái chuột để chọn một đối tượng trong cửa sổ thiết
kế, rê nó đến vị trí mới và thả chuột ra. Chúng ta cũng có thể di chuyển một đối
tượng bằng các phím di chuyển. Chúng ta chỉ có thể di chuyển đối tượng song
26

song với cửa sổ thiết kế. Khi Snap được kích hoạt trên thanh bar, đối tượng chỉ
có thể di chuyển theo tọa độ gốc (World Snap), theo gốc tọa độ của một nhóm
(Local snap), hoặc theo gốc tọa độ của riêng đối tượng (Delta snap). Nút Move
Restrict trên thanh bar hạn chế sự di chuyển theo hướng dọc và hướng ngang.
Giữ phím [INS] trong khi di chuyển để tạo ra một bản sao của đối tượng ở vị trí
của con chuột.
Object Rotate: Chế độ này cho phép thay đổi hướng của đối tượng được chọn.
Để quay một đối tượng, hãy nhấn trái chuột vào đối tượng đó trên cửa sổ thiết
kế, rê nút trái hoặc phải chuột và thả ra. Việc này sẽ làm cho đối tượng quay
theo hướng ngược chiều kim đồng hồ và cùng chiều kim đồng hồ trong mặt
phẳng song song với cửa sổ. Chúng ta cũng có thể quay các đối tượng bằng các
phím mũi tên.
Object Scale: Chế độ này cho phép thay đổi kích thướt của các đối tượng.
Tương tự như Object Move và Rotate, chúng ta có thể thay đổi kích thướt của
một đối tượng bằng cách: chọn đối tượng, rê và thả chuột theo ý muốn. Theo
mặc định, tại một thời điểm, WED sẽ giới hạn chỉ thay đổi kích thướt theo hai
chiều. 2 chiều này được xác định bởi các trục của mặt phẳng song song với cửa
sổ. Khi thay đổi kích thướt của một nhóm các đối tượng, chỉ kích thướt của các
khối trong nhóm đó mới được thay đổi. Các thực thể chỉ có thể thay đổi kích
thướt theo cách riêng. Nút Axis Restriction trên thanh bar sẽ hạn chế sự thay
đổi kích thướt theo hướng dọc hoặc hướng ngang. Nếu phím [CTRL] được giữ
trong lúc rê chuột, thì kích thướt của đối tượng sẽ được thay đổi bằng nhau theo
2 hướng.
Vertex Move: hàm này chỉ dành cho các khối hoặc cách đối tượng đường dẫn
(path). Nó cho phép thay đổi hình dạng của một khối bằng cách thay đổi vị trí
của các đỉnh. Trong chế độ này, các đỉnh của khối được chọn sẽ được hiển thị
màu vàng. Để di chuyển một đỉnh, nhấn trái chuột vào đỉnh đó và rê đến vị trí
27

mới. Khi biên dịch map, tất cả các khối đặc phải có hình dạng lồi. Chúng ta
không thể thay đổi vị trí của một đỉnh mà làm cho khối có hình dạng lõm. Điều
này xảy ra khi chúng ta rê một đỉnh ra khỏi mặt phẳng của bề mặt. Trong
trường hợp này, WED sẽ phát sinh ra một lỗi. Nếu nhấn vào nút Ignore thì khối
có dạng không hợp lệ này sẽ bị giữ lại và việc này có thể tạo ra nhiều lỗi trong
map – vì thế đừng nên mạo hiểm. Bằng không WED sẽ chuyển khối trở lại
trạng thái gốc.
Face Move: Hàm này chỉ dành cho các khối. Nó cho phép di chuyển một bề
mặt của một khối đến vị trí khác. Trong chế độ này, các điểm màu vàng xuất
hiện ở giữa tất cả các bề mặt của nó. Để di chuyển một mặt, nhấp chuột phải
vào điểm màu vàng và kéo rê nó đến vị trí mới. Khi sử dụng chế độ Snap,
chuyển đến Delta Snap để tránh tình trạng làm méo mó các khối. Di chuyển
một mặt có thể làm méo mó một khối, làm cho nó có hình dạng lõm không có
giá trị. Trong trường hợp này WED sẽ phát sinh ra một lỗi. Nếu nhấn vào nút
Ignore thì khối có dạng không hợp lệ này sẽ bị giữ lại và việc này có thể tạo ra
nhiều lỗi trong map – vì thế đừng nên mạo hiểm. Bằng không WED sẽ chuyển
khối trở lại trạng thái gốc.
Eye Move: Chế độ này thay đổi vị trí của con mắt ảo đang nhìn vào cửa sổ thiết
kế. Theo mặc định, tất cả các tiêu điểm của 4 cửa sổ đều nằm tại một điểm
trong không gian. Nếu di chuyển một khung nhìn của một cửa sổ thiết kế, thì
khung nhìn của tất cả các cửa sổ thiết kế khác sẽ tự động cập nhật theo tiêu
điểm mới. Để di chuyển vị trí tiêu điểm này, nhấn chuột trái và kéo rê chuột
trong bất kì cửa sổ nào. Sự di chuyển này chỉ nằm trong mặt phẳng song song
với cửa sổ. Để di chuyển tiêu điểm tiến tới và lùi ra trong trong khung nhìn 3D,
nhấp phải và kéo rê chuột tới và lùi ra trong cửa sổ thiết kế 3D. Chúng ta cũng
có thể dùng phím mũi tên để di chuyển vị trí của tiêu điểm.
28

Eye Rotate: Chế độ này cho phép thay đổi hướng của khung nhìn trong cửa sổ
thiết kế 3D. Có 2 cách thực hiện. Cách thứ nhất là quay tròn khung nhìn xung
quanh tiêu điểm thiết kế. Vị trí của con mắt ảo thay đổi nhưng vị trí của tiêu
điểm thiết kế thì không. Vì thế cách thực hiện này sẽ không có tác dụng trong
cửa sổ 2D. Bằng cách nhấp trái và kéo rê chuột trong cửa sổ thiết kế 3D. Mặc
định, chế độ này sử dụng giao diện quả cầu thạch anh, thì hành động quay sẽ
trông giống như việc quay một quả cầu thạch anh xung quanh tiêu điểm. Nếu
tùy chọn Invert Mouse được kích hoạt trong cửa sổ cấu hình (config), thì chế độ
này sẽ sử dụng tương tác quay theo quỹ đạo. Lúc đó, chúng ta sẽ di chuyển vị
trí của con mắt qua trái và phải xung quanh vị trí tiêu điểm. Cách thứ 2 là con
mắt của khung nhìn 3D vẫn nằm ở vị trí đó, nhưng khung nhìn sẽ nhìn lên, nhìn
xuống, nhìn trái, nhìn phải. Nếu tùy chọn View/Lock Views được chọn, chế độ
này sẽ đưa ra một tiêu điểm thiết kế mới dựa trên hướng của khung nhìn mới,
và cập nhật các khung nhìn 2D có liên quan. Để quay khung nhìn, nhấn phải và
kéo rê chuột trong cửa sổ thiết kế 3D.
Eye Zoom: Chế độ này cho phép phóng to hoặc thu nhỏ khung nhìn 2D. Nhấp
trái chuột trong bất kì cửa sổ nào và kéo rê chuột lên và xuống. Trong khung
nhìn 3D, chế độ này cho phép tăng và giảm khoảng cách giữa vị trí con mắt của
khung nhìn 3D với vị trí của tiêu điểm.
Walk-thru: Chế độ này cho phép di chuyển khung nhìn 3D trong toàn bộ khung
cảnh thiết kế sử dụng giống như camera Fly-thru. Trong chế độ này, chúng ta
có thể sử dụng chuột để nhìn trái, phải, trên, dưới và di chuyển bằng cách dùng
các phím mũi tên hoặc nút phải chuột. Giữ [shift] để nhân đôi tốc độ. Phím
[Home] và phím [End] cho phép di chuyển theo chiều dọc. [Pgup], [PgDn],
Left/Right cho phép rẽ xung quanh trục chính. Ấn phím [ESC], [SPACE], hoặc
[ENTER] bất cứ lúc nào muốn thoát khỏi chế độ WalkThrough.
2.1.4. Thực đơn Object
29

Grouping: Thực đơn con – Nhóm và giới hạn lại các đối
tượng, đây chính là đặc trưng hướng đối tượng của WED.
Khi nhóm và giới hạn lại, chúng ta có thể xem nhiều nhóm
như là những đối tượng có thực. Chúng ta có thể nhóm các
đối tượng bằng cách sử dụng các lệnh theo sau:
Add To: Sử dụng lệnh này để thêm những đối tượng được
chọn vào một nhóm. Màu của các đối tượng được chọn sẽ
chuyển sang màu da cam để chúng ta biết rằng đối tượng
đã được đánh dấu chuẩn bị gom thành nhóm.
Finish: Lệnh này nhận ra các đối tượng đã được đánh dấu
hoặc được chọn và nhóm chúng lại thành một đối tượng mới.
Ungroup: Lệnh này sẽ phân nhóm được chọn ra thành các đối tượng riêng
rẽ.
Scope: Thực đơn con - việc này tương tự như tập hợp các thư mục trong một hệ
thống tập tin. WED định nghĩa giới hạn của một đối tượng là tập hợp các thành
phần con của nó. Nếu chúng ta muốn thay đổi các thành phần con của một đối
tượng, đầu tiên chúng ta cần phải nhảy tới phạm vi của đối tượng này. WED
cung cấp 2 lệnh scope up và scope down để thực hiện các mục tiêu này. Giới
hạn dưới cuối cùng là các bề mặt của một khối, trong khi giới hạn trên cùng thì
luôn luôn là toàn bộ map.
Scope up: lệnh này sẽ thoát ra khỏi phạm vi của một đối tượng. Nếu phạm
vi hiện thời là toàn bộ level, và có nhiều đối tượng trong phạm vi hiện thời,
WED sẽ tạo ra một phạm vi mới và đặt tất cả các đối tượng vào một nhóm
mới. Hàm này tương tự với lệnh chuyển về thư mục cha trong hệ thống tập
tin.
30

Scope down: lệnh này cho phép tiến vào phạm vi của một nhóm các đối
tượng. Mặc định, tất cả mọi thứ, ngoài đối tượng được chọn sẽ không xuất
hiện trong cửa sổ thiết kế. Scope down sẽ dấu đi những thông tin không cần
thiết, tức là dấu đi phần còn lại của khung cảnh mà chỉ làm việc với đối
tượng được chọn. Hàm này tương tự với lệnh chuyển về thư mục con trong
hệ thống tập tin.
Add Cube: Thực đơn con này cung cấp nhiều khối có dạng hình lập phương mà
chúng ta sẽ đặt vào level.
Add Hollow Cube: Thực đơn con này cung cấp một vài hộp đã được làm rỗng
mà ta sẽ đặt vào level.
Add Primitive: Thực đơn con này cung cấp một vài khối cơ sở mà chúng ta có
thể sử dụng trong WED. Những khối cơ sở này gồm có các loại: hình lập
phương, hình cầu, hình tam giác, và các hình lăng trụ có số cạnh khác nhau.
Add Prefab: Thực đơn con này đưa ra khoảng 500 loại đối tượng, được sắp
xếp vào một vài nhóm, được sử dụng trong WED. Đồ đạc, cửa, xe cộ hoặc các
kiến trúc có giá trị khác. Các đối tượng được làm sẵn nằm trong thư mục
PREFAB và có thể được thêm vào bởi người dùng.
Add Light: đặt một nguồn sáng tĩnh vào map. Chúng ta có thể thay đổi màu sắc
(chỉ trong một vài phiên bản) và độ sáng bằng cách thay đổi các giá trị Red,
Green, Blue (từ 0..25) và phạm vi của nguồn sáng. Nếu Red và Green được gán
là 0 thì ánh sáng có màu trắng thì độ sáng của nó được thay đổi bởi giá trị Blue.
Add Sound: Đặt một tài nguyên âm thanh tĩnh (tập tin WAV) vào map. Chúng
ta có thể điều chỉnh độ lớn và phạm vi của tài nguyên âm thanh.
Add Position: Đặt một vị trí vào map. Vị trí có thể được xác định trong lúc viết
mã. Nếu không có thực thể người chơi, vị trí đầu tiên được sử dụng là vị trí bắt
đầu của camera.
31

Add Map Entity: Đặt một thực thể map (tập tin WMB) như cửa, thang máy, sân
ga. Thực đơn hiện ra tất cả các thực thể map trong thư mục map và trong các
thư mục con. Chúng ta có thể tự tạo ra một thực thể thể map bằng cách mở một
đối tượng đã được làm sẵn, và BUILD để tạo ra tập tin WMB. Khi thêm một
thực thể mới vào WED sẽ đặt chúng vào chính giữa 4 cửa sổ thiết kế.
Add Model: đưa một thực thể mô hình (tập tin MDL) vào map, là các thực thể
có thể chuyển động. Thực đơn hiện ra tất cả các thực thể mô hình trong thư
mục map và trong các thư mục con. Chúng ta có thể tạo ra một thực thể mô
hình bằng cách sử dụng chương trình thiết kế các mô hình, MED.
Add Terrain: đưa một thực thể địa hình (tập tin HMP; không được hỗ trợ trong
tất cả các phiên bản). Thực thể địa hình có thể được tạo ra bằng chương trình
MED. Thực thể địa hình có thể được di chuyển và thay đổi kích thướt nhưng
không quay được.
Add Sprite: đưa một thực thể cảnh (tập tin PCX), như đồng cỏ, cây…Thực đơn
hiện ra tất cả các thực thể cảnh trong thư mục map và trong các thư mục con.
Có thể sử dụng các chương trình vẽ hình, như Paint Shop Pro, để tạo ra một
thực thể cảnh. Nhớ lưu tâp tin PCX theo định dạng có màu sắc thật.
Add Path: Thêm vào một đường dẫn, để các thực thể hành động sử dụng
(không được hỗ trợ trong mọi phiên bản). Chúng ta có thể đặt tên cho đường
dẫn trong properties; còn không thì một tên mặc định được tạo ra. Trong chế
độ Vertex Mode, các điểm trong đường dẫn có thể được tạo thêm hoặc xóa đi.
Load Entity: Đưa một tập tin thực thể từ một thư mục nào đó, đưa nó vào map,
và sao chép nó vào thư mục map. Cẩn thận nếu không nó sẽ đè lên thực thể có
cùng tên.
Load Sound: Đưa một tập tin WAV từ một thư mục nào đó, đưa nó vào map, và
sao chép nó vào thư mục map.
32

Load Prefab: Đưa tập tin WMP như là đối tượng kiểu khối vào khung cảnh
thiết kế.
Save Prefab: Lưu khối đối tượng được chọn vào tập tin WMP, để sử dụng
trong các khung cảnh thiết kế khác.
2.1.5. Thực đơn Texture
Apply to Object: Lệnh này gắn kết cấu được chọn trong
cửa sổ texture đến tất cả các mặt của đối tượng được
chọn. Hoặc chúng ta có thể nhấp double vào kết cấu được
chọn trong cửa sổ kết cấu.
Texture Bookmarks: Lệnh này mở ra một cửa sổ cho phép cất giữ các kết cấu
ưa thích trong cửa sổ kết cấu.
Texture Manager: Lệnh này đưa ra một hộp thoại, trên đó chúng ta có thể thêm
hoặc xóa đi bộ kết cấu WAD trong thanh
texture. Trên đó có các tùy chọn sau:
New WAD: Tạo ra một tập tin WAD rỗng, để
chúng ta có thể thêm các kết cấu mới vào thanh
texture.
Add WAD: Thêm một tập tin WAD vào texture.
Add Folder:Thêm tất cả các tập tin WAD trong
thư mục được chọn.
Save WAD: Lưu tập tin WAD sau khi nó đã bị thay đổi như thêm vào hoặc bỏ
đi một kết cấu nào đó.
Build WAD: Tạo ra một tập tin WAD mới chứa đựng tất cả các kết cấu được sử
dụng trong lúc thiết kế.
Remove WAD: Xóa đi một kết cấu trên thanh kết cấu.
33

2.1.6. Thực đơn View
GXL Properties: Danh sách các thuộc tính của thư
viện đồ họa được sử dụng trong khung nhìn 2D và 3D.
Toolbars: Hiển thị hoặc ẩn đi một toolbar nào đó hoặc
cửa sổ dự án.
Add View: Thêm một cửa sổ khung nhìn mới ngoài 4
cửa số thiết kế đã có.
Wireframe: Chọn loại biểu diễn trong cửa sổ 3D theo
dạng khung dây.
Solid: Chọn loại biểu diễn trong cửa sổ 3D theo dạng khối đặc.
Textured: Chọn loại biểu diễn trong cửa sổ 3D theo dạng kết cấu.
Goto Center: Đưa tiêu điểm của 4 cửa sổ thiết kế đến phạm vi của đối tượng
đang chọn.
Lock Views: Mặc định, tiêu điểm của 4 cửa sổ thiết kế nằm trên cùng một
điểm trong không gian. Khi thay đổi vị trí của một khung nhìn, các khung nhìn
thiết kế khác cũng sẽ tự động cập nhật vị trí của chúng tùy vào tiêu điểm mới.
Lệnh Lock Views sẽ cho phép hoặc vô hiệu đặc điểm này. Khi vô hiệu, các cửa
sổ thiết kế này có thể di chuyển một cách độc lập, không phụ thuộc vào nhau.
Decrease View Depth: làm cho dễ dàng thấy cửa sổ thiết kế hơn, WED sẽ
không hiển thị những phần của khung cảnh nằm ngoài phạm vi nào đó. Lệnh
này sẽ làm giảm phạm vi tầm nhìn này.
Increase View Depth: làm cho dễ dàng thấy cửa sổ thiết kế hơn, WED sẽ không
hiển thị những phần của khung cảnh nằm ngoài phạm vi nào đó. Lệnh này sẽ
tăng phạm vi tầm nhìn này.
2.1.6. Thực đơn help
34

Tutorial: mở tập tin hướng dẫn sử dụng 3D GameStudio.
About WED: Thông tin về WED và phiên bản GameStudio.
2.2. Giao diện sử dụng
4 cửa sổ thiết kế hiển thị khung cảnh mà chúng ta xây dựng từ 4 khung nhìn
khác nhau theo các hướng: hướng trên, sau lưng, bên cạnh và ở một góc tùy ý
trong cửa sổ 3D. Theo mặc định, 4 khung nhìn có tiêu điểm nằm trên cùng một
điểm trong không gian. Có thể cuộn một cửa sổ bằng cách nhấp phải và kéo rê
chuột, và phóng to, thu nhỏ bằng nút lăn chuột hoặc giữ phím [SHIFT] và rê
nút chuột phải. Khi di chuyển một khung nhìn trong cửa sổ WED sẽ tự động
cập nhật các khung nhìn khác tùy vào vị trí của tiêu điểm mới. Chúng ta có thể
khóa hoặc mở khóa khung nhìn của 4 cửa sổ bằng cách chọn Lock Views.
Engine sử dụng hệ tọa độ thuận tay phải trong lúc thiết kế. Để hiểu được hệ
thống này, hãy tưởng tượng về con đường đi hằng ngày. Chiều dương của trục
X chỉ về hướng đông, và hướng đến cạnh bên phải trong cửa sổ khung nhìn
trên. Chiều dương của trục Y chỉ về hướng bắc, và hướng lên trên trong cửa sổ
khung nhìn trên. Còn trục Z thì chỉ chiều cao của khung cảnh. Chiều dương của
trục Z tiến ra bên ngoài cửa sổ khung nhìn trên và hướng về phía chúng ta. Cửa
sổ sau lưng quy định khung nhìn hướng đến hướng bắc, và cửa sổ bên cạnh quy
định khung nhìn hướng đến hướng tây. Hệ thống lưới của cửa sổ không chia
lưới tọa độ theo bội số của 10, như chúng ta mong đợi mà được chia theo bội số
của 8 (có thể điều chỉnh trong Preference). Theo phương pháp này chúng ta có
thể dễ dàng tạo ra một đối tượng có chính xác cùng kích thướt với kết cấu của
mình, thông thường kích thướt của nó chính là bội số của 2 (như 64x64,
128x128, hoặc 256x256). Sử dụng mạng lưới mặc định và kích thướt của kết
cấu, ví dụ với một kết cấu 128x128 điểm sẽ bao phủ 128 hình lập phương đơn
vị mà không cần phải lợp thêm vào nữa. Kích thướt của một hộp lưới nhỏ, và
số hộp nhỏ trên hộp lưới lớn, được cho biết trên thanh tiêu đề.
35

Trong cửa sổ 3D chỉ là một khung nhìn quay xung quanh tiêu điểm thiết kế
trong không gian. Cửa sổ 3D có thể được biểu diễn ở dạng khung dây, rắn,
hoặc kết cấu để xem trước. Cách biểu diễn này có thể được thay đổi bằng cách
chọn thực đơn View/Render. Trong Preferences chúng ta có thể chọn giữa phần
mềm biểu diễn cơ sở (GXL_BASE) và biểu diễn DirectX 8.1(GXL_DX81) cho
khung nhìn 2D và khung nhìn 3D. Tất cả chúng cũng đều hiển thị màu sắc của
nguồn sáng và đưa ra một khung nhìn khá thực cho toàn cảnh, tuy nhiên nó
không có cùng chất lượng như sản phẩm cuối cùng. Nếu phần mềm biểu diễn là
DirectX, chúng ta có thể điều chỉnh các tham số biểu diễn bằng cách nhấn phải
chuột vào cửa sổ và chọn GXL_Properties. Lúc này chúng ta có thể điều chỉnh
tác dụng của mặt trời, ánh sáng được biểu diễn trong cửa sổ 3D.
Chúng ta có thể đưa các khung nhìn của các cửa sổ thiết kế trở về trạng thái
ban đầu bằng lệnh View/Home. Cửa sổ thiết kế có giới hạn theo chiều sâu.
Nhiều đối tượng của khung cảnh sẽ không được hiển thị nếu nó vượt ra khỏi
phạm vi nào đó của khung nhìn. Nó rất hữu ích khi chúng ta xây dựng một
level quá lớn, bởi vì nó có thể làm giảm số đối tượng được hiển thị trên màn
hình. Chúng ta có thể điều chình giá trị khoảng cách trong GXL_Properties
hoặc sử dụng lệnh View/Decrease ViewDepth và View/Increase View Depth.
Để dọn dẹp cửa sổ thiết kế trong lúc xây dựng level, chúng ta có thể tắt việc
hiện thị các thực thể trong map. Chúng ta có thể việc này bằng cách bỏ chọn
tùy chọn Show Entities trong cửa sổ Preferences.
2.3. Cửa sổ dự án
2.3.1. Tab đối tượng
Cửa sổ này hiển thị danh sách tất cả các đối tượng ở dạng cây trong toàn bộ
level. Đối tượng được chọn được làm nổi bật trong cây danh sách. Chúng ta có
thể chọn một đối tượng bằng cách nhấp double vào nó. Có thể chọn nhiều đối
36

tượng trong cây đối tượng bằng cách giữ phím [CTRL] trong khi nhấp vào các
đối tượng. Khi nhấp phải vào một đối tượng sẽ đưa ra tùy chọn sau đây:
Scope to: Giới hạn lại một nhóm trong cửa sổ
2D và 3D.
Goto Object: Trung tâm của khung nhìn được
chọn bao quanh đối tượng được chọn.
New Group: Tạo ra một nhóm mới bên trong
nhóm hiện tại.
Ungroup: Đưa các đối tượng ra khỏi nhóm
hiện tại.
Cut/Copy/Delete: Thay đổi một đối tượng
hoặc nhóm đối tượng.
Render style:
Chọn loại biểu diễn (khung dây, đặc, kết cấu) của đối
tượng hoặc nhóm. Cũng cho phép nó không được chọn
(disable) và di chuyển đối tượng, và làm cho nó không thể
nhìn thấy được (invisible) trong khung nhìn.
Đối tượng hoặc nhóm các đối tượng có thể được bỏ qua trong quá trình biên
dịch, để tăng tốc độ biên dịch để kiểm tra các phần khác trong toàn level. Để
làm điều này, chúng ta có thể nhấp chuột phải vào đối tượng và chọn Render
Style->Ignore
Properties: mở ra cửa sổ thuộc tính của đối tượng.
37

2.3.2 Tab Views
Cửa sổ này hiển thị một danh sách các khung nhìn đã được lưu, và cho phép
lưu vị trí một khung nhìn nào đó bằng cách nhấp phải chuột.
Add View Setting: vị trí mới của khung
nhìn.
Save View Settings: lưu vị trí của khung nhìn.
Restore View Setting: Gọi lại vị trí của khung nhìn.
Delete: Xóa vị trí của khung nhìn đang chọn.
2.3.3. Tab Texture
Cửa sổ này hiển thị tất cả các kết cấu từ các tập tin kết
cấu đã được xác định trong texture manager. Chúng ta có
thể mở một bộ các kết cấu WAD bằng cách nhấp vào nó,
thay đổi kích thướt cửa số texture bằng cách kéo rê chuột ở
cạnh phía dưới, và có thể cuộn một WAD bằng thanh cuộn
nằm ở phía bên phải. Nếu con chuột đang nằm trên một
texture nào, thì tên của nó sẽ được hiển thị trong cửa sổ cửa
sổ Texture. Khi nhấp vào một kết cấu thì hình ảnh của nó sẽ được xuất hiện ở
38

cửa sổ Texture, chúng ta có thể thay đổi các thuộc tính của kết cấu bằng cách
nhấp phải chuột vào nó và chọn Setting. Khi nhấp double chuột vào một kết
cấu, thì nó sẽ xuất hiện trong cửa sổ Object và gắn đến tất cả các mặt của khối
đang chọn. Muốn thay đổi kết cấu của một khối map, đầu tiên chọn khối, rồi
cuộn đến cửa sổ kết cấu, nhấp trái chuột vào kết cấu mong muốn, rồi nhấp
chuột phải vào nó và chọn lệnh apply.
Hộp thoại cũng cho phép thêm vào hoặc xóa đi một kết cấu
trong bộ sưu tập các kết cấu WAD. Nhấp chuột phải vào một kết
cấu đưa ra những tùy chọn sau đây:
Apply: Gắn kết cấu vào đối tượng được chọn.
Settings: Xuất hiện bảng điều chỉnh các thuộc tính của một kết
cấu.
Tên, độ phân giải, độ sâu của màu sắc.
x – y offset: độ dịch chuyển của kết cấu.
x – y scale: kích thướt của kết cấu.
Angle: góc quay của kết cấu.
Ambient: điều chỉnh cường độ ambient.
Albedo: Albedo dưới 5 để điều chỉnh màu sương mù, trên 5 chỉ cường độ suất
phân chiếu.
Flags Được sử dụng trong lúc viết mã.
Smooths Để điều chỉnh độ mịn của bóng.
Mirror Làm cho kết cấu có độ phản chiếu lại.
Shaded kết cấu vô hình
Flat kết cấu phẳng
39

Sky kết cấu bầu trời
Turbulence kết cấu chuyển động
None không có kết cấu
Add Teture: sẽ thêm một kết cấu PCX, BMP, TGA đến WAD, để làm kết cấu
cho các bề mặt. Tên kết cấu được tạo từ các kí tự thông thường, số, gạch dưới
(không chứa các kí tự đặc biệt và khoảng cách). Các trường hợp ngoài lệ: nếu
một kết cấu được đặt tên bắt đầu là một kí tự ‘+’, theo sau là 1 số, thì kết cấu
này là một hoạt ảnh với chu trình từ ‘+0…+9’. Nếu tên bắt đầu là ‘*’ thì đây
chính là một kết cấu chuyển động hỗn loạn có thể qua lại được; nếu nó bắt đầu
với sky, thì nó chính là kết cấu loại bầu trời.
Remove Texture: sẽ xóa kết cấu đang chọn ra khỏi WAD.
Rename: đổi tên kết cấu đang chọn.
Extract Texture: lưu kết cấu được chọn vào tập tin BMP hoặc PCX.
Add to Bookmarks: thêm kết cấu được chọn vào tập các kết cấu được làm dấu.
Save WAD: Lưu tập tin WAD. Chú ý rằng tập tin WAD trong
GameStudio có định dạng khác với định dạng tập tin WAD trong Quake. Tuy
nhiên, WED đều có thể truy cập cả hai loại theo cách thức riêng.
Show Texture: Đưa ra nhiều cách thức hiển thị của kết cấu.
1:1 hiển thị kết cấu cùng với
kích thướt gốc của nó
64x64 hiển thị kết cấu có kích
thướt là 64x64
32x32 hiển thị kết cấu có kích
thướt là 32x32
40

Texture Name hiển thị tên của kết cấu
dưới ảnh của nó
Texture Name
Only
chỉ hiển thị tên của kết
cấu
2.3.4. Tab Resource
Cửa sổ này hiển thị danh sách tất cả các tập tin và mã nguồn trong game.
Chúng ta có thể xem mã nguồn hoặc nhấp double chuột vào một tập tin nào đó
để mở nó bằng trình soạn thảo của nó.
2.4. Cửa sổ Bookmark
chúng ta sử dụng cửa sổ này để đánh dấu những kết cấu trong cửa sổ
texture. Để mở cửa sổ này chọn lệnh Textures/Bookmarks. Để đánh dấu một
kết cấu thường sử dụng, nhấp phải chuột vào kết cấu
trong cửa sổ kết cấu rồi chọn lệnh Add to
Bookmarks.
2.5. Thuộc tính của khối
Properties
Block: Cho phép đặt tên cho một khối.
Texture Lock: kết cấu được giữ thẳng hàng trong lúc di chuyển khối. Chúng
không được giữ thẳng hàng trong lúc quay và thay đổi kích thướt.
Passable: Được dùng khi muốn tạo ra một môi trường chất lỏng. Để cho
khối có thể qua lại được và có thể thấy được bề mặt có nó từ bên trong.
Invisible: Chướng ngại vật không nhìn thấy được. Chú ý rằng những khối
không nhìn thấy thì không thể được dò tìm bởi lệnh trace(). Nếu muốn một
41

khối khối nhìn thấy nhưng có thể được dò tìm bằng lệnh trace() thì hãy sử dụng
cờ none.
Surface/Texture
Surface: Cho phép gắn một kết cấu khác đến từng bề mặt của khối được chọn,
và điều chỉnh các tham số của bề mặt này. sử dụng nút >> và nút << để chuyển
đến bề mặt mong muốn. Bề mặt được chọn sẽ có màu vàng trong khung nhìn
hiện tại. Để gắn một kết cấu khác đến bề mặt này, chọn một kết cấu mới trong
cửa sổ kết cấu, nhấp phải chuột và chọn apply. Sử dụng X/Y offset, và X/Y scale
để sửa lại cho kết cấu thẳng hàng với cạnh bề
mặt nếu cần. Chúng ta có thể quan sất kết quả
trong khung nhìn 3D. Điều chỉnh Angle để
quay hướng của kết cấu trên bề mặt. Ô flags
cho phép thay đổi các thuôc tính của bề mặt.
Ambient: làm tối hoặc chiếu sáng kết cấu của khối, -100..+100 (mặc định là
0).
Albedo/Fog: hệ số phản xạ của mặt trời (10..100, mặc định là 50), hệ số phản
xạ của gương hoặc màu sắc (1..4).
Shaded: kết cấu thông thường có bóng mờ với ánh sáng tĩnh và ánh sáng
động.
Flat: kết cấu phía bên ngoài, không có bóng mờ. Bóng thẳng theo góc
chiếu sáng của mặt trời.
Sky: bề mặt bầu trời nhiều lớp, cần thiết cho hộp bầu trời bao quanh
khung cảnh. Là mặc định nếu tên kết cấu bắt đầu là ‘sky’.
Turbulence: được dùng cho các chất lỏng, kết cấu này được dùng cho nước
hoặc dung nham. Là mặc định nếu tên kết cấu bắt đầu là ‘*’.
42

None: bề mặt không được hiển thị.
Flag1..7 thông thường được sử dụng trong lúc viết mã.
Mirror: xác định bề mặt này có chiều ngang hoặc dọc (chỉ sử dụng trong
các phiên bản chuyên nghiệp).
Possition: cho phép chỉnh sửa bằng số để
di chuyển, quay, kích thướt của khối. Các giá
trị quay và kích thướt có thể nhập vào nhưng
không được thay đổi.
Object: Hiển thị vị trí cục bộ (trong một
nhóm) và toàn cục của một khối.
2.6. Thuộc tính của thực thể
Nhấp phải chuột vào thực thể, rồi
chọn Properties để hiển thị hộp thoại
này. Tùy chọn bên phải xuất hiện:
Name: Mỗi thực thể có một tên
duy nhất, để xác định thực thể trong lúc viết mã. Tên này được phát sinh tự
động nhưng cũng có thể được sửa lại (tối đa 20 kí tự).
File: Tên tập tin địa hình, map, mô hình, ảnh của thực thể (tối đa 32 kí
tự).
Ambient: giảm hoặc tăng độ sáng cho thực thể (-100...+100).
43

Flags: Transparent – làm cho thực thể trở nên trong mờ.
Invisible – thực thể không nhìn thấy được, nhưng nó vẫn còn là một
chướng ngại vật.
Shadow – thực thể sẽ có bóng nửa trong suốt trên nền đất.
Overlay – chuyển kết cấu của các mô hình hoặc map từ đen sang
trong suốt.
Flare – sự trong suốt của một mô hình hoặc một cảnh phụ thuộc vào
độ sáng của nó.
Bright – tăng độ sáng của một mô hình hoặc cảnh trong mờ, cho các
ngọn lửa hoặc tia sáng.
Metal – làm cho vỏ bên ngoài của thực thể có thể phản xạ lại khi bị
ánh sáng mặt trời chiếu vào.
Action: Hành vi của thực thể, nhận
được từ mã nguồn.
Flag1..Flag8: Có nhiệm vụ là làm
một công tắc, phụ thuộc vào hành vi
của thực thể trong mã nguồn. Chúng
có thể xuất hiện dưới tên gọi khác
được định nghĩa bởi khai báo define
trong mã nguồn.
Skill1..Skill20: chứa các giá trị kiểu
số, phụ thuộc vào hành vi của thực thể
trong mã nguồn. Chúng có thể xuất
hiện dưới tên gọi khác được định
44

nghĩa bởi khai báo define trong mã nguồn.
Position: Cho phép di chuyển, quay và thay
đổi kích thướt của thực thể bằng cách nhập
giá trị vào các ô position, angle, scale.
Object: hiển thị vị trí cục bộ (trong một
nhóm) và vị trí toàn cục của thực thể.
3.Thiết kế một map
Không những về mặt thẩm mỹ mà còn cả những kỹ thuật phát sinh cũng
phải được đề cập đến trong lúc thiết kế một level. Một cấu trúc cây BSP chứa
tất cả các bề mặt mà cắt với các mặt khác. Các cạnh và đỉnh không được nhận
từ WED, mà được tính toán từ các phần giao nhau. Ưu điểm của ý tưởng này là
chúng ta có thể sử dụng những khối trùng lắp lên nhau - những phần giao
không nhìn thấy được sẽ bị bỏ đi trong quá trình xử lý, và các cạnh và đỉnh mới
sẽ tự động được thêm vào phần giao nhau. Chính vì đặc điểm này mà biên dịch
sẽ nhanh hơn, bởi vì những khối bị trùng lắp, không thấy được không được
biên dịch (những engine khác sẽ biên dịch tất cả các khối giao với nhau).
Khuyết điểm của ý tưởng này chính là khi các đỉnh tạo ra một góc quá nhỏ dẫn
đến sự chênh lệch vị trí giữa các đỉnh là rất lớn. Nếu bề mặt tiếp xúc hoặc giao
nhau tạo ra một góc rất nhỏ, sai lệch khoảng 1/100 độ có thể cách vị trí các
cạnh khoảng một vài pixel thì có thể thấy được trong level.
Với đặc điểm này, chúng ta không nên sử dụng những khối quá hẹp, quá
dài, hoặc quá nhọn. Không nên tạo ra những khối có cạnh nhỏ hơn 2 quants.
Hãy thiết kế các map có bề mặt ít nhất như có thể, và sử dụng những khối dày
như có thể. Đôi khi chúng ta không thể không sử dụng những bề mặt có góc
quá nhỏ, những vẫn có một cách thiết kế tốt và xấu để thiết kế những bề mặt
này. Ví dụ, khi thiết kế một đoạn đường dốc như thế này:
45

Thiết kế tồi: sử dụng khối quá mỏng, góc chênh lệch quá nhỏ. Và các chỗ
nối sẽ có thể giống như là những lỗ hổng.
Thiết kế tốt: sử dụng 3 khối với 15 bề mặt thay vì 5 khối với 20 bề mặt, và
sự sai lệch của một góc, khi xảy ra cũng không nhìn thấy được.
4. Thực thể
Thực thể là loại tập tin ngoài nằm ở thư mục work hoặc trong các thư mục
con của nó. Có 4 loại thực thể có thể đưa vào WED.
4.1. Thực thể mô hình
Một mô hình là một đối tượng 3D có thể chuyển động, được lưu trữ trong
tập tin ngoài MDL. Nó bao gồm một mạng lưới 3D với vỏ bao rất mịn. Mô
hình thực thể thường dùng là các đối tượng nhỏ có thể chuyển động: diễn viên,
quái vật hoặc giống như vậy. Chúng có thể được tạo ra bằng cách sử dụng
46

chương trình thiết kế mô hình, như MED, là một thành phần của 3D
gameStudio. Hầu hết tất cả các chương trình thiết kế mô hình, kể cả MED, đều
có thể hiểu các định dạng 3D khác như 3DS, X, hoặc MD2 và chuyển nó thành
mô hình MDL. Vì thế nếu muốn đưa các đối tượng, cảnh được tạo ra bởi một
chương trình khác, như Truespace®, Maya® hoặc 3D Studio MAX®. Với các
mô hình nhận được từ các chương trình như MAX hoặc MAYA có thể được tải
từ trang web GameStudio.
4.2 Thực thể Sprite
Một sprite là một hình phẳng 2 chiều, nó giống như là một hình vẽ trên một
bức tường, hoặc luôn luôn đối mặt với camera nếu cả 3 góc của nó đều là 0. Nó
được lưu trữ trong các tập tin ngoài theo các định dạng PCX, BMP, TGA và có
thể được tạo ra bằng các chương trình vẽ hình chuẩn, như PaintShop Pro hoặc
Adobe Photoshop. Loại tập tin TGA có chứa kênh alpha có thể đưa ra được giá
trị trong suốt trong từng điểm ảnh. Thực thể sprite được biên dịch nhanh hơn
các thực thể map hoặc thực thể mô hình, và rất thích hợp để sử dụng để tạo ra
các vụ nổ, nguồn sáng, ngọn lửa hoặc như thứ tương tự như vậy.
Nếu không muốn một thực thể luôn luôn di chuyển theo camera, thì cần
thiết lập các góc của nó khác 0, như 0.1 chẳng hạn. Với các sprite có thể
chuyển động, cất tất cả các khung chuyển động liên tục trong cùng một tập tin,
ví dụ như tập tin explo+7.pcx trong thư mục template. Thông thường, cần đặt 4
sprite vào một hình dạng ‘X’ để tạo ra một đối tượng giống thế giới thực như
các loại cây. Một vài chương trình làm ảnh chuyển động 3D, như VoodooT
không cho phép kích thướt của các sprite lớn hơn 256x256 điểm ảnh.
4.3 Thực thể Map
Một thực thể map là một đối tượng 3D tĩnh, được lưu trữ trong tập tin ngoài
có định dạng WMB. Thực thể map có thể được sử dụng như là các thành phần
47

của level như cửa, nền đất, các loại xe cộ. Bởi vì chúng chỉ là một map đã được
biên dịch, vì thế chúng ta có tạo ra chúng bằng trình thiết kế WED. Thí dụ,
chúng ta có thể chuyển từng map đã được làm sẵn thành một thực thể bằng
cách mở nó, thực hiện BUILD với tùy chọn Map Entity, rồi chép tập tin WMB
vào thư mục hiện tại. Chúng ta có thể tìm thấy các loại map đã được làm sẵn
như cửa, đồ đạc, xe cộ… trong thư mục con prefab. Các thực thể mô hình
(model), ảnh (sprite), địa hình (terrain) đều là như bộ phận cấu thành thực thể
map sẽ được đưa vào level khi thực thể map được đưa vào level. Như vậy, một
nhóm thực thể có thể được định nghĩa và biên dịch thành các thực thể map.
Chúng ta có thể truy cập đến các thực thể trong thực thể map bằng chỉ lệnh
map_subents.
4.4. Thực thể Địa hình (terrain)
Thực thể địa hình gồm nhiều kết cấu được ánh xạ vào mạng lưới hình chữ
nhật. Nó được tập tin ngoài HMP (không được hỗ trợ trong tất cả các phiên
bản). Giống như tên gọi thực thể địa hình có thể được sử dụng như là các thành
phần lớn hoặc nhỏ của level mà không theo bất kì quy luật nào của địa hình.
Địa hình không quay được.
4.5. Bóng
Chỉ các thực thể mô hình mới có bóng động trên mặt đất. Tuy nhiên, nếu
một thực thể không di chuyển mà không hoạt động, như cây, chúng ta nên chọn
loại bóng cho nó là bóng tĩnh. Bóng tĩnh thì mịn hơn và được biên dịch nhanh
hơn, và được hỗ trợ trong tất cả các phiên bản. Tạo ra một khối có kích thướt
và hình dạng gần giống như thực thể, đặt vào vị trí của thực thể, bật cờ detail
và chọn chế độ kết cấu cho tất cả các mặt của nó là None để cho nó không thấy
được. Khối sẽ tạo ra một bóng tĩnh trên nền đất và nó các tác dụng như một
48

chướng ngại vật, nhưng không thấy được. Có thể bật cờ passable để cho sự dò
tìm thực thể được nhanh hơn.
4.5. Thuộc tính trong suốt
Thực thể có thể trở nên trong suốt nếu bật cờ transparent hoặc cờ flare,
hoặc sử dụng ảnh có định dạng với kênh alpha cho các thực thể sprite hoặc vỏ
bao bên ngoài của thực thể.
49

Chương 3: Game Engine – Cách sử dụng MED
II. Cách sử dụng MED
MED được sử dụng để tạo hoặc chuyển đổi định dạng các mô hình hoặc các địa
hình 3D trong 3D GameStudio. Giao diện rất dễ sử dụng để tạo ra các mô hình
3D và vỏ bao bên ngoài đơn giản.
1. Trình thiết kế
Dưới đây là giao diện của MED:
Chúng ta thấy rằng 4 khung nhìn của MED rất giống 4 khung nhìn của
WED. Tuy nhiên, vì chức năng và nhiệm vụ của nó là thiết kế một mô hình
chuyển động, khác so với WED là thiết kế level, nên tương tác với người dùng
là khác. Khi kéo rê vào các thanh trong các khung nhìn thì sự cân xứng của các
khung nhìn sẽ bị thay đổi.
Khi nhấp phải vào khung nhìn 3D và chọn GXL Properties, thì thuộc tính
của nó như độ sáng và phạm vi khung nhìn có thể được thay đổi.
1.1. Các thực đơn
1.1.1. Thực đơn File
Với thực đơn file, chúng ta có thể lưu, gọi lại, nhập hoặc xuất các tập tin từ
MED.
50

New Model: Tạo ra một mô hình mới.
New Terrain:Tạo ra một địa hình mới.
Open
Save Lưu mô hình hoặc địa hình với
đến tập tin hiện trong các định dạng MDL5,
MDL7, HMP của GameStudio. Định dạng
MDL không giống như định dạng mô hình
có cung phần mở rộng trong QuakeT. Khung xương chỉ được hỗ trợ trong
định dạng MDL7.
Save As: Lưu với tên mới.
Merge: Cộng mô hình khác vào mô hình hiện tại, vì thế kết quả là sự
kết hợp của hai mô hình.
Choose Palette: Gọi một bảng màu cho các mô hình mà vỏ bọc có kết cấu kiểu
8 bit. Bảng màu có thể nhận được từ các định dạng như BMP, PCX, PAL, LMP
hoặc RAW.
Import / Append Vertices: Nhập một mô hình từ các định dạng .ASC hoặc .3DS.
Lệnh này sẽ nhập các mô hình được tạo ra từng các ứng dụng 3D như 3D
Studio. Cả hình dạng và kết cấu của các mô hình đều được đưa vào. Muốn đưa
một mô hình đã được tạo ra bởi các ứng dụng khác, đầu tiên cần đưa khung vào
trước, rồi sử dụng tùy chọn "Import Append Frames" giữ nguyên các khung.
Khi nhập một tập tin 3DS quá phức tạp, chúng ta nên chọn tùy chọn Model
Properties / Fast Prec trước khi lưu nó. Sau khi nhập theo phương pháp này,
các bản vẽ và kết cấu có thể được tạo ra bằng trình thiết kế skin.
Import / Append Frames: Đưa vào một vài khung chuyển động của một mô
hình. Để cho các khung theo đúng thứ tự, đầu tiên, chọn khung cuối cùng, rồi
51

giữ phím SHIFT, rồi chọn tập tin đầu tiên trong nhóm muốn đưa vào, rồi nhấn
OK.
Import / Frame Names From Text : Lệnh này nhập các khung có tên trong tập
tin kiểu text. Để tạo ra một tập tin kiểu text, đặt tên một khung trên một dòng
không có khoảng trống.
Export / Q1 MDL: Xuất mô hình ra định dạng Quake 1 MDL.
Export / MD2: Xuất mô hình ra định dạng Quake 2 MDL, là định dạng
được sử dụng rất phổ biến và là phần thứ 3 của trình thiết kế mô hình. Sẽ xuất
hiện một hộp thoại lưu các tập tin có định dạng .MD2 này trong đó cần nhập
đường dẫn để lưu tập tin skin của mô hình.
Export / AQM: Xuất mô hình ra định dạng .AQM, là định dạng được sử
dụng trong trình thiết kế mô hình Quake 2.
Export / Frame to ASC: Xuất khung hiện thời ra định dạng .ASC.
Export / Model to ASC: Xuất mô hình hiện thời ra nhiều định dạng .ASC tùy
thuộc vào số khung của nó.
Export / Frame to 3DS: Xuất mô hình hiện thời ra định dạng .3DS (không có
skin).
Export / Model to 3DS: Xuất mô hình hiện thời ra nhiều định dạng .3DS tùy
thuộc vào số khung của nó.
History: Chỉ 8 tập tin đã mở.
Exit: Thoát khỏi chương trình.
52

Open:
Mở hoặc đưa một mô hình hoặc địa hình. Danh sách các tập tin này đưa ra
nhiều định dạng khác nhau. Chúng ta có thể mở các định dạng MDL, MD2,
WMP hoặc X đối với các mô hình, và các định dạng PCX, BMP hoặc HMP đối
với các địa hình. Khi nhập một định dạng nào đó thì một cửa sổ sẽ hiện ra để
chúng ta có thể chọn các thuộc tính của cần đưa vào. Khi nhập một mô hình
phức tạp có định dạng là MD2 hoặc X thì tùy chọn Model Properties/Fast Prec
nên được chọn trước khi lưu chúng.
Một bản đồ địa hình có định dạng PCX, BMP hoặc RAW có thể được tạo ra
từ các chương trình vẽ phong cảnh hoặc địa hình. Các định dạng bitmap sẽ
được nhập vào và chuyển thành mô hình theo định dạng HMP. Chúng ta có thể
xác định giá trị tốt nhất của độ phân giải của một mắt lưới theo chiều ngang
hoặc chiều dọc theo mỗi hướng từ 30 đến 100 đỉnh. Một vài hướng có thể được
phát sinh tự động.
1.1.2. Thực đơn Edit
53

Undo: Quay trở lại hành động vừa mới thực hiện.
Redo: Quay trở lại hành động Undo vừa mới thực hiện.
Copy Selected: Lưu phần được chọn vào clipboard.
Paste: Dán dữ liệu đã được sao chép vào mô hình. Hộp
thoại đưa ra các tùy chọn cho phép thay thế các vị trí của
các đỉnh trong mô hình và thêm vào mô hình như đó là
các đỉnh mới. Việc thay các đỉnh cũng có một nhân tố pha
trộn, vì thế khi chép dữ liệu từ một khung và dán vào
khung khác, chúng ta có thể pha trộn giữa hai bộ dữ liệu.
Paste range: Dán dữ liệu đã được sao chép vào một phần nào đó của khung,
tùy vào yếu tố pha trộn ở trên.
Change Frame Name: Đổi tên khung hiện tại. Thông thường tên khung nên
bao gồm một từ mô tả và 1 số, như “walk1”, “walk2”. Tên khung xác định các
khung này có chức năng là đi bộ, tấn công, chết …Các hoạt động này sẽ được
gắn vào sau.
Goto Frame: Nhảy đến một khung xác định, chọn khung mà bạn
muốn đến trong danh sách và nhấp OK.
Add New Frame: Thêm một khung mới. Hộp thoại sẽ đưa ra những tùy
chọn là đặt khung mới sau khung cuối cùng, trước
khung đầu tiên, hoặc sau một khung nào đó. Chúng ta
cũng có thể nhập vào tên của một khung.
Delete Current Frame: Xóa khung hiện tại, xuất hiện hộp thoại xác nhận quyết
định của bạn.
Delete Frame: Xóa nhiều khung bằng cách nhập khung bắt đầu và
khung kết thúc.
54

Move Frame: Di chuyển một vài khung trong một mô hình bằng cách
chọn khung đầu tiên và khung cuối trong một tập các
khung muốn di chuyển đến vị trí mới, chọn khung
trước và khung sau và chọn OK.
Select All: Chọn tất cả các đỉnh hoặc mặt của mô hình tùy vào chế
độ đang chọn.
Select None: Bỏ chọn tất cả các đỉnh hoặc mặt của mô hình tùy vào
chế độ đang chọn.
Select Inverse: Đảo ngược sự chọn lựa hiện tại.
Select Connected: Chọn tất cả các mặt hoặc đỉnh liên kết với các đối
tượng được chọn.
Select Touching: Chọn tất cả các mặt hoặc đỉnh kề với đối tượng được
chọn.
Toolbars: Bật hoặc tắt hiển thị các toolbar.
Status Bar: Bật hoặc tắt hiển thị thanh tình trạng.
Skins: Chuyển sang chế độ thiết kế vỏ bao, ở đây vỏ bao của thực thể
được hiển thị, và skin có thể được nhập hoặc sửa đổi.
Model Properties: Hiển thị số mặt, đỉnh… trong mô hình. Bằng cách chọn
tùy chọn Fast Prec thì mô hình sẽ được lưu với định dạng khác, định dạng tạo
ra kích thướt tập tin lớn hơn, nhưng tăng lên độ phân giải các đỉnh. Chọn chế
độ phân giải cao để nhập các mô hình hoạt hình lớn và phức tạp từ các định
dạng 3DS, X hoặc MD2 để ngăn chặn tình trạng các đỉnh không được liên tục
khi chuyển động. Chú ý một khi mô hình được lưu với Fast Prec, độ phân giải
55

của các đỉnh sẽ mất mãi mãi - điều chỉnh các cờ sau này cũng không giúp được
gì.
1.1.4. Thực đơn Options
Vertices Ticks: Thể hiện tất cả các đỉnh bằng hình chữ
thập.
Show Origin: Hiển thị gốc tọa độ của mô hình
(x=0,y=0,z=0). Gốc được sử dụng để quay, cũng như để dò
tìm xung đột trong engine A5.
Show Grid: Hiển thị mặt phẳng lưới.
Show Normals ...
None: Không hiển thị các bề mặt
pháp tuyến.
Selected Faces: hiển thị pháp tuyến của bề
mặt được chọn.
All: hiển thị pháp tuyến của tất cả các bề mặt được chọn.
2D View…
Draw BackFaces: tắt mở việc hiển thị các
mặt mà các pháp tuyến của nó hướng đến
camera.
Play camera XY: Khi chạy một hoạt ảnh, thì nó cũng được thể hiện trong
khung nhìn 2D trên.
Play Camera XZ: Khi chạy một hoạt ảnh, thì nó cũng được thể hiện trong
khung nhìn 2D bên cạnh.
56

Play Camera ZY: Khi chạy một hoạt ảnh, thì nó cũng được thể hiện trong
khung nhìn 2D phía trước.
3D View:
WireFrame: hiển thị khung nhìn 3D trong chế độ khung dây.
Gouraud Shaded: hiển thị khung nhìn 3D
trong chế độ Gouraud Shaded.
Gouraud Shaded: hiển thị khung nhìn 3D
trong chế độ kết cấu.
Texture + Gouraud: hiển thị khung nhìn 3D trong chế độ Textured Gouraud
Shaded .
Draw BackFaces: Chuyển đổi việc hiển thị bề mặt sau lưng trong khung nhìn
3D.
Sync Skin Selection: Bất kỳ mặt nào được chọn trong khung nhìn 3D sẽ được
chọn trong trình thiết kế skin.
Configure:
Colors: Hiển thị thực đơn cấu hình màu
sắc. Ở đây chúng ta có thể gắn màu sắc đến
phần nào đó của giao diện hoặc mô hình hiển
thị.
Keyboard: Hiển thị thực đơn cấu hình bàn phím. Ở đây, chúng ta có thể gắn
các phím tắt vào từng lệnh.
1.1.5. Thực đơn Help
Contents: Hiển thị tài liệu hướng dẫn.
About: Nói về phiên bản này của MED.
57

1.2. Toolbars
Toolbar là nơi mà bạn thường thao tác và thiết kế các mô hình. MED có
nhiều toolbar có thể được bật hoặc tắt hoặc được sắp xếp lại. Muốn sắp xếp
một toolbar, chỉ cần nhấp trái và kéo rê chuột đến nơi mà bạn muốn. Nếu con
chuột nằm trên một nút toolbar nào đó, thì một mô tả nút sẽ được hiển thị.
1.2.1. Toolbar File
Toolbar này chứa đựng những lệnh thường dùng trong thực đơn File.
New: tạo một mô hình mới
Open: mở một mô hình/ địa hình
Save: lưu một mô hình/ địa hình
Copy: sao chép phần được chọn
Paste: dán phần được chọn
Delete: xóa phần được chọn
Undo: Trở lại hành động kế trước
Redo: Trở lại hành động Undo kế trước
1.2.2. Toolbar Edit
Toolbar này được sử dụng để thay đổi chế độ soạn thảo. Dưới đây là diễn giải
các nút từ trái qua phải:
58

Pan: Khi nút này chọn, kéo rê nút chuột trái trong cửa sổ 2D sẽ di chuyển
viewport, trong cửa sổ 3D camera sẽ được quay. Kéo rê nút chuột phải sẽ
phóng to hoặc thu nhỏ cửa sổ.
Select: Trong chế độ Select, kéo rê một hình chữ nhật xung quanh các đỉnh
hoặc mặt mà chúng ta muốn chọn.
Move: Di chuyển các mặt hoặc các đỉnh được chọn. Nếu một giá trị nap
được thiết lập, chúng chỉ có thể được di chuyển theo bội số của các giá trị đó.
Chúng ta cũng có thể di chuyển nó bằng cách sử dụng các phím di chuyển. Các
đỉnh trong các bản đồ địa hình chỉ có thể được di chuyển theo chiều dọc.
Rotate: Quay các mặt hoặc đỉnh được chọn. Quay xung quanh một điểm mà
chúng ta chọn đầu tiên. Kéo rê chuột xuống hoặc lên để quay nó theo hướng
cùng chiều hoặc ngược chiều kim đồng hồ. Nếu giá trị quay snap được thiết
lập. Các đỉnh và các mặt chỉ có thể được quay theo bội số của giá trị này. Nên
nhớ rằng một địa hình không thể quay được.
Scale: Thay đổi kích thướt của các đỉnh hoặc các mặt được chọn. Kéo rê lên
hoặc xuống để thay đổi kích thướt của nó.
Options: vài tùy chọn để thiết kế mô hình là:
Các giá trị Move Snap, Rotate Snap và Scale
Snap cho biết đơn vị để di chuyển, quay, hoặc
thay đổi kích thướt bằng chuột hoặc bàn phím.
Nút Rotate Center cho phép chọn điểm nối để
quay là điểm trung tâm của phần được chọn,
vị trị của con chuột, và gốc của mô hình.
Nếu hộp Use Frame Range được chọn, bất cứ
thay đổi gì cũng đều tác động đến tất cả các
59

khung với phạm vi được thiết lập trong vị trí From và To. Còn không nó chỉ có
tác dụng đối với khung hiện tại
Restrict: 3 trạng thái của nút sẽ hạn chế sự di chuyển hoặc thay đổi kích thướt
theo chiều dọc hoặc chiều ngang trong các cửa sổ.
1.2.3. Toolbar Select
Để quyết định loại đối tượng được chọn và thay đổi.
Vertex Mode: hành động chọn có hiệu lực với các đỉnh của mạng lưới.
Triangle Mode: hành động chọn có hiệu lực với các mặt của mạng lưới.
Bones Mode: hành động chọn có hiệu lực với các khung xương.
Select All: Chọn tất cả các đỉnh hoặc mặt tùy thuộc vào chế độ hiện tại.
Select None: Bỏ chọn tất cả các đỉnh hoặc mặt tùy thuộc vào chế độ hiện
tại.
Select Connected: Chọn tất cả các mặt hoặc đỉnh liên kết với tập được chọn.
1.2.4. Toolbar Mesh
Để thiết kế các đỉnh hoặc bộ ba đỉnh của mạng lưới.
Create Vertex: Nhấp vào bất cứ đâu trong cửa sổ 2D để tạo một đỉnh. Một
phương pháp khác là sử dụng hàm Insert Vertex mà đã được gắn vào một phím
nào đó đã được thiết lập trong cấu hình bàn phím.
60

Build Face: Trong bất kì cửa sổ nào, nhấp 3 đỉnh theo chiều kim đồng hồ để
tạo thành một mặt giữa chúng. Chọn theo thứ tự ngược chiều kim đồng hồ sẽ
tạo ra một mặt phẳng mà pháp tuyến của nó sẽ có hướng đi ra từ chúng ta.
Mirror : Chuyển đỉnh hoặc mặt được chọn về trục trung tâm của nó.
Weld: Gắn kết các đỉnh được chọn đến một điểm chung là trung bình
của các đỉnh được chọn.
Merge: Gộp 2 hoặc nhiều đỉnh được chọn mà nằm ở cùng vị trí (sai
lệch khoang +/-0.5).
Subdivide: Chia nhỏ mặt được chọn. Việc này bao gồm việc tạo ra một
đỉnh ở trung tâm của mỗi đỉnh và chia nhỏ mỗi mặt thành 3 mặt.
Extrude: Kéo hoặc đẩy các mặt được chọn từ mạng lưới.
Flip Normals: Chuyển hướng pháp tuyển của mặt được chọn.
Magnet: Là công cụ để tạo ra những đồi núi và thung lũng trong một
địa hình bằng cách di chuyển nam châm trên địa hình. Ấn nút chuột trái để hút
các đỉnh được chọn; nút phải chuột để đẩy các đỉnh được chọn. Chúng ta có thể
điều chỉnh phạm vi, cường độ và hình dạng của đỉnh được chọn trong cửa sổ
công cụ Magnet xuất hiện khi chọn công cụ này.
1.2.5. Toolbar các đối tượng cơ sở
Chọn một đối tượng cơ sở và chèn chúng vào bằng cách nhấp vào một cửa
sổ 2D. Có 8 loại cơ sở sau đây:
Cube: hình lập phương
Sphere: hình cầu
61

Cylinder: hình trụ
Torus(1): bánh xe
Torus(2): bánh xe
Pyramid: hình chóp
Cone: hình nón
DCone: hai hình nón ghép lại
1.2.6. Toolbar View
Điều khiển 4 khung nhìn, các nút từ trái qua phải được diễn giải như sau:
2D Vertices Ticks: Tất cả các đỉnh được hiển thị với hình dạng là dấu chữ
thập trong cửa sổ 2D.
3D Vertices Ticks: Tất cả các đỉnh được hiển thị với hình dạng là dấu chữ
thập trong cửa sổ 3D.
Show Vertices: Hiển thị tất cả các đỉnh trong khung nhìn.
Show Faces: Hiển thị tất cả các mặt trong khung nhìn.
Show Bones: Không được sử dụng trong phiên bản này.
Hide Selected: Ẩn đi phần được chọn của mô hình.
Hide Unselected: Ẩn đi phần không được chọn của mô hình.
Flip: Ẩn đi phần không ẩn lúc trước của mô hình.
Show All: Ẩn đi toàn bộ mô hình.
Fit All: nút này phóng to hoặc thu nhỏ và quay mô hình để nó vừa vặn
với từng khung nhìn.
62

Fit Selected: tính toán giống như tron “Fit All”, tuy nhiên các hệ thống
được chọn được điều chỉnh để vừa với các khung nhìn thay vì
toàn bộ thực thể.
Top: mở rộng cửa sổ trên.
Front: mở rộng cửa sổ trước.
Side: mở rộng cửa sổ cạnh.
3D: mở rộng cửa sổ 3D.
Default: khôi phục lại kích thướt mặc định của cửa sổ.
1.2.7. Toolbar Frame
Điều chỉnh sự hoạt động của mô hình. Các nút từ trái qua phải:
Play Camera: Trình diễn hoạt động của mô hình.
Goto Frame: Chọn một khung cho tất cả cửa sổ. Số và tên khung được
chỉ trên thanh trạng thái.
Play Setup: Xuất hiện một hộp thoại khi nhấn nút này.
FPS: Đưa ra số khung trên giây trong lúc
hoạt ảnh.
Interpolate: Sẽ tự ý thêm vào các khung trung
gian để cho sự chuyển động được liên tục hơn.
From: Khung bắt đầu.
To: Khung cuối của hoạt ảnh.
63

Hoạt ảnh sẽ lặp giữa khung bắt đầu và khung kết thúc, vì thể khi trình
diễn một cảnh thiết lập khung from và to như là trạng thái bắt đầu và kết
thúc của họat ảnh và chúng ta sẽ thấy sự chuyển động được liên tục.
Use Bones Animation: Không sử dụng trong phiên bản này.
Frame slider: Với thanh trượt Frame, chúng ta có thể tìm ra khung chuyển
động nhanh và dễ dàng hơn. Di chuyển thanh trượt từ trái qua phải hoặc
nhấp vào mũi tên ở cuối thanh trượt sẽ di chuyển qua từng khung. Số và tên
khung được chỉ ra trong cửa sổ.
Animate: Chuyển giữa chế độ hoạt ảnh và chế độ đối tượng. Kích hoạt
phím này để hoạt ảnh mô hình.
1.2.8. Thanh trạng thái
Hiển thị vị trí con trỏ, số đỉnh hoặc mặt được chọn, và chế độ hiện tại. Số
đỉnh được sử dụng để gắn các hiệu ứng hoặc chiếu sáng đến một vị trí nào đó
của mô hình trong mã nguồn, hoặc để gắn các mô hình với nhau.
2. Trình thiết kế Skin
Trình thiết kế skin được gọi lên bằng lệnh View/skins. Trước khi vẽ hoặc
nhập một skin vào một mô hình, chúng ta phải tạo ra một Skin Mapping để khu
vực mà skin ánh xạ vào khu vực của mô hình. Trình thiết kế skin cũng có một
cửa sổ 3D để vẽ trực tiếp lên mô hình.
64

2.1. Các thực đơn
2.1.1. Thực đơn File
Với thực đơn file, chúng ta có thể nhập hoặc xuất các skin. Trước đó chúng
ta phải tạo ra một Skin-Mapping.
Import:
Skin Imange: Chọn tùy chọn này để nhập một skin từ các định
dạng: .pcx, bmp, hoặc tga với 8 bit màu, RGB 24 bit màu, ARGB với 32 màu.
Kênh alpha không được hỗ trợ trong tất cả các phiên bản). Một hộp thoại sẽ
xuất hiện để chúng ta chọn một tập tin ảnh. Nếu skin mới lớn hơn skin cũ,
chúng ta có thể chỉnh bản đồ có kích thướt mới bằng cách chọn hộp Adapt Skin
Points. Bỏ chọn Adapt Skin Points khi skin không được sử dụng cho bản vẽ, nó
sẽ được nói đến chi tiết trong Detail Map.
Skin Mesh From ASC: Nhập một skin cho mô hình từ một tập tin. Chúng ta
phải xuất một mạng lưới trước mới có thể nhập được.
Export...
Image to BMP: Xuất skin hiện tại ra tập tin .bmp.
Image to PCX: Xuất skin hiện tại ra tập tin .pcx.
Skin Mesh to ASC:Xuất tọa độ mạng lưới skin ra tập tin .ASC.
65

Exit: Thoát khỏi trình thiết kế skin trở lại trình thiết kế 3D.
2.1.2. Thực đơn Edit
Undo: Trở về hành động lúc trước.
Redo: Trở về hành động Undo lúc trước.
Convert MDL -> MD2: Chuyển bản vẽ MDL đã được tạo ra
lúc trước thành một bản vẽ kiểu MDL.
Create MDL Mapping: Tạo ra một skin loại MDL bằng
cách chiếu từ mạng lưới 3D vào mặt phẳng 2D. Đây là cách
dễ nhất để tạo ra một bản vẽ. Sử dụng hộp Front / Right / Top để xác định
hướng được sử dụng trong phép chiếu. Bất kỳ mặt nào trong khung nhìn 3D có
pháp tuyến cùng hướng với hướng được đưa sẽ được nhập đến nửa trái của
mạng lưới skin, còn mặt còn lại đến hướng phải. Chú ý rằng khi tạo ra một bản
vẽ MDL sẽ thiết lập trở lại cờ FastPrec.
Create MD2 Mapping: Tạo ra một skin loại MD2 bằng cách chiếu từ mạng
lưới 3D vào mặt phẳng 2D. Phương pháp này sẽ làm cho sự sắp xếp các mặt
lưới của skin được tự do hơn, nhưng nó đòi hỏi nhiều lần chiếu và sắp xếp lại
các thành phần của skin của tất cả các mặt.
Trong trình thiết kế 3D, trong Mode Face, chọn thành phần của mô hình
muốn ánh xạ (hoặc tất cả các mô hình). Sử dụng hộp kiểm tra Front / Back /
Right / Left / Top / Bottom để xác định hướng chiếu. Chỉ những mặt được chọn
trong trình thiết kế 3D mà có pháp tuyến cùng hướng với hướng được đưa mới
được nhập vào mạng lưới skin. Giá trị Tolerance xác định mặt có góc của pháp
tuyến là bao nhiêu sẽ là mặt được bỏ qua.
Add New Skin : Thêm một skin mới vào mô hình. Nó được bố trí ở vị trí
đầu tiên.
66

Delete Current Skin:Xóa skin hiện thời ra khỏi mô hình.
Clear Current Skin: Khôi phục skin hiện thời thanh một ảnh màu đen.
Resize Skin: Thay đổi kích thướt của một skin.
Convert...
True Color: Chuyển một skin có bảng màu 8 bit thành màu RGB, sử
dụng bảng màu được đưa trong thực đơn File trong giao diện chính.
Select All: Chọn tất cả các đỉnh hoặc mặt của lưới skin tùy vào chế độ
đang chọn.
Select None: Bỏ chọn tất cả các đỉnh hoặc mặt của lưới skin tùy vào chế
độ đang chọn.
Select Inverse: Đảo ngược trạng thái chọn hiện tại.
Select Connected: Chọn tất cả các đỉnh hoặc mặt liên kết với tập đang chọn.
Select Touching: Chọn tất cả các đỉnh hoặc mặt kề với tập đang chọn.
Toolbars: Bật hoặc tắt 3 toolbar: Skin, Edit, Paint.
Statusbar:Bật hoặc tắt dòng trạng thái.
Lines...
None Không có dòng nào được hiển thị và xuất ra.
Lines Bật tắt hiển thị dòng lưới và xuất ra trên skin. Nếu chọn “Lines” thì
các dòng sẽ được xuất ra theo ảnh, thì chúng có thể được tô màu trên bản vẽ.
WireframeBật tắt hiển thị dòng lưới và xuất ra trên skin.
Vertices...
None Bật tắt chế độ hiển thị tất cả các đỉnh.
67

Dots Bật tắt chế độ hiển thị tất cả các đỉnh là các điểm ảnh đơn lẻ.
Ticks Bật tắt chế độ hiển thị tất cả các đỉnh là các dấu chữ thập.
2.2. Các Toolbar
2.2.1. Toolbar Skin
Vertex: Trong khi nút này được chọn, tất cả các hành động chọn, và các
hàm làm biến dạng lưới skin được thực hiện trên các đỉnh.
Face: Trong khi nút này được chọn, tất cả các hành động chọn, và
các hàm làm biến dạng lưới skin được thực hiện trên các mặt.
Zoom In: Mở rộng kích thướt khung nhìn skin.
Zoom Out: Giảm bớt kích thướt khung nhìn skin.
Zoom x1: Không phóng to, thu nhỏ
Zoomx2: Phóng to, thu nhỏ gấp 2.
Zoom x4: Phóng to, thu nhỏ gấp 4.
Zoom x8: Phóng to, thu nhỏ gấp 8.
Previous Skin: Chọn skin phía trước của mô hình.
Next Skin: Chọn skin tiếp theo của mô hình.
2.2.2. Toolbar Edit
Với toolbar này, chúng ta có thể thay đổi mạng lưới skin. Một vài hàm sửa đổi
các mặt – như xóa hoặc di chuyển các hình tam giác - chỉ làm việc trên skin
loại MD2.
68

Select: Chế độ chọn đối tượng, kéo rê thành một hộp bao quanh các đỉnh
hoặc mặt muốn chọn.
Move: Di chuyển các đỉnh hoặc mặt đang chọn.
Rotate: Quay các mặt hoặc đỉnh đang chọn. Nó sẽ quay quanh một điểm mà
chúng ta đã nhấp lúc đầu, kéo rê chuột xuống/lên để quay theo cùng/ngược
chiều kim đồng hồ.
Scale: Thay đổi kích thướt của các mặt hoặc đỉnh đang chọn. Rê lên/xuống
để thay đổi kích thướt lớn lên/ nhỏ xuống.
Restrict: Hạn chế sự di chuyển, thay đổi kích thướt, hoặc phản chiếu theo trục
X và Y.
Mirror: Phản chiếu các đỉnh được chọn về trục X hoặc Y.
Weld: Kết hợp các định được chọn thành một đỉnh là trung bình của nó.
Delete: Xóa khối hoặc mặt được chọn.
2.2.3. Toolbar Paint
Trình vẽ skin là công cụ vẽ hình 3D cơ sở, để thêm các kết cấu đến các mô
hình. Thông thường, chúng ta chỉ sử dụng các chương trình vẽ ngoài để tạo ra
một skin, trình vẽ này có tất cả các hàm cơ bản có thể nhanh chóng tạo hoặc
thay đổi skin của mô hình. Nó được kích hoạt khi nhấp vào cửa sổ vẽ hình 3D.
Chúng ta có thể quay hình bằng con trượt và vẽ trực tiếp vào skin.
Position: Khi được kích hoạt, chúng ta có thể quay hoặc phóng to, thu nhỏ mô
hình bằng chuột.
Face: Khi được kích hoạt, chỉ những mặt mới có thể được nhìn thấy và
thay đổi.
69

Pen: Vẽ/Tô mô hình với màu đang chọn.
Spray: Chưa có giá trị.
Fill: Tô tất cả các mặt với màu đang chọn.
Palette: Để chọn màu và các chế độ
vẽ khác.
Chọn 4 màu từ bảng màu. Chọn màu
kích hoạt bằng cách nhấp vào nó.
Pen Size: Thiết lập kích thướt của bút
vẽ theo số điểm.
Opacity: Điều chỉnh độ mờ màu của ảnh. 100 là màu thuần nhất, 0 là hoàn
toàn trong suốt.
70

Chương 3: Game Engine – Cách sử dụng SED
III. SED, C-Script editor
1. Giao diện sử dụng
Đây là giao diện sử dụng của C-Script:
Ở bên trái chúng ta có thể thấy danh sách các biến, danh sách môi trường.
Dĩ nhiên, chúng ta có thể di chuyển cửa sổ này và đặt nó ở phía bên phải nếu
muốn.
Ở phía bên dưới, chúng ta có cửa sổ chú thích các lệnh, cung cấp tất cả các
hướng dẫn nằm trong tập tin help liên quan đến lệnh mà bạn đang viết. Nó
cũng hiển thị kết quả kiểm tra cấu trúc mà nó kiểm tra trong lần biên dịch gần
nhất. Nếu muốn debug, có cửa sổ xem biến hoặc thực thể trong tab Watch. Nếu
đặt con trỏ chuột nằm trên toolbar, sẽ hiện lên một lời chỉ dẫn để mô tả những
gì chúng ta sẽ thực hiện.
71

2. Soạn thảo
Đây là phần quan trọng nhất của hướng dẫn sử dụng SED, nó sẽ giới thiệu
về cách soạn thảo nhanh với những phím tắt.
2.1. Lệnh Insert
Nếu muốn thêm một lệnh chỉ cần ấn phím [CTRL+SPACE]. Nó đưa ra một
danh sách các lệnh từ dữ liệu các lệnh và cả các hàm hoặc hành động từ tập tin
wdl. Đánh kí tự đầu tiên của lệnh muốn thêm vào và danh sách sẽ cuộn đến
lệnh đó, cũng có thể đi lên hoặc xuống danh sách bằng ấn phím mũi tên
[UP/DOWN] hoặc phím [PAGE UP / PAGE DOWN].
Chúng ta cũng có thể ấn [CTRL+SPACE] ngay khi mới bắt đầu viết lệnh.
Danh sách sẽ được cuộn đến một lệnh trước con trỏ và khi đó ấn [ENTER]
được chèn lệnh vào.
2.2. Dòng chú thích
Dòng chú thích rất cần thiết khi người biên soạn muốn bỏ qua một vài đoạn
mã trong engine.
Để có một dòng chú thích, chọn nó và ấn nút “//” xanh trên toolbar. Hoặc có
thể ấn lệnh [CTRL+ALT+C]. Lệnh này sẽ chèn thêm dấu “//” trước dòng được
chọn.
Để bỏ một dòng chú thích, chọn nó và ấn nút “//” đỏ trên toolbar. Hoặc có
thể ấn lệnh [CTRL+SHIFT+C]. Lệnh này sẽ xóa dấu “//” trước dòng được
chọn.
2.3. Nhảy đến một đoạn mã
72

Nhảy đến một đoạn mã sẽ tiết kiệm được rất nhiều thời gian, nếu chúng ta
viết một hàm có tên là “myfunction”. Rồi khi mã nguồn nhiều lên và chúng ta
muốn quay trở lại và thay đổi nó, lúc này chúng ta sẽ nhảy đến đoạn mã đó.
Mặc định, nó nằm phía bên phải, và chứa tất cả các hàm, hành vi, chuỗi …
Chỉ cần mở phần function trong cửa sổ code jumber và nhấp vào
myfunction. Con trỏ sẽ nhảy tới hàm myfunction.
2.4. Sử dụng danh sách các thành phần
Chúng ta biết rằng danh sách môi trường chứa tất cả các nhân tố trong mã
nguồn, như tập tin wdl, pcx được đưa vào. Để mở những tập tin này, vào
element list và nhấp vào mục cần thiết. Nếu nó là một tập tin wdl nó sẽ được
mở trong SED, còn không nó sẽ được mở trong một ứng dụng thích hợp.
2.5. Kiểm tra cú pháp
Đây là cách để kiểm tra xem có lỗi trong mã nguồn hay không. Để có thể
phát hiện ra đúng các lỗi trong lúc viết mã, nên chạy Test Run trước khi kiểm
tra cú pháp. Tuy nhiên, hàm Test Run sẽ tự động kiểm tra cú pháp sau khi
engine được thực thi.
Để kiểm tra cú pháp nhanh chóng, chúng ta có thể ấn phím F5 để chạy
engine và ấn F6 để kiểm tra cú pháp.
2.6. Soạn thảo thông minh
Trong khi đang viết mã chúng ta nên chú ý hàm tự động thụt đầu dòng, nó
sẽ tự động thuộc đầu dòng khi ấn phím [ENTER], cũng khi ấn phím [ENTER]
và nếu một biểu tượng “{” được đặc trên một dòng thì biểu tượng “}” sẽ được
được thêm tự động. Một tab sẽ được thêm vào để thụt lề đoạn mã giữa các dấu
ngoặc. Cũng giống như vậy, khi một biểu tượng “(” được thêm vào, thì một
biểu tượng “)” sẽ tự động thêm vào.
73

Tất cả các cửa sổ trong SED là lưu động, có nghĩa là chúng nó có thể được
di chuyển và được lưu trữ lại. Sử dụng khả năng này và điều chỉnh màu sắc để
có được một giao diện tốt.
Một số phím tắt nên nhớ:
[Alt+Left] để nhảy đến vị trí cuối cùng trong cửa sổ soạn thảo.
[Ctrl+F6] chuyển đổi giữa các tập tin mã nguồn đang mở.
[F1] mở tập tin giúp đỡ và chuyển đến lệnh hiện thời mà con trỏ đang chi
vào.
3. Cấu hình
Đây là hộp thoại cấu hình, nó nằm
ở vị trí Options->Configuration.
Paths
Thư mục 3D GameStudio – thư
mục chứa tập tin acknex.exe.
Environment
Tabsize: kích thướt của tab trong mã nguồn, mặc định là 3.
Show hints while writing: Mặc định, hiển thị lời chỉ dẫn trong khi viết hàm.
Load included files: Mở các tập tin được bao gồm trong tập tin wdl khi mở
tập tin này, mặc định là tắt.
Start with a blank script: Mặc định bắt đầu với một tập tin trống rỗng.
Auto Indent: Giống như trong thực đơn Options, tự động thụt lề khi ấn phím
enter
74

Only use these extensions with the element list: đánh “wdl,pcx” để chỉ có
các tập tin wdl và pcx trong danh sách thành phần.
Update watches every X ms: Cập nhật cửa sổ sau X giây, nếu giá trị này
thấp, nó sẽ được cập nhật nhanh hơn nhưng nó có thể làm cho quá trình gỡ lỗi
chậm xuống. Nếu xem các giá trị không thay đổi thường xuyên, hãy chọn giá
trị này càng lớn càng tốt.
Back up:
Enable backup when opening files: Nếu tùy chọn này được chọn, một bản
sao sẽ được tạo ra mỗi khi một đoạn mã được mở. Nó sẽ được lưu trữ trong thư
mục backup, hãy nhìn vào thư mục này, dung lượng của nó sẽ ngày càng tăng
lên nhưng tùy chọn này nên được chọn.
4. Thực đơn
4.1. Thực đơn File
Đây là thực đơn File, hầu hết mọi lệnh ở đây đều
chuẩn ngoại trừ lệnh Commands Database.
75

4.2. Thực đơn Edit
Đây là thực đơn edit, chứa các lệnh chuẩn và các lệnh:
Find In Files: Tìm đoạn văn bản trong các tập tin
wdl trong một thư mục.
Indent All: Thụt lề trong tất cả các tập tin wdl,
để cho đoạn mã được dễ nhìn hơn.
Comment Line : Tất cả các dòng được chọn đều trở
thành các dòng chú thích, hoặc chỉ chuyển dòng hiện
tại thành dòng chú thích nếu không chọn dòng nào.
Uncomment Line : Xóa các dấu “//” trước các dòng
được chọn, hoặc xóa dấu “//” trước dòng hiện tại nếu
không chọn dòng nào.
Insert Date: Chèn ngày hiện thời vào mã nguồn,
Bookmarks: Đánh dấu một dòng để sau này có thể di chuyển đến dòng đó
được dễ dàng hơn.
4.3. Thực đơn Options
Đây là thực đơn Options, dưới đây là phần diễn giải
các tùy chọn:
Auto Indent: Tự động thụt lề khi nhấn phím enter.
Show Line Numbers: Hiển thị số dòng ở phía bên trái,
chúng ta có thể tìm thấy số dòng hiển thị ở phía dưới
của SED.
Highlight Selected Line: Làm nổi bật dòng được chọn bằng màu được chọn
trong hộp thoại Customize Colors.
76

Show Toolbar: Hiển thị toolbar nếu nó đã bị tắt.
Show Command Help: Hiển thị Command Help nếu nó đã bị tắt.
Show Variable List: Hiển thị danh sách biến nếu nó đã bị tắt.
Configuration: Hiển thị hộp thoại cấu hình.
Font: Thay đổi Font.
4.4. Thực đơn Tools
Đây là thực đơn tools, chứa các lệnh sau:
Add Comment: Để cho người dùng có thể nhập dòng chú
thích.
To-Do List: Mang đến một danh sách có ghi tất cả những
công việc bạn sẽ thực hiện.
Color Picker: Để chọn một màu và giá trị RGB sẽ được đưa vào đoạn mã.
Insert Image: Để chọn một ảnh và thêm nó và mã nguồn.
4.5. Thực đơn Debug
Đây là thực đơn debug, nó chứa các lệnh sau:
Syntax Check: Kiểm tra lỗi cú pháp trong lần chạy
cuối cùng.
Test Run: Khởi động engine sử dụng đường dẫn đã
được cấu hình. Hãy chắc chắn những thiết lập này
đều chính xác. Nếu engine được khởi động, nó sẽ tiếp
túc chạy tập tin wdl.
Step over:Bỏ qua các dòng tiếp theo và tiến tới vị trí gỡ lỗi hiện tại.
Toggle Breakpoint: Chỉ được thực hiện khi engine được khởi động.
77

Goto current debugposition: Nhảy tới vị trí gỡ lỗi hiện tại.
Ignore further breakpoints: Tiếp tục engine và bỏ qua các điểm dừng tiếp theo.
Add watch: Thêm biến vào cửa sổ watch.
Edit watch: Thay đổi giá trị được chọn trong cửa sổ watch trong lúc run-time.
Delete watch:Xóa biến được chọn trong cửa sổ watch.
78

Chương 3: Game Engine – Cách viết một DLL
IV. Giao tiếp với các DLL
DLL là một thư viện ngoài chứa các hàm có sẵn hoặc do người dùng viết. DLL
A6 có thể được sử dụng như phần mở rộng đến engine và ngôn ngữ C-Script.
Để tạo ra một plugin A6, SDK (hệ thống phát triển mã nguồn) và ngôn ngữ lập
trình như Visual C++ cần phải có. Plugin DLL được dùng để thêm nhiều tác
động mới, như tạo ra trí thông minh cho một thực thế, chỉ lệnh C-Script mới,
cũng như có thể viết toàn bộ chương trình bằng C++ hoặc Delphi thay vì viết
bằng C-Script. Theo lý thuyết, mọi thứ: engine vật lý, một engine 3D khác hoặc
ngay cả một ngôn ngữ viết kịch bản có thể được thêm vào engine theo cách
này. Bởi vì plugin DLL làm việc với tất cả các phiên bản.
1. Bắt đầu với SDK
Khi tạo một dự án mới (chọn File->New Project), VC++ sẽ đề nghị chọn
một dự án mẫu. Hãy chọn Win32 Dynamic-Link Library, khi ứng dụng
Win32 được hiển thị, chọn Simple DLL. VC++ sẽ tạo ra một dự án DLL. Tập
tin main.cpp chứa mã nguồn như sau:
//plugin.cpp : Defines the entry point for the DLL
application.
#include "stdafx.h"
BOOL APIENTRY DllMain(
HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved)
{
return TRUE;
}
Chép tất cả các tập tin SDK vào thư mục được tạo ra bởi VC++. Bây giờ, đê
biên dịch một plugin DLL A6, chúng ta phải liên kết thư viện a5dll.lib (một tập
tin trong SDK) đến dự án (Project Properties -> Linker Input -> Additional
Dependencies) và include tập tin a5dll.h và a5funcs.h đến tập tin main.cpp. 3
tập tin này là những tập tin cần thiết để tạo một DLL A6.
79

Thư viện a5dll.lib chứa đựng một vài hàm cần thiết cho một DLL, như các
hàm: a5dll_getwdlobj, a5dll_getwdlfunc, vả a5dll_getscript. Chúng ta sẽ
xem những hàm này sau. Tuy nhiên DLL phải gọi ít nhất một trong những hàm
này để chắc chắn rằng thư viện được liên kết đúng. Để làm điều này, thêm hàm
theo sau:
// để chắc chắn rằng thư viện được liên kết đúng
void force_library(void)
{
a5dll_getwdlobj("");
}
Bây giờ, chúng ta có thể thêm một hàm nào đó đến DLL, mà nó có thể được
gọi trong một script, hoặc bởi hàm main của game. Để được engine chấp nhận,
tất cả các hàm phải có loại là DLLFUNC fixed function(...), như thế này:
// trả về giá trị x * 2n
DLLFUNC fixed ldexpc(fixed x,fixed n)
{
return (FLOAT2FIX(FIX2FLOAT(x)*pow(2.0,FIX2FLOAT(n))));
}
Hàm này trả về một biểu thức số học với các đối số của nó. DLLFUNC không
phải là một phần của C++ - đây chỉ quy ước để định nghĩa một hàm DLL xuất.
fixed là loại biến số của A6 và C-Script. Cả hai đều được định nghĩa trong
a5dll.h với các hàm chuyển đổi sau:
#define DLLFUNC extern "C" __declspec(dllexport)
typedef long fixed; // fixed point 22.10 number format used by
C-Script
inline fixed INT2FIX(int i) { return i<<10; }
inline int FIX2INT(fixed x) { return x>>10; }
inline double FIX2FLOAT(fixed x) { return ((double)x)/(1<<10);
}
inline fixed FLOAT2FIX(double f) { return (fixed)(f*(1<<10));
}
Engine sẽ đưa qua và nhận lấy tất cả đều là số - tọa độ, biến … đều được biểu
diễn theo loại fixed. Vì thế, hãy chuyển đổi bất kì số nào thành fixed trước khi
đưa nó trở lại engine, giống như trong ví dụ trên.
80

Hãy dịch DLL - giả định rằng tên nó là plugin.dll - và chép nó thư mục
work. Để gọi hàm ldexpc, chúng ta phải làm 2 việc: khai báo hàm và mở DLL.
Việc đầu tiên được thực hiện bằng tuyên bố dllfunction trong script:
dllfunction ldexpc(x,n); // khai báo một hàm dll
Với khai báo này, hàm ldexpc sẽ được biết trong script. Trước khi gọi nó,
chúng ta phải mở DLL. Hãy đặt nó trong hàm main của script:
function main() {
...
dll_open("plugin.dll");
và đừng quên đóng DLL trước khi thoát khỏi game:
...
dll_close(dll_handle);
exit;
Sau hoàn thành, chúng ta có thể gọi chỉ lệnh thêm vào trong C-Script:
...
x = ldexp(y,n); // tính x = y * 2n
...
Để có thể debug DLL trong VC++, thiết lập lệnh trong Project Properties -
> Debug đến đường dẫn của tập tin exe của engine ( ví dụ như "C:program
filesgstudiobinacknex.exe), đối số lệnh chỉnh đến tập tin script và tham số
dòng lệnh (như “mygame.wdl -wnd") và thư mục làm việc đến thư mục game
(như "C:program filesgstudiomygame"). Trong Project Properties ->
General, thiết lập thư mục output và immediate là “.” (dấu chấm, có nghĩa là
thư mục đang làm việc) để engine có thể tìm thấy tập tin ngay lập tức. Như
vậy, chúng ta có thể biên dịch và debug bằng cách đặt các điểm dừng như
thông thường.
Đây chỉ là những kiến thức cơ bản để viết một plugin DLL. Vẫn còn nhiều
thứ để học. Còn các phương pháp để trao đổi dữ liệu với engine sẽ được mô tả
trong phần tiếp theo. Tất cả các hàm DLL có thể được khai báo và gọi đến
trong script giống như những hàm trong C-Script, sau khi kích hoạt DLL bằng
hàm dll_open và dll_close được mô tả trong phần hướng dẫn script.
81

2. Sử dụng đối tượng C-Script trong một DLL
Chúng ta đã biết được cách thêm một chỉ lệnh C-Script mới, còn bên trong
DLL chúng ta có thể truy cập biến, đối tượng và hàm như thế nào? Chúng ta có
một vài hàm thư viện để làm điều này. Tất cả các hàm thư viện được cung cấp
bởi SDK đều bắt đầu bằng a5dll_. Trong đó, hàm thường sử dụng nhất là:
long a5dll_getwdlobj(char *name);
Hàm này trả về địa chỉ của một đối tượng hoặc biến có tên được đưa. Nó có thể
sử dụng để đọc hoặc ghi bất kì một đối tượng C-Script bên trong một DLL.
Nếu đối tượng không tồn tại, nó sẽ trả về NULL và sẽ xuất hiện một lỗi. Thí dụ
một hàm DLL mà truy cập đối tượng trong C-Script.
// thêm giá trị được đưa vào một vector trong C-
Script
fixed AddToVector(fixed value)
{
// lấy địa chỉ của một biến
static fixed *myvector = (fixed
*)a5dll_getwdlobj("myvector");
// thêm cùng giá trị đến 3 thành phần của vector
myvector[0] += value;
return value;
}
Vì thế, chúng ta có thể sử dụng hàm này để lấy một con trỏ chỉ đến một đối
tượng bất kì trong C-Script, không kể nó được định nghĩa trước bởi engine
hoặc do chúng ta định nghĩa. Trong trường hợp, nó là một vector được định
nghĩa trong C-Script như sau:
var myvector[3] = 1,2,3;
82

và hàm a5dll_getwdlobj sẽ trả về một con trỏ đến vector này, cũng chính là
một mảng các số fixed. Tại sao chúng ta lại không chuyển sang số kiểu fixed?.
Bởi vì value có kiểu là fixed và chúng ta có thể cộng hai số kiểu fixed giống
như 2 số nguyên. Nhưng chúng ta không thể chia hoặc nhân 2 số này.
Như vậy, bây giờ chúng ta đã biết cách đọc và thay đổi các biến trong C-
Script, nhưng với những đối tượng phức tạp như panel, view, entity thì sao?
Hãy nhìn vào tập tin a5dll.h – chúng ta sẽ tìm thấy tất cả các cấu trúc được
định nghĩa trong C-Script, như A4_STRING, A4_ENTITY, A4_PARTICLE,
A4_BMAP, A4_TEX … Tất cả những cấu trúc này bắt đầu với A4_ ( ngay cả
trong phiên bản A6). Chúng ta sẽ nhận được một con trỏ chỉ đến cấu trúc như
với các biến.
// phóng to, thu nhỏ camera view
fixed ZoomIn(fixed value)
{
static A4_VIEW *camera = (A4_VIEW
*)a5dll_getwdlobj("camera");
return (camera->arc -= value);
}
camera là một khung nhìn (view) đã được định nghĩa trước. Bởi vì
a5dll_getwdlobj trả về một số nguyên kiểu long, chúng ta có thể ép nó đến
kiểu mong muốn, như toán tử (A4_VIEW *) ở đây. Trong a5dll.h, chúng ta có
thể thấy các khai báo cấu trúc, với cấu trúc A4_VIEW chứa đựng tất cả các
tham số mà chúng ta sử dụng trong C-Script, như arc, ambient…Và một khi có
được con trỏ chúng ta có thể thay đổi và đọc tất cả chúng.
3. Sử dụng các hàm API
Truy cập các hàm trong C-Script tương tự như truy cập đối tượng C-Script,
bằng hàm:
long a5dll_getwdlfunc(char *name);
83

Hàm này trả về địa chỉ của một hàm trong C-Script có tên là name. Nó có thể
được sử dụng để gọi một hàm engine trong DLL. Không phải tất cả các hàm
trong C-Script đều có giá trị trong DLL. Nếu chỉ lệnh không có giá trị bởi vì nó
không được hiểu trong DLL (như hàm wait() hoặc INKEY()), NULL sẽ được
trả về cùng với một lỗi. Thí dụ một hàm DLL cho một thực thể AI sử dụng các
hàm C-Script để quét môi trường xung quanh thực thể.
// trả về khoảng cách từ thực thể đến một chướng ngại
vật phía trước
fixed DistAhead(long p_ent)
{
if (!my) return 0;
// lấy lại con trỏ đến thực thể được đưa
A4_ENTITY *ent = (A4_ENTITY *)p_ent;
// lấy địa chỉ của các biến và hàm
static wdlfunc2 vecrotate =
(wdlfunc2)a5dll_getwdlfunc("vec_rotate");
static wdlfunc3 c_trace =
(wdlfunc3)a5dll_getwdlfunc("c_trace");
fixed target[3] = { FLOAT2FIX(1000.0),0,0 };
//vector đích
// quay vector đích hướng đến thực thể
(*vecrotate)((long)target,(long)&(ent->pan));
// thêm vị trí của thực thể vào vector đích
target[0] += ent->x;
target[1] += ent->y;
target[2] += ent->z;
// truy tìm theo một dòng giữa thực thể và đích,
// và trả về kết quả
fixed tracemode = INT2FIX(TRMF_IGNORE_ME +
TRMF_IGNORE_PASSABLE + TRMF_USE_BOX);
return (*c_trace)((long)&(ent-
>x),(long)target,tracemode);
}
Chúng ta sẽ xem chi tiết đoạn mã:
wdlfunc2 vecrotate = (wdlfunc2)a5dll_getwdlfunc("vec_rotate");
84

wdlfunc2 là một quy ước loại của con trỏ chỉ đến các chỉ lệnh trong C-Script
nhận hai tham số. Bởi vì tất cả các chỉ lệnh trong C-Script nhận 1, 2, 3 hoặc 4
đối số, nên có 4 định nghĩa trong a5dll.h:
typedef fixed (*wdlfunc1)(long);
typedef fixed (*wdlfunc2)(long,long);
typedef fixed (*wdlfunc3)(long,long,long);
typedef fixed (*wdlfunc4)(long,long,long,long);
Một khi, chúng ta nhận con trỏ đến chỉ lệnh đó, nó được đề nghị để lấy lại
con trỏ đến tất cả các chỉ lệnh được sử dụng trong hàm khởi động, chúng ta sẽ
gọi nó như thế này:
(*vecrotate)((long)target,(long)&(ent->pan));
Có một ít khác so với việc thường gọi một hàm trong C++. Tuy nhiên, nó khá
dễ hiểu: Chúng ta có một con trỏ hàm, vì thế để gọi nó, chúng ta phải sử dụng
(*…). Và đối số được đưa luôn luôn là kiểu fixed hoặc long. Chúng ta đã ép
kiểu nó thành kiểu long thay cho kiểu fixed, đó chỉ là sự thỏa thuận rằng chúng
ta đang đưa một tham số con trỏ. Tất cả các chỉ lệnh vector đều đòi hỏi một con
trỏ các số fixed.
Nếu chỉ lệnh không đòi hỏi một vector hoặc một giá trị mà là cái gì đó phức
tạp hơn như là một thực thể. Chúng ta chỉ cần đưa một con trỏ A4_ENTITY
được ép sang kiểu long. Nhưng nếu nó đòi hỏi một chuỗi thì sao – chúng ta sẽ
sử dụng con trỏ kiểu A4_STRING hoặc chỉ cần đưa char*? Chúng ta phải sử
dụng A4_STRING. Trong thí dụ ackdll.cpp, chúng ta có thể tìm thấy cách để
đưa một hằng chuỗi vào một chỉ lệnh trong C-Script.
long pSTRING(char* chars)
{
static A4_STRING tempstring;
static char tempchar[256];
strncpy(tempchar,chars,255);
tempstring.chars = tempchar;
tempstring.link.index = 4<<24;
85

return (long)&tempstring;
}
//thí dụ được ra một chuỗi để tạo một thực thể
DLLFUNC
fixed create_warlock(long vec_pos) {
static
wdlfunc3 ent_create =
(wdlfunc3)a5dll_getwdlfunc("ent_create");
return
(*ent_create)(pSTRING("warlock.mdl"),vec_pos,0);
}
Một vài chỉ lệnh không thể được gọi trực tiếp từ một DLL. Tuy nhiên, chúng
có thể được thi hành trực tiếp bằng cách gọi một script thực hiện những chỉ
lệnh đó. Script có thể được gọi từ DLL bằng hàm sau:
long a5dll_getscript(char *name);
Hàm này trả về địa chỉ của một hàm script được định nghĩa bởi người dùng có
tên được đưa. Nó có thể được dùng để gọi một hàm hoặc hành động trong C-
Script được định nghĩa bởi người dùng bên trong một DLL. Nếu hàm không
tìm thấy, NULL sẽ được trả về và phát sinh ra một lỗi.
fixed a5dll_callscript(long script,long p1=0,long p2=0,long p3=0,long p4=0);
fixed a5dll_callname(char *name,long p1=0,long p2=0,long p3=0,long
p4=0);
Hàm này gọi một hàm script được định nghĩa bởi người dùng có địa chỉ hoặc
tên được đưa. 4 tham số được đưa có thể là một số kiểu fixed, mảng, hoặc một
con trỏ đến một đối tượng C-Script. Nếu hàm yêu cầu ít hơn 4 tham số, các
tham số còn lại đặt là 0.
Thí dụ một hàm DLL gọi một hàm đã được định nghĩa trong C-Script:
DLLFUNC fixed WDLBeep(fixed value)
{
// lấy con trỏ hàm
static long beeptwice =
a5dll_getscript("beeptwice");
// gọi hàm
86

return a5dll_callscript(beeptwice,0,0,0,0);
}
Hàm DLL này sẽ yêu cầu hàm trong C-Script sau sẽ được gọi:
function beeptwice() { beep; beep; }
4. Lập trình một game trong C++
Sử dụng đối tượng A4_ENTITY, một DLL có thể thực thi một hàm AI phức
tạp, mà nó sẽ rất khó để viết trong C-Script. Ngay cả toàn bộ game đều có thể
được viết trong một DLL. Thí dụ sau chỉ ra cách thay đổi tham số thực thể
trong một hàm DLL.
// lăn tròn thực thể được đưa một góc 180 độ
DLLFUNC fixed FlipUpsideDown(long entity)
{
if (!entity) return 0;
// lấy con trỏ đến thực thể được đưa
A4_ENTITY *ent = (A4_ENTITY *)entity;
// gán góc lăn tròn của thực thể đến 180 độ
ent->roll = FLOAT2FIX(180);
return 0;
}
Hàm này sẽ được gọi trong C-Script bằng hàm FlipUpsideDown(my). Để điều
khiển toàn bộ thực thể trong một DLL, giả sử chúng ta viết toàn bộ một game
bằng ngôn ngữ C++, một hành động giả trong C-Script có thể được gắn vào
thực thể như sau:
var appdll_handle;
dllfunction dll_entmain(entity);
dllfunction dll_entevent(entity);
function main()
{
// Mở DLL
appdll_handle = dll_open("myapp.dll");
...
}
action myent_event {
dll_handle = appdll_handle;
87

dll_entevent(my); // hàm DLL này điều khiển tất cả
các sự kiện của thực thể
}
action myentity {
my.event = myent_event;
while(1) {
dll_handle = appdll_handle;
dll_entmain(my); // hàm DLL này điều khiển thực
thể
wait(1);
}
}
88

Chương 4: Cài đặt
89
Chương 4
CÀI ĐẶT
Game được tạo thành từ các thành phần: các khối và các thực thể.
Các khối sẽ được kết hợp lại trong lúc thiết kế bằng WED để tạo ra một
khung cảnh môi trường tĩnh trong game.
Các thực thể: sprite (núi, mặt trời, mây…), mô hình (bao gồm cây trồng, xe
của người chơi và các xe tự điều khiển…), terrain (tạo ra một địa hình có hình
dạng phức tạp).
Các thành phần tĩnh hoặc không cần xử lý hoặc đòi hỏi xử lý rất ít trong lúc
viết mã. Do đó lúc cài đặc chủ yếu tập trung vào hai đối tượng quan trọng là
chiếc xe do người chơi khiển khiển và những chiếc xe tự chuyển động theo một
hướng nào đó.
I. Cài đặt cho người chơi
1. Chuyển động vật lý
a. Gia tốc, quán tính và lực ma sát
Giả định rằng, người chơi di chuyển thẳng về phía trước, quãng đường mà
nó đi được tăng lên theo vận tốc và thời gian:
ds=v*dt
v là tốc độ đo bằng quants (khoảng 1 inch) trên tick(khoảng 1/16s).
ds quãng đường đi được đo bằng quants.
dt thời gian để người chơi đi được quãng đường ds, do bằng tick.
Nếu muốn thay đổi vận tốc của người chơi, chúng ta cần phải tác dụng một
lực lên người chơi, lực càng lớn làm cho vận tốc người chơi thay đổi càng

90
nhanh. Theo vật lý học, thì khi một vật thay đổi vận tốc, thì nó sẽ bị một sự
kháng cự nào đó. Đó chính là quán tính, phụ thuộc vào khối lượng m của một
vật. Với cùng một lực tác dụng, thì vật có khối lượng càng lớn có sự thay đổi
vận tốc càng nhỏ.
Ta đã biết được các công thức:
a - gia tốc – sự thay đổi của vận tốc trên 1 tick
f - lực tác dụng
m - khối lượng của vật.
Chúng ta sẽ xem xét 3 loại lực tác dụng.
- Lực đẩy (propelling force): Lực này dùng để thay đổi vận tốc người chơi,
được tạo ra khi ấn phím. Trong một game đơn giản, lực này sẽ tùy thuộc vào
khối lượng của người chơi. Đối với người chơi có khối lượng càng lớn thì lực
tác dụng đến nó càng lớn.
p=p*m
- Lực thứ hai là lực hấp dẫn, có thể là một lực hút người chơi đến một
hướng nào đó, hoặc là trọng lực của trái đất. Lực hấp dẫn thay đổi từ nơi này
đến nơi khác. Trong game, độ lớn của lực này cũng tùy thuộc vào khối lượng
của người chơi. Điều này rất dễ thấy trong trường hợp lực này là trọng lực:
d=d*m
- Lực thứ 3 tác dụng lên người chơi là lực ma sát. Lực này làm cản trở hoạt
động của người chơi, liên tục làm giảm tốc độ của anh ta. Không giống như vật
lý học, là lực hãm bao gồm lực ma sát và những thành phần suy giảm, chúng ta
sử dụng lực giả tạo, nó sẽ tăng với khối lượng người chơi (sức ép lên mặt đất)
và tốc độ:
r= - f*m*v
r: lực ma sát.
dv = a*dt
a=f/m

91
f: hệ số ma sát.
v: vận tốc.
m: khối lượng.
Hệ số của lực ma sát tùy thuộc vào bề mặt mà người chơi đang di chuyển
trên đó: tuyết có hệ số ma sát thấp hơn đá. Trong không trung, hệ số ma sát hầu
như bằng 0. Dấu trừ chỉ rằng lực lực có chiều ngược hướng với vận tốc của
người chơi. Khối lượng của người chơi là m, cũng là một thành phần trong
phương trình, bởi vì trong game, nếu trọng lượng của người chơi lớn thì lực ma
sát ép vào bề mặt càng lớn. Như vậy, 3 lực: lực đẩy f, lực hấp dẫn d và lực
giảm tốc độ r đều làm thay đổi vận tốc của người chơi.
dv phải được thêm vào vận tốc sau mỗi trạng thái (frame). p, d và f là các lực
đẩy, lực hấp dẫn, lực ma sát. dt là khoảng thời gian mà vận tốc thay đổi - ở đây
nó là thời giữa hai trang thái, bởi vì chúng ta đang tính vận tốc mới sau mỗi
trạng thái. Chúng ta sẽ làm cho tất cả các lực cân xứng với trọng lượng, vì thế
yếu tố khối lượng sẽ không còn cần thiết nữa, nó không còn có tác dụng gì
trong chuyển động vật lý nữa, chúng ta sẽ loại nó ra khỏi phương trình. Chúng
ta sẽ viết mã nguồn cho công thức cuối cùng như sau:
dv = a * dt
dv = (p + d + r) / m * dt
dv = (p + d - f * v) * dt

92
Lực tác dụng là 10, lực ma sát là 0.7 trong cả lúc quay và lúc di chuyển. Chúng
ta sử dụng các skill (biến có sẵn của thực thể), để lưu giữ vận tốc hiện tại của
thực thể, bởi vì cần biết vận tốc của người chơi ở trạng thái trước để tính toán
lực tác dụng hiện tại vào người chơi. Chúng ta đã sử dụng skill14 để cất giữ
vận tốc góc, và skill11 để lưu vận tốc di chuyển về phía trước. time là dt trong
công thức tính quãng đường đi được, vì thế người chơi sẽ di chuyển cùng vận
tốc trên mọi PC, nó hầu như độc lập với tốc độ khung! Chú ý rằng, chúng ta đã
thay đổi công thức gốc, theo lý thuyết thì công thức tính sự thay đổi của vận tốc
trên một chu kỳ trạng thái là:
Nó sẽ được viết lại trong script như sau:
var force[3];
var dist[3];
action move_me
{
while (1)
{
force.PAN = -10 * KEY_FORCE.X; // tính lực quay
my.SKILL14 = TIME*force.PAN + max(1-
TIME*0.7,0)*my.SKILL14; // vận tốc quay
my.PAN += TIME * my.SKILL14; // quay người chơi
force.X = 10 * KEY_FORCE.Y; // tính toán lực di chuyển
my.SKILL11 = TIME*force.X + max(1-TIME*0.7,0)*my.SKILL11; //
tính vận tốc
dist.X = TIME * my.SKILL11; // quãng đường đi được
dist.Y = 0;
dist.Z = 0;
move_mode = ignore_passable + glide;
ent_MOVE(dist,nullvector); // di chuyển người chơi
move_view(); // di chuyển camera theo người chơi
wait(1);
}
}
v -> v + dv
v -> v + (p - f * v) * d

93
my.SKILL11 = my.skill11 + (force.X - 0.7 * my.SKILL11) * time;
và được thay đổi từng bước như sau:
my.SKILL11 = my.skill11 + TIME * force.X - time * 0.7 * my.SKILL11;
my.SKILL11 = TIME * force.X + (1-time*0.7) * my.SKILL11;
Cuối cùng cho ra một kết quả khá phức tạp:
my.SKILL11 = TIME * force.X + max(1-TIME*0.7,0) * my.SKILL11;
Như vậy, chúng ta đã hoàn thành script cho công thức tính vận tốc trên. Nhưng
chúng ta sử dụng hàm max ở đây để làm gì. Max(a.b) so sánh hai giá trị a và b,
và trả về giá trị nào lớn hơn. Khi sử dụng max(1-TIME*0.7,0), nó sẽ chỉ cho ra
kế quả dương, chúng ta phải làm như vậy, bởi vì trong các máy tính có tốc độ
khung quá thấp, và giá trị time quá lớn – TIME*0.7 có thể sẽ lớn hơn 1, cho ra
kết quả âm. Điều này làm cho vận tốc bị đảo chiều, và người chơi sẽ di chuyển
ngược ra sau.
b. Rơi từ trên xuống
Trong khi sự di chuyển theo chiều ngang của người chơi chủ yếu được tác
dụng từ các lực do người sử dụng ấn phím, thì sự di chuyển theo chiều dọc là
do tác dụng của trọng lực tác dụng vào người chơi. Nếu người chơi đang đứng
ở trên mặt đất, nó sẽ không cần di chuyển theo chiều dọc. Nhưng nếu người
chơi bỗng nhiên rơi vào không trung – như nếu nó tiến đến một vực thẳm, thì
nó nhất định phải rơi xuống. Để xác định người chơi có ở trạng thái này hay
không, cần phải xác định người chơi cách đất bao nhiêu. Chúng ta sẽ sử dụng
lệnh trace:

94
Lệnh trace trả về khoảng cách đến chướng ngại vật đầu tiên mà một tia giữa 2
điểm (2 vector được đưa). Chúng ta đang sử dụng điểm trung tâm của người
chơi (my.x) là điểm thứ nhất, và điều chỉnh điểm temp để nó là điểm thứ 2 nằm
phía dưới người chơi khoảng 4000 quant. Bằng cách sử dụng chế độ use_box,
chúng ta đang sử dụng tia truy tìm có một bề dày là vỏ bao bên ngoài người
chơi, thông thường có đường kính là 32 quant – nó cũng trả về khoảng cách
đến điểm dưới cùng của hộp bao bên ngoài người chơi, không phải là trung tâm
action move_me
{
while (1)
{
my.SKILL14 = TIME*force.PAN + max(1-TIME*0.7,0)*my.SKILL14; //
tính vận tốc quay
force.X = 10 * KEY_FORCE.Y;
my.SKILL11 = TIME*force.X + max(1-TIME*0.7,0)*my.SKILL11; // tính
vận tốc tiến về trước
dist.X = TIME * my.SKILL11; // quãng đường đi được về phía trước
dist.Y = 0;
vec_set(temp,my.x);
temp.z -= 4000; // một vị trí nằm dưới người chơi 4000 quants
// chọn các chế độ truy tìm các thực thể và bề mặt từ vị trí của người chơi
trace_mode =
ignore_me+ignore_sprites+IGNORE_MODELS+USE_BOX;
dist.z = -trace(my.x,temp); // trừ khoảng cách theo chiều dọc
move_view(); // di chuyển camera
wait(1);
}
}

95
của người chơi. Nếu chúng ta xem điểm dưới cùng của hộp bao bên ngoài là
chân của người chơi, thì lệnh trace sẽ tính chân người chơi đang cách mặt đất
là bao nhiêu. Nếu chân của nó đang ở dưới nền đất, lệnh trace sẽ trả về kết quả
âm. Vì thế dist.z được gán bằng phủ định của khoảng cách trả về từ lệnh trace.
Theo phương pháp này, người chơi có thể đi bộ giữa những vùng có độ cao
khác nhau, như lên hoặc xuống cầu thang. Chú ý để cho đơn giản chúng ta
dùng vector khoảng cách tương đối (dist) để di chuyển người chơi theo hướng
Z. Thông thường ở đây, nên sử dụng khoảng cách tương đối. Nhưng người chơi
sẽ điều chỉnh đến các độ cao khác nhau ngay lập tức. Cách di chuyển này rất
không tự nhiên. Để cho sự di chuyển được tự nhiên hơn, chúng ta sẽ tìm các
lực tác động đến người chơi theo hướng thẳng đứng:
- Khi người chơi là một chiếc máy bay thì lệnh trace trả về một giá trị lớn
hơn 0 - chỉ những lực hấp dẫn và ma sát mới tác dụng lên nó. Lực hấp
dẫn ở đây là trọng lực mà chúng ta đã đề cập, nó kéo người chơi xuống
phía dưới.
- …cho đến khi người chơi tiến đến mặt đất hoặc chìm vào nó - lệnh trace
sẽ trả về một giá trí nhỏ hơn hoặc bằng 0. Trong trường hợp này thì lực
đàn hồi sẽ tác động. Đây là loại lực mới, nó càng mạnh khi người chơi
càng chìm sâu trong nền đất. Nó tạo ra cho người chơi một gia tốc
hướng lên. Hơn nữa gia tốc của người chơi sẽ tăng đáng kể khi người
chơi tiến vào mặt đất.
Sử dụng kĩ thuật này, và tùy theo trung tâm của thực thể người chơi, mà
chân của thực thể có thể đi xuyên qua bề mặt rắn, không thể qua được. Trong
thế giới thực loại bề mặt này dĩ nhiên không bao giờ đi qua được, nhưng với
đầu gối của người chơi, nó sẽ tạo ra cùng tác dụng. Vì thế sự xuất hiện của lực
đàn hồi là kết quả từ việc nhún của đầu gối - nếu người chơi là một động cơ –
thì đó là bộ giảm xóc. Cũng tương tự chúng ta có thể giải thích sự tăng lên của

96
lực ma sát trên nền đất bằng lực ma sát được tạo ra bởi lực nhún của người chơi
hoặc bộ giảm xóc của xe.
var friction;
action move_me
{
while (1)
{
my.SKILL14 = TIME*force.PAN + max(1-TIME*0.7,0)*my.SKILL14; //
vận tốc quay
vec_set(temp,my.x);
temp.z -= 4000; // một vị trí nằm dưới người chơi 4000 quants
// chọn các chế độ truy tìm các thực thể và bề mặt từ vị trí của người chơi
trace_mode =
ignore_me+ignore_sprites+IGNORE_MODELS+USE_BOX;
result = trace(my.x,temp); // subtract vertical distance to ground
if (RESULT > 5) // có phải đang ở trong không gian?
{
force.X = 0; // không có lực đẩy
force.Y = 0;
force.Z = -5; // trọng lực
friction = 0.1; // lực ma sát của không khí
}

97
Bằng cách sử dụng lệnh if với kết quả truy tìm được, chúng ta có thể xác định
người chơi đang ở trong không khí hoặc cách mặt đất 5 quant. Trong trường
hợp đầu tiên, các lực được tạo ra từ bàn phím sẽ không có tác dụng, mà người
chơi sẽ rơi xuống dưới tác dụng của trọng lực. Trong trường hợp sau, xuất hiện
lực đàn hồi tương ứng với độ sâu khi thực thể chìm vào mặt đất, sẽ đẩy người
chơi ra khỏi mặt đất. Chúng ta đang sử dụng nhiều skill của thực thể, skill13 sẽ
lưu vận tốc theo phương thẳng đứng hiện tại của thực thể.
2. Cách di chuyển camera theo người chơi
2.1. Tầm nhìn của người thứ nhất
else // đang ở trên mặt đất
{
force.X = 10 * KEY_FORCE.Y; // lực quay
force.Y = 0;
force.Z = -0.5 * RESULT; // lực nẩy
friction = 0.7; // lực ma sát dưới nền đất
}
my.SKILL11 = TIME*force.X + max(1-TIME*friction,0)*my.SKILL11; //
tính vận tốc tiến về phía trước
my.SKILL13 = TIME*force.Z + max(1-TIME*friction,0)*my.SKILL13; //
tính vận tốc theo phương thẳng đứng
dist.X = TIME * my.SKILL11; // quãng đường tiến về phía trước
dist.y = 0;
dist.Z = TIME * my.SKILL13; // quãng đường rơi xuống
move_view(); // di chuyển camera theo
wait(1);
}
}

98
Hãy đặt viết mã nguồn như sau:
Và gọi hàm init_camera trong hàm main sau khi gọi hàm level_load. Lưu và
chạy ứng dụng. Khi đó camera sẽ di chuyển theo người chơi.
Chúng ta đã định nghĩa một khung nhìn mới. Hãy tượng tượng một khung nhìn
trong game. Nó chỉ là một cửa sổ. Chúng ta có thể xác định vị trí và kích thướt
của cửa sổ bằng cách điều chỉnh các thuộc tính pos_x, pos_y, size_x, size_y.
Như trên, chúng ta đã định nghĩa, góc trên bên trái của khung nhìn trùng với
góc trên bên trái của màn hình và có kích thướt của nó cũng bằng kích thướt
của màn hình.
view 1st_person
{
layer = 1;
pos_x = 0;
pos_y = 0;
}
function init_cameras()
{
camera.visible = off;
1st_person.size_x = screen_size.x;
1st_person.size_y = screen_size.y;
1st_person.genius = player;
1st_person.visible = on;
}
function update_views()
{
1st_person.x = player.x;
1st_person.y = player.y;
1st_person.z = player.z;
1st_person.pan = player.pan;
1st_person.roll = player.roll;
1st_person.tilt = player.tilt;
}

99
Hàm update_views, sẽ được cập nhật sau mỗi trạng thái và thay đổi tọa độ x, y,
z của camera trong game. Ở đây, chúng ta thay đổi nó đến tọa độ của người
chơi, vì thế làm cho camera luôn luôn ở bên trong người chơi.
Đoạn mã vẫn chưa được hoàn hảo. Ví dụ, nếu camera được đặt ở điểm trung
tâm của mô hình người chơi, không ở trên đầu, là nguyên nhân làm cho khung
nhìn đặt quá gần nền đất. Như vậy chúng ta chưa thể nhìn lên hoặc xuống.
Chúng ta định nghĩa thêm một biến ở đầu đoạn mã.
var eye_height = 20;
và thay vì
1st_person.z = player.z;
chúng ta viết lại là:
1st_person.z = player.z + eye_height;
Nó sẽ điều chỉnh camera lên cao hơn 20 quant. Nếu giá trị này chưa được tốt,
có thể điều chỉnh lại trong lúc chơi game.
Bây giờ, chúng ta muốn người chơi có thể nhìn lên hoặc nhìn xuống. Để thực
hiện được, chúng ta cần các biến sau:
var tilt_1st = 0;
var cam_turnspeed = 2;
var max_tilt_1st = 40;
và thay đổi dòng mã:
1st_person.tilt = player.tilt;
thành:
1st_person.tilt = player.tilt + tilt_1st;
và thêm các hàm sau:

100
Những hàm này phải được gọi trong lúc chơi game. Ví dụ, chúng ta có thể định
nghĩa như thế này:
on_pgup = look_up;
on_pgdn = look_down;
Hãy lưu lại và chạy thử. Không tồi, nhưng chưa có tác dụng như mong muốn.
Nếu ấn một phím và giữ nó, thì khung nhìn chỉ di chuyển một ít và sẽ không
thay đổi nữa. Chúng ta phải ấn nó nhiều lần để khung nhìn có thể di chuyển và
điều này quá chậm chạp.
Chúng ta sẽ thay đổi nó như thế nào? Thay đổi định nghĩa on_pageup và
on_pagedown như sau:
on_pgup = handle_pageup;
on_pgdn = handle_pagedown;
Và định nghĩa 2 hàm sau:
function look_up()
{
if (tilt_1st < max_tilt_1st) { tilt_1st += cam_turnspeed; }
}
function look_down()
{
if (tilt_1st > -max_tilt_1st) { tilt_1st -= cam_turnspeed; }
}

101
Theo cách này các hàm của chúng ta sẽ được gọi trong mỗi trạng thái trong khi
các phím này đang được ấn. Nếu camera quay quá nhanh hoặc quá chậm, có
thể điều chỉnh giá trị cam_turnspeed. Nếu phạm vi của khung nhìn quá nhỏ và
để người chơi có thể thay đổi góc nhìn nhiều hơn, hãy thay đổi biến
max_tilt_1st. Giá trị 90 ở đây có nghĩa là: người chơi có thể nhìn thẳng lên
hoặc xuống. Giá trị trên 90 tức là người chơi có thể nhìn ngược ra sau.
2.2 Quay tự do tầm nhìn của người thứ 3
Bây giờ chúng ta muốn tạo ra một khung nhìn có thể quay của người thứ 3. Có
hai cách thực hiện: cách thứ nhất là tạo ra một camera ở bên ngoài người chơi
và không quay, ngay cả khi nó đi, luôn luôn đối diện với nó từ một hướng nào
đó. Cách thứ 2 là tạo ra một camera có thể rẽ khi người chơi rẽ, vì thế nó sẽ
luôn nằm ở đằng sau người chơi (hoặc trước, hoặc bên cạnh …).
Chúng ta sẽ làm cho camera này có thể rẽ và phóng to thu nho tự do. Để bắt
đầu, chúng ta sẽ tạo ra một khung nhìn của người thứ 3 luôn luôn đối mặt với
function handle_pageup()
{
while (key_pgup)
{
look_up();
wait(1);
}
}
function handle_pagedown()
{
while (key_pgdn)
{
look_down();
wait(1);
}
}

102
người chơi từ một hướng và những thay đổi khi muốn khung nhìn quay cùng
với thực thể.
Định nghĩa khung nhìn thứ 2 như sau:
Chúng ta chưa làm cho nó có thể nhìn thấy được. Thay vì, chúng ta sẽ có thể
thay đổi camera trong lúc chơi game. Chúng ta sẽ định nghĩa thủ tục chuyển
đổi camera ngay bây giờ:
view 3rd_person
{
layer = 1;
pos_x = 0;
pos_y = 0;
}
Thêm dòng sau vào bên trong hàm "init_cameras":
...
3rd_person.size_x = screen_size.x;
3rd_person.size_y = screen_size.y;
...
var cam_mode = 0; // 0 cho người thứ nhất, 1 cho người thứ 3
function toggle_cams()
{
if (cam_mode == 0)
{ // Thay đổi đến người thứ 3
1st_person.visible = off;
3rd_person.visible = on;
cam_mode = 1;
}
else
{ // thay đổi đến người thứ nhất
3rd_person.visible = off;
1st_person.visible = on;
cam_mode = 0;
}
}
on f8 = toggle cams;

103
Như vậy, bằng cách nhấn f8 ta có thể chuyển đổi giữa các khung nhìn. Tuy
nhiên, nó chưa có tác dụng, bởi vì các tọa độ x, y, z của người thứ 3 chưa được
định nghĩa. Chúng ta sẽ định nghĩa ngay giờ bằng cách thay đổi hàm
"update_views".
Nhưng chúng ta sẽ định nghĩa một camera quay quanh người chơi như thế nào?
Nó nên nằm trên cùng một mặt phẳng, vì thế giá trị z là giống nhau. Nhưng
chúng ta sẽ tính giá trị x và y như thế nào? Chúng ta cần một chút toán học.
Tưởng tượng người chơi được quan sát từ phía trên. Cách tốt nhất là lấy một tờ
báo và đặt một điểm trên nó, ở một nơi nào đó, để chỉ ra vị trí của người chơi
được thấy từ phía trên. Vẽ một đường tròn xung quanh điểm này. Đây là vòng
tròn mà camera sẽ di chuyển trên đó. Vòng tròn này có một bán kính nào đó.
Giả sử trên vòng tròn có một điểm là điểm gốc, khi đó chúng ta có thể xác định
một điểm P trên vòng tròn bằng một cung giữa đường thẳng vẽ từ gốc đến tâm
và từ P đến tâm của đường tròn.
Như vậy, khi có khoảng cách đến người chơi (bán kính của đường tròn) và một
góc trong mặt phẳng thì vị trí của camera sẽ được xác định.

104
Lưu mã nguồn và chạy nó. Chọn f8 để chuyển đổi giữa các khung nhìn. Nên
xem người chơi trong khung nhìn của người thứ 3. Khi di chuyển, camera sẽ
luôn luôn di chuyển cùng khoảng cách với người chơi, và sẽ không thay đổi vị
trí khi người chơi rẽ. Nếu thay đổi giá trị của biến dist_planar thì camera sẽ tiến
lại gần hoặc lùi ra xa. Nếu thay đổi góc cam_angle thì nó sẽ quay xung quanh
người chơi, và luôn luôn đối diện với người chơi.
Tuy nhiên vẫn còn vấn đề khi người chơi ở gần các bức tường. Camera sẽ
thường xuyên đi xuyên qua các bức tường, và các chướng ngại vật sẽ chắn tầm
nhìn của người chơi. Chúng ta sẽ giải quyết vấn đề này trong phần sau. Bây giờ
chúng ta sẽ thay đổi mã nguồn một ít…chúng ta muốn di chuyển camera lên
phía trên nhưng vẫn đối diện với người chơi. Và cũng cần phải giữ cùng
var dist_planar = 300; // khoảng cách đến người chơi
var cam_angle = 0;
{
if (cam_mode == 0)
{
1st_person.x = player.x;
1st_person.y = player.y;
1st_person.z = player.z + eye_height;
1st_person.pan = player.pan;
1st_person.roll = player.roll;
1st_person.tilt = player.tilt + tilt_1st;
}
else
{
3rd_person.x = player.x - cos (cam_angle) * dist_planar;
3rd_person.y = player.y - sin (cam_angle) * dist_planar;
3rd_person.z = player.z;
3rd_person.pan = cam_angle;
3rd_person.roll = 0;
3rd_person.tilt = 0;
}
}

105
khoảng cách đến người chơi, vì thế sự di chuyển không còn theo đường tròn
nữa mà theo hình cầu.
Chúng ta sẽ thực hiện điều này như thế nào? Hãy tưởng tượng người chơi được
nhìn từ bên cạnh. Nếu camera nằm trên mặt phẳng XY của người chơi. Hãy vẽ
một đường thẳng từ nó đến người chơi, chúng ta sẽ nhận được một góc giữa
mặt phẳng XY và đường này. Góc này sẽ xác định chính xác vị trí của người
chơi.
Hình sau đây sẽ biểu diễn vị trí của camera trong trường hợp này:
Lúc này chúng ta cần chỉnh lại mã nguồn như sau:

106
Bằng cách thay đổi giá trị của các biến tilt_3rd, cam_angle, dist_total, chúng ta
có thể di chuyển camera tự do xung quanh người chơi. Nó sẽ được di chuyển
trên một mặt cầu với bán kính có thể được thay đổi bằng cách thay đổi giá trị
của biến.
2.3 Cách để cho camera tránh chạm vào tường
Ý tưởng là gửi một tia từ người chơi đến vị trí mới của camera, nếu thấy có
một chướng ngại vật nằm trên tia này. Khi đó, khoảng cách giữa người chơi và
camera cần được thay đổi… bằng khoảng cách giữa người chơi và chướng ngại
vật.
Thêm những dòng sau vào hàm update_views:
var dist_total = 300; // thay đổi giá trị này để tiến lại gần hoặc ra xa thực
thể
var tilt_3rd = 0;
{
...
else
{
dist_planar = cos (tilt_3rd) * dist_total;
3rd_person.z = player.z + sin (tilt_3rd) * dist_total;
3rd_person.pan = cam_angle;
3rd_person.tilt = - tilt_3rd;
}

107
Hàm này xác định vị trí của camera một cách hoàn toàn giống như cách trên,
nó chỉ sử dụng một khoảng cách mới đến người chơi, đó là khoảng cách từ
người chơi đến chướng ngại vật. Nó sẽ thay đổi từ từ để ngăn chặn việc camera
nằm bên trong bức tường.
Để đặt camera sau người chơi, chúng ta thay đổi những dòng:
thành:
{
...
3rd_person.tilt = - tilt_3rd;
validate_view();
}
...
}
hàm trên sẽ được định nghĩa như sau:
var dist_traced;
function validate_view()
{
my = player;
trace_mode = ignore_me + ignore_passable;
dist_traced = trace (player.x, 3rd_person.x);
if (dist_traced == 0) { return; } // không chạm vào bất kì chướng ngại
vật nào
if (dist_traced < dist_total)
{
dist_traced -= 5; // Di chuyển ra ngoài bức tường
dist_planar = cos (tilt_3rd) * dist_traced;
3rd_person.z = player.z + sin (tilt_3rd) * dist_traced;
}
}

108
3rd_person.x = player.x - cos (cam_angle + player.pan) * dist_planar;
3rd_person.y = player.y - sin (cam_angle + player.pan) * dist_planar;
chúng ta chỉ cần thêm góc quay của thực thể (player.pan) vào cam_angle.
II. Xe tự động
Tránh chướng ngại vật trên đường đi
Giả sử người chơi muốn di chuyển từ một điểm bắt đầu đến điểm kết thúc.
Tất nhiên nếu giữa nó không có chướng ngại vật nào hết thì rất đơn giản, chỉ
cần cho nó di chuyển theo một đường thẳng đi qua điểm bắt đầu và điểm kết
thúc.
Ở đây chúng ta đặc biệt chú ý đến trường hợp: giữa 2 điểm bắt đầu và kết
thúc có các chướng ngại vật: là các chiếc xe khác hoặc là các chướng ngại vật
tĩnh.
Hình 1

109
Ví dụ ở đây: để người chơi di chuyển đến một vị trí nào đó ta có thể nhấp
chuột đến vị trí cần người chơi cần đến:
Lúc này điểm bắt đầu là vị trí của người chơi, điểm kết thúc là vị trí nút
nhất của chuột.
Có 8 hướng khác nhau xung quanh một người chơi, mỗi một hướng khác
nhau ta xem đó là một nút. Một nút có thể có độ rộng khác nhau tùy thuộc vào
chúng ta muốn chọn bao nhiêu.
Hình 2
Nếu một nút chứa một chướng ngại vật thì ta xem nút đó là nút không có
giá trị, sẽ không được chọn trong lúc tìm đường đến đích.
Hình 3
3 4 5 kt
2 v v
1 v v
bđ v V

110
Giả sử từ nút bắt đầu bđ, muốn tìm một đường đi đi đến nút cần đến (nút kt).
Và các nút v là các chướng ngại vật:
Ở đây, mỗi nút trung gian (như các nút 0, 1 … 7), sẽ chứa 2 giá trị là chi phí
đường đi (waycost), và chi phí toàn bộ nút (nodecost).
Mỗi nút có một nút cha, và một nút cha có 8 nút con (trong trường hợp bình
thường), nằm xung quanh nút này.
Giả sử một nút có chi phí đường đi là waycost, thì các nút con của nó sẽ có
waycostcon=waycostcha+1;
Trong đó nút bắt đầu không có nút cha và ta cho waycost của nó là 0.
Ở đây ta sử dụng một heuristic, đó là khoảng cách từ nút đó đến nút đích (nút
kt), ta kí hiệu là goal_dist, thì chi phí của một nút sẽ là:
nodecost=waycost+goal_dist
Như vậy thuật toán sẽ gồm các bước sau:
Với thuật toán như vậy, trong hình 3 để tìm đường đi từ điểm bắt đầu (bd) đến
điểm kết thúc (kt), ta sẽ đi qua con đường đi qua các nút 1, 2, 3, 4, 5.
Bước 1:
Mở nút bắt đầu
Bước 2:
- Chọn trong danh sách các nút mở ra một nút có nodecost nhỏ nhất.
- Nếu không còn nút nào nữa thì kết thúc thuật toán.
Bước 3:
- Nếu nút này là nút đích thì thuật toán kết thúc.
- Nếu không thì:
+ Tạo ra các nút con từ nút này, với điều kiện các nút con không
phải là nút chứa các chướng ngại vật.
+ Đóng nút này lại và mở tất cả các nút con được tạo ra.
Bước 4:

111
TÀI LIỆU THAM KHẢO
[1] Hướng dẫn có sẵn trong chương trình 3D Game Studio.
[2] Các tài liệu hướng dẫn trên trang web: www.3DGameStudio.com.
[3] Bạch Hưng Khang, Hoàng Kiếm, Trí tuệ nhân tạo, các phương pháp và
ứng dụng, Nhà xuất bản Khoa học và Kỹ thuật Hà Nội - 1999

Ung dung tri tue nhan tao trong game

More Related Content

Similar to Ung dung tri tue nhan tao trong game (20)

More from Vcoi Vit (20)

Ung dung tri tue nhan tao trong game