Python-сообщество

[code python]# Sea Salt
#       * * *
# murkOwl | 11.07.2012

# imports
import sys
import os
import math
import random

import pygame
from pygame.locals import *

from numpy import *

# functions
def inpute(events):
    global shipturn, cursh, gamestate
    for event in events:
        # keyboard
        if event.type == QUIT: gexit()
        elif event.type == KEYDOWN:
            if event.key == K_ESCAPE: gexit()
            elif event.key == K_RETURN: restart()
        # mouse
        if not victory:
            if event.type == MOUSEBUTTONDOWN and event.button == 1:
                parts.append(part(event.pos[0],
                                 event.pos[1],
                                 (10,random.randint(50,150),random.randint(100,200)), 30, 0))
                if gamestate:
                    shot((event.pos[0]-420)//30, (event.pos[1]-150)//30)
                    parts.append(part(event.pos[0], event.pos[1], (200,50,10), 15, 0, 3))
                else:
                    if not placeship((event.pos[0]-80)//30, (event.pos[1]-150)//30):
                        parts.append(part(event.pos[0], event.pos[1], (255,20,10), 40, 0, 2))
                    else:
                        cursh+=1
                        if cursh >= len(SHIPS): gamestate = True
            elif event.type == MOUSEBUTTONDOWN and event.button == 3:
                if shipturn == 1: shipturn = 0
                else: shipturn = 1
        else:
            if event.type == MOUSEBUTTONDOWN and event.button == 1:
                parts.append(part(event.pos[0],
                                 event.pos[1],
                                 (10,random.randint(50,150),random.randint(100,200)), 30, 0))

def gexit():
    pygame.quit()
    sys.exit(0)

def randcolor(a,b):
    return (random.randint(a,b),random.randint(a,b),random.randint(a,b),255)

def fin(p):
    global victory, total_a, total_b
    if p:
        victory = 1
        total_a += 1
    else:
        victory = 2
        total_b += 1

def clearborder(field,sx,sy,sd = -1):
    if field[sx][sy] == 2:     # if broken ship
        if sd in (0,-1):
            if sx<9:
                clearborder(field,sx+1,sy,0)
                if sy>0: clearborder(field,sx+1,sy-1,4)
                if sy<9: clearborder(field,sx+1,sy+1,4)
        if sd in (1,-1):
            if sy<9:
                clearborder(field,sx,sy+1,1)
                if sx>0: clearborder(field,sx-1,sy+1,4)
                if sx<9: clearborder(field,sx+1,sy+1,4)
        if sd in (2,-1):
            if sx>0:
                clearborder(field,sx-1,sy,2)
                if sy>0: clearborder(field,sx-1,sy-1,4)
                if sy<9: clearborder(field,sx-1,sy+1,4)
        if sd in (3,-1):
            if sy>0:
                clearborder(field,sx,sy-1,3)
                if sx>0: clearborder(field,sx-1,sy-1,4)
                if sx<9: clearborder(field,sx+1,sy-1,4)
    elif field[sx][sy] == 0:
        field[sx][sy] = 3      # miss

def shot(sx,sy):
    global score_a, score_b, shipx, shipy, shipd
    if sx<0 or sx>9: return False
    if sy<0 or sy>9: return False
    if field_b[sx][sy] in (2,3): return False
    if field_b[sx][sy] == 1:
        field_b[sx][sy] = 2
        score_a+=1
        if score_a == NUMSH: fin(True)
        return True
    elif field_b[sx][sy] == 0: field_b[sx][sy] = 3
    # enemy shot
    while True:
        if shipx == -1:
            x = random.randint(0,10); y = random.randint(0,10)
            while field_a[x][y] not in (0,1):
                x = random.randint(0,10); y = random.randint(0,10)
        else:
            x = shipx
            y = shipy
            while field_a[x][y] == 2:
                x+=VECTOR[shipd][0]
                y+=VECTOR[shipd][1]
                if x<0 or x>9:
                    shipd += 1
                    x = shipx
                    y = shipy
                if y<0 or y>9:
                    shipd += 1
                    x = shipx
                    y = shipy
                if field_a[x][y] == 3:
                    shipd += 1
                    x = shipx
                    y = shipy
                if shipd >= 4:
                    clearborder(field_a, shipx, shipy)
                    shipx = -1
                    shipy = -1
                    break
            if shipd >= 4: continue
        if field_a[x][y] == 1:
            field_a[x][y] = 2
            score_b+=1
            if score_b == NUMSH: fin(False)
            if shipx == -1:
                shipx = x; shipy = y; shipd = 0
        elif field_a[x][y] == 0:
            field_a[x][y] = 3
            if shipx != -1:
                shipd += 1
                if shipd >= 4:
                    shipx = -1; shipy = -1
            break
    return True

def checkplace(sx,sy,lx,ly,field):
    if sx<0 or (sx+lx-1)>9: return False
    if sy<0 or (sy+ly-1)>9: return False
    for x in range(lx):
        for y in range(ly):
            if (x+sx)>0:
                if field[x+sx-1][y+sy]!=0: return False
                if (y+sy)>0:
                    if field[x+sx-1][y+sy-1]!=0: return False
                if (y+sy)<9:
                    if field[x+sx-1][y+sy+1]!=0: return False
            if (y+sy)>0:
                if field[x+sx][y+sy-1]!=0: return False
            if field[x+sx][y+sy]!=0: return False
            if (y+sy)<9:
                if field[x+sx][y+sy+1]!=0: return False
            if (x+sx)<9:
                if field[x+sx+1][y+sy]!=0: return False
                if (y+sy)>0:
                    if field[x+sx+1][y+sy-1]!=0: return False
                if (y+sy)<9:
                    if field[x+sx+1][y+sy+1]!=0: return False
    return True

def placeship(sx,sy):
    res = checkplace(sx, sy, SHIPS[cursh][turn[shipturn][0]], SHIPS[cursh][turn[shipturn][1]], field_a)
    if res:
        for x in range(SHIPS[cursh][turn[shipturn][0]]):
            for y in range(SHIPS[cursh][turn[shipturn][1]]):
                field_a[x+sx][y+sy] = 1
    return res

def placeships():
    global shipturn
    x = 0; y = 0
    mask = zeros((10,10), dtype=int16)
    for c in range(len(SHIPS)):
        x = random.randint(0,10); y = random.randint(0,10)
        while True:
            while mask[x][y]!=0:
                x = random.randint(0,10); y = random.randint(0,10)
                #x+=1
                #if x>9: x = 0; y+=1
            shipturn = 0
            res = checkplace(x, y, SHIPS[c][turn[shipturn][0]], SHIPS[c][turn[shipturn][1]], field_b)
            if res:
                for sx in range(SHIPS[c][turn[shipturn][0]]):
                    for sy in range(SHIPS[c][turn[shipturn][1]]):
                        field_b[x+sx][y+sy] = 1
                        mask[x+sx][y+sy] = 1
                break
            shipturn = 1
            res = checkplace(x, y, SHIPS[c][turn[shipturn][0]], SHIPS[c][turn[shipturn][1]], field_b)
            if res:
                for sx in range(SHIPS[c][turn[shipturn][0]]):
                    for sy in range(SHIPS[c][turn[shipturn][1]]):
                        field_b[x+sx][y+sy] = 1
                        mask[x+sx][y+sy] = 1
                break
            mask[x][y] = 1

def restart():
    global gamestate, score_a, score_b, cursh, shipturn, victory, shipx, shipy, shipd
    gamestate = False        # place your ships again
    cursh = 0                # current ship = first
    for x in range(10):      # clear fields
        for y in range(10):
            field_a[x][y] = 0
            field_b[x][y] = 0
    placeships()             # place enemy ships
    score_a = 0; score_b = 0 # zero all scores
    shipturn = 0             # defaults
    victory = 0              # no results
    shipx = -1
    shipy = -1
    shipd = 0                # no targets for enemy fire

#####################################################################################

# classes
class enemy:
    def __init__(self, x, y, model, life):
        self.x, self.y, self.model, self.life = x, y, model, life
        self.image = enemy.copy()
        self.image.fill(COLORMARK[model], None, BLEND_RGBA_MULT) # color

    def update(self):
        pass

    def draw(self):
        # image size = 50 x 50
        screen.blit(self.image,(self.x-25,self.y-25))


class part:
    def __init__(self, x, y, color, life, effect, width = 1):
        self.x, self.y, self.color, self.life, self.effect = x, y, color, life, effect
        self.rad = width
        self.adelta = 255/self.life
        self.width = width

    def update(self):
        self.rad+=1
        self.life-=1
        #self.color = (self.color[0],self.color[1],self.color[2],self.color[3]+self.adelta)

    def draw(self):
        pygame.draw.circle(screen,self.color,(self.x,self.y),self.rad,self.width)

#####################################################################################

# globals
WIDTH, HEIGHT = 800, 600
WT, HT = math.floor(WIDTH/20), math.floor(HEIGHT/20)
FONT_SIZE = 30
GAMESPEED = 1.0
SHIPS = ((4,1),(4,1),(3,1),(2,1),(2,1),(1,1),(1,1),(1,1),(1,1))
NUMSH = 4+4+3+2+2+1+1+1+1
COLORF = ((50,255,40),(255,50,20))
MESSAGEF = ('WINNER','LOSER')
VECTOR = ((1,0),(0,1),(-1,0),(0,-1))

# init graph
os.environ['SDL_VIDEO_WINDOW_POS'] = "100,100"
pygame.init()
window = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Sea Salt')
screen = pygame.display.get_surface()

# resourses
font = pygame.font.Font(os.path.join('data','KIN668.ttf'), FONT_SIZE)
bigfont = pygame.font.Font(os.path.join('data','KIN668.ttf'), FONT_SIZE*4)

watertile = pygame.image.load(os.path.join('data','water.png')).convert_alpha()

tile = []
tile.append(pygame.image.load(os.path.join('data','empty.png')).convert_alpha())
tile.append(pygame.image.load(os.path.join('data','ship.png')).convert_alpha())
tile.append(pygame.image.load(os.path.join('data','broken.png')).convert_alpha())
tile.append(pygame.image.load(os.path.join('data','miss.png')).convert_alpha())
                   
# variables
parts = []
field_a = zeros((10,10), dtype=int16); score_a = 0
field_b = zeros((10,10), dtype=int16); score_b = 0
cursh = 0
water = pygame.Surface((300,300),SRCALPHA)
for x in range(10):
    for y in range(10):
        water.blit(watertile,(x*30,y*30))
gamestate = False   # False - place ships   True - batle]
shipturn = 0
turn = ((0,1),(1,0))
victory = 0
shipx = -1; shipy = -1; shipd = 0
total_a = 0
total_b = 0

# init data
clock = pygame.time.Clock()
placeships()

# main cycle
if __name__ == '__main__':
    while True:
        # fps counter
        clock.tick(30)
        
        # update
        inpute(pygame.event.get())
        key = pygame.key.get_pressed()
        c = random.randint(0,80)
        if c==1:
            parts.append(part(random.randint(0,80), random.randint(0,600),
                             (30,random.randint(20,150),random.randint(100,200)), 40, 0))
        elif c==2:
            parts.append(part(random.randint(720,800), random.randint(0,600),
                             (30,random.randint(20,150),random.randint(100,200)), 40, 0))
        elif c==3:
            parts.append(part(random.randint(0,800), random.randint(0,150),
                             (30,random.randint(20,150),random.randint(100,200)), 40, 0))
        elif c==4:
            parts.append(part(random.randint(0,800), random.randint(450,600),
                             (30,random.randint(20,150),random.randint(100,200)), 40, 0))

        screen.fill((0,0,10))
        screen.blit(water,(80,150)); pygame.draw.rect(screen, (255,255,255),(79,149,302,302),1)
        screen.blit(water,(420,150)); pygame.draw.rect(screen, (255,255,255),(419,149,302,302),1)
        for x in range(10):
            for y in range(10):
                screen.blit(tile[field_a[x][y]], (80+x*30,150+y*30))
                if field_b[x][y] != 1: screen.blit(tile[field_b[x][y]], (420+x*30,150+y*30))
                else: screen.blit(tile[0], (420+x*30,150+y*30))
        pygame.draw.line(screen,(200,200,200),(80,105),(720,105),1)
        pygame.draw.line(screen,(200,200,200),(80,140),(720,140),1)
        pygame.draw.line(screen,(200,200,200),(80,460),(720,460),1)
        pygame.draw.line(screen,(200,200,200),(80,495),(720,495),1)
        screen.blit(font.render('You',True,(100,120,200)), (200,110))
        screen.blit(font.render('Enemy',True,(100,120,200)), (525,110))

        if not gamestate:
            c = pygame.mouse.get_pos()
            for x in range(SHIPS[cursh][turn[shipturn][0]]):
                for y in range(SHIPS[cursh][turn[shipturn][1]]):
                    screen.blit(tile[1],(c[0]-15+x*30,c[1]-15+y*30))
        
        for x in parts:
            x.draw()
            x.update()
        parts = list(filter(lambda x: x.life>0,parts))
        
        # draw - menu & gui
        
        screen.blit(font.render('FPS : '+str(round(clock.get_fps(),1)),True,(100,120,200)), (10,10))
        screen.blit(font.render(str(score_a),True,(100,120,200)), (220,465))
        screen.blit(font.render(str(score_b),True,(100,120,200)), (560,465))
        screen.blit(font.render(':',True,(200,200,20)), (390,15))
        image = font.render(str(total_a),True,(200,200,20))
        screen.blit(image, (380-image.get_size()[0],15))
        screen.blit(font.render(str(total_b),True,(200,200,20)), (420,15))

        if victory:
            image = bigfont.render(MESSAGEF[victory-1],True,(0,0,0))
            screen.blit(image,(400-image.get_size()[0]/2+2,252))
            image = bigfont.render(MESSAGEF[victory-1],True,COLORF[victory-1])
            screen.blit(image,(400-image.get_size()[0]/2,250))
        
        # flip
        pygame.display.update()

# The End! Hooray!!!
[/code]