Bonjour, Habr! J'ai décidé que cela signifie essayer de réécrire le serveur que j'ai fait avec MS Orleans sur Akka.NET juste pour essayer cette technologie aussi. Si vous êtes intéressé par ce qui s'est passé auparavant, bienvenue chez cat.Code source
gitlab.com/VictorWinbringer/msorleansonlinegame/-/tree/master/Server/AkkaActorsÀ propos du jeu
Prise de vue avec le mode des match. Tous contre tout le monde. Vert # sont des adversaires. Jaune # est votre personnage. Red $ est une balle. La prise de vue est dans la direction dans laquelle vous vous déplacez.La direction du mouvement est contrôlée par les boutons ou flèches WASD. La barre d'espace est utilisée pour la prise de vue. Je veux faire un client graphique sur Three.js à l'avenir et mettre le jeu sur une sorte d'hébergement gratuit. Jusqu'à présent, il n'y a qu'un client de console temporaire.
Impressions personnelles
En général, ils résolvent tous les deux le problème lorsque vous souhaitez paralléliser vos calculs et n'utilisez pas de verrou (objet). En gros, tout le code que vous avez à l'intérieur de la serrure peut généralement être placé dans un acteur. De plus, chaque acteur vit sa propre vie et peut être redémarré indépendamment des autres. Dans le même temps, maintenir la viabilité de l'ensemble du système dans son ensemble. Tolérance aux pannes en général. Le MS Orleans m'a semblé plus pratique et plus affûté sous RPC. Akka.NET est plus simple et moins. Il peut être utilisé simplement comme une bibliothèque pour l'informatique asynchrone réactive. MS Orleans se demande immédiatement de sélectionner un port séparé et de configurer lui-même un hôte qui sera lancé au démarrage de l'application. Akka.NET n'a besoin de rien dans la configuration de base. J'ai connecté le paquet nuget et je l'ai utilisé. Mais MS Orleans a des interfaces fortement typées pour les acteurs (grains).En général, si j'avais besoin d'écrire un microservice entièrement sur les acteurs, je choisirais MS Orleans si, en un seul endroit, nous parallélisons simplement les calculs et évitons de synchroniser les threads via lock, AutoResetEventSlim ou quelque chose comme ça, Akka.NET. Alors oui, il y a une idée fausse prétendument que le serveur de tir Hallo est fait sur les acteurs. Oh, encore. Là, sur les acteurs, seulement n'importe quelle infrastructure comme les paiements et autres choses. La logique même du mouvement du joueur et de la frappe, c'est la logique du jeu, elle est calculée en C ++ monolith. Ici, dans un MMO comme WoW où vous choisissez clairement la cible et vous avez une recharge globale de presque 1 seconde pour tous les sorts qui utilisent souvent des acteurs.Code et commentaires
Le point d'entrée de notre serveur. 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);
}
}
Enregistrez notre système d'acteurs en 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;
}
});
Acteurs
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();
}
}
Messages transmis entre les acteurs
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(" !");
}
}