PyOpenGL网络游戏应用

  这个游戏很简单，可以操纵的飞机不断发子弹，前面不断有敌机来袭，子弹打中敌机然后敌机和子弹消失，最后实现了网络互联功能，允许两个人在局域网中不同机器上操作各自的飞机，平且两个游戏界面是同步的。

我这样设计的：自己维护一个飞机，子弹队列，敌机队列，将网络来的数据打包成另一个飞机，子弹队列，敌机队列，所以这里面传送的数据有自己飞机数据，子弹队列，敌机队列，这些数据通过TCP在服务器和客户端之间不断更新，传递。

     图形用opengl渲染，由于python不能直接访问指针，通过网络只能传递字符串型，所以传送二进制数据有点问题，自己写了对函数，用于字符串和二进制数的转换，每个数由长度为4的字符串组成，索引高的为数据高位，最高位为符号位，所以只能保存-1600万到1600万之间的数，对于视频游戏这个范围足矣，但有个缺陷，不知道怎么传浮点数，所以需要浮点数的地方先*1000，传送后除以1000得到浮点数。

     为了更像网络游戏，跟CS一样能自动搜索局域网中的服务器，实现了一个较简单实用的方法，大致是这样的：服务器启动后开放一个udp端口udpport，客户端向局域网中所有机器udpport发送验证信息，建立一个临时TCP端口tcpport0，当服务器端客户验证通过后向刚才的客户机tcpport0发送欢迎信息，这样客户机就得到了服务器的ip地址（还可同时进行一些必要的初始化），到此客户端便开始正式通过tcp与服务器交换游戏信息。

 

pyOpengl安装方法：http://pyopengl.sourceforge.net/documentation/installation.html

 

游戏代码：

 

 #-*- coding:utf-8 -*-

 import sys,struct
 import random,math,thread,time,socket,string,re
 try:
   from OpenGL.GLUT import *
   from OpenGL.GL import *
   from OpenGL.GLU import *
 except:
   print '''''
 ERROR: PyOpenGL not installed properly.
         '''
   sys.exit()
 x_coord=10
 y_coord=10
 isAserver=False     #True为服务端，False为客户端

 #数值统统为4个字节，最高位为符号位，1600万足矣,低字节为低位
 def westicenumtostring(num):
     tempnum=abs(num)
     tempnum=int(tempnum)
     s=''
     i=0
     while tempnum>0:
        s=s+chr(tempnum%256)
        tempnum=int(tempnum/256)
        i+=1
     while len(s)<3:#补齐3位
        s=s+chr(0)
     if num<0:
         s=s+chr(1)
     else:#0和正数最高位为0
         s=s+chr(0)
     return s

 def westicestringtonum(s):
     if len(s)!=4:
         print 'len(s) must be 4'
         return None
     n0=ord(s[0])
     n1=ord(s[1])
     n2=ord(s[2])
     n3=ord(s[3])
     num=n0+256*n1+256*256*n2
     if n3==1:#负数
         num=(-num)
     if n3!=0 and n3!=1:
         return "wrong string when convert ro number"
     return num

 def drawenemy(x,y): #画敌人形象
     glLoadIdentity()
     glTranslate(x,y,0.0)
     glScale(0.2,0.2,0.2)
     glBegin(GL_POLYGON)
     glVertex3f(1.0,1.0,0)
     glVertex3f(1.0,-1.0,0)
     glColor3f(1.0,0.0,0.0)
     glVertex3f(-1.0,-1.0,0)
     glVertex3f(-1.0,1.0,0)
     glEnd()

 def drawbullet(x,y):#画子弹形象
    glLoadIdentity()
    glTranslate(x,y,0.0)
    glScale(0.1,0.1,0.1)
    glBegin(GL_POLYGON)
    glColor3f(0.0,1.0,0.0)
    glVertex3f(0.5,1.0,0)
    glVertex3f(0.5,-1.0,0)
    glVertex3f(-0.5,-1.0,0)
    glVertex3f(-0.5,1.0,0)
    glEnd()

 def drawpalne(x,y,rquad):#画玩家飞机形象
     glLoadIdentity()
     glTranslate(x,y,0.0)
     glRotatef(rquad,0.0,1.0,0.0)        # Rotate
     glScale(0.5,0.5,0.5)
     glBegin(GL_POLYGON)                   # Start drawing
     glColor3f(1.0,0.0,0.0)
     glVertex3f(1.0,0.0,0.0)
     glColor3f(0.0,1.0,0.0)
     glVertex3f(-1.0,0.0,0.0)
     glColor3f(0.0,0.0,1.0)
     glVertex3f(0.0,3.0,0.0)
     glEnd()                             # We are done with the polygon

     glBegin(GL_POLYGON)
     glVertex3f(0.0,0.0,0)
     glVertex3f(0.0,3.0,0)
     glColor3f(1.0,0.0,0.0)
     glVertex3f(0.0,0.5,0.5)
     glEnd()

 class Enemy(): #定义敌人
     def __init__(self):
         self.reset()
     def update(self):
         if self.live:
            self.y-=0.01
            self.draw()
            if self.y<0:
                self.live=False
     def setxy(self,x,y):
         self.x=x
         self.y=y
     def draw(self):
         drawenemy(self.x,self.y)
     def reset(self):
         self.x=x_coord*random.random()
         self.y=y_coord
         self.live=True #活着状态

 class Bullet():#定义子弹
     def __init__(self,x,y):
         self.reset(x,y)
         self.live=False
     def update(self):
         if self.live:
            self.y+=0.05
            self.draw()
            if self.y>y_coord:
                self.live=False
     def draw(self):
         drawbullet(self.x,self.y)
     def reset(self,x,y):
         self.x=x
         self.y=y
         self.live=True

 class Plane():
     def __init__(self,x,y):
         self.x=x
         self.y=y
         self.rquad=0
     def update(self):
         self.draw()
         if self.rquad<0:
            self.rquad+=1.0
         if self.rquad>0:
            self.rquad-=1.0
     def draw(self):
         drawpalne(self.x,self.y,self.rquad)
     def left(self):
         self.x-=0.1
         if self.rquad>-40:#限制
            self.rquad-=3
     def right(self):
         self.x+=0.1
         if self.rquad<40:
            self.rquad+=3

 westiceplane=None
 myenemylist=None
 bulletlist=None
 otherplane=None
 otherenemylist=None
 otherbulletlist=None
 frameobj=None
 #网络用帧
 class netframe():
     def __init__(self,player,mybulletlist,enemylist):
         self.player=player
         self.mybulletlist=mybulletlist
         self.enemylist=enemylist
     def senddata(self,conn):
         global isconnected
         senddata=''
         senddata+=westicenumtostring(self.player.x*1000)
         senddata+=westicenumtostring(self.player.y*1000)
         senddata+=westicenumtostring(self.player.rquad*1000)#自己的位置
         senddata+=westicenumtostring(len(self.mybulletlist))#子弹个数
         for bullet in self.mybulletlist:
             senddata+=westicenumtostring(bullet.x*1000)
             senddata+=westicenumtostring(bullet.y*1000)#子弹位置
         senddata+=westicenumtostring(len(self.enemylist))#敌人个数
         for enemy in self.enemylist:
             senddata+=westicenumtostring(enemy.x*1000)
             senddata+=westicenumtostring(enemy.y*1000)#敌人位置
         if isconnected:
            try:
               conn.send(senddata)
            except socket.error:
               isconnected=False
         #conn.sendall(senddata)
     #接收数据
     def recvdata(self,conn):
         global otherplane
         global otherenemylist
         global otherbulletlist
         global isconnected
         if isconnected:
             try:
                  recvdata=conn.recv(4)
                  otherplanex=westicestringtonum(recvdata)/1000.0
                  recvdata=conn.recv(4)
                  otherplaney=westicestringtonum(recvdata)/1000.0
                  otherplane=Plane(otherplanex,otherplaney)
                  recvdata=conn.recv(4)
                  otherplane.rquad=westicestringtonum(recvdata)/1000.0
                  recvdata=conn.recv(4)#接收子弹数据
                  bulletnum=westicestringtonum(recvdata)
                  otherbulletlist=[]
                  for i in range(bulletnum):
                      recvdata=conn.recv(4)
                      bulletx=westicestringtonum(recvdata)/1000.0
                      recvdata=conn.recv(4)
                      bullety=westicestringtonum(recvdata)/1000.0
                      bullet=Bullet(bulletx,bullety)
                      bullet.live=True
                      otherbulletlist.append(bullet)

                  recvdata=conn.recv(4)
                  enemynum=westicestringtonum(recvdata)
                  otherenemylist=[]
                  for i in range(enemynum):
                      recvdata=conn.recv(4)
                      enemyx=westicestringtonum(recvdata)/1000.0
                      recvdata=conn.recv(4)
                      enemyy=westicestringtonum(recvdata)/1000.0
                      enemy=Enemy()
                      enemy.setxy(enemyx,enemyy)
                      otherenemylist.append(enemy)
             except socket.error:
                 isconnected=False

 #游戏服务器
 port=8088  #主数据通道
 conn=None#socket连接对象，可能是服务器或客户端
 serverUDPport=9090
 clientTCPport=9091
 isconnected=False
 class GameServer():
     def __init__(self):
         print '初始化游戏服务器'
         global conn
         global otherplane
         global otherenemylist
         global otherbulletlist
         global frameobj
         global isconnected
         global serverUDPport
         global clientTCPport

         #服务器接收客户UDP报文，如果验证通过向客户发送TCP回应
         UDPsock0=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
         UDPsock0.bind(("",serverUDPport))
         #还需验证客户端,用udp
         recvstring,clientaddr=UDPsock0.recvfrom(1024)
         if recvstring=="west":
             print "服务器收到验证from ",clientaddr[0]
         UDPsock0.close()

         #服务器发送tcp回应
         tempconn=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
         tempconn.connect((clientaddr[0],clientTCPport))
         tempconn.send("sure")
         tempconn.close()

         #创建TCP服务器
         TCPsock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
         TCPsock.bind(('',port))
         TCPsock.listen(5)
         conn,clientaddr=TCPsock.accept()
         print "来自客户端：",clientaddr
         isconnected=True
         while isconnected: #服务端循环，先发后收
             frameobj.senddata(conn)
             time.sleep(0.02)
             frameobj.recvdata(conn)
         conn.close()

 #游戏客户端
 class GameClient():
     def __init__(self):
         print '初始化游戏客户端'
         global conn
         global frameobj
         global isconnected
         global serverUDPport
         global clientTCPport
         self.lanserverip=None
         #搜索服务器，向局域网内发送udp数据
         ip=socket.gethostbyname(socket.gethostname())
         match_str="\d+\.\d+\.\d+\."
         ipheader=re.match(match_str,ip)
         ipheader=ipheader.group()
         UDPsock0=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
         for i in range(1,256):
             self.lanserverip=ipheader+str(i)
             UDPsock0.sendto("west",(self.lanserverip,serverUDPport))
         UDPsock0.close()

         #客户端建立tcp服务器  接收服务器ip和其它信息，之后断开，连接服务器的tcp
         TCPsock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
         TCPsock.bind(('',clientTCPport))
         TCPsock.listen(5)
         tempconn,serveraddr=TCPsock.accept()
         hellomsg=tempconn.recv(4)
         tempconn.close()
         self.lanserverip=serveraddr[0]
         print "服务器为：",self.lanserverip
         print "服务器信息：",hellomsg

         #连接tcp服务器发送数据
         conn=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
         conn.connect((self.lanserverip,port))
         isconnected=True
         while isconnected:#客户端循环，先收后发
             frameobj.recvdata(conn)
             frameobj.senddata(conn)
             time.sleep(0.02)
         conn.close()

 def threadfunc():#线程函数
     global isAserver
     if isAserver:
         gameserver=GameServer()
     else:
         gameclient=GameClient()

 def GameInit():
     global x_coord
     global y_coord
     global westiceplane
     global myenemylist
     global mybulletlist
     global frameobj
     westiceplane=Plane(x_coord/2,1)#加入飞机
     myenemylist=[]
     for i in range(4):  #加入敌人
         westiceenemy=Enemy()
         myenemylist.append(westiceenemy)
     mybulletlist=[]
     for i in range(20):
         mywesticebullet=Bullet(westiceplane.x,westiceplane.y)
         mybulletlist.append(mywesticebullet)
     #新建一个线程处理网络
     thread.start_new_thread(threadfunc,())
     frameobj=netframe(westiceplane,mybulletlist,myenemylist)

 def init():
     glClearColor(0.5,0.5,0.5,0.0)
     glClearDepth(1.0)                    # Enables Clearing Of The Depth Buffer
     glDepthFunc(GL_LESS)                # The Type Of Depth Test To Do
     glEnable(GL_DEPTH_TEST)                # Enables Depth Testing
     glShadeModel(GL_SMOOTH)                # Enables Smooth Color Shading

 def calcdistance(object0,object1):
     return math.sqrt(pow(object0.x-object1.x,2)+pow(object0.y-object1.y,2))

 count=0
 def display():
     #print 'display'
     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
     westiceplane.update()
     for enemy in myenemylist:
         enemy.update()
         if not enemy.live:
             enemy.reset()
         for bullet in mybulletlist:
             if calcdistance(bullet,enemy)<=0.2:#是否相遇
                 bullet.live=False
                 enemy.live=False
     #自动发射子弹
     global count
     if count>=15:
         count=0
         for bullet in mybulletlist:
             if not bullet.live:
                 bullet.reset(westiceplane.x,westiceplane.y+1)#激活一颗
                 break

     for bullet in mybulletlist:
         bullet.update()
     count+=1
     #显示网络来的数据
     global otherplane
     global otherenemylist
     global otherbulletlist
     if isconnected and otherplane:
        otherplane.draw()
     if isconnected and otherbulletlist and otherenemylist and otherplane:
         otherplane.draw()
         for myenemy in myenemylist:
             for otherbullet in otherbulletlist:
                 if calcdistance(otherbullet,myenemy)<=0.2:#是否相遇
                    otherbullet.live=False
                    myenemy.live=False
         for otherenemy in otherenemylist:
             if otherenemy.live:
                otherenemy.draw()
         for otherbullet in otherbulletlist:
             if otherbullet.live:
                otherbullet.draw()

     glutSwapBuffers()
     #glFlush()

 def reshape(w,h):
    print 'reshape'
    glViewport(0,0,w,h)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    print 'w:',w,' h:',h
    if w!=0 and h!=0:
        global x_coord
        global y_coord
        if(w<=h):
           gluOrtho2D(0.0,x_coord,0.0,x_coord*h/w)
        else:
           gluOrtho2D(0.0,x_coord*w/h,0.0,x_coord)
    glMatrixMode(GL_MODELVIEW)

 def keyboard(key,x,y):
 #   if key==chr(27):
 #      sys.exit(0)
     if key=='a'or key=='A':
        westiceplane.left()
     if key=='d'or key=='D':
        westiceplane.right()


 GameInit()
 glutInit(sys.argv)
 glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH) #使用双缓冲和深度测试
 glutInitWindowSize(600,500)
 glutInitWindowPosition(100,100)
 if isAserver:
     glutCreateWindow('Game Server')
 else:
     glutCreateWindow('Game Client')
 init()
 glutReshapeFunc(reshape)
 glutKeyboardFunc(keyboard)
 glutDisplayFunc(display)
 glutIdleFunc(display)

 glutMainLoop()

 

 From:http://westice.iteye.com/blog/979045