fork download 
  1. from threading import Thread # потоки
  2. import msvcrt # библиотека неприрывно считывающая нажатие клавиш в консоли
  3. #a = msvcrt.getch() # получает клавишу формат: b'a' - a
  4. #str(a)[2]
  5. import random
  6. import os
  7. import math
  8. import time
  9. import copy
  10.  
  11. # PixelDisplay(width,height) поле для рисования
  12. # Clear() очистить
  13. # ShowDisplay() обновить
  14. # SetPixel(x,y) нарисовать пиксель
  15. # ClearPixel(x,y) удалить пиксель
  16. # DrawLine(x1,y1,x2,y2) нарисовать линию
  17. # DrawCircul(x,y,r) нарисовать окружность
  18. # DrawPoligon(x1,y1,z1,x2,y2,z2,x3,y3,z3) нарисовать трехмерный полигон
  19.  
  20. class PixelDisplay:
  21.     h = 10 # 3d projection value
  22.     def __init__(self,width,height):
  23.         self.width = width
  24.         self.height = height
  25.         self.PixelArray = self.CreateDisplay()
  26.         self.cls = copy.deepcopy(self.PixelArray)
  27.     def CreateDisplay(self):
  28.         Y = []
  29.         X = []
  30.         for i in range(self.height):
  31.             for j in range(self.width):
  32.                 X.append(" ")
  33.             Y.append(X)
  34.             X = []
  35.         return Y
  36.     def Clear(self):
  37.         self.PixelArray = []
  38.         self.PixelArray = copy.deepcopy(self.cls)
  39.         time.sleep(0.004)
  40.         os.system("cls")
  41.         time.sleep(0.004)
  42.     def ShowDisplay(self):
  43.         st = ""
  44.         for i in range(self.height):
  45.             for j in range(self.width):
  46.                 st += self.PixelArray[i][j]
  47.             print(st)
  48.             st = ""
  49.     def SetPixel(self,x,y,pix="*"):
  50.         if (y < self.height and x <self.width and y >= 0 and x>= 0):
  51.             self.PixelArray[y][x] = pix
  52.     def ClearPixel (self,x,y):
  53.         if (y < self.height and x <self.width and y >= 0 and x>= 0):
  54.             self.PixelArray[y][x] = " "
  55.     def DrawLine(self,x1,y1,x2,y2,pix="*"):
  56.         if (abs(x2-x1)>=abs(y2-y1)):
  57.             if (x2 != x1):
  58.                 tan = (y2-y1)/(x2-x1)
  59.             if (x2>x1):
  60.                 for x in range(x1,x2):
  61.                     y = tan*(x-x1)+y1
  62.                     self.SetPixel(x,int(y),pix)
  63.             elif (x1>x2):
  64.                 for x in range(x2,x1):
  65.                     y = tan*(x-x1)+y1
  66.                     self.SetPixel(x,int(y),pix)
  67.             elif (x1 == x2):
  68.                 if (y2 > y1):
  69.                     for y in range(y1,y2):
  70.                         self.SetPixel(x1,y,pix)
  71.                 elif (y1 > y2):
  72.                     for y in range(y2,y1):
  73.                         self.SetPixel(x1,y,pix)
  74.                 else:
  75.                     self.SetPixel(x1,y1,pix)
  76.         if (abs(x2-x1)< abs(y2-y1)):
  77.             if (y2 != y1):
  78.                 tan = (x2-x1)/(y2-y1)
  79.             if (y2>y1):
  80.                 for y in range(y1,y2):
  81.                     x = tan*(y-y1)+x1
  82.                     self.SetPixel(int(x),y,pix)
  83.             elif (y1>y2):
  84.                 for y in range(y2,y1):
  85.                     x = tan*(y-y1)+x1
  86.                     self.SetPixel(int(x),y,pix)
  87.             elif (y1 == y2):
  88.                 if (x2 > x1):
  89.                     for x in range(x1,x2):
  90.                         self.SetPixel(x,y1,pix)
  91.                 elif (x1 > x2):
  92.                     for x in range(x2,x1):
  93.                         self.SetPixel(x,y1,pix)
  94.                 else:
  95.                     self.SetPixel(x1,y1,pix)
  96.     def DrawCircul(self,x,y,r,pix="*"):
  97.         for i in range(360):
  98.             _x = int(x + r*math.cos(i*3.1415926/180))
  99.             _y = int(y + r*math.sin(i*3.1415926/180))
  100.             self.SetPixel(_x,_y,pix)
  101.     def Pixel3d(self,x,y,z):
  102.         if (z > 0):
  103.             _x = int((x/z)*self.h)
  104.             _y = int((y/z)*self.h)
  105.             return [_x, _y]
  106.         else:
  107.             print("error")
  108.     def DrawPoligon(self,x1,y1,z1,x2,y2,z2,x3,y3,z3,pix="*"):
  109.         v1 = [x2-x1,y2-y1,z2-z1]
  110.         v2 = [x3-x2,y3-y2,z3-z2]
  111.         n = [v1[1]*v2[2]-v1[2]*v2[1],v1[2]*v2[0]-v1[0]*v2[2],v1[0]*v2[1]-v1[1]*v2[0]]
  112.         if (n[2]*1< 0):
  113.             P1 = self.Pixel3d(x1,y1,z1)
  114.             P2 = self.Pixel3d(x2,y2,z2)
  115.             P3 = self.Pixel3d(x3,y3,z3)
  116.             x1,y1 = P1[0],P1[1]
  117.             x2,y2 = P2[0],P2[1]
  118.             x3,y3 = P3[0],P3[1]
  119.             self.DrawLine(x1,y1,x2,y2,pix)
  120.             self.DrawLine(x2,y2,x3,y3,pix)
  121.             self.DrawLine(x3,y3,x1,y1,pix)
  122.  
  123. class Sprite:
  124.     # format
  125.     # A = [
  126.     #[[" ","*"," "],[" ","*"," "],[" ","*"," "]],
  127.     #[[" ","*"," "],["*","*","*"],[" ","*"," "]]
  128.     #]
  129.     def __init__(self,A,x,y,display):
  130.         self.x = x
  131.         self.y = y
  132.         self.display = display
  133.         self.img = A
  134.         self.width = len(self.img[0][0])
  135.         self.height = len(self.img[0])
  136.         self.shoot = len(self.img)
  137.         self.currentShoot = 0
  138.         self.collisionShoot = self.currentShoot
  139.     # отобразить спрайт и переключить на новый кадр
  140.     def Draw(self):
  141.         # i - y
  142.         # j - x
  143.         for i in range(len(self.img[self.currentShoot])):
  144.             for j in range(len(self.img[self.currentShoot][0])):
  145.                 self.display.SetPixel(self.x+j,self.y+i,self.img[self.currentShoot][i][j])
  146.         self.collisionShoot = self.currentShoot
  147.         self.currentShoot += 1
  148.         if (self.currentShoot >= len(self.img)):
  149.             self.currentShoot = 0
  150.     # отобразить конкретный кадр (OK)
  151.     def DrawShoot(self,Shoot):
  152.         # i - y
  153.         # j - x
  154.         for i in range(len(self.img[Shoot])):
  155.             for j in range(len(self.img[Shoot][0])):
  156.                 self.display.SetPixel(self.x+j,self.y+i,self.img[Shoot][i][j])
  157.         self.collisionShoot = Shoot
  158.         self.currentShoot = Shoot
  159.         self.width = len(self.img[Shoot][0])
  160.         self.height = len(self.img[Shoot])
  161.     # проверка попадания
  162.     def CheckCollision(self,x,y):
  163.         x = x - self.x
  164.         y = y - self.y
  165.         if (abs(x) < self.width and abs(y) < self.height):
  166.             if (self.img[self.collisionShoot][y][x] != " "):
  167.                 return True
  168.             else:
  169.                 return False
  170.         else:
  171.             return False 
  172.     # обновить координаты
  173.     def updateXY(self,x,y):
  174.         self.x = x
  175.         self.y = y
  176.  
  177. class Player:
  178.     def __init__(self,playerSprite,x,y,display):
  179.         self.x = x
  180.         self.y = y
  181.         self.sprite = Sprite(playerSprite,x,y,display)
  182.     def move_x(self,value):
  183.         if (value==-1):
  184.             self.x-=1
  185.         if (value==1):
  186.             self.x+=1
  187.         self.sprite.updateXY(self.x,self.y)
  188.     def move_y(self,value):
  189.         if (value==-1):
  190.             self.y-=1
  191.         if (value==1):
  192.             self.y+=1
  193.         self.sprite.updateXY(self.x,self.y)
  194.  
  195. class bullet:
  196.     def __init__(self,bulletSprite,x,y,display,vx,vy,dist):
  197.         self.x0 = x
  198.         self.y0 = y
  199.         self.x = x
  200.         self.y = y
  201.         self.vx = vx
  202.         self.vy = vy
  203.         self.dist = dist
  204.         self.sprite = Sprite(bulletSprite,x,y,display)
  205.     def move(self):
  206.         self.x = self.x + self.vx
  207.         self.y = self.y + self.vy
  208.         self.sprite.updateXY(self.x,self.y)
  209.     def check(self):
  210.         vector = pow(pow(self.x-self.x0,2)+pow(self.y-self.y0,2),0.5)
  211.         if (vector < self.dist):
  212.             return True
  213.         else:
  214.             return False
  215.  
  216. class Game:
  217.     def __init__(self):
  218.         self.A = [[[" ","*"," "],["*","*","*"],[" ","*"," "],["*"," ","*"]],
  219.              [["*"," ","*"," "],[" ","*","*","*"],["*"," ","*"," "]],
  220.              [["*"," ","*"],[" ","*"," "],["*","*","*"],[" ","*"," "]],
  221.              [[" ","*"," ","*"],["*","*","*"," "],[" ","*"," ","*"]]]
  222.         self.plShootNum = 0
  223.         self.pl2ShootNum = 0
  224.         self.bullets = []
  225.         self.bulletsLen = 0
  226.         self.bulletsIndexes = []
  227.         self.key = "b'm'"
  228.         self.GameScreen = PixelDisplay(100,70)
  229.         self.player = Player(self.A,10,25,self.GameScreen)
  230.         self.player2 = Player(self.A,25,25,self.GameScreen)
  231.         self.player2Action = True
  232.         self.playerScore = 0
  233.         self.player2Score = 0
  234.     # рендер игры
  235.     def gameLoop(self):
  236.         while (True):
  237.             # действия игрока2
  238.             vect = [(self.player2.x),(self.player2.y)]
  239.             vect1 = [-15+self.player.x,0+self.player.y]
  240.             vect2 = [15+self.player.x,0+self.player.y]
  241.             vect3 = [0+self.player.x,15+self.player.y]
  242.             vect4 = [0+self.player.x,-15+self.player.y]
  243.             v = [vect1,vect2,vect3,vect4]
  244.             dist = [0,0,0,0]
  245.             index = 0
  246.             while (self.player2Action):
  247.                 for i in range(4):
  248.                     dist[i] = pow(pow(v[i][0]-vect[0],2)+pow(v[i][1]-vect[1],2),0.5)
  249.                 min_d = dist[0]
  250.                 for i in range(4):
  251.                     if dist[i] < min_d:
  252.                         index = i
  253.                 target = v[index]
  254.                 if (vect[0]<target[0]):
  255.                     self.pl2ShootNum = 1
  256.                     self.player2.move_x(1)
  257.                     self.player2Action = False
  258.                     continue
  259.                 if (vect[0]>target[0]):
  260.                     self.pl2ShootNum = 3
  261.                     self.player2.move_x(-1)
  262.                     self.player2Action = False
  263.                     continue
  264.                 if (vect[1]<target[1]):
  265.                     self.pl2ShootNum = 2
  266.                     self.player2.move_y(1)
  267.                     self.player2Action = False
  268.                     continue
  269.                 if (vect[1]>target[1]):
  270.                     self.pl2ShootNum = 0
  271.                     self.player2.move_y(-1)
  272.                     self.player2Action = False
  273.                     continue
  274.                 if index == 1:
  275.                     self.bullets.append(bullet([[['"']]],self.player2.x-5,self.player2.y+1,self.GameScreen,-1,0,20))
  276.                     self.bulletsLen = len(self.bullets)
  277.                     self.pl2ShootNum = 3
  278.                 if index == 0:
  279.                     self.bullets.append(bullet([[['"']]],self.player2.x+5,self.player2.y+1,self.GameScreen,1,0,20))
  280.                     self.bulletsLen = len(self.bullets)
  281.                     self.pl2ShootNum = 1
  282.                 if index == 2:
  283.                     self.bullets.append(bullet([[['"']]],self.player2.x+1,self.player2.y-4,self.GameScreen,0,-1,20))
  284.                     self.bulletsLen = len(self.bullets)
  285.                     self.pl2ShootNum = 0
  286.                 if index == 3:
  287.                     self.bullets.append(bullet([[['"']]],self.player2.x+1,self.player2.y+4,self.GameScreen,0,1,20))
  288.                     self.bulletsLen = len(self.bullets)
  289.                     self.pl2ShootNum = 2
  290.                 self.player2Action = False
  291.             self.player2Action = True
  292.             # обработка кнопок
  293.             if (str(self.key)[2]=='a'):
  294.                 self.plShootNum = 3
  295.                 self.player.move_x(-1)
  296.                 self.key = "b'm'"
  297.             if (str(self.key)[2]=='d'):
  298.                 self.plShootNum = 1
  299.                 self.player.move_x(1)
  300.                 self.key = "b'm'"
  301.             if (str(self.key)[2]=='w'):
  302.                 self.plShootNum = 0
  303.                 self.player.move_y(-1)
  304.                 self.key = "b'm'"
  305.             if (str(self.key)[2]=='s'):
  306.                 self.plShootNum = 2
  307.                 self.player.move_y(1)
  308.                 self.key = "b'm'"
  309.             # пули
  310.             if (str(self.key)[2]=='f'):
  311.                 if self.plShootNum == 0:
  312.                     self.bullets.append(bullet([[['"']]],self.player.x+1,self.player.y-4,self.GameScreen,0,-1,20))
  313.                 elif self.plShootNum == 2:
  314.                     self.bullets.append(bullet([[['"']]],self.player.x+1,self.player.y+4,self.GameScreen,0,1,20))
  315.                 elif self.plShootNum == 1:
  316.                     vect = [1,0]
  317.                     self.bullets.append(bullet([[['"']]],self.player.x+5,self.player.y+1,self.GameScreen,1,0,20))
  318.                 elif self.plShootNum == 3:
  319.                     vect = [-1,0]
  320.                     self.bullets.append(bullet([[['"']]],self.player.x-5,self.player.y+1,self.GameScreen,-1,0,20))
  321.                 self.bulletsLen = len(self.bullets)
  322.                 self.key = "b'm'"
  323.             # код
  324.             # пули
  325.             for i in range(self.bulletsLen):
  326.                 if (self.bullets[i].check()):
  327.                     self.bullets[i].move()
  328.                 else:
  329.                     self.bulletsIndexes.append(i)
  330.             for i in self.bulletsIndexes:
  331.                 self.bullets.pop(i)
  332.                 self.bulletsLen -= 1
  333.             self.bulletsIndexes = []
  334.             # пули конец
  335.             self.GameScreen.Clear()
  336.             self.player.sprite.DrawShoot(self.plShootNum)
  337.             self.player2.sprite.DrawShoot(self.pl2ShootNum)
  338.             for i in range(self.bulletsLen):
  339.                 self.bullets[i].sprite.DrawShoot(0)
  340.             self.GameScreen.ShowDisplay()
  341.             # попадание по игроку
  342.             for b in self.bullets:
  343.                 if (self.player.sprite.CheckCollision(b.x,b.y)):
  344.                     self.player = Player(self.A,random.randint(1,99),random.randint(1,69),self.GameScreen)
  345.                     self.bullets = []
  346.                     self.bulletsLen = 0
  347.                     self.player2Score += 1
  348.                 if (self.player2.sprite.CheckCollision(b.x,b.y)):
  349.                     self.player2 = Player(self.A,random.randint(1,99),random.randint(1,69),self.GameScreen)
  350.                     self.bullets = []
  351.                     self.bulletsLen = 0
  352.                     self.playerScore += 1
  353.             print("Player Score:",self.playerScore,"Computer Score:",self.player2Score)
  354.     # считка клавиш
  355.     def getKey(self):
  356.         while (True):
  357.             self.key = msvcrt.getch()
  358.  
  359. game = Game()
  360.  
  361. thread1 = Thread(target=game.gameLoop)
  362. thread2 = Thread(target=game.getKey)
  363.  
  364. thread1.start()
  365. thread2.start()
  366. thread1.join()
  367. thread2.join()
  368.  
Runtime error #stdin #stdout #stderr 0.18s 26028KB
comments (?)
stdin 
Standard input is empty
stdout 
Standard output is empty
stderr 
Traceback (most recent call last):
  File "./prog.py", line 2, in <module>
ModuleNotFoundError: No module named 'msvcrt'
https://ideone.com/SJLnwd
language:
Python 3 (python  3.12)
created:
1 year ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!