Максим Фисман's questions

我想以水平线的形式制作一个时间顺序图表，事件分支从该水平线以一定角度延伸（有点像火车车厢中的地铁线路图）：

我写了这个：

.chrono-line-window {
  width: 100%;
  height: 400px;
  border-radius: 15px;
  box-shadow: 0 0 15px 5px rgba(0, 0, 0, 0.25) inset;
  overflow-x: auto;
  padding: 0 70px 0 70px;
  display: flex;
  align-items: center;
}

.chrono-line {
  flex: 0 0 1000px;
  height: 10px;
  background-color: #333;
  display: flex;
  align-items: center;
}

.sub-line {
  width: 200px;
  height: 5px;
  background: #333;
  margin: 3px;
}

.sub-line:before {
  content: "";
  display: block;
  width: 20px;
  height: 20px;
  border-radius: 50%;
  background: #333;
}

.top-branch .sub-line:before {
  transform: translate(-50%, -40%);
}

.bottom-branch .sub-line:before {
  transform: translate(-45%, -35%);
}

.edge-circle {
  width: 25px;
  height: 25px;
  border-radius: 50%;
  background: #333;
}

.edge-circle:first-child {
  transform: translate(-50%, 0px);
}

.edge-circle:last-child {
  margin-left: auto;
  transform: translate(50%, 0px);
}

.branch-container {
  width: 200px;
}

.branch {
  text-align: center;
  transform-origin: left center;
}

.top-branch {
  transform: translateY(-1.5px) rotate(45deg);
}

.bottom-branch {
  transform: translateY(3px) rotate(-45deg);
}

.branch p {
  font-size: 16px;
  margin-left: 40px;
  margin-right: 20px;
}

.branch p:first-child {
  font-weight: 600;
}

.branch p:last-child {
  font-weight: 300;
}

<div class="chrono-line-window">
  <div class="chrono-line">
    <div class="edge-circle"></div>
    <div class="branch-container top-branch-container">
      <div class="branch top-branch">
        <p>Name of procedure</p>
        <div class="sub-line"></div>
        <p>01.01.2000</p>
      </div>
    </div>
    <div class="branch-container">
      <div class="branch bottom-branch">
        <p>Name of procedure</p>
        <div class="sub-line"></div>
        <p>01.01.2000</p>
      </div>
    </div>
    <div class="branch-container top-branch-container">
      <div class="branch top-branch">
        <p>Name of procedure</p>
        <div class="sub-line"></div>
        <p>01.01.2000</p>
      </div>
    </div>
    <div class="branch-container">
      <div class="branch bottom-branch">
        <p>Name of procedure</p>
        <div class="sub-line"></div>
        <p>01.01.2000</p>
      </div>
    </div>
  </div>
</div>

但由于.chrono-line设置了y display: flex，线（.branch-container）严格地水平地生成了一条又一条，并且我想手动设置 X 坐标。

当然，您可以计算边距，但将来我计划在 JS 中生成分支，并且我想根据分支上事件的日期在一行中设置它们的 X 位置，例如margin-left: N px, где N=ширина_ветки*(дата_события-дата_начала_линии)/(дата_конец_линии-дата_начала_линии)

逻辑教学应用：玩家可以从逻辑门组装电路（电路）。我希望他能收集到某种锁链，然后将它们合二为一。

例如，我们组装一个由两个门（AND 和 NOT）组成的电路，并将其组合成一个 NAND 门：

在这种情况下，每个阀门可以有一个或多个输入（input）和一个或多个输出（outputs）。

我想不通怎么写这样的门类。这是我的想法：

1. 创建委托：'委托列表 GateFunction(List)'

2. 门类包含一个“GateFunction func”字段，该字段定义将输入转换为输出的函数。

3. 门类包含一个“List _inputs”数组，该数组包含对连接到此门的输入的先前门的输出的引用。

一个阀门可以有多个输出是非常重要的，一个阀门的不同输出可以转到不同的阀门。

我需要这样一种体系结构，该类的每个实例都存储一个对基本函数进行操作的 SPECIFIC func 函数。

最主要的是，在运行时，用户将构建并保存他自己的、新的、自定义的阀门，包括以前创建的（或基本的：和/或/不）。

我将不胜感激一般建议和代码。也许我错过了一些方便的明显模式......

想法和截图来自 Sebastian Lague 视频 ( https://youtu.be/QZwneRb-zqA )。它完美地展示了我需要 4 到 5 分钟的时间。

UPD：解释示例。场上的玩家可以从可用的方块中收集左边的方案，点击“创建”按钮，得到右边对应的方块。同时可以看到，左边的所有功能都打开了，也就是可以连接到原来的联系人（屏幕左边第一个截图）。使用鼠标按钮打开和关闭这些联系人。也就是说，这些触点不包含在阀门本身中。因此，有必要能够告诉完成的、组装好的阀门其输入端连接到哪些触点。

UPD2：通过单击“创建”按钮，阀门应保存到菜单中，以便以后可以从那里获取和使用：

我正在使用AI minimax算法来玩跳棋。
为了获得最佳性能，我使用 alpha-beta 剪辑。

由于在检查器中很难预测在特定位置需要什么深度的搜索，我想使用迭代加深：搜索首先发生在深度 1，然后是 2、3，依此类推。

据我了解，迭代加深的意思是，当计算到n的深度时，我们使用之前执行的计算到n-1的深度，其结果存储（在哈希表/文件中...... )

但是，我并不完全清楚我需要在这个哈希表中存储什么？我应该保存在 minimax 过程中出现的所有位置还是只保存起始深度的位置？

现在我的程序只是按顺序遍历所有深度，而不以任何方式使用先前较不深度计算的结果。

class AI:
    def get_best_move (self, board, time_limit):
        self.analysed_positions = 0
        self.best_move = None
        self.calculation_process = True

        calculation_process = threading.Thread(target=self.iterative_deepening_minimax, args=(board, ))
        calculation_process.start()
        calculation_process.join(time_limit)
        self.calculation_process = False

        return self.best_move


    def iterative_deepening_minimax (self, board):
        for depth in range(2, 30):
            if self.calculation_process:
                # Начинаем поиск на глубине depth, который возвращает лучший ход в этой позиции
                self.best_move = self.minimax(board, depth, -INFINITY, INFINITY, board.whitesMove)[1]
            else:
                break


    def minimax (self, board, depth, alpha, beta, maximizingPlayer):
        if self.calculation_process == False:
            return (0, None)

        board.find_all_moves()

        game_state = board.get_game_state()
        if game_state != STATE_OK:
            self.analysed_positions += 1
            return (INFINITY + depth, None) if game_state == WHITE_WIN else (-INFINITY - depth, None)
        if depth == 0:
            self.analysed_positions += 1
            eval = self.evaluate(board)
            return (eval, None)

        bestMove = None
        if maximizingPlayer:
            maxEval = -INFINITY
            for move in board.moves:
                next_pos = Board(board, search_all_moves=False)
                next_pos.make_move(move)
                next_pos.change_turn()

                eval = self.minimax(next_pos, depth - 1, alpha, beta, False)[0]
                if eval > maxEval:
                    maxEval = eval
                    bestMove = move
                # Pruning
                alpha = max(alpha, eval)
                if beta <= alpha:
                    break
            return (maxEval, bestMove)

        else:
            minEval = INFINITY
            for move in board.moves:
                next_pos = Board(board, search_all_moves=False)
                next_pos.make_move(move)
                next_pos.change_turn()

                eval = self.minimax(next_pos, depth-1, alpha, beta, True)[0]
                if eval < minEval:
                    minEval = eval
                    bestMove = move
                # Pruning
                beta = min(beta, eval)
                if beta <= alpha:
                    break

            return (minEval, bestMove)

    # Возвращает статическую оценку позиции
    def evaluate():
        ...

对于玩家可以收集的物品，我有一个 ScriptableObject。它可以是硬币、棍子、石头、椰子等等。这样的对象具有名称、精灵和类型：

public enum FancyItemType
{
    Coin, Stick, Stone, Coconut
}

[CreateAssetMenu(fileName = "New Fancy Item", menuName = "New item", order = 51)]
public class FancyItem : ScriptableObject
{
    public FancyItemType Type;
    public Sprite Sprite;
    public string Name;
}

我在单元中创建并配置了这些对象。我想通过枚举 Enum 来接收这样的 FancyItem。例如，我想给玩家 10 根棍子：

void ReceiveBonus (FancyItemType type, int amount) {
    // Эта функция принимает ТИП предмета, который игроку надо выдать
    // Функция должна каким-то образом узнать спрайт и название предмета по типу
}
...
ReceiveBonus(FancyItemType.Stick, 10); // Передаем тип предмета -- палка, 10 штук

如何从枚举中获取包含所有数据的 FancyItem：精灵和名称？

我有这个想法：创建一个类，我将在检查器中向其中抛出对 ScriptableObject 的引用，它将通过 Enum 发出必要的引用：

public class FancyItemHelper : MonoBehaviour {
    [SerializeField] private FancyItem Coin, Stick, Stone, Coconut;

    public FancyItem GetItem (FancyItemType type) {
        switch (type) {
            case FancyItemType.Coin:
            return Coin;
            case FancyItemType.Stick:
            return Stick;
            case FancyItemType.Stone:
            return Stone;
            case FancyItemType.Coconut:
            return Coconut;
        }
    }
}

但是，这种方法对我来说太复杂了。我应该如何实现这个？

假设我有一个圆形物体。行星或苹果...

我想要一个圆形（或椭圆形）的棋子在比赛中被“击落”、“咬断”或以任何其他方式与其分离。它应该看起来像这样：

自然与物理有关。

这可能会发生很多次，理论上，即使是已经拍摄的片段的一部分也可以被拍摄。如何实施？

我找到了这个插图：

有一个大小为 的二进制数组 α（0 和 1）AxA。
我想得到一个大小为 β 的新二进制数组BxB。小2倍，因此数组
B比小4倍。 ABxBAxA

规则如下：

• 如果数组 α 的以下元素中的至少(x;y)一个等于 1，则数组 β的“像素”等于 1：(2x; 2y), (2x+1; 2y), (2x; 2y+1), (2x+1; 2y+1)

我有这个代码：

def compress_4_times (canvas):
    new_size = 16
    field = [[0]*new_size]*new_size

    for y in range(0, new_size):
        for x in range(0, new_size):
            _x, _y = 2*x, 2*y
            count_active = 0

            if is_pixel_active(canvas, _x, _y):
                count_active += 1
            if is_pixel_active(canvas, _x+1, _y):
                count_active += 1
            if is_pixel_active(canvas, _x, _y+1):
                count_active += 1
            if is_pixel_active(canvas, _x+1, _y+1):
                count_active += 1

            if count_active > 0:
                field[x][y] = True
            else:
                field[x][y] = False

    return field

给定一个数组 α 作为输入，应该返回 β。在此示例中，大小 α 为 32。

问题： 在循环过程中，一切正常，我检查了打印：一些像素变为真，而且显然是正确的。
但是该函数返回一个只有 False 的数组！它不包含任何 True!

似乎循环完成后，由于某种原因，该字段被重置。为什么会这样？

我希望我正确地推断出翻译规则。例如，我想转这个：

 0 0 0 1
 0 1 1 0
 0 0 0 1
 0 0 1 1

进入这个：

 1 1
 0 1

有一个 WordBlock 对象。它有VerticalLayoutGroup一个 ，它垂直定位子对象，和ContentSizeFitter，它将 RectTransform 的大小调整为子对象的数量。简单地说
，我希望灰色矩形在添加白框时向下拉伸。InputField

但是，从脚本创建对象后SynonymBlock，灰色框的大小不会改变，就好像它没有更新一样。要更新它，只需手动禁用-启用对象就足够了，但这是手动的。需要做什么才能在创建子对象后更新和调整自身大小？

可能已经有类似的问题了，但我找不到。如果是这样，请将其标记为重复，我会看看。

这么多 C++ 程序从何而来？

其中哪些可以删除？

当你安装他们安装什么程序？

在 C# 中是否可以将函数泛型限制为数字？例如，我想创建一个 Bounds 结构来保存某物的最小和最大边界。限制只能是数字，但可以是 and int, and float, and double, 等等。

我有想法通过结构泛型来实现这一点，并将该泛型限制为仅给定的类型，如下所示：

struct Bounds<T> where T: int, float, double {
    T Min, Max;
    // Далее можно будет, например реализовать метод проверки числа в границах:
    bool isInBounds (T num)
        => num >= Min && num <= Max;
}

但是，这样的实现会引发错误："int" не является допустимым ограничением. 似乎结构泛化根本不能成为约束！
如果没有，怎么可能引入这样的限制？
如果是这样，除了做这样的事情之外，是否有更漂亮的方法来引入类似的约束：

public struct Bounds <T> {
    T Min, Max;

    public Bounds<T> (T min, T max) {
        if (typeof(T) == typeof(int) || typeof(T) == typeof(float) || ...) {
            Min = min;
            ...
        }
        else 
            throw new Exception(...);
    }
}

我要创建的游戏是迷宫。简而言之，10x10海战中的2个场地，玩家轮流进行：他们可以从场地的一个单元格移动到任何相邻的单元格，构建所有访问单元格的“路线”。

问题是这样的：如何正确实现字段本身？我看到的额头上的想法：Field 字段精灵，它有 100 个带有碰撞器的子 FieldCell 对象和相应的脚本。但是，玩家仍然需要能够通过点击墙壁来布置迷宫的墙壁。10x10 的场地只有 81 面墙（不包括外面的墙）。结果总共有：2*(1+100+81)=364 个对象，在我看来，这是很多 => 方法是错误的。

那么如何实现这样的事情呢？也许您可以以某种方式获得相对于图像本身而不是屏幕/世界的单击图像的确切位置...

这篇文章包含对常见问题的解答，例如：

• 它们的作用是什么以及它们是如何工作的：OnCollisionEnter、OnTriggerEnter、OnCollisionEnter2D、OnTriggerStay、OnCollisionExit 等；
• 如何正确调用它们/为什么它们不起作用；
• 他们接受和返回什么；
• 为什么 OnCollision Stay /OnTrigger Stay /... 功能在几帧后停止工作，如果它们最初工作，并且对象甚至没有移动。

重要提示：它还描述了触发器是什么、它的作用以及它与常规对撞机的不同之处。

当我双击时，我希望屏幕上对象的大小发生变化。通过双击，我的意思是移动一根手指，例如向左移动，另一根向右移动，那么图像应该减小。

当然，我自己实现了减少和增加，但是你需要用这个双击来调用它。

我有这个想法：

1. 在更新中，我们检查手推车
2. 如果我们有 2 辆汽车，那么我们计算运动方向。
3. 如果运动方向相反，
   • 如果彼此 - 减少
   • 从彼此 - 增加。

但是如果有 3 辆汽车怎么办，这样做是否正确？也许有一些简单的选择？在互联网上关于 requestsизменение размеров свайпом等scale swipe，我没有找到选项......

UPD1：我找到了我想要的这张照片：

也许你可以用谷歌搜索一些东西来捏和松开。如果我发现了什么，我会发布一个答案并格式化问题。

很惊讶，但我在网上没有找到答案，也许我看起来很糟糕。

如果玩家还没有购买该图片负责的特定物品，我想制作一张原本为黑白的图片。我确信有比制作每个游戏图像的黑白副本更好的方法，但我不知道是否可以以编程方式使精灵去饱和。

我试图探索这个想法。特别是，我遇到了以下问题。但是，它考虑对整个场景进行去饱和处理，除了玩家使用相机上的后期效果，我需要对 SpriteRenderer 组件中的一些单个对象进行黑白处理。

我还看了这篇关于相对亮度的文章 ( https://en.wikipedia.org/wiki/Relative_luminance )。但是，我不太明白到底需要做什么，我完全不确定这是否有帮助。所以，为了不存在 XY 问题，我不会坚持认为这可以是一个解决方案。

我知道这类问题对于这个网站来说并不是最好的，但是我已经研究了一些东西，但还没有找到解决方案。也许 Unity 中的 AssetStore 中有一些特殊的组件或资产可以用于此类任务？

C# 中的类型基本上是一个类。

类型分为值类型和引用类型。值类型例如是 int、double、float、bool... 引用类型例如是类、接口或 - 在 Unity 中 - GameObject、Transform 等。

所以，如果一个值类型变量可以立即赋值: int a=3; bool b = false;，那么引用类型变量会用单词 new: 进行初始化Cat cat = new Cat("Tom");。

我想创建自己的类型来存储大量数字。它将以指数格式表示大于一百万的数字，例如3.67 E8- this 3.67*10^8，即 367000000.

现在我有这样的课：

public class LargeInt {
      public string Number;
    
(1)   public LargeInt (string number) => Number = number;
}

我可以使用构造函数通过 new: 来初始化它LargeInt price = new LargeInt("5 E10")，即 它是一个引用类型。

是否可以使类直接初始化：LargeInt price = "5 E10";？

然后这个类看起来像一个普通的 int。它将包含函数 ToString()、CompareTo()、运算符 +、-... 因为 int 不能处理大于 20 亿和尾部的数字。

制作游戏“三连冠”遇到了这样一个问题。我需要像这样销毁组：

Буква T:          Буква L:          Знак +:
1 1 1             1 0 0             0 1 0
0 1 0             1 0 0             1 1 1
0 1 0             1 1 1             0 1 0

其中一个是相同颜色的块，而零是其他一些。而且，这些字母可以旋转 90、-90、180 度。

到目前为止，我已经能够让程序明白，某个组合是这样一个字母：

// Определяем, сколько точек есть на одной линии при определенном X и Y
// conn - это массив Vector2Int единичек
        Dictionary<int, int> dictX, dictY;
        dictX = dictY = new Dictionary<int, int>();
        for (int i = 0; i < conn.Length; i++)
        {
            if (!dictX.ContainsKey(conn[i].x))
                dictX.Add(conn[i].x, 1);
            else dictX[conn[i].x]++;

            if (!dictY.ContainsKey(conn[i].y))
                dictY.Add(conn[i].y, 1);
            else dictY[conn[i].y]++;
        }

        if (dictX.ContainsValue(3) && dictY.ContainsValue(3))
            return true;
        else return false;

如果 3x3 数组包含一列 3 个 1 + 一行 3 个 1，则此函数返回 true。

不过，除了简单的破坏之外，我还想加一个特殊的加成，激活时会爆炸——这现在不那么重要了。我希望在这些线和一列 3 条线的交汇处形成这个奖金。那是：

2 : 1 1 1
1 : 1 0 0
0 :1 0 0
__ 0_1_2 _

奖金应出现在坐标 (0,2) 中 - 在交叉点处。

所以，我不明白如何找到这个交叉路口。为了不毫无根据和“没有自己的意识形态”，我可以说有一个想法来考虑那个（X，Y）的交集，在
(X,1) == 1 && (X, 2) == 1 && (X, 3) == 1... && (1, Y) == 1 && (2, y) == 1 && (3, Y) == 1...

但我不知道如何确切地实施它。我将添加我将列表提供给我指定的函数的输入。我用递归填充它。它存储了与我开始查看的与它直接接触或通过直接接触的那些间接接触的块相同颜色的所有块的位置；那些与那些直接接触的人接触的人，等等。简而言之，对于这样的数组：

1 1 0 0
0 1 0 1
0 1 0 0
1 1 0 0

conn = { (0,0), (0,3), (1,0), (1,1), (1,2), (1,3) } 如果从左下角开始搜索。



更新： conn 数组不必是 3x3。例如，它可以是这样的：

1 0 0 0
1 0 1 1
1 1 1 0

在这种情况下，必须再次删除字母 L，以便我们得到：

* 0 0 0
* 0 1 1
* * * 0

* 标记那些已被删除的块，因为它们组成了字母 L。

这个问题具有教育意义，但包含我的想法和我自己的半工作解决方案

锻炼：

给定一个由编号点和它们之间的线组成的模式。编写一个程序，它会告诉您是否可以在不举手且不画线两次的情况下绘制此图（在所有点和线上画一支笔）？

输入： 第一行包含数字 NNN - 点数（从 0 到 1000 的数字）。
第二行包含数字 MMM - 行数（从 0 到 1000 的数字）。
接下来是 MMM 线，每条线都包含由线连接的点数对（点从 1 开始编号，一对点之间可以画几条线）

输出： Yes - 如果你能画出这样的图片，否则No

我的想法：

根据图的欧拉性质，如果满足以下条件，则图中存在欧拉路径：

• 该图最多有 2 个奇数顶点
• 除了可能的一个之外，所有连接的组件都不包含边。

因此，需要做的就是在数组中写入每个顶点有多少条边，计算奇数顶点的数量，如果超过 2 个，则返回 No，否则返回 Yes。这是第一个条件。现在我有这样的代码通过 9/10 测试（除了 4）。

我的代码：

int main () {
    int n, m;
    cin >> n >> m;
    int num[n+1];
    
    for (int i = 1; i <= n; i++) num[i] = 0;
    
    int a;
    for (int i = 1; i <= m; i++) {
        for (int j = 0; j < 2; j++) {
            cin >> a;
            num[a]++;
        }
    }
    
    int oddNum = 0;
    bool answer = true;
    for (int i = 0; i < n; i++) {
        if (num[i] == 0) { answer = false; break; }
        else if (num[i] % 2 != 0) oddNum++;
        
    }
    if (answer) {
        if (oddNum > 2) answer = false;
        else answer = true;
    }
    cout << (answer ? "Yes" : "No");
}

问题和我的想法：

我认为问题出在关于连接组件的条件的第二部分，应该不超过1，但我不知道如何检查。也许通过蛮力，试图从每个点到达所有其他点？

我正在学习如何使用 json 文件序列化数据（这就是它应该被调用的）。我想保存计算机科学作业的文本及其答案。Json 文件包含以下文本：

{
    "all_tasks": {
        "IT_task": [
            {
                "tasks": [

                    "В одной из кодировок Unicode каждый символ кодируется 16 битами. Вова написал текст (в нём нет лишних пробелов):
«Ёж, лев, слон, олень, тюлень, носорог, крокодил, аллигатор — дикие животные».
Ученик вычеркнул из списка название одного из животных. Заодно он вычеркнул ставшие лишними запятые и пробелы — два пробела не должны идти подряд.
При этом размер нового предложения в данной кодировке оказался на 16 байтов меньше, чем размер исходного предложения. Напишите в ответе вычеркнутое название животного.",   
        
            "В одной из кодировок Unicode каждый символ кодируется 16 битами. Ваня написал текст (в нём нет лишних пробелов):
«Уфа, Азов, Пермь, Белово, Вологда, Камбарка, Соликамск — города России».
Ученик вычеркнул из списка название одного из городов. Заодно он вычеркнул ставшие лишними запятые и пробелы — два пробела не должны идти подряд.
При этом размер нового предложения в данной кодировке оказался на 22 байта меньше, чем размер исходного предложения. Напишите в ответе вычеркнутое название города России.",              

             "В одной из кодировок Unicode каждый символ кодируется 32 битами. Алёша написал текст (в нём нет лишних пробелов):
«Ток, фата, шляпа, колпак, диадема, кокошник - головные уборы».
Ученик вычеркнул из списка название одного из головных уборов. Заодно он вычеркнул ставшие лишними запятые и пробелы — два пробела не должны идти подряд.
При этом размер нового предложения в данной кодировке оказался на 24 байта меньше, чем размер исходного предложения. Напишите в ответе вычеркнутое название головного убора.",         

             "В одной из кодировок Unicode каждый символ кодируется 8 битами. Слава написал текст (в нём нет лишних пробелов):
«Уно, вист, нард, домино, реверси, мельница, монополия - настольные игры».
Ученик вычеркнул из списка название одной из настольных игр. Заодно он вычеркнул ставшие лишними запятые и пробелы — два пробела не должны идти подряд.
При этом размер нового предложения в данной кодировке оказался на 10 байтов меньше, чем размер исходного предложения. Напишите в ответе вычеркнутое название головного убора."         
                ],
                "answers": [
                    "Тюлень",
                    "Соликамск",
                    "Фата",
            "Мельница"
                ]
            }
        ]
    }
}

统一起来，我使用以下代码将此代码转换为具有 all_tasks 结构的类：

public void initializeTasksDictionaries ()
    {
        string path = Application.streamingAssetsPath + "/DataTask.game";
        
        StreamReader reader = File.OpenText(path);

        string jsonString = reader.ReadToEnd();
        all_tasks = JsonUtility.FromJson<Tasks>(jsonString).all_tasks;
    }

我得到一个错误： ArgumentException: JSON parse error: Invalid escape character in string. UnityEngine.JsonUtility.FromJson (System.String json, System.Type type) (at <1386288601af43018501cce2912f52f4>:0)...

也就是说，错误在于json文件，但我没有找到任何东西：所有的括号都到位，都正确，逗号也是......

通过实验，我发现添加换行符时出现错误？这是否意味着在 json 文件中我只能使用 \n 进行换行，但将文件中的所有文本写在一行上？

以下是这些短语：链接：0，链接：0，链接：0...它们确实干扰了函数的正常结构，因此它们连续排列，而不是通过一条线。此外，我绝对不需要有关功能链接数量的信息。有没有办法隐藏这些信息？也许在我正在为其编写脚本的 VisualStudio 或 Unity 的设置中？

我必须马上说我只是在学习虚幻引擎，所以这个问题可能看起来有点......

我希望能够用鼠标旋转相机，这样我就可以上下左右（在地板上，在天花板上）环顾四周。相机被蠕变到 Pawn，如下所示 ：

我添加了以下 AxisMappings： 即（至少据我了解）未来相机向左右旋转对应于鼠标沿 X 轴的移动，换句话说，左右，向上down rotation对应Y轴，更简单的up-down。

好的，在我的角色（第一张照片）上，我写了以下代码： 即根据鼠标的移动发生旋转。

结果：

• 左右旋转按预期正常工作
• 上下旋转根本不起作用。也就是说，无论我如何移动鼠标，相机都不会旋转，我看不到天空或地板。

请告诉我我的错误是什么以及如何解决？

PS人们经常写（我自己写）人们很少提供有关他们问题的信息。所以我决定附上更多的截图，以使其更清晰，虽然我不知道如何在蓝图上正确应用代码，所以我也附上了截图。

我希望在像 TowerDefence 这样的游戏中，炮塔发射的箭不是以直线飞向敌人，而是以弧线飞行：向上，向下。我自己做了飞行和旋转。箭头会旋转，因此无论它飞多远，它仍然能够准确地转动 1 次。但问题是我的箭头是逆时针旋转的，这仅适用于敌人/对手/怪物在塔左侧的情况。如果它在右边，那么物理上正确的箭头应该顺时针旋转。实现这一点的最佳方法是什么？只是比较X坐标并设置旋转，还是有一些更聪明的方法？