python/pygame 挑战魂斗罗 笔记(二)

news2024/12/27 13:45:26

一、建立地面碰撞体：

现在主角Bill能够站立在游戏地图的地面，是因为我们初始化的时候把Bill的位置固定了self.rect.y = 250。而不是真正的站在地图的地面上。

背景地图是一个完整的地图，没有地面、台阶的概念，就无法通过碰撞检测来实现玩家角色在各台阶地面上的移动跳跃，可以考虑在PS中把地面、台阶给提取出来，让角色可以通过碰撞检测来实现，但这需要重新PS中修改地图，并在代码中加载好多个图片。

这里采用的是在所有地面、台阶的位置画一条线，暂时就叫地面碰撞体吧。然后实现主角Bill和这些地面碰撞体发生碰撞，从而让主角Bill能够站在这个碰撞体上面。

1、先写出地面碰撞体的类：

在ContraMap.py中增加CollideGround类：

class CollideGround(pygame.sprite.Sprite):
    def __init__(self, length, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.Surface((length * Constant.MAP_SCALE, 3))
        self.image.fill((255, 0, 0))
        self.rect = self.image.get_rect()
        self.rect.x = x * Constant.MAP_SCALE - Constant.WIDTH * 2
        self.rect.y = y * Constant.MAP_SCALE

这个类很简单，就是一个3像素高的红色矩形。因为地图放大了3倍，同时我们在主角出现，也就是地图走到- Constant.WIDTH * 2的时候再把碰撞体画出来，把这些因素考虑进去，可以使在PS中测量碰撞体长度、坐标位置更方便一点。

2、测量并定义地面碰撞体：

在Config.py中增加一些存放碰撞体的组，测量可以在PS或其它画图软件中进行：

    collider = pygame.sprite.Group()
    collider83 = pygame.sprite.Group()
    collider115 = pygame.sprite.Group()
    collider146 = pygame.sprite.Group()
    collider163 = pygame.sprite.Group()
    collider178 = pygame.sprite.Group()
    collider211 = pygame.sprite.Group()
    collider231 = pygame.sprite.Group()

这里先测量并定义出前面的部分，其实有collider一个组就行，这里按照y坐标的位置分了很多组只是为了测量、加载的时候更清晰一点，不容易乱，最后统一加入collider组。

Variable.collider115.add(
    CollideGround(736, 832, 115)
)

Variable.collider146.add(
    CollideGround(97, 959, 146),
    CollideGround(66, 1215, 146)
)

Variable.collider163.add(
    CollideGround(95, 1440, 163)
)

Variable.collider178.add(
    CollideGround(32, 1055, 178),
    CollideGround(32, 1151, 178)
)

Variable.collider211.add(
    CollideGround(63, 1088, 211),
    CollideGround(63, 1407, 211)
)

Variable.collider.add(Variable.collider83, Variable.collider115, Variable.collider146, Variable.collider163,
                      Variable.collider178, Variable.collider211, Variable.collider231)
3、修改StateMap类的update方法，在Varibale.step==2时，加入all_sprites组进行绘制。
    def update(self):
        if self.order == 2:
            print('纵向地图')
        else:
            if Variable.step == 0 and self.rect.x >= -Constant.WIDTH:
                self.rect.x -= 10
            if Variable.step == 1 and self.rect.x > -Constant.WIDTH * 2:
                self.rect.x -= 10
                if self.rect.x == -Constant.WIDTH * 2:
                    Variable.step = 2
                    Variable.all_sprites.add(Variable.collider)

这样就得到了这张带红色地面线的图片。 

二、主角Bill移动+跳跃：

1、给主角Bill定义移动、跳跃、下落三种状态。

初始状态为下落，也就是主角从画面外降落，碰撞到地面碰撞体后把碰撞体的top值赋值给Bill的bottom，实现停止下落。

            self.falling = True
            self.jumping = False
            self.moving = False
2、常量中增加x、y两个方向的移动速度，以及模拟重力。
    SPEED_X = 3
    SPEED_Y = -10
    GRAVITY = 0.5
 3、先定义移动、跳跃、下落、动作图片序列四个方法：

移动需要考虑三种情况：

第一是开始直到人物走到屏幕中间，这部分是主角Bill正常移动；

第二是Bill移动到游戏窗口中间时，Bill需要一直停留在中间，而Bill的向前移动实际是地图向后移动，这里设立了一个x = self.rect.centerx - Constant.WIDTH / 2，也就是Bill移动超过游戏窗口中间的距离，然后让all_sprites中的所有精灵，包括Bill都向后移动这个距离。反过来也一样。

第三是地图移动到边界时就不能继续移动了，这时需要Bill继续移动，并保证不能走出游戏窗口。这里为了控制地图，需要获取地图的rect属性。网上搜了很多一直没找到怎么从all_sprites精灵组中获取指定精灵的方法，搞了好久，后来终于想到给地图单独一个组Varible.map_storage，通过遍历这个组来获取地图以及地图的rect属性。

    def move(self):
        if self.direction == 'right' and self.rect.right <= Constant.WIDTH - 80 * Constant.MAP_SCALE:
            self.rect.x += Constant.SPEED_X
            if self.rect.centerx >= Constant.WIDTH / 2:
                x = self.rect.centerx - Constant.WIDTH / 2
                for j in Variable.map_storage:
                    if j.rect.right >= Constant.WIDTH:
                        for i in Variable.all_sprites:
                            i.rect.x -= x

        elif self.direction == 'left' and self.rect.left >= 40 * Constant.MAP_SCALE:
            self.rect.x -= Constant.SPEED_X
            if self.rect.centerx <= Constant.WIDTH / 2:
                x = Constant.WIDTH / 2 - self.rect.centerx
                for j in Variable.map_storage:
                    if j.rect.left <= -Constant.WIDTH * 2:
                        for i in Variable.all_sprites:
                            i.rect.x += x

图片序列：就是正常设定时间钟，然后image_order在0-5中间循环。

跳跃：先设定SPEED_Y为-10，GRAVITY为0.5，这样向上移动SPPED_Y的值逐渐减小，直到SPPED_Y==0，调整jumping和falling状态，并将SPEED_Y恢复为-10，完成一次跳跃。

下落：简单的写了一个10倍Constant.GRAVITY 下落。

    def order_loop(self):
        self.now_time = pygame.time.get_ticks()
        if self.now_time - self.last_time >= 100:
            self.image_order += 1
            if self.image_order > 5:
                self.image_order = 0
            self.last_time = self.now_time

    def jump(self):
        Constant.SPEED_Y += Constant.GRAVITY
        self.rect.y += Constant.SPEED_Y
        if Constant.SPEED_Y == 0:
            self.jumping = False
            self.falling = True
            Constant.SPEED_Y = -10

    def fall(self):
        self.rect.y += Constant.GRAVITY * 10
4、修改update方法，实现跳下功能：

前后移动以及跳跃都可以根据设定的按键来修改状态以及图片类型。

重点是向下跳跃，向下跳跃实现的思路，是将Bill的状态设定为一直处于下落状态(跳跃时除外)，让他与地面碰撞体一直碰撞，并将碰撞体的top值赋值给self.floor变量，然后向下跳的时候(s和j键同时按下)，将该碰撞体从collider中删除并用sprite_storage组暂时寄存，实现Bill往下落：

            if key_pressed[pygame.K_s] and key_pressed[pygame.K_j]:
                self.image_type = 'oblique_down'
                Variable.collider.remove(l[0])
                Variable.sprite_storage.add(l[0])

等到Bill的rect.top值大于self.floor时，也就是完全超过哪条地面线的位置，再把该碰撞体加载回来，否则就会出现跳下一半就检测到碰撞，被拉回原来地面的情况。加回碰撞体后，就可以实现跳回来的动作。

        if self.rect.top >= self.floor:
            for i in Variable.sprite_storage:
                Variable.collider.add(i)
                Variable.sprite_storage.remove(i)

其它的部分，就是按照按键以及按键组合，调整各自的状态参数就可以了。

把按键监测写到碰撞后的for循环里面，是想控制主角Bill必须是与碰撞体接触后才能进行移动及跳跃等操作，否则在刚开始下落的时候就可以移动了，也会出现半空中继续跳跃的情况。 

    def update(self):
        self.image = self.image_dict[self.image_type][self.image_order]
        if self.direction == 'left':
            self.image = pygame.transform.flip(self.image, True, False)

        if self.rect.top >= self.floor:
            for i in Variable.sprite_storage:
                Variable.collider.add(i)
                Variable.sprite_storage.remove(i)

        key_pressed = pygame.key.get_pressed()
        if self.falling:
            self.fall()

        if self.jumping:
            self.jump()

        if self.moving:
            self.move()

        self.order_loop()

        collider_ground = pygame.sprite.groupcollide(Variable.player_sprites, Variable.collider, False, False)
        for p, l in collider_ground.items():
            self.floor = l[0].rect.top
            p.rect.bottom = self.floor
            if key_pressed[pygame.K_d]:
                self.direction = 'right'
                self.moving = True
                if key_pressed[pygame.K_w]:
                    self.image_type = 'oblique_up'
                elif key_pressed[pygame.K_s]:
                    self.image_type = 'oblique_down'
                elif key_pressed[pygame.K_j]:
                    self.image_type = 'jump'
                    self.jumping = True
                    self.falling = False
                else:
                    self.image_type = 'run'
            elif key_pressed[pygame.K_a]:
                self.direction = 'left'
                self.moving = True
                if key_pressed[pygame.K_w]:
                    self.image_type = 'oblique_up'
                elif key_pressed[pygame.K_s]:
                    self.image_type = 'oblique_down'
                elif key_pressed[pygame.K_j]:
                    self.image_type = 'jump'
                    self.jumping = True
                    self.falling = False
                else:
                    self.image_type = 'run'

            elif key_pressed[pygame.K_w]:
                self.image_type = 'up'
                self.moving = False

            elif key_pressed[pygame.K_s]:
                self.image_type = 'down'
                self.moving = False

            else:
                self.image_type = 'stand'
                self.moving = False

            if key_pressed[pygame.K_s] and key_pressed[pygame.K_j]:
                self.image_type = 'oblique_down'
                Variable.collider.remove(l[0])
                Variable.sprite_storage.add(l[0])

这一部分功能的实现费了挺长时间，前前后后改了很多次才终于完成，虽然总觉得跳的有点别扭，但总算是实现了跳下跳回的功能，就这样吧。

三、现阶段各文件完整代码：

1、Contra.py
# Contra.py
import sys
import pygame

import ContraBill
import ContraMap
from Config import Constant, Variable


def control():
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            Variable.game_start = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RETURN:
                Variable.step = 1


class Main:
    def __init__(self):
        pygame.init()
        self.game_window = pygame.display.set_mode((Constant.WIDTH, Constant.HEIGHT))
        self.clock = pygame.time.Clock()

    def game_loop(self):
        while Variable.game_start:
            control()
            if Variable.stage == 1:
                ContraMap.new_stage()
                ContraBill.new_player()

            if Variable.stage == 2:
                pass

            if Variable.stage == 3:
                pass

            Variable.all_sprites.draw(self.game_window)
            Variable.all_sprites.update()

            self.clock.tick(Constant.FPS)
            pygame.display.set_caption(f'魂斗罗  1.0    {self.clock.get_fps():.2f}')
            pygame.display.update()

        pygame.quit()
        sys.exit()


if __name__ == '__main__':
    main = Main()
    main.game_loop()
2、ContraMap.py

这里把第一关的全部地面碰撞体都测量并加载出来。

# ContraMap.py
import os
import pygame

from Config import Constant, Variable


class StageMap(pygame.sprite.Sprite):
    def __init__(self, order):
        pygame.sprite.Sprite.__init__(self)
        self.image_list = []
        self.order = order
        for i in range(1, 9):
            image = pygame.image.load(os.path.join('image', 'map', 'stage' + str(i) + '.png'))
            rect = image.get_rect()
            image = pygame.transform.scale(image, (rect.width * Constant.MAP_SCALE, rect.height * Constant.MAP_SCALE))
            self.image_list.append(image)
        self.image = self.image_list[self.order]
        self.rect = self.image.get_rect()
        self.rect.x = 0
        self.rect.y = 0
        self.speed = 0

    def update(self):
        if self.order == 2:
            print('纵向地图')
        else:
            if Variable.step == 0 and self.rect.x >= -Constant.WIDTH:
                self.rect.x -= 10
            if Variable.step == 1 and self.rect.x > -Constant.WIDTH * 2:
                self.rect.x -= 10
                if self.rect.x == -Constant.WIDTH * 2:
                    Variable.step = 2
                    Variable.all_sprites.add(Variable.collider)


def new_stage():
    if Variable.map_switch:
        stage_map = StageMap(Variable.stage - 1)
        Variable.all_sprites.add(stage_map)
        Variable.map_storage.add(stage_map)
        Variable.map_switch = False


class CollideGround(pygame.sprite.Sprite):
    def __init__(self, length, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.Surface((length * Constant.MAP_SCALE, 3))
        self.image.fill((255, 0, 0))
        self.rect = self.image.get_rect()
        self.rect.x = x * Constant.MAP_SCALE - Constant.WIDTH * 2
        self.rect.y = y * Constant.MAP_SCALE


Variable.collider83.add(
    CollideGround(511, 2176, 83),
    CollideGround(161, 2847, 83),
    CollideGround(64, 3296, 83)
)

Variable.collider115.add(
    CollideGround(736, 832, 115),
    CollideGround(128, 1568, 115),
    CollideGround(160, 1695, 115),
    CollideGround(128, 1856, 115),
    CollideGround(256, 1984, 115),
    CollideGround(224, 2656, 115),
    CollideGround(65, 3040, 115),
    CollideGround(64, 3264, 115),
    CollideGround(64, 3392, 115),
    CollideGround(128, 3808, 115)
)

Variable.collider146.add(
    CollideGround(97, 959, 146),
    CollideGround(66, 1215, 146),
    CollideGround(225, 2400, 146),
    CollideGround(96, 2976, 146),
    CollideGround(64, 3136, 146),
    CollideGround(160, 3424, 146),
    CollideGround(64, 3744, 146),
    CollideGround(32, 3936, 146)
)

Variable.collider163.add(
    CollideGround(95, 1440, 163),
    CollideGround(64, 2304, 163),
    CollideGround(32, 2912, 163),
    CollideGround(32, 2328, 163),
    CollideGround(32, 3328, 163),
    CollideGround(97, 3840, 163)
)

Variable.collider178.add(
    CollideGround(32, 1055, 178),
    CollideGround(32, 1151, 178),
    CollideGround(65, 2720, 178),
    CollideGround(64, 2816, 178),
    CollideGround(96, 3168, 178),
    CollideGround(63, 3648, 178),
    CollideGround(32, 3969, 178)
)

Variable.collider211.add(
    CollideGround(63, 1088, 211),
    CollideGround(63, 1407, 211),
    CollideGround(97, 2208, 211),
    CollideGround(192, 2528, 211),
    CollideGround(33, 3135, 211),
    CollideGround(33, 3295, 211),
    CollideGround(97, 3520, 211),
    CollideGround(242, 3807, 211)
)

Variable.collider.add(Variable.collider83, Variable.collider115, Variable.collider146, Variable.collider163,
                      Variable.collider178, Variable.collider211, Variable.collider231)
3、ContraBill.py
# ContraBill.py
import os
import pygame

from Config import Constant, Variable


class Bill(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image_dict = {
            'be_hit': [],
            'down': [],
            'jump': [],
            'oblique_down': [],
            'oblique_up': [],
            'run': [],
            'shoot': [],
            'stand': [],
            'up': []
        }
        for i in range(6):
            for key in self.image_dict:
                image = pygame.image.load(os.path.join('image', 'bill', str(key), str(key) + str(i + 1) + '.png'))
                rect = image.get_rect()
                image_scale = pygame.transform.scale(
                    image, (rect.width * Constant.PLAYER_SCALE, rect.height * Constant.PLAYER_SCALE))
                self.image_dict[key].append(image_scale)

            self.image_order = 0
            self.image_type = 'stand'

            self.image = self.image_dict[self.image_type][self.image_order]
            self.rect = self.image.get_rect()
            self.rect.x = 100
            self.rect.y = 100
            self.direction = 'right'

            self.now_time = 0
            self.last_time = 0

            self.falling = True
            self.jumping = False
            self.moving = False
            self.floor = 0

    def update(self):
        self.image = self.image_dict[self.image_type][self.image_order]
        if self.direction == 'left':
            self.image = pygame.transform.flip(self.image, True, False)

        if self.rect.top >= self.floor:
            for i in Variable.sprite_storage:
                Variable.collider.add(i)
                Variable.sprite_storage.remove(i)

        key_pressed = pygame.key.get_pressed()
        if self.falling:
            self.fall()

        if self.jumping:
            self.jump()

        if self.moving:
            self.move()

        self.order_loop()

        collider_ground = pygame.sprite.groupcollide(Variable.player_sprites, Variable.collider, False, False)
        for p, l in collider_ground.items():
            self.floor = l[0].rect.top
            p.rect.bottom = self.floor
            if key_pressed[pygame.K_d]:
                self.direction = 'right'
                self.moving = True
                if key_pressed[pygame.K_w]:
                    self.image_type = 'oblique_up'
                elif key_pressed[pygame.K_s]:
                    self.image_type = 'oblique_down'
                elif key_pressed[pygame.K_j]:
                    self.image_type = 'jump'
                    self.jumping = True
                    self.falling = False
                else:
                    self.image_type = 'run'
            elif key_pressed[pygame.K_a]:
                self.direction = 'left'
                self.moving = True
                if key_pressed[pygame.K_w]:
                    self.image_type = 'oblique_up'
                elif key_pressed[pygame.K_s]:
                    self.image_type = 'oblique_down'
                elif key_pressed[pygame.K_j]:
                    self.image_type = 'jump'
                    self.jumping = True
                    self.falling = False
                else:
                    self.image_type = 'run'

            elif key_pressed[pygame.K_w]:
                self.image_type = 'up'
                self.moving = False

            elif key_pressed[pygame.K_s]:
                self.image_type = 'down'
                self.moving = False

            else:
                self.image_type = 'stand'
                self.moving = False

            if key_pressed[pygame.K_s] and key_pressed[pygame.K_j]:
                self.image_type = 'oblique_down'
                Variable.collider.remove(l[0])
                Variable.sprite_storage.add(l[0])

    def order_loop(self):
        self.now_time = pygame.time.get_ticks()
        if self.now_time - self.last_time >= 100:
            self.image_order += 1
            if self.image_order > 5:
                self.image_order = 0
            self.last_time = self.now_time

    def move(self):
        if self.direction == 'right' and self.rect.right <= Constant.WIDTH - 80 * Constant.MAP_SCALE:
            self.rect.x += Constant.SPEED_X
            if self.rect.centerx >= Constant.WIDTH / 2:
                x = self.rect.centerx - Constant.WIDTH / 2
                for j in Variable.map_storage:
                    if j.rect.right >= Constant.WIDTH:
                        for i in Variable.all_sprites:
                            i.rect.x -= x

        elif self.direction == 'left' and self.rect.left >= 40 * Constant.MAP_SCALE:
            self.rect.x -= Constant.SPEED_X
            if self.rect.centerx <= Constant.WIDTH / 2:
                x = Constant.WIDTH / 2 - self.rect.centerx
                for j in Variable.map_storage:
                    if j.rect.left <= -Constant.WIDTH * 2:
                        for i in Variable.all_sprites:
                            i.rect.x += x

    def jump(self):
        Constant.SPEED_Y += Constant.GRAVITY
        self.rect.y += Constant.SPEED_Y
        if Constant.SPEED_Y == 0:
            self.jumping = False
            self.falling = True
            Constant.SPEED_Y = -10

    def fall(self):
        self.rect.y += Constant.GRAVITY * 10


def new_player():
    if Variable.step == 2 and Variable.player_switch:
        bill = Bill()
        Variable.all_sprites.add(bill)
        Variable.player_sprites.add(bill)
        Variable.player_switch = False
4、Config.py
# Config.py
import pygame


class Constant:
    WIDTH = 1200
    HEIGHT = 720
    FPS = 60

    MAP_SCALE = 3
    PLAYER_SCALE = 2.5

    SPEED_X = 3
    SPEED_Y = -10
    GRAVITY = 0.5


class Variable:
    all_sprites = pygame.sprite.Group()
    player_sprites = pygame.sprite.Group()

    collider = pygame.sprite.Group()
    collider83 = pygame.sprite.Group()
    collider115 = pygame.sprite.Group()
    collider146 = pygame.sprite.Group()
    collider163 = pygame.sprite.Group()
    collider178 = pygame.sprite.Group()
    collider211 = pygame.sprite.Group()
    collider231 = pygame.sprite.Group()

    sprite_storage = pygame.sprite.Group()
    map_storage = pygame.sprite.Group()

    game_start = True
    map_switch = True
    player_switch = True

    stage = 1
    step = 0

以上代码完成，我们的主角Bill终于可以连跑带跳游览整个地图，并终于站在了第一关的关头。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1605608.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java中类装载的执行过程

Java中类装载的执行过程

类装载的执行过程 类从加载到虚拟机中开始&#xff0c;直到卸载为止&#xff0c;它的整个生命周期包括了&#xff1a;加载、验证、准备、解析、初始化、使用和卸载这7个阶段。其中&#xff0c;验证、准备和解析这三个部分统称为连接&#xff08;linking&#xff09;。 1.加载 …
阅读更多...
《八》QSplitter拆分器以及QDockWidget窗口详解

《八》QSplitter拆分器以及QDockWidget窗口详解

QSplitter简介 QSplitter拆分器允许用户通过拖动子部件之间的边界来控制它们的大小。 单个拆分器可以控制任意数量的小部件。QSplitter的典型用法是创建几个小部件&#xff0c;并使用insertWidget()或addWidget()添加它们。 常用方法 默认情况下&#xff0c;QSplitter会动态…
阅读更多...
ollama大语言模型

ollama大语言模型

查看已经安装的大语言模型 ollama list运行大语言模型 ollama run llama2:latest
阅读更多...
【前端面试3+1】16 TCP与UDP的区别、如何清除浮动、哪些原因造成阻塞页面渲染、【相同的树】

【前端面试3+1】16 TCP与UDP的区别、如何清除浮动、哪些原因造成阻塞页面渲染、【相同的树】

一、TCP与UDP的区别 TCP&#xff08;Transmission Control Protocol&#xff09;和UDP&#xff08;User Datagram Protocol&#xff09;是两种常用的网络传输协议&#xff0c;它们有以下几点区别&#xff1a; 1、连接性&#xff1a; TCP是面向连接的协议&#xff0c;通信双方在…
阅读更多...
multiprocessing Process子进程会把非main的代码重新再次执行

multiprocessing Process子进程会把非main的代码重新再次执行

from funasr import AutoModel print("2222")def play_audio(text):print(text)if __name__ __main__:audio_process multiprocessing.Process(targetplay_audio, args("1111",))audio_process.start() # 启动进程audio_process_id audio_process.pid解…
阅读更多...
Android播放音频、视频

Android播放音频、视频

1、播放音频 <LinearLayout xmlns:android"http://schemas.android.com/apk/res/android"android:orientation"vertical"android:layout_width"match_parent"android:layout_height"match_parent" ><Buttonandroid:id"i…
阅读更多...
【Python基础】Redis

【Python基础】Redis

文章目录 [toc]进入Redis交互模式Redis服务测试切换仓库字符串Key命令HashListSetZSet数据添加数据查询数据更新数据删除查询存在的所有key 个人主页&#xff1a;丷从心 系列专栏&#xff1a;Python基础 学习指南&#xff1a;Python学习指南 进入Redis交互模式 redis-cliRed…
阅读更多...
ElasticSearch虚拟机安装（单机版）

ElasticSearch虚拟机安装（单机版）

1.下载7.10.2 下载链接&#xff0c;选择LINUX X86_64下载 2.创建用户 useradd es也可以使用系统默认用户&#xff08;非root&#xff09;,root用户会报错 3.解压 tar xvf elasticsearch-7.10.2-linux-x86_64.tar.gz假定目录在/home/es/elasticsearch-7.10.2-linux-x86_64 …
阅读更多...
Springboot整合nacos报错无法连接nacos

Springboot整合nacos报错无法连接nacos

报错信息&#xff1a;Nacos com.alibaba.nacos.api.exception.NacosException: Client not connected, current status:STARTING 关于这个报错的原因有很多&#xff1a;如Nacos未启动、网络问题、配置问题、版本不兼容问题等&#xff0c;我的报错原因主要是版本不兼容。 下面…
阅读更多...
TCP和UDP协议的区别

TCP和UDP协议的区别

1、定义 TCP协议的全称是Transmission Control Protocol&#xff08;传输控制协议&#xff09;&#xff0c;是一种面向连接的点对点的传输层协议。 UDP协议的全称是User Datagram Protocal&#xff08;用户数据报协议&#xff09;&#xff0c;为应用程序提供一种无需建立连接…
阅读更多...
更改docker镜像下载地址

更改docker镜像下载地址

一.简介 使用指令 sudo docker info 查看本机的docker镜像下载地址为 由于本机的var文件空间不足&#xff0c;因此&#xff0c;想更改他的存储地址&#xff0c;如下 二.开始操作 1.停止Docker服务&#xff1a; 执行命令 sudo systemctl stop docker 以及 sudo systemctl s…
阅读更多...
Python中的Super方法实现问题及解决方案

Python中的Super方法实现问题及解决方案

1、问题背景 在Python中&#xff0c;super方法用于在子类中调用父类的方法。Guido van Rossum曾给出了一个纯Python实现的super方法&#xff0c;以便更好地理解其工作原理。然而&#xff0c;在这个实现中&#xff0c;存在一个问题&#xff1a;当传入的对象不是要调用的父类的实…
阅读更多...
PTA L1-009 N个数求和 【C++】【辗转相除法】【Python】

PTA L1-009 N个数求和 【C++】【辗转相除法】【Python】

C&#xff1a; 辗转相除法&#xff1a; 每次算最小公倍数和最大公约数都是用的常规思路&#xff0c;本身是不会有错的&#xff0c;但是当数据很大时&#xff0c;就会出现错误&#xff0c;时间复杂度过高 辗转相除法&#xff0c;又称欧几里德算法&#xff08;Euclidean Algori…
阅读更多...
解决IDEA https://start.spring.io/连接不上

解决IDEA https://start.spring.io/连接不上

1.换成下边这个地址试试 https://start.springboot.io/2.换成阿里云试试&#xff0c;绝对可行&#xff0c;但是版本有点低 https://start.aliyun.com
阅读更多...
BackTrader 中文文档（二）

BackTrader 中文文档（二）

原文&#xff1a;www.backtrader.com/ 概念 平台概念 原文&#xff1a;www.backtrader.com/docu/concepts/ 这是平台某些概念的集合。它试图收集可在使用平台时有用的信息片段。 开始之前 所有小代码示例都假设以下导入可用&#xff1a; import backtrader as bt import ba…
阅读更多...
用一个寓言故事讲明白KMP算法

用一个寓言故事讲明白KMP算法

在讲寓言故事之前&#xff0c;先讲一下理论的前提知识&#xff0c;避免有些0基础而无法理解 前提知识 首先KMP算法是指在串中&#xff0c;想要快速找出主串里跟我们的模板串一样的位置的一种算法&#xff0c;其主要是解决最普通的BF算法中主串指针回溯的问题。 BF算法就是一…
阅读更多...
原生支付宝小程序 - 获取“dom“元素

原生支付宝小程序 - 获取“dom“元素

在支付宝中是不能获取到dom元素的&#xff0c;但是我门可以借助my.createSelectorQuery来实现 Page({data:{sq:{}},onLoad(){},onShow(){this.setData({sq: my.createSelectorQuery()})} })通过axml来查看 <view>{{sq}} </view>会发现它只是一个Object&#xff0…
阅读更多...
2024华中杯A题完整1-3问py代码+完整思路16页+后续参考论文

2024华中杯A题完整1-3问py代码+完整思路16页+后续参考论文

A题太阳能路灯光伏板朝向问题 &#xff08;完整版资料文末获取&#xff09; 第1小问&#xff1a;计算每月15日的太阳直射强度和总能量 1. 理解太阳直射辐射和光伏板的关系**&#xff1a;光伏板接收太阳辐射并转化为电能&#xff0c;直射辐射对光伏板的效率影响最大。 2. 收集…
阅读更多...
ssm058基于Java的共享客栈管理系统+jsp

ssm058基于Java的共享客栈管理系统+jsp

共享客栈管理系统的设计与实现 摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对房屋出租信息管理混乱&#xff0c;出…
阅读更多...
电脑技巧：如何把Edge浏览器扩展程序打包安装到其他浏览器

电脑技巧：如何把Edge浏览器扩展程序打包安装到其他浏览器

目录 1、进入浏览器扩展界面 2、找到Edge浏览器扩展插件的路径 3、找到需要扩展的插件ID 4、打开浏览器扩展插件目录 5、进入打包扩展界面 6、 安装到其他浏览器 大家日常使用浏览器的时候通常会安装很多浏览器插件&#xff0c;从而大大提升我们的办公效率&#xff0c;有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023