public SolarSystemService(ISolarSystemRepository repository, ISolarSystemValidator solarSystemValidator,
IPlanetRepository planetRepository)
{
_repository = repository;
_solarSystemValidator = solarSystemValidator;
_planetRepository = planetRepository;
}
public ProjectDataPageViewModel(IPlanetRepository planetRepository) : base(planetRepository) {
CreateCommand = new DelegateCommand(ExecuteCreateCommand, CanExecuteCreateCommand);
ReadCommand = new DelegateCommand(ExecuteReadCommand, CanExecuteReadCommand);
WriteCommand = new DelegateCommand(ExecuteWriteCommand, CanExecuteWriteCommand);
DeleteCommand = new DelegateCommand(ExecuteDeleteCommand, CanExecuteDeleteCommand);
Instructions = "Reminder: Project data needs BuildAction=Content, CopyToOutputDirectory=CopyAlways";
}
public RoverRepository(IConfiguration configuration, IPlanetRepository planetRepository,
IObstacleRepository obstacleRepository)
{
_configuration = configuration;
_planetRepository = planetRepository;
_obstacleRepository = obstacleRepository;
}
public MainWindow()
{
InitializeComponent();
window = this;
IKernel kernel;
kernel = new StandardKernel(new NinjectConfigModule());
resourceRepo = kernel.Get <IResourceRepository>();
planetRepo = kernel.Get <IPlanetRepository>();
missionRepo = kernel.Get <IMissionRepository>();
fractionRepo = kernel.Get <IFractionRepository>();
typeRepo = kernel.Get <IMissionTypeRepository>();
pausedRepo = kernel.Get <IPausedMissionRepository>();
endedRepo = kernel.Get <IEndedMissionRepository>();
planetSer = kernel.Get <IPlanetService>();
missionSer = kernel.Get <IMissionService>();
resourceSer = kernel.Get <IResourceService>();
resourceCollection = new ObservableCollection <string>();
planetCollection = new ObservableCollection <string>();
missionCollection = new ObservableCollection <string>();
resourcesListBox.ItemsSource = resourceCollection;
planetsListBox.ItemsSource = planetCollection;
missionsListBox.ItemsSource = missionCollection;
resourcesListBox.SelectionChanged += new SelectionChangedEventHandler(ResourceListBox_Click);
planetsListBox.SelectionChanged += new SelectionChangedEventHandler(PlanetListBox_Click);
missionsListBox.SelectionChanged += new SelectionChangedEventHandler(MissionListBox_Click);
FillDatabase();
LoadResources();
}
public LocalDataPickerPageViewModel(IPlanetRepository planetRepository) : base(planetRepository) {
CreateCommand = new DelegateCommand(ExecuteCreateCommand, CanExecuteCreateCommand);
ReadCommand = new DelegateCommand(ExecuteReadCommand, CanExecuteReadCommand);
WriteCommand = new DelegateCommand(ExecuteWriteCommand, CanExecuteWriteCommand);
DeleteCommand = new DelegateCommand(ExecuteDeleteCommand, CanExecuteDeleteCommand);
Instructions = string.Empty;
}
public LifecyclePageViewModel(IPlanetRepository planetRepository, INavigationService navigationService, IEventAggregator eventAggregator) {
this.planetRepository = planetRepository;
this.navigationService = navigationService;
this.eventAggregator = eventAggregator;
AddCommand = new DelegateCommand(AddPlanet, CanAddPlanet);
AllErrors = BindableValidator.EmptyErrorsCollection;
}
public CommandingPageViewModel(IPlanetRepository planetRepository) {
this.planetRepository = planetRepository;
PopulateListViewCommand = new DelegateCommand(ExecutePopulateListViewCommand, CanExecutePopulateListViewCommand);
PlanetsListViewSelectionChangedCommand = new DelegateCommand(ExecutePlanetsListViewSelectionChangedCommand,
CanExecutePlanetsListViewSelectionChangedCommand);
}
public CreateNewPlanet()
{
InitializeComponent();
_planetRepository = App.ServiceProvider.GetService <IPlanetRepository>();
_planet = new PlanetViewModel(new Planet(), null);
this.DataContext = _planet;
}
public PlanetService(IPlanetRepository repository, IPlanetValidator planetValidator,
ISolarSystemRepository solarSystemRepository, IHttpClientFactory clientFactory)
{
_repository = repository;
_planetValidator = planetValidator;
_solarSystemRepository = solarSystemRepository;
_clientFactory = clientFactory;
}
public QuestionRepository(IDatabaseContext databaseContext,
IPlanetRepository planetRepository,
ILevelRepository levelRepository)
{
_databaseContext = databaseContext;
_planetRepository = planetRepository;
_levelRepository = levelRepository;
}
public EventAggregatorPageViewModel(IEventAggregator eventAggregator, IPlanetRepository planetRepository) {
this.planetRepository = planetRepository;
this.eventAggregator = eventAggregator;
PlanetImageViewModel = new PlanetImageViewModel(eventAggregator);
PopulateListViewCommand = new DelegateCommand(ExecutePopulateListViewCommand, CanExecutePopulateListViewCommand);
PlanetsListViewSelectionChangedCommand = new DelegateCommand(ExecutePlanetsListViewSelectionChangedCommand,
CanExecutePlanetsListViewSelectionChangedCommand);
}
public PlanetController(IPlanetRepository planetRepository, IProfileRepository profileRepository)
{
this.planetRepository = planetRepository;
this.profileRepository = profileRepository;
if (circuitBreaker == null)
{
circuitBreaker = new Helpers.CircuitBreaker.CircuitBreaker("planet_breaker", Constants.API.FAILURE_THRESHOLD, TimeSpan.FromSeconds(Constants.API.OPEN_CIRCUIT_TIMEOUT));
}
}
public PlanetEditPageViewModel(IPlanetRepository planetRepository, INavigationService navigationService) {
this.planetRepository = planetRepository;
this.navigationService = navigationService;
SaveCommand = new DelegateCommand(SavePlanet, CanSavePlanet);
CancelCommand = new DelegateCommand(CancelPlanet, CanCancelPlanet);
ValidateCommand = new DelegateCommand(ValidatePlanet);
AllErrors = BindableValidator.EmptyErrorsCollection;
}
public MovieViewModel(IVehiclesRepository vehiclesRepository, ISpeciesRepository speciesRepository, IPeopleRepository peopleRepository, IStarshipRepository starshipRepository, IPlanetRepository planetRepository, IDataService dataService)
{
_vehiclesRepository = vehiclesRepository;
_speciesRepository = speciesRepository;
_peopleRepository = peopleRepository;
_starshipRepository = starshipRepository;
_planetRepository = planetRepository;
_dataService = dataService;
InitAsyncCommand = new AsyncRelayCommand <Film>(InitAsync);
}
public SpecieViewModel(IDataService dataService, IFilmRepository filmRepository, IPeopleRepository peopleRepository, IVehiclesRepository vehiclesRepository, IStarshipRepository starshipRepository, IPlanetRepository planetRepository)
{
_dataService = dataService;
_filmRepository = filmRepository;
_peopleRepository = peopleRepository;
_vehiclesRepository = vehiclesRepository;
_starshipRepository = starshipRepository;
_planetRepository = planetRepository;
InitAsyncCommand = new AsyncRelayCommand <Specie>(InitAsync);
}
public NavigationPageViewModel(IPlanetRepository planetRepository, INavigationService navigationService) {
this.planetRepository = planetRepository;
this.navigationService = navigationService;
ReLoadCommand = new DelegateCommand(ReLoadPlanetVMs);
AddCommand = new DelegateCommand(AddPlanet, CanAddPlanet);
PlanetsListViewSelectionChangedCommand = new DelegateCommand(ExecutePlanetsListViewSelectionChangedCommand,
CanExecutePlanetsListViewSelectionChangedCommand);
AllErrors = BindableValidator.EmptyErrorsCollection;
}
public TreeUtilities(IHebrewLetterRepository hebrewLetterRepository, ISephiraRepository sephiraRepository,
IPlanetRepository planetRepository, IZodiacSignRepository zodiacSignRepository,
IPathRepository pathRepository, ITreeOfLifeDatabase database)
{
_hebrewLetterRepository = hebrewLetterRepository;
_sephiraRepository = sephiraRepository;
_planetRepository = planetRepository;
_zodiacSignRepository = zodiacSignRepository;
_pathRepository = pathRepository;
_database = database;
}
public PlanetBrowsePageViewModel(IPlanetRepository planetRepository, INavigationService navigationService) {
this.planetRepository = planetRepository;
this.navigationService = navigationService;
CancelCommand = new DelegateCommand(CancelPlanet, CanCancelPlanet);
EditCommand = new DelegateCommand(EditPlanet, CanEditPlanet);
DeleteCommand = new DelegateCommand(DeletePlanet, CanDeletePlanet);
IsInEditMode = false;
AllErrors = BindableValidator.EmptyErrorsCollection;
}
public PlanetService(ILogger <PlanetService> logger, IPlanetRepository planetRepository)
{
_logger = logger;
_planetRepository = planetRepository;
_planetRepository.AddPlanet(new Planet {
PlanetId = 1,
PlanetName = "Test Planet",
AdjacentPlanets = new List <AdjacentPlanet>()
{
new AdjacentPlanet()
{
PlanetId = 2,
Distance = 10
}
},
Market = new PlanetMarket()
{
ProductionItems = new List <ProductionItem>()
{
new ProductionItem()
{
ItemId = 1,
ItemName = "Box",
ProducedPerHour = 1000,
BaseValue = 1,
Amount = 0,
MaxAmount = 10000
}
},
ConsumableItems = new List <ConsumableItem>()
{
new ConsumableItem()
{
ItemId = 2,
ItemName = "Food",
ConsumedPerHour = 1000,
BaseValue = 2,
Amount = 0,
MaxAmount = 20000
},
new ConsumableItem()
{
ItemId = 3,
ItemName = "Metal",
ConsumedPerHour = 2000,
BaseValue = 10,
Amount = 0,
MaxAmount = 5000
}
},
LastUpdate = DateTime.Now
}
});
}
public Tree(IHebrewLetterRepository hebrewLetterRepository, ISephiraRepository sephiraRepository,
IPlanetRepository planetRepository, IZodiacSignRepository zodiacSignRepository,
IPathRepository pathRepository, IElementRepository elementRepository, IMetalRepository metalRepository)
{
Paths = pathRepository.ReadAll();
Sephiroth = sephiraRepository.ReadAll();
HebrewLetters = hebrewLetterRepository.ReadAll();
Planets = planetRepository.ReadAll();
ZodiacSigns = zodiacSignRepository.ReadAll();
Elements = elementRepository.ReadAll();
Metals = metalRepository.ReadAll();
}
public LocalDataPageViewModel(IPlanetRepository planetRepository, IJsonFileService jsonFileService) {
this.planetRepository = planetRepository;
this.jsonFileService = jsonFileService;
FileExistsCommand = new DelegateCommand(ExecuteFileExistsCommand, CanExecuteFileExistsCommand);
CreateFileCommand = new DelegateCommand(ExecuteCreateFileCommand, CanExecuteCreateFileCommand);
AddCommand = new DelegateCommand(ExecuteAddCommand, CanExecuteAddCommand);
ReadCommand = new DelegateCommand(ExecuteReadCommand, CanExecuteReadCommand);
EditCommand = new DelegateCommand(ExecuteEditCommand, CanExecuteEditCommand);
DeleteCommand = new DelegateCommand(ExecuteDeleteCommand, CanExecuteDeleteCommand);
DeleteFileCommand = new DelegateCommand(ExecuteDeleteFileCommand, CanExecuteDeleteFileCommand);
BackupFileCommand = new DelegateCommand(ExecuteBackupFileCommand, CanExecuteBackupFileCommand);
RestoreFileCommand = new DelegateCommand(ExecuteRestoreFileCommand, CanExecuteRestoreFileCommand);
}
public OverviewViewModel(IPeopleRepository peopleRepository, IFilmRepository filmRepository, IStarshipRepository starshipRepository, IVehiclesRepository vehiclesRepository, ISpeciesRepository speciesRepository, IPlanetRepository planetRepository)
{
_peopleRepository = peopleRepository;
_filmRepository = filmRepository;
_starshipRepository = starshipRepository;
_vehiclesRepository = vehiclesRepository;
_speciesRepository = speciesRepository;
_planetRepository = planetRepository;
InitCommand = new AsyncRelayCommand(Init);
RefreshCommand = new AsyncRelayCommand(RefreshAsync);
SearchCommand = new AsyncRelayCommand(SearchAsync);
ResetSearchCommand = new AsyncRelayCommand(ResetSearchAsync);
}
public PlanetsController
(
ILogger <PlanetsController> logger,
IPlanetRepository plRepo,
IPeopleRepository peopRepo,
IFilmRepository fRepo
)
{
_logger = logger;
_planetRepository = plRepo;
_filmRepository = fRepo;
_peopleRepository = peopRepo;
}
public MainWindow()
{
InitializeComponent();
_planetRepository = App.ServiceProvider.GetService <IPlanetRepository>();
_viewModel = new MainScreenViewModel(_planetRepository);
DataContext = _viewModel;
this.Loaded += async(sender, args) =>
{
await _viewModel.Load();
this.UpdateLayout();
};
}
public ValidationPageViewModel(IPlanetRepository planetRepository) {
this.planetRepository = planetRepository;
ReLoadCommand = new DelegateCommand(ReLoadPlanetVMs);
AddCommand = new DelegateCommand(AddPlanet, CanAddPlanet);
EditCommand = new DelegateCommand(EditPlanet, CanEditPlanet);
SaveCommand = new DelegateCommand(SavePlanet, CanSavePlanet);
CancelCommand = new DelegateCommand(CancelPlanet, CanCancelPlanet);
DeleteCommand = new DelegateCommand(DeletePlanet, CanDeletePlanet);
ValidateCommand = new DelegateCommand(ValidatePlanet);
IsInEditMode = false;
AllErrors = BindableValidator.EmptyErrorsCollection;
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="playerRepository">
/// The player repository.
/// </param>
/// <param name="galaxyRepository">
/// The galaxy repository.
/// </param>
/// <param name="galaxySettingsRepository">
/// The Galaxy Settings repository.
/// </param>
/// <param name="solarSystemRepository">
/// The solar system repository.
/// </param>
/// <param name="planetRepository">
/// The planet repository.
/// </param>
/// <param name="spatialEntityRepository">
/// The entity repository.
/// </param>
public Game(
IPlayerRepository playerRepository,
IGalaxyRepository galaxyRepository,
IGalaxySettingsRepository galaxySettingsRepository,
ISolarSystemRepository solarSystemRepository,
IPlanetRepository planetRepository,
ISpatialEntityRepository spatialEntityRepository)
{
this.playerRepository = playerRepository;
this.galaxyRepository = galaxyRepository;
this.galaxySettingsRepository = galaxySettingsRepository;
this.solarSystemRepository = solarSystemRepository;
this.planetRepository = planetRepository;
this.spatialEntityRepository = spatialEntityRepository;
}
public MvvmPageViewModel(IPlanetRepository planetRepository) {
this.planetRepository = planetRepository;
List<Planet> planets = planetRepository.ReLoadPlanets();
PlanetVMs = new ObservableCollection<PlanetViewModel>();
foreach (Planet p in planets) {
PlanetVMs.Add(new PlanetViewModel {
Id = p.Id,
Name = p.Name,
ImagePath = p.ImagePath,
Mass = p.Mass,
Diameter = p.Diameter,
Gravity = p.Gravity,
LengthOfDay = p.LengthOfDay,
DistanceFromSun = p.DistanceFromSun,
OrbitalPeriod = p.OrbitalPeriod,
MeanTemperature = p.MeanTemperature,
NumberOfMoons = p.NumberOfMoons
});
}
SelectedPlanetVM = PlanetVMs[2];
}
public StarType(IPlanetRepository planetsRepository, IStarSystemRepository starSystemRepository)
{
Field(s => s.StarId, nullable: false, type: typeof(IdGraphType));
Field(s => s.StarName, nullable: false).Description("Primary designation of this star");
Field(s => s.SpectralType, nullable: false);
Field(s => s.BvColorIndex, type: typeof(FloatGraphType));
Field(s => s.AbsoluteMagnitude, type: typeof(FloatGraphType));
Field(s => s.Mass, type: typeof(FloatGraphType));
Field(s => s.Radius, type: typeof(FloatGraphType));
Field(s => s.Luminosity, type: typeof(FloatGraphType));
Field(s => s.Temperature, type: typeof(FloatGraphType));
Field(s => s.Age, type: typeof(FloatGraphType));
Field(s => s.Metallicity, type: typeof(FloatGraphType));
Field(s => s.DiscoveryYear, nullable: true, type: typeof(IntGraphType));
Field <ListGraphType <PlanetType>, IEnumerable <Planet> >()
.Name("planets")
.ResolveAsync(context => planetsRepository.GetPlanetsByStarIdAsync(context.Source.StarId));
Field <StarSystemType, StarSystem>()
.Name("starSystem")
.ResolveAsync(context => starSystemRepository.GetStarSystemAsync(context.Source.StarSystemId) !);
}
public PlanetService(IPlanetRepository _planetRepository)
{
this.planetRepository = _planetRepository;
}
public WebGameMutation(
IPlayerRepository playerRepository,
IPlanetRepository planetRepository,
ICountryRepository countryRepository,
ICityRepository cityRepository
)
{
//Name = "CreatePlayerMutation";
Field <PlayerType>(
"createPlayer",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerInputType> > {
Name = "player"
}
),
resolve: context =>
{
var player = context.GetArgument <Player>("player");
return(playerRepository.Add(player));
});
Field <PlanetType>(
"createPlanet",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlanetInputType> > {
Name = "planet"
}
),
resolve: context =>
{
var planet = context.GetArgument <Planet>("planet");
return(planetRepository.Add(planet));
});
Field <CountryType>(
"createCountry",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <CountryInputType> > {
Name = "country"
}
),
resolve: context =>
{
var country = context.GetArgument <Country>("country");
return(countryRepository.Add(country));
});
Field <CityType>(
"createCity",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <CityInputType> > {
Name = "city"
}
),
resolve: context =>
{
var city = context.GetArgument <City>("city");
return(cityRepository.Add(city));
});
Field <CityType>(
"addCity",
arguments: new QueryArguments(new[] {
new QueryArgument <NonNullGraphType <AddCityInputType> > {
Name = "cityLink"
},
}
),
resolve: context =>
{
var dico = (Dictionary <string, object>)context.Arguments["cityLink"];
var country = (int)dico["country"];
var city = (int)dico["city"];
return(countryRepository.Add(country, city));
});
Field <PlanetType>(
"addCoutry",
arguments: new QueryArguments(new[] {
new QueryArgument <NonNullGraphType <AddCountryInputType> > {
Name = "countryLink"
},
}
),
resolve: context =>
{
var dico = (Dictionary <string, object>)context.Arguments["countryLink"];
var planet = (int)dico["planet"];
var country = (int)dico["country"];
return(planetRepository.Add(planet, country));
});
Field <PlayerType>(
"setCity",
arguments: new QueryArguments(new[] {
new QueryArgument <NonNullGraphType <SetCityInputType> > {
Name = "cityLink"
},
}
),
resolve: context =>
{
var dico = (Dictionary <string, object>)context.Arguments["cityLink"];
var player = (int)dico["player"];
var city = (int)dico["city"];
return(playerRepository.Add(player, city));
});
}
public LevelRepository(IDatabaseContext databaseContext, IPlanetRepository planetRepository)
{
_databaseContext = databaseContext;
_planetRepository = planetRepository;
}
/// <summary>
/// Controller Constructor.
/// </summary>
/// <param name="planetRepository">IPlanetRepository planetRepository</param>
/// <param name="swApiConnector">ISwApiConnector swApiConnector</param>
/// <param name="mapper">IMapper mapper</param>
public PlanetsController(IPlanetRepository planetRepository, ISwApiConnector swApiConnector, IMapper mapper)
{
_planetRepository = planetRepository;
_swApiConnector = swApiConnector;
_mapper = mapper;
}
public BaseController(IPlanetRepository repository)
{
_repository = repository;
}
public PlanetController(IPlanetRepository repository)
{
this.repository = repository;
}
public PlanetBusiness(IPlanetRepository repository)
{
_repository = repository;
}
public WebGameQuery(
IPlayerRepository playerRepository,
IPlanetRepository planetRepository,
ICountryRepository countryRepository,
ICityRepository cityRepository
)
{
Field <PlayerType>(
"player",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "pseudo"
}),
resolve: context => playerRepository.Get(context.GetArgument <string>("pseudo")));
Field <PlayerType>(
"randomPlayer",
resolve: context => playerRepository.GetRandom());
Field <ListGraphType <PlayerType> >(
"players",
resolve: context => playerRepository.All());
Field <PlanetType>(
"planet",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "name"
}),
resolve: context => planetRepository.Get(context.GetArgument <string>("name")));
Field <PlanetType>(
"randomPlanet",
resolve: context => planetRepository.GetRandom());
Field <ListGraphType <PlanetType> >(
"planets",
resolve: context => planetRepository.All());
Field <CountryType>(
"country",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "name"
}),
resolve: context => countryRepository.Get(context.GetArgument <string>("name")));
Field <CountryType>(
"randomCountry",
resolve: context => countryRepository.GetRandom());
Field <ListGraphType <CountryType> >(
"countries",
resolve: context => countryRepository.All());
Field <CityType>(
"cityByName",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "name"
}),
resolve: context => cityRepository.Get(context.GetArgument <string>("name")));
Field <CityType>(
"cityById",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => cityRepository.GetById(context.GetArgument <int>("id")));
Field <CityType>(
"randomCity",
resolve: context => cityRepository.GetRandom());
Field <ListGraphType <CityType> >(
"cities",
resolve: context => cityRepository.All());
}
public PlanetController(IPlanetRepository planetRepository)
{
this.planetRepository = planetRepository;
}
public PlanetService(IPlanetRepository planetRepository, IResourceRepository resourceRepository, IMissionRepository missionRepository)
{
_planetRepository = planetRepository;
_resourceRepository = resourceRepository;
_missionRepository = missionRepository;
}
public PlanetController(IMapper mapper, IPlanetRepository planetaRepository, INotificador notificador) : base(notificador)
{
_mapper = mapper;
_planetaRepository = planetaRepository;
}
public PlanetsController(IPlanetRepository planetRepository)
{
_planetRepository = planetRepository;
}
//private readonly IFacilityRepository _frepository;
public HomeController(IPlanetRepository repository, IFacilityRepository frepository)
: base(repository)
{
//_frepository = frepository;
}
public PlanetService(ILogger <PlanetService> logger, IPlanetRepository repository, ISolarSystemRepository solarSystemService)
{
m_logger = logger;
m_repository = repository;
m_solarSystemService = solarSystemService;
}
public PlanetsController(IPlanetRepository _planets)
{
this.planets = _planets;
}
public PlanetProvider(IPlanetRepository repository)
{
this.repository = repository;
}
public ResourceController(IResourceRepository repository, IPlanetRepository planetRepository)
: base(planetRepository)
{
_repository = repository;
}
public MainScreenViewModel(IPlanetRepository planetRepository)
{
_planetRepository = planetRepository;
}
public DataOperationsViewModelBase(IPlanetRepository planetRepository) {
this.planetRepository = planetRepository;
}
public PlanetService(IPlanetRepository planetRepository)
{
_planetRepository = planetRepository;
}
public PlanetsController(IServiceFactory serviceFactory)
{
_repo = new PlanetRepository(serviceFactory.CreateDB());
}
static PlanetController()
{
Kernel = new StandardKernel(new LogicModule(), new DataModule());
PlanetRepository = Kernel.Get<IPlanetRepository>();
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="playerRepository">
/// The player repository.
/// </param>
/// <param name="galaxyRepository">
/// The galaxy repository.
/// </param>
/// <param name="galaxySettingsRepository">
/// The Galaxy Settings repository.
/// </param>
/// <param name="solarSystemRepository">
/// The solar system repository.
/// </param>
/// <param name="planetRepository">
/// The planet repository.
/// </param>
/// <param name="spatialEntityRepository">
/// The entity repository.
/// </param>
public Game(
IPlayerRepository playerRepository,
IGalaxyRepository galaxyRepository,
IGalaxySettingsRepository galaxySettingsRepository,
ISolarSystemRepository solarSystemRepository,
IPlanetRepository planetRepository,
ISpatialEntityRepository spatialEntityRepository)
{
this.playerRepository = playerRepository;
this.galaxyRepository = galaxyRepository;
this.galaxySettingsRepository = galaxySettingsRepository;
this.solarSystemRepository = solarSystemRepository;
this.planetRepository = planetRepository;
this.spatialEntityRepository = spatialEntityRepository;
}
