Merge pull request #1 from amjadkofahi/pr/860

Author: amjadkofahi

77_Salvo/csharp/Coordinate.cs

@@ -0,0 +1,45 @@
+namespace Salvo;
+
+internal record struct Coordinate(int Value)
+{
+    public const int MinValue = 1;
+    public const int MaxValue = 10;
+
+    public static IEnumerable<Coordinate> Range => Enumerable.Range(1, 10).Select(v => new Coordinate(v));
+
+    public bool IsInRange => Value is >= MinValue and <= MaxValue;
+
+    public static Coordinate Create(float value) => new((int)value);
+
+    public static bool TryCreateValid(float value, out Coordinate coordinate)
+    {
+        coordinate = default;
+        if (value != (int)value) { return false; }
+
+        var result = Create(value);
+
+        if (result.IsInRange)
+        {
+            coordinate = result;
+            return true;
+        }
+
+        return false;
+    }
+
+    public Coordinate BringIntoRange(IRandom random)
+        => Value switch
+        {
+            < MinValue => new(MinValue + (int)random.NextFloat(2.5F)),
+            > MaxValue => new(MaxValue - (int)random.NextFloat(2.5F)),
+            _ => this
+        };
+
+    public static implicit operator Coordinate(float value) => Create(value);
+    public static implicit operator int(Coordinate coordinate) => coordinate.Value;
+
+    public static Coordinate operator +(Coordinate coordinate, int offset) => new(coordinate.Value + offset);
+    public static int operator -(Coordinate a, Coordinate b) => a.Value - b.Value;
+
+    public override string ToString() => $" {Value} ";
+}

77_Salvo/csharp/Extensions/IOExtensions.cs

@@ -0,0 +1,27 @@
+namespace Games.Common.IO;
+
+internal static class IOExtensions
+{
+    internal static Position ReadPosition(this IReadWrite io) => Position.Create(io.Read2Numbers(""));
+
+    internal static Position ReadValidPosition(this IReadWrite io)
+    {
+        while (true)
+        {
+            if (Position.TryCreateValid(io.Read2Numbers(""), out var position)) 
+            { 
+                return position; 
+            }
+            io.Write(Streams.Illegal);
+        }
+    }
+
+    internal static IEnumerable<Position> ReadPositions(this IReadWrite io, string shipName, int shipSize)
+    {
+        io.WriteLine(shipName);
+        for (var i = 0; i < shipSize; i++)
+        {
+             yield return io.ReadPosition();
+        }
+    }
+}

77_Salvo/csharp/Extensions/RandomExtensions.cs

@@ -0,0 +1,32 @@
+namespace Games.Common.Randomness;
+
+internal static class RandomExtensions
+{
+    internal static (Position, Offset) NextShipPosition(this IRandom random)
+    {
+        var startX = random.NextCoordinate();
+        var startY = random.NextCoordinate();
+        var deltaY = random.NextOffset();
+        var deltaX = random.NextOffset();
+        return (new(startX, startY), new(deltaX, deltaY));
+    }
+
+    private static Coordinate NextCoordinate(this IRandom random)
+        => random.Next(Coordinate.MinValue, Coordinate.MaxValue + 1);
+
+    private static int NextOffset(this IRandom random) => random.Next(-1, 2);
+
+    internal static (Position, Offset) GetRandomShipPositionInRange(this IRandom random, int shipSize)
+    {
+        while (true)
+        {
+            var (start, delta) = random.NextShipPosition();
+            var shipSizeLessOne = shipSize - 1;
+            var end = start + delta * shipSizeLessOne;
+            if (delta != 0 && end.IsInRange) 
+            {
+                return (start, delta);
+            }
+        }
+    }
+}

77_Salvo/csharp/Fleet.cs

@@ -0,0 +1,66 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Salvo;
+
+internal class Fleet
+{
+    private readonly List<Ship> _ships;
+
+    internal Fleet(IReadWrite io)
+    {
+        io.WriteLine(Prompts.Coordinates);
+        _ships = new()
+        {
+            new Battleship(io),
+            new Cruiser(io),
+            new Destroyer("A", io),
+            new Destroyer("B", io)
+        };
+    }
+
+    internal Fleet(IRandom random)
+    {
+        _ships = new();
+        while (true)
+        {
+            _ships.Add(new Battleship(random));
+            if (TryPositionShip(() => new Cruiser(random)) &&
+                TryPositionShip(() => new Destroyer("A", random)) &&
+                TryPositionShip(() => new Destroyer("B", random)))
+            {
+                return;
+            } 
+            _ships.Clear();
+        }
+
+        bool TryPositionShip(Func<Ship> shipFactory)
+        {
+            var shipGenerationAttempts = 0;
+            while (true)
+            {
+                var ship = shipFactory.Invoke();
+                shipGenerationAttempts++;
+                if (shipGenerationAttempts > 25) { return false; }
+                if (_ships.Min(ship.DistanceTo) >= 3.59)
+                {
+                    _ships.Add(ship);
+                    return true; 
+                }
+            }
+        }
+    }
+
+    internal IEnumerable<Ship> Ships => _ships.AsEnumerable();
+
+    internal void ReceiveShots(IEnumerable<Position> shots, Action<Ship> reportHit)
+    {
+        foreach (var position in shots)
+        {
+            var ship = _ships.FirstOrDefault(s => s.IsHit(position));
+            if (ship == null) { continue; }
+            if (ship.IsDestroyed) { _ships.Remove(ship); }
+            reportHit(ship);
+        }
+    }
+}

77_Salvo/csharp/Game.cs

@@ -0,0 +1,29 @@
+namespace Salvo;
+
+internal class Game 
+{
+    private readonly IReadWrite _io;
+    private readonly IRandom _random;
+
+    public Game(IReadWrite io, IRandom random)
+    {
+        _io = io;
+        _random = random;
+    }
+
+    internal void Play()
+    {
+        _io.Write(Streams.Title);
+
+        var turnHandler = new TurnHandler(_io, _random);
+        _io.WriteLine();
+
+        Winner? winner;
+        do 
+        {
+            winner = turnHandler.PlayTurn();
+        } while (winner == null);
+
+        _io.Write(winner == Winner.Computer ? Streams.IWon : Streams.YouWon);
+    }
+}

77_Salvo/csharp/Offset.cs

@@ -0,0 +1,25 @@
+namespace Salvo;
+
+internal record struct Offset(int X, int Y)
+{
+    public static readonly Offset Zero = 0;
+
+    public static Offset operator *(Offset offset, int scale) => new(offset.X * scale, offset.Y * scale);
+
+    public static implicit operator Offset(int value) => new(value, value);
+
+    public static IEnumerable<Offset> Units
+    {
+        get
+        {
+            for (int x = -1; x <= 1; x++)
+            {
+                for (int y = -1; y <= 1; y++)
+                {
+                    var offset = new Offset(x, y);
+                    if (offset != Zero) { yield return offset; }
+                }
+            }
+        }
+    }
+}

77_Salvo/csharp/Position.cs

@@ -0,0 +1,52 @@
+namespace Salvo;
+
+internal record struct Position(Coordinate X, Coordinate Y)
+{
+    public bool IsInRange => X.IsInRange && Y.IsInRange;
+    public bool IsOnDiagonal => X == Y;
+
+    public static Position Create((float X, float Y) coordinates) => new(coordinates.X, coordinates.Y);
+
+    public static bool TryCreateValid((float X, float Y) coordinates, out Position position)
+    {
+        if (Coordinate.TryCreateValid(coordinates.X, out var x) && Coordinate.TryCreateValid(coordinates.Y, out var y))
+        {
+            position = new(x, y);
+            return true;
+        }
+
+        position = default;
+        return false;
+    }
+
+    public static IEnumerable<Position> All
+        => Coordinate.Range.SelectMany(x => Coordinate.Range.Select(y => new Position(x, y)));
+
+    public IEnumerable<Position> Neighbours
+    {
+        get
+        {
+            foreach (var offset in Offset.Units)
+            {
+                var neighbour = this + offset;
+                if (neighbour.IsInRange) { yield return neighbour; }
+            }
+        }
+    }
+
+    internal float DistanceTo(Position other)
+    {
+        var (deltaX, deltaY) = (X - other.X, Y - other.Y);
+        return (float)Math.Sqrt(deltaX * deltaX + deltaY * deltaY);
+    }
+
+    internal Position BringIntoRange(IRandom random)
+        => IsInRange ? this : new(X.BringIntoRange(random), Y.BringIntoRange(random));
+
+    public static Position operator +(Position position, Offset offset) 
+        => new(position.X + offset.X, position.Y + offset.Y);
+
+    public static implicit operator Position(int value) => new(value, value);
+
+    public override string ToString() => $"{X}{Y}";
+}

77_Salvo/csharp/Program.cs

@@ -0,0 +1,9 @@
+global using System;
+global using Games.Common.IO;
+global using Games.Common.Randomness;
+global using Salvo;
+global using Salvo.Ships;
+global using static Salvo.Resources.Resource;
+
+//new Game(new ConsoleIO(), new RandomNumberGenerator()).Play();
+new Game(new ConsoleIO(), new DataRandom()).Play();

77_Salvo/csharp/Resources/Coordinates.txt

@@ -0,0 +1 @@
+Enter coordinates for...

77_Salvo/csharp/Resources/IHaveMoreShotsThanSquares.txt

@@ -0,0 +1 @@
+I have more shots than blank squares.