Olá Habr! Decidi que isso significa tentar reescrever o servidor que fiz com o MS Orleans no Akka.NET, apenas para experimentar essa tecnologia. Se você está interessado no que aconteceu antes, seja bem-vindo ao gato.Código fonte
gitlab.com/VictorWinbringer/msorleansonlinegame/-/tree/master/Server/AkkaActorsSobre o jogo
Fotografar com o modo des match. Tudo contra todos. Verde # são oponentes. Amarelo # é o seu personagem. $ Vermelho é uma bala. O disparo está na direção em que você está se movendo.A direção do movimento é controlada pelos botões ou setas WASD. A barra de espaço é usada para a foto. Quero criar um cliente gráfico no Three.js no futuro e colocar o jogo em algum tipo de hospedagem gratuita. Até o momento, existe apenas um cliente de console temporário.
Impressões pessoais
Em geral, ambos resolvem o problema quando você deseja paralelizar seus cálculos e não usa o bloqueio (objeto). Grosso modo, todo o código que você tem dentro da trava geralmente pode ser colocado em um ator. Além disso, cada ator vive sua própria vida e pode ser reiniciado independentemente dos outros. Ao mesmo tempo, mantendo a viabilidade de todo o sistema como um todo. Tolerância a falhas em geral. O MS Orleans me pareceu mais conveniente e aprimorado sob o RPC. O Akka.NET é mais simples e menos. Pode ser usado simplesmente como uma biblioteca para computação assíncrona reativa. O MS Orleans exige imediatamente a seleção de uma porta separada e a configuração de um host que será iniciado quando o aplicativo for iniciado. O Akka.NET não precisa de nada na configuração básica. Conectei o pacote de pepitas e o usei. Mas o MS Orleans digitou fortemente interfaces para atores (grãos).Em geral, se eu precisasse escrever um microsserviço inteiramente sobre os atores, escolheria o MS Orleans se, em um só lugar, paralelizarmos os cálculos e evitarmos a sincronização de threads por meio de lock, AutoResetEventSlim ou qualquer outra coisa assim, Akka.NET. Então, sim, há um equívoco, alegadamente, que o servidor de tiro Hallo é feito sobre os atores. Ah, ainda. Lá, para os atores, apenas qualquer infraestrutura, como pagamentos e outras coisas. A própria lógica do movimento do jogador e o acerto, que é a lógica do jogo, é calculada no monólito C ++. Aqui em um MMO como o WoW, onde você escolhe claramente um alvo e tem uma recarga global de quase 1 segundo em tamanho para todos os feitiços que costumam usar atores.Código e comentários
O ponto de entrada do nosso servidor. SignalR Hub
public class GameHub : Hub
{
private readonly ActorSystem _system;
private readonly IServiceProvider _provider;
private readonly IGrainFactory _client;
public GameHub(
IGrainFactory client,
ActorSystem system,
IServiceProvider provider
)
{
_client = client;
_system = system;
_provider = provider;
}
public async Task JoinGame(long gameId, Guid playerId)
{
var gameFactory = _provider.GetRequiredServiceByName<Func<long, IActorRef>>("game");
var game = gameFactory(gameId);
var random = new Random();
var player = new Player()
{
IsAlive = true,
GameId = gameId,
Id = playerId,
Point = new Point()
{
X = (byte)random.Next(1, GameActor.WIDTH - 1),
Y = (byte)random.Next(1, GameActor.HEIGHT - 1)
}
};
game.Tell(player);
}
public async Task GameInput(Input input, long gameId)
{
_system.ActorSelection($"user/{gameId}/{input.PlayerId}").Tell(input);
}
}
Registre nosso sistema de atores em DI:services.AddSingleton(ActorSystem.Create("game"));
var games = new Dictionary<long, IActorRef>();
services.AddSingletonNamedService<Func<long, IActorRef>>(
"game", (sp, name) => gameId =>
{
lock (games)
{
if (!games.TryGetValue(gameId, out IActorRef gameActor))
{
var frame = new Frame(GameActor.WIDTH, GameActor.HEIGHT) { GameId = gameId };
var gameEntity = new Game()
{
Id = gameId,
Frame = frame
};
var props = Props.Create(() => new GameActor(gameEntity, sp));
var actorSystem = sp.GetRequiredService<ActorSystem>();
gameActor = actorSystem.ActorOf(props, gameId.ToString());
games[gameId] = gameActor;
}
return gameActor;
}
});
Atores
Gameactor
public sealed class GameActor : UntypedActor
{
public const byte WIDTH = 100;
public const byte HEIGHT = 50;
private DateTime _updateTime;
private double _totalTime;
private readonly Game _game;
private readonly IHubContext<GameHub> _hub;
public GameActor(Game game, IServiceProvider provider)
{
_updateTime = DateTime.Now;
_game = game;
_hub = (IHubContext<GameHub>)provider.GetService(typeof(IHubContext<GameHub>));
Context
.System
.Scheduler
.ScheduleTellRepeatedly(
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(1),
Context.Self,
new RunMessage(),
ActorRefs.Nobody
);
}
protected override void OnReceive(object message)
{
if (message is RunMessage run)
Handle(run);
if (message is Player player)
Handle(player);
if (message is Bullet bullet)
Handle(bullet);
}
private void Update<T>(
List<T> entities,
T entity,
Func<object> createInitMessage,
Func<Props> createProps
)
where T : IGameEntity
{
if (!entity.IsAlive)
{
var actor = Context.Child(entity.Id.ToString());
if (!actor.IsNobody())
Context.Stop(actor);
entities.RemoveAll(b => b.Id == entity.Id);
}
else if (!entities.Any(b => b.Id == entity.Id))
{
Context.ActorOf(createProps(), entity.Id.ToString());
entities.Add(entity);
Context.Child(entity.Id.ToString()).Tell(createInitMessage());
}
else
{
entities.RemoveAll(b => b.Id == entity.Id);
entities.Add(entity);
}
}
private void Handle(Bullet bullet)
{
Update(
_game.Bullets,
bullet,
() => new InitBulletMessage(bullet.Clone(), _game.Frame.Clone()),
() => Props.Create(() => new BulletActor())
);
}
private void Handle(Player player)
{
Update(
_game.Players,
player,
() => new InitPlayerMessage(player.Clone(), _game.Frame.Clone()),
() => Props.Create(() => new PlayerActor())
);
}
private void Handle(RunMessage run)
{
var deltaTime = DateTime.Now - _updateTime;
_updateTime = DateTime.Now;
var delta = deltaTime.TotalMilliseconds;
Update(delta);
Draw(delta);
}
private void Update(double deltaTime)
{
var players = _game.Players.Select(p => p.Clone()).ToList();
foreach (var child in Context.GetChildren())
{
child.Tell(new UpdateMessage(deltaTime, players));
}
}
private void Draw(double deltaTime)
{
_totalTime += deltaTime;
if (_totalTime < 50)
return;
_totalTime = 0;
_hub.Clients.All.SendAsync("gameUpdated", _game.Clone()).PipeTo(Self);
}
}
BulletActor
public class BulletActor : UntypedActor
{
private Bullet _bullet;
private Frame _frame;
protected override void OnReceive(object message)
{
if (message is InitBulletMessage bullet)
Handle(bullet);
if (message is UpdateMessage update)
Handle(update);
}
private void Handle(InitBulletMessage message)
{
_bullet = message.Bullet;
_frame = message.Frame;
}
private void Handle(UpdateMessage message)
{
if (_bullet == null)
return;
if (!_bullet.IsAlive)
{
Context.Parent.Tell(_bullet.Clone());
return;
}
_bullet.Move(message.DeltaTime);
if (_frame.Collide(_bullet))
_bullet.IsAlive = false;
if (!_bullet.IsInFrame(_frame))
_bullet.IsAlive = false;
foreach (var player in message.Players)
{
if (player.Id == _bullet.PlayerId)
continue;
if (player.Collide(_bullet))
{
_bullet.IsAlive = false;
Context
.ActorSelection(Context.Parent.Path.ToString() + "/" + player.Id.ToString())
.Tell(new DieMessage());
}
}
Context.Parent.Tell(_bullet.Clone());
}
}
PlayerActor
public class PlayerActor : UntypedActor
{
private Player _player;
private Queue<Direction> _directions;
private Queue<Command> _commands;
private Frame _frame;
public PlayerActor()
{
_directions = new Queue<Direction>();
_commands = new Queue<Command>();
}
protected override void OnReceive(object message)
{
if (message is Input input)
Handle(input);
if (message is UpdateMessage update)
Handle(update);
if (message is InitPlayerMessage init)
Handle(init);
if (message is DieMessage)
{
_player.IsAlive = false;
Context.Parent.Tell(_player.Clone());
}
}
private void Handle(InitPlayerMessage message)
{
_player = message.Player;
_frame = message.Frame;
}
private void Handle(Input message)
{
if (_player == null)
return;
if (_player.IsAlive)
{
foreach (var command in message.Commands)
{
_commands.Enqueue(command);
}
foreach (var direction in message.Directions)
{
_directions.Enqueue(direction);
}
}
}
private void Handle(UpdateMessage update)
{
if (_player == null)
return;
if (_player.IsAlive)
{
HandleCommands(update.DeltaTime);
HandleDirections();
Move(update.DeltaTime);
}
Context.Parent.Tell(_player.Clone());
}
private void HandleDirections()
{
while (_directions.Count > 0)
{
_player.Direction = _directions.Dequeue();
}
}
private void HandleCommands(double delta)
{
_player.TimeAfterLastShot += delta;
if (!_player.HasColldown && _commands.Any(command => command == Command.Shoot))
{
var bullet = _player.Shot();
Context.Parent.Tell(bullet.Clone());
_commands.Clear();
}
}
private void Move(double delta)
{
_player.Move(delta);
if (_frame.Collide(_player))
_player.MoveBack();
}
}
Mensagens encaminhadas entre atores
public sealed class DieMessage { }
public sealed class InitBulletMessage
{
public Bullet Bullet { get; }
public Frame Frame { get; }
public InitBulletMessage(Bullet bullet, Frame frame)
{
Bullet = bullet ?? throw new ApplicationException(" ");
Frame = frame ?? throw new ApplicationException(" ");
}
}
public class InitPlayerMessage
{
public Player Player { get; }
public Frame Frame { get; }
public InitPlayerMessage(Player player, Frame frame)
{
Player = player ?? throw new ApplicationException(" !");
Frame = frame ?? throw new ApplicationException(" ");
}
}
public sealed class RunMessage { }
public sealed class UpdateMessage
{
public double DeltaTime { get; }
public List<Player> Players { get; }
public UpdateMessage(double deltaTime, List<Player> players)
{
DeltaTime = deltaTime;
Players = players ?? throw new ApplicationException(" !");
}
}