Python-使用cocos2d实现的捕鱼游戏

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import cocos
import random
import pyglet
import os
import math
import time
from cocos.director import director
from cocos import layer
from cocos import scene
from cocos import sprite
from cocos import collision_model as collision
from cocos.scenes.transitions import *
from cocos.audio.pygame import music
from cocos.audio.effect import Effect
from cocos.cocosnode import CocosNode


director.init(width=800, height=600, caption="wang and miao", audio_backend="sdl")
working_dir = os.path.dirname(os.path.realpath(__file__))
pyglet.resource.path = [os.path.join(".")]
pyglet.resource.reindex()
image_convert = pyglet.resource.image
WIN_WIDTH, WIN_HEIGHT = director.get_window_size()
score = 0
las_bit = 1


class Cannon(sprite.Sprite):
    def __init__(self):
        super(Cannon, self).__init__('textures/pao5.png')
        self.position = WIN_WIDTH//2, 0
        self.scale = 0.8
        self.angle = 0

    def fire(self, x, y):
        tanX = abs(float(y)/(x - self.position[0]+0.001))
        radian = math.atan(tanX)
        self.angle = 90 - radian*180/math.pi
        if x < WIN_WIDTH//2:
            self.angle = -self.angle
        duration = abs(self.angle) / 200.0
        self.do(cocos.actions.RotateTo(self.angle, duration))


class Net(sprite.Sprite):
    def __init__(self):
        super(Net, self).__init__('textures/B5.png')
        WIN_WIDTH, WIN_HEIGHT = director.get_window_size()
        self.position = WIN_WIDTH//2, 0
        self.cshape = collision.AARectShape(cocos.euclid.Vector2(0, 0), self.width//2, self.height//2)
        self.schedule(self._update_cshape)

    def _update_cshape(self, dt):
        self.cshape.center = collision.eu.Vector2(*self.position)

    def shoot(self, x, y, angle):
        tan_corner =float(600)/(400+0.001)
        corner_radian = math.atan(tan_corner)
        corner_angle = 90 - corner_radian*180/math.pi
        if abs(angle) > corner_angle:
            mx = WIN_WIDTH + 10 if angle > 0 else -10
            my = (WIN_WIDTH//2+10)/(x-WIN_WIDTH//2)*y if angle > 0 else (WIN_WIDTH//2+10)/(WIN_WIDTH//2-x)*y
        else:
            my = WIN_HEIGHT + 10
            mx = WIN_WIDTH//2 + my/y*(x-WIN_WIDTH//2) if angle > 0 else WIN_WIDTH//2 - my/y*(WIN_WIDTH//2-x)
        distance = math.sqrt(abs(mx - WIN_WIDTH//2)**2+abs(my)**2)
        self.scale = 0.8
        times = round(distance / 200)
        times = times if times else 1
        self.do(cocos.actions.RotateTo(angle, 0)|cocos.actions.MoveTo((mx, my), 0.5*times)+cocos.actions.Delay(0.2)+cocos.actions.CallFunc(self.explode))

    def explode(self):
        self.stop()
        self.kill()


class Fish(sprite.Sprite):
    def __init__(self, ft):
        self.name = ft
        WIN_WIDTH, WIN_HEIGHT = director.get_window_size()
        textures = []
        for x in range(1, 10):
            if ft == 'ballfish':
                fish_path_str = 'textures/ballfish/clownfish_%s.png'
            elif ft == 'greenfish':
                x = str(0) + str(x)
                fish_path_str = 'textures/greenfish/fish03_%s.png'
            elif ft == 'redfish':
                x = str(0) + str(x)
                fish_path_str = 'textures/redfish/fish02_%s.png'
            elif ft == 'swimming' and 0 < x < 5:
                x = 'r' + str(x)
                fish_path_str = 'textures/swimming/shark_%s.png'
            else:
                continue
            texture = pyglet.resource.image(fish_path_str % x)
            textures.append(texture)
        if ft == 'swimming':
            animation  = pyglet.image.Animation.from_image_sequence(textures, 0.5)
            super(Fish, self).__init__(animation)
            self.position = -100, random.randint(120, WIN_HEIGHT-320)
            self.scale = 0.75        
        else:
            self.ds = random.randint(0, 10) * 30
            animation  = pyglet.image.Animation.from_image_sequence(textures, 0.1)
            super(Fish, self).__init__(animation)
            self.position = WIN_WIDTH+100+self.ds, random.randint(100, WIN_HEIGHT-self.height-20)
            self.scale = 0.5
        self.cshape = collision.AARectShape(collision.eu.Vector2(0,0), self.width//2, self.height//2)
        self.schedule(self._update_cshape)

    def _update_cshape(self, dt):
        self.cshape.center = collision.eu.Vector2(*self.position)

    def swim(self, ft):
        if ft == 'swimming':
            self.do(cocos.actions.MoveTo((WIN_WIDTH+100, self.position[1]), 18)+cocos.actions.CallFunc(self.shark_btb_action))
        else:
            self.do(cocos.actions.MoveTo((-100-self.ds, self.position[1]), 12)+cocos.actions.CallFunc(self.small_fish_btb_action))

    def shark_btb_action(self):
        self.do(cocos.actions.RotateTo(180, 0))
        self.do(cocos.actions.MoveTo((-100, self.position[1]+random.choice([-50, 50])), 18)+cocos.actions.CallFunc(self.explode))

    def small_fish_btb_action(self):
        self.do(cocos.actions.RotateTo(180, 0))
        self.do(cocos.actions.MoveTo((WIN_WIDTH+100, self.position[1]+random.choice([-100, 100])), 12)+cocos.actions.CallFunc(self.explode))

    def explode(self):
        self.stop()
        self.kill()


class MenuBackgound(cocos.layer.Layer):
    def __init__(self):
        super(MenuBackgound, self).__init__()
        d_width, d_height = director.get_window_size()
        background = cocos.sprite.Sprite("textures/menu.png")
        background.position = d_width//2, d_height//2
        logo_layer = cocos.sprite.Sprite("textures/logo.png")
        logo_layer.position = d_width//2 , d_height//2+180
        self.add(background)
        self.add(logo_layer)


class MainMenu(cocos.menu.Menu):
    def __init__(self):
        super(MainMenu, self).__init__()
        self.font_item['font_size'] = 50
        self.font_item_selected['font_size'] = 50
        self.font_item['color'] = (255, 255, 255, 25)
        self.font_item_selected['color'] = (215, 255, 255, 255)

        menu_start=cocos.menu.ImageMenuItem('textures/start.png', self.menu_start_callback)
        menu_setting = cocos.menu.ImageMenuItem('textures/set.png', self.menu_setting_callback)
        menu_help = cocos.menu.ImageMenuItem('textures/help.png', self.menu_help_callback)
        self.create_menu([menu_start, menu_setting, menu_help],
            layout_strategy = cocos.menu.fixedPositionMenuLayout([(420, 339), (420, 220), (420, 100)]),
            selected_effect=cocos.menu.zoom_in(),
            unselected_effect=cocos.menu.zoom_out())

    def menu_start_callback(self):
        yinxiao=Effect('textures/biu.wav')
        yinxiao.play()
        layer = GameLayer()
        gamemenu = GameMenu()
        game_scene = scene.Scene(layer)
        game_scene.add(gamemenu)
        donghua = TurnOffTilesTransition(game_scene, 1)
        director.push(donghua)

    def menu_help_callback(self):
        yinxiao=Effect('textures/biu.wav')
        yinxiao.play()

    def menu_setting_callback(self):
        yinxiao=Effect('textures/biu.wav')
        yinxiao.play()


class GameMenu(cocos.menu.Menu):
    def __init__(self):
        super(GameMenu, self).__init__()
        self.font_item['font_size'] = 50
        self.font_item_selected['font_size'] = 50
        self.font_item['color'] = (255, 255, 255, 25)
        self.font_item_selected['color'] = (215, 255, 255, 255)

        exit = cocos.menu.ImageMenuItem("textures/exit.png", self.exit_callback)
        self.create_menu([exit, ],
            layout_strategy=cocos.menu.fixedPositionMenuLayout([(80, 532),]),
            selected_effect=cocos.menu.zoom_in(), 
            unselected_effect=cocos.menu.zoom_out())

    def exit_callback(self):
        director.pop()
        music.stop()


class GameLayer(layer.Layer):
    is_event_handler = True
    def __init__(self):
        self.nets = layer.Layer()
        self.fishs = layer.Layer()
        super(GameLayer, self).__init__()
        self.bg = sprite.Sprite('textures/seaworld.jpg')
        WIN_WIDTH, WIN_HEIGHT = director.get_window_size()
        self.bg.position = WIN_WIDTH // 2, WIN_HEIGHT // 2
        self.add(self.bg)
        self.cannon = Cannon()
        self.add(self.cannon)

        self.create_label()
        self.create_fish()
        self.play_bgm()
        self.adjust_las()

        self.add(self.nets)
        self.add(self.fishs)
        self.schedule(collision_handle, self.nets, self.fishs, self.score_value, self)

    def create_label(self):
        pyglet.font.add_file("CroissantD.ttf")
        self.score_label = cocos.text.Label('Score:', 
            font_name="Times New Roman",
            font_size=32,
            anchor_x='center', anchor_y='center')
        self.score_label.position = WIN_WIDTH - 150, WIN_HEIGHT -50        
        self.score_value = cocos.text.Label('0', 
            font_name="CroissantD",
            font_size=32,
            anchor_x='center', anchor_y='center')
        self.score_value.position = WIN_WIDTH - 60, WIN_HEIGHT - 50
        self.add(self.score_label)
        self.add(self.score_value)

    def create_fish(self):
        add_small_fish(0, self.fishs)
        self.schedule_interval(add_small_fish, 3, self.fishs)
        self.schedule_interval(add_shark, 8, self.fishs)

    def adjust_las(self):
        self.do(cocos.actions.Delay(1.5)+cocos.actions.CallFunc(lambda : light_and_shade(0, self.bg)))
        self.schedule_interval(light_and_shade, 5, self.bg)

    def play_bgm(self):
        music.load("textures/bgm.wav".encode())
        music.play(loops=-1)
        music.set_volume(2)

    def open_net(self, x, y):
        onet = cocos.sprite.Sprite("textures/net.png")
        onet.position = x, y
        onet.scale = 0.5
        self.add(onet)
        onet.do(cocos.actions.Delay(0.5)+cocos.actions.CallFunc(onet.kill))

    def on_mouse_motion(self, x, y, dx, dy):
        self.cannon.fire(x, y)

    def on_mouse_press(self, x, y, button, modiffiers):
        self.cannon.fire(x, y)
        if button == pyglet.window.mouse.LEFT:
            if len(self.nets.children) >= 3:
                return
            self.net = Net()
            self.nets.add(self.net)
            self.net.shoot(x, y, self.cannon.angle)


def collision_handle(dt, nets, fishs, label, game_layer):
    global score
    for i in nets.children:
        for j in fishs.children:
            if i[1].cshape.distance(j[1].cshape) == 0:
                i[1].explode()
                j[1].stop()
                j[1].do(cocos.actions.Delay(0.5)+cocos.actions.CallFunc(j[1].explode))
                game_layer.open_net(i[1].position[0], i[1].position[1])
                if j[1].name == "swimming":
                    score = score + 3
                else:
                    score = score + 1
                if score > 999:
                    score = 999
                label.element.text = str(score)
                break


def add_small_fish(dt, fish_layer):
    if len(fish_layer.children) > 12:
        return
    randnum = random.randrange(1, 6)
    for i in range(randnum):
        ft = random.choice(['ballfish', 'greenfish', 'redfish'])
        fish = Fish(ft)
        fish_layer.add(fish)
        fish.swim(ft)


def add_shark(dt, fish_layer):
    if len(fish_layer.children) > 12:
        return
    ft = "swimming"
    fish = Fish(ft)
    fish_layer.add(fish)
    fish.swim(ft)


def light_and_shade(dt, bg):
    global las_bit
    if las_bit:
        bg.do(cocos.actions.FadeTo(127, 3.5))
        las_bit = las_bit - 1
    else:
        bg.do(cocos.actions.FadeTo(255, 3.5))
        las_bit = las_bit + 1


if __name__ == '__main__':
    menu_bg=MenuBackgound()
    main_scence = scene.Scene(menu_bg)
    main_menu = MainMenu()
    main_scence.add(main_menu)
    director.run(main_scence)