资源列表

一、简介这是一个学习模仿WireShark的抓包软件。可以的功能有：侦听、解析、构造数据包等。其中还包括扩展功能：流量监测和攻击检测（Land攻击，Ping of Death）。软件目前支持解析：IP、IPv6、ARP、TCP、UDP、ICMP、ICMPv6、SSDP、HTTP、TLS。
二、主要功能
侦听指定网卡或所有网卡，抓取流经网卡的数据包
解析捕获的数据包每层的每个字段，查看数据包的详细内容
可通过不同的需求设置了BPF过滤器，获取指定地址、端口或协议等相关条件的报文
针对应用进行流量监测，监测结果实时在流量图显示，并可设置流量预警线，当流量超过预警线时自动报警
提供了以饼状图的形式统计ARP、TCP、UDP、ICMP报文，以柱状图的形式统计IPv4、IPv6报文
可将抓取到的数据包另存为pcap文件，并能通过打开一个pcap文件对其中的数据包进行解析
可逐层逐字段构造数据包，实现自定义数据包发送

三、主要模块
数据报文采集模块：完成网络接口数据的捕获、解析，可以根据用户定义条件组合来进行捕获，如只监视采用TCP或UDP协议的数据包，也可以监视用户希望关注的相关IP地址的数据包，同时完成数据封包日志记录，提高了系统的灵活性。此外，对IP类型、ARP、TCP、UDP、ICMP的数量进行统计。
应用流量监测模块：获取当前正在运行的应用进程，用户可选择一个应用进行流量监测，获取应用中流量信息，同时对一些常见的入侵攻击特征进行判断，如根据源目的地址是否相同判断Land攻击、IP头部长度是否过长判断ping拒绝服务攻击，并发出预警。
报文伪造模块：可以自行构造Ether、IP、TCP、UDP、ICMP、ARP报文，并选择send()、sendp()、sr()、srl()、srloop()五种方式发送报文以实现简单攻击或对TCP/IP进行调试。
界面显示模块：设计系统主窗口即数据报文采集界面、应用流量监测界面、报文伪造界面。并完成报文统计图的显示，流量图的显示。
四、源代码结构
img存放程序中使用的背景和图标。
capture_core.py抓包程序的后台文件，主要用来生成数据包的摘要信息、分析数据包的结构、程序状态处理、下载速度和上传速度的更新等。
flow_monitor.py流量监控程序的后台服务代码，实时更新速度、应用流量的过滤及摘要信息的生成、更新应用的网络连接等。
forged_packet用于构造数据包并发送，可自定义数据包的每个字段，实现网络攻击或网络欺骗等功能。
main_ui.py抓包程序的GUI代码，包括了快捷键的绑定以及可自定义字体和背景图片、已抓到数据包的摘要信息的展示、显示某个数据包的详细信息和十六进制数据等功能。
main.py程序的入口。
monitor_system.py流量监控的GUI代码，用于查看网络连接速度等。
tools.py工具代码，用于获取网卡的NIC、格式的转换、网络连接速度的获取。
data.json用于存放程序的配置信息。

五、环境依赖
Python 3.6
Scapy 2.4

Linux & Windows
# pip install psutil scapy matplotlib pyqt5
在Windows下，还需要
# pip install wmi pywin32
六、使用方法进入项目目录
# cd WireWhale # python main.py
七、部分功能介绍
主界面主要包括5个部分：
菜单栏
文件：文件保存、打开，软件退出编辑：可自行设置主窗体字体捕获：捕获数据包的流程分析：两大拓展功能，应用流量监测和伪造数据包统计：报文统计帮助：功能介绍及版权声明
工具栏
界面初始时，根据程序运行状态转移图只有开始键可以响应设置了标志位：start_flag、pause_flag、stop_flag、save_flag，用于对程序中一些函数的使用添加限制。开始、暂停、停止、重新开始四个按钮全部按照下图逻辑设置在什么情况下可响应下面为部分状态截图
起始状态运行状态暂停状态停止状态

过滤器以及网卡选择
页面初始化时网卡选择下拉框获取网卡信息进行显示，如下图所示，默认全选
报文显示
根据报文类型显示不同颜色，以进行明显的区别报文解析以树状结构显示，层次结构清晰明了抓包简略信息显示框定时滑到最底部
状态栏（显示当前网卡、实时收发包速度、上传下载速度）

数据统计模块：绘制图使用python下最流行的数据处理框架Matplotlib绘制要求的统计图。


八、软件运行时部分截图8.1 主程序



8.2 数据包伪造

8.3 流量监控

Python 2.7.13
IDE Pycharm 5.0.3
macOS 10.12.1

前言
花了一点时间，半抄半写半修改的写了第一个能用的python小程序，作用是在IDE端模拟有道词典的访问，效果如下图所示，不足之处在于，当输入的中英文字符串超过一定数量，会抛出中间代码，新手并不知道怎么处理，望知道的不吝赐教

初阶：交互界面
首先在jupyter或者pycharm中进行交互的操作，核心语句是使用raw_input捕获系统输入

1. 效果图
2. 代码# -*- coding: utf-8 -*-import urllib2import urllib # python2.7才需要两个urllibimport jsonwhile True: content = raw_input("请输入需要翻译的内容：") # 系统捕获输入，就是命令框会弹出提示，需要你进行手动输入 if content == 'q': # 输入q退出while循环 break url = "http://fanyi.youdao.com/translate?smartresult=dict&smartresult=rule&smartresult=ugc&sessionFrom=null" data = {} # 构造data，里面构造参数传入 data['type'] = 'AUTO' data['i']=content data['doctype'] = 'json' data['xmlVersion'] = '1.8' data['keyfrom'] = 'fanyi.web' data['ue'] = 'UTF-8' data['action'] = 'FY_BY_ENTER' data['typoResult'] = 'true' data = urllib.urlencode(data).encode('utf-8') # 将构造的data编码 req = urllib2.Request(url) # 向浏览器发出请求 response = urllib2.urlopen(req, data) # 带参请求，返回执行结果 html = response.read().decode('utf-8') # print(html) # 可以取消print的注释，查看其中效果，这边获取的结果是进行解析 target = json.loads(html) # 以json形式载入获取到的html字符串 print "翻译的内容是："+target['translateResult'][0][0]['tgt'].encode('utf-8')# 请输入需要翻译的内容：test# 翻译的内容是：测试# 请输入需要翻译的内容：测试# 翻译的内容是：test# 请输入需要翻译的内容：q
注意：这里的data字典中的数据根据实际网页中数据为准，可能会不一样，具体操作，点击审查元素。
进阶：做成gui
离实用还差那么两步，第一步是先做成GUI

1. 界面效果
2. 代码# -*- coding: utf-8 -*-from Tkinter import *import difflibimport urllib2import urllib # python2.7才需要两个urllibimport json# ----------------------主框架部分----------------------root = Tk()root.title('翻译GUI&beta1')root.geometry()Label_root=Label(root)#-----------------------定义规则------------------------def translate(content): url = "http://fanyi.youdao.com/translate?smartresult=dict&smartresult=rule&smartresult=ugc&sessionFrom=null" data = {} # 构造data，里面构造参数传入 data['type'] = 'AUTO' data['i']=content data['doctype'] = 'json' data['xmlVersion'] = '1.8' data['keyfrom'] = 'fanyi.web' data['ue'] = 'UTF-8' data['action'] = 'FY_BY_ENTER' data['typoResult'] = 'true' data = urllib.urlencode(data).encode('utf-8') # 将构造的data编码 req = urllib2.Request(url) # 向浏览器发出请求 response = urllib2.urlopen(req, data) # 带参请求，返回执行结果 html = response.read().decode('utf-8') # print(html) # 可以取消print的注释，查看其中效果，这边获取的结果是进行解析 target = json.loads(html) # 以json形式载入获取到的html字符串 #print u"翻译的内容是："+target['translateResult'][0][0]['tgt'] return target['translateResult'][0][0]['tgt'].encode('utf-8')#还可以继续增加规则函数，只要是两输入的参数都可以#----------------------触发函数-----------------------def Answ():# 规则函数 Ans.insert(END,"翻译 %s: "%var_first.get().encode('utf-8') + translate(var_first.get().encode('utf-8')))def Clea():#清空函数 input_num_first.delete(0,END)#这里entry的delect用0 Ans.delete(0,END)#text中的用0.0#----------------------输入选择框架--------------------frame_input = Frame(root)Label_input=Label(frame_input, text='请输入需要翻译的内容', font=('',15))var_first = StringVar()input_num_first = Entry(frame_input, textvariable=var_first)#---------------------计算结果框架---------------------frame_output = Frame(root)Label_output=Label(frame_output, font=('',15))Ans = Listbox(frame_output, height=5,width=30) #text也可以，Listbox好处在于换行#-----------------------Button-----------------------calc = Button(frame_output,text='翻译', command=Answ)cle = Button(frame_output,text='清空', command=Clea)Label_root.pack(side=TOP)frame_input.pack(side=TOP)Label_input.pack(side=LEFT)input_num_first.pack(side=LEFT)frame_output.pack(side=TOP)Label_output.pack(side=LEFT)calc.pack(side=LEFT)cle.pack(side=LEFT)Ans.pack(side=LEFT)#-------------------root.mainloop()------------------root.mainloop()
高阶：发布应用
如何在小伙伴面前装B才是我学习的动力，哈哈哈

Pay Attention
python3的用户注意url包的使用和python2是有区别的，请根据实际需求自行百度
Python如果操作频率太快或者网页限制机器人对此的访问，则需要修改head了，修改代码后.当然每个电脑的user都不一样，具体去审查元素查看。

req = urllib2.Request(url) # 生成对象# 添加如下一行代码；req.add_header('User-Agent','Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.101 Safari/537.36')，这样就可以伪装成人类啦
当然也可以添加延时模块, 即可限定访问时间。
import time #添加延时模块time.sleep(1)#休息1秒钟再进行操作
python3的同学需要Tkinter改成小写，还有就是注意编码部分的转化。
mac的同学可能遇到tkinter无法输入中文问题，可能是由tkinter版本过低导致，解决方案参考：MAC 系统中，Tkinter 无法用 中文输入法 输入中文

1.使用说明1.1 项目简介参照微软cotana的工作方式，编写自己的一个python语音助手程序，借助PyQt5和Pipy，创建可视化窗口，能实现基本的语音识别功能，同时根据几个特定的关键词执行简单的行动（如music，readme等）。
1.2 项目功能要求
实现语音识别，并将识别的内容在屏幕上打印出来
设置几个命令关键词（music，readme），并实现相应的行动。若识别出的内容中包含设置的几个关键词，则程序执行相应的行动。
设置两种识别模式：PocketSphinx中包含7个Recognizer API：程序中使用了两个API：recognize_sphinx和recognize_google。（两种识别模式可由用户自行选择，其中recognize_sphinx可直接在本地运行，但识别精度较低；recognize_google识别精度较高，但是使用recognize_google需要处于联网状态下且IP地址需要在境外，否则语音识别会出现错误）
设置文本框：用户可直接在文本框中输入命令，其执行效力与语音输入等效

2.程序设计与实现2.1 设计class Ui_MainWindow(object):
Ui_Mainwindow类加载图形化用户界面，控制界面布局，类中包含各种Label，PushButton，MenuBar控件。
class myWindow(QtWidgets.QMainWindow):
mywindow类处理交互逻辑，类中包含各种执行函数，同时实现控件与函数的连接。
2.2 主要函数实现声音监听与处理函数def listen(self): # Working with Microphones mic = sr.Recognizer() with sr.Microphone() as source: # use the default microphone as the audio source audio = mic.listen(source) # listen for the first phrase and extract it into audio data try: if self.isgoogle: content = mic.recognize_google(audio) else: content = mic.recognize_sphinx(audio) except sr.RequestError: self.ui.label.setText("Something was wrong! Try again......") COMMEND = ["music", "open"] commend_is_music = re.search(COMMEND[0].lower(), content.lower()) commend_is_file = re.search(COMMEND[1].lower(), content.lower()) if commend_is_music: self.ui.label.setText("you said: \" " + content + "\"") win32api.ShellExecute(0, 'open', 'D:\\网易云音乐\\CloudMusic\\cloudmusic.exe', '', '', 1) elif commend_is_file: self.ui.label.setText("you said: \"" + content + "\"") win32api.ShellExecute(0, 'open', 'D:\\Notpad++\\Notepad++\\notepad++.exe', '', '', 0) else: self.ui.label.setText("you said: \" " + content + "\"\nIt's not a valid command.")
创建监听线程def listen_thread(self): self.ui.label.setText("I'm listening...... ") t1 = threading.Thread(target=self.listen) t1.setDaemon(True) t1.start()
文本处理函数def text_changed(self): content = self.ui.textbox.text() print(content) COMMEND = ["music", "open"] commend_is_music = re.search(COMMEND[0].lower(), content.lower()) commend_is_file = re.search(COMMEND[1].lower(), content.lower()) if commend_is_music: self.ui.label.setText("you typed: \" " + content + "\"") win32api.ShellExecute(0, 'open', 'D:\\网易云音乐\\CloudMusic\\cloudmusic.exe', '', '', 1) elif commend_is_file: self.ui.label.setText("you typed: \"" + content + "\"") win32api.ShellExecute(0, 'open', 'D:\\Notpad++\\Notepad++\\notepad++.exe', '', '', 0) else: self.ui.label.setText("you typed: \" " + content + "\"\nIt's not a valid command.")
创建文本处理线程def text_thread(self): t2 = threading.Thread(target=self.text_changed) t2.setDaemon(True) t2.start()
连接各类控件与相应函数self.ui.recognize_btn.clicked.connect(self.listen_thread)#语音识别按钮连接监听线程self.ui.sphinx_bar.triggered.connect(self.sphinxbar_recognize)#sphinx模式触发self.ui.google_bar.triggered.connect(self.googlebar_recognize)#google模式触发self.ui.text_btn.clicked.connect(self.text_thread)#文本框输入确认按钮连接文本处理线程
3.测试截图

这是一个非常简单的 AI，基于这个框架，还可以进行大量改进以提高智商，代码已经进行了很基础的封装，关键过程的说明见注释。
以下可参考：

https://en.wikipedia.org/wiki/Minimax
https://cs.uwaterloo.ca/~cbright/reports/cs686project.pdf ，(Negamax 是 miniMax 的变体）

Minimax 算法首先，同化棋是一种“0和”对抗游戏（一方优势一方必然劣势） 那么我们考虑用通过 Minimax 算法解决。
Minimax 算法又名极小化极大算法，是一种找出失败的最大可能性中的最小值的算法。
简单来说，就是枚举当前执行者所有可能的选择，不断一层层拓展局面，达到限定层数后，对局面进行估值，然后按 MAX 层选择分支的最大值，MIN 层选择分支的最小值，模拟对弈双方的选择。
α-β剪枝通过分析可以发现，在利用穷举方法执行 Minimax 算法中有许多的无效搜索，也就是说，许多明显较劣的状态分支我们也进行搜索了。
我们在进行极大值搜索的时候，我们仅仅关心，下面最大的状态，对于任何小于目前值的分支也都是完全没有必要进行进一步检查的。

图中 MIN 层第二个结点，在得到下一层的估值 2 后，它的返回值必然<=2，而上一层是 MAX 层，从 MIN 层第一个结点已经得到了 4，故其>=4，所以，MIN 层第二个结点必然不会被选 择，没有继续的必要。
同理，我们在进行极小值搜索的时候，我们仅仅关心，下面最小的状态，对于任何大于目前值的分支都是完全没有必要进行进一步检查的。

估价函数使用 Minimax 算法，最为关键的部分是如何对一个局面进行估价，判断其到底有多大的可能性会给 AI 带来胜利。
分析同化棋的规则，容易发现其局面上的总棋子数是不减的。那么，双方获得的棋子的差是最容易想到的估价，也是此 AI 所使用的主要估价。
其次，经过尝试，当一方占据半壁江山（>24）后，非常容易走向胜利，所以我们贪心地尽量让其超过一半，即给予较高估价。
改进此 AI 可以进一步改进的地方：
1.估价函数由于同化棋一步可以最多同化 8 个棋子，所以可能当前你优势（棋子差额）很大，但是下一步立马被翻盘。所以我们可以考虑统计一些容易被同化的如中空的方形，菱形的个数，给予估价值。还有很多估值方法…
2.优化程序以加速根据 Minimax 算法的特点，在时限内搜索的层数越深，结点越多，选择就越优，AI 的智商就越高。此 AI 以易读性为主，牺牲了许多性能，可以做许多改进：
（1）状态压缩对于一个棋盘，由于其只有 49 个位置，我们可以把位置映射到 0~48 这 49 个数 （f(x,y) = x * 7 + y） ，对于某个位置，其只有存在棋子，不存在棋子，两种状态，所以对于对弈的一方，我们可以用一个 64 位整数的第 k 个 2 进制位=0/1 表示是否在 k 位置有这个数，从而把他的所有棋子的位置映射成一个 64 位整数（c++： long long int）。
这样一来，棋盘状态由一个 7*7 数组变成了两个整数，我们可以使用位运算，十分快速地进行查找位置，更新状态，统计个数等等操作。将压缩的状态 hash 判断冲突是防止进入循环局面的方法之一。
（2）剪枝及搜索顺序如已经被已方及边界与最近对方分隔 2 层以上的己方完全占领区域的棋子，是可以稍后考虑的。 接近对方边缘部位的棋子是可以优先考虑的，这样可以容易得出接近最优值的选择，更高效地利用α-β剪枝。
（3）常数优化根据语言及计算机的一些特性，在不改变功能的情况下对程序的语句进行修改，以期获得更好的性能。
3. 随机化可以用随机化在一定程度上防止局面陷入循环，或者被对手用同样的走法再次打败。但要注意，不能随机进入一个劣势局面。
4.迭代加深因为此 AI 现有估价及搜法较弱，最大搜索层数很低，所以在搜索时采用迭代加深层数限制的方法，这就产生了问题，下一个深度是沿用之前所有搜索深度得到的首层 max、min 值（通常在低深度得到最优值）， 还是初始化 max,min 值，现版本 AI 经测试，第一种占优，但是改进后，是否还进行迭代加深，或者采取哪种方法，需测试。（理论上第二种占优，本质上第一种是贪心）。
界面展示人人对弈，搜索深度为3

AI先手，搜索深度为3

AI后手，搜索深度为5

一、什么是设计文档游戏类型是什么？游戏有哪些功能？相关数学公式是什么？
描述一个游戏的所有功能，这就是设计文档，也叫需求说明。真正的设计文档，并不是我写的这个样子，应该由策划来写（俗称“案子”）。我写的这篇，有流程图、有分类，条理清晰，基本上和真实代码完全对应，已经接近伪码了。
二、游戏状态图
三、游戏功能设计1.开屏

显示内容：
程序启动后，显示初始化图片，计时结束，进入菜单界面。
逻辑处理：
控制图片从左至右显示。

2.菜单

显示内容：
显示菜单背景图片，显示“开始”按钮。
逻辑处理：
检测鼠标移动。当鼠标移动到按钮上，更改按钮图片。
检测鼠标单击。当按下按钮后，初始化游戏数据，开始“地图加载”动画。

3. 地图加载动画

显示内容：
显示背景图片，进度条，显示当前关卡、目标金钱数量。
逻辑处理：
控制进度条移动。

4. 游戏中

显示内容：
显示人物图片，地面背景。
显示当前金钱数量，目标金钱数量，剩余时间。
显示叉子。
显示金子、石头。
显示炮的数量。
显示爆炸动画。
逻辑处理：
控制叉子摆动，伸出，收回。
检测按键“下”，按下后，叉子伸出。
检测叉子是否碰到物品，碰到物品后，叉子收回，物品跟随叉子移动。
当物品移动到地面位置，清除物品，增加金钱。
胜负判断。
道具使用：
检测按键“上”，按下后，清除当前所抓物品，播放爆炸动画。
判断玩家属性：如果有“体力”道具，增加叉子收回速度。
判断玩家属性：如果有“魔法”道具，增加物品价值。

5.游戏过关

显示内容：
显示过关图片。
逻辑处理：
计时结束，进入“购买道具”状态。

6.购买道具

显示内容：
道具按钮：炮，体力，魔法。
“下一关”按钮。
逻辑处理：
检测鼠标移动。当鼠标移动到按钮上，更改按钮图片。
点击“炮”，增加炮的数量。
点击“体力”，增加叉子收回速度。
点击“魔法”，设置玩家属性：有魔法道具。
点击“下一关”，加载地图，进入下一关游戏。

7.游戏失败

显示内容：
显示失败图片。
逻辑处理：
计时结束，进入“菜单”状态。

8.游戏通关

显示内容：
显示通关图片。
逻辑处理：
计时结束，进入“菜单”状态。

四、叉子坐标系统叉子所在位置为坐标原点，所在位置垂线为X轴。向左摆动，旋转角度A大于0；向右摆动，旋转角度A小于0。其中，x，y是屏幕坐标系统。叉子坐标系统示意图：

五、碰撞检测怎样检测叉子碰到了物品？在叉子端口处，设定一个圆形区域。如果这个圆与物品碰撞，则叉子碰到了物品。示意图如下：

其中，圆心坐标A(50, 0) ，半径14。
物品的检测范围也是圆形区域，示意图如下：

六、地图数据物品属性表



ID
价值
名称
检测半径(像素)
移动速度(像素)




0
500
金子
32
4


1
150
金子
24
12


2
50
金子
16
20


3
15
石头
24
12


4
5
石头
16
20


5
600
钻石
16
20



地图物品数据
目前只制作了3张地图。
第一关地图，过关金钱数量：700



ID
横坐标
纵坐标




0
50
110


1
100
270


2
200
370


1
380
370


2
480
340


0
550
150


3
190
190


4
390
260


5
120
380



第二关，过关金钱数量：1000



ID
横坐标
纵坐标




1
50
110


4
100
270


2
200
370


3
380
370


4
480
340


5
450
400


0
550
150


1
190
190


2
390
260



第三关，过关金钱数量：2000



ID
横坐标
纵坐标




4
50
110


1
100
270


0
200
370


0
380
370


3
480
340


4
550
150


2
190
190


4
390
260


5
460
300



游戏截图

Python 2.7
IDE Pycharm 5.0.3
Firefox浏览器：47.0.1

目的自动实现图书馆借书籍的书单截图，并一键续约全部书籍，我登录校图书馆的目的无非就这两个咯，我才不去预约没有的书呢—反正没有一次预约成功过0.0
实现方法Selenium+PhantonJS自动化脚本执行
实现方案
采用Firefox浏览器进行模拟登录，这个比较酷炫把，可以看着浏览器自己在那边跑，欢快的停不下来。。。
调用PhantomJS.exe，不展现浏览器的运作，直接在cmd窗口跑（用pyinstaller打包成exe后有cmd窗）

方案实现过程采用Selenium+Firefox方式：
先来个最后成品动图：

然后来程序代码—主模块（被调用模块，也可单独执行）
# -*- coding: utf-8 -*-from selenium import webdriverimport time#shift-tab多行缩进(左)print 'please wait...system loading...'#reload(sys)PostUrl = "http://lib.hrbeu.edu.cn/#"driver=webdriver.Firefox()#用浏览器实现访问#driver = webdriver.PhantomJS(executable_path="phantomjs.exe")#没用浏览器driver.get(PostUrl)elem_user = driver.find_element_by_name('number')elem_psw = driver.find_element_by_name('passwd')#选择我的图书馆，点击后才能看到输入账号密码click_first = driver.find_element_by_xpath("//ul[@id='imgmenu']/li[4]")click_first.click()elem_user.send_keys('S315080092')elem_psw.send_keys('xxxxxxxxx')#点击登录click_second = driver.find_element_by_name('submit')click_second.click()print 'log in...'time.sleep(1)#定位新页面元素，将handle重定位即可driver.switch_to_window(driver.window_handles[1])#定位弹出的第一个页面，也就是当前页面#sreach_window = driver.current_window_handle #此行代码用来定位当前页面#不可行driver.find_element_by_xpath("/html/body/div[4]/div/div/ul/li[3]/a").click()driver.save_screenshot('image_booklist_firefox.jpg')print 'turning to the mylib...'time.sleep(1)#搜索结果页面停留片刻#driver.switch_to_window(driver.window_handles[1])#没有跳出新窗口就是在同一页面的！for i in range(2,30):#这里限定是29本书，一般我们都不会借那么多书的 try: #driver.find_element_by_xpath("/html/body/div[4]/div/div[2]/table/tbody/%s/td[8]/div/input"%('tr[%s]'%i)).click()#下面的比较好理解 driver.find_element_by_xpath("/html/body/div[4]/div/div[2]/table/tbody/tr[%s]/td[8]/div/input"%i).click() print 'renewing...the %d\'th book renewed '%(i-1) except: print '%d books have been renewed !'%(i-2) a=i-2 time.sleep(4) driver.save_screenshot('image_done_firefox.jpg') print 'the picture is saving...' print 'done!' breaktime.sleep(1)driver.close()driver.quit()
调用上述模块的主执行函数（其实就是为了封装上述模块而已，封装成gui界面，为后续的打包做准备)
# -*- coding: utf-8 -*-from Tkinter import *import tkMessageBox#执行gui窗import timedef check_renew(): print 'checking and renewing...' tkMessageBox.showinfo('提示','即将开启装逼模式，请确认已安装Firefox浏览器') #time.sleep(4) import Selenium_PhantomJS_lib_firefox tkMessageBox.showinfo('提示','已执行成功!\n(截图已保存于程序目录)')#主框架部分root = Tk()root.title('图书馆查询续约(哈尔滨工程大学专版))label=Label(root,text=' 图书馆一键查询与续约Firefox版本 (✪ω✪) ')button_check=Button(root,text='查询书单并续期━Σ(ﾟДﾟ|||)━开启Firefox有形装逼模式 ',background='green',command=check_renew)label.pack()button_check.pack()root.mainloop()
实现效果如图所示：

程序中的注释相信可以把程序解释的差不多了把。。。。
遇到问题和解决方案
selenium对新页面元素无法定位抛出NoSuchElementException: Message: Unable to locate element
错误，导致无法进行对新的界面进行点击操作。
解决方案：专门写了一篇博客，请见
解决Selenium弹出新页面无法定位元素问题（Unable to locate element）

对打包后的版本无法运行，抛出如图错误Errno 10054

解决方案：暂未找到解决方案，exe文件不可用，程序执行可用

对未知书籍数目重复点击操作，代码冗余
解决方案：因为点击续借按钮的元素每个都不一样，通过观察可知其中的规律，之后就知道在那进行修改，但是，光修改的话，十本书就有十个相似的代码串，很不pythontic，所以，采用格式化字符串的方式进行for循环带入，方便又漂亮！

使用了1中的解决方案还是不能定位元素
可能查找元素的方式出现错误，我现在的使用方法是采用xpath的方式来找，比如说这样
driver.find_element_by_xpath("/html/body/div[4]/div/div/ul/li[3]/a")虽然看起来有点长，但是元素相当好找，而且定位很准，如果采用类似这种driver.find_element_by_xpath("//ul[@id='imgmenu']/li[4]")，我现在还不能很好地驾驭，出错可能性有点大，下次要多进行尝试。
接下来实现方案二的构思：调用PhantomJS.exe，不展现浏览器的运作，直接在cmd窗口跑（用pyinstaller打包成exe后有cmd窗）
方案实现过程1. 效果
2. 代码
被调模块（可单独执行）

# -*- coding: utf-8 -*-from selenium import webdriverimport timeimport sysfrom PIL import Image#shift-tab多行缩进(左)print 'please wait...system loading...'reload(sys)PostUrl = "http://lib.hrbeu.edu.cn/#"driver = webdriver.PhantomJS(executable_path="phantomjs.exe")#没用浏览器driver.get(PostUrl)elem_user = driver.find_element_by_name('number')elem_psw = driver.find_element_by_name('passwd')#选择我的图书馆，点击后才能看到输入账号密码click_first = driver.find_element_by_xpath("//ul[@id='imgmenu']/li[4]")click_first.click()elem_user.send_keys('S315080092')elem_psw.send_keys('xxxxxxxx')#点击登录click_second = driver.find_element_by_name('submit')click_second.click()print 'log in...'time.sleep(1)#定位新页面元素，将handle重定位即可driver.switch_to_window(driver.window_handles[1])#定位弹出的第一个页面，也就是当前页面driver.find_element_by_xpath("/html/body/div[4]/div/div/ul/li[3]/a").click()driver.save_screenshot('image_booklist.jpg')print 'turning to the mylib...'time.sleep(1)#搜索结果页面停留片刻#driver.switch_to_window(driver.window_handles[1])#没有跳出新窗口就是在同一页面的！for i in range(2,30):#这里限定是29本书，一般我们都不会借那么多书的 try: driver.find_element_by_xpath("/html/body/div[4]/div/div[2]/table/tbody/%s/td[8]/div/input"%('tr[%s]'%i)).click() print 'renewing...the %d\'th book renewed '%(i-1) except: print '%d books have been renewed !'%(i-2) a=i-2 time.sleep(4) driver.save_screenshot('image_done.jpg') print 'the picture is opening...please wait...' breaktime.sleep(2)driver.close()driver.quit()def show_img(): im_check=Image.open('image_booklist.jpg') im_check.show() im_done =Image.open('image_done.jpg') im_done.show()

然后是程序入口

# -*- coding: utf-8 -*-from Tkinter import *import tkMessageBoxdef check_renew(): print 'checking and renewing...' tkMessageBox.showinfo('提示','执行速度取决于网速和电脑，能等着就按"确定"\n(请允许phantomjs.exe访问网络)\nBTW 你现在按啥都不好使，程序照样执行（*゜Д゜）σ凸') from Selenium_PhantomJS_lib import show_img show_img()#show一下预约前和预约后截图，好确认 tkMessageBox.showinfo('提示','已执行成功!\n(若没有弹出图片则请自行打开程序目录)')#主框架部分root = Tk()root.title('图书馆查询续约(哈尔滨工程大学专版)--by 哈士奇说喵')label=Label(root,text=' 图书馆一键查询与续约cmd版本 (✪ω✪) ')button_check=Button(root,text='查询书单并续期━Σ(ﾟДﾟ|||)━开启cmd无形装逼模式 ',background='green',command=check_renew)label.pack()button_check.pack()root.mainloop()

之后启动的画面应该是这样的



最后完成的画面应该是这样的，截图，确认框，cmd窗口，一个都不少；


原理和上面并没有什么区别，只是调用了一个phantomjs.exe文件而已，实际上的处理都是这个exe在进行处理的，所以，在进行打包的时候，打包出来的exe需要和此文件在一个文件夹下才可以，就像这样

遇到问题和解决方案
找不到执行文件，phantomjs.exe
解决方案：把phantomjs.exe添加到工作路径下，最方便的方法就是，你的工程在哪，直接添加到工程文件夹下就可以了

截图的图片没有显示出来，或者提示”在禁用UAC时无法激活此应用“
解决方案：图片有没有显示，可以看有没有调用show方法，如果调用了，那在自己电脑测试肯定是没有问题的，我在测试别的电脑的时候遇到UAC问题，直接启用就可以了，一般没有问题的，如果不想麻烦启动，那就直接去工作文件夹下手动打开看，截图已保存在本地的工作路径下的。
最后这个程序是可以打包在别的电脑进行运行的，不过账号和密码我都直接输在程序里面了，而且也只是我自己学校的专版，主要还是自己用，如果有哈尔滨工程大学的小伙伴想用，你只要自己改个账号密码参数就可以了，前提是你有完整的python开发环境。

一、任务介绍1.1 任务描述网上购物是人们日常生活的重要事情之一。在超市中有很多日常生活的用品，如电饭煲、蒸锅、洗衣机、电冰箱等。
本任务要求，通过所学Servlet、JavaBean和JDBC知识读取数据库数据，以JSP页面的形式呈现数据，用于数据浏览。
备注：

本任务需要编写2个JSP页面、2个Servlet文件（处读取商品列表信息和指定商品信息）、1-2个JavaBean文件、1个dao文件、1个service文件（实现功能）和1个数据库连接文件
本任务所需要的类文件，需要按如右图所示结构创建
当首次登录购买页面（访问相应的Servlet文件）时可以跳转到商品列表页面，当首次登录购物车页面（访问相应的Servlet文件）时可以有相应提示信息输出
单击某商品图片，进入商品详细页面，并且能有分页功能
要求商品列表页面，能够根据价格区间输入的价格范围筛选出相应的商品

1.2 运行结果商品列表页面

价格筛选后的商品列表页面

商品详细页面

1.3 任务目标
学会分析“实现购物车”程序的实现思路
根据思路独立完成“实现购物车”的源代码编写、编译和运行
掌握Servlet和JSP运行原理
掌握JavaBean、EL表达式和JSP标签库（JSTL）的使用
掌握分页技术的原理以及实现
熟练应用Servlet技术、JavaBean和JDBC技术完成数据访问。

二、实现思路
单击某商品图片，进入商品详细页面思路在<img>外层嵌套<a>标签，<a>标签设置herf属性，该属性存放商品详细信息页面的路径。
能有分页功能思路在servlet中通过SQL语句的limit关键字实现分页查询，查询结果存放在list中，以及存放currentPage当前页面属性、totalPage总页面属性；将该数据利用request.setAttribute(string,value );传至前端页面。在JSP页面中通过${}表达式遍历输出list集合中的数据，设置4个button分别对应首页、前一页、下一页、尾页;编写<script>脚本实现点击事件的函数、分别为firstPage、previousPage、nextPage、lastPage;当条件满足时实现跳转显示下一页。【不跳转的条件，在首页按首页、前一页；在尾页按下一页、尾页】
根据价格区间输入的价格范围筛选出相应的商品思路在servlet中利用request.getParameter(“string”);获取前端的价格区间的输入信息，在servlet实现查询信息存储在list中request.setAttribute(string,value );传至前端页面。

三、实现代码以及运行效果Pagination(servelt)

sy2Allbook(servlet)

sy2SearchServelet

四、总结或感悟4.1 错误总结
对分页查询不熟练导致在程序显示错误
在<script>脚本中无法跳转servlet();



在SQLyog无法保存修改的数据
4.2 错误解决
利用最简单的limit关键词实现分页查询
在csdn中学习他人方法，即在路径在加 ”./”。


4.3 未解决错误
在SQLyog无法保存修改的数据
4.4 总结感悟本次实验学习到简单的分页显示功能，对<script>脚本语言的简单复习，经过这次的实验，在实验中学习到了我对前端的请求相应有了更深的理解。本实验存在不足之处在价格区间查询时未进行分页显示而是将所有信息显示在页面中，由于SQLyog的无法保存修改数据，部分的商品详细信息链接并未实现。

一、实践要求要求以前后端分离的形式，运用合适的语言平台开发一个注册、登录和信息修改的小程序。
二、实现思路2.1 总体思路
采用JQuery+PHP+JSON完成实验
利用三层体系结构,即模型、视图、控制器实现前端、后端分离
利用ajax实现异步刷新页面，实现资源合理利用
设计登录界面，实现用户登录
设计注册页面，实现用户注册，即“增”
设计修改页面，实现用户信息修改，即“改“

2.2 体系结构
2.3 开发工具与平台介绍2.3.1 Sublime TextSublime Text 是一个代码编辑器（Sublime Text 2是收费软件，但可以无限期试用），也是HTML和散文先进的文本编辑器。Sublime Text是由程序员Jon Skinner于2008年1月份所开发出来，它最初被设计为一个具有丰富扩展功能的Vim。
2.3.2 XAMPPXAMPP（Apache+MySQL+PHP+PERL）是一个功能强大的建站集成软件包。这个软件包原来的名字是 LAMPP，但是为了避免误解，最新的几个版本就改名为 XAMPP 了。它可以在Windows、Linux、Solaris、Mac OS X 等多种操作系统下安装使用，支持多语言：英文、简体中文、繁体中文、韩文、俄文、日文等。
2.3.3 ajaxAjax 即“Asynchronous Javascript And XML”（异步 JavaScript 和 XML），是指一种创建交互式网页应用的网页开发技术。Ajax = 异步 JavaScript 和 XML 或者是 HTML（标准通用标记语言的子集）。Ajax 是一种用于创建快速动态网页的技术。Ajax 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
2.3.4 JSONJSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。它基于 ECMAScript (欧洲计算机协会制定的js规范)的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
2.3.5 PHP （超文本预处理器）PHP即“超文本预处理器”，是一种通用开源脚本语言。PHP是在服务器端执行的脚本语言，与C语言类似，是常用的网站编程语言。PHP独特的语法混合了C、Java、Perl以及 PHP 自创的语法。利于学习，使用广泛，主要适用于Web开发领域。
2.3.6 jQueryjQuery是一个快速、简洁的JavaScript框架，是继Prototype之后又一个优秀的JavaScript代码库（或JavaScript框架）。jQuery设计的宗旨是“write Less，Do More”，即倡导写更少的代码，做更多的事情。它封装JavaScript常用的功能代码，提供一种简便的JavaScript设计模式，优化HTML文档操作、事件处理、动画设计和Ajax交互。jQuery的核心特性可以总结为：具有独特的链式语法和短小清晰的多功能接口；具有高效灵活的css选择器，并且可对CSS选择器进行扩展；拥有便捷的插件扩展机制和丰富的插件。
2.4 注册功能
界面:

设置三个input文本输入框，一个为id，一个为username，一个为password填写注册信息设置一个submit对填写信息的提交设置一个超链接实现注册的页面跳转放回登录界面。
功能:

点击保存实现用户的信息写入数据库
思路:通过mysqli连接MySQL数据库，将输入框中的数据保存在PHP的数组array中，利用json_encode和json_decode实现数值转换成json数据存储格式，最后利用SQL语句存入MySQL中

关键源码
<?php if(isset($_POST['save'])){ $conn = new mysqli('localhost', 'root', '', 'app'); $input = array( 'id' => $_POST['id'], 'username' => $_POST['username'], 'password' => $_POST['password'], ); $data[] = $input; $data = json_encode($data); $data = json_decode($data); echo $data[0]->id; foreach ($data as $user) { $sql="INSERT INTO members (id,username,password) VALUES ($user->id,'$user->username','$user->password')"; echo $sql; $result = $conn->query($sql); //查询执行成功 echo $result;//返回1表示成功 } header('location: index.php'); }?>

2.5 登录功能
界面:

设置两个input文本输入框，一个为username，另一个为password输入用户名密码设置一个button登录按钮设置一个超链接实现注册的页面跳转
关键代码
<?phpif(!empty($_POST['username'])){ $data = array() //database details $dbHost = 'localhost'; $dbUsername = 'root'; $dbPassword = ''; $dbName = 'app'; //create connection and select DB $db = new mysqli($dbHost, $dbUsername, $dbPassword, $dbName); if($db->connect_error){ die("Unable to connect database: " . $db->connect_error); } //get user data from the database $query = $db->query("SELECT * FROM members WHERE username = {$_POST['username']} and password = {$_POST['password']}" ); if($query->num_rows > 0){ $userData = $query->fetch_assoc(); $data['status'] = 'ok'; $data['result'] = $userData; }else{ $data['status'] = 'err'; $data['result'] = ''; } //returns data as JSON format echo json_encode($data);}?>
<script src="jquery-3.4.1.js"></script> <script> $(document).ready(function(){ $('#getUser').on('click',function(){ $.ajax({ type:'POST', url:'getData.php', dataType: "json", data: { // 要传递的数据 "username": $("#username").val(), "password": $("#password").val() }, success:function(data){ if(data.status == 'ok'){ alert("登录成功！"); window.location.href="index.php" }else{ alert("用户名或密码错误！"); } }});}); $("#username").blur(function (){ $.ajax({ type:'POST', url:'getData.php', dataType: "json", data: { // 要传递的数据 "username": $("#username").val() }, success:function(data){ if(data.status == 'ok'){ }else{ alert("用户名不存在！"); } }});});});</script>
功能:

用户名输入框失去焦点，判断用户是否存在
思路：利用ID选择器，选择输入框username，利用JQuery的blur()事件判断是否失去焦点，利用ajax异步传值通过放回值，判断数据库中是否有该信息，若不存在则提示用户名不存在
点击确认判断用户名密码是否正确。
思路：利用ID选择器，选择输入框input，利用JQuery的click()事件判断是否触发事件，利用ajax异步传值通过放回值，判断数据库中用户名密码是否正确，它利用alert提示性


2.6 信息修改
界面:

设置三个input文本输入框，一个为id，一个为username，一个为password填写修改信息设置一个submit对填写信息的提交设置一个超链接实现注册的页面跳转放回登录界面
功能:

点击编辑实现用户的信息修改数据库
思路:通过mysqli连接MySQL数据库，将输入框中的数据保存在PHP的数组array中，利用json_encode和json_decode实现数值转换成json数据存储格式，最后利用SQL语句存入MySQL中

关键代码
<?php if(isset($_POST['save'])){ $conn = new mysqli('localhost', 'root', '', 'app'); $input = array( 'id' => $_POST['id'], 'username' => $_POST['username'], 'password' => $_POST['password'], ); //update the selected index $data_array[$index] = $input; //encode back to json $data = json_encode($data_array); $data = json_decode($data); // 解析json echo $data[0]->id; foreach ($data as $user) { $sql="update members set username='$user->username',password='$user->password' where id=$user->id"; echo $sql; $result = $conn->query($sql); //查询执行成功 echo $result;//返回1表示成功 } header('location: index.php'); }?>

2.7 信息删除
功能:

点击删除实现用户的信息删除
思路:通过mysqli连接MySQL数据库，将输入框中的数据保存在PHP的数组array中，利用json_encode和json_decode实现数值转换成json数据存储格式，最后利用SQL语句存入MySQL中

关键代码
<?php $index = $_GET['index']; $conn = new mysqli('localhost', 'root', '', 'app'); $data = array(); $sql = "SELECT * FROM members"; $query = $conn->query($sql); while($row = $query->fetch_assoc()){ $data[] = $row; } //convert to json $data = json_encode($data); $data_array = json_decode($data); //assign the data to selected index $row = $data_array[$index]; $data = json_encode($data, JSON_PRETTY_PRINT); $data = json_decode($data); // 解析json $sql = "delete from members where id=$row->id"; $query = $conn->query($sql); header('location: index.php'); unset($data[$index]);?>

三、成果展示3.1 注册功能注册前

注册

注册完成

3.2 登录功能登录前

登录成功

登陆失败

3.3 信息修改功能修改前

修改

修改成功

3.4 信息删除功能删除前

删除成功

四、疑难问题及解决思路
选择实现语言出现问题

解决：根据课设要求，选择PHP\JAVA上出现先选择Java随着进度，在写JSP作为View中利用Ajax时错误频出，以及用IDEA开发工具配置Tomcat出现系统错误，而后选择PHP作为主要实现工具
端口配置问题，在配置环境之初出现被端口占用

解决：通过老师的指导，以及利用网络学习如何修改端口
Ajax不相应问题

解决: 查找Ajax相关的资料，结合课设中老师所发的资料解决该问题

五、总结感悟本次的课程设计，使用JQuery+PHP+JSON进行系统的开发, 在设计之余，查询过资料，了解Ajax的相关知识。在开发过程中，大大小小的会遇到些问题，在询问老师或上网查找资料的过程中，对这项开发技术的一些细节也有了更深的理解和掌握。
由于时间比较紧张，以及设计之初选用Java最终选择用PHP做为开发语言，所以对于整体的系统美化存在一定的瑕疵，但是功能基本实现，经过这两天的课程设计体会到项目开发的的不易，以及自身知识的不足，以及快速简单入门一种语言的方法：通过网络他人总结的经验简单有效的学习。
总的来说，本次的课程设计对我是一次很好的锻炼，让我在有限的时间对系统开发的有了新的了解。对分层体系结构有了一定的了解，前端和后端的区别、对未知领域的探索，从不了解JSON、Ajax时什么到能够独立使用其常用方法。
去分析一个复杂的问题，一步一步进行分解，从小问题进行解决从而实现复杂的功能。
参考资料
[1]. [美] Lindsay Bassett (作者) 魏嘉汛 (译者)：《JSON必知必会》，人民邮电出版社，2016年出版。
[2]. [美]汤姆·马尔斯(作者)鉊钏(译者)：《JSON实战》，人民邮电出版社，2017年出版。

一、任务介绍1.1 任务描述本任务要搭建一个考试系统界面。考试题型主要有两类：判断题和单选题，题库是存放在两个二维数组中，要求考试题目能随机生成5到题目，并能通过左边的树形结构选择相应题型来改变右边面板的内容，具体运行效果如下。
1.2 运行结果主界面

判断题

单选题

二、任务目标
学会分析“简易考试系统界面搭建”任务的实现思路
根据思路独立完成“简易考试系统界面搭建”的源代码编写、编译和运行
掌握Java动态生成组件的方法以及添加组件的方法
掌握GUI开发过程中如何处理组件上发生的界面事件

三、实现思路
窗口实现思路:
设计产生随机数作为存放二维数组的下标，设置组件JLabel存放改下标中题目，设置组件JRadioButton存放选择选择项，将组件JRadioButton存放在组件ButtonGroup将选择像设置为单选。
阅卷取消思路:利用ButtonGroup类中的clearSelection清空每组选择的选项，通过已知产生五组题目，即生成一个ButtonGroup[]的组件组，该组的长度为五，通过
Enumeration<AbstractButton> radioBtns = buttonGroup[i].getElements();AbstractButton btn = radioBtns.nextElement();
获得每一个ButtonGroup[]中的选择项与答案进行比较。【利用产生题目的随机数组定位答案进行判断】

四、实现代码及运行结果My.java
public interface My extends MouseListener, ActionListener { public void setJButton(JButton jButton[]); public void setJRadioButton(JRadioButton jRadioButton[]); public void setButtonGroup(ButtonGroup Group[]); public void setIntA(int a[]); public void setquestion_select(String string[][]); public void setquestion_judge(String string[][]); void setTree(JTree jTree);}
Police.java
public class Police extends MouseAdapter implements My { JButton jButton[]; JRadioButton jRadioButton[]; ButtonGroup buttonGroup[]; JTree jTree; int a[]; String[][] question_select; String[][] question_judge; @Override public void actionPerformed(ActionEvent e) { double Mark = 0; if (e.getActionCommand().equals("确定")) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) jTree.getLastSelectedPathComponent(); if (node.isLeaf()) { String s = node.getUserObject().toString().trim(); if (s.equals("判断")) { for (int i = 0; i < a.length; i++) { Enumeration<AbstractButton> radioBtns = buttonGroup[i].getElements(); AbstractButton btn = radioBtns.nextElement(); System.out.println(question_select[a[i]][5]); System.out.println(btn.getText()); if (question_select[a[i]][5].equals(btn.getText())) { Mark += 20; } buttonGroup[i].clearSelection(); } JOptionPane.showMessageDialog(null, "成绩:" + Mark, "成绩", JOptionPane.WARNING_MESSAGE); } else { Mark = 0; for (int i = 0; i < a.length; i++) { Enumeration<AbstractButton> radioBtns = buttonGroup[i].getElements(); AbstractButton btn = radioBtns.nextElement(); System.out.println(question_judge[a[i]][3]); System.out.println(btn.getText()); if (question_judge[a[i]][3].equals(btn.getText())) { Mark += 20; } buttonGroup[i].clearSelection(); } JOptionPane.showMessageDialog(null, "成绩:" + Mark, "成绩", JOptionPane.WARNING_MESSAGE); } } } else { for (int i = 0; i < buttonGroup.length; i++) { buttonGroup[i].clearSelection(); } } }
Masm_test.java
public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { try { Masm_test window = new Masm_test(); Police police = new Police(); window.setMy(police); window.frame.setVisible(true); } catch (Exception e) { e.printStackTrace(); } } }); } /** * Create the application. */ public Masm_test() { initialize(); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } /** * Initialize the contents of the frame. */ private void initialize() { frame = new JFrame(); frame.setBounds(100, 100, 609, 471); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().setLayout(null); JPanel panel = new JPanel(); panel.setBounds(0, 0, 594, 419); frame.getContentPane().add(panel); panel.setLayout(null); JSplitPane splitPane = new JSplitPane(); splitPane.setBounds(0, 0, 594, 409); panel.add(splitPane); jButton = new JButton[2]; jButton[0] = new JButton("确定"); jButton[1] = new JButton("取消"); jRadioButton = new JRadioButton[4]; group = new ButtonGroup[6]; tree = new JTree(); tree.addMouseListener(new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); if (node.isLeaf()) { String s = node.getUserObject().toString().trim(); if (s.equals("判断")) { show(1); } else { show(0); } } } }); tree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("JTree") { { add(new DefaultMutableTreeNode("\u5224\u65AD")); add(new DefaultMutableTreeNode("\u5355\u9009")); } })); splitPane.setLeftComponent(tree); scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS); splitPane.setRightComponent(scrollPane); } void show(int n) { JPanel panel = new JPanel(new GridLayout(7, 1, 0, 0)); a = new int[6]; for (int i = 0; i < 6; i++) { a[i] = (int) (Math.random() * (10)); for (int j = 0; j < i; j++) { if (a[j] == a[i]) { i--; } } } listener.setIntA(a); if (n == 0) { for (int i = 0; i < 6; i++) { JPanel p = new JPanel(new GridLayout(3, 1, 0, 0)); lab = new JLabel(i + 1 + "、" + question_judge[a[i]][0]); // lab.addActionListener(listener); group[i] = new ButtonGroup(); p.add(lab); for (int j = 0; j < 2; j++) { jRadioButton[j] = new JRadioButton(question_judge[a[i]][j + 1]); group[i].add(jRadioButton[j]); p.add(jRadioButton[j]); // jRadioButton[j].addActionListener(listener); } panel.add(p); } // scrollPane.setViewportView(panel); } if (n == 1) { // JPanel panel = new JPanel(new GridLayout(6, 1, 0, 0)); for (int i = 0; i < 6; i++) { JPanel p = new JPanel(new GridLayout(5, 1, 0, 0)); lab = new JLabel(i + 1 + "、" + question_select[a[i]][0]); // lab.addActionListener(listener); group[i] = new ButtonGroup(); p.add(lab); for (int j = 0; j < jRadioButton.length; j++) { jRadioButton[j] = new JRadioButton(question_select[a[i]][j + 1]); group[i].add(jRadioButton[j]); p.add(jRadioButton[j]); // jRadioButton[j].addActionListener(listener); } panel.add(p); } } scrollPane.setViewportView(panel); JPanel panel_south = new JPanel(); panel_south.add(jButton[0]); panel_south.add(jButton[1]); panel.add(panel_south); } void setMy(My listener) { this.listener = listener; for (int i = 0; i < jButton.length; i++) { jButton[i].addActionListener(listener); } listener.setButtonGroup(group); listener.setJButton(jButton); listener.setTree(tree); listener.setquestion_judge(question_judge); listener.setquestion_select(question_select); // listener.setJRadioButton(jRadioButton); }
登入首页

判断题

单选题

五、总结或感悟通过实验三，实验四的对编写代码实现窗口，熟练掌握常用组件的常用方法的使用。本次实验结合Windowbuilder插件对组件布局很快的完成实现”出卷”;
根据实验提示选项单选的情况使用ButtonGroup存放选项radioBtns实现单选；根据提示一次出道五题想到获取每组ButtonGroup选择情况与答案进行对比实现“阅卷”。
结合三次实验，虽然在前两次实验中使用大量的时间学习如何布局，组件的使用，触发事件的过程，但是在第三次实验体现出了前两次实验的必要性；如何合理的封装程序，实现改变ButtonGroup[]的长度便改变题目的个数，以及将窗口可见的组件做成员变量，窗口不可见的做局部变量传入事件触发后的处理类（Police）中的方法。

Python 2.7IDE Pycharm 5.0.3
起因
昨天接触了Tkinter框架，之后就迫不及待的想写个计算器出来，结果呢，可想而知了，当初自己犟脾气，掌握几个语法后就想什么都不参考写自己的一段四则运算器出来，结果。。。。。。花了我一天时间，我竟然歪打正着写了个规则器出来窝草。。。。

对比
贴个图，别人家的计算器是这样的；而且用了五十行，说的貌似很了不起的样子（老纸的规则器，只要40-就可以！不算上Scrollbar，分割子框架这类的）


But
我的规则器是这样的。。。。


我知道布局排丑了，不要在意这些细节好么0.0
说说优点
以计算器角度说，能完美实现计算，而且带标号，记录存储等功能，知道上一步计算结果。
最大的优点在于二输入，调用各种def的函数，而四则运算只是最简单的函数而已，比如说我又写了字符串连接函数，相似度比较函数等等，做个实例而已，大家可以大开脑洞

缺点
需要键盘输入，与普通计算器按键输入不同
我的代码冗余量比较大，因为自己需要看懂，所以不像别的教程那样直接跟着lambda和pack，一长串的，不利于我们这种小白读。等我水平再高一些，或许我也会采用lambda，这样才够pythontic~

后续
本身在做分类聚类方面的课题，结合这个规则器，我完全可以把k-means中的k参数在交互界面上输入，这样就不用每次上程序里面改了！还有DBSCAN里面的Eps和MinPts也可以直接用这个框架！！想想有点小激动呢！(挖的坑不计其数)
需要优化下布局，尝试用grid来做，感觉pack里面参数略多啊。

构思框架放代码之前，先来设计思路，我设计了两个框架，输入和输出在两个框架上，这样便于写代码思路清晰，框架大概是这样的；

代码此代码(就算再烂)绝此一家，别无分店哈哈
#-------------------二输入规则计算器--------------------# -*- coding: utf-8 -*-from Tkinter import *import difflib#主框架部分root = Tk()root.title('乞丐版规则器0.0')root.geometry()Label_root=Label(root,text='规则运算(根框架)',font=('宋体',15))#-----------------------定义规则------------------------def Plus(a,b): return round(a+b, 2)def Sub(a,b): return round(a-b,2)def Mult(a,b): return round(a*b, 2)def Div(a,b): return round(a/b, 2)def P_str(a,b): return a+bdef Rep(a,b): return difflib.SequenceMatcher(None,a,b).ratio() #difflib可以看看其中的定义，计算匹配率的#还可以继续增加规则函数，只要是两输入的参数都可以#----------------------触发函数-----------------------def Answ():#规则函数 if lb.get(lb.curselection()).encode('utf-8') == '加': Ans.insert(END,'规则:+ ->'+str(Plus(float(var_first.get()),float(var_second.get())))) if lb.get(lb.curselection()).encode('utf-8')=='减': Ans.insert(END,'规则:- ->'+str(Sub(float(var_first.get()),float(var_second.get())))) if lb.get(lb.curselection()).encode('utf-8')=='乘': Ans.insert(END,'规则:x ->'+str(Mult(float(var_first.get()),float(var_second.get())))) if lb.get(lb.curselection()).encode('utf-8')=='除': Ans.insert(END,'规则:/ ->'+str(Div(float(var_first.get()),float(var_second.get())))) if lb.get(lb.curselection()).encode('utf-8')=='字符串连接': Ans.insert(END,'规则：字符串连接 ->' +P_str(var_first.get(),var_second.get()).encode('utf-8')) if lb.get(lb.curselection()).encode('utf-8')=='字符串相似度': Ans.insert(END,'规则:字符串相似度 ->'+str(Rep(var_first.get(),var_second.get()))) #添加规则后定义规则函数def Clea():#清空函数 input_num_first.delete(0,END)#这里entry的delect用0 input_num_second.delete(0,END) Ans.delete(0,END)#text中的用0.0#----------------------输入选择框架--------------------frame_input = Frame(root)Label_input=Label(frame_input, text='(输入和选择框架)', font=('',15))var_first = StringVar()var_second = StringVar()input_num_first = Entry(frame_input, textvariable=var_first)input_num_second = Entry(frame_input, textvariable=var_second)#---------------------选择运算规则---------------------#还可以添加其他规则lb = Listbox(frame_input,height=4)list_item=['加', '减', '乘', '除','字符串连接','字符串相似度']for i in list_item: lb.insert(END,i)#---------------------计算结果框架---------------------frame_output = Frame(root)Label_output=Label(frame_output, text='(计算结果框架)', font=('',15))Ans = Listbox(frame_output, height=5,width=30)#text也可以，Listbox好处在于换行#-----------------------Button-----------------------calc = Button(frame_output,text='计算', command=Answ)cle = Button(frame_output,text='清除', command=Clea)#---------------------滑动Scrollbar-------------------scr1 = Scrollbar(frame_input)lb.configure(yscrollcommand = scr1.set)scr1['command']=lb.yviewscr2 = Scrollbar(frame_output)Ans.configure(yscrollcommand = scr2.set)scr2['command']=Ans.yview#-------------------------布局------------------------#布局写在一块容易排版，可能我low了吧Label_root.pack(side=TOP)frame_input.pack(side=TOP)Label_input.pack(side=LEFT)input_num_first.pack(side=LEFT)lb.pack(side=LEFT)scr1.pack(side=LEFT,fill=Y)input_num_second.pack(side=RIGHT)frame_output.pack(side=TOP)Label_output.pack(side=LEFT)calc.pack(side=LEFT)cle.pack(side=LEFT)Ans.pack(side=LEFT)scr2.pack(side=LEFT,fill=Y)#-------------------root.mainloop()------------------root.mainloop()
Tkinter还是比较好上手的，知道一些基本语法就可以实现自己想要的效果了，这里我把自己遇到的问题写一下，如果也有人遇到，恰好能帮助的话，我很荣幸。
问题&解决Q.button或插件不显示A.记得加上pack显示函数！！一般我都定义完了插件直接补上 pack函数
Q.插件位置显示问题A.这个要看你的pack函数写在哪了，所以我一般直接写在最后，容易排序，比如side都是LEFT的话，就按先后顺序显示的
Q.刚开始键入的被get之后，直接运算出错。A.结果是str类型，所以记得用float强制转换，不用int是因为int做除法时候不好使，需要float，切记（python2.7）
Pay Attention
在自定义规则的时候，主要get抓到的数据类型和你的def里面的数据类型，保持一致。
清空函数中，text和entry，listbox的delect清空不一样！比如被实例的是Listbox(Entry)的，那么清空是Obj.delect(0,END),而如果是Text的对象，那么就是Obj.delect(0.0,END)，这个是我之前没想到的，只有实践过才记得住把。而且，用listbox好处在于计算一个值之后，下一个值自动换行，用text时候\n还不好使
如果使用python3，会出现，no model name Tkinter,其实py3只是把它改成小写了，所以导入包的时候改成tkinter 小写就行
出现点击运算符之后无法输出结果或者gui中文乱码问题，一般也是出现在python3的问题上，所以解决方案是吧encode(‘utf-8’)删掉就可以了。

1 游戏介绍「消灭星星」是一款很经典的「消除类游戏」，它的玩法很简单：消除相连通的同色砖块。

「消灭星星」存在多个版本，不过它们的规则除了「关卡分值」有些出入外，其它的规则都是一样的。笔者介绍的版本的游戏规则整理如下：
1. 色砖分布

10 x 10 的表格
5种颜色 ——— 红、绿、蓝，黄，紫
每类色砖个数在指定区间内随机
5类色砖在 10 x 10 表格中随机分布

2. 消除规则
两个或两个以上同色砖块相连通即是可被消除的砖块。
3. 分值规则

消除总分值 = n * n * 5
奖励总分值 = 2000 - n * n * 20

「n」表示砖块数量。上面是「总」分值的规则，还有「单」个砖块的分值规则：

消除砖块得分值 = 10 * i + 5
剩余砖块扣分值 = 40 * i + 20

「i」表示砖块的索引值（从 0 开始）。简单地说，单个砖块「得分值」和「扣分值」是一个等差数列。
4. 关卡分值
关卡分值 = 1000 + (level - 1) * 2000；「level」即当前关卡数。
5. 通关条件

可消除色块不存在
累计分值 >= 当前关卡分值

上面两个条件同时成立游戏才可以通关。
2 MVC 设计模式笔者这次又是使用了 MVC 模式来写「消灭星星」。星星「砖块」的数据结构与各种状态由 Model 实现，游戏的核心在 Model 中完成；View 映射 Model 的变化并做出对应的行为，它的任务主要是展示动画；用户与游戏的交互由 Control 完成。
从逻辑规划上看，Model 很重而View 与 Control 很轻，不过，从代码量上看，View 很重而 Model 与 Control 相对很轻。
2.1 Model10 x 10 的表格用长度为 100 的数组可完美映射游戏的星星「砖块」。
[ R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P, R, R, G, G, B, B, Y, Y, P, P]
R - 红色，G - 绿色，B - 蓝色，Y - 黄色，P - 紫色。Model 的核心任务是以下四个：

生成砖墙
消除砖块 （生成砖块分值）
夯实砖墙
清除残砖 （生成奖励分值）

2.1.1 生成砖墙砖墙分两步生成：

色砖数量分配
打散色砖

理论上，可以将 100 个格子可以均分到 5 类颜色，不过笔者玩过的「消灭星星」都不使用均分策略。通过分析几款「消灭星星」，其实可以发现一个规律 ——— 「色砖之间的数量差在一个固定的区间内」。
如果把传统意义上的均分称作「完全均分」，那么「消灭星星」的分配是一种在均分线上下波动的「不完全均分」。

笔者把上面的「不完全均分」称作「波动均分」，算法的具体实现可以参见「波动均分算法」。
「打散色砖」其实就是将数组乱序的过程，笔者推荐使用「 费雪耶兹乱序算法」。
以下是伪代码的实现：
// 波动均分色砖waveaverage(5, 4, 4).forEach( // tiles 即色墙数组 (count, clr) => tiles.concat(generateTiles(count, clr)); ); // 打散色砖shuffle(tiles);
2.1.2 消除砖块「消除砖块」的规则很简单 ——— 相邻相连通相同色即可以消除。

前两个组合符合「相邻相连通相同色即可以消除」，所以它们可以被消除；第三个组合虽然「相邻相同色」但是不「相连通」所以它不能被消除。
「消除砖块」的同时有一个重要的任务：生成砖块对应的分值。在「游戏规则」中，笔者已经提供了对应的数学公式：「消除砖块得分值 = 10 * i + 5」。
「消除砖块」算法实现如下：
function clean(tile) { let count = 1; let sameTiles = searchSameTiles(tile); if(sameTiles.length > 0) { deleteTile(tile); while(true) { let nextSameTiles = []; sameTiles.forEach(tile => { nextSameTiles.push(...searchSameTiles(tile)); makeScore(++count * 10 + 5); // 标记当前分值 deleteTile(tile); // 删除砖块 }); // 清除完成，跳出循环 if(nextSameTiles.length === 0) break; else { sameTiles = nextSameTiles; } } }}
清除的算法使用「递归」逻辑上会清晰一些，不过「递归」在浏览器上容易「栈溢出」，所以笔者没有使用「递归」实现。
2.1.3 夯实砖墙砖墙在消除了部分砖块后，会出现空洞，此时需要对墙体进行夯实：










向下夯实
向左夯实
向左下夯实（先下后左）



一种快速的实现方案是，每次「消除砖块」后直接遍历砖墙数组（10x10数组）再把空洞夯实，伪代码表示如下：
for(let row = 0; row < 10; ++row) { for(let col = 0; col < 10; ++col) { if(isEmpty(row, col)) { // 水平方向（向左）夯实 if(isEmptyCol(col)) { tampRow(col); } // 垂直方向（向下）夯实 else { tampCol(col); } break; } }}
但是，为了夯实一个空洞对一张大数组进行全量遍历并不是一种高效的算法。在笔者看来影响「墙体夯实」效率的因素有：

定位空洞
砖块移动（夯实）

扫描墙体数组的主要目的是「定位空洞」，但能否不扫描墙体数组直接「定位空洞」？
墙体的「空洞」是由于「消除砖块」造成的，换种说法 ——— 被消除的砖块留下来的坑位就是墙体的空洞。在「消除砖块」的同时标记空洞的位置，这样就无须全量扫描墙体数组，伪代码如下：
function deleteTile(tile) { // 标记空洞 markHollow(tile.index); // 删除砖块逻辑 ...}
在上面的夯实动图，其实可以看到它的夯实过程如下：

空洞上方的砖块向下移动
空列右侧的砖块向左移动

墙体在「夯实」过程中，它的边界是实时在变化，如果「夯实」不按真实边界进行扫描，会产生多余的空白扫描：

如何记录墙体的边界？
把墙体拆分成一个个单独的列，那么列最顶部的空白格片段就是墙体的「空白」，而其余非顶部的空白格片段即墙体的「空洞」。

笔者使用一组「列集合」来描述墙体的边界并记录墙体的空洞，它的模型如下：
/* @ count - 列砖块数 @ start - 顶部行索引 @ end - 底部行索引 @ pitCount - 坑数 @ topPit - 最顶部的坑 @ bottomPit - 最底部的坑*/ let wall = [ {count, start, end, pitCount, topPit, bottomPit}, {count, start, end, pitCount, topPit, bottomPit}, ...];
这个模型可以描述墙体的三个细节：

空列
列的连续空洞
列的非连续空洞

// 空列if(count === 0) { ...}// 连续空洞else if(bottomPit - topPit + 1 === pitCount) { ...}// 非连续空洞else { ...}
砖块在消除后，映射到单个列上的空洞会有两种分布形态 ——— 连续与非连续。

「连续空洞」与「非连续空洞」的夯实过程如下：

其实「空列」放大于墙体上，也会有「空洞」类似的分布形态 ——— 连续与非连续。

它的夯实过程与空洞类似，这里就不赘述了。
2.1.4 消除残砖上一小节提到了「描述墙体的边界并记录墙体的空洞」的「列集合」，笔者是直接使用这个「列集合」来消除残砖的，伪代码如下：
function clearAll() { let count = 0; for(let col = 0, len = this.wall.length; col < len; ++col) { let colInfo = this.wall[col]; for(let row = colInfo.start; row <= colInfo.end; ++row) { let tile = this.grid[row * this.col + col]; tile.score = -20 - 40 * count++; // 标记奖励分数 tile.removed = true; } }}
2.2 ViewView 主要的功能有两个：

UI 管理
映射 Model 的变化（动画）

UI 管理主要是指「界面绘制」与「资源加载管理」，这两项功能比较常见本文就直接略过了。View 的重头戏是「映射 Model 的变化」并完成对应的动画。动画是复杂的，而映射的原理是简单的，如下伪代码：
update({originIndex, index, clr, removed, score}) { // 还没有 originIndex 或没有色值，直接不处理 if(originIndex === undefined || clr === undefined) return ; let tile = this.tiles[originIndex]; // tile 存在，判断颜色是否一样 if(tile.clr !== clr) { this.updateTileClr(tile, clr); } // 当前索引变化 ----- 表示位置也有变化 if(tile.index !== index) { this.updateTileIndex(tile, index); } // 设置分数 if(tile.score !== score) { tile.score = score; } if(tile.removed !== removed) { // 移除或添加当前节点 true === removed ? this.bomb(tile) : this.area.addChild(tile.sprite); tile.removed = removed; }}
Model 的砖块每次数据的更改都会通知到 View 的砖块，View 会根据对应的变化做对应的动作（动画）。
2.3 ControlControl 要处理的事务比较多，如下：

绑定 Model & View
生成通关分值
判断通关条件
对外事件
用户交互

初始化时，Control 把 Model 的砖块单向绑定到 View 的砖块了。如下：
Object.defineProperties(model.tile, { originIndex: { get: () => {...}, set: () => { ... view.update({originIndex}); } }, index: { get: () => {...}, set: () => { ... view.update({index}); } }, clr: { get: () => {...}, set: () => { ... view.update({clr}); } }, removed: { get: () => {...}, set: () => { ... view.update({removed}); } }, score: { get: () => {...}, set: () => { ... view.update({score}); } }, });
「通关分值」与「判断通关条件」这对逻辑在本文的「游戏规则」中有相关介绍，这里不再赘述。
对外事件规划如下：



name
detail




pass
通关


pause
暂停


resume
恢复


gameover
游戏结束



用户交互 APIs 规划如下：



name
type
deltail




init
method
初始化游戏


next
method
进入下一关


enter
method
进入指定关卡


pause
method
暂停


resume
method
恢复


destroy
method
销毁游戏



3 问题在知乎有一个关于「消灭星星」的话题：popstar关卡是如何设计的？
这个话题在最后提出了一个问题 ——— 「无法消除和最大得分不满足过关条件的矩阵」。

「无法消除的矩阵」其实就是最大得分为0的矩阵，本质上是「最大得分不满足过关条件的矩阵」。
最大得分不满足过关条件的矩阵
求「矩阵」的最大得分是一个 「背包问题」，求解的算法不难：对当前矩阵用「递归」的形式把所有的消灭分支都执行一次，并取最高分值。但是 javascript 的「递归」极易「栈溢出」导致算法无法执行。
其实在知乎的话题中提到一个解决方案：

网上查到有程序提出做个工具随机生成关卡，自动计算，把符合得分条件的关卡筛选出来

这个解决方案代价是昂贵的！笔者提供有源码并没有解决这个问题，而是用一个比较取巧的方法：进入游戏前检查是事为「无法消除矩阵」，如果是重新生成关卡矩阵。
注意：笔者使用的取巧方案并没有解决问题。

1 需求分析1.1 五类地方旅游类App下载量分布图从下载量来看，交通出行类App显然是最受用户欢迎的，在数量少于景点攻略类App的情况下，交通出行类App总下载量为前者2.43倍，占总下载量的70%。六大平台中仅有应用宝上，交通出行类App总下载量低于景点攻略类App。

1.2 六大商店地方旅游类App下载量分布图六大商店地方旅游类App下载量显示，在百度手机助手上线的地方旅游类App总计下载量为8912449次，明显领先360助手、安卓市场、安智市场、豌豆荚、应用宝五家商店。

2 可行性分析经济可行性

服务器：Linux系统的阿里云服务器
PC机：开发电脑3台
数据库：MySQL
建模工具：Rotational Rose 2003

技术可行性

版本控制系统：SVN
前端：Bootstrap框架、Html5+CSS3、JavaScript、Ajax
后台：Struts2框架、Hibernate框架、Spring框架
设计模式：拟采用单例模式、适配器和外观模式
算法：AES加密算法、MD5加密算法、路径规划算法

社会因素可行性分析

所有软件都选用正版
所有技术资料都由提出方保管
合同制定确定违约责任
用户使用可行性分析

3 分析图用例建模


流程图
系统分析
时序图
E-R图



数据库设计
四、关键技术
版本控制系统：SVN
前端：Bootstrap框架、Html5+CSS3、JavaScript、Ajax
后台：Struts2框架、Hibernate框架、Spring框架
设计模式：拟采用单例模式、适配器和外观模式
算法：AES加密算法、MD5加密算法、路径规划算法



五、模块测试景点和旅游路线的查询，支持模糊查询



预定旅游服务，用户登录注册之后就可以预定旅游服务

后台管理系统，旅游公司的管理员可以进行接收旅游服务订票操作


旅游公司管理员可以新开旅游路线

维护旅游公司的旅游路线

开发景点，支持图片上传，带Jquery的城市选择器

进行景点维护，采用UEditor富文本编辑器框架进行编辑，可以将样式写入数据库

Python 2.7
IDE Pycharm 5.0.3
Firefox 47.0.1

起因
就是想写个豆瓣电影的爬取，给我电影荒的同学。。。。当然自己也练手啦

目的
根据用户输入，列出豆瓣高分TOP(用户自定义)的电影，链接，及热评若干。
制作不需要Python环境可运行的exe，但由于bug未修复，需要火狐浏览器支持

方案
使用PhantomJS+Selenium+Firefox实现

实现过程
get到首页后，根据选择，点击种类，然后根据输入需求，进行排序
抓取每个电影及超链接，进入超链接后，抓取当前电影的热评及长评
当用户所要求TOP数目大于第一页的20个时候，点击加载更多，再出现20个电影，重复2操作


以豆瓣高分，然后按评分排序的点击过程（其余操作一致，先种类后排序选择，再爬）


实现代码# -*- coding: utf-8 -*-#Author:哈士奇说喵#爬豆瓣高分电影及hot影评from selenium import webdriverimport selenium.webdriver.support.ui as uiimport timeprint "---------------system loading...please wait...---------------"SUMRESOURCES = 0 #全局变量driver_detail = webdriver.PhantomJS(executable_path="phantomjs.exe")#driver_item=webdriver.PhantomJS(executable_path="phantomjs.exe")driver_item=webdriver.Firefox()url="https://movie.douban.com/"#等待页面加载方法wait = ui.WebDriverWait(driver_item,15)wait1 = ui.WebDriverWait(driver_detail,15)#获取URL和文章标题def getURL_Title(): global SUMRESOURCES###############################################################################需要键入想要获取的信息，比如种类，排序方式，想看多少内容############################################################################## print "please select:" kind=input("1-Hot\n2-Newest\n3-Classics\n4-Playable\n5-High Scores\n6-Wonderful but not popular\n7-Chinese film\n8-Hollywood\n9-Korea\n10-Japan\n11-Action movies\n12-Comedy\n13-Love story\n14-Science fiction\n15-Thriller\n16-Horror film\n17-Cartoon\nplease select:") print "--------------------------------------------------------------------------" sort=input("1-Sort by hot\n2-Sort by time\n3-Sort by score\nplease select:") print "--------------------------------------------------------------------------" number = input("TOP ?:") print "--------------------------------------------------------------------------" ask_long=input("don't need long-comments,enter 0,i like long-comments enter 1:") print "--------------------------------------------------------------------------" global save_name save_name=raw_input("save_name (xx.txt):") print "---------------------crawling...---------------------" driver_item.get(url)###############################################################################进行网页get后，先进行电影种类选择的模拟点击操作，然后再是排序方式的选择#最后等待一会，元素都加载完了，才能开始爬电影，不然元素隐藏起来，不能被获取#wait.until是等待元素加载完成！############################################################################## wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='fliter-wp']/div/form/div/div/label[%s]"%kind)) driver_item.find_element_by_xpath("//div[@class='fliter-wp']/div/form/div/div/label[%s]"%kind).click() wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='fliter-wp']/div/form/div[3]/div/label[%s]"%sort)) driver_item.find_element_by_xpath("//div[@class='fliter-wp']/div/form/div[3]/div/label[%s]"%sort).click() num=number+1#比如输入想看的TOP22，那需要+1在进行操作，细节问题 time.sleep(2) #打开几次“加载更多” num_time = num/20+1 wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='list-wp']/a[@class='more']")) for times in range(1,num_time): time.sleep(1) driver_item.find_element_by_xpath("//div[@class='list-wp']/a[@class='more']").click() time.sleep(1) wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='list']/a[%d]"%num)) #print '点击\'加载更多\'一次' #使用wait.until使元素全部加载好能定位之后再操作，相当于try/except再套个while把 for i in range(1,num): wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='list']/a[%d]"%num)) list_title=driver_item.find_element_by_xpath("//div[@class='list']/a[%d]"%i) print '----------------------------------------------'+'NO' + str(SUMRESOURCES +1)+'----------------------------------------------' print u'电影名: ' + list_title.text print u'链接: ' + list_title.get_attribute('href') #print unicode码自动转换为utf-8的 #写入txt中部分1 list_title_wr=list_title.text.encode('utf-8')#unicode码，需要重新编码再写入txt list_title_url_wr=list_title.get_attribute('href') Write_txt('\n----------------------------------------------'+'NO' + str(SUMRESOURCES +1)+'----------------------------------------------','',save_name) Write_txt(list_title_wr,list_title_url_wr,save_name) SUMRESOURCES = SUMRESOURCES +1 try:#获取具体内容和评论。href是每个超链接也就是资源单独的url getDetails(str(list_title.get_attribute('href')),ask_long) except: print 'can not get the details!'###############################################################################当选择一部电影后，进入这部电影的超链接，然后才能获取#同时别忽视元素加载的问题#在加载长评论的时候，注意模拟点击一次小三角，不然可能会使内容隐藏##############################################################################def getDetails(url,ask_long): driver_detail.get(url) wait1.until(lambda driver: driver.find_element_by_xpath("//div[@id='link-report']/span")) drama = driver_detail.find_element_by_xpath("//div[@id='link-report']/span") print u"剧情简介："+drama.text drama_wr=drama.text.encode('utf-8') Write_txt(drama_wr,'',save_name) print "--------------------------------------------Hot comments TOP----------------------------------------------" for i in range(1,5):#四个短评 try: comments_hot = driver_detail.find_element_by_xpath("//div[@id='hot-comments']/div[%s]/div/p"%i) print u"最新热评："+comments_hot.text comments_hot_wr=comments_hot.text.encode('utf-8') Write_txt("--------------------------------------------Hot comments TOP%d----------------------------------------------"%i,'',save_name) Write_txt(comments_hot_wr,'',save_name) except: print 'can not caught the comments!' #加载长评 if ask_long==1: try: driver_detail.find_element_by_xpath("//img[@class='bn-arrow']").click() #wait.until(lambda driver: driver.find_element_by_xpath("//div[@class='review-bd']/div[2]/div/div")) time.sleep(1) #解决加载长评会提示剧透问题导致无法加载 comments_get = driver_detail.find_element_by_xpath("//div[@class='review-bd']/div[2]/div") if comments_get.text.encode('utf-8')=='提示: 这篇影评可能有剧透': comments_deep=driver_detail.find_element_by_xpath("//div[@class='review-bd']/div[2]/div[2]") else: comments_deep = comments_get print "--------------------------------------------long-comments---------------------------------------------" print u"深度长评："+comments_deep.text comments_deep_wr=comments_deep.text.encode('utf-8') Write_txt("--------------------------------------------long-comments---------------------------------------------\n",'',save_name) Write_txt(comments_deep_wr,'',save_name) except: print 'can not caught the deep_comments!'###############################################################################将print输出的写入txt中查看，也可以在cmd中查看，换行符是为了美观##############################################################################def Write_txt(text1='',text2='',title='douban.txt'): with open(title,"a") as f: for i in text1: f.write(i) f.write("\n") for j in text2: f.write(j) f.write("\n")def main(): getURL_Title() driver_item.quit()main()
上面的代码是可以实现的，但需要Firefox的配合，因为我其中一个引擎调用了Firefox，另一个抓评论的用了PhantomJS。
实现效果

存入的txt文件



因为打包成exe必须是中文的键入，所以没办法，我改成英文来着，不然会出现这种情况。。。



输出内容是没有问题的。。。。。。

问题及解决方案Q: 使用PhantomJS和Firefox出现不同效果的问题，第21个回到起点。
A: 解决方案，暂且我也没有找到，只有调用Firefox然后完事后再关闭，分析请见伪解决Selenium中调用PhantomJS无法模拟点击(click)操作
Q: 在对unicode输出在txt出现的问题，但是在print可以直接中文输出的。
A: 解决方案：详见Python输出(print)内容写入txt中保存
Q: 元素无法定位问题
A: 首先查看是不是隐藏元素，其次再看自己的规则有没有写错，还有就是是不是页面加载未完成，详见解决网页元素无法定位（NoSuchElementException: Unable to locate element）的几种方法
Q: 只采集自己需要的数据，剔除无用数据，比如说，刚开始我用
driver_detail.find_elements_by_xpath然后写个取出list中元素的方法，但是这样的话，一个便签下内容未必太多，并不是我想要的如图：

比如说，我只想要红色的部分，那么，采取elements就不太好处理。
A: 我采用的方法是格式化字符串！根据元素的特性，可以发现，每个热评的正文标签不一样的，其余标签一样，只要格式化正文标签即可，像这样
for i in range(1,5):#取了前四条热评 try: comments = driver_detail.find_element_by_xpath("//div[@id='hot-comments']/div[%s]/div/p"%i) print u"最新热评："+comments.text except: print 'can not caught comments!'
Q: 一个引擎干有个事！我现在没办法，只有将第一个需要处理的页面用Firefox来处理，之后评论用PhantomJS来抓取，之后可以用quit来关闭浏览器，但是启动浏览器还是会耗费好多资源，而且挺慢，虽然PhantomJS也很慢，我12G内存都跑完了。。。。。。看样子是给我买8x2 16G双通道的借口啊。
Q: 备注不标准也会导致程序出错，这个是我没想到的，我一直以为在’’’备注’’’之间的都可以随便来，结果影响程序运行了，之后分模块测试才注意到这个问题，也是以前没有遇到过的，切记！需要规范自己代码，特别是像Python这样缩进是灵魂的语言。。。。
Q: 补充，长评论的抓取

这是点击之后的图，可以看到元素定位也是不一样的，注意

一、需求分析1. 面向对象点典点菜系统是一款面向顾客和管理人员的全方面系统，其中管理人员又包括服务员、采购员和厨师。本组认真分析了不同对象的需求，为不同的对象都设计了独特的系统功能。简化了传统点菜、烧菜和采购方式繁琐的步骤，为顾客提供便捷操作的同时提高酒店管理的效率。
2. 市场背景目前传统的点菜、烧菜和采购方式繁琐复杂。在人才配置方面，任何的餐厅或酒店都要配置大量的基层服务人员，这些基层服务人员大多从事简单的任务。例如：誊写顾客点菜的名称或代号、沟通顾客与厨房的材料状况、沟通采购员和厨房的材料状况。而这些工作恰恰是能由计算机代替人力来劳动的。在工作效率方面，传统的方式有着极大的时延缺陷。例如：服务员在为顾客点菜时并不能及时了解材料的剩余情况。如果材料已近用完了服务员又不知道，在顾客点菜后又要去询问顾客是否要取消或更改点菜情况。这样不仅极大地降低工作效率，还有可能引起顾客的不满。又或者材料用完了不能及时通知采购员，会降低销售额，不利于经营。
3. 运行环境
操作系统及版本：Windows XP、Win7开发环境：VS 2012数据库环境：SQL Server 2005
二、数据库设计1. 数据字典
餐桌信息表：餐桌号、座位号、餐桌位置、餐桌使用情况顾客表：顾客号、餐桌号、顾客信息菜单表：菜号、菜名、价格、类别账单表：账单号、顾客号、菜号、数量、价格部门表：部门号、部门名员工表：员工号、员工密码、员工名、性别、部门号、工种进货表：商品号、员工号、商品名、进货数量、进货日期商品表：商品号、商品名、商品价格
2. 概念模型点餐子系统E-R图

餐厅内部管理子系统E-R图

3. 表格合并化简过程
Dinner_Table：Table_ID，Table_Seat_quantity，Table_Position，Table_SituationTable_Use：Table_ID，Client_IDClient：Client_ID，Client_MessageDishes_List：Dishes_ID，Dishes_Name，Dishes_Price，Dishes_ClassificationBill：Bill_ID，Dishes_ID，QuantityOrders：Bill_ID，Client_IDEmployee：Employee_ID，Employee_Password，Employee_Name，SexDepartment：Department_ID，Department_NameDept_Belonging：Employee_ID，Department_IDGoods：Good_ID，Good_Name，Goods_PricePurchase：Goods_ID，Employee_ID，Good_Quantity，Purchase_Date
（加粗标注为关系集合）
合并表格后得：

Dinner_Table：Table_ID，Table_Seat_quantity，Table_Position，Table_SituationClient：Client_ID，Table_ID，Client_Message(将餐桌使用表和顾客表合并)Dishes_List：Dishes_ID，Dishes_Name，Dishes_Price，Dishes_ClassificationBill：Bill_ID，Client_ID，Dishes_ID，Quantity(将账单表和点菜表合并)Employee：Employee_ID，Employee_Password，Department_ID，Employee_Name，Sex(将员工表和部门隶属表合并)Department：Department_ID，Department_NameGoods：Good_ID，Good_Name，Goods_PricePurchase：Goods_ID，Employee_ID，Good_Quantity，Purchase_Date
（加粗标注为合并表格后新增属性）
4. 建表代码Create table Dinner_Table( Table_ID char(3) not null , Seat_Num int not null, Table_Position varchar(20), Table_Situation varchar(10) Primary key(Table_ID));
Create table Client( Client_ID char(6) not null,--从000001开始 Table_ID char(3), Client_Message varchar(10) Primary key(Client_ID), Foreign key(Table_ID) references Dinner_Table On delete cascade On update cascade );
Create table Dishes_List( Dishes_ID char(6) not null , Dishes_Name varchar(20) not null, Dishes_Price int not null, Dishes_Classification varchar(10) not null, Primary key (Dishes_ID ));
Create table Bill ( Bill_ID char(6) not null , Client_ID char(6) not null, Dishes_ID char(6) not null, Quantity int not null, Price int, Foreign key(Client_ID ) references Client On delete cascade On update cascade, Foreign key(Dishes_ID) references Dishes_List On delete cascade On update cascade, Primary key(Bill_ID,Dishes_ID));
Create table Department( Department_ID char(6), Department_Name varchar(10), Primary key(Department_ID));
Create table Employee( Employee_ID char(11), Employee_Password varchar(6) not null, Employee_Name varchar(20), Employee_Sex char(2) check(Employee_Sex='男' or Employee_Sex='女'), Department_ID char(6), Employee_Style char(10), Primary key(Employee_ID), Foreign key(Department_ID) references Department On delete cascade On update cascade );
Create table Purchase( Goods_ID char(6), Employee_ID char(11), Goods_Name char(20), Goods_Quantity int, Purchase_Date char(10), Foreign key(Employee_ID) references Employee On delete cascade On update cascade, Primary key(Goods_ID));
Create table Goods( Goods_ID char(6), Goods_Name varchar(20), Goods_Price int, Foreign key(Goods_ID) references Goods On delete cascade On update cascade Primary key(Goods_ID));
三、系统功能模块说明本系统主要分为点餐和餐馆内部管理两个大的功能模块。
在点餐模块，程序分为管理终端和顾客终端。设想的是在每台餐桌上都有一台用以点餐的pc终端，顾客可以通过此终端浏览菜品进行点菜，同时可以和餐馆管理端进行通信，实时获得所需的服务。在管理终端，可以直观地看到各台餐桌的使用情况以及各个顾客的点餐信息，同时可以和各台顾客进行通信。程序截图如下：
管理端登录界面

输入错误时输出提示信息

管理端工作界面

使用不同图标表示餐桌的使用情况

和客户端的通信

客户端开始界面

客户端功能菜单窗口

客户点餐

客户查看菜单

客户修改菜单

客户与管理端的通信界面

客户点击结账时看到的账单界面

餐馆内部管理模块，在此模块我设置了不同的接口，对不同的登录员工显示不同的界面。程序截图如下：
采购员登录后显示的界面(为方便管理，设置了查找功能)

餐馆管理员登录后显示的界面

管理员对本系统所有表格均能进行更新修改

四、项目总结1. 问题项目开发中遇到的主要问题是多台客户端和管理终端的通信。比如客户在对管理端发起通话时，若管理端未打开对话窗口，要如何将收到的信息暂存起来，并且如何在管理端打开对话框后正确的显示；其次还有管理端与多个客户端通信时要如何做到信息的正确发送给对应的客户。然后因为是网络软件，和平时简单的写个程序调用数据库不同，这里采用的是各个终端连接远程的数据库，因为没有接触过，费了一番周折。其次还有一些小的问题，比如列表控件显示图标，子、父窗口之间数据参数的传递。同时程序中还需处理大量事先约定的带特定意义的字符串，以此辨别此次通信的目的，否则程序中在通信方面涉及多种功能，如果为每一种功能都维系一个通信套接字对资源的利用将非常低。
2. 解决方法对于第一个问题，没有采用进程间通信，而是在通信对话框未打开时由其父窗口接收信息并写入临时文件夹，当打开通信对话框时由初始化函数将信息从临时文件夹读出显示在编辑框上，这样也实现了聊天记录的保存。
对于第二个问题，采用iocp框架的服务器，维护各个客户端与管理端通信的套接字，以便准确转发各种信息。同时完成端口框架的服务器也非常适合处理多用户并发通信的问题。
五、参考资料
《VC++ 深入详解》
《Visual C++ 网络通信开发入门与编程实践》
《Visual C++ 网络编程经典案例详解》
《C++ Primer》
http://blog.sina.com.cn/s/blog_625ef6610101g4qj.html
http://blog.163.com/notepad_2008/blog/static/48206602200802353810418/
http://blog.csdn.net/ristal/article/details/6652020
http://blog.sina.com.cn/s/blog_6d0730c70100thvi.html
http://bbs.csdn.net/topics/390620910?page=1
http://blog.sina.com.cn/s/blog_5f30147a0100dzgx.html
http://www.cnblogs.com/mgtwei/archive/2012/08/27/2659365.html

游戏截图



游戏中用到的类结构介绍图像层
图像基类MYBITMAP
游戏背景MYBKSKY—>MYBITMAP
游戏图片MYANIOBJ—>MYBITMAP
魔法攻击MYANIMAGIC—>MYBITMAP

逻辑层
游戏逻辑GAMEMAP
时钟处理MYCLOCK
字体处理MYFONT
跟踪打印FILEREPORT
玩家控制MYROLE—>MYBITMAP

结构和表
精灵结构ROLE
物品结构MapObject
地图信息表MAPINFO

一、工程开始介绍下准备工作，也就是所需要的开发工具。代码编写调试：VC 6.0，美术工具：Windows自带的画图（开始-程序-附件-画图）。这是最简陋的开发工具，但已足够。最好再有Photoshop，记事本或UltraEdit等等你喜欢的文本编辑工具。
游戏代码分两部分，图像部分和逻辑部分。
先说图像部分：图像分两种，矩形图片和不规则图片。工程中的PIC文件夹下，可以看到所有图像资源。
矩形图片有：地面、砖块、水管、血条、血条背景。
不规则图片有：蘑菇（玩家，敌人1，敌人2），子弹、旋风、爆炸效果、金币、撞击金币后的得分、攻击武器（那个从魂斗罗里抠来的东东）、火圈1、火圈2、箭头（用于开始菜单选择）、树木、河流、WIN标志、背景图片（游戏背景和菜单背景）。
所有图片都分成几个位图BMP文件存储。一个文件中，每种图片，都纵向排列。每种图片可能有多帧。比如，金币需要4帧图像，才能构成一个旋转的动画效果，那么，各帧图像横向排列。
图像层的结构就这样简单，逻辑层只需要确定“哪个图像，哪一帧”这两个参数，就能在屏幕上绘制出所有图片。
图像层的基类是：
class MYBITMAP{public: MYBITMAP(); ~MYBITMAP(); // 初始化 void Init(HINSTANCE hInstance,int iResource,int row,int col); void SetDevice(HDC hdest,HDC hsrc,int wwin,int hwin); void SetPos(int istyle,int x,int y); // 显示 void Draw(DWORD dwRop); void Stretch(int x,int y); void Stretch(int x,int y,int id); void Show(int x,int y); void ShowCenter(int y); void ShowLoop(int left,int top,int right,int bottom,int iframe); void ShowNoBack(int x,int y,int iFrame); void ShowNoBackLoop(int x,int y,int iFrame,int iNum); // 动画播放 void ShowAni(); void SetAni(int x,int y); HBITMAP hBm;public: // 按照行列平均分成几个 int inum; int jnum; int width; int height; int screenwidth; int screenheight; HDC hdcdest; HDC hdcsrc; // 当前位置 int xpos; int ypos; int iStartAni;};
这只是一个基类，上面是几个重要的数据成员和函数。它所描述的图片，是一个m行n列构成的m*n个图片，每个图片大小一致，都是矩形。显然，这并不能满足上面的设计要求，怎么解决呢？派生，提供更多的功能。但是，这个基类封装了足够的物理层信息：设备上下文HDC，和位图句柄HBITMAP。矩形图片的显示、不规则图片的显示、图片组织排列信息，这些功能交给它的派生类MYANIOBJ。
还有，我们最关心的问题是图片坐标，比如，不同位置的砖块、精灵、金币，这些由逻辑层处理。
二、图片基类MYBITMAP先说一下代码风格，大家都说看不懂，这就对了。整套代码约有3000行，并不都是针对这个游戏写的。我想把代码写成一个容易扩展、容易维护、功能全面的“框架”，需要什么功能，就从这个框架中取出相应功能，如果是一个新的功能，比如新的图像显示、新的运动控制，我也能方便地实现。所以，这个游戏的代码，是在前几个游戏的基础上扩充起来的。部分函数，部分变量在这款游戏中，根本不用，但要保留，要为下一款游戏作准备。只要理解了各个类，就理解了整个框架。
今天先讲最基础的图像类MYBITMAP，先说一下代码风格，大家都说看不懂，这就对了。整套代码约有3000行，并不都是针对这个游戏写的。我想把代码写成一个容易扩展、容易维护、功能全面的“框架”，需要什么功能，就从这个框架中取出相应功能，如果是一个新的功能，比如新的图像显示、新的运动控制，我也能方便地实现。所以，这个游戏的代码，是在前几个游戏的基础上扩充起来的。部分函数，部分变量在这款游戏中，根本不用，但要保留，要为下一款游戏作准备。只要理解了各个类，就理解了整个框架。
今天先讲最基础的图像类MYBITMAP，成员函数功能列表:
// 功能 根据一个位图文件,初始化图像// 入参 应用程序实例句柄 资源ID 横向位图个数 纵向位图个数void Init(HINSTANCE hInstance,int iResource,int row,int col);// 功能 设置环境信息// 入参 目的DC(要绘制图像的DC),临时DC,要绘制区域的宽 高void SetDevice(HDC hdest,HDC hsrc,int wwin,int hwin);// 功能 设置图片位置// 入参 设置方法 横纵坐标void SetPos(int istyle,int x,int y);// 功能 图片显示// 入参 图片显示方式void Draw(DWORD dwRop);// 功能 图片缩放显示// 入参 横纵方向缩放比例void Stretch(int x,int y);// 功能 图片缩放显示// 入参 横纵方向缩放比例 缩放图像ID(纵向第几个)void Stretch(int x,int y,int id);// 功能 在指定位置显示图片// 入参 横纵坐标void Show(int x,int y);// 功能 横向居中显示图片// 入参 纵坐标void ShowCenter(int y);// 功能 将某个图片平铺在一个区域内// 入参 左上右下边界的坐标 图片ID(横向第几个)void ShowLoop(int left,int top,int right,int bottom,int iframe);// 功能 不规则图片显示// 入参 横纵坐标 图片ID(横向第几个)void ShowNoBack(int x,int y,int iFrame);// 功能 不规则图片横向平铺// 入参 横纵坐标 图片ID(横向第几个) 平铺个数void ShowNoBackLoop(int x,int y,int iFrame,int iNum);// 动画播放// 功能 自动播放该图片的所有帧,函数没有实现,但以后肯定要用:)// 入参 无void ShowAni();// 功能 设置动画坐标// 入参 横纵坐标void SetAni(int x,int y);
成员数据：
// 图像句柄HBITMAP hBm;// 按照行列平均分成几个int inum;int jnum;// 按行列分割后,每个图片的宽高(显然各个图片大小一致,派生后,这里的宽高已没有使用意义)int width;int height;// 屏幕宽高int screenwidth;int screenheight;// 要绘制图片的dcHDC hdcdest;// 用来选择图片的临时dcHDC hdcsrc; // 当前位置int xpos;int ypos;// 是否处于动画播放中(功能没有实现)int iStartAni;
这个基类的部分函数和变量，在这个游戏中没有使用，是从前几个游戏中保留下来的，所以看起来有些零乱。这个游戏的主要图像功能，由它的派生类完成。由于基类封装了物理层信息(dc和句柄)，派生类的编写就容易一些，可以让我专注于逻辑含义。
基类的函数实现上，很简单，主要是以下几点：
1.图片初始化
// 根据程序实例句柄,位图文件的资源ID,导入该位图,得到位图句柄 hBm=LoadBitmap(hInstance,MAKEINTRESOURCE(iResource)); // 获取该位图文件的相关信息 GetObject(hBm,sizeof(BITMAP),&bm); // 根据横纵方向的图片个数,计算出每个图片的宽高(对于超级玛丽,宽高信息由派生类处理) width=bm.bmWidth/inum; height=bm.bmHeight/jnum;
2.图片显示
各个图片的显示函数，大同小异，都要先选入一个临时DC，再bitblt到要绘制的dc上。矩形图片，可以直接用SRCCOPY的方式绘制；不规则图片，需要先用黑白图与目的区域相”与”(SRCAND)，再用”或”的方法显示图像(SRCPAINT)，这是一种简单的”绘制透明位图”的方法。
void MYBITMAP::ShowNoBack(int x,int y,int iFrame){ xpos=x; ypos=y; SelectObject(hdcsrc,hBm); BitBlt(hdcdest,xpos,ypos,width,height/2,hdcsrc,iFrame*width,height/2,SRCAND); BitBlt(hdcdest,xpos,ypos,width,height/2,hdcsrc,iFrame*width,0,SRCPAINT); }
3.图片缩放
用StretchBlt的方法实现。
void MYBITMAP::Stretch(int x,int y,int id){ SelectObject(hdcsrc,hBm); StretchBlt(hdcdest,xpos,ypos,width*x,height*y, hdcsrc,0,id*height, width,height, SRCCOPY); }
在超级玛丽这个游戏中，哪些图像的处理是通关这个基类呢？只有一个：MYBITMAP bmPre;由于这个基类只能处理几个大小均等的图片，只有这些图片大小一致，且都是矩形：游戏开始前的菜单背景，操作信息的背景，每一关开始前的背景(此时显示LIFE x WORLD x)，通关或游戏结束时显示的图片，共5个，将这5个图片，放在一个位图文件中，于是，这些图片的操作就做完了，代码如下：
// 初始设置,在InitInstance函数中bmPre.Init(hInstance,IDB_BITMAP_PRE1,1,5);bmPre.SetDevice(hscreen,hmem,GAMEW*32,GAMEH*32);bmPre.SetPos(BM_USER,0,0);// 图片绘制,在WndProc中,前两个参数指横纵方向扩大2倍显示.bmPre.Stretch(2,2,0);bmPre.Stretch(2,2,4);bmPre.Stretch(2,2,2); bmPre.Stretch(2,2,1); bmPre.Stretch(2,2,3);
三、游戏背景类MYBKSKY类说明
这是一个专门处理游戏背景的类。在横版游戏或射击游戏中，都有一个背景画面，如山、天空、云、星空等等。这些图片一般只有1到2倍屏幕宽度，然后像一个卷轴一样循环移动，连成一片，感觉上像一张很长的图片。这个类就是专门处理这个背景的。在超级玛丽增强版中，主要关卡是3关，各有一张背景图片；从水管进去，有两关，都用一张全黑图片。共四张图。这四张图大小一致，纵向排列在一个位图文件中。MYBKSKY这个类，派生于MYBITMAP。由于背景图片只需要完成循环移动的效果，只需要实现一个功能，而无需关心其他任何问题（例如句柄、dc）。编码起来很简单，再次反映出面向对象的好处。
技术原理
怎样让一张图片像卷轴一样不停移动呢？很简单，假设有一条垂直分割线，把图片分成左右两部分。先显示右边部分，再把左边部分接到图片末尾。不停移动向右移动分割线，图片就会循环地显示。
MYBKSKY类定义如下所示：
class MYBKSKY:public MYBITMAP{public: MYBKSKY(); ~MYBKSKY(); // show // 功能 显示一个背景. // 入参 无 void DrawRoll(); // 循环补空 // 功能 显示一个背景,并缩放图片 // 入参 横纵方向缩放比例 void DrawRollStretch(int x,int y); // 功能 指定显示某一个背景,并缩放图片,游戏中用的就是这个函数 // 入参 横纵方向缩放比例 背景图片ID(纵向第几个) void DrawRollStretch(int x,int y,int id); // 功能 设置图片位置 // 入参 新的横纵坐标 void MoveTo(int x,int y); // 功能 循环移动分割线 // 入参 分割线移动的距离 void MoveRoll(int x); // data // 分割线横坐标 int xseparate;};
函数具体实现都很简单，例如：
void MYBKSKY::DrawRollStretch(int x,int y, int id){ // 选入句柄 SelectObject(hdcsrc,hBm); // 将分割线右边部分显示在当前位置 StretchBlt(hdcdest, xpos,ypos, // 当前位置 (width-xseparate)*x,height*y, // 缩放比例 hdcsrc, xseparate,id*height, // 右边部分的坐标 width-xseparate,height, // 右边部分的宽高 SRCCOPY); // 将分割线左边部分接在图片末尾 StretchBlt(hdcdest,xpos+(width-xseparate)*x,ypos, xseparate*x,height*y, hdcsrc,0,id*height, xseparate,height, SRCCOPY); }
使用举例：
// 定义 MYBKSKY bmSky;// 初始化bmSky.Init(hInstance,IDB_BITMAP_MAP_SKY,1,4);bmSky.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32);bmSky.SetPos(BM_USER,0,0);// 游戏过程中显示bmSky.DrawRollStretch(2,2,gamemap.mapinfo.iBackBmp);// 每隔一定时间,移动分割线bmSky.MoveRoll(SKY_SPEED);//云彩移动// 以下两处与玩家角色有关:// 当玩家切换到一张新地图时,刷新背景图片的坐标bmSky.SetPos(BM_USER,viewx,0);// 当玩家向右移动时,刷新背景图片的坐标bmSky.SetPos(BM_USER,viewx,0);
至此，游戏背景图片的功能就做完了。
四、图片显示类MYANIOBJ类说明
这个类负责游戏中的图片显示。菜单背景、通关和游戏结束的提示图片，由MYBITMAP处理（大小一致的静态图片）。游戏背景由MYBKSKY处理。其余图片，也就是游戏过程中的所有图片，都是MYANIOBJ处理。
技术原理
游戏中的图片大小不一致，具体在超级玛丽中，可以分成两类：矩形图片和不规则图片。在位图文件中，都是纵向排列各个图片，横向排列各帧。用两个数组存储各个图片的宽和高。为了方便显示某一个图片，用一个数组存储各个图片的纵坐标（即位图文件中左上角的位置）。使用时，由逻辑层指定“哪个图片”的“哪一帧”，显示在“什么位置”。这样图片的显示功能就实现了。
MYANIOBJ类定义如下所示：
class MYANIOBJ:public MYBITMAP{public: MYANIOBJ(); ~MYANIOBJ(); // init list // 功能 初始化宽度数组 高度数组 纵坐标数组 是否有黑白图 // 入参 宽度数组地址 高度数组地址 图片数量 是否有黑白图(0 没有, 1 有) // (图片纵坐标信息由函数计算得出) void InitAniList(int *pw,int *ph,int inum,int ismask); // 功能 初始化一些特殊的位图,例如各图片大小一致,或者有其他规律 // 入参 初始化方式 参数1 参数2 // (留作以后扩展, 目的是为了省去宽高数组的麻烦) void InitAniList(int style,int a,int b); // show // 功能 显示图片(不规则图片) // 入参 横纵坐标(要显示的位置) 图片id(纵向第几个), 图片帧(横向第几个) void DrawItem(int x,int y,int id,int iframe); // 功能 显示图片(矩形图片) // 入参 横纵坐标(要显示的位置) 图片id(纵向第几个), 图片帧(横向第几个) void DrawItemNoMask(int x,int y,int id,int iframe); // 功能 指定宽度, 显示图片的一部分(矩形图片) // 入参 横纵坐标(要显示的位置) 图片id(纵向第几个), 显示宽度 图片帧(横向第几个) void DrawItemNoMaskWidth(int x,int y,int id,int w,int iframe); // 功能 播放一个动画 即循环显示各帧 // 入参 横纵坐标(要显示的位置) 图片id(纵向第几个) void PlayItem(int x,int y,int id); // 宽度数组 最多支持20个图片 int wlist[20]; // 高度数组 最多支持20个图片 int hlist[20]; // 纵坐标数组 最多支持20个图片 int ylist[20]; // 动画播放时的当前帧 int iframeplay;};
函数实现上也很简单。构造函数中，所有成员数据清零；初始化时，将各图片的高度累加，即得到各图片的纵坐标。显示图片的方法如前所述。
使用举例：
游戏图片分成三类：地图物品、地图背景物体、精灵（即所有不规则图片）。
MYANIOBJ bmMap;MYANIOBJ bmMapBkObj;MYANIOBJ bmAniObj;
初始化宽高信息，程序中定义一个二维数组，例如：
int mapani[2][10]={ {32,32,64,32,32,52,64,32,64,32}, {32,32,64,32,32,25,64,32,64,32},};
第一维mapani[0]存储10个图片的宽度，第二维mapani[1]存储10个图片的高度，初始化时，将mapani[0]，mapani[1]传给初始化函数即可。
1.地图物品的显示
// 定义MYANIOBJ bmMap;// 初始化// 这一步加载位图bmMap.Init(hInstance,IDB_BITMAP_MAP,1,1);// 这一步初始化DCbmMap.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32);// 这一步设置宽高信息, 图片为矩形bmMap.InitAniList(mapsolid[0],mapsolid[1], sizeof(mapsolid[0])/sizeof(int),0);// 对象作为参数传给逻辑层, 显示地图物品gamemap.Show(bmMap);
2.血条的显示
打怪时，屏幕上方要显示血条。由于同样是矩形图片，也一并放在了地图物品的位图中。
// 变量声明extern MYANIOBJ bmMap;// 显示血条背景，指定图片宽度：最大生命值*单位生命值对应血条宽度bmMap.DrawItemNoMaskWidth(xstart-1, ATTACK_TO_Y-1, ID_MAP_HEALTH_BK, iAttackMaxLife*BMP_WIDTH_HEALTH, 0);// 显示怪物血条，指定图片宽度：当前生命值*单位生命值对应血条宽度 bmMap.DrawItemNoMaskWidth(xstart, ATTACK_TO_Y, ID_MAP_HEALTH, iAttackLife*BMP_WIDTH_HEALTH, 0);
3.地图背景物体的显示
背景物体包括草、河流、树木、目的地标志。这些物体都不参与任何逻辑处理，只需要显示到屏幕上。图片放在一个位图文件中，都是不规则形状。
// 定义MYANIOBJ bmMapBkObj;// 初始化并加载位图bmMapBkObj.Init(hInstance,IDB_BITMAP_MAP_BK,1,1);// 设置dcbmMapBkObj.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32);// 设置各图片宽高信息bmMapBkObj.InitAniList(mapanibk[0],mapanibk[1],sizeof(mapanibk[0])/sizeof(int),1);// 对象作为参数传给逻辑层, 显示地图背景物体gamemap.ShowBkObj(bmMapBkObj);
4.精灵的显示
精灵包括：蘑菇（玩家，敌人1，敌人2），子弹、旋风、爆炸效果、金币、撞击金币后的得分、攻击武器（那个从魂斗罗里抠来的东东）、火圈1、火圈2、箭头（用于开始菜单选择）。
// 定义MYANIOBJ bmAniObj;// 初始化加载位图bmAniObj.Init(hInstance,IDB_BITMAP_ANI,1,1);// 设置dcbmAniObj.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32);// 设置宽高信息bmAniObj.InitAniList(mapani[0],mapani[1],sizeof(mapani[0])/sizeof(int),1);// 菜单显示（即菜单文字左边的箭头）gamemap.ShowMenu(bmAniObj);// 对象作为参数传给逻辑层, 显示各个精灵gamemap.ShowAniObj(bmAniObj);
五、魔法攻击类MYANIMAGIC类说明：玩家有两种攻击方式：普通攻击（子弹），魔法攻击（旋风）。这个类是专门处理旋风的。我最初的想法是用一些特殊的bitblt方法制造特效，例如或、与、异或。试了几次，都失败了。最后只能用“先与后或”的老方法。这个类可看成MYANIOBJ的一个简化版，只支持不规则图片的显示。
MYANIMAGIC类定义如下所示：
class MYANIMAGIC:public MYBITMAP{public: MYANIMAGIC(); ~MYANIMAGIC(); // init list // 功能 初始化宽度数组 高度数组 纵坐标数组（必须有黑白图） // 入参 宽度数组地址 高度数组地址 图片数量 // (图片纵坐标信息由函数计算得出) void InitAniList(int *pw,int *ph,int inum); // 功能 设置dc // 入参 显示dc 临时dc(用于图片句柄选择) 临时dc(用于特效实现) void SetDevice(HDC hdest,HDC hsrc,HDC htemp); // show // 功能 显示某个图片的某帧 // 入参 横纵坐标(显示位置) 图片id(纵向第几个) 帧(横向第几个) void DrawItem(int x,int y,int id,int iframe); // 宽度数组 int wlist[20]; // 高度数组 int hlist[20]; // 纵坐标数组 int ylist[20]; // 用于特效的临时dc, 功能没有实现 HDC hdctemp;};
函数具体实现很简单，可参照MYANIOBJ类。
使用举例
// 定义MYANIMAGIC bmMagic;// 初始化加载位图bmMagic.Init(hInstance,IDB_BITMAP_MAGIC,1,1);// 设置dcbmMagic.SetDevice(hscreen,hmem, hmem2);// 初始化宽高信息bmMagic.InitAniList(mapanimagic[0],mapanimagic[1],sizeof(mapanimagic[0])/sizeof(int));// 变量声明extern MYANIMAGIC bmMagic;// 在逻辑层中, 显示旋风图片bmMagic.DrawItem(xstart,ystart, 0, FireArray[i].iframe);
六、时钟控制类MYCLOCK类说明
时间就是生命。这对于游戏来说，最为准确。游戏程序只做两件事：显示图片、处理逻辑。更准确的说法是：每隔一段时间显示图片并处理逻辑。程序中，要设置一个定时器。这个定时器会每隔一段时间发出一个WM_TIMER消息。在该消息的处理中，先逻辑处理。逻辑处理完毕，通过InvalidateRect函数发出WM_PAINT消息，显示各种图片。游戏就不停地运行下去，直至程序结束。
时间表示
用一个整数iNum表示当前时间，游戏中的时间是1,2,3, … , n, 1,2,3, …,n 不停循环.假设1秒内需要25个WM_TIMER消息(每40毫秒1次)，则n=25。也可以用一个变量，统计过了几秒。
控制事件频率的方法

一秒内发生多次
以游戏背景图片为例, 每秒移动5下, 可以在iNum为5,10,15,20,25这5个时间点上移动.即iNum可以被5整除时,修改背景图片的坐标.
一秒内发生一次
例如火圈, 每秒产生一个新的蘑菇兵. 可以随便指定一个时间点,如20. 当iNum等于20时，生成一个蘑菇兵。
多秒内发生一次
需要一个辅助变量iNumShow，统计时间过了几秒。每隔一秒iNumShow减1，当iNumShow等于0时处理逻辑。

MYCLOCK类定义如下所示：（所有函数都是内联函数）
class MYCLOCK{public: // 构造函数 初始化所有变量 MYCLOCK() { iNum=0; // 时间点 iIsActive=0; // 是否已经开始计时 iNumShow=0; // 计时秒数 iElapse=100; // 默认每100ms发一个WM_TIMER消息 ishow=0; // 是否显示时间 } // 析构函数 销毁计时器 ~MYCLOCK() { Destroy(); } // 功能 开始计时, 产生WM_TIEMR消息的时间间隔为elapse. // 设置计时秒数(timetotal). // 入参 窗口句柄 时间间隔 计时秒数 void Begin(HWND hw,int elapse,int timetotal) { if(iIsActive) return;//已经启动了，直接返回 hWnd=hw; iElapse=elapse; SetTimer(hWnd,1,iElapse,NULL); iNum=1000/iElapse;//一秒钟的时间消息数量 iNumShow=timetotal; iIsActive=1; } // 功能 销毁计时器. // 入参 无 void Destroy() { if(iIsActive) { iIsActive=0; KillTimer(hWnd,1); } } // 功能 重置计时秒数 // 入参 秒数 void ReStart(int timetotal) { iNumShow=timetotal; iNum=1000/iElapse; ishow=1; } //////////////////////////// 显示部分 // 功能 设置显示dc (在超级玛丽增强版中不显示时间) // 入参 显示dc void SetDevice(HDC h) { hDC=h; } // 功能 显示时间, TIME 秒数 // 入参 显示坐标 void Show(int x,int y) { char temp[20]={0}; if(!ishow) return; // 设置显示文本 sprintf(temp,"TIME: %d ",iNumShow); TextOut(hDC,x, y, temp,strlen(temp)); } // 功能 时间点减一 // 如果到了计时秒数, 函数返回1, 否则返回0. // 入参 无 int DecCount() { iNum--; if(iNum==0) { // 过了一秒 iNum=1000/iElapse; iNumShow--; if(iNumShow<=0) { // 不销毁计时器 return 1; } } return 0; } // 功能 时间点减一 // 如果到了计时秒数, 函数返回1并销毁计时器, 否则返回0. // 入参 无 int Dec() { iNum--; if(iNum<=0) { //过了一秒 iNum=1000/iElapse; iNumShow--; if(iNumShow<=0) { iNumShow=0; Destroy(); return 1; } } return 0; } // 功能 设置是否显示 // 入参 1,显示; 0, 不显示 void SetShow(int i) { ishow=i; }public: // 窗口句柄 HWND hWnd; // 显示dc HDC hDC; // 时间点 int iNum; // 计时秒数 int iNumShow; // 消息时间间隔 int iElapse; // 是否开始计时 int iIsActive; // 是否显示 int ishow;};
具体函数实现很简单，如上所述。
使用举例
// 定义MYCLOCK c1;// 设置显示dcc1.SetDevice(hscreen);// 开始计时（计时秒数无效）c1.Begin(hWnd, GAME_TIME_CLIP ,-1);// 选择游戏菜单，每隔一定时间，重绘屏幕，实现箭头闪烁c1.DecCount();if(0 == c1.iNum%MENU_ARROW_TIME)// 屏幕提示LIFE,WORLD，如果达到计时秒数，进入游戏。if(c1.DecCount())// 进入游戏，计时300秒（无意义，在超级玛丽增强版中取消时间限制）c1.ReStart(TIME_GAME_IN); // 在游戏过程中，每隔一定时间，处理游戏逻辑c1.DecCount();if(0 == c1.iNum%SKY_TIME)gamemap.ChangeFrame(c1.iNum); // 帧控制gamemap.CheckAni(c1.iNum); // 逻辑数据检测// 玩家过关后，等待一定时间。if(c1.DecCount())// 玩家进入水管，等待一定时间。if(c1.DecCount())c1.ReStart(TIME_GAME_IN); // 玩家失败后，等待一定时间。if(c1.DecCount())// 玩家通关后，等待一定时间。if(c1.DecCount())// 玩家生命值为0，游戏结束，等待一定时间。if(c1.DecCount())// 程序结束（窗口关闭），销毁计时器c1.Destroy();// 变量声明extern MYCLOCK c1;// 游戏菜单中，选择“开始游戏”，显示LIFE,WORLD提示，计时两秒c1.ReStart(TIME_GAME_IN_PRE); // 停顿两秒// 进入水管，等待，计时两秒c1.ReStart(TIME_GAME_PUMP_WAIT);// 玩家过关，等待，计时两秒c1.ReStart(TIME_GAME_WIN_WAIT);// 生命值为0，游戏结束，等待，计时三秒c1.ReStart(TIME_GAME_END); // 玩家失败，显示LIFE,WORLD提示，计时两秒c1.ReStart(TIME_GAME_IN_PRE); // 玩家失败，等待，计时两秒c1.ReStart(TIME_GAME_FAIL_WAIT);
至此，所有的时间消息控制、时间计时都已处理完毕。
七、字体管理类MYFONT类说明
游戏当然少不了文字。在超级玛丽中，文字内容是比较少的，分两类：游戏菜单中的文字，游戏过程中的文字。菜单中的文字包括：

“操作: Z:子弹 X:跳 方向键移动 W:默认窗口大小”,“地图文件错误，请修正错误后重新启动程序。”,“(上下键选择菜单,回车键确认)”,“开始游戏”,“操作说明”,“(回车键返回主菜单)”
这几个字符串存储在一个指针数组中（全局变量），通关数组下标使用各个字符串。
游戏中的文字只有两个：’LIFE’,’WORLD’。
其他的文字其实都是位图，例如“通关”、“gameover”以及碰到金币后的“+10”。这些都是位图图片，在pic文件夹里一看便知。
技术原理
要在屏幕上显示一个字符串，分以下几步：将字体句柄选入dc，设置文字背景色，设置文字颜色，最后用TextOut完成显示。这个类就是将整个过程封装了一下。显示dc，背景色，文字颜色，字体句柄都对应各个成员数据。函数具体实现很简单，一看便知。
MYFONT类定义如下所示：
class MYFONT{public: // 构造函数,初始化”字体表”,即5个字体句柄构成的数组,字体大小依次递增. MYFONT(); ~MYFONT(); // 功能 设置显示文字的dc // 入参 显示文字的dc句柄 void SetDevice(HDC h); // 功能 设置当前显示的字体 // 入参 字体表下标 void SelectFont(int i); // 功能 设置当前字体为默认字体 // 入参 无 void SelectOldFont(); // 功能 在指定坐标显示字符串 // 入参 横纵坐标 字符串指针 void ShowText(int x,int y,char *p); // 功能 设置文字背景颜色,文字颜色 // 入参 文字背景颜色 文字颜色 void SetColor(COLORREF cbk, COLORREF ctext); // 功能 设置文字背景颜色,文字颜色 // 入参 文字背景颜色 文字颜色 void SelectColor(COLORREF cbk, COLORREF ctext); // 显示文字的dc HDC hdc; // 字体表,包含5个字体句柄,字体大小依次是0,10,20,30,40 HFONT hf[5]; // 默认字体 HFONT oldhf; // color COLORREF c1; // 字体背景色 COLORREF c2; // 字体颜色};
使用举例
// 定义MYFONT myfont;// 初始化设置显示dcmyfont.SetDevice(hscreen);// 地图文件错误：设置颜色，设置字体，显示提示文字myfont.SelectColor(TC_WHITE,TC_BLACK);myfont.SelectFont(0);myfont.ShowText(150,290,pPreText[3]);// 游戏开始菜单：设置字体，设置颜色，显示三行菜单文字myfont.SelectFont(0);myfont.SelectColor(TC_BLACK, TC_YELLOW_0);myfont.ShowText(150,260,pPreText[4]);myfont.ShowText(150,290,pPreText[5]);myfont.ShowText(150,320,pPreText[6]);// 游戏操作说明菜单：设置字体，设置颜色，显示四行说明文字myfont.SelectFont(0);myfont.SelectColor(TC_BLACK, TC_YELLOW_0);myfont.ShowText(150,230,pPreText[8]);myfont.ShowText(50,260,pPreText[1]);myfont.ShowText(50,290,pPreText[0]);myfont.ShowText(50,320,pPreText[7]);
这个类的使用就这些。这个类只是负责菜单文字的显示，那么，游戏中的LIFE,WORLD的提示，是在哪里完成的呢？函数如下：
void GAMEMAP::ShowInfo(HDC h){ char temp[50]={0}; SetTextColor(h, TC_WHITE); SetBkColor(h, TC_BLACK); sprintf(temp, "LIFE : %d",iLife); TextOut(h, 220,100,temp,strlen(temp)); sprintf(temp, "WORLD : %d",iMatch+1); TextOut(h, 220,130,temp,strlen(temp));}
这个函数很简单。要说明的是，它并没有设置字体，因为在显示菜单的时候已经设置过了。
至此，所有文字的处理全部实现。
八、跟踪打印类FILEREPORT前面介绍了图片显示、时钟控制、字体管理几项基本技术。这是所有游戏都通用的基本技术。剩下的问题就是游戏逻辑，例如益智类、运动类、射击类、格斗类等等。当然，不同的游戏需要针对自身做一些优化，比如益智类游戏的时钟控制、画面刷新都更简单，而格斗游戏，画面的质量要更酷、更炫。下面要介绍整个游戏的核心层：逻辑控制。地图怎样绘制的？物品的坐标怎么存储？人物怎样移动？游戏流程是什么样的？
在介绍这些内容前，先打断一下思路，说程序是怎样写出来的，即“调试”。
程序就是一堆代码，了无秘密。初学时，dos下一个猜数字的程序，只需要十几行。一个纸牌游戏，一千多行，而超级玛丽增强版，近三千行。怎样让这么一堆程序从无到有而且运行正确？开发不是靠设计的巧妙或者笨拙，而是靠反复调试。在三千行的代码中，增加一千行，仍然运行正确，这是编程的基本要求。这个最基本的要求，靠设计做不到，只能靠调试。正如公司里的测试部，人力规模，工作压力，丝毫不比开发部差。即使如此，还是能让一些简单bug流入最终产品。老板只能先问测试部：“这么简单的bug，怎么没测出来？”再问开发部：“这么明显的错误，你怎么写出来的？”总之，程序是调出来的。
怎么调？vc提供了很全面的调试方法，打断点、单步跟踪、看变量。这些方法对游戏不适用。一个bug，通常发生在某种情况下，比如超级玛丽，玩家在水管上，按方向键“下”，新的地图显示不出来，屏幕上乱七八糟。请问，bug在哪里？玩家坐标出问题、按键响应出问题、地图加载出问题、图片显示出问题？打断点，无处下手。
解决方法是：程序中，创建一个文本文件，在“可能有问题”的地方，添加代码，向这个文件写入提示信息或变量内容(称为跟踪打印)。这个文本文件，就成了代码运行的日志。看日志，就知道代码中发生了什么事情。最终，找到bug。
FILEREPORT，就是对日志文件创建、写入等操作的封装。
FILEREPORT类定义如下所示：
class FILEREPORT{public: // 功能 默认构造函数,创建日志trace.txt // 入参 无 FILEREPORT(); // 功能 指定日志文件名称 // 入参 日志文件名称 FILEREPORT(char *p); // 功能 析构函数,关闭文件 // 入参 无 ~FILEREPORT(); // 功能 向日志文件写入字符串 // 入参 要写入的字符串 void put(char *p); // 功能 向日志文件写入一个字符串,两个整数 // 入参 字符串 整数a 整数b void put(char *p,int a,int b); // 功能 计数器计数, 并写入一个提示字符串 // 入参 计时器id 字符串 void putnum(int i,char *p); // 功能 判断一个dc是否为null, 如果是,写入提示信息 // 入参 dc句柄 字符串 void CheckDC(HDC h,char *p); // 功能 设置显示跟踪信息的dc和文本坐标 // 入参 显示dc 横纵坐标 void SetDevice(HDC h,int x,int y); // 功能 设置要显示的跟踪信息 // 功能 提示字符串 整数a 整数b void Output(char *p,int a,int b); // 功能 在屏幕上显示当前的跟踪信息 void Show();private: // 跟踪文件指针 FILE *fp; // 计数器组 int num[5]; // 显示dc HDC hshow; // 跟踪文本显示坐标 int xpos; int ypos; // 当前跟踪信息 char info[50];};
函数具体实现很简单，只是简单的文件写入。要说明的是两部分，

一：计数功能，有时要统计某个事情发生多少次，所以用一个整数数组，通过putnum让指定数字累加。二：显示功能，让跟踪信息，立刻显示在屏幕上。
使用举例：没有使用。程序最终完成，所有的跟踪打印都已删除。
九、精灵结构struct ROLE这个结构用来存储两种精灵：敌人（各种小怪）和子弹（攻击方式）。敌人包括两种蘑菇兵和两种火圈。子弹包括火球和旋风。游戏中，精灵的结构很简单：
struct ROLE{ int x; // 横坐标 int y; // 纵坐标 int w; // 图片宽度 int h; // 图片高度 int id; // 精灵id int iframe; // 图片当前帧 int iframemax; // 图片最大帧数 // 移动部分 int xleft; // 水平运动的左界限 int xright; // 水平运动的右界限 int movex; // 水平运动的速度 // 人物属性 int health; // 精灵的生命值 int show; // 精灵是否显示};
游戏中的子弹处理非常简单，包括存储、生成、销毁。子弹的存储：所有的子弹存储在一个数组中，如下：
struct ROLE FireArray[MAX_MAP_OBJECT];
其实，所有的动态元素都有从生成到销毁的过程。看一下子弹是怎样产生的。
首先，玩家按下z键：发出子弹，调用函数：
int GAMEMAP::KeyProc(int iKey) case KEY_Z: // FIRE if(iBeginFire) break; iTimeFire=0; iBeginFire=1; break;
这段代码的意思是：如果正在发子弹，代码结束。否则，设置iBeginFire为1，表示开始发子弹。
子弹是在哪里发出的呢？
思路：用一个函数不停地检测iBeginFire，如果它为1，则生成一个子弹。函数如下：
int GAMEMAP::CheckAni(int itimeclip)
发子弹的部分：
// 发子弹 if(iBeginFire) { // 发子弹的时间到了(连续两个子弹要间隔一定时间) if(0 == iTimeFire ) { // 设置子弹属性: 可见, 动画起始帧:第0帧 FireArray[iFireNum].show=1; FireArray[iFireNum].iframe = 0; // 子弹方向 // 如果人物朝右 if(0==rmain.idirec) { // 子弹向右 FireArray[iFireNum].movex=1; } else { // 子弹向左 FireArray[iFireNum].movex=-1; } // 区分攻击种类: 子弹,旋风 switch(iAttack) { // 普通攻击: 子弹 case ATTACK_NORMAL: // 精灵ID: 子弹 FireArray[iFireNum].id=ID_ANI_FIRE; // 设置子弹坐标 FireArray[iFireNum].x=rmain.xpos; FireArray[iFireNum].y=rmain.ypos; // 设置子弹宽高 FireArray[iFireNum].w=FIREW; FireArray[iFireNum].h=FIREH; // 设置子弹速度: 方向向量乘以移动速度 FireArray[iFireNum].movex*=FIRE_SPEED; break;
最后,移动数组的游标iFireNum.这个名字没起好, 应该写成cursor.游标表示当前往数组中存储元素的位置。
// 移动数组游标iFireNum=(iFireNum+1)%MAX_MAP_OBJECT;
至此，游戏中已经生成了一个子弹。 由图像层，通过子弹的id，坐标在屏幕上绘制出来。
子弹已经显示在屏幕上，接下来，就是让它移动、碰撞、销毁。
十、子弹的显示和帧的刷新继续介绍子弹的显示和动画帧的刷新，这个思路，可以应用的其他精灵上。
上次讲所有的子弹存储到一个数组里，用一个游标（数组下标）表示新生产的子弹存储的位置。设数组为a，长度为n。游戏开始，一个子弹存储在a0，然后是a1，a2，…,a(n-1)。然后游标又回到0，继续从a0位置存储。数组长度30，保存屏幕上所有的子弹足够了。
子弹的显示功能由图像层完成，如同图像处理中讲的，显示一个子弹(所有图片都是如此)，只需要子弹坐标，子弹图片id，图片帧。函数如下：
void GAMEMAP::ShowAniObj(MYANIOBJ & bmobj)
代码部分:
// 显示子弹，魔法攻击 for(i=0;i<MAX_MAP_OBJECT;i++) { if (FireArray[i].show) { ystart=FireArray[i].y; xstart=FireArray[i].x; switch(FireArray[i].id) { case ID_ANI_FIRE: bmobj.DrawItem(xstart,ystart,FireArray[i].id,FireArray[i].iframe); break;
子弹图片显示完成。游戏中，子弹是两帧图片构成的动画。动画帧是哪里改变的呢?
刷新帧的函数是：
voidGAMEMAP::ChangeFrame(int itimeclip)
游戏中，不停地调用这个函数，刷新各种动画的当前帧。其中子弹部分的代码：
// 子弹，攻击控制 for(i=0;i<MAX_MAP_OBJECT;i++) { if(FireArray[i].show) { switch(FireArray[i].id) { default: FireArray[i].iframe=1-FireArray[i].iframe; break; } } }
子弹的动画只有两帧，所以iframe只是0,1交替变化。至此,子弹在屏幕上显示，并且两帧图片不停播放。
子弹和小怪碰撞，是游戏中的关键逻辑。网游里也是主要日常工作，打怪。消灭小怪，也是这个游戏的全部乐趣。那么, 这个关键的碰撞检测，以及碰撞检测后的逻辑处理，是怎样的呢?
十一、子弹运动和打怪玩家按攻击键，生成子弹，存储在数组中，显示，接下来：子弹运动，打怪。先说子弹是怎样运动的。思路：用一个函数不停地检测子弹数组，如果子弹可见，刷新子弹的坐标。
实现如下：
int GAMEMAP::CheckAni(int itimeclip){ // 子弹移动 for(i=0;i<MAX_MAP_OBJECT;i++) { // 判断子弹是否可见 if (FireArray[i].show) { // 根据子弹的移动速度movex,修改子弹坐标. // (movex为正,向右移动;为负,向左移动,). FireArray[i].x+=FireArray[i].movex; // 判断子弹是否超出了屏幕范围，如果超出,子弹消失(设置为不可见) if( FireArray[i].x > viewx+VIEWW || FireArray[i].x<viewx-FIRE_MAGIC_MAX_W) { FireArray[i].show = 0; } } }}
至此，子弹在屏幕上不停地运动。
打怪是怎样实现的呢：碰撞检测的思路：用一个函数不停地检测所有子弹，如果某个子弹碰到了小怪，小怪消失，子弹消失。
实现如下:
int GAMEMAP::CheckAni(int itimeclip){ // 检测子弹和敌人的碰撞（包括魔法攻击） for(i=0;i<MAX_MAP_OBJECT;i++) { // 判断小怪是否可见 if(MapEnemyArray[i].show) { // 检测所有子弹 for(j=0;j<MAX_MAP_OBJECT;j++) { // 判断子弹是否可见 if (FireArray[j].show) { // 判断子弹和小怪是否"碰撞" if(RECT_HIT_RECT(FireArray[j].x+FIRE_XOFF, FireArray[j].y, FireArray[j].w, FireArray[j].h, MapEnemyArray[i].x, MapEnemyArray[i].y, MapEnemyArray[i].w, MapEnemyArray[i].h) ) { // 如果碰撞,小怪消灭 ClearEnemy(i); switch(iAttack) { case ATTACK_NORMAL: // 子弹消失 FireArray[j].show=0;
如果是旋风，在旋风动画帧结束后消失。
碰撞检测说明
子弹和小怪，都被看作是矩形，检测碰撞就是判断两个矩形是否相交。以前，有网友说，碰撞检测有很多优化算法。我还是想不出来，只写成了这样：
// 矩形与矩形碰撞#define RECT_HIT_RECT(x,y,w,h,x1,y1,w1,h1) ( (y)+(h)>(y1) && (y)<(y1)+(h1) && (x)+(w)>(x1) && (x)<(x1)+(w1) )
小怪的消失，代码如下所示：
void GAMEMAP::ClearEnemy(int i){ // 小怪的生命值减一 MapEnemyArray[i].health--; // 如果小怪的生命值减到0, 小怪消失(设置为不可见) if(MapEnemyArray[i].health<=0) { MapEnemyArray[i].show=0; }}
至此，玩家按下攻击键，子弹生成、显示、运动，碰到小怪，子弹消失，小怪消失。这些功能全部完成。如果只做成这样，不算本事。
攻击方式分两种：子弹和旋风。小怪包括：两种蘑菇兵和两种火圈。同时，火圈能产生两种蘑菇兵，而旋风的攻击效果明显高于普通子弹。这是不是很复杂？怎样做到的呢？
十二、旋风攻击、小怪运动、火圈前面介绍了子弹的生成、显示、运动、碰撞、消失的过程。这个过程可以推广到其他精灵上。继续介绍旋风、蘑菇兵、火圈。
作为魔法攻击方式的旋风，和子弹大同小异。旋风的存储与子弹同存储在一个数组中，如下：
struct ROLE FireArray[MAX_MAP_OBJECT];
使用时，用id区分。旋风生成函数如下所示：
int GAMEMAP::CheckAni(int itimeclip){ // 发子弹 if(iBeginFire) { if(0 == iTimeFire ) { FireArray[iFireNum].show=1; FireArray[iFireNum].iframe = 0; // 子弹方向 if(0==rmain.idirec) { FireArray[iFireNum].movex=1; } else { FireArray[iFireNum].movex=-1; } switch(iAttack) { case ATTACK_MAGIC: FireArray[iFireNum].id=ID_ANI_FIRE_MAGIC; FireArray[iFireNum].x=rmain.xpos-ID_ANI_FIRE_MAGIC_XOFF; FireArray[iFireNum].y=rmain.ypos-ID_ANI_FIRE_MAGIC_YOFF; FireArray[iFireNum].w=FIRE_MAGIC_W; FireArray[iFireNum].h=FIRE_MAGIC_H; FireArray[iFireNum].movex=0; break; } // 移动数组游标 iFireNum=(iFireNum+1)%MAX_MAP_OBJECT; } iTimeFire=(iTimeFire+1)%TIME_FIRE_BETWEEN; }}
这和子弹生成的处理相同。唯一区别是旋风不移动，所以movex属性最后设置为0。
旋风的显示原理
旋风在屏幕上的绘制和子弹相同，代码部分和子弹相同。但是旋风的帧刷新有些特殊处理：
void GAMEMAP::ChangeFrame(int itimeclip){ // 子弹，攻击控制 for(i=0;i<MAX_MAP_OBJECT;i++) { // 如果攻击（子弹、旋风）可见 if(FireArray[i].show) { switch(FireArray[i].id) { case ID_ANI_FIRE_MAGIC: // 旋风当前帧加一 FireArray[i].iframe++; // 如果帧为2(即第三张图片) ,图片坐标修正,向右移 if(FireArray[i].iframe == 2) { FireArray[i].x+=FIRE_MAGIC_W; } // 如果帧号大于3,即四张图片播放完,旋风消失,设置为不可见 if(FireArray[i].iframe>3) { FireArray[i].show=0; } break; } }
至此，旋风显示，动画播放结束后消失。旋风不涉及运动。碰撞检测的处理和子弹相同，唯一区别是：当旋风和小怪碰撞，旋风不消失。
int GAMEMAP::CheckAni(int itimeclip){ switch(iAttack) { case ATTACK_NORMAL: // 子弹消失 FireArray[j].show=0; break; // 旋风不消失 default: break; }
那么，再看小怪消失的函数：
void GAMEMAP::ClearEnemy(int i){ MapEnemyArray[i].health--; if(MapEnemyArray[i].health<=0) { MapEnemyArray[i].show=0; }
可以看到，此时并不区分攻击方式。但旋风存在的时间长(动画结束后消失)，相当于多次调用了这个函数，间接提高了杀伤力。至此，两种攻击方式都已实现。
再看小怪，分蘑菇兵和火圈两种。
存储问题和攻击方式处理相同，用数组加游标的方法，蘑菇兵和火圈存储在同一数组中，如下：
struct ROLE MapEnemyArray[MAX_MAP_OBJECT];int iMapEnemyCursor;
小怪是由地图文件设定好的，以第二关的地图文件为例，其中小怪部分如下：
;enemy21 6 1 1 0 15 2423 6 1 1 0 15 2448 7 2 2 6 0 0 68 5 2 2 8 0 0
各个参数是什么意义呢？看一下加载函数就全明白了。函数如下所示：
int GAMEMAP::LoadMap(){// 如果文件没有结束后while(temp[0]!='#' && !feof(fp)) { // 读入小怪数据 横坐标 纵坐标 宽 高 id 运动范围左边界 右边界 sscanf(temp,"%d %d %d %d %d %d %d", &MapEnemyArray[i].x, &MapEnemyArray[i].y, &MapEnemyArray[i].w, &MapEnemyArray[i].h, &MapEnemyArray[i].id, &MapEnemyArray[i].xleft, &MapEnemyArray[i].xright); // 坐标转换.乘以32 MapEnemyArray[i].x*=32; MapEnemyArray[i].y*=32; MapEnemyArray[i].w*=32; MapEnemyArray[i].h*=32; MapEnemyArray[i].xleft*=32; MapEnemyArray[i].xright*=32; MapEnemyArray[i].show=1; // 设置移动速度(负,表示向左) MapEnemyArray[i].movex=-ENEMY_STEP_X; // 动画帧 MapEnemyArray[i].iframe=0; // 动画最大帧 MapEnemyArray[i].iframemax=2; // 设置生命值 switch(MapEnemyArray[i].id) { case ID_ANI_BOSS_HOUSE: MapEnemyArray[i].health=BOSS_HEALTH; break; case ID_ANI_BOSS_HOUSE_A: MapEnemyArray[i].health=BOSS_A_HEALTH; break; default: MapEnemyArray[i].health=1; break; } // 将火圈存储在数组的后半段,数值长30, BOSS_CURSOR为15 if ( i<BOSS_CURSOR && ( MapEnemyArray[i].id == ID_ANI_BOSS_HOUSE || MapEnemyArray[i].id == ID_ANI_BOSS_HOUSE_A) ) { // move data to BOSS_CURSOR MapEnemyArray[BOSS_CURSOR]=MapEnemyArray[i]; memset(&MapEnemyArray[i],0,sizeof(MapEnemyArray[i])); i=BOSS_CURSOR; } i++; // 读取下一行地图数据 FGetLineJumpCom(temp,fp); }
看来比生成子弹要复杂一些，尤其是火圈，为什么要从第15个元素上存储？因为，火圈要不停地生成蘑菇兵，所以”分区管理”，数值前一半存储蘑菇兵，后一半存储火圈。那么，小怪和火圈是怎样显示和运动的呢？火圈怎样不断产生新的小怪？
十三、小怪和火圈小怪的显示问题，蘑菇兵和火圈处于同一个数组，很简单：
void GAMEMAP::ShowAniObj(MYANIOBJ & bmobj){ // 显示敌人 for(i=0;i<MAX_MAP_OBJECT;i++) { if (MapEnemyArray[i].show) { bmobj.DrawItem(MapEnemyArray[i].x,MapEnemyArray[i].y, MapEnemyArray[i].id,MapEnemyArray[i].iframe); } }
同样，如同图片处理所讲，显示一个图片，只需要坐标、id、帧。
帧刷新和小怪运动的代码如下所示：
void GAMEMAP::ChangeFrame(int itimeclip){ // 移动时间:每隔一段时间ENEMY_SPEED，移动一下 if(0 == itimeclip% ENEMY_SPEED) { for(i=0;i<MAX_MAP_OBJECT;i++) { // 如果小怪可见 if(MapEnemyArray[i].show) { // 帧刷新 MapEnemyArray[i].iframe=(MapEnemyArray[i].iframe+1)%MapEnemyArray[i].iframemax; switch(MapEnemyArray[i].id) { case ID_ANI_ENEMY_NORMAL: case ID_ANI_ENEMY_SWORD: // 蘑菇兵移动(士兵，刺客) MapEnemyArray[i].x+=MapEnemyArray[i].movex; // 控制敌人移动：向左移动到左边界后，移动速度movex改为向右。移动到右边界后，改为向左。 if(MapEnemyArray[i].movex<0) { if(MapEnemyArray[i].x<=MapEnemyArray[i].xleft) { MapEnemyArray[i].movex=ENEMY_STEP_X; } } else { if(MapEnemyArray[i].x>=MapEnemyArray[i].xright) { MapEnemyArray[i].movex=-ENEMY_STEP_X; } } break; }
至此，所有小怪不停移动。（火圈的movex为0，不会移动）
在前面的子弹、旋风的碰撞处理中已讲过。碰撞后，生命值减少，减为0后，消失。火圈会产生新的蘑菇兵，怎样实现的呢？思路：不断地检测火圈是否出现在屏幕中，出现后，生成蘑菇兵。
int GAMEMAP::CheckAni(int itimeclip){ // 如果在显示范围之内，则设置显示属性 for(i=0;i<MAX_MAP_OBJECT;i++) { // 判断是否在屏幕范围内 if ( IN_AREA(MapEnemyArray[i].x, viewx, VIEWW) ) { // 如果有生命值,设置为可见 if(MapEnemyArray[i].health) { MapEnemyArray[i].show=1; switch(MapEnemyArray[i].id) { // 普通级火圈 case ID_ANI_BOSS_HOUSE: // 每隔一段时间, 产生新的敌人 if(itimeclip == TIME_CREATE_ENEMY) { MapEnemyArray[iMapEnemyCursor]=gl_enemy_normal; MapEnemyArray[iMapEnemyCursor].x=MapEnemyArray[i].x; MapEnemyArray[iMapEnemyCursor].y=MapEnemyArray[i].y+32; // 移动游标 iMapEnemyCursor=(iMapEnemyCursor+1)%BOSS_CURSOR; } break; // 下面是战斗级火圈,处理相似 } } } else { // 不在显示范围内,设置为不可见 MapEnemyArray[i].show=0; } }
这样，火圈就不断地产生蘑菇兵。
再说一下模板，这里的模板不是C++的模板。据说template技术已发展到艺术的境界，游戏中用到的和template无关，而是全局变量。如下：
// 普通蘑菇兵struct ROLE gl_enemy_normal={ 0, 0, 32, 32, ID_ANI_ENEMY_NORMAL, 0, 2, 0, 0, -ENEMY_STEP_X, // speed 1, 1};
当火圈不断产生新的蘑菇兵时，直接把这个小怪模板放到数组中，再修改一下坐标即可。(对于蘑菇刺客，还要修改id和生命值)
游戏的主要逻辑完成。此外，还有金币，爆炸效果等其他动态元素，它们是怎么实现的？
十四、爆炸效果和金币子弹每次攻击到效果，都会显示一个爆炸效果。由于只涉及图片显示，它的结构很简单。如下：
struct MapObject{ int x; int y; int w; int h; int id; int iframe; int iframemax; // 最大帧数 int show; // 是否显示};
存储问题，爆炸效果仍然使用数组加游标的方法，如下：
struct MapObject BombArray[MAX_MAP_OBJECT];int iBombNum;
当子弹和小怪碰撞后，生成。
void GAMEMAP::ClearEnemy(int i){ // 生成BombArray[iBombNum].show=1; BombArray[iBombNum].id=ID_ANI_BOMB; BombArray[iBombNum].iframe=0; BombArray[iBombNum].x=MapEnemyArray[i].x-BOMB_XOFF; BombArray[iBombNum].y=MapEnemyArray[i].y-BOMB_YOFF; // 修改数组游标 iBombNum=(iBombNum+1)%MAX_MAP_OBJECT;
和子弹、小怪的显示方法相同。
void GAMEMAP::ShowAniObj(MYANIOBJ & bmobj){ for(i=0;i<MAX_MAP_OBJECT;i++) { if (BombArray[i].show) { ystart=BombArray[i].y; xstart=BombArray[i].x; bmobj.DrawItem(xstart,ystart,BombArray[i].id, BombArray[i].iframe); } }
和子弹、小怪的帧刷新方法相同。
void GAMEMAP::ChangeFrame(int itimeclip){for(i=0;i<MAX_MAP_OBJECT;i++) { if(BombArray[i].show) { BombArray[i].iframe++; // 当第四张图片显示完毕，设置为不可见。 if(BombArray[i].iframe>3) { BombArray[i].show=0; } } }
碰撞检测：爆炸效果不涉及碰撞检测。
消失：如上所述，爆炸效果在动画结束后消失。
金币的处理比小怪更简单。当玩家和金币碰撞后，金币消失，增加金钱数量。用数组加游标的方法存储，如下：
struct MapObject MapCoinArray[MAX_MAP_OBJECT];int iCoinNum;
金币的生成，和小怪相似，从地图文件中加载。以第二关为例，地图文件中的金币数据是：
6 5 32 32 3 7 5 32 32 3 8 5 32 32 3 9 5 32 32 3 18 4 32 32 3 19 4 32 32 3 20 4 32 32 3
数据依次表示横坐标、纵坐标、宽、高、图片id。
int GAMEMAP::LoadMap(){ while(temp[0]!='#' && !feof(fp)) { sscanf(temp,"%d %d %d %d %d", &MapCoinArray[i].x, &MapCoinArray[i].y, &MapCoinArray[i].w, &MapCoinArray[i].h, &MapCoinArray[i].id); MapCoinArray[i].show=1; MapCoinArray[i].iframe=0; // 坐标转换，乘以32 MapCoinArray[i].x*=32; MapCoinArray[i].y*=32; // 设置这个动画元件的最大帧 switch(MapCoinArray[i].id) { case ID_ANI_COIN: MapCoinArray[i].iframemax=4; break; } i++; iCoinNum++; // 读取下一行数据 FGetLineJumpCom(temp,fp); }
金币显示和小怪的显示方法相同：
void GAMEMAP::ShowAniObj(MYANIOBJ & bmobj){ // 显示金币,和其他物品 for(i=0;i<iCoinNum;i++) { ystart=MapCoinArray[i].y; xstart=MapCoinArray[i].x; bmobj.DrawItem(xstart,ystart,MapCoinArray[i].id, MapCoinArray[i].iframe); }
金币帧刷新和小怪的帧刷新方法相同：
void GAMEMAP::ChangeFrame(int itimeclip){ for(i=0;i<MAX_MAP_OBJECT;i++) { // 如果金币可见,帧加一 if(MapCoinArray[i].show) { MapCoinArray[i].iframe=(MapCoinArray[i].iframe+1)%MapCoinArray[i].iframemax; } }
金币碰撞检测和小怪的碰撞检测方法相似，区别在于：金币的碰撞检测没有判断是否可见，只要金币位于屏幕中，和玩家碰撞，则金币消失，金钱数量iMoney增加。
int GAMEMAP::CheckAni(int itimeclip){ for(i=0;i<iCoinNum;i++) { tempx=MapCoinArray[i].x; tempy=MapCoinArray[i].y; if ( IN_AREA(tempx, viewx-32, VIEWW) ) { // 玩家坐标是rmain.xpos rmain.ypos if( RECT_HIT_RECT(rmain.xpos, rmain.ypos, 32,32, tempx, tempy, MapCoinArray[i].w,MapCoinArray[i].h) ) { switch(MapCoinArray[i].id) { case ID_ANI_COIN: // 增加金钱数量 iMoney+=10; // 金币消失 ClearCoin(i); break; } return 0; } } } // end of for
金币消失和小怪的消失不一样，不需要设置show为0，而是直接删除元素，即数组移动的方法：
void GAMEMAP::ClearCoin(int i){ // 检查合法性 if(i<0 || i>=iCoinNum) return; // 减少一个金币,或者减少一个其他物品 for(;i<iCoinNum;i++) { MapCoinArray[i]=MapCoinArray[i+1]; } // 修改数量 iCoinNum--;
由此可见，直接删除元素，省去了是否可见的判断。但凡事都有两面性，移动数组显然比单个元素的设置要慢（实际上不一定，可以优化）。方法多种多样，这就是程序的好处，永远有更好的答案。
所有的动态元素都介绍完了。所谓动态元素，就是有一个生成、运行、销毁的过程。只不过，有的复杂一些，如子弹、旋风、蘑菇兵、火圈，有些元素简单一些，如爆炸效果、金币。方法都大同小异，要强调的是，这不是最好的方法。碰到金币后，会出现‘+10’的字样，怎么做呢？
十五、金币提示和攻击提示提示信息，是玩家得到的反馈。比如，碰到金币，金币消失，此时就要显示“+10”；攻击小怪，小怪却没有消失，这时要显示血条，告知玩家小怪的生命值。下面讲提示信息。
金币提示+10的字样，并没有用文字处理，而是用图片（4帧的动画）。这样，实现起来很简单，和爆炸效果用同一个数组存储，处理方法相同。
金币的碰撞检测函数如下所示：
int GAMEMAP::CheckAni(int itimeclip){ for(i=0;i<iCoinNum;i++) { // 判断玩家是否碰到金币 switch(MapCoinArray[i].id) { case ID_ANI_COIN: // 碰到金币 iMoney+=10; // 金币消失,显示+10字样 ClearCoin(i); break;
金币消失函数如下所示：
void GAMEMAP::ClearCoin(int i){ switch(MapCoinArray[i].id) { case ID_ANI_COIN: // 碰到了金币，显示+10字样. 和爆炸效果的处理一样, 只是图片id不同 BombArray[iBombNum].show=1; BombArray[iBombNum].id=ID_ANI_COIN_SCORE; BombArray[iBombNum].iframe=0; BombArray[iBombNum].x=MapCoinArray[i].x-COIN_XOFF; BombArray[iBombNum].y=MapCoinArray[i].y-COIN_YOFF; iBombNum=(iBombNum+1)%MAX_MAP_OBJECT; break; }
攻击提示需要给出攻击对象名称，血条。存储：
// 攻击对象提示 char AttackName[20]; // 攻击对象名称 int iAttackLife; // 攻击对象当前生命值 int iAttackMaxLife; // 攻击对象最大生命值
提示信息设置：在小怪被攻击的时候，设置提示信息。其他攻击对象处理相似。
void GAMEMAP::ClearEnemy(int i){ // 设置攻击对象生命值 iAttackLife=MapEnemyArray[i].health; switch(MapEnemyArray[i].id) { case ID_ANI_BOSS_HOUSE: // 设置名称 strcpy(AttackName,"普通级火圈"); // 设置最大生命值 iAttackMaxLife=BOSS_HEALTH;
提示信息显示：
void GAMEMAP::ShowOther(HDC h){ // 如果攻击对象生命值不为0, 显示提示信息 if(iAttackLife) { // 输出名称 TextOut(h,viewx+ATTACK_TO_TEXT_X, ATTACK_TO_TEXT_Y,AttackName,strlen(AttackName)); // 显示血条 xstart=viewx+ATTACK_TO_X-iAttackMaxLife*10; // 按最大生命值显示一个矩形, 作为背景 bmMap.DrawItemNoMaskWidth(xstart-1, ATTACK_TO_Y-1,ID_MAP_HEALTH_BK, iAttackMaxLife*BMP_WIDTH_HEALTH, 0); // 按当前生命值对应的宽度, 显示一个红色矩形 bmMap.DrawItemNoMaskWidth(xstart, ATTACK_TO_Y,ID_MAP_HEALTH, iAttackLife*BMP_WIDTH_HEALTH, 0); }
金钱数量显示和攻击提示位于同一个函数：
void GAMEMAP::ShowOther(HDC h){ sprintf(temp,"MONEY: %d",iMoney); TextOut(h,viewx+20,20,temp,strlen(temp));
至此，攻击系统（子弹、旋风、蘑菇兵，火圈），金币（金币，金钱数量），提示信息（金币提示，攻击提示），这几类元素都介绍过了，还有一个，武器切换，就是从魂斗罗里抠来的那个东西。
十六、攻击方式切换当玩家碰到武器包（就是魂斗罗里那个东西），攻击方式切换。

思路：把它放到存储金币的数组中，用id区别。碰撞检测时，如果是金币，金币消失，如果是武器包，攻击方式切换。存储：和金币位于同一个数组MapCoinArray。生成：由地图文件加载。比如第一关的地图文件数据：
25 4 52 25 5
各参数含义：横坐标、纵坐标、宽、高、图片id。
和金币的加载相同，唯一区别是金币图片有4帧，武器包只有2帧，加载函数如下所示：
int GAMEMAP::LoadMap(){ MapCoinArray[i].iframemax=2;
显示和金币的处理相同，相同函数，相同代码。（再次显示出图像层的好处）
帧刷新和金币的处理相同，相同函数，相同代码。（再次显示出图像层的好处）
碰撞检测和金币的处理相同，如果是武器包，设置新的攻击方式，武器包消失。
int GAMEMAP::CheckAni(int itimeclip){ switch(MapCoinArray[i].id) { case ID_ANI_ATTACK: // 设置新的攻击方式 iAttack=ATTACK_MAGIC; // 武器包消失 ClearCoin(i); break; }
武器包的消失和金币的处理相同，相同函数，相同代码，这是逻辑层的好处（放在同一个数组中，处理简单）。
至此，攻击系统，金币系统，提示信息，武器切换，全部完成。只需要一个地图把所有的物品组织起来，构成一个虚拟世界，呈现在玩家眼前。
十七、地图物品自从游戏机发明以来，地图是什么样的呢？打蜜蜂，吃豆，地图是一个矩形，玩家在这个矩形框内活动。后来，地图得到扩展，可以纵向移动，比如打飞机；可以横向移动，比如超级玛丽、魂斗罗等等横板过关游戏。再后来，横向纵向都可以移动，后来又有45度地图，3D技术后终于实现了高度拟真的虚拟世界。

超级玛丽的地图可以看成是一个二维的格子。每个格子的大小是32x32像素。游戏窗口大小为12个格子高，16个格子宽。游戏地图宽度是游戏窗口的5倍，即12个格子高，5x16个格子宽。
地图物品有哪些呢？地面，砖块，水管。先看一下存储结构：
struct MapObject{ int x; int y; int w; int h; int id; int iframe; int iframemax; // 最大帧数 int show; // 是否显示};
各个成员含义是横坐标、纵坐标、宽、高、id、当前帧、最大帧、是否可见。用第一关地图文件的地图物品举例：（只包含5个参数）
0 9 10 3 0这个物品是什么呢？横向第0个格子，纵向第9个格子，宽度10个格子，高度3个格子，id为0，表示地面。
在显示的时候，只要把坐标、宽高乘以32，即可正确显示。
地图所有物品仍然用数组+游标的方法存储，如下：
struct MapObject MapArray[MAX_MAP_OBJECT];int iMapObjNum;
从地图文件中加载并生成地图。
int GAMEMAP::LoadMap(){ while(temp[0]!='#' && !feof(fp)) { // 读取一个物品 sscanf(temp,"%d %d %d %d %d", &MapArray[i].x, &MapArray[i].y, &MapArray[i].w, &MapArray[i].h, &MapArray[i].id); MapArray[i].show=0; iMapObjNum++; i++; // 读取下一个物品 FGetLineJumpCom(temp,fp); }
地图显示和物品显示一样，只是地面和砖块需要双重循环。对于每个宽w格，高h格的地面、砖块，需要把单个地面砖块平铺w*h次，所以用双重循环。
void GAMEMAP::Show(MYANIOBJ & bmobj){ for(i=0;i<iMapObjNum;i++) { ystart=MapArray[i].y*32; switch(MapArray[i].id) { //进出水管 case ID_MAP_PUMP_IN: case ID_MAP_PUMP_OUT: xstart=MapArray[i].x*32; bmobj.DrawItemNoMask(xstart, ystart, MapArray[i].id, 0); break; default: for(j=0;j<MapArray[i].h;j++) { xstart=MapArray[i].x*32; for(k=0;k<MapArray[i].w;k++) { bmobj.DrawItemNoMask(xstart, ystart, MapArray[i].id, 0); xstart+=32; } ystart+=32; } // end of for break;
其中，水管是一个单独完整的图片，直接显示，不需要循环。
地面、砖块、水管都是静态图片，不涉及帧刷新。保证玩家顺利地行走，如果玩家不踩在物品上，则不停地下落。
int GAMEMAP::CheckRole(){ // 检测角色是否站在某个物体上 for(i=0;i<iMapObjNum;i++) { // 玩家的下边线，是否和物品的上边线重叠 if( LINE_ON_LINE(rmain.xpos, rmain.ypos+32, 32, MapArray[i].x*32, MapArray[i].y*32, MapArray[i].w*32) ) { // 返回1，表示玩家踩在这个物品上 return 1; } } // 角色开始下落 rmain.movey=1; rmain.jumpx=0; // 此时要清除跳跃速度，否则将变成跳跃，而不是落体 return 0;
十八、背景物品背景物品更简单，包括草丛，树木，河流，win标志。这些背景物品只需要显示，不涉及逻辑处理。用数组+游标的方法存储，如下：
struct MapObject MapBkArray[MAX_MAP_OBJECT];int iMapBkObjNum;
第一关的背景物品数据（含义和地图物品相同）：
17 5 3 2 0 （草丛）76 7 3 2 1 （win标志）10 10 3 2 2 （河流）
背景物品加载和地图物品加载方法相同。
int GAMEMAP::LoadMap(){ while(temp[0]!='#' && !feof(fp)) { sscanf(temp,"%d %d %d %d %d", &MapBkArray[i].x, &MapBkArray[i].y, …... MapBkArray[i].iframe=0; iMapBkObjNum++; i++; // 下一个物品 FGetLineJumpCom(temp,fp); }
背景物品的显示：
void GAMEMAP::ShowBkObj(MYANIOBJ & bmobj){ for(i=0;i<iMapBkObjNum;i++) { bmobj.DrawItem(xstart,ystart,MapBkArray[i].id,ibkobjframe); }
帧刷新：背景物品都是2帧动画。所有背景物品当前帧用ibkobjframe控制。
void GAMEMAP::ChangeFrame(int itimeclip){ if(0 == itimeclip% WATER_SPEED) { ibkobjframe=1-ibkobjframe;
十九、视图怎样把所有东西都显示在窗口中，并随着玩家移动呢？
思路：玩家看到的区域称为视图，即12格高，16格宽的窗口（每格32*32像素）。先把整个地图则绘制在一个DC上，然后从这个地图DC中，截取当前视图区域的图像，绘制到窗口中。修改视图区域的坐标（横坐标增加），就实现了地图的移动。
初始化：
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow){ // hwindow是游戏窗口的DC句柄 hwindow=GetDC(hWnd); // hscreen是整个地图对应的DC hscreen=CreateCompatibleDC(hwindow); // 建立一个整个地图大小（5倍窗口宽）的空位图，选入hscreen hmapnull=CreateCompatibleBitmap(hwindow,GAMEW*32*5,GAMEH*32); SelectObject(hscreen,hmapnull);
视图的显示：
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ case WM_PAINT: // hwindow是游戏窗口的DC句柄 hwindow = BeginPaint(hWnd, &ps); SelectObject(hscreen,hmapnull); case GAME_IN: // 显示天空 bmSky.DrawRollStretch(2,2,gamemap.mapinfo.iBackBmp); // 显示背景物品 gamemap.ShowBkObj(bmMapBkObj); // 显示地图物品 gamemap.Show(bmMap); // 显示动态元素 gamemap.ShowAniObj(bmAniObj); // 显示提示信息 gamemap.ShowOther(hscreen); // 显示玩家 rmain.Draw(); break; if(gamemap.iScreenScale) { // 窗口大小调整功能,代码略 } else { // 从整个地图的DC中, 截取当前视图区域的图像，绘制到窗口 BitBlt(hwindow, 0, 0, GAMEW*32, GAMEH*32, hscreen, gamemap.viewx, 0, SRCCOPY); }
可以看到，视图的左上角横坐标是viewx，只需要刷新这个坐标，就实现了地图移动。
视图坐标刷新思路：用一个函数不停地检测，玩家角色和视图左边界的距离，超过特定值，把视图向右移。如果玩家坐标和视图左边界的距离大于150，移动视图。
void GAMEMAP::MoveView(){ if(rmain.xpos - viewx > 150) { viewx+=ROLE_STEP; //判断视图坐标是否达到最大值（地图宽度减去一个窗口宽度） if(viewx>(mapinfo.viewmax-1)*GAMEW*32) viewx=(mapinfo.viewmax-1)*GAMEW*32; }
二十、地图切换地图分两种，普通地图和隐藏地图（指通过水管进入的地图）。先讲普图地图的切换，再讲隐藏地图的切换。
普通地图的切换思路：很简单，用一个数字iMatch表示当前是第几关。每过一关，iMatch+1，加载下一张地图。
过关检测：用一个函数不停地检测玩家是否到了地图终点，如果是，加载下一关的地图。
int GAMEMAP::IsWin(){ // 判断玩家的坐标是否到达地图终点（横坐标大于等于地图宽度） if(rmain.xpos >= MAX_PAGE*GAMEW*32 ) { // iMatch增加 iMatch=mapinfo.iNextMap; if(iMatch>=MAX_MATCH) { // 如果iMatch大于关卡数量（即通过最后一关），加载第一关的数据，代码略 } else { // 没有通关 InitMatch();//初始化游戏数据 // 设置玩家角色坐标，初始化玩家角色 rmain.SetPos(BM_USER,3*32,8*32); rmain.InitRole(0,GAMEW*32*MAX_PAGE-32); // 加载下一关的地图 LoadMap(); }
函数LoadMap()根据iMatch的值加载某一关的地图。而iMatch的修改代码是：

对于普通地图iMatch取值为0,1,2,…，只需要+1即可，为什么要有一个复杂的赋值过程呢？是为了实现隐藏地图的切换。
隐藏地图的切换，先看一下LoadMap加载的地图文件是什么样子？超级玛丽增强版的地图存储在一个文本文件中，结构为：
*0// 第0关的地图数据*1// 第1关的地图数据…*4// 第4关的地图数据
其中，编号0,1,2表示前三关的普图地图，编号3,4是隐藏地图（3是第0关的隐藏地图，4是第1关的隐藏地图）。怎样表示地图之间的关系呢？
思路：设计一张“地图信息表”，格式如下：
第0关：下一关编号，隐藏地图编号第1关：下一关编号，隐藏地图编号…第4关：下一关编号，隐藏地图编号
这样就形成一个地图信息的处理：

从“地图信息表”中读取当前关卡的的地图信息。当玩家到达地图终点，读取“下一关”编号；玩家进入水管，读取“隐藏地图编号”。
游戏的地图信息结构：
struct MAPINFO{ int iNextMap; int iSubMap;};
地图信息表（全局变量）： （数组的第i个元素，表示第i关的地图信息）
struct MAPINFO allmapinfo[]={ {1,3}, {2,4}, {MAX_MATCH,-1, }, {-1,0}, {-1,1}};
对应的逻辑信息为：

第0关的下一关是第1关，从水管进入第3关。第1关的下一关是第2关，从水管进入第4关。第2关（最后一关）没有下一关（MAX），没有从水管进入的地图。第3关没有下一关，从水管进入第0关。第4关没有下一关，从水管进入第1关。
这样，实现了从水管进入隐藏关，又从水管返回的功能。
地图信息的存储在 struct MAPINFO mapinfo; 结构体变量中，每一关的游戏开始前，都要用这个函数初始化游戏数据。包括读取地图信息：
void GAMEMAP::InitMatch(){ mapinfo=allmapinfo[iMatch];
玩家到达地图终点的检测：
int GAMEMAP::IsWin(){ iMatch=mapinfo.iNextMap;
切换到下一关的地图编号。
玩家进入水管的检测思路：当玩家按下方向键“下”，判断是否站在水管上（当然进入地图的水管），如果是，切换地图。
int GAMEMAP::KeyProc(int iKey){ case VK_DOWN: for(i=0;i<iMapObjNum;i++) { // 判断玩家是否站在一个地图物品上 if( LINE_IN_LINE(玩家坐标，地图物品坐标)) { // 这个物品是水管 if(MapArray[i].id == ID_MAP_PUMP_IN) { // 设置游戏状态：进入水管 iGameState=GAME_PUMP_IN;
函数WndProc中，不断检测GAME_PUMP_IN状态，代码如下：
case WM_TIMER: switch(gamemap.iGameState) { case GAME_PUMP_IN: if(c1.DecCount()) { // 如果GAME_PUMP_IN状态结束，加载隐藏地图。 gamemap.ChangeMap();：
是不是复杂一些？确实，它可以简化。我想这还是有好处，它容易扩展。这仍然是我最初的构思，这是一个代码框架。看一下ChangeMap的处理：
void GAMEMAP::ChangeMap(){ //读取隐藏地图编号 iMatch=mapinfo.iSubMap; //游戏初始化 InitMatch(); //加载地图 LoadMap();
可见，ChangeMap的简单很简单。因为，LoadMap的接口只是iMatch，我只要保证iMatch在不同情况下设置正确，地图就会正确地加载。
至此，地图切换实现。但是，地图切换中，还有其它的游戏数据要刷新，怎样处理呢？
二十一、游戏数据管理进入每一关之前，需要对所有游戏数据初始化。进入隐藏地图，同样需要初始化。而且，从隐藏地图返回上层地图，还要保证玩家出现在“出水管”处。地图数据、玩家数据、视图数据，都要设置正确。
所有的游戏数据，即封装在gamemap中的数据，分成如下几种：

场景数据：包含当前关卡的地图，所有精灵，金币，提示信息。视图数据：视图窗口坐标。玩家数据：玩家角色的个人信息，例如金钱数量，攻击方式，游戏次数。
1.场景数据
int iGameState; // 当前游戏状态 int iMatch; // 当前关卡 // 各种精灵的数组: struct MapObject MapArray[MAX_MAP_OBJECT]; // 地图物品 struct MapObject MapBkArray[MAX_MAP_OBJECT]; // 地图背景物品 struct ROLE MapEnemyArray[MAX_MAP_OBJECT]; // 小怪 struct MapObject MapCoinArray[MAX_MAP_OBJECT]; // 金币 struct ROLE FireArray[MAX_MAP_OBJECT]; // 子弹 struct MapObject BombArray[MAX_MAP_OBJECT]; // 爆炸效果 // 当前关卡的地图信息 struct MAPINFO mapinfo; // 图片帧int ienemyframe; // 小怪图片帧 int ibkobjframe; // 背景图片帧 // 玩家攻击 int iTimeFire; // 两个子弹的间隔时间 int iBeginFire; // 是否正在发子弹 // 攻击对象提示 char AttackName[20]; // 攻击对象名称 int iAttackLife; // 攻击对象生命值 int iAttackMaxLife; // 攻击对象最大生命值
2.视图数据
int viewx; // 视图起始坐标
3.玩家数据
int iMoney; // 金钱数量 int iAttack; // 攻击方式 int iLife; // 玩家游戏次数
可见，每次加载地图前，要初始化场景数据和视图数据，而玩家数据不变，如金钱数量。
游戏数据处理，假设没有隐藏地图的功能，游戏数据只需要完成初始化的功能，分别位于以下三个地方：

程序运行前，初始化；过关后，初始化，再加载下一关地图；失败后，初始化，再加载当前地图；
1.游戏程序运行，所有游戏数据初始化
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow){ gamemap.Init();void GAMEMAP::Init(){ // 设置游戏初始状态 iGameState=GAME_PRE; // 设置当前关卡 iMatch=0; // 设置玩家数据 玩家游戏次数,金钱数量,攻击种类 iLife=3; iMoney=0; iAttack=ATTACK_NORMAL; // 设置视图坐标 viewx=0; // 初始化场景数据 InitMatch();void GAMEMAP::InitMatch(){ memset(MapArray,0,sizeof(MapArray)); memset(BombArray,0,sizeof(BombArray)); ienemyframe=0; iFireNum=0; ……
这样，程序启动，InitInstance中完成第一次初始化。
2.过关后，游戏数据初始化，加载下一关地图
int GAMEMAP::IsWin(){ // 判断玩家是否到达地图终点 if(rmain.xpos >= MAX_PAGE*GAMEW*32 ) { // 读取下一关地图编号 iMatch=mapinfo.iNextMap; if(iMatch>=MAX_MATCH) { // 如果全部通过 Init(); // 初始化所有数据 LoadMap(); // 加载地图 } else { InitMatch(); // 初始化场景数据 // 设置玩家坐标 rmain.SetPos(BM_USER,3*32,8*32); rmain.InitRole(0,GAMEW*32*MAX_PAGE-32); // 加载下一关的地图 LoadMap(); }
3.如果玩家失败，重新加载当前地图
int GAMEMAP::IsWin(){ // 检测角色和敌人的碰撞 for(i=0;i<MAX_MAP_OBJECT;i++) { if(MapEnemyArray[i].show) { if(HLINE_ON_RECT(玩家坐标 小怪坐标)) { if(0 == rmain.movey) { // 玩家在行走过程中，碰到小怪，游戏失败 Fail(); } else { // 玩家在下落过程中，碰到火圈，游戏失败 switch(MapEnemyArray[i].id) { case ID_ANI_BOSS_HOUSE: case ID_ANI_BOSS_HOUSE_A: Fail(); …… // 玩家到达地图底端（掉入小河），游戏失败 if(rmain.ypos > GAMEH*32) { Fail(); return 0; } void GAMEMAP::Fail(){ // 玩家游戏次数减1 iLife--; // 设置游戏状态 iGameState=GAME_FAIL_WAIT;// GAME_FAIL_WAIT状态结束后，调用函数void GAMEMAP::Fail_Wait()加载地图。void GAMEMAP::Fail_Wait(){ if( iLife <=0) { // 游戏次数为0，重新开始，初始化所有数据 Init(); } else { // 还能继续游戏 } // 设置玩家坐标 rmain.SetPos(BM_USER,3*32,8*32); rmain.InitRole(0,GAMEW*32*MAX_PAGE-32); // 加载当前地图 LoadMap();
至此，在没有隐藏地图的情况下，游戏数据管理（只有初始化）介绍完了。
增加了隐藏地图的功能，游戏数据管理包括：初始化，数据刷新。哪些数据需要刷新呢？

刷新玩家坐标
例如，从第一关（地图编号为0）进入隐藏地图，玩家出现在（3，8），即横向第3格，纵向第8格。玩家返回第一关后，要出现在“出水管”的位置（66，7）。
刷新视图坐标
例如，从第一关进入隐藏地图，玩家出现在（3，8），视图对应地图最左边，玩家返回第一关后，视图要移动到“出水管”的位置。
刷新背景图片的坐标
例如，从第一关进入隐藏地图，玩家出现在（3，8），天空背景对应地图最左边，玩家返回第一关后，背景图片要移动到“出水管”的位置。

void GAMEMAP::ChangeMap(){ // 初始化视图坐标 viewx=0; // 获取隐藏地图编号 iMatch=mapinfo.iSubMap; // 初始化场景数据 InitMatch(); // 设置玩家坐标 rmain.SetPos(BM_USER,mapinfo.xReturnPoint*32,mapinfo.yReturnPoint*32); // 玩家角色初始化rmain.InitRole(0,GAMEW*32*MAX_PAGE-32); // 设定视图位置 if(rmain.xpos - viewx > 150) { SetView(mapinfo.xReturnPoint*32-32); // 往左让一格 if(viewx>(mapinfo.viewmax-1)*GAMEW*32) viewx=(mapinfo.viewmax-1)*GAMEW*32; } // 设定人物活动范围 rmain.SetLimit(viewx, GAMEW*32*MAX_PAGE); // 设定背景图片坐标 bmSky.SetPos(BM_USER,viewx,0); // 加载地图 LoadMap();}
所以，地图信息表中，要包含“出水管”的坐标。完整的地图信息表如下：
struct MAPINFO{ int iNextMap; // 过关后的下一关编号 int iSubMap; // 进入水管后的地图编号 int xReturnPoint; // 出水管的横坐标 int yReturnPoint; // 出水管的纵坐标 int iBackBmp; // 背景图片ID int viewmax; // 视图最大宽度};struct MAPINFO allmapinfo[]={{1,3,66,7,0,5},{2,4,25,4,1,5},{MAX_MATCH,-1,-1,-1,2,5},{-1,0,3,8,3,1},{-1,1,3,8,3,2}};
第0关
{1,3,66,7,0,5},表示第0关的下一关是第1关，从水管进入第3关，出水管位于（66，7），天空背景id为0，视图最大宽度为5倍窗口宽度。
第3关
{-1,0,3,8,3,1},表示第3关没有下一关，从水管进入第0关，出水管位于（3，8），天空背景id为3，视图最大宽度为1倍窗口宽度。
这样，隐藏地图切换的同时，视图数据，玩家数据均正确。
各个动态元素，地图的各种处理都已完成，只需要让玩家控制的小人，走路，跳跃，攻击，进出水管。玩家的动作控制怎样实现？
二十二、玩家角色类MYROLE玩家控制的小人，和各种小怪基本一致。没什么神秘的。主要有三个功能要实现：键盘响应，动作控制，图片显示。
为了方便图片显示，玩家角色类MYROLE直接派生自图片类MYBITMAP。
MYROLE类定义如下所示：
class MYROLE:public MYBITMAP{public: // 构造函数,析构函数 MYROLE(); ~MYROLE(); // 初始化部分 // 功能 初始化玩家信息 // 入参 玩家运动范围的左边界 右边界() void InitRole(int xleft, int xright); // 功能 设置玩家运动范围 // 入参 玩家运动范围的左边界 右边界() void SetLimit(int xleft, int xright); // 图片显示部分 // 功能 显示玩家角色图片(当前坐标 当前帧) // 入参 指定的横坐标 纵坐标 帧 void Draw(int x,int y,int iframe); // 功能 刷新帧,该函数没有使用, 帧刷新的功能在其它地方完成 // 入参 无 void ChangeFrame(); // 功能 设置玩家状态. 该函数没有使用 // 入参 玩家状态 void SetState(int i); // 动作部分 // 功能 玩家角色移动 // 入参 无 void Move(); // 功能 玩家角色跳跃. 该函数没有使用 // 入参 指定地点横坐标 纵坐标 void MoveTo(int x,int y); // 功能 从当前位置移动一个增量 // 入参 横坐标增量 纵坐标增量 void MoveOffset(int x,int y); // 功能 向指定地点移动一段距离(移动增量是固定的) // 入参 指定地点横坐标 纵坐标 void MoveStepTo(int x,int y); // 动画部分 // 功能 播放动画 // 入参 无 void PlayAni(); // 功能 设置动画方式 // 入参 动画方式 void SetAni(int istyle); // 功能 判断是否正在播放动画, 如果正在播放动画,返回1.否则,返回0 // 入参 无 int IsInAni(); // 数据部分 // 玩家状态, 该变量没有使用 int iState; // 图片数据 // 玩家当前帧 int iFrame; // 动作控制数据 // 玩家活动范围: 左边界 右边界(只有横坐标) int minx; int maxx; // 运动速度 int movex; // 正值,向右移动 int movey; // 正值,向下移动 // 跳跃 int jumpheight; // 跳跃高度 int jumpx; // 跳跃时, 横向速度(正值,向右移动) // 玩家运动方向 int idirec; // 动画数据 int iAniBegin; // 动画是否开始播放 int iparam1; // 动画参数 int iAniStyle; // 动画方式};
各个功能的实现：
键盘响应
玩家通过按键，控制人物移动。
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ case WM_KEYDOWN: if(gamemap.KeyProc(wParam)) InvalidateRect(hWnd,NULL,false); break; case WM_KEYUP: gamemap.KeyUpProc(wParam); break;
按键消息包括“按下”和“抬起”两种方式：
int GAMEMAP::KeyProc(int iKey){ switch(iGameState) { case GAME_PRE: // 选择游戏菜单 switch(iKey) { case 0xd: // 按下回车键 switch(iMenu) { case 0: // 菜单项0“开始游戏” c1.ReStart(TIME_GAME_IN_PRE); // 计时两秒 iGameState=GAME_IN_PRE; // 进入游戏LIFE/WORLD提示状态 break; case 1: // 菜单项1“操作说明” SetGameState(GAME_HELP); // 进入游戏状态“操作说明”，显示帮助信息 break; } break; case VK_UP: // 按方向键“上”，切换菜单项 iMenu=(iMenu+1)%2; break; case VK_DOWN: // 按方向键“下”，切换菜单项 iMenu=(iMenu+1)%2; break; } return 1; case GAME_HELP: // 游戏菜单项“操作说明”打开 switch(iKey) { case 0xd: // 按回车键，返回游戏菜单 SetGameState(GAME_PRE); // 设置游戏状态：选择菜单 break; } return 1; case GAME_IN: // 游戏进行中 // 如果人物正在播放动画，拒绝键盘响应 if(rmain.IsInAni()) { break; } // 根据方向键, X, Z, 触发移动,跳跃,攻击等功能 switch(iKey) { case VK_RIGHT: case VK_LEFT: case VK_DOWN: case KEY_X: // 跳 case KEY_Z: // FIRE // 秘籍 case 0x7a: // 按键F11, 直接切换攻击方式 iAttack=(iAttack+1)%ATTACK_MAX_TYPE; break; case 0x7b: // 按键F12 直接通关（游戏进行中才可以，即游戏状态GAME_IN） rmain.xpos = MAX_PAGE*GAMEW*32; break; } break; } return 0;}
可见，按键响应只需要处理三个状态：

菜单选择GAME_PRE操作说明菜单打开GAME_HELP游戏进行中GAME_IN
说明前两个状态属于菜单控制，函数返回1，表示立即刷新屏幕。对于状态GAME_IN，返回0。游戏过程中，屏幕刷新由其它地方控制。
按键“抬起”的处理：
void GAMEMAP::KeyUpProc(int iKey){ switch(iKey) { // 松开方向键“左右”，清除横向移动速度 case VK_RIGHT: rmain.movex=0; break; case VK_LEFT: rmain.movex=0; break; case KEY_X: // 松开跳跃键，无处理 break; case KEY_Z: // 松开攻击键，清除变量iBeginFire，表示停止攻击 iBeginFire=0; break; case KEY_W: // 按W，调整窗口为默认大小 MoveWindow(hWndMain, (wwin-GAMEW*32)/2, (hwin-GAMEH*32)/2, GAMEW*32, GAMEH*32+32, true); break; }
显示问题：
void MYROLE::Draw(){ // 判断是否播放动画，即iAniBegin为1 if(iAniBegin) { // 显示动画帧 PlayAni(); } else { // 显示当前图片 SelectObject(hdcsrc,hBm); BitBlt(hdcdest,xpos,ypos, width,height/2, hdcsrc,iFrame*width,height/2,SRCAND); BitBlt(hdcdest,xpos,ypos, width,height/2, hdcsrc,iFrame*width,0,SRCPAINT); }
二十三、玩家动作控制玩家移动：把行走和跳跃看成两个状态，各自用不同的变量表示横纵方向的速度。
相关属性：

行走：横向速度为movex，纵向不移动跳跃：横向速度为jumpx，纵向速度为movey。当前跳跃高度jumpheight运动方向：idirec
思路：

第一步：玩家按键，按键处理函数设置这些属性。按键松开，清除动作属性。第二步：用一个函数不停检测这些变量，控制玩家移动。
按键触发
int GAMEMAP::KeyProc(int iKey){ switch(iKey) { case VK_RIGHT: // 按右 // 判断是否正在跳跃, 即纵向速度不为0 if(rmain.movey!=0) { // 跳跃过程中, 设置横向速度, 方向向右, 大小为4像素 rmain.jumpx=4; } rmain.movex=4; // 设置横向速度, 方向向右, 大小为4像素 rmain.idirec=0; // 设置玩家方向, 向右 break; case VK_LEFT: // 按左 // 如果是跳跃过程中, 设置横向速度, 方向向左, 大小为4像素 if(rmain.movey!=0) { rmain.jumpx=-4; } rmain.movex=-4; // 设置横向速度, 方向向左, 大小为4像素 rmain.idirec=1; // 设置玩家方向, 向左 break; case KEY_X: // X键跳 // 如果已经是跳跃状态，不作处理，代码中断 if(rmain.movey!=0) break; // 设置纵向速度，方向向上（负值），大小为13 rmain.movey=-SPEED_JUMP; // 将当前的横向速度，赋值给“跳跃”中的横向速度 rmain.jumpx=rmain.movex; break; case KEY_Z: // FIRE if(iBeginFire) break; // 如果已经开始攻击，代码中断 iTimeFire=0; // 初始化子弹间隔时间 iBeginFire=1; // 置1，表示开始攻击 break;
按键松开
void GAMEMAP::KeyUpProc(int iKey){ // 松开左右键，清除横向速度 case VK_RIGHT: rmain.movex=0; break; case VK_LEFT: rmain.movex=0; break; case KEY_X: // 跳// 不能清除跳跃的横向速度jumpx// 例如，移动过程中起跳，整个跳跃过程中都要有横向速度 break; case KEY_Z: // FIRE iBeginFire=0; // 停止攻击 break;
控制移动
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ case WM_TIMER: switch(gamemap.iGameState) { case GAME_IN: rmain.Move();//人物移动 …… break;
每45毫秒产生一个WM_TIMER消息，在GAME_IN状态下，调用各种检测函数。其中rmain.Move()就是不断检测玩家动作属性，实现移动。
void MYROLE::Move(){ if(0 == movey) { // 如果不是跳跃, 横向移动 MoveOffset(movex, 0); } else { // 跳跃, 先横向移动, 再纵向移动 MoveOffset(jumpx, 0); MoveOffset(0, movey); } // 玩家帧控制 ”纠错法” if(movex<0 && iFrame<3) { iFrame=3; // 如果玩家向左移动, 而图片向右, 则设置为3(第4张图片) } if(movex>0 && iFrame>=3) { iFrame=0; // 如果玩家向右移动, 而图片向右, 则设置为0(第1张图片) } // 帧刷新 if(movex!=0) { if(0==idirec) iFrame=1-iFrame; // 如果方向向右, 图片循环播放0,1帧 else iFrame=7-iFrame; // 如果方向向左, 图片循环播放3,4帧 } if(movey!=0) {// 跳跃过程中, 帧设置为0(向右),3(向左)// 帧刷新后, 重新设置帧, 就实现了跳跃过程中, 图片静止 iFrame=idirec*3; } // 跳跃控制 if(movey<0) { // 向上运动(纵向速度movey为负值) jumpheight+=(-movey); // 增加跳跃高度 // 重力影响,速度减慢 if(movey<-1) { movey++; } // 到达顶点后向下落, 最大跳跃高度为JUMP_HEIGHT * 32, 即3个格子的高度 if(jumpheight >= JUMP_HEIGHT * 32) { jumpheight = JUMP_HEIGHT * 32; // 跳跃高度置为最大 movey=4; // 纵向速度置为4, 表示开始下落 } } else if(movey>0) { // 下落过程, 跳跃高度减少 jumpheight -= movey; // 重力影响,速度增大 movey++; }
玩家移动
void MYROLE::MoveOffset(int x,int y){ // 横纵增量为0，不移动，代码结束 if(x==0 && y==0) return; // 如果碰到物体，不移动，代码结束 if(!gamemap.RoleCanMove(x,y)) return; // 修改玩家坐标 xpos+=x; ypos+=y; // 判断是否超出左边界 if(xpos<minx) xpos=minx; // 设置玩家坐标为左边界 // 判断是否超出右边界 if(xpos>maxx) xpos=maxx;
碰撞检测
无论行走，跳跃，都是用函数MoveOffset操纵玩家坐标。这时，就要判断是否碰到物体。如果正在行走，则不能前进；如果是跳跃上升，则开始下落。
int GAMEMAP::RoleCanMove(int xoff, int yoff){ int canmove=1;// 初始化, 1表示能移动 for(i=0;i<iMapObjNum;i++) { if( RECT_HIT_RECT(玩家坐标加增量，地图物品坐标)) { // 碰到物体，不能移动 canmove=0; if(yoff<0) { // 纵向增量为负(即上升运动), 碰到物体开始下落 rmain.movey=1; } if(yoff>0) { // 纵向增量为正(即下落运动), 碰到物体, 停止下落 rmain.jumpheight=0; // 清除跳跃高度 rmain.movey=0; // 清除纵向速度 rmain.ypos=MapArray[i].y*32-32;// 纵坐标刷新，保证玩家站在物品上 } break; } } return canmove;
玩家移动的过程中，要不断检测是否站在地图物品上。如果在行走过程中，且没有站在任何物品上，则开始下落。
int GAMEMAP::CheckRole(){ if(rmain.movey == 0 ) { // 检测角色是否站在某个物体上 for(i=0;i<iMapObjNum;i++) { // 玩家的下边线，是否和物品的上边线重叠 if( LINE_ON_LINE(rmain.xpos, rmain.ypos+32, 32, MapArray[i].x*32, MapArray[i].y*32, MapArray[i].w*32) ) { // 返回1，表示玩家踩在这个物品上 return 1; } } // 角色开始下落 rmain.movey=1; rmain.jumpx=0;// 此时要清除跳跃速度，否则将变成跳跃，而不是落体 return 0;
至此，玩家在这个虚拟世界可以做出各种动作，跳跃，行走，攻击。增强版中，加入了水管，玩家在进出水管，就需要动画。
二十四、角色动画玩家在进出水管的时候，需要进入水管、从水管中升起两个动画。当动画播放结束后，切换到新的地图。动画播放过程中，禁止键盘响应，即玩家不能控制移动。
玩家进水管
地图物品中，水管分两个，进水管（玩家进入地图）和出水管（从别的地图返回）。两种水管对应不同的图片ID：
#define ID_MAP_PUMP_IN 9#define ID_MAP_PUMP_OUT 10
玩家进入水管的检测：
int GAMEMAP::KeyProc(int iKey){ // 检测玩家按“下”，如果玩家站在进水管上，开始播放动画 case VK_DOWN: for(i=0;i<iMapObjNum;i++) { if( LINE_IN_LINE(玩家坐标的下边界，地图物品的上边界)) { // 判断是否站在进水管上 if(MapArray[i].id == ID_MAP_PUMP_IN) { // 如果站在设置角色动画方式，向下移动 rmain.SetAni(ROLE_ANI_DOWN); iGameState=GAME_PUMP_IN; // 设置游戏状态：进水管 c1.ReStart(TIME_GAME_PUMP_WAIT);// 计时2秒 } } } break;
动画设置函数：
void MYROLE::SetAni(int istyle){ iAniStyle=istyle; // 设置动画方式 iparam1=0; // 参数初始化为0 iAniBegin=1; // 表示动画开始播放
iparam1是动画播放中的一个参数，根据动画方式不同，可以有不同的含义。
动画播放
玩家角色显示函数：
void MYROLE::Draw(){ //判断是否播放动画，即iAniBegin为1 if(iAniBegin) { PlayAni(); //播放当前动画 }
动画播放函数：
void MYROLE::PlayAni(){ // 根据不同的动画方式，播放动画 switch(iAniStyle) { case ROLE_ANI_DOWN: // 玩家进入水管的动画，iparam1表示下降的距离 if(iparam1>31) { // 下降距离超过31（即图片高度），玩家完全进入水管，无需图片显示 break; } // 玩家没有完全进入水管，截取图片上半部分，显示到当前的坐标处 SelectObject(hdcsrc,hBm); BitBlt(hdcdest, xpos,ypos+iparam1, width,height/2-iparam1, hdcsrc, iFrame*width,height/2,SRCAND); BitBlt(hdcdest, xpos,ypos+iparam1, width,height/2-iparam1, hdcsrc, iFrame*width,0,SRCPAINT); // 增加下降高度 iparam1++; break;
玩家进入水管后，切换地图
在时间片的处理中，当GAME_PUMP_IN状态结束，切换地图，并设置玩家动画：
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ case GAME_PUMP_IN: if(c1.DecCount()) { gamemap.ChangeMap(); // 切换地图 gamemap.SetGameState(GAME_IN); // 设置游戏状态 c1.ReStart(TIME_GAME_IN); // 计时300秒 rmain.SetAni(ROLE_ANI_UP); // 设置动画，图片上升 } InvalidateRect(hWnd,NULL,false); break;
从水管中上升
根据不同的动画方式，播放动画：
void MYROLE::PlayAni(){ switch(iAniStyle) { case ROLE_ANI_UP: if(iparam1>31) { // 如果上升距离超过31（图片高度），动画结束 break; } // 人物上升动画，截取图片上部，显示到当前坐标 SelectObject(hdcsrc,hBm); BitBlt(hdcdest, xpos,ypos+32-iparam1, width,iparam1, hdcsrc, iFrame*width,height/2,SRCAND); BitBlt(hdcdest, xpos,ypos+32-iparam1, width,iparam1, hdcsrc, iFrame*width,0,SRCPAINT); // 增加上升距离 iparam1++; // 如果上升距离超过31（图片高度） if(iparam1>31) { iAniBegin=0; // 动画结束，清除动画播放状态 }
至此，两个动画方式都实现了。但是，如果在动画播放过程中，玩家按左右键，移动，就会出现，角色一边上升，一边行走，甚至跳跃。怎样解决？如果播放动画，屏蔽键盘响应。
int GAMEMAP::KeyProc(int iKey){ case GAME_IN: // 如果人物正在播放动画，拒绝键盘响应 if(rmain.IsInAni()) { break; }
这样，在播放过程中，不受玩家按键影响。玩家所有功能全部实现，接下来看一下整个游戏逻辑。
二十五、GAMEMAP全局变量类所有游戏数据都需要封装到实际的变量中。整个游戏，就是用类GAMEMAP表示的。
GAMEMAP类定义如下所示：
class GAMEMAP{public: // 加载地图 int LoadMap(); // 初始化所有游戏数据 void Init(); // 初始化场景数据 void InitMatch(); // 显示地图物品 void Show(MYANIOBJ & bmobj); // 显示地图背景物品,河流,树木 void ShowBkObj(MYANIOBJ & bmobj); // 显示所有动态元素,金币,小怪等 void ShowAniObj(MYANIOBJ & bmobj); // 显示LIFE, WORLD提示 void ShowInfo(HDC h); // 显示金钱, 攻击提示信息 void ShowOther(HDC h); // 键盘处理 int KeyProc(int iKey); // 按键抬起处理 void KeyUpProc(int iKey); // 移动视图 void MoveView(); // 设置视图起始坐标 void SetView(int x); // 设置视图状态, 函数没有使用 void SetViewState(int i); // 设置游戏状态 void SetGameState(int i); // 碰撞检测 // 判断人物能否移动 int RoleCanMove(int xoff, int yoff); // 检测人物是否站在物品上 int CheckRole(); // 检测所有动态元素之间的碰撞, 子弹和蘑菇兵的生成 int CheckAni(int itimeclip); // 清除一个小怪 void ClearEnemy(int i); // 清除一个金币 void ClearCoin(int i); // 帧刷新 void ChangeFrame(int itimeclip); // 逻辑检测 int IsWin(); // 胜负检测 void Fail(); // 失败处理 void Fail_Wait(); //失败后, 加载地图 // 地图切换 void ChangeMap(); // 错误检查 void CodeErr(int i); // 菜单控制 void ShowMenu(MYANIOBJ & bmobj); // 构造和析构函数 GAMEMAP(); ~GAMEMAP(); // 数据部分 int iMatch; // 当前关卡 int iLife; // 游戏次数 int iGameState; // 游戏状态 // 地图物品数组 游标 struct MapObject MapArray[MAX_MAP_OBJECT]; int iMapObjNum; // 地图背景物品数组 游标 struct MapObject MapBkArray[MAX_MAP_OBJECT]; int iMapBkObjNum; // 小怪火圈数组 游标 struct ROLE MapEnemyArray[MAX_MAP_OBJECT]; int iMapEnemyCursor; // 金币武器包 数组 游标 struct MapObject MapCoinArray[MAX_MAP_OBJECT]; int iCoinNum; // 下一个地图编号, 变量没有使用 int iNextMap; // 玩家数据 int iMoney; // 金钱数量 int iAttack; // 攻击方式 // 视图数据 int viewx; // 视图横坐标 int viewy; // 视图纵坐标 int iViewState; // 视图状态 // 地图信息 struct MAPINFO mapinfo; // frame control int ienemyframe; // 小怪帧 int ibkobjframe; // 背景物品帧 // 子弹数组 游标 struct ROLE FireArray[MAX_MAP_OBJECT]; int iFireNum; int iTimeFire; // 两个子弹的时间间隔 int iBeginFire; // 是否开始攻击 // 爆炸效果,+10字样 数组 游标 struct MapObject BombArray[MAX_MAP_OBJECT]; int iBombNum; // 攻击对象提示 char AttackName[20]; // 名称 int iAttackLife; // 生命值 int iAttackMaxLife; // 最大生命值 // 菜单部分 int iMenu; // 当前菜单项编号 // 屏幕缩放 int iScreenScale; // 是否是默认窗口大小};
所有的数据都存储到一系列全局变量中：
// 所有菜单文字char *pPreText[]={ "操作: Z:子弹 X:跳 方向键移动 W:默认窗口大小",};// 所有动态元素的图片宽 高int mapani[2][10]={{32,32,64,32,32,52,64,32,64,32},{32,32,64,32,32,25,64,32,64,32},};// 所有地图物品的图片宽 高int mapsolid[2][13]={{32,32,32,32,32,32,32,32,32,64,64,20,100},{32,32,32,32,32,32,32,32,32,64,64,10,12}};// 所有背景物品的图片宽 高int mapanibk[2][4]={{96,96,96,96},{64,64,64,64},};// 旋风的宽 高int mapanimagic[2][1]={{192},{128}};// 所有地图信息struct MAPINFO allmapinfo[]={{1,3,66,7,0,5},{2,4,25,4,1,5},{MAX_MATCH,-1,-1,-1,2,5},{-1,0,3,8,3,1},{-1,1,3,8,3,2}};// 普通蘑菇兵模板struct ROLE gl_enemy_normal={ 0, 0, 32, 32, ID_ANI_ENEMY_NORMAL,};// 跟踪打印// FILEREPORT f1;// 计时器MYCLOCK c1;// 游戏全部逻辑GAMEMAP gamemap;//各种图片MYBITMAP bmPre; // 菜单背景，通关，GAMEOVERMYBKSKY bmSky; // 天空背景MYANIOBJ bmMap; // 地图物品MYANIOBJ bmMapBkObj; // 地图背景物品MYANIOBJ bmAniObj; // 所有动态元素MYROLE rmain; // 玩家角色MYANIMAGIC bmMagic; // 旋风// 字体管理MYFONT myfont; // 字体// DC句柄HDC hwindow,hscreen,hmem,hmem2;// 窗口DC, 地图DC, 临时DC,临时DC2// 空位图HBITMAP hmapnull;// 窗口大小int wwin,hwin; // 显示器屏幕宽 高int wwingame,hwingame; // 当前窗口宽 高HWND hWndMain; // 窗口句柄
二十六、菜单控制 窗口缩放菜单控制：开始菜单只有两项：0项“开始游戏”，1项“操作说明”，菜单编号用iMenu表示。
菜单文字显示：
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ // 在WM_PAINT绘制消息中： case GAME_PRE: gamemap.viewx=0; // 设置视图坐标 bmPre.Stretch(2,2,0); // 菜单背景图片 myfont.SelectFont(0); // 设置文字字体 myfont.SelectColor(TC_BLACK, TC_YELLOW_0);// 设置文字颜色 // 显示3行文字 myfont.ShowText(150,260,pPreText[4]); myfont.ShowText(150,290,pPreText[5]); myfont.ShowText(150,320,pPreText[6]); // 显示箭头 gamemap.ShowMenu(bmAniObj); break;
菜单箭头显示：
void GAMEMAP::ShowMenu(MYANIOBJ & bmobj){ // 根据当前菜单编号，决定箭头的纵坐标 bmobj.PlayItem(115,280+iMenu*30, ID_ANI_MENU_ARROW);
箭头会不停闪烁，怎样刷新帧？就在显示函数PlayItem中，如下
void MYANIOBJ::PlayItem(int x,int y,int id){ // 按照坐标，ID，显示图片 …… // 切换当前帧 iframeplay=(iframeplay+1)%2;}
菜单的按键响应：
int GAMEMAP::KeyProc(int iKey){ switch(iGameState) { case GAME_PRE:// 选择游戏菜单 switch(iKey) { case 0xd:// 按下回车键 switch(iMenu) { case 0: // 菜单项0“开始游戏” c1.ReStart(TIME_GAME_IN_PRE); // 计时两秒 iGameState=GAME_IN_PRE;// 进入游戏LIFE WORLD提示状态 break; case 1: // 菜单项1“操作说明” SetGameState(GAME_HELP); // 进入游戏状态“操作说明”，显示帮助信息 break; } break; case VK_UP: // 按方向键“上”，切换菜单项 iMenu=(iMenu+1)%2; break; case VK_DOWN: // 按方向键“下”，切换菜单项 iMenu=(iMenu+1)%2; break; } return 1; // 表示立即刷新画面
窗口缩放功能的实现
窗口是否为默认大小，用iScreenScale表示。iScreenScale为1，表示窗口被放大，将视图区域缩放到当前的窗口大小。
初始化由构造函数完成，窗口大小检测，用户拉动窗口，触发WM_SIZE消息。
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ case WM_SIZE: // 获取当前窗口宽 高 wwingame=LOWORD(lParam); hwingame=HIWORD(lParam); // 如果窗口小于默认大小，仍然设置为默认数值，图像不缩放 if( wwingame <= GAMEW*32 || hwingame <= GAMEH*32) { wwingame = GAMEW*32; hwingame = GAMEH*32; gamemap.iScreenScale = 0; } else { // 宽度大于高度的4/3 if(wwingame*3 > hwingame*4) { wwingame = hwingame*4/3; // 重新设置宽度 } else { hwingame = wwingame*3/4; // 重新设置高度 } gamemap.iScreenScale =1; // 表示图像需要缩放 } break;
图像缩放，在WM_PAINT消息处理中，绘制完所有图片后，根据iScreenScale缩放视图区域的图像。
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ // 判断是否缩放图像 if(gamemap.iScreenScale) { // 缩放视图区域图像 StretchBlt(hwindow,0,0, wwingame,hwingame, hscreen, gamemap.viewx,0, GAMEW*32,GAMEH*32, SRCCOPY); } else { // 不缩放，视图区域拷贝到窗口 BitBlt(hwindow, 0, 0, GAMEW*32, GAMEH*32, hscreen, gamemap.viewx, 0, SRCCOPY); }
二十七、程序框架WinProc怎样把所有的功能组织起来，形成一个完整的游戏呢？游戏状态。不同的游戏状态下，对应不同的图片显示、逻辑处理、按键响应。这样就形成了一个结构清晰的框架。各个模块相对独立，也方便扩展。
由于是消息处理机制，所有功能对应到消息处理函数WndProc，程序框架如下：
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ 绘图消息WM_PAINT: 状态1：状态1绘图。 状态2：状态2绘图。 …… 计时消息WM_TIMER: 状态1：状态1逻辑处理。发WM_PAINT消息，通知绘图。 状态2：状态2逻辑处理。发WM_PAINT消息，通知绘图。 …… 按键消息WM_KEYDOWN WM_KEYUP: 状态1：状态1逻辑处理。发WM_PAINT消息，通知绘图。 状态2：状态2逻辑处理。发WM_PAINT消息，通知绘图。 ……}
程序入口：
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){ MyRegisterClass(hInstance); // 类注册 // 初始化 if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } // 消息循环 while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } return msg.wParam;}
整个消息处理循环，是默认的结构。InitInstance函数复杂初始化。类注册函数MyRegisterClass中，把菜单栏取消了，即wcex.lpszMenuName=NULL，其它不变。
消息处理函数：
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM){ switch (message) { case WM_PAINT: // 窗口DC hwindow = BeginPaint(hWnd, &ps); // 初始化空图 SelectObject(hscreen,hmapnull); switch(gamemap.iGameState) { case GAME_ERR: // 地图文件加载错误 gamemap.viewx=0; // 视图坐标 // 显示错误信息 bmPre.Stretch(2,2,0); // 背景图片 myfont.SelectColor(TC_WHITE,TC_BLACK);// 文字颜色 myfont.SelectFont(0); // 字体 myfont.ShowText(150,290,pPreText[3]); // 显示文字 break; case GAME_PRE: // 菜单显示 (代码略) break; case GAME_HELP: // 菜单项“操作说明” （代码略） break; case GAME_IN_PRE: // 游戏LIFE,WORLD提示 gamemap.viewx=0; // 视图坐标 bmPre.Stretch(2,2,2); // 背景图片 gamemap.ShowInfo(hscreen); // 显示LIFE,WORLD break; case GAME_IN: // 游戏进行中 case GAME_WIN: // 游戏进行中,过关 case GAME_FAIL_WAIT: // 游戏进行中,失败 case GAME_PUMP_IN: // 游戏进行中,进入水管 bmSky.DrawRollStretch(2,2,gamemap.mapinfo.iBackBmp);// 背景图片 gamemap.ShowBkObj(bmMapBkObj); // 地图背景物品 gamemap.Show(bmMap); // 地图物品 gamemap.ShowAniObj(bmAniObj); // 动态元素 gamemap.ShowOther(hscreen); // 金钱数量,攻击提示 rmain.Draw(); // 玩家角色 break; case GAME_OVER: // 游戏结束 gamemap.viewx=0; bmPre.Stretch(2,2,1); // 输出图片GAME OVER break; case GAME_PASS: // 游戏通关 gamemap.viewx=0; bmPre.Stretch(2,2,3); // 输出图片通关 break; } if(gamemap.iScreenScale) { // 窗口缩放，放大视图区域 StretchBlt(hwindow,0,0,wwingame,hwingame,hscreen, gamemap.viewx,0,GAMEW*32,GAMEH*32,SRCCOPY); } else { // 拷贝视图区域 BitBlt(hwindow,0,0,GAMEW*32,GAMEH*32,hscreen, gamemap.viewx, 0, SRCCOPY); } EndPaint(hWnd, &ps); // 绘图结束 break; case WM_TIMER: switch(gamemap.iGameState) { case GAME_PRE: // 游戏菜单 c1.DecCount();// 计时器减1 if(0 == c1.iNum%MENU_ARROW_TIME) { // 每隔10个时间片（即箭头闪烁的时间），刷新屏幕 InvalidateRect(hWnd,NULL,false); } break; case GAME_IN_PRE: // 游戏LIFE,WORLD提示 if(c1.DecCount()) { // 计时结束，进入游戏。 gamemap.SetGameState(GAME_IN); c1.ReStart(TIME_GAME_IN); // 启动计时300秒 } InvalidateRect(hWnd,NULL,false); // 刷新屏幕 break; case GAME_IN: // 游戏进行中 case GAME_WIN: // 游戏进行中，过关 c1.DecCount();// 计时器计时 if(0 == c1.iNum%SKY_TIME) { bmSky.MoveRoll(SKY_SPEED);// 云彩移动 } gamemap.ChangeFrame(c1.iNum);// 帧控制 rmain.Move();// 人物移动 gamemap.MoveView();// 视图移动 gamemap.CheckRole();// 角色检测 gamemap.CheckAni(c1.iNum);// 逻辑数据检测 gamemap.IsWin(); // 胜负检测 InvalidateRect(hWnd,NULL,false); // 刷新屏幕 break; case GAME_WIN_WAIT: // 游戏进行中，过关,停顿2秒 if(c1.DecCount()) { // 计时结束，进入游戏LIFE,WORLD提示 gamemap.SetGameState(GAME_IN_PRE); InvalidateRect(hWnd,NULL,false); // 刷新屏幕 } break; case GAME_PUMP_IN: // 游戏进行中，进入水管，停顿2秒 if(c1.DecCount()) { // 计时结束，切换地图 gamemap.ChangeMap(); gamemap.SetGameState(GAME_IN); // 进入游戏 c1.ReStart(TIME_GAME_IN); // 启动计时300秒 rmain.SetAni(ROLE_ANI_UP); // 设置玩家出水管动画 } InvalidateRect(hWnd,NULL,false); // 刷新屏幕 break; case GAME_FAIL_WAIT: // 游戏进行中，失败，停顿2秒 if(c1.DecCount()) { // 计时结束，加载地图 gamemap.Fail_Wait(); } break; case GAME_PASS: //全部通关，停顿2秒 if(c1.DecCount()) { // 计时结束，设置游戏状态：游戏菜单 gamemap.SetGameState(GAME_PRE); } InvalidateRect(hWnd,NULL,false); // 刷新屏幕 break; case GAME_OVER: // 游戏结束，停顿3秒 if(c1.DecCount()) { // 计时结束，设置游戏状态：游戏菜单 gamemap.SetGameState(GAME_PRE); } InvalidateRect(hWnd,NULL,false); // 刷新屏幕 break; } break; case WM_KEYDOWN: // 按键处理 if(gamemap.KeyProc(wParam)) InvalidateRect(hWnd,NULL,false); break; case WM_KEYUP: // 按键“抬起”处理 gamemap.KeyUpProc(wParam); break; case WM_SIZE: // 窗口大小调整，代码略 break; case WM_DESTROY: // 窗口销毁，释放DC, 代码略 break;
终于，所有模块全部完成，游戏制作完成。整个工程差不多3000行代码。第一个制作超级玛丽的程序员，是否用了这么多代码，肯定没有。当时，应该是汇编。3000行C++代码，还达不到汇编程序下的地图规模、图片特效、游戏流畅度。可见，程序的乐趣无穷。
二十八、InitInstance函数说明BOOL InitInstance(HINSTANCE, int){ // 默认窗口大小 wwingame=GAMEW*32; hwingame=GAMEH*32; // 显示器屏幕大小 wwin=GetSystemMetrics(SM_CXSCREEN); hwin=GetSystemMetrics(SM_CYSCREEN); // 创建窗口 hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, (wwin-wwingame)/2, (hwin-hwingame)/2, wwingame, hwingame+32, NULL, NULL, hInstance, NULL); // 设置窗口句柄 hWndMain=hWnd; //DC hwindow=GetDC(hWnd); // 窗口DC hscreen=CreateCompatibleDC(hwindow); // 地图绘制DC hmem=CreateCompatibleDC(hwindow); // 临时DC hmem2=CreateCompatibleDC(hwindow); // 临时DC // 用空位图初始化各个DC hmapnull=CreateCompatibleBitmap(hwindow,GAMEW*32*5,GAMEH*32); SelectObject(hscreen,hmapnull); SelectObject(hmem,hmapnull); SelectObject(hmem2,hmapnull); // 释放窗口DC ReleaseDC(hWnd, hwindow); // 位图初始化 // 菜单背景图片，通关，GAMEOVER bmPre.Init(hInstance,IDB_BITMAP_PRE1,1,5); bmPre.SetDevice(hscreen,hmem,GAMEW*32,GAMEH*32); bmPre.SetPos(BM_USER,0,0); // 天空背景图片 bmSky.Init(hInstance,IDB_BITMAP_MAP_SKY,1,4); bmSky.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32); bmSky.SetPos(BM_USER,0,0); // 地图物品图片 bmMap.Init(hInstance,IDB_BITMAP_MAP,1,1); bmMap.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32); bmMap.InitAniList(mapsolid[0],mapsolid[1], sizeof(mapsolid[0])/sizeof(int),0); // (其它位图代码略) // 玩家图片初始化 rmain.Init(hInstance,IDB_BITMAP_ROLE,5,1); rmain.SetDevice(hscreen,hmem,GAMEW*32*MAX_PAGE,GAMEH*32); // 字体初始化 myfont.SetDevice(hscreen); // 游戏数据初始化 gamemap.Init(); // 玩家角色初始化坐标，数据初始化 rmain.SetPos(BM_USER,3*32,8*32); rmain.InitRole(0,GAMEW*32*MAX_PAGE-32); // 文件检查 if(!gamemap.LoadMap()) { // 文件加载失败，设置游戏状态：文件错误 gamemap.CodeErr(ERR_MAP_FILE); } // 计时器初始化 c1.SetDevice(hscreen); // 计时器启动，每40毫秒一次WM_TIMER消息 c1.Begin(hWnd, GAME_TIME_CLIP ,-1); // 设置显示方式，显示窗口 ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd);}