2021-2022-1 20211325高进涛《信息安全专业导论》第十周学习总结

学习目标

信息系统
数据库与SQL
人工智能与专家系统
人工神经网络
模拟与离散事件
排队系统
天气与地震模型
图形图像

学习资源

教材
阅读「反作弊」：任何时候发现同学们有抄袭作业，抄袭代码的情况，即时课程总成绩清零

学习任务

加入云班课，参考本周学习资源
自学教材
- 计算机科学概论第12，13，14章并完成云班课测试
- 《看漫画学Python》第13，15章并完成云班课测试

## 教材学习内容总结

信息系统（Information system），是由计算机硬件、网络和通信设备、计算机软件、信息资源、信息用户和规章制度组成的以处理信息流为目的的人机一体化系统。主要有五个基本功能，即对信息的输入、存储、处理、输出和控制。信息系统经历了简单的数据处理信息系统、孤立的业务管理信息系统、集成的智能信息系统三个发展阶段
数据库（Database， DB）是将大量数据保存起来，通过计算机加工而成的可以进行高效访问的数据集合。
用来管理数据库的计算机系统称为数据库管理系统（Database Management System，DBMS）。
为什么DBMS那么重要？因为文本文件或Excel的局限性：
无法多人共享数据
无法提供操作大量数据所需的格式
实现读写自动化需要编程能力
无法应对突发事故
DBMS的种类
层次数据库（Hierarchical Database， HDB）：最古老的数据库之一，它把数据通过层次结构（树形结构）的方式表现出来。
关系数据库（Relational Database， RDB）：关系数据库是现在应用最广泛的数据库。
面向对象数据库（Object Oriented Database， OODB）：把数据以及对数据的操作集合起来以对象为单位进行管理。
XML数据库（XML Database， XMLDB）：XML 数据库可以对 XML 形式的大量数据进行高速处理。
键值存储系统（Key-Value Store， KVS）：这是一种单纯用来保存查询所使用的主键（Key）和值（Value）的组合的数据
SQL（Structured Query Language，结构化查询语言）是用来操作关系数据库的语言。

SQL语句及其种类：SQL 用关键字、表名、列名等组合而成的一条语句（SQL 语句）来描述操作的内容。关键字是指那些含义或使用方法已事先定义好的英语单词，存在包含“对表进行查询”或者“参考这个表”等各种意义的关键字。根据对 RDBMS 赋予的指令种类的不同， SQL 语句可以分为以下三类。PS：实际使用的 SQL 语句当中有 90% 属于 DML。
DDL（Data Definition Language，数据定义语言）用来创建或者删除存储数据用的数据库以及数据库中的表等对象。 DDL 包含以下几种指令。
CREATE：创建数据库和表等对象
DROP：删除数据库和表等对象
ALTER：修改数据库和表等对象的结构
DML（Data Manipulation Language，数据操纵语言）用来查询或者变更表中的记录。 DML 包含以下几种指令。
CREATE：创建数据库和表等对象
DROP：删除数据库和表等对象
ALTER：修改数据库和表等对象的结构
DCL（Data Control Language，数据控制语言）用来确认或者取消对数据库中的数据进行的变更。除此之外，还可以对 RDBMS 的用户是否有权限操作数据库中的对象（数据库表等）进行设定。 DCL 包含以下几种指令。
COMMIT：确认对数据库中的数据进行的变更
ROLLBACK：取消对数据库中的数据进行的变更
GRANT：赋予用户操作权限
REVOKE：取消用户的操作权限
SQL的基本书写规则：
SQL语句要以分号（;）结尾；
SQL语句不区分关键字大小写，插入表中的数据区分大小写；
常数的书写方式是固定的，字符串和日期常数需要使用单引号（'）括起来，数字常数无需加注单引号（直接书写数字即可）；
单词间需要用半角空格或者换行来分隔，不能使用全角空格作为单词的分隔符；
专家系统属于人工智能的一个发展分支，运用于医疗、军事、地质勘探、教学、化工等领域，产生了巨大的经济效益和社会效益。现在，专家系统已成为人工智能领域中最活跃、最受重视的领域
人工神经网络（Artificial Neural Network，即ANN ），是20世纪80 年代以来人工智能领域兴起的研究热点。它从信息处理角度对人脑神经元网络进行抽象，建立某种简单模型，按不同的连接方式组成不同的网络。在工程与学术界也常直接简称为神经网络或类神经网络。神经网络是一种运算模型，由大量的节点（或称神经元）之间相互联接构成。每个节点代表一种特定的输出函数，称为激励函数（activation function）。每两个节点间的连接都代表一个对于通过该连接信号的加权值，称之为权重，这相当于人工神经网络的记忆。网络的输出则依网络的连接方式，权重值和激励函数的不同而不同。而网络自身通常都是对自然界某种算法或者函数的逼近，也可能是对一种逻辑策略的表达。
离散事件模拟（DES）是一种模拟现实生活过程，设施或系统的行为和性能的方法。 DES越来越多地用于医疗保健服务，并且计算机的速度和内存的增加使得该技术可以应用于增加规模和复杂性的问题。
排队系统亦称“排队服务系统”。由一个或多个并联、串联及混合相联的服务台组成、服务于多种需求不同的顾客或工作对象，并按给定排队规则确定服务顺序的服务系统。现实中的生产制造和服务系统大多属于排队系统。服务的对象可以是自然人、待完成的工作、或待加工的工件。简单的排队系统可以用A/B/C表达，A指顾客到达时间间隔分布，B指服务时间分布，C指服务台个数。
图形是矢量图（Vector Drawn），它是根据几何特性来绘制的。图形的元素是一些点、直线、弧线等。矢量图常用于框架结构的图形处理，应用非常广泛，如计算机辅助设计（CAD）系统中常用矢量图来描述十分复杂的几何图形，适用于直线以及其它可以用角度、坐标和距离来表示的图。图形任意放大或者缩小后，清晰依旧。
图像是位图（Bitmap），它所包含的信息是用像素来度量的。就像细胞是组成人体的最小单元一样，像素是组成一幅图像的最小单元。对图像的描述与分辨率和色彩的颜色种数有关，分辨率与色彩位数越高，占用存储空间就越大，图像越清晰。

问题一：在编写游戏模块时music模块加载失败

解决：在pip下载了好几个music包，可能有一个碰巧成功了

from transitions import Machine


class Progress(object):
    pass


model = Progress()
states = ['New', 'Ready', 'Waiting', 'Running', 'Terminated']
transitions = [
    {'trigger': 'Admitted', 'source': 'New', 'dest': 'Ready'},
    {'trigger': 'Input', 'source': 'Waiting', 'dest': 'Ready'},
    {'trigger': 'Output', 'source': 'Waiting', 'dest': 'Ready'},
    {'trigger': 'event_completion', 'source': 'Waiting', 'dest': 'Ready'},
    {'trigger': 'event_wait', 'source': 'Running', 'dest': 'Waiting'},
    {'trigger': 'Input', 'source': 'Running', 'dest': 'Waiting'},
    {'trigger': 'Output', 'source': 'Running', 'dest': 'Waiting'},
    {'trigger': 'Interrupt', 'source': 'Running', 'dest': 'Ready'},
    {'trigger': 'Dispatch', 'source': 'Ready', 'dest': 'Running'},
    {'trigger': 'Exit', 'source': 'Running', 'dest': 'Terminated'}]

machine = Machine(model=model, states=states,
                  transitions=transitions, initial='New')

print(model.state)
model.Admitted()
print(model.state)
model.Dispatch()
print(model.state)
model.event_wait()
print(model.state)
model.Output()
print(model.state)
model.Dispatch()
print(model.state)
model.Exit()
print(model.state)

from pgzero.actor import Actor
from pgzero.keyboard import keyboard
from pgzero.loaders import sounds
import pgzrun
from math import sqrt
from math_funcs import *
from pkg_resources.extern import packaging

SIZE_X = 30
SIZE_Y = 30

N_X = 25
N_Y = 19

WIDTH = SIZE_X * N_X
HEIGHT = SIZE_Y * N_Y

MAXIMUM_VELOCITY_X = 2
JUMP_INIT_VELOCITY = 3
JUMP_ACCELERATION = 0.3
ACCELERATING_PERIOD = 10

COEFFICIENT_OF_RESTITUTION = 0.5

GRAVITY = 0.2

RADIUS_OF_KID = 5

class Actors(object):
    """Actor类作人物和子弹等可动物体父类

    :param image_name 外部素材图片文件名
    :param init_x, init_y 初始位置的方块坐标
    :param shape 碰撞箱形状

    """
    def __init__(self, image_name, init_x, init_y):
        self.x_velocity = 0
        self.y_velocity = 0
        self.shape = ''
        self.act = Actor(image_name, (init_x, init_y))


class Kid(Actors):
    """
    Kid类 用户操纵人物的单实例类

    :param jumping,jumped,has_jumped,jump1,jump1 用于实现可长按跳跃与二段跳跃算法的相关变量
    :param gravity 实现重力效果
    :param visible 可见性用于处理死亡事件
    :param rebirth_location 重生点用于处理存档、复活事件
    :param shape kid的碰撞箱形状为圆形
    :param radius radius为碰撞箱圆半径
    :param x_image, y_image 用于处理kid贴图
    """
    def __init__(self, image_name, init_x, init_y):
        """初始化实例"""

        super().__init__(image_name, init_x, init_y)
        self.visible = True
        self.rebirth_location = 1
        self.gravity = GRAVITY
        self.shape = 'circle'
        self.radius = RADIUS_OF_KID
        self.jumping = False
        self.jump1 = 0
        self.jump2 = 0
        self.jumped = False
        self.has_junmped = False
        self.x_image = 'right'
        self.y_image = 'stand'

    def move_x(self, scene):
        """处理左右移动事件"""

        self.layout_check(scene)
        if keyboard.d and not self.block_check('right', scene):
            self.x_velocity = MAXIMUM_VELOCITY_X
        elif keyboard.a and not self.block_check('left', scene):
            self.x_velocity = -MAXIMUM_VELOCITY_X
        else:
            self.x_velocity = 0
        self.act.x += self.x_velocity

    def jump(self, scene):
        """配合move_y处理跳跃事件"""

        if self.block_check('up', scene):
            self.y_velocity = -COEFFICIENT_OF_RESTITUTION * self.y_velocity
        if keyboard.k and self.jump1 == 0:
            self.y_velocity = -JUMP_INIT_VELOCITY
            self.jump1 += 1
            self.jumping = True
        if keyboard.k and self.jump1 != 0 and self.jump2 == 0:
            self.jump1 += 1
            if self.jump1 < ACCELERATING_PERIOD:
                self.y_velocity -= JUMP_ACCELERATION
        if not keyboard.k and self.jump1 != 0:
            self.jumped = True
        if keyboard.k and self.jumped and self.jump2 == 0:
            self.y_velocity = -JUMP_INIT_VELOCITY
            self.jump2 += 1
        if keyboard.k and self.jumped and self.jump2 != 0:
            self.jump2 += 1
            if self.jump2 < ACCELERATING_PERIOD:
                self.y_velocity -= JUMP_ACCELERATION
        if not keyboard.k and self.jump2 != 0:
            self.has_junmped = True
        if self.jump_check(scene) and self.jumped:
            self.jumped = False
            self.has_junmped = False
            self.jumping = False
            self.jump1 = 0
            self.jump2 = 0

    def fall(self, scene):
        """配合move_y处理重力下落"""

        if self.block_check('down', scene):
            self.y_velocity = 0
        else:
            self.y_velocity += self.gravity

    def move_y(self):
        """配合jumping, fall实现跳跃和重力"""

        self.act.y += self.y_velocity

    def image_refresh(self):
        """根据kid的运动方向刷新贴图"""

        if self.x_velocity > 0:
            self.x_image = 'right'
        elif self.x_velocity < 0:
            self.x_image = 'left'
        if self.y_velocity == 0:
            self.y_image = 'stand'
        elif self.y_velocity > 0:
            self.y_image = 'jump'
        elif self.y_velocity < 0:
            self.y_image = 'fall'

        self.act.image = self.y_image + self.x_image

    def shoot(self):
        """实现kid的射击动作"""
        pass

    def die(self, scene):
        """处理死亡事件:碰刺或者掉出界面"""
        if (self.lethal_check(scene) or self.act.y > 570)and not scene.blackcurtain:
            scene.death += 1
            sounds.diesound.play()
            self.visible = False
            scene.texts.append(Text("Press R to retry!", center=(WIDTH / 2, HEIGHT / 2 + 150),
                         fontsize=30, color='white'))
            scene.texts.append(Text("GAME OVER", center=(WIDTH / 2, HEIGHT / 2 - 100),
                                    fontsize=100, color='white'))
            scene.blackcurtain = True
        if keyboard.r:
            if scene.blackcurtain:
                for i in range(len(scene.texts)):
                    scene.texts.pop()
                scene.blackcurtain = False
            self.visible = True
            self.goback_rebirth(scene)

    def goback_rebirth(self, scene):
        """处理复活事件"""

        self.act.x = scene.savers[self.rebirth_location - 1].act.x
        self.act.y = scene.savers[self.rebirth_location - 1].act.y

    def jump_check(self, scene):
        """更新跳跃条件"""

        for obj in scene.blocks:
            if isinstance(obj, Block) and obj.jumpable:
                delta_x = obj.act.x - self.act.x
                delta_y = obj.act.y - self.act.y
                delta_x0 = self.radius + obj.size_x / 2
                delta_y0 = self.radius + obj.size_y / 2
                if 0 < delta_y <= delta_y0 and abs(delta_x) < delta_x0:
                    return True
        return False

    def block_check(self, direction, scene):
        """为掉落、跳跃等事件服务的方块碰撞检测函数"""

        for obj in scene.blocks:
            if self.collide_check(obj, direction):
                return True
        return False

    def lethal_check(self, scene):
        """死亡物碰撞检测事件"""

        for obj in scene.lethals:
            if self.collide_check(obj, None):
                return True
        return False

    def layout_check(self, scene):
        """布局物块的碰撞检测"""

        for obj in scene.layouts:
                if self.act.colliderect(obj.act) and keyboard.j:
                    if isinstance(obj, Saver) and obj.visible == True:
                        obj.action(self, scene)
                    if isinstance(obj, Ending):
                        obj.action(scene)
                    if isinstance(obj, Trigger):
                        obj.action()

    def collide_check(self, obj, direction):
        """为方块碰撞检测，死亡物碰撞检测提供的不同形状物体的碰撞检测算法"""

        collide = False
        if obj.shape == 'rectangle' and obj.collidable:
            delta_x = obj.act.x - self.act.x
            delta_y = obj.act.y - self.act.y
            delta_x0 = self.radius + obj.size_x / 2
            delta_y0 = self.radius + obj.size_y / 2
            if direction == "right" and 0 < delta_x <= delta_x0 and abs(delta_y) < delta_y0:
                if abs(delta_x) > abs(delta_y):
                    self.act.x = obj.act.x - delta_x0
                collide = True
            if direction == 'left' and 0 < -delta_x <= delta_x0 and abs(delta_y) < delta_y0:
                if abs(delta_x) > abs(delta_y):
                    self.act.x = obj.act.x + delta_x0
                collide = True
            if direction == 'down' and 0 < delta_y <= delta_y0 and abs(delta_x) < delta_x0:
                if abs(delta_x / delta_y) < 1:
                    self.act.y = obj.act.y - delta_y0
                collide = True
            if direction == 'up' and 0 < -delta_y <= delta_y0 and abs(delta_x) < delta_x0:
                if abs(delta_x / delta_y) < 1:
                    self.act.y = obj.act.y + delta_y0
                collide = True

        if obj.shape == 'triangle':
            collide = is_circle_intersect_triangle(self.act.x, self.act.y, self.radius,
                                                obj.x1, obj.y1, obj.x2, obj.y2, obj.x3, obj.y3)
        return collide


class Bullet(Actors):
    """子弹类，尚未实现"""
    def __init__(self, image_name, init_x, init_y, direction):
        super().__init__(image_name, init_x, init_y)
        self.direction = direction

    def move(self):
        pass

    def perish(self):
        pass


class Objects(object):
    """物块、致死物、布局物的父类

    :param image_name 外部素材图片文件名
    :param init_x, init_y 初始位置的方块坐标

    """
    def __init__(self, image_name, init_x, init_y):
        self.act = Actor(image_name, (init_x, init_y))
        self.shape = ''
        self.collidable = True
        self.jumpable = True
        self.lethal = False


class Block(Objects):
    """可以踩踏 不能穿过 不致死的物块类，做父类"""

    def __init__(self, image_name, init_x, init_y):
        super().__init__(image_name, init_x, init_y)
        self.collidable = True
        self.jumpable = True
        self.lethal = False
        self.size_x = 0
        self.size_y = 0


class Brick(Block):
    """最一般的标准1×1砖块"""

    def __init__(self, image_name, init_x, init_y):
        super().__init__(image_name, init_x, init_y)
        self.shape = 'rectangle'
        self.size_x = 30
        self.size_y = 30


class Board(Block):
    """会移动的板子，尚未实现"""
    pass


class Shattered_brick:
    """踩踏后会碎裂的砖块，尚未实现"""
    pass


class Lethal(Objects):
    """致死物的父类"""
    def __init__(self, image_name, init_x, init_y):
        super().__init__(image_name, init_x, init_y)
        self.lethal = True


class Thorn(Lethal):
    """最一般的致死物尖刺

    :param x1, y1, x2, y2, x3, y3 为圆形与三角形碰撞检测留下的三个顶点坐标参数

    """

    def __init__(self, image_name, init_x, init_y, direction='up'):
        """根据刺的方向对刺的图片素材和顶点坐标做初始化"""

        super().__init__(image_name, init_x, init_y)
        self.shape = 'triangle'
        if direction == 'up':
            self.act.image = self.act.image + 'up'
            self.x1 = init_x
            self.y1 = init_y - 10 * sqrt(3)
            self.x2 = init_x - 15
            self.y2 = init_y + 5 * sqrt(3)
            self.x3 = init_x + 15
            self.y3 = init_y + 5 * sqrt(3)
        elif direction == 'down':
            self.act.image = self.act.image + 'down'
            self.x1 = init_x
            self.y1 = init_y + 10 * sqrt(3)
            self.x2 = init_x - 15
            self.y2 = init_y - 5 * sqrt(3)
            self.x3 = init_x + 15
            self.y3 = init_y - 5 * sqrt(3)
        elif direction == 'left':
            self.act.image = self.act.image + 'left'
            self.x1 = init_x - 10 * sqrt(3)
            self.y1 = init_y
            self.x2 = init_x + 5 * sqrt(3)
            self.y2 = init_y + 15
            self.x3 = init_x + 5 * sqrt(3)
            self.y3 = init_y - 15
        elif direction == 'right':
            self.act.image = self.act.image + 'right'
            self.x1 = init_x + 10 * sqrt(3)
            self.y1 = init_y
            self.x2 = init_x - 5 * sqrt(3)
            self.y2 = init_y - 15
            self.x3 = init_x - 5 * sqrt(3)
            self.y3 = init_y + 15


class Apple(Lethal):
    """致死物苹果，尚未实现"""
    pass


class Dart(Lethal):
    """致死物忍者标，尚未实现"""
    pass


class Vine(Objects):
    """可刷新跳跃的藤蔓，尚未实现"""
    pass


class Water(Objects):
    """可以在其中游泳的水，尚未实现"""
    pass


class Layout(Objects):
    """布局物：出生点、通关点、保存点，触发器的父类"""

    def __init__(self, image_name, init_x, init_y):
        super().__init__(image_name, init_x, init_y)
        self.collidable = False
        self.jumpable = False
        self.lethal = False

    def action(self, *args):
        """对于布局物需要触发的用于重写的动作函数"""
        pass

class Trigger(Layout):
    """触发器类，用于设计机关和完成一些选择任务

    :param func 在scene模块中设定的函数，传入地址，函数用于实现触发器触发后的功能

    """
    def __init__(self, image_name, init_x, init_y, func):
        super().__init__(image_name, init_x, init_y)
        self.func = func

    def action(self):
        """触发器的动作函数，调用scene中设计好的触发动作"""

        self.func()

class Saver(Layout):
    """保存点类

    :param n 保存点标号
    :param difficulty 保存点的难度 保存点难度低于场景难度则可见
    :param visible 可见性，在不同难度下保存点的可见性不同，对应影响不同难度下的保存点数量
    """
    def __init__(self, image_name, init_x, init_y, n, difficulty = 0, visible = True):
        """初始化相关参数"""

        super().__init__(image_name, init_x, init_y)
        self.num = n
        self.difficulty = difficulty
        self.visible = visible
        if self.num == 1:
            self.act.image = 'load'


    def action(self, kid, scene):
        """保存点动作函数，重置重生点为当前保存点，将以前保存点改为失效贴图，将当前保存点改为生效贴图"""
        if self.act.image == 'unload':
            sounds.loadsound.play()
        if kid.rebirth_location < self.num:
            kid.rebirth_location = self.num
            self.act.image = "load"
            for i in scene.savers:
                if i.num < self.num and i.visible:
                    i.act.image = "hasload"

class Starting(Layout):
    """出生点，尚未实现，现以第一个保存点代替"""
    pass


class Ending(Layout):
    """通关点，切换到下一个场景"""

    def __init__(self, image_name, init_x, init_y):
        super().__init__(image_name, init_x, init_y)

    def action(self, scene):
        """通关点动作函数，将当前场景的结束属性设为True"""

        sounds.passsound.play()
        scene.over = True


class Scene(object):
    """场景类

    :param objects 场景内object的汇总
    :param bricks,blocks,thorns,lethals,savers,endings,triggers,layouts 场景内object的分类及分类汇总
    :param decorations,texts 场景内需要的装饰品、文本
    :param blackcurtain 用于处理死亡黑幕
    :param kid 场景内的kid
    :param waiting_j,need_press_j 用于处理等待按j的事件
    :param over 当前场景是否结束
    :param difficulty 场景的难度
    :param brick_image, thorn_image 场景素材图片
    :param death 记录当前scene死亡次数
    :param sum_death 记录总死亡次数
    :param loadfunc Scene的初始化函数
    """
    def __init__(self, loadfunc):
        """初始化相关变量"""

        self.objects = []
        self.bricks = []
        self.blocks = []
        self.thorns = []
        self.lethals = []
        self.savers = []
        self.endings = []
        self.triggers = []
        self.layouts = []
        self.texts = []
        self.decorations = []
        self.brick_image = ''
        self.thorn_image = ''
        self.blackcurtain = False
        self.kid = None
        self.waiting_j = False
        self.need_press_j = False
        self.over = False
        self.difficulty = 0
        self.death = 0
        self.sum_death = 0
        self.loadfunc = loadfunc

    def update(self):
        """场景内需要实时更新的函数"""

        self.kid.move_x(self)
        self.kid.jump(self)
        self.kid.move_y()
        self.kid.fall(self)
        self.kid.die(self)
        self.kid.image_refresh()

    def set_style(self, color):
        """设置场景风格接口"""
        self.brick_image = color + 'brick'
        self.thorn_image = color + 'thorn'

    def set_difficulty(self, difficulty):
        """用于设定、传递场景难度，改变不同难度下的保存点可见性"""
        self.difficulty = difficulty
        for saver in self.savers:
            if saver.difficulty < self.difficulty:
                saver.visible = False
                saver.act.image = 'null'

    def set_j(self):
        """处理一些等待j事件"""

        self.waiting_j = True

    def set_decorations(self,decorations):
        """创建装饰物接口"""
        for dec in decorations:
            self.decorations.append(Decoration(dec[0], dec[1], dec[2]))

    def set_texts(self,texts):
        """创建文本接口"""
        for text in texts:
            self.texts.append(Text(text=text[0], center=text[1], align=text[2], fontsize=text[3], color=text[4]))

    def set_bricks(self,bricks):
        """创建砖块接口"""
        for brick in bricks:
            self.bricks.append(Brick(self.brick_image, get_x(brick[0]), get_y(brick[1])))

    def set_thorns(self,thorns):
        """创建尖刺接口"""
        for thorn in thorns:
            self.thorns.append(Thorn(self.thorn_image, get_x(thorn[0]), get_y(thorn[1]), thorn[2]))

    def set_savers(self,savers):
        """创建保存点接口"""
        for saver in savers:
            self.savers.append(Saver('unload', get_x(saver[0]), get_y(saver[1]), saver[2], saver[3]))

    def set_endings(self,endings):
        """创建通关点接口"""
        for ending in endings:
            self.endings.append(Ending('ending', get_x(ending[0]), get_y(ending[1])))

    def set_triggers(self,triggers):
        """创建触发器接口"""
        for trigger in triggers:
            self.triggers.append(Trigger('null', get_x(trigger[0]), get_y(trigger[1]), trigger[2]))

    def append_objects(self):
        """汇总objects接口，用于初始化场景"""
        self.blocks += self.bricks

        self.lethals += self.thorns

        self.layouts += self.savers
        self.layouts += self.endings
        self.layouts += self.triggers

        self.objects = self.blocks + self.lethals + self.layouts

    def set_kid(self):
        """创建kid接口"""
        self.kid = Kid("standright", self.savers[0].act.x, self.savers[0].act.y)

    def load(self):
        self.loadfunc(self)

class Text(object):
    """文本类，用于添加到场景中

    :param text 文本字符串
    :param center 文本中心点像素坐标
    :param align 文本对齐方式
    :param fontname 文本字体
    :param fontsize 文本字号
    :param color 文本颜色
    """
    def __init__(self, text, center=None, align=None, fontname='方正胖头鱼简体', fontsize=24, color='white'):
        self.text = text
        self.center = center
        self.align = align
        self.fontname = fontname
        self.fontsize = fontsize
        self.color = color

class Decoration(object):
    """装饰类，用于添加到场景中

    :param decoration 贴图素材文件名
    :param x,y 贴图中心点的像素坐标
    """
    def __init__(self, decoration, x, y):
        self.decoration = decoration
        self.x = x
        self.y = y

from resources import *
from math_funcs import *
from random import choice
"""
场景设计模组
制作流程：
    def load_scene_sample(scene):     # 定义加载函数
        scene.set_style(choice(colors))  # 随机进行场景风格化
        scene.set_decorations(decorations)  # 添加装饰
        scene.set_texts(texts)        # 添加文本
        scene.set_bricks(bricks)      # 添加砖块
        scene.set_thorns(thorns)      # 添加尖刺
        scene.set_savers(savers)      # 添加保存点
        scene.set_endings(endings)    # 添加通关点
        def trigger_act_i():
            pass                             # 制作触发器动作函数
        scene.set_triggers(triggers)  # 添加触发器
        scene.set_kid()               # 初始化kid
        scene.append_objects()        # 汇总objects
    scenes.append(Scene(load_scene_sample))     # 将新建场景加到场景list中，将加载函数传给场景，以便随时加载
    
    其中 decorations,texts,bricks,thorns,savers,endings,triggers 为tuple组成的tuple或list
    每个元素tuple需要包含初始化对应实体的必要参数，具体可见resources.py中的scene类的对应接口方法
    具体实例如下
"""

VERSION = '1.5'  
scenes = [] 
colors = ['yellow', 'red', 'purple', 'orange', 'grey', 'green', 'cyangreen', 'cyanblue',]

"""------------------------------------SCENE_INIT--------------------------------------"""

def load_scene_init(scene):

    scene.waiting_j = True

    scene.set_style('purple0')

    scene.set_decorations((
        ('initial_menu', 0, 0),
    ))

    scene.set_texts((
        ("Welcome to", (WIDTH / 2, 70), 'center', 100, 'white'),

        ("I wanna be the dinosaur", (WIDTH / 2, 150), 'center', 50, 'white'),

        ("Press J to continue...", (WIDTH / 2 + 240, 550), 'center', 20, 'white'),
    ))

    scene.set_bricks(
        [(x + 10, 13) for x in range(7)] +
        [(x + 10, 19) for x in range(7)] +
        [(10, x + 14) for x in range(5)] +
        [(16, x + 14) for x in range(5)]
    )

    scene.set_savers((
        (13, 18, 1, 4),
    ))

    scene.set_kid()

    scene.append_objects()

"""-----------------------------------SCENE_START-------------------------------------"""

def load_scene_start(scene):

    scene.set_style(choice(colors))

    scene.set_decorations((
        ('scene1', 0, 0),
    ))

    scene.set_texts((
        ("Press A/D to move left and right\nPress K for longer or shorter time and for once or twice to get\n\tfamiliar with the sensitivity of jumping\nPress R to go back to the loaded rebirth point when you need\nPress J at flagpole to load or at cup to choose the difficulty", (WIDTH / 2, 120), 'left', 19, 'white'),
        ("EASY", (get_x(5.5), get_y(14)), 'center', 16, 'white'),
        ("NORMAL", (get_x(12), get_y(14)), 'center', 16, 'white'),
        ("HARD", (get_x(17.5), get_y(14)), 'center', 16, 'white')
    ))

    scene.set_bricks(
        [(x + 1, 19) for x in range(24)] +
        [(x + 2, 1) for x in range(24)] +
        [(1, x + 1) for x in range(19)] +
        [(25, x + 2) for x in range(18)] +
        [(x + 2, 9) for x in range(23)] +
        [(x + 2, 15) for x in range(21)]
    )

    scene.set_savers((
        (3, 18, 1, 4),
        (21, 14, 2, 4)
    ))

    scene.set_endings((
        (4, 14),
        (10, 14),
        (16, 14)
    ))


    def set_dif_1():
        scene.set_difficulty(1)


    def set_dif_2():
        scene.set_difficulty(2)


    def set_dif_3():
        scene.set_difficulty(3)


    scene.set_triggers((
        (4, 14, set_dif_1),
        (10, 14, set_dif_2),
        (16, 14, set_dif_3),
    ))

    scene.set_kid()

    scene.append_objects()

"""--------------------------------------SCENE1----------------------------------------"""

def load_scene1(scene):

    scene.set_style(choice(colors))

    scene.set_decorations((
        ('scene2', 0, 0),
    ))

    scene.set_bricks(
        [(x + 1, 19) for x in range(24)] +
        [(x + 2, 1) for x in range(24)] +
        [(1, x + 1) for x in range(19)] +
        [(25, x + 2) for x in range(18)] +
        [(x + 2, 15) for x in range(20)] +
        [(x + 5, 11) for x in range(20)] +
        [(x + 2, 6) for x in range(21)] +
        [
            (7, 2),
            (7, 3),
            (9, 2),
            (9, 3),
            (19, 3),
            (19, 4),
            (19, 5),
            (11, 9),
            (23, 10),
        ]
    )

    scene.set_thorns((
        (6, 18, 'up'),
        (8, 18, 'up'),
        (10, 18, 'up'),
        (13, 18, 'up'),
        (16, 18, 'up'),
        (19, 17, 'up'),
        (19, 18, 'up'),
        (20, 18, 'up'),
        (22, 15, 'right'),
        (24, 15, 'left'),
        (19, 12, 'down'),
        (18, 14, 'up'),
        (15, 12, 'down'),
        (14, 14, 'up'),
        (13, 12, 'down'),
        (10, 14, 'up'),
        (9, 14, 'up'),
        (8, 14, 'up'),
        (7, 14, 'up'),
        (4, 14, 'up'),
        (2, 12, 'right'),
        (4, 11, 'left'),
        (8, 10, 'up'),
        (8, 7, 'down'),
        (8, 8, 'down'),
        (13, 10, 'up'),
        (13, 9, 'up'),
        (13, 8, 'up'),
        (15, 10, 'up'),
        (15, 7, 'down'),
        (17, 10, 'up'),
        (18, 10, 'up'),
        (19, 10, 'up'),
        (20, 10, 'up'),
        (21, 10, 'up'),
        (18, 7, 'down'),
        (19, 7, 'down'),
        (23, 6, 'right'),
        (17, 2, 'down'),
        (17, 5, 'up'),
        (16, 5, 'up'),
        (15, 5, 'up'),
        (12, 5, 'up'),
        (10, 5, 'up'),
        (8, 5, 'up'),
        (6, 5, 'up'),
        (17, 4, 'up'),
        (10, 3, 'right'),
        (6, 3, 'left')
    ))

    scene.set_savers((
        (3, 18, 1, 4),
        (21, 14, 2, 1),
        (5, 10, 3, 2),
        (22, 5, 4, 1)
    ))

    scene.set_endings((
        (3, 5),
    ))

    scene.set_kid()

    scene.append_objects()

"""--------------------------------------SCENE2----------------------------------------"""

def load_scene2(scene):

    scene.set_style(choice(colors))

    scene.set_decorations((
        ('scene3', 0, 0),
    ))

    scene.set_bricks(
        [(x + 1, 19) for x in range(24)] +
        [(x + 1, 1 ) for x in range(24)] +
        [(1 , y + 1) for y in range(19)] +
        [(25, y + 1) for y in range(19)] +
        [(x + 18, 2 ) for x in range(5)] +
        [(x + 13, 4 ) for x in range(4)] +
        [(x + 19, 5 ) for x in range(4)] +
        [(x + 17, 6 ) for x in range(4)] +
        [(x + 15, 7 ) for x in range(4)] +
        [(x + 13, 8 ) for x in range(6)] +
        [(x + 13, 9 ) for x in range(5)] +
        [(x + 12, 10) for x in range(5)] +
        [(x + 12, 11) for x in range(4)] +
        [(x +  5, 11) for x in range(5)] +
        [(x + 4, 12) for x in range(16)] +
        [(x + 4, 13) for x in range(12)] +
        [(x + 10, 14) for x in range(8)] +
        [(x + 9, 15) for x in range(3)] +
        [(x + 15, 16) for x in range(6)] +
        [
            (24,2),
            (16,3),
            (17,3),
            (9,7),
            (10,7),
            (3,8),
            (4,8),
            (8,8),
            (9,8),
            (7,9),
            (8,9),
            (6,10),
            (7,10),
            (8,10),
            (3,14),
            (4,14),
            (6,14),
            (6,15),
            (3,15),
            (19,14),
            (19,15),
            (21,13),
            (21,14),
            (21,15),
            (23,13),
            (23,14),
            (23,15),
            (12,17),
            (13,17),
            (14,17),
            (8,16),
            (9,16),
            (8,17),
            (8,18),
            (2,18)
        ]
    )

    scene.set_thorns((
        (18, 3, 'down'),
        (19, 3, 'down'),
        (20, 3, 'down'),
        (21, 3, 'down'),
        (22, 3, 'down'),
        (24, 3, 'left'),
        (24, 4, 'left'),
        (24, 5, 'left'),
        (24, 6, 'left'),
        (24, 7, 'left'),
        (24, 8, 'left'),
        (24, 9, 'left'),
        (24, 10, 'left'),
        (21, 10, 'up'),
        (22, 10, 'up'),
        (23, 10, 'up'),
        (17, 4, 'down'),
        (13, 5, 'down'),
        (14, 5, 'down'),
        (9, 6, 'up'),
        (10, 6, 'up'),
        (7, 7, 'up'),
        (7, 8, 'up'),
        (5, 10, 'up'),
        (3, 12, 'left'),
        (11, 11, 'up'),
        (13, 7, 'up'),
        (3, 18, 'up'),
        (5, 18, 'up'),
        (13, 16, 'up'),
        (19, 11, 'up'),
        (19, 13, 'up'),
        (20, 15, 'up'),
        (22, 15, 'up'),
        (16, 18, 'up'),
        (19, 18, 'up'),
        (21, 18, 'up'),
        (22, 18, 'up'),
        (24, 18, 'up'),
        (21, 6, 'down'),
        (22, 6, 'down')
    ))

    scene.set_savers((
        (5, 15, 1, 4),
        (10, 9, 2, 1),
        (23, 2, 3, 2),
        (17, 10, 4, 1)
    ))

    scene.set_endings((
        (16, 13),
    ))
    scene.set_kid()

    scene.append_objects()

"""--------------------------------------SCENE3----------------------------------------"""

def load_scene3(scene):

    scene.set_style(choice(colors))

    scene.set_decorations((
        ('scene4', 0, 0),
    ))

    scene.set_bricks(
        [(x + 1, 19) for x in range(24)] +
        [(x + 1, 1 ) for x in range(24)] +
        [(1 , y + 1) for y in range(19)] +
        [(25, y + 1) for y in range(19)] +
        [(x + 17, 3) for x in range(6)] +
        [(x + 7, 3) for x in range(2)] +
        [(x + 18, 4) for x in range(2)] +
        [(x + 13, 8) for x in range(3)] +
        [(x + 13, 9) for x in range(3)] +
        [(x + 10, 10) for x in range(13)] +
        [(x + 17, 11) for x in range(3)] +
        [(x + 18, 12) for x in range(3)] +
        [(x + 18, 14) for x in range(5)] +
        [(x + 12, 13) for x in range(4)] +
        [(x + 15, 15) for x in range(9)] +
        [(x + 14, 18) for x in range(3)] +
        [(x + 10, 18) for x in range(3)] +
        [(x + 10, 15) for x in range(4)] +
        [(x + 3, 16) for x in range(3)] +
        [(x + 3, 15) for x in range(4)] +
        [(x + 6, 14) for x in range(5)] +
        [(x + 4, 13) for x in range(6)] +
        [(x + 5, 12) for x in range(3)] +
        [
            (7, 2),
            (5,6),
            (4,7),
            (18,5),
            (14,6),
            (14,7),
            (20,7),
            (19,8),
            (20,8),
            (18,9),
            (19,9),
            (9,8),
            (9,9),
            (10,9),
            (7,10),
            (2,11),
            (3,11),
            (5,11),
            (6,11),
            (10,11),
            (10,12),
            (9,12),
            (4,14),
            (21,13),
            (15,14),
            (12,16),
            (12,17),
            (16,17),
            (21,16),
            (22,16),
            (22,17),
            (23,17)

        ]
    )

    scene.set_thorns((
        (24, 2, 'left'),
        (24, 3, 'left'),
        (24, 4, 'left'),
        (24, 5, 'left'),
        (24, 6, 'left'),
        (24, 7, 'left'),
        (2, 12, 'down'),
        (2, 13, 'down'),
        (13, 16, 'down'),
        (14, 11, 'down'),
        (15, 11, 'down'),
        (2, 10, 'up'),
        (5, 10, 'up'),
        (6, 10, 'up'),
        (10, 8, 'up'),
        (11, 9, 'up'),
        (12, 9, 'up'),
        (15, 7, 'up'),
        (16, 9, 'up'),
        (17, 9, 'up'),
        (18, 8, 'up'),
        (19, 7, 'up'),
        (21, 7, 'up'),
        (22, 7, 'up'),
        (8, 11, 'up'),
        (8, 12, 'up'),
        (12, 12, 'up'),
        (16, 13, 'up'),
        (16, 14, 'up'),
        (17, 14, 'up'),
        (4, 18, 'up'),
        (5, 18, 'up'),
        (7, 18, 'up'),
        (8, 18, 'up'),
        (9, 18, 'up'),
        (8, 17, 'up'),
        (9, 17, 'up'),
        (15, 17, 'up'),
        (17, 17, 'up'),
        (17, 18, 'up'),
        (19, 17, 'up'),
        (19, 18, 'up'),
        (18, 18, 'up'),
        (20, 18, 'up'),
        (23, 10, 'right'),
        (24, 13, 'left')
    ))

    scene.set_savers((
        (8, 15, 1, 4),
        (14, 5, 2, 1),
        (24,18, 3, 2),
        (13,18, 4, 1)

    ))

    scene.set_endings((
        (20, 13),
    ))

    scene.set_kid()

    scene.append_objects()

"""--------------------------------------SCENE4----------------------------------------"""

def load_scene4(scene):
    scene.set_style(choice(colors))
    scene.set_decorations((
        ('scene5', 0, 0),
    ))

    scene.set_bricks(
        [(x + 9, 1) for x in range(3)] +
        [(x + 7, 3) for x in range(5)] +
        [(13, y + 3) for y in range(3)] +
        [(x + 2, 5) for x in range(7)] +
        [(x + 11, 5) for x in range(2)] +
        [(1, y + 6) for y in range(3)] +
        [(1, y + 12) for y in range(3)] +
        [(x + 8, 10) for x in range(11)] +
        [(7, y + 11) for y in range(3)] +
        [(x + 2, 15) for x in range(6)] +
        [(7, y + 16) for y in range(4)] +
        [(x + 11, 19) for x in range(3)] +
        [(x + 15, 19) for x in range(3)] +
        [(19, y + 1) for y in range(8)] +
        [(x + 20, 5) for x in range(5)] +
        [(25, y + 6) for y in range(3)] +
        [(x + 18, 9) for x in range(3)] +
        [(x + 17, 13) for x in range(2)] +
        [(23, y + 9) for y in range(5)] +
        [(x + 21, 11) for x in range(2)] +
        [(25, y + 12) for y in range(3)] +
        [(10, y + 12) for y in range(5)] +
        [(x + 13, 15) for x in range(12)] +
        [(13, y + 16) for y in range(2)] +
        [(x + 14, 17) for x in range(6)] +
        [(19, y + 18) for y in range(2)] +

        [
            (7, 1),
            (2, 6),
            (2, 14),
            (8, 7),
            (9, 8),
            (9, 9),
            (8, 11),
            (18, 5),
            (24, 6),
            (24, 14),
            (11, 16)

        ]
    )

    # THORNS
    scene.set_thorns((
        (1, 1, 'right'),
        (1, 2, 'right'),
        (1, 3, 'right'),
        (1, 4, 'right'),
        (2, 1, 'down'),
        (3, 1, 'down'),
        (4, 1, 'down'),
        (5, 1, 'down'),
        (6, 1, 'down'),
        (6, 3, 'left'),
        (8, 1, 'down'),
        (9, 5, 'up'),
        (10, 5, 'up'),
        (12, 1, 'down'),
        (13, 1, 'down'),
        (14, 1, 'down'),
        (14, 4, 'up'),
        (15, 4, 'up'),
        (16, 4, 'up'),
        (14, 7, 'right'),
        (15, 7, 'right'),
        (17, 7, 'left'),
        (18, 7, 'left'),
        (16, 9, 'up'),
        (12, 8, 'up'),
        (12, 9, 'up'),
        (1, 9, 'right'),
        (1, 10, 'right'),
        (1, 11, 'right'),
        (3, 12, 'right'),
        (5, 12, 'left'),
        (6, 12, 'left'),
        (4, 14, 'up'),
        (8, 19, 'up'),
        (9, 19, 'up'),
        (10, 19, 'up'),
        (14, 19, 'up'),
        (18, 19, 'up'),
        (12, 14, 'left'),
        (13, 14, 'up'),
        (14, 11, 'left'),
        (15, 11, 'down'),
        (15, 12, 'down'),
        (19, 13, 'right'),
        (20, 12, 'down'),
        (21, 14, 'up'),
        (21, 9, 'right'),
        (23, 8, 'up'),
        (25, 9, 'left'),
        (25, 10, 'left'),
        (24, 13, 'up')
    ))

    # LAYOUTS
    scene.set_savers((
        (2, 2, 1, 4),
        (18, 2, 2, 1),
        (2, 13, 3, 2),
        (23, 14, 4, 1)

    ))

    scene.set_endings((
        (25, 11),
    ))

    # KID
    scene.set_kid()

    scene.append_objects()

"""--------------------------------------SCENE5----------------------------------------"""


def load_scene5(scene):

    # BACKGOUND
    scene.set_style(choice(colors))

    scene.set_decorations((
        ('scene6', 0, 0),
    ))

    # BRICKS
    scene.set_bricks(
        [(x + 15, 19) for x in range(10)] +
        [(x + 6, 15) for x in range(3)] +
        [(14, y + 12) for y in range(5)] +
        [(8, y + 10) for y in range(3)] +
        [(13, x + 8) for x in range(3)] +
        [(x + 23, 12) for x in range(3)] +
        [(x + 5, 7) for x in range(3)] +
        [(x + 9, 7) for x in range(3)] +
        [(17, x + 1) for x in range(4)] +
        [(x + 11, 0) for x in range(6)] +
        [
            (21, 1),
            (13, 2),
            (14, 2),
            (23, 2),
            (8, 3),
            (12, 4),
            (21, 4),
            (24, 4),
            (2, 5),
            (13, 6),
            (16, 5),
            (23, 5),
            (20, 7),
            (22, 7),
            (3, 8),
            (20, 9),
            (22, 9),
            (10, 10),
            (22, 11),
            (7, 12),
            (21, 12),
            (4, 14),
            (11, 14),
            (23, 14),
            (2, 15),
            (18, 15),
            (2, 16),
            (10, 16),
            (11, 16),
            (25, 16),
            (3, 17),
            (13, 17),
            (17, 17),
            (10, 19),
            (11, 19),
            (3, 10),
            (14, 11),
            (19, 10),
            (20, 3),
            (14, 18),
            (13, 7),
            (12, 7),
    ]
    )

    # THORNS
    scene.set_thorns((
        (9, 19, 'left'),
        (11, 18, 'up'),
        (19, 18, 'up'),
        (20, 18, 'up'),
        (21, 18, 'up'),
        (22, 18, 'up'),
        (23, 18, 'up'),
        (16, 17, 'left'),
        (20, 17, 'up'),
        (22, 17, 'up'),
        (17, 16, 'up'),
        (4, 15, 'down'),
        (10, 15, 'up'),
        (11, 15, 'up'),
        (2, 14, 'left'),
        (3, 14, 'left'),
        (7, 14, 'up'),
        (8, 14, 'up'),
        (13, 14, 'left'),
        (18, 14, 'up'),
        (4, 13, 'up'),
        (6, 12, 'left'),
        (9, 12, 'right'),
        (15, 12, 'right'),
        (22, 12, 'down'),
        (7, 11, 'up'),
        (9, 11, 'right'),
        (25, 11, 'left'),
        (20, 10, 'down'),
        (22, 10, 'down'),
        (25, 10, 'left'),
        (14, 9, 'right'),
        (23, 9, 'right'),
        (25, 9, 'left'),
        (4, 8, 'down'),
        (5, 8, 'down'),
        (6, 8, 'down'),
        (7, 8, 'down'),
        (8, 8, 'down'),
        (9, 8, 'down'),
        (10, 8, 'down'),
        (11, 8, 'down'),
        (28, 8, 'right'),
        (20, 8, 'left'),
        (22, 8, 'right'),
        (25, 8, 'left'),
        (8, 7, 'up'),
        (21, 8, 'up'),
        (25, 7, 'left'),
        (2, 6, 'down'),
        (6, 6, 'up'),
        (7, 6, 'up'),
        (9, 6, 'up'),
        (10, 6, 'up'),
        (23, 6, 'down'),
        (2, 4, 'up'),
        (8, 4, 'down'),
        (16, 4, 'up'),
        (23, 3, 'down'),
        (7, 2, 'left'),
        (9, 2, 'right'),
        (21, 2, 'down'),
        (7, 1, 'left'),
        (9, 1, 'right'),
        (13, 5, 'up'),
        (13, 3, 'down'),
        (15, 5, 'left'),
        (16, 6, 'down'),
        (21, 5, 'down'),
        (8, 16, 'down'),
        (8, 17, 'down'),
        (8, 18, 'down'),
        (12, 8, 'down')
    ))

    # LAYOUTS
    scene.set_savers((
        (3, 16, 1, 4),
        (8, 9, 2, 1),
        (11, 6, 3, 2),
        (19, 9, 4, 1),

    ))

    scene.set_endings((
        (23, 11),
    ))

    # KID
    scene.set_kid()

    scene.append_objects()



"""----------------------------------SCENE_TERMINAL------------------------------------"""

def load_scene_terminal(scene):

    scene.need_press_j = True

    # DECORATIONS
    scene.set_style('red0')

    scene.set_decorations((
        ('scene_terminal', 0, 0),
    ))
    scene.set_texts((
        ("Thanks for your enjoying\nMore scenes are coming...\n\nPress J to exit", (500, 130), 'center', 30, 'white'),
        ("I wanna be the dinosaur\nVersion:{}".format(VERSION), (WIDTH / 2, 360), 'center', 40, 'white'),
        ("Contact us: habibzhu@foxmail.com".format(VERSION), (WIDTH / 2, 440), 'center', 25, 'white'),
        ("Difficulty:{}".format({'0':'Cheat', '1':'Easy', '2':'Normal', '3':'Hard'}[str(scene.difficulty)]), (200, 490), 'left', 25, 'red'),
        ("Death:{} times".format(scene.sum_death), (540, 490), 'left', 25, 'red')
    ))

    # BLOCKS
    scene.set_bricks(
        [(x + 2, 9) for x in range(23)] +
        [(x + 2, 18) for x in range(23)] +
        [(2, x + 10) for x in range(8)] +
        [(24, x + 10) for x in range(8)]
    )

    # LETHALS
    scene.set_thorns(
        [(x+2, 8, 'up') for x in range(23)] +
        [(x+2, 19, 'down') for x in range(23)] +
        [(1, x + 9, 'left') for x in range(10)] +
        [(25, x + 9, 'right') for x in range(10)]
    )

    # LAYOUTS
    scene.set_savers((
        (13, 17, 1, 4),
    ))

    # KIDkr
    scene.set_kid()

    scene.append_objects()


"""--------------------------------------SCENES----------------------------------------"""

scenes.append(Scene(load_scene_init))
scenes.append(Scene(load_scene_start))
scenes.append(Scene(load_scene1))
scenes.append(Scene(load_scene2))
scenes.append(Scene(load_scene3))
scenes.append(Scene(load_scene4))
scenes.append(Scene(load_scene5))
scenes.append(Scene(load_scene_terminal))

import pgzrun
from pgzero.clock import clock
from pgzero.keyboard import keyboard

from scenes import *


def draw():
    if scene.decorations and not scene.over:
        for dec in scene.decorations:
            screen.blit(dec.decoration, (dec.x, dec.y))
    for i in range(len(scene.objects)):
        scene.objects[i].act.draw()
    if scene.kid and scene.kid.visible:
        scene.kid.act.draw()
    if scene.blackcurtain:
        screen.blit('blackcurtain', (0,0))
    if scene.texts:
        for text in scene.texts:
            screen.draw.text(text.text,center=text.center, align=text.align, fontname=text.fontname,
                             fontsize=text.fontsize, color=text.color)



def update():
    global scene, i
    if not music.is_playing('bgm'):
        music.play('bgm')
        music.set_volume(0.7)
    scene.update()
    if scene.waiting_j:
        if keyboard.j:
            scene.over = True
    if scene.over:
        if i == len(scenes) - 1:
            exit()
        else:
            i += 1
            scene = scenes[i]
            scene.sum_death = scenes[i - 1].death + scenes[i - 1].sum_death
            scene.difficulty = scenes[i - 1].difficulty
            scene.load()
            scene.set_difficulty(scene.difficulty)
            if scene.need_press_j:
                clock.schedule_unique(scene.set_j,1)

i = 0 
scene = scenes[i]  
scene.load()
pgzrun.go()

from math import *
"""
进行三角形与圆形碰撞检测数学算法
方块坐标转换像素坐标匿名函数
"""

get_x = lambda x0:30 * x0 - 15
get_y = lambda y0:30 * y0 - 15

def evaluate_point_to_line(x, y, x1, y1, x2, y2):
    """计算点到线距离"""

    a = y2 - y1
    b = x1 - x2
    c = x2 * y1 - x1 * y2
    return a * x + b * y + c


def is_point_in_triangle(x, y, x1, y1, x2, y2, x3, y3):
    """判断点是否在三角形内"""
    d1 = evaluate_point_to_line(x, y, x1, y1, x2, y2)
    d2 = evaluate_point_to_line(x, y, x2, y2, x3, y3)
    if d1 * d2 < 0:
        return False
    d3 = evaluate_point_to_line(x, y, x3, y3, x1, y1)
    if d2 * d3 < 0:
        return False
    return True


def is_circle_intersect_line_seg(x, y, r, x1, y1, x2, y2):
    """判断圆是否与直线相交"""
    vx1 = x - x1
    vy1 = y - y1
    vx2 = x2 - x1
    vy2 = y2 - y1
    len = sqrt(vx2 ** 2 + vy2 ** 2)
    vx2 /= len
    vy2 /= len
    u = vx1 * vx2 + vy1 * vy2
    if u <= 0:
        x0 = x1
        y0 = y1
    elif u >= len:
        x0 = x2
        y0 = y2
    else:
        x0 = x1 + vx2 * u
        y0 = y1 + vx2 * u
    if (x - x0) ** 2 + (y - y0) ** 2 <= r ** 2:
        return True


def is_circle_intersect_triangle(x, y, r, x1, y1, x2, y2, x3, y3):
    """判断圆是否与三角形相交"""
    if is_point_in_triangle(x, y, x1, y1, x2, y2, x3, y3):
        return True
    if is_circle_intersect_line_seg(x, y, r, x1, y1, x2, y2):
        return True
    if is_circle_intersect_line_seg(x, y, r, x2, y2, x3, y3):
        return True
    if is_circle_intersect_line_seg(x, y, r, x3, y3, x1, y1):
        return True
    return False

	代码行数（新增/积累）	博客量（新增/积累）	学习时间（新增/积累）	重要成长
目标	5000行	30篇	400小时
第一周	100/150	2/2	20/20
第二周	250/300	2/4	30/50	对于纯理论性知识的记忆还有待加强
第三周	100/400	1/5	40/90	对于简单的编码和设计程序判断已基本掌握，但对于在atom中在编写python时的图片插入仍存在问题
第四周	200/600	1/6	20/110	换用了VScode编辑器，好像是要方便一点，之后学会了BASE64编码，浮点数，还有阿拉伯数字和罗马数字的互相转化。
第五周	250/850	3/9	20/130	终于不是一脸懵的抄代码了
第六周	200/1050	3/12	20/150	知道了原来代码并没有什么唯一解，只有更方便更简洁的答案
第七周	300/1350	4/16	25/175	对伪代码的理解更深入了，这将便于我更准确的书写代码，以及对算法的深入了解将会方便我选择更合适的算法
第八周	250/1600	2/18	20/195	在项目python数据库编程中的学习中，学会了怎么方便的创建和修改表格，顺便复习了一下字典
第九周	300/1900	4/22	25/220	完善了项目，自己做了几个游戏玩玩，越来越喜欢计算机了
第十周	350/2250	3/25	27/247	自己做了几个小游戏，但是在音频导入时出现了问题

posted on 2021-11-28 13:33 STERNSTUN 阅读(28) 评论(0) 收藏举报

刷新页面返回顶部

2021-2022-1 20211325高进涛《信息安全专业导论》第十周学习总结

2021-2022-1 20211325高进涛《信息安全专业导论》第十周学习总结

学习目标

学习资源

学习任务

## 教材学习内容总结

导航

公告