Advertisement
ZhongNi

Aquarium (5)

Oct 31st, 2024
20
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 14.61 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4.  
  5. namespace Classes
  6. {
  7.     internal class Program
  8.     {
  9.         static void Main()
  10.         {
  11.             Aquarium aquarium = new Aquarium();
  12.             aquarium.Live();
  13.         }
  14.     }
  15.  
  16.     public class Aquarium
  17.     {
  18.         public List<Fish> _fishes;
  19.         public int _size;
  20.         public Manager _manager;
  21.  
  22.         public Aquarium()
  23.         {
  24.             _size = 50;
  25.             _fishes = new List<Fish>();
  26.             _manager = new Manager();
  27.            _manager.Fill(_fishes, _size);
  28.         }
  29.  
  30.         public void Live()
  31.         {
  32.             int turn = 1;
  33.  
  34.             Console.WriteLine("Turn :" + turn++);
  35.             _manager.ShowAllFishes(_fishes);
  36.  
  37.             bool isRunning = true;
  38.             ConsoleKey menuLaunchKey = ConsoleKey.D0;
  39.             string menuLaunch = "0";
  40.  
  41.             while (isRunning)
  42.             {
  43.                 Console.WriteLine($"\nPress something for next turn... or {menuLaunch} for menu");
  44.  
  45.                 if (Console.ReadKey().Key == menuLaunchKey)
  46.                 {
  47.                     Console.Clear();
  48.                     isRunning = _manager.LaunchMenu(_fishes);
  49.                     continue;
  50.                 }
  51.  
  52.                 Console.Clear();
  53.                 Console.WriteLine("Turn :" + turn++);
  54.  
  55.                 _manager.GrowOldFishes(_fishes);
  56.                 _manager.KillFishes(_fishes, _size);
  57.                 _manager.RemoveFishes(_fishes, _size);
  58.                 _manager.ShowAllFishes(_fishes);
  59.             }
  60.         }
  61.     }
  62.  
  63.     public class Manager
  64.     {
  65.         public bool LaunchMenu(List<Fish> fishes)
  66.         {
  67.             const string CommandAddFish = "1";
  68.             const string CommandRemoveFish = "2";
  69.             const string CommandShowFish = "3";
  70.             const string CommandExitMenu = "4";
  71.             const string CommandExit = "5";
  72.  
  73.             bool hasSelected = false;
  74.             bool isRunning = true;
  75.  
  76.             while (hasSelected == false)
  77.             {
  78.                 Console.Clear();
  79.                 Console.WriteLine($"Press {CommandAddFish} for add fish," +
  80.                     $"\n {CommandRemoveFish} for remove," +
  81.                     $"\n {CommandShowFish} for show," +
  82.                     $"\n {CommandExitMenu} for exit the menu" +
  83.                     $"\n or {CommandExit} for close aquarium");
  84.  
  85.                 string userCommand = Console.ReadLine();
  86.  
  87.                 switch (userCommand)
  88.                 {
  89.                     case CommandAddFish:
  90.                         IncreaseFishes(fishes);
  91.                         break;
  92.                     case CommandRemoveFish:
  93.                         DecreaseFishes(fishes);
  94.                         break;
  95.                     case CommandShowFish:
  96.                         Console.Clear();
  97.                         ShowAllFishes(fishes);
  98.                         Console.WriteLine("\nPress something..");
  99.                         Console.ReadKey();
  100.                         break;
  101.                     case CommandExitMenu:
  102.                         hasSelected = true;
  103.                         break;
  104.                     case CommandExit:
  105.                         hasSelected = true;
  106.                         isRunning = false;
  107.                         break;
  108.                     default:
  109.                         Console.WriteLine("Wrong key");
  110.                         break;
  111.                 }
  112.             }
  113.  
  114.             return isRunning;
  115.         }
  116.  
  117.         public void Fill(List<Fish> fishes, int aquariumSize)
  118.         {
  119.             int fishListCount = Characteristics.PresetCharacteristics.Count;
  120.             int minOccupiedVolume = Characteristics.PresetCharacteristics.Min(fish => fish.OccupiedSize);
  121.  
  122.             for (int size = 0; size < aquariumSize;)
  123.             {
  124.                 Characteristics currentCharacteristic = Characteristics.PresetCharacteristics[UserUtil.GenerateRandomNumber(fishListCount)];
  125.  
  126.                 if (size + currentCharacteristic.OccupiedSize > aquariumSize)
  127.                 {
  128.                     fishListCount = fishListCount > minOccupiedVolume ? fishListCount-- : minOccupiedVolume;
  129.                     continue;
  130.                 }
  131.  
  132.                 fishes.Add(new Fish(currentCharacteristic));
  133.                 size += currentCharacteristic.OccupiedSize;
  134.             }
  135.         }
  136.  
  137.         public void ShowAllFishes(List<Fish> fishes)
  138.         {
  139.             foreach (var fish in fishes)
  140.             {
  141.                 Console.ForegroundColor = fish.Characteristics.Color;
  142.                 int minLeftPosition = 30;
  143.                 int maxLeftPosition = 110;
  144.                 int minTopPosition = 1;
  145.                 int maxTopPosition = 14;
  146.  
  147.                 Console.SetCursorPosition(UserUtil.GenerateRandomNumber(minLeftPosition, maxLeftPosition + 1), UserUtil.GenerateRandomNumber(minTopPosition, maxTopPosition + 1));
  148.                 Console.WriteLine(fish.Characteristics.Image);
  149.             }
  150.  
  151.             var ordered = fishes.OrderBy(fish => fish.Characteristics.Name).ThenBy(fish => fish.Age);
  152.  
  153.             int leftPosition = 0;
  154.             int topPosition = 4;
  155.             Console.SetCursorPosition(leftPosition, topPosition);
  156.  
  157.             foreach (var fish in ordered)
  158.             {
  159.                 Console.ForegroundColor = fish.Characteristics.Color;
  160.                 Console.WriteLine($"{fish.Characteristics.Name} - {fish.Age}({fish.Characteristics.LifeExpectancy})");
  161.             }
  162.  
  163.             Console.ResetColor();
  164.         }
  165.  
  166.         public void GrowOldFishes(List<Fish> fishes)
  167.         {
  168.             foreach (var fish in fishes)
  169.             {
  170.                 fish.IncreaseAge();
  171.             }
  172.         }
  173.    
  174.         public void KillFishes(List<Fish> fishes, int aquariumSize)
  175.         {
  176.             int fishCount = Characteristics.PresetCharacteristics.Count;
  177.             int quantityPerLiter = 10;
  178.             int maxFishCount = aquariumSize * quantityPerLiter;
  179.             int volumeFish = fishes.Sum(fish => fish.Characteristics.OccupiedSize);
  180.             int fullMultiplier = VerifyFullVolume(volumeFish, aquariumSize);
  181.  
  182.             if (volumeFish >= maxFishCount)
  183.             {
  184.                 foreach (var fish in fishes)
  185.                 {
  186.                     fish.Kill();
  187.                 }
  188.             }
  189.             else
  190.             {
  191.                 foreach (var fish in fishes)
  192.                 {
  193.                     int probabilityDeath = VerifyAge(fish);
  194.  
  195.                     probabilityDeath *= VerifyAlone(fish, fishes);
  196.  
  197.                     probabilityDeath *= fullMultiplier;
  198.  
  199.                     int maxChance = 100;
  200.  
  201.                     if (UserUtil.GenerateRandomNumber(maxChance + 1) < probabilityDeath)
  202.                     {
  203.                         fish.Kill();
  204.                     }
  205.                 }
  206.             }
  207.         }
  208.  
  209.         private int VerifyFullVolume(int volumeFish, int aquariumSize)
  210.         {
  211.             int multiplier = 1;
  212.             int fullMultiplier = 2;
  213.  
  214.             if (volumeFish > aquariumSize)
  215.             {
  216.                 multiplier = fullMultiplier;
  217.             }
  218.  
  219.             return multiplier;
  220.         }
  221.  
  222.         private int VerifyAge(Fish fish)
  223.         {
  224.             int probabilityDeath = 2;
  225.             int firstHalf = 2;
  226.             int secondHalf = 5;
  227.             int longLife = 90;
  228.             int lifePeriod = 2;
  229.  
  230.             if (fish.Age < fish.Characteristics.LifeExpectancy / lifePeriod)
  231.             {
  232.                 probabilityDeath = firstHalf;
  233.             }
  234.             else if (fish.Age < fish.Characteristics.LifeExpectancy)
  235.             {
  236.                 probabilityDeath = secondHalf;
  237.             }
  238.             else if (fish.Age >= fish.Characteristics.LifeExpectancy)
  239.             {
  240.                 probabilityDeath = longLife;
  241.             }
  242.  
  243.             return probabilityDeath;
  244.         }
  245.  
  246.         private int VerifyAlone(Fish fish, List<Fish> fishes)
  247.         {
  248.             string fishName = fish.Characteristics.Name;
  249.             int nameCount = fishes.Count(fish => fish.Characteristics.Name == fishName);
  250.             int multiplier = 1;
  251.             int aloneMultiplier = 2;
  252.  
  253.             if (nameCount == 1)
  254.             {
  255.                 multiplier = aloneMultiplier;
  256.             }
  257.  
  258.             return multiplier;
  259.         }
  260.    
  261.         public void RemoveFishes(List<Fish> fishes, int aquariumSize)
  262.         {
  263.             int quantityPerLiter = 10;
  264.             int maxFishCount = aquariumSize * quantityPerLiter;
  265.             int volumeFish = fishes.Sum(fish => fish.Characteristics.OccupiedSize);
  266.  
  267.             if (volumeFish >= maxFishCount)
  268.             {
  269.                 Console.WriteLine("Too many fish. All died.");
  270.             }
  271.  
  272.             int numberDead = 0;
  273.  
  274.             for (int i = fishes.Count - 1; i >= 0; i--)
  275.             {
  276.                 if (fishes[i].IsAlive == false)
  277.                 {
  278.                     fishes.RemoveAt(i);
  279.                     numberDead++;
  280.                 }
  281.             }
  282.  
  283.             int leftPosition = 0;
  284.             int topPosition = 2;
  285.             Console.SetCursorPosition(leftPosition, topPosition);
  286.             Console.WriteLine($"fish died: {numberDead}");
  287.         }
  288.    
  289.         public void IncreaseFishes(List<Fish> fishes)
  290.         {
  291.             Characteristics.ShowListCharacteristics();
  292.             Console.Write("\nChoose type of fish to add: ");
  293.  
  294.             if (int.TryParse(Console.ReadLine(), out int typeNumber) && typeNumber >= 0 && typeNumber < Characteristics.PresetCharacteristics.Count)
  295.             {
  296.                 Console.WriteLine("How many fish to add?");
  297.  
  298.                 if (int.TryParse(Console.ReadLine(), out int amount) && amount > 0)
  299.                 {
  300.                     for (int i = 0; i < amount; i++)
  301.                     {
  302.                         fishes.Add(new Fish(Characteristics.PresetCharacteristics[typeNumber]));
  303.                     }
  304.                 }
  305.                 else
  306.                 {
  307.                     Console.WriteLine("Wrong amount");
  308.                 }
  309.             }
  310.             else
  311.             {
  312.                 Console.WriteLine("Wrong type");
  313.             }
  314.         }
  315.  
  316.         public void DecreaseFishes(List<Fish> fishes)
  317.         {
  318.             Characteristics.ShowListCharacteristics();
  319.             Console.Write("\nChoose the type of fish to remove: ");
  320.  
  321.             if (int.TryParse(Console.ReadLine(), out int typeNumber) && typeNumber >= 0 && typeNumber < Characteristics.PresetCharacteristics.Count)
  322.             {
  323.                 string fishName = Characteristics.PresetCharacteristics[typeNumber].Name;
  324.                 int nameCount = fishes.Count(fish => fish.Characteristics.Name == fishName);
  325.  
  326.                 Console.WriteLine($"How many fish to remove? There are {nameCount} fish of this type");
  327.  
  328.                 if (int.TryParse(Console.ReadLine(), out int amount) && amount > 0)
  329.                 {
  330.                     if (amount > nameCount)
  331.                     {
  332.                         Console.WriteLine("The entered quantity exceeds the quantity of fish of this type in the aquarium, delete all fish of this type");
  333.                         Console.WriteLine("\nPress something..");
  334.                         Console.ReadKey();
  335.                     }
  336.  
  337.                     amount = Math.Min(amount, nameCount);
  338.  
  339.                     for (int i = fishes.Count - 1; i >= 0; i--)
  340.                     {
  341.                         if (fishes[i].Characteristics.Name == fishName && amount > 0)
  342.                         {
  343.                             fishes.RemoveAt(i);
  344.                             amount--;
  345.                         }
  346.                     }
  347.                 }
  348.                 else
  349.                 {
  350.                     Console.WriteLine("Wrong amount");
  351.                 }
  352.             }
  353.             else
  354.             {
  355.                 Console.WriteLine("Wrong type");
  356.             }
  357.         }
  358.     }
  359.  
  360.     public class Fish
  361.     {
  362.  
  363.         public Fish(Characteristics characteristics)
  364.         {
  365.             Characteristics = characteristics;
  366.             IsAlive = true;
  367.  
  368.             InitiateAge();
  369.         }
  370.  
  371.         public Characteristics Characteristics { get; private set; }
  372.         public int Age { get; private set; }
  373.         public bool IsAlive { get; private set; }
  374.  
  375.         public void IncreaseAge()
  376.         {
  377.             Age++;
  378.         }
  379.  
  380.         public void Kill()
  381.         {
  382.             IsAlive = false;
  383.         }
  384.  
  385.         private void InitiateAge()
  386.         {
  387.             int minAge = 1;
  388.             int minLifeSpan = 10;
  389.             int maxAge = Characteristics.LifeExpectancy > minLifeSpan ? Characteristics.LifeExpectancy - minLifeSpan : 1;
  390.  
  391.             Age = UserUtil.GenerateRandomNumber(minAge, maxAge + 1);
  392.         }
  393.     }
  394.  
  395.     public class Characteristics
  396.     {
  397.         public static List<Characteristics> PresetCharacteristics = new List<Characteristics>()
  398.         {
  399.             new Characteristics("Guppy", 30, 2, ">-->", ConsoleColor.Cyan),
  400.             new Characteristics("Paracheirodon", 48, 2, ">==>",ConsoleColor.Blue),
  401.             new Characteristics("Xiphophorus",60,4 ,"_>=>",ConsoleColor.Red),
  402.             new Characteristics("Yucatan molly",30,4, ">WW>",ConsoleColor.DarkCyan),
  403.             new Characteristics("Catfish", 96,8,">=>_",ConsoleColor.Gray ),
  404.             new Characteristics("Goldfish",120,12,">=@>",ConsoleColor.DarkYellow)
  405.         };
  406.  
  407.         public Characteristics(string name, int lifeExpectancy, int occupiedSize, string image, ConsoleColor color)
  408.         {
  409.             Name = name;
  410.             LifeExpectancy = lifeExpectancy;
  411.             OccupiedSize = occupiedSize;
  412.             Image = image;
  413.             Color = color;
  414.         }
  415.  
  416.         public string Name { get; private set; }
  417.         public int LifeExpectancy { get; private set; }
  418.         public int OccupiedSize { get; private set; }
  419.         public string Image { get; private set; }
  420.         public ConsoleColor Color { get; private set; }
  421.  
  422.         public static void ShowListCharacteristics()
  423.         {
  424.             Console.Write("There is the following fish: ");
  425.  
  426.             for (int i = 0; i < PresetCharacteristics.Count; i++)
  427.             {
  428.                 Console.Write($"{i} - {PresetCharacteristics[i].Name} ");
  429.             }
  430.         }
  431.     }
  432.  
  433.     public class UserUtil
  434.     {
  435.         private static Random s_random = new Random();
  436.  
  437.         public static int GenerateRandomNumber(int min, int max)
  438.         {
  439.             return s_random.Next(min, max);
  440.         }
  441.  
  442.         public static int GenerateRandomNumber(int max)
  443.         {
  444.             return s_random.Next(max);
  445.         }
  446.     }
  447. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement