“我假装自己是一台计算机”是什么意思？你做了一些计算并发出哔哔声？基本 Unity 引擎占用了大约那么多空间。你为什么要关心空项目构建有多大？

好的，所以你没有禁用那么多包，但其中一些是编辑器包，所以不会出现在最终版本中。你需要记住，Unity 是一个引擎，所以你的应用程序不仅仅基于你的代码，它还有大量的 Unity 内容在后台运行，包括所有的物理、图形、声音等。所以即使是一个相当空的项目也包含相当多的内容，因为它必须能够完成所有这些事情。

当我尝试运行：cmd := exec.Command(\'bash\', \'-c\', \'docker ps\')outp, err := cmd.Output()log.Print(\'outp\', outp)if err != nil { log.Fatalln(\'

当我尝试运行时：

cmd := exec.Command("bash", "-c", "docker ps")
outp, err := cmd.Output()
log.Print("outp", outp)
if err != nil {
    log.Fatalln("Starting command failed:", err)
}

我遇到了错误：

exit status 127

即使安装了 docker 并 docker ps 从终端运行，如果我从 GO 文件运行代码（不使用 FN 项目），docker 也能正常工作。我认为使用 FN 项目将此代码作为函数会导致终端找不到 docker 等命令。

尝试以下代码：

cmd := exec.Command("docker", "ps")

出现此错误：

exec: \"docker\": executable file not found in $PATH

我也尝试了很多其他命令，但都 ls 不起作用。以前有人遇到过这个问题吗？我想这可能是我需要做的配置，或者是需要为 exec 命令或 FN 项目设置的路径问题...（我在 Ubuntu 22.04 上，一切都已更新）任何帮助都非常感谢。

[编辑] 感谢 Eik 执行建议的代码后，我的 FN 项目环境是：

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=2d6affdfa0d4
FN_MEMORY=128
FN_TYPE=sync
FN_FN_ID=01HZ5VWQM6NG8G00GZJ000003Q
FN_APP_ID=01HZ5VT0E7NG8G00GZJ000003P
FN_LISTENER=unix:/tmp/iofs/lsnr.sock
FN_FORMAT=http-stream
HOME=/home/fn

错误会非常清楚地告诉你哪里出了问题——检查可执行文件运行时 PATH 中的目录，并确保其中一个目录包含

...好的，我们得到了变量（谢谢！）——现在，您要运行的可执行文件位于哪里？（并确保这是失败的同一进程的环境变量转储——如果您的程序作为服务运行，f/e，它将具有与交互式 shell 不同的一组环境变量；类似地，如果您查看

背景我使用 Unity 编写代码，使用 C#8.0。我正在制作一款游戏，玩家通过打出具有不同效果的卡牌与敌人战斗（比如 Slay the Spire）。玩家选择卡牌，然后

背景

我在 Unity 中使用 C#8.0 进行编码。

我正在制作一款游戏，玩家通过打出具有不同效果的卡牌与敌人战斗（例如 Slay the Spire ）。玩家选择卡牌，然后选择卡牌的目标，然后（如果目标有效）调用卡牌的效果。

许多不同的游戏对象都可以成为卡片的目标：敌人、玩家角色、其他卡片、回合计数器、天空等。对于每个可以作为目标的对象，我都有它的类实现一个接口：

public interface ICardTarget
{
    public bool IsValidTarget(Card targetingCard);
}

类似地，许多不同的游戏对象可以打牌：玩家角色、敌人、障碍物等等。对于每个可以使用牌的对象，我让它的类实现一个接口：

public interface ICardUser
{
    //I don't have anything in here, this is really more of just a tag to group together any card users. Am I using interfaces right?
}

因此我的场景中的某些对象可能是：

public class Enemy : ICardTarget, ICardUser
{
    public bool IsValidTarget(Card targetingCard) {/*...*/}

    public string Species {get;set;}
}

public class PlayerCharacter : ICardTarget, ICardUser
{
    public bool IsValidTarget(Card targetingCard) {/*...*/}

    public float AttackSpeed {get;set;}
    public int Health {get;set;}
}

public class Weather : ICardTarget
{
    public bool IsValidTarget(Card targetingCard) {/*...*/}

    public bool IsCloudy {get;set;}
}

public class Boulder: ICardUser
{
    public int Mass {get;set;}
}

ETC。

每张卡牌都定义了哪些类型的目标有效。当玩家（或任何卡牌用户）选择一个对象作为卡牌的目标时，卡牌会将自身传递给 IsValidTarget 函数并接收布尔响应，以判断这是否是该卡牌的有效目标。

public class Card
{
    private ICardUser _user;     //reference to this card's user, set somewhere else
    private ICardTarget _target; //reference to this card's target, set somewhere else

    public void CheckTarget()
    {
        if (_target.IsValidTarget(this))
        {
            PerformCardEffect();
        }
    }

    private void PerformCardEffect() {/*whatever the card does*/}
}

到目前为止一切顺利！现在卡牌需要对目标对象产生效果，并且还可能对卡牌使用者产生影响。

问题

目前，卡牌对该目标对象唯一知道的是，它是一个有效目标（毕竟，ICardTarget 接口保证了这一切）。那么，我该如何执行 取决于目标类型的 ，而无需检查类型和向下转型？同样的问题也适用于卡牌用户：我只知道卡牌来自卡牌用户，我该如何与它交互而不进行向下转型？或者，向下转型并不是我认为的恶魔？

尝试的解决方案 1

我并不担心它，并在运行 PerformCardEffect() 时将目标/用户向下转换为实现它的类之一：

public class Card
{
    private ICardUser _user;
    private ITarget _target;

    public PerformCardEffect()
    {
        if (_target is Weather w)
        {
            w.IsCloudy = true;
        }
        if (_target is Enemy e)
        {
            print(e.Species);
        }
        if (_target is PlayerCharacter p)
        {
            p.AttackSpeed *= 2;
        }

       if (_user is PlayerCharacter p)
        {
            p.Health -= 3;
        }
       if (_user is Enemy e)
        {
            e.Health -= 5;
        }

        //etc.
    }
}

对于我来说，这是目前最容易进行迭代的，但我 知道 这是不受欢迎的。

尝试的解决方案 2

我修改了 ICardTarget/ICardUser，以便调用正确函数的责任从 Card 转移到它们身上：

public interface ICardTarget
{
    //...
    public void SelectCardEffectTarget(Card targetingCard);
    //...
}

public interface ICardUser
{
    public void SelectCardEffectUser(Card targetingCard);
}

public class Enemy : ICardTarget, ICardUser
{
    //...
    public void SelectCardEffectTarget(Card targetingCard)
    {
        targetingCard.PerformCardEffectTarget(this);
    }

    public void SelectCardEffectUser(Card targetingCard)
    {
        targetingCard.PerformCardEffectUser(this);
    }
    //...
}

public class PlayerCharacter : ICardTarget, ICardUser
{
    //...
    public void SelectCardEffectTarget(Card targetingCard)
    {
        targetingCard.PerformCardEffectTarget(this);
    }

    public void SelectCardEffectUser(Card targetingCard)
    {
        targetingCard.PerformCardEffectUser(this);
    }
    //...
}

public class Weather : ICardTarget
{
    //...
    public void SelectCardEffectTarget(Card targetingCard)
    {
        targetingCard.PerformCardEffectTarget(this);
    }
    //...
}

public class Card
{
    private ICardUser _user;
    private ITarget _target;

    public void CheckTarget()
    {
        if (_target.IsValidTarget(this))
        {
            _target.SelectCardEffectTarget(this);
            _user.SelectCardEffectUser(this);
        }
    }


    public void PerformCardEffectTarget(Weather w)
    {
        w.IsCloudy = true;
    }
    public void PerformCardEffectTarget(Enemy e)
    {
        print(e.Species);
    }
    public void PerformCardEffectTarget(PlayerCharacter p)
    {
        p.AttackSpeed *= 2;
    }

    public void PerformCardEffectUser(Enemy e)
    {
        e.Health -= 5;
    }
    public void PerformCardEffectUser(PlayerCharacter p)
    {
        p.Health -= 3;
    }

    //I have to include these calls so that any objects not caught by the above overloaded parameters default to doing nothing.
    public void PerformCardEffectTarget(ICardTarget t) {}
    public void PerformCardEffectUser(ICardUser u) {}
}

这似乎更好，但需要来回传递大量引用，这不是坏事，但对我来说感觉有点过分。我还必须在 Card 和接口上公开许多方法。

PS 有没有更简洁的编写 SelectCardEffectTarget()/SelectCardEffectUser() 的方法，这样我就不必在每个子类中重复相同的代码块了？我知道我可以将 ICardTarget/ICardUser 变成一个类，并在那里设置函数，这样它就可以被继承，但这似乎不是适合这种情况的层次结构。

尝试的解决方案 3（失败）

我试图利用通用类来指定目标/用户类型，但我无法找到一种方法来包含它并从中获取有用的功能。

public class CardEffectDetails<T,U> where T : ICardTarget where U : ICardUser
{
    T Target {get;set;}
    U User {get;set;}
}

public class Card
{
    private ICardTarget _target;
    private ICardUser _user;

    private void CreateEffectDetails()
    {
        CardEffectDetails<_target.GetType(), _user.GetType()> effectDetails = new();
        //what can I even do with this thing?
    }
}

我正在尝试在 Ubuntu 22.04.4 的 Raspberry Pi 上安装 Node-RED，使用在 Raspberry Pibash 上运行的脚本 <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/

我正在尝试使用 Ubuntu 22.04.4 在 Raspberry Pi 上运行

bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

但是当我运行这个脚本时什么也没有发生，如果我用 sudo 运行它，我得到-

bash: /dev/fd/63: No such file or directory

跑步后 curl -L https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered

我明白了

curl: (7) Failed to connect to localhost port 3128 after 1 ms: Connection refused

哪里可能存在问题？感谢您的帮助。

您是指 Fn Project ？

我假设你的函数在 docker容器 ，它 不包含docker二进制文件 .

我不清楚 ls 为什么无法执行

package main
 
import (
   "fmt"
   "os"
)
 
func main() {
   for _, value := range os.Environ() {
       fmt.Println(value)
   }
}

编辑： 你 $PATH 看起来很合理，输出是什么

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "/")
    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(string(out))
}

？

您要执行的操作称为“双重分派”，这是“多重分派”的特殊情况。C# 本身不支持此功能（尽管

@Peter 如您所见，答案中也很喜欢，它使用的是 alpine:edge。它不包含 bash，但包含 busybox，因此它有 ash、sh 和 ls。

谢谢您的回答，执行该代码后，我获得了环境变量并按照您的建议将它们添加到问题中。

问题，如果可能的话：如果 ICardTarget 暴露了它是什么类型的目标（可能是 TargetType 枚举），会有什么问题？您可以检查接口确保的枚举属性，而不是检查类型

如果您阅读 Eric Lippert 关于这个主题的文章， 他最终会推荐一种基于规则的方法。

这会将向目标打出一张牌的逻辑推入负责将逻辑结合在一起的类中。让我们尝试一下。（为简洁起见，这将是一个稍微简化的版本。）

首先让我们定义一些我们需要的基本接口：

public interface ITarget
{
    string Name { get; }
}

public interface ICard : ITarget
{
}

（显然实际的应用会稍微扩展这些。）

接下来，我们可以编写一个“规则集合”，它将封装和隐藏任何反射，并管理在目标上打牌的规则集合：

public sealed class RulesCollection
{
    public void AddRule<TCard, TTarget>(Action<TCard, TTarget> play) where TCard : ICard where TTarget : ITarget
    {
        string key = keyFromTypes(typeof(TCard), typeof(TTarget));
        _rules.Add(key, (card, target) => play((TCard)card, (TTarget)target));
    }

    public bool IsValidTarget(ICard card, ITarget target)
    {
        string key = keyFromObjects(card, target);
        return _rules.ContainsKey(key);
    }

    public void PlayCard(ICard card, ITarget target)
    {
        string key = keyFromObjects(card, target);

        if (_rules.TryGetValue(key, out var play))
            play(card, target);
        else
            throw new InvalidOperationException($"{card.Name} cannot be played on {target.Name}");
    }

    static string keyFromObjects(ICard card, ITarget target)
    {
        return keyFromTypes(card.GetType(), target.GetType());
    }

    static string keyFromTypes(Type cardType, Type targetType)
    {
        return cardType.FullName + "|" + targetType.FullName;
    }

    delegate void playDelegate(ICard card, ITarget target);

    readonly Dictionary<string, playDelegate> _rules = new Dictionary<string, playDelegate>();
}

（此类仅处理两种类型 - 卡片类型和目标类型。但是，您可以轻松扩展它以处理更多类型，从而实现更复杂的交互。）

现在让我们定义一些具体的游戏对象类型：

public sealed class Fireball : ICard
{
    public int Damage { get; set; } = 10;

    public string Name => "Fireball";
}

public sealed class Hurricane : ICard
{
    public string Name => "Hurricane";

    public int WindSpeed => 90;
    public int Rain      => 100;
}

public sealed class Player : ITarget
{
    public int    Health { get; set; } = 100;
    public string Name   => "Player";
}

public sealed class Enemy : ITarget
{
    public int    Health { get; set; } = 50;
    public string Name   => "Enemy";
}

public sealed class Weather : ITarget
{
    public string Name => "Weather";

    public int WindSpeed { get; set; } = 5;
    public int Rain      { get; set; } = 0;
}

现在我们可以创建一个类，它实际上实现了所有必要的卡片规则并使用来 RulesCollection 存储它们：

public sealed class RulesManager
{
    public RulesManager()
    {
        _rules.AddRule<Fireball, Player>(fireballPlayer);
        _rules.AddRule<Fireball, Enemy>(fireballEnemy);
        _rules.AddRule<Hurricane, Weather>(hurricaneWeather);
    }

    public bool IsValidTarget(ICard card, ITarget target) => _rules.IsValidTarget(card, target);
    public void PlayCard     (ICard card, ITarget target) => _rules.PlayCard     (card, target);

    static void hurricaneWeather(Hurricane hurricane, Weather weather)
    {
        weather.Rain      = hurricane.Rain;
        weather.WindSpeed = hurricane.WindSpeed;

        Console.WriteLine($"Hurricane set weather wind speed to {hurricane.WindSpeed} and rain to {hurricane.Rain}");
    }

    static void fireballPlayer(Fireball fireball, Player player)
    {
        player.Health -= fireball.Damage;
        Console.WriteLine($"Fireball damages player for {fireball.Damage}. Player health is now {player.Health}");
    }

    static void fireballEnemy(Fireball fireball, Enemy enemy)
    {
        enemy.Health -= fireball.Damage;
        Console.WriteLine($"Fireball damages enemy for {fireball.Damage}. Enemy health is now {enemy.Health}");
    }

    readonly RulesCollection _rules = new RulesCollection();
}

您应该能够看到如何扩展它以涵盖所有卡的交互。

最后我们可以练习一下规则：

public static void Main()
{
    var rules = new RulesManager();

    var player    = new Player();
    var fireball  = new Fireball();
    var hurricane = new Hurricane();
    var weather   = new Weather();
    var enemy     = new Enemy();

    rules.PlayCard(fireball, player);
    rules.PlayCard(fireball, enemy);
    rules.PlayCard(hurricane, weather);

    Console.WriteLine(rules.IsValidTarget(hurricane, weather)); // Prints "true".
    Console.WriteLine(rules.IsValidTarget(hurricane, player));  // Prints "false".

    rules.PlayCard(fireball, weather); // Throws exception with message "Fireball cannot be played on Weather". 
}

请参阅此 DotNetFiddle 以获取可运行的示例 :

输出结果为：

Fireball damages player for 10. Player health is now 90
Fireball damages enemy for 10. Enemy health is now 40
Hurricane set weather wind speed to 90 and rain to 100
True
False
Unhandled exception. System.InvalidOperationException: Fireball cannot be played on Weather
   at RulesCollection.PlayCard(ICard card, ITarget target)
   at RulesManager.PlayCard(ICard card, ITarget target)
   at Net48Console.Program.Main()

您的问题是您将 HTTPS_PROXY 或 HTTP_PROXY 环境变量设置为 http://localhost:3128 .

这告诉 curl 它需要通过在端口 3128 上运行的 HTTP 代理（根据端口号，最有可能是 squid）发送所有请求。

在这种情况下，我假设 squid 没有运行，因此 curl 不返回任何内容（并隐藏 -s 任何错误消息）。这导致 bash 立即返回，因为没有要运行的脚本。sudo 的错误是因为没有 stdout/stdin 流供 bash 读取。

您有以下几种选择：

• 需要启动 squid 代理
• 删除代理环境变量
• 设置环境变量以指向正确的代理

这不是 Node-RED 安装脚本或说明的问题。

啊，非常感谢！我并没有真正理解 Lippert 的规则方法在课堂上所要表达的意思，但您的具体示例非常棒！

是的，在 /etc/environment 中，我使用 http://localhost:3128 设置了代理变量，但我不知道为什么。我使用的是企业代理，也许这就是原因。

我确实还有另一个问题，但首先介绍一下背景：这是 Fiddle 的一个分支，我在其中添加了一个新的接口 IUser : ITarget 来表示卡的用户。我更新了与规则相关的类，以支持将这些用户数据纳入规则效果的能力（因此现在规则采用了）。我还创建了一个新的类，FireEnemy : Enemy，来演示卡牌使用者如何影响卡牌功能（例如，FireEnemy 使用 Fireball 时会对目标造成额外伤害）。[下一条评论中的问题]

。)。同样，如果将来我添加一个新的接口 IHasHealth，Player 和 Enemy 都会实现，会怎么样？理想情况下，我只需添加和我的问题：如何处理默认情况？也就是说，如果我不关心哪个（非 FireEnemy）用户正在使用 Fireball，该怎么办？Fireball 根本不引用其用户的数据，因此任何 IUser 都可以使用它。我似乎无法创建规则所有 IUser 都默认使用这个规则，我必须为 IUser 的每个实现类创建一个规则（

我知道 Cards 和 Users 都可以作为目标，因为它们都实现了 ITarget。但是如果 IUser 本身不显示行为，那为什么要有它呢？似乎 IUser（我个人可能会将其重命名为 ICardUser 以更明确）可以具有您正在寻找的行为。如果 ICardUser 需要您宣布它是什么类型的用户怎么办？它是 Player？敌人？还是 FireEnemy？如果您这样做，那么您就有一个接口，它公开了您需要的属性，并且这些属性将不可避免地在实现 Player、Enemy 等中设置。