bazowa wersja aplikacji

.gitignore

@@ -0,0 +1,3 @@
+bin/
+obj/
+/packages/

.idea/.gitignore

@@ -0,0 +1,3 @@
+
+# Default ignored files
+/.idea.Life/.idea/workspace.xml

.idea/.idea.Life/.idea/contentModel.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ContentModelStore">
+    <e p="C:\Users\Kacper\.Rider2019.2\system\extResources" t="IncludeRecursive" />
+    <e p="C:\Users\Kacper\.Rider2019.2\system\resharper-host\local\Transient\ReSharperHost\v192\SolutionCaches\_Life.1627287830.00" t="ExcludeRecursive" />
+    <e p="C:\Users\Kacper\Studies\dotnet\Life" t="IncludeFlat">
+      <e p="Life" t="IncludeRecursive">
+        <e p="Annotations.cs" t="Include" />
+        <e p="App.xaml" t="Include" />
+        <e p="App.xaml.cs" t="Include" />
+        <e p="Automaton" t="Include">
+          <e p="BasicField.cs" t="Include" />
+          <e p="Cell.cs" t="Include" />
+          <e p="GameOfLife.cs" t="Include" />
+          <e p="IAutomaton.cs" t="Include" />
+          <e p="IField.cs" t="Include" />
+          <e p="MooreField.cs" t="Include" />
+        </e>
+        <e p="AutomatonField.xaml" t="Include" />
+        <e p="AutomatonField.xaml.cs" t="Include" />
+        <e p="bin" t="ExcludeRecursive" />
+        <e p="Life.csproj" t="IncludeRecursive" />
+        <e p="MainWindow.xaml" t="Include" />
+        <e p="MainWindow.xaml.cs" t="Include" />
+        <e p="Misc" t="Include">
+          <e p="DelegateSubscriber.cs" t="Include" />
+          <e p="DelegateUnsubscriber.cs" t="Include" />
+          <e p="Position.cs" t="Include" />
+          <e p="Size.cs" t="Include" />
+        </e>
+        <e p="obj" t="ExcludeRecursive">
+          <e p="Debug" t="Include">
+            <e p="netcoreapp3.0" t="Include">
+              <e p="Life.AssemblyInfo.cs" t="Include" />
+            </e>
+          </e>
+        </e>
+        <e p="ViewModel" t="Include">
+          <e p="BaseViewModel.cs" t="Include" />
+          <e p="CellViewModel.cs" t="Include" />
+          <e p="FieldViewModel.cs" t="Include" />
+        </e>
+      </e>
+      <e p="Life.sln" t="IncludeFlat" />
+      <e p="packages" t="ExcludeRecursive" />
+    </e>
+  </component>
+</project>

.idea/.idea.Life/.idea/encodings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
+</project>

.idea/.idea.Life/.idea/indexLayout.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ContentModelUserStore">
+    <attachedFolders />
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>

.idea/.idea.Life/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.Life/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.Life/riderModule.iml" />
+    </modules>
+  </component>
+</project>

.idea/.idea.Life/.idea/projectSettingsUpdater.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RiderProjectSettingsUpdater">
+    <option name="vcsConfiguration" value="1" />
+  </component>
+</project>

.idea/.idea.Life/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/.idea.Life/riderModule.iml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RIDER_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$/../.." />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

Life.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Life", "Life\Life.csproj", "{359EE343-AEB5-48C7-BAED-A6BD10072733}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{359EE343-AEB5-48C7-BAED-A6BD10072733}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{359EE343-AEB5-48C7-BAED-A6BD10072733}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{359EE343-AEB5-48C7-BAED-A6BD10072733}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{359EE343-AEB5-48C7-BAED-A6BD10072733}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Life.sln.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=Life_002EAnnotations/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Life.sln.DotSettings.user

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Unsubscriber/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Life/App.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="Life.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:Life"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

Life/App.xaml.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace Life
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}

Life/Automaton/BasicField.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Life.Annotations;
+using Life.Misc;
+
+namespace Life.Automaton
+{
+    public abstract class BasicField : IField, INotifyPropertyChanged
+    {
+        List<IObserver<IField>> _observers = new List<IObserver<IField>>();
+        
+        protected BasicField(int width, int height)
+        {
+            Size = new Size(width, height);
+            _cells = new Cell[width, height];
+            
+            for (int x = 0; x < width; x++)
+                for (int y = 0; y < height; y++)
+                    _cells[x, y] = new Cell();
+        }
+        
+        private Cell[,] _cells;
+
+        public Size Size { get; }
+
+        public Cell this[int x, int y]
+        {
+            get => _cells[x, y];
+            set
+            {
+                _cells[x, y] = value;
+                _observers.ForEach(observer => observer.OnNext(this));
+            }
+        }
+
+        public IEnumerable<Cell> Cells => _cells.Cast<Cell>();
+
+        public abstract IEnumerable<Cell> Neighbours(int x, int y);
+
+        public void Transform(Rule transform)
+        {
+            _cells = transform(this);
+            _observers.ForEach(observer => observer.OnNext(this));
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        public IDisposable Subscribe(IObserver<IField> observer)
+        {
+            _observers.Add(observer);
+
+            return new DelegateUnsubscriber(() => _observers.Remove(observer));
+        }
+    }
+}

Life/Automaton/Cell.cs

@@ -0,0 +1,9 @@
+using Life.Misc;
+
+namespace Life.Automaton
+{
+    public class Cell
+    {
+        public bool IsAlive { get; set; }
+    }
+}

Life/Automaton/GameOfLife.cs

@@ -0,0 +1,33 @@
+using System.Linq;
+
+namespace Life.Automaton
+{
+    public static class GameOfLife
+    {
+        public static Rule Rule(string born, string survive)
+        {
+            bool WillSurvive(int neighbours) => survive.Contains(neighbours.ToString());
+            bool WillBorn(int neighbours) => born.Contains(neighbours.ToString());
+            
+            return field =>
+            {
+                var @new = new Cell[field.Size.Width, field.Size.Height];
+
+                for (int i = 0; i < field.Size.Width; i++)
+                {
+                    for (int j = 0; j < field.Size.Height; j++)
+                    {
+                        var neighbours = field.Neighbours(i, j).Count(c => c.IsAlive);
+                        
+                        @new[i,j] = new Cell
+                        {
+                            IsAlive = field[i,j].IsAlive ? WillSurvive(neighbours) : WillBorn(neighbours)
+                        };
+                    }
+                }
+                
+                return @new;
+            };
+        }
+    }
+}

Life/Automaton/IAutomaton.cs

@@ -0,0 +1,11 @@
+namespace Life.Automaton
+{
+    public interface IAutomaton
+    {
+        int Iteration { get; }
+        IField Field { get; }
+
+        void Initialize(IField field);
+        void Advance();
+    }
+}

Life/Automaton/IField.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using Life.Misc;
+
+namespace Life.Automaton
+{
+    public delegate Cell[,] Rule(IField old);
+    
+    public interface IField : IObservable<IField>
+    {
+        Size Size { get; }
+
+        Cell this[int x, int y] { get; set; }
+
+        IEnumerable<Cell> Cells { get; }
+
+        IEnumerable<Cell> Neighbours(int x, int y);
+
+        void Transform(Rule rule);
+    }
+}

Life/Automaton/MooreField.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Life.Automaton
+{
+    public class MooreField : BasicField
+    {
+        public MooreField(int width, int height) : base(width, height)
+        {
+        }
+
+        public override IEnumerable<Cell> Neighbours(int x, int y)
+        {
+            var potential = new []
+            {
+                (x - 1, y + 1), (x, y + 1), (x + 1, y + 1),
+                (x - 1, y)  /*, (x, y)  */, (x + 1, y),
+                (x - 1, y - 1), (x, y - 1), (x + 1, y - 1),
+            };
+
+            return potential
+                .Where(c => c.Item1 >= 0 && c.Item1 < Size.Width && c.Item2 >= 0 && c.Item2 < Size.Height)
+                .Select(c => this[c.Item1, c.Item2]);
+        }
+
+        public override string ToString()
+        {
+            return $"MooreField {Size.Width} x {Size.Height}";
+        }
+    }
+}

Life/AutomatonField.xaml

@@ -0,0 +1,89 @@
+<UserControl x:Class="Life.AutomatonField"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:local="clr-namespace:Life"
+             mc:Ignorable="d"
+             d:DesignHeight="300" d:DesignWidth="300">
+    <UserControl.Resources>
+        <ResourceDictionary>
+            <Style TargetType="Button" x:Key="Cell">
+                <Style.Triggers>
+                    <DataTrigger Binding="{Binding IsAlive}" Value="True">
+                        <DataTrigger.EnterActions>
+                            <BeginStoryboard>
+                                <Storyboard>
+                                    <ColorAnimation Duration="0:0:0.15" To="Black" Storyboard.TargetProperty="(Button.Background).(SolidColorBrush.Color)"/>
+                                </Storyboard>
+                            </BeginStoryboard>
+                        </DataTrigger.EnterActions>
+                        <DataTrigger.ExitActions>
+                            <BeginStoryboard>
+                                <Storyboard>
+                                    <ColorAnimation Duration="0:0:0.15" From="Black" Storyboard.TargetProperty="(Button.Background).(SolidColorBrush.Color)"/>
+                                </Storyboard>
+                            </BeginStoryboard>
+                        </DataTrigger.ExitActions>
+                    </DataTrigger>
+                    <EventTrigger RoutedEvent="MouseEnter">
+                        <BeginStoryboard>
+                            <Storyboard>
+                                <ColorAnimation Duration="0:0:0.05" To="Aqua" Storyboard.TargetProperty="(Button.BorderBrush).(SolidColorBrush.Color)"/>
+                            </Storyboard>
+                        </BeginStoryboard>
+                    </EventTrigger>
+                    <EventTrigger RoutedEvent="MouseLeave">
+                        <BeginStoryboard>
+                            <Storyboard>
+                                <ColorAnimation Duration="0:0:0.05" From="Aqua" Storyboard.TargetProperty="(Button.BorderBrush).(SolidColorBrush.Color)"/>
+                            </Storyboard>
+                        </BeginStoryboard>
+                    </EventTrigger>
+                </Style.Triggers>
+                
+                <Setter Property="Background" Value="LightGray"/>
+                <Setter Property="Template">
+                       <Setter.Value>
+                           <ControlTemplate TargetType="Button">
+                              <Border x:Name="Border" 
+                                      BorderThickness="1"
+                                      Background="{TemplateBinding Background}"
+                                      BorderBrush="{TemplateBinding BorderBrush}">
+                                  <ContentPresenter Margin="2"
+                                                    HorizontalAlignment="Center"
+                                                    VerticalAlignment="Center"
+                                                    RecognizesAccessKey="True"/>
+                               </Border>
+                            </ControlTemplate>
+                        </Setter.Value>
+                   </Setter>
+            </Style>
+        </ResourceDictionary>
+    </UserControl.Resources>
+    <Border Background="LightGray" BorderThickness="{Binding Separation}" 
+            BorderBrush="LightGray" DataContext="{Binding ViewModel, RelativeSource={RelativeSource AncestorType={x:Type local:AutomatonField}}}">
+        <ItemsControl ItemsSource="{Binding Cells}">
+            <ItemsControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <Canvas Width="{Binding Width}" Height="{Binding Height}" />
+                </ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
+            <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                    <Button Width="{Binding Size, RelativeSource={RelativeSource AncestorType={x:Type local:AutomatonField}}}" 
+                            Height="{Binding Size, RelativeSource={RelativeSource AncestorType={x:Type local:AutomatonField}}}" 
+                            Click="Cell_Click"
+                            Style="{DynamicResource Cell}"
+                            />
+                </DataTemplate>
+            </ItemsControl.ItemTemplate>
+            <ItemsControl.ItemContainerStyle>
+                <Style>
+                    <Setter Property="Canvas.Left" Value="{Binding Left}"/>
+                    <Setter Property="Canvas.Top" Value="{Binding Top}"/>
+                </Style>
+            </ItemsControl.ItemContainerStyle>
+        </ItemsControl>
+    </Border>
+</UserControl>

Life/AutomatonField.xaml.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Shapes;
+using Life.Automaton;
+using Life.ViewModel;
+
+namespace Life
+{
+    public partial class AutomatonField : UserControl
+    {
+        #region Dependency Property Wrappers
+        public int Size
+        {
+            get { return (int) GetValue(SizeProperty); }
+            set { SetValue(SizeProperty, value); }
+        }
+
+        public int Separation
+        {
+            get { return (int) GetValue(SeparationProperty); }
+            set { SetValue(SeparationProperty, value); }
+        }
+
+        public IField Field
+        {
+            get { return (IField) GetValue(FieldProperty); }
+            set { SetValue(FieldProperty, value); }
+        }
+        #endregion
+        
+        public FieldViewModel ViewModel { get; set; } = new FieldViewModel();
+        
+        public AutomatonField()
+        {
+            InitializeComponent();
+        }
+
+        private static void OnFieldChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var field = d as AutomatonField;
+            
+            field.ViewModel.Field = e.NewValue as IField;
+        }
+
+        private static void OnSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var field = d as AutomatonField;
+            
+            field.ViewModel.Size = (int)e.NewValue;
+        }
+
+        private static void OnSeparationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var field = d as AutomatonField;
+            
+            field.ViewModel.Separation = (int)e.NewValue;
+        }
+        
+        #region Dependency Properties
+        public static readonly DependencyProperty SizeProperty = DependencyProperty.Register(
+            "Size", 
+            typeof(int), typeof(AutomatonField),
+             new PropertyMetadata(OnSizeChanged)
+        );
+        
+        public static readonly DependencyProperty SeparationProperty = DependencyProperty.Register(
+            "Separation", 
+            typeof(int), typeof(AutomatonField),
+            new PropertyMetadata(OnSeparationChanged)
+        );
+
+        public static readonly DependencyProperty FieldProperty = DependencyProperty.Register(
+            nameof(Field), 
+            typeof(IField), typeof(AutomatonField),
+            new PropertyMetadata(OnFieldChanged)
+        );
+        #endregion
+
+        private void Cell_Click(object sender, RoutedEventArgs e)
+        {
+            var vm = (sender as Button).DataContext as CellViewModel;
+            var cell = Field[vm.Position.X, vm.Position.Y];
+
+            cell.IsAlive = !cell.IsAlive;
+            
+            ViewModel.Sync();
+        }
+    }
+}

Life/Life.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
+    <PropertyGroup>
+        <OutputType>WinExe</OutputType>
+        <TargetFramework>netcoreapp3.0</TargetFramework>
+        <UseWPF>true</UseWPF>
+    </PropertyGroup>
+
+</Project>

Life/MainWindow.xaml

@@ -0,0 +1,39 @@
+<Window x:Class="Life.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:Life"
+        mc:Ignorable="d"
+        Title="MainWindow" Height="450" Width="800" d:DataContext="{d:DesignInstance local:MainWindow}">
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="2*" MinWidth="400"/>
+            <ColumnDefinition Width="3"/>
+            <ColumnDefinition Width="1*" MinWidth="250"/>
+        </Grid.ColumnDefinitions>
+        
+        <ScrollViewer HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto">
+            <local:AutomatonField Field="{Binding Field}" Size="{Binding Size}" Separation="3"/>
+        </ScrollViewer>
+        
+        <GridSplitter Grid.Column="1" Width="3" ResizeDirection="Columns" ResizeBehavior="PreviousAndNext"/>
+        <Grid Margin="8" Grid.Column="2">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="3*"/>
+                <RowDefinition Height="1*"/>
+            </Grid.RowDefinitions>
+            
+            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
+                <TextBlock Text="{Binding Field.Size.Width}"/>
+                <TextBlock Text=" x "/>
+                <TextBlock Text="{Binding Field.Size.Height}"/>
+            </StackPanel>
+            
+            <StackPanel Orientation="Vertical" Grid.Row="1" VerticalAlignment="Bottom">
+                <Button VerticalAlignment="Stretch" Margin="0 0 0 8">Step</Button>
+                <Button VerticalAlignment="Stretch" Click="Step_OnClick">Step</Button>
+            </StackPanel>
+        </Grid>
+    </Grid>
+</Window>

Life/MainWindow.xaml.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using Life.Annotations;
+using Life.Automaton;
+
+namespace Life
+{
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window, INotifyPropertyChanged
+    {
+        private IField _field;
+        private int _size;
+        private Rule _rule = GameOfLife.Rule("3", "23");
+
+        public IField Field
+        {
+            get => _field;
+            set
+            {
+                 _field = value;
+                 OnPropertyChanged(nameof(Field));
+            }
+        }
+
+        public int Size
+        {
+            get => _size;
+            set
+            {
+                _size = value;
+                OnPropertyChanged(nameof(Size));
+            }
+        }
+
+        public MainWindow()
+        {
+            Size = 20;
+            Field = new MooreField(20, 20);
+            Field[5, 5].IsAlive = true;
+            DataContext = this;
+            
+            InitializeComponent();   
+        }
+
+        private void Step_OnClick(object sender, RoutedEventArgs e)
+        {
+            Field.Transform(_rule);
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}

Life/Misc/DelegateSubscriber.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Life.Misc
+{
+    public class DelegateSubscriber<T> : IObserver<T>
+    {
+        public Action<T> Action;
+        public Action<Exception> Error;
+        public Action Completed;
+
+        public void OnCompleted()
+        {
+            Completed?.Invoke();
+        }
+
+        public void OnError(Exception error)
+        {
+            Error?.Invoke(error);
+        }
+
+        public void OnNext(T value)
+        {
+            Action?.Invoke(value);
+        }
+    }
+}

Life/Misc/DelegateUnsubscriber.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Life.Misc
+{
+    public class DelegateUnsubscriber : IDisposable
+    {
+        private readonly Action _action;
+
+        public DelegateUnsubscriber([NotNull] Action action)
+        {
+            _action = action;
+        }
+
+        public void Dispose()
+        {
+            _action.Invoke();
+        }
+    }
+}

Life/Misc/Position.cs

@@ -0,0 +1,19 @@
+namespace Life.Misc
+{
+    public struct Position
+    {
+        public Position(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public readonly int X;
+        public readonly int Y;
+
+        public override string ToString()
+        {
+            return $"({X}, {Y})";
+        }
+    }
+}

Life/Misc/Size.cs

@@ -0,0 +1,14 @@
+namespace Life.Misc
+{
+    public struct Size
+    {
+        public int Width { get; }
+        public int Height { get; }
+
+        public Size(int width, int height)
+        {
+            Width = width;
+            Height = height;
+        }
+    }
+}

Life/ViewModel/BaseViewModel.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using Life.Annotations;
+
+namespace Life.ViewModel
+{
+    public abstract class BaseViewModel : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}

Life/ViewModel/CellViewModel.cs

@@ -0,0 +1,48 @@
+using Life.Misc;
+
+namespace Life.ViewModel
+{
+    public class CellViewModel : BaseViewModel
+    {
+        private int _left;
+        private int _top;
+        private bool _isAlive;
+
+        public CellViewModel(int x, int y)
+        {
+            Position = new Position(x, y);
+        }
+
+        public int Left
+        {
+            get => _left;
+            set
+            {
+                _left = value;
+                OnPropertyChanged(nameof(Left));
+            }
+        }
+        
+        public int Top
+        {
+            get => _top;
+            set
+            {
+                _top = value;
+                OnPropertyChanged(nameof(Top));
+            }
+        }
+
+        public bool IsAlive
+        {
+            get => _isAlive;
+            set
+            {
+                _isAlive = value;
+                OnPropertyChanged(nameof(IsAlive));
+            }
+        }
+
+        public Position Position { get; }
+    }
+}

Life/ViewModel/FieldViewModel.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.ObjectModel;
+using Life.Automaton;
+using Life.Misc;
+
+namespace Life.ViewModel
+{
+    public class FieldViewModel : BaseViewModel
+    {
+        private int _width;
+        private int _height;
+        private IField _field;
+        private int _size;
+        private int _separation;
+        private IDisposable _fieldObserverDisposal;
+
+        public ObservableCollection<CellViewModel> Cells { get; set; } = new ObservableCollection<CellViewModel>();
+
+        public int Width
+        {
+            get => _width;
+            set
+            {
+                _width = value;
+                OnPropertyChanged(nameof(Width));
+            }
+        }
+
+        public int Height
+        {
+            get => _height;
+            set
+            {
+                _height = value;
+                OnPropertyChanged(nameof(Height));
+            }
+        }
+
+        public IField Field
+        {
+            get => _field;
+            set
+            {
+                _fieldObserverDisposal?.Dispose();
+                _fieldObserverDisposal = value.Subscribe(new DelegateSubscriber<IField>
+                {
+                    Action = field => Sync()
+                });
+                
+                _field = value;
+                ResetFields();
+            }
+        }
+
+        public int Size
+        {
+            get => _size;
+            set
+            {
+                _size = value;
+                OnPropertyChanged(nameof(Size));
+                RecalculateSize();
+            }
+        }
+
+        public int Separation
+        {
+            get => _separation;
+            set
+            {
+                _separation = value;
+                OnPropertyChanged(nameof(Separation));
+                RecalculateSize();
+            }
+        }
+
+        private void ResetFields()
+        {
+            Cells.Clear();
+            
+            for (int i = 0; i < Field.Size.Width; i++)
+                for (int j = 0; j < Field.Size.Height; j++)
+                    Cells.Add(CreateCellViewModel(i, j));
+            
+            Sync();
+            RecalculateSize();
+        }
+
+        private void RecalculateSize()
+        {
+            if (Field == null) return;
+            
+            foreach (var cell in Cells)
+            {
+                cell.Left = cell.Position.X * (Separation + Size);
+                cell.Top  = cell.Position.Y * (Separation + Size);
+            }
+            
+            Width = Field.Size.Width * Size + (Field.Size.Width - 1) * Separation;
+            Height = Field.Size.Height * Size + (Field.Size.Height - 1) * Separation;
+        }
+
+        private CellViewModel CreateCellViewModel(int x, int y)
+        {
+            return new CellViewModel(x, y);
+        }
+
+        public void Sync()
+        {
+            foreach (var cell in Cells)
+            {
+                cell.IsAlive = Field[cell.Position.X, cell.Position.Y].IsAlive;
+            }
+        }
+    }
+}