标签: game-development

我正在使用python中的多人游戏,它使用套接字库进行网络连接.该游戏将支持局域网上的游戏.一个玩家将设置服务器,LAN上的其他玩家将能够加入游戏.

为了实现这一点,我需要一种简单的方法让玩家发现可用服务器列表(玩家不应该被要求输入IP地址!).我首选的解决方案只使用python套接字库(以及标准库的其他部分).

我要找的是客户端和服务器代码:

• 客户端:向在LAN上某个端口上侦听的所有计算机广播其游戏请求

• server(s):以可用性回复客户端

根据Hans在下面的回答中提出的建议,可以使用UDP套接字来响应来自客户端的广播请求.

服务器:

#UDP server responds to broadcast packets
#you can have more than one instance of these running
import socket
address = ('', 54545)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
server_socket.bind(address)

while True:
    print "Listening"
    recv_data, addr = server_socket.recvfrom(2048)
    print addr,':',recv_data
    server_socket.sendto("*"+recv_data, addr)

客户:

#UDP client broadcasts to server(s)
import socket

address = ('<broadcast>', 54545)
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

data = "Request"
client_socket.sendto(data, address)
while True:
    recv_data, addr = client_socket.recvfrom(2048)
    print addr,recv_data …

我一直在阅读有关 wgpu-rs 的内容，如果用于构建本机桌面应用程序，它会使用 Vulkan、Dx12、Metal 等。鉴于此，我们是否可以期望 wgpu-rs 和直接使用 vulkan 之间具有可比的性能？我是图形编程领域的业余爱好者，但一直在 Rust 中开发一款游戏，一旦 wgpu-rs 支持就能够构建 wasm 的想法非常有吸引力。

目前我使用两个物体（彗星和飞船）的位置来检测它们是否发生碰撞。

fn collision_detection(
    comets: Query<&Transform, With<Comet>>,
    mut ships: Query<(&Transform, &mut ShipStatus), With<Ship>>,
) {
    for comet in comets.iter() {
        for (ship, mut status) in ships.iter_mut() {
            if comet.translation.x < ship.translation.x + 80.0 && comet.translation.y < ship.translation.y + 80.0
            && comet.translation.x > ship.translation.x - 80.0 && comet.translation.y > ship.translation.y - 80.0 {
                status.dead = true;
            }
        }
    }
}

但必须有更好的方法来做到这一点。

我正在开发一个程序生成系统，并且希望能够在 bevy rust 中逐帧修改网格。

我尝试过使用，assets.get_mut()但这会导致错误：help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `bevy::prelude::Res<'_, bevy::prelude::Assets<bevy::prelude::Mesh>>

任何帮助将不胜感激。

我当前的代码大致如下：

// Function which is executed at the very start

fn setup (
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>
) {

    let mut mesh = Mesh::from(bevy::prelude::shape::Icosphere { radius: 0.5, subdivisions: 10 });

    commands.spawn()
            .insert_bundle(PbrBundle {
                mesh: meshes.add(mesh),
                material: materials.add(colour.into()),
                ..Default::default()
            })
            .insert(Transform::from_xyz(0.0, 0.0, 0.0));
}

// Function which is …

我已经实现了在这个问题中标记为正确答案的算法：What to use for flow free-like game random level creation?

但是，使用该方法将创建可能具有多种解决方案的电路板。我想知道是否可以对算法进行任何简单的限制或修改以确保只有一种可能的解决方案？

所以，我真的不知道如何寻找我的问题的答案，我是一名自由职业者的游戏开发者，我的任务是做一个“钟摆平台”，这就是概念：

我尝试了很多不同的方法，例如在平台的侧面设置碰撞盒，当玩家进入碰撞盒时，平台会像钟摆一样移动。

但是，我总是遇到很多小故障，当我设法解决所有这些小故障时，运动感觉不自然。

这是我尝试的方法之一：

public IEnumerator RotatesTowardsLeft()
{
    while (transform.parent.eulerAngles.z < 25 || transform.parent.eulerAngles.z >= 330)//25
    {
        transform.parent.eulerAngles += new Vector3(0, 0, speed);
        yield return new WaitForSeconds(0.01f);
    }
    currentDirection = Directions.Left;
}

public IEnumerator RotatesTowardsRight()
{
    while (transform.parent.eulerAngles.z > 335 || transform.parent.eulerAngles.z < 30)
    {
        transform.parent.eulerAngles += new Vector3(0, 0, -speed);
        yield return new WaitForSeconds(0.01f);
    }
    currentDirection = Directions.Right;
}

所以，如果有人可以帮助我，那将意味着很多，因为我觉得我没有选择了......

我正在创建一个基本游戏，但我的代码中出现键盘响应问题。当你点击开始时，立方体会一直沿着你按下的箭头键的方向移动，但我希望它移动你用箭头键按下的任何方向，如果没有按下任何键，它就会停止。有人可以告诉我我的代码中有什么错误以及如何正确执行吗？

这是代码：

import  pygame
import  time
import  sys
import  pygame.event as EVENTS
from  pygame.locals import *
import  random

print("Welcome to the prototype of rpg game -Made by Adam Pospíchal.")

pygame.init()

sirka = 800
vyska = 800

okno = pygame.display.set_mode((sirka,vyska))
pygame.display.set_caption("RPG GAME")
#PARAMETRE OKNA#

#PARAMETRE OKNA#

#PARAMETRE KOCKY HRACA#

#PARAMETRE MENU#

#farby - RGB#
RM = 255
GM = 255
BM = 0


player_r = 0
player_g = 255
player_b = 0

player_height = 20 …

我在画布上绘制了一个等距网格。它使用 30 度角偏移，我使用一些脚本来绘制基本网格。对于这个网格，我投影了一个具有 40x40 平铺尺寸的平面网格。

gridRows = 10;
gridCols = 10;
tileSize = 40;

gridWidth = gridCols * tileSize;
gridHeight = gridRows * tileSize;

canvasWidth = tileSize * (gridCols + gridRows) * Math.sqrt(3) / 2;
canvasHeight = tileSize * (gridRows + gridCols) / 2;

canvasOffset = tileSize * gridRows * Math.sqrt(3) / 2;

function carToIso(x, y) {
      // Convert cartesian (x, y) to isometric coordinates
      return [
        Math.round((x - y) * Math.sqrt(3) / 2 + canvasOffset),
        Math.round((x + y) / …

首先感谢您花时间查看此内容 - 我们感谢您的任何意见！

关于我们现在面临的问题：\n在过去的几个月里，我们在 Android 上的游戏应用程序中遇到了随机 fps 下降到接近于零的情况，并且到目前为止尚未成功调试该问题。它完全随机发生（有时在 3 分钟后，有时在 3 小时后），感觉就像冻结一样 - 但实际上 FPS 在仍在运行时下降得非常快。\n我们已经花了相当多的时间使用各种工具进行调试和分析。现在我们希望您能帮助我们并从我们的数据中得出新的结论。

版本：

\n
• Unity版本：2020.3.30f1
\n
• 用户计划：10.8.1
\n

线索：

\n
• 这不是完全冻结。如果您等待足够长的时间，新的帧就会被渲染。
\n
• 首先，帧时间变为 30 毫秒、50 毫秒、100 毫秒、500 毫秒、1000 毫秒、3 分钟、5 分钟等 - 在很短的时间内
\n
• 该问题已在不同的 Android 设备上重现（例如 OnePlus 6）
\n
• 在统一分析器中，我们可以看到，当问题发生时，主线程似乎正在等待渲染线程上的“gfx.presentframe”
\n
• 负载没有实际增加（您可能在同一场景中闲置 30 分钟，一切都很好，然后 fps 突然下降。我们也没有看到多边形、内存使用量增加，分析器中的任何内容都没有增加）
\n
• 问题发生在屏幕上具有不同对象的不同场景等中
\n
• 问题随机发生，有时在运行应用程序 5 分钟后，有时在运行应用程序 2 小时后。它似乎与设备变热或进入电源安全模式无关
\n
• 问题不需要任何输入/交互。它只是在让应用程序空闲时发生
\n
• 在 ARM mobile studio 图形分析器中，我们可以看到，一旦问题发生，eglGetCurrentContext() 和下一个命令 (eglGetSyncAttribKHR ) 之间就会有约 3 分钟（或更长）的间隙 - 然而命令本身只需要几个 …

我很难确定如何将游戏中特定回合的游戏状态转换为代表该回合所采取的动作的有限动作序列。我希望得到关于如何做到这一点的建议。

注意：游戏现已上线！如果有人想尝试，请访问： https: //mystikaze.com
（我最终实现了一种用于存储游戏动作的算法，该算法可能不完全有效，但我认为确实可以保证任何给定回合的动作列表不能被无界/无限长）。

游戏规则相对简单。有一个六角形棋盘，其中六角形属于 2 个玩家。在任何给定的回合中，棋子可能已经存在于棋盘上，已在上一回合中购买，或者它们可以被购买到棋盘上（黄色棋子代表其在本回合被购买到棋盘上）。

这些棋子是“活跃的”，并且仍然可以移动。碎片也可以组合起来，并且仍然保持“活跃”状态。它们可以通过将现有的一块移动到另一块上或通过购买新的块到现有的块上来组合。组合后，目标六角形上将存在升级后的棋子。棋子可以有 3 种强度；X、Y 和 Z。X 与 X 结合得到 Y，X 与 Y 结合得到 Z。

片段可以继续像这样合并并保持“活跃”。一个棋子可以移动到其自己领土内的另一个六角形并保持“活跃”。当一个棋子被移动以捕获其他玩家的六角形时，它就不再是“活跃的”。此后它无法移动，但仍然可以结合。下面的绿色表示不活动的部分。

一个棋子也可以直接召唤到另一个棋子之上，从而产生升级的棋子（如果它已经处于活动状态，则它保持活动状态；如果它处于非活动状态，则它保持非活动状态）：

现在，这很容易在游戏状态中表示；只需更新棋子和棋盘的状态以反映当前的真实情况即可。只要理论上允许该移动序列是无界的，就可以很容易地将其转换为一系列移动。碎片可以保持活跃并无限地来回移动。当然，我想限制动作的顺序。这就是我遇到麻烦的地方。我有以下2个动作：

• 将棋子移动到指定位置
• 将棋子召唤到指定位置

如何将玩家所做的动作转换为有限的动作序列，以代表玩家实际所做的事情，从而达到最终状态？我不知道我是否遗漏了一些东西，但这似乎变得几乎不可能复杂到弄清楚。如果您有棋子在自己的区域内移动并保持活动状态，您可能会认为您可以将移动就地更新到新坐标，而不是向新坐标添加新移动，但如果有另一个移动，其中一块与另一块结合形成一个升级块，它依赖于第一块移动到其第一组坐标？现在就地更新移动坐标意味着第二个组合移动成为常规移动，因为它现在移动到空六角形上，但它应该仍然是组合移动（棋盘状态实际上是已移动到新坐标）。

从概念上讲，应该始终存在可以代表任何操作的有限移动序列。然而，我发现很难弄清楚如何编写一个算法来自动执行此操作。我认为至少可以防止移动的无限性质的算法是说“如果最近的移动不是组合或捕获操作，则更新一个棋子的最近移动，而不是将新移动添加到列表中”。这应该始终导致移动集正确创建游戏状态，并防止无限循环。然而，这仍然可能导致相当多的变动。例如，如果你在一个领土上有 10 个棋子，你可以移动所有 1 个棋子，捕获 1 个棋子，移动剩余的 9 个棋子，将一个棋子与另一个棋子组合，移动剩余的 8 个棋子等等，这可能会导致 10 个棋子的移动次数超过 60 次。如果有一种算法可以把这个问题降低一点，那就太好了，而且我仍然不能 100% 确定即使这个算法也没有一些无法工作的边缘情况。

我是否缺少一种相对直接的方法来解决这个问题？规则必须保持不变，但我愿意接受有关引入新移动类型的建议，如果这也有助于解决问题的话。