public void ProcessTurn(IHub services) { var personService = services.Resolve<IPersonService>(); var gameClockService = services.Resolve<IGameClockService>(); foreach(var person in personService.People.Where(p => !personService.IsRetired(p))) { if (person.RetirementDate > gameClockService.CurrentDate) { continue; } var currentWorkHistory = person.WorkHistory.FirstOrDefault(wh => !wh.EndDate.HasValue); if(currentWorkHistory != null) { var employee = currentWorkHistory.Company.GetEmployee(person.Id); if(!employee.IsFounder) { currentWorkHistory.EndDate = gameClockService.CurrentDate; currentWorkHistory.EndingSalary = employee.Salary; } } } }
public void ProcessTurn(IHub services) { var companyService = services.Resolve<ICompanyService>(); var gameClockService = services.Resolve<IGameClockService>(); foreach(var company in companyService.Companies) { foreach(var project in company.Projects) { if (IsProjectComplete(project)) { CompleteProject(company, project); companyService.ProcessTransaction(company, TransactionType.Project, project.Value, $"Completed {project.Definition.Name} project."); } else { var deadline = project.ExtensionDeadline.HasValue ? project.ExtensionDeadline.Value : project.Deadline; if (gameClockService.CurrentDate >= deadline) { FailProject(company, project); } } } } }
public IEnumerable<IActionData> GenerateData(IHub services, Company company) { var actionData = new List<IActionData>(); var recruitAction = company.Actions.FirstOrDefault(a => a.Action.Id == (byte)ActionType.RecruitPerson); if (recruitAction.Count == 0) { return actionData; } var founder = company.Employees.FirstOrDefault(e => e.IsFounder); var configurationService = services.Resolve<IConfigurationService>(); var fastGrowth = configurationService.GetDecimalValue(ConfigurationKey.FastCompanyGrowthValue, ConfigurationFallbackValue.FastCompanyGrowthValue); var growthTarget = founder.Person.GetPersonalityValue(PersonalityAttributeId.DesiredCompanyGrowth); var growthImportance = founder.Person.GetPersonalityValue(PersonalityAttributeId.CompanyGrowthImportance); var targetNumberOfProspects = fastGrowth * growthTarget; var maxDifferential = fastGrowth * (1m - growthImportance); var differential = (int)(targetNumberOfProspects - company.Prospects.Count); if (differential <= maxDifferential) { return actionData; } var personService = services.Resolve<IPersonService>(); var recruitCount = recruitAction.Count; var recruitTargetCount = targetNumberOfProspects - maxDifferential; while (recruitCount-- > 0 && (company.Prospects.Count + actionData.Count) < recruitTargetCount) { var person = personService.GetUnemployedPerson(); actionData.Add(new RecruitPersonActionData(person.Id)); } return actionData; }
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount) { var perkService = services.Resolve<IPerkService>(); var applicablePerkCount = company.Perks.Count(cp => cp.Count > 0 && perkService.DoesPerkApplyTo(cp.Perk, person)); var personService = services.Resolve<IPersonService>(); var minimumPerkCount = person.GetPersonalityValue(PersonalityAttributeId.MinimumPerkCount); if(minimumPerkCount <= applicablePerkCount) { return null; } return OfferResponseReason.Perks; }
public void ProcessTurn(IHub services) { var personService = services.Resolve<IPersonService>(); var configurationService = services.Resolve<IConfigurationService>(); var minimumPersonCount = configurationService.GetIntValue(ConfigurationKey.MinimumPersonCount, ConfigurationFallbackValue.MinimumPersonCount); var nonRetiredPersonCount = personService.People.Count(p => !personService.IsRetired(p)); var numberOfPeopleToGenerate = minimumPersonCount - nonRetiredPersonCount; if(numberOfPeopleToGenerate > 0) { personService.GeneratePeople(numberOfPeopleToGenerate); } }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as MakeOfferActionData; var personService = services.Resolve<IPersonService>(); var companyService = services.Resolve<ICompanyService>(); var person = personService.GetPerson(data.PersonId); var gameClockService = services.Resolve<IGameClockService>(); var message = new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Human Resources" }; if (personService.IsUnemployed(person)) { var response = companyService.MakeOffer(company, person, data.OfferValue); if (response.DidAccept) { message.Subject = "Offer Accepted"; message.Message = $"{person.FirstName} {person.LastName} accepted an offer of {data.OfferValue:C}."; } else { message.Subject = "Offer Declined"; message.Message = $"{person.FirstName} {person.LastName} declined an offer of {data.OfferValue:C}."; } } else { message.Subject = "Offer Too Late"; message.Message = $"{person.FirstName} {person.LastName} recently accepted an offer elsewhere."; } return message; }
public void ProcessTurn(IHub services) { var projectService = services.Resolve<IProjectService>(); var configurationService = services.Resolve<IConfigurationService>(); var minimumProjectCount = configurationService.GetIntValue(ConfigurationKey.MinimumProjectCount, ConfigurationFallbackValue.MinimumProjectCount); var numberOfProjectsToGenerate = minimumProjectCount - projectService.Projects.Count(); if (numberOfProjectsToGenerate > 0) { var gameService = services.Resolve<IGameService>(); projectService.GenerateProjects(gameService.CurrentIndustry, numberOfProjectsToGenerate); } }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as AcceptProjectActionData; var projectService = services.Resolve<IProjectService>(); var project = projectService.GetProject(data.ProjectId); var gameClockService = services.Resolve<IGameClockService>(); var message = new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Source = "Project Management", Status = CompanyMessageStatus.UnRead }; if (project != null) { if (projectService.CanAcceptProject(project, company.Reputation)) { var companyService = services.Resolve<ICompanyService>(); companyService.AcceptProject(company, project); message.Subject = "We got the project!"; message.Message = $"We have been granted the {project.Definition.Name} project."; } else { message.Subject = "We did not get the project..."; message.Message = $"We were deemed not reputable enough to be granted the {project.Definition.Name} project."; } } else { message.Subject = "We missed out on the project."; message.Message = $"A project we were seeking has been given to another company."; } return message; }
public void ProcessTurn(IHub services) { var companyService = services.Resolve<ICompanyService>(); foreach(var company in companyService.Companies) { var accumulations = new Dictionary<int, decimal>(); foreach (var employee in company.Employees) { var allocations = company.Allocations.Where(a => a.Employee == employee); var skillValues = new Dictionary<int, decimal>(); var remainingSkillValues = new Dictionary<int, decimal>(); foreach (var skill in employee.Person.Skills) { var skillValue = CalculateEmployeeSkillValue(employee, skill); skillValues.Add(skill.SkillDefinition.Id, skillValue); remainingSkillValues.Add(skill.SkillDefinition.Id, skillValue); } foreach (var allocation in allocations) { foreach (var requirement in allocation.Project.Requirements) { if (skillValues.ContainsKey(requirement.SkillDefinition.Id)) { var value = allocation.Percent * skillValues[requirement.SkillDefinition.Id]; requirement.CurrentValue += value; remainingSkillValues[requirement.SkillDefinition.Id] -= value; } } } foreach (var skill in remainingSkillValues) { if (accumulations.ContainsKey(skill.Key)) { accumulations[skill.Key] += skill.Value; } else { accumulations.Add(skill.Key, skill.Value); } } } ProcessActionAccumulations(company, accumulations); } }
public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services) { var companyService = services.Resolve<ICompanyService>(); if (!companyService.CanPerformAction(company, Type)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company); } return new ActionExecutionInformation(true); }
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount) { var personService = services.Resolve<IPersonService>(); var expectedCompensation = personService.CalculateCompensationValue(person); if(amount >= expectedCompensation) { return null; } return OfferResponseReason.OfferValue; }
public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services) { var companyService = services.Resolve<ICompanyService>(); if (!companyService.CanPerformAction(company, Type)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company); } var data = eventData as PurchasePerkActionData; var perkService = services.Resolve<IPerkService>(); var perk = perkService.GetPerk(data.PerkId); if(!perkService.CanPurchasePerk(company, perk, data.Count)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot purchase {data.Count} of perk {perk.Id}.", company, data); } return new ActionExecutionInformation(true); }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as RecruitPersonActionData; var personService = services.Resolve<IPersonService>(); var companyService = services.Resolve<ICompanyService>(); var person = personService.GetPerson(data.PersonId); var gameClockService = services.Resolve<IGameClockService>(); var message = new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Human Resources" }; if(personService.IsUnemployed(person)) { companyService.RecruitPerson(company, person); message.Subject = "Recruited Candidate"; message.Message = $"We have successfully recruited {person.FirstName} {person.LastName}."; } else { message.Subject = "Missed a Potential Recruit"; message.Message = $"{person.FirstName} {person.LastName} has been recently employed and cannot be recruited at this time."; } return message; }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as InterviewProspectActionData; var companyService = services.Resolve<ICompanyService>(); var prospect = company.GetProspect(data.PersonId); var personService = services.Resolve<IPersonService>(); var gameClockServices = services.Resolve<IGameClockService>(); var message = new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockServices.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Human Resources" }; if(personService.IsUnemployed(prospect.Person)) { companyService.InterviewProspect(company, prospect); message.Subject = "Interview Complete"; message.Message = $"{prospect.Person.FirstName} {prospect.Person.LastName} has completed a round of interviews."; } else { message.Subject = "Prospect Off the Market"; message.Message = $"{prospect.Person.FirstName} {prospect.Person.LastName} has recently accepted an offer elsewhere."; } return message; }
public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services) { var companyService = services.Resolve<ICompanyService>(); if(!companyService.CanPerformAction(company, Type)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company); } var data = eventData as SellPerkActionData; var perkService = services.Resolve<IPerkService>(); var perk = perkService.GetPerk(data.PerkId); var companyPerk = company.GetPerk(perk); if(companyPerk.Count < data.Count) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot sell {data.Count} perks (ID: {perk.Id}).", perk, company); } return new ActionExecutionInformation(true); }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as PurchasePerkActionData; var perkService = services.Resolve<IPerkService>(); var perk = perkService.GetPerk(data.PerkId); var companyService = services.Resolve<ICompanyService>(); companyService.PurchasePerk(company, perk, data.Count); var gameClockService = services.Resolve<IGameClockService>(); return new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Finance", Subject = "Purchase Made", Message = $"Purchased {data.Count} {perk.Name} perks." }; }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as AdjustSalaryActionData; var companyService = services.Resolve<ICompanyService>(); var employee = company.GetEmployee(data.PersonId); var previousSalary = employee.Salary; companyService.AdjustSalary(company, employee, data.Salary); var gameClockService = services.Resolve<IGameClockService>(); return new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Human Resources", Subject = "Employee Salary Adjustment", Message = $"{employee.Person.FirstName} {employee.Person.LastName}'s salary has been adjust from {previousSalary:C} to {employee.Salary:C}." }; }
public override CompanyMessage ProcessEvent(Company company, IActionData eventData, IHub services) { var data = eventData as AdjustAllocationActionData; var employee = company.GetEmployee(data.PersonId); var project = company.GetProject(data.ProjectId); var companyService = services.Resolve<ICompanyService>(); companyService.AdjustAllocation(company, employee, project, data.Percentage, data.Role); var gameClockService = services.Resolve<IGameClockService>(); return new CompanyMessage { Id = Utilities.InvalidId, DateCreated = gameClockService.CurrentDate, Status = CompanyMessageStatus.UnRead, Source = "Project Management", Subject = "Employee has been reallocated.", Message = $"{employee.Person.FirstName} {employee.Person.LastName} has been directed to work on {project.Definition.Name} {data.Percentage:P} in a {data.Role} role." }; }
public void ProcessTurn(IHub services) { var companyService = services.Resolve<ICompanyService>(); foreach(var company in companyService.Companies) { foreach(var employee in company.Employees) { if (!employee.IsFounder && employee.Salary != 0) { companyService.ProcessTransaction(company, TransactionType.Payroll, -employee.Salary, $"Paid {employee.Person.FirstName} {employee.Person.LastName} {employee.Salary:C}."); } } } }
public void ProcessTurn(IHub services) { var companyService = services.Resolve<ICompanyService>(); foreach(var company in companyService.Companies) { foreach (var perk in company.Perks) { var cost = perk.Count * perk.Perk.RecurringCost; var message = $"Charged {cost:C} for {perk.Count} {perk.Perk.Name} perks."; companyService.ProcessTransaction(company, TransactionType.Perk, -cost, message); } } }
public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services) { var companyService = services.Resolve<ICompanyService>(); if (!companyService.CanPerformAction(company, Type)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company); } var data = eventData as AdjustSalaryActionData; if (data.Salary < 0) { return new ActionExecutionInformation(false, $"Cannot have a negative employee value.", company, data.Salary); } return new ActionExecutionInformation(true); }
public override ActionExecutionInformation CanPerformEvent(Company company, IActionData eventData, IHub services) { var companyService = services.Resolve<ICompanyService>(); if (!companyService.CanPerformAction(company, Type)) { return new ActionExecutionInformation(false, $"Company {company.Id} cannot perform turn action {Type}.", company); } var data = eventData as MakeOfferActionData; if(company.Money < data.OfferValue) { return new ActionExecutionInformation(false, $"Company {company.Id} does not have {data.OfferValue:C} for this offer.", company, data); } if (data.OfferValue < 0) { return new ActionExecutionInformation(false, $"Cannot offer negative amounts of money.", company, data); } return new ActionExecutionInformation(true); }
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount) { var configurationService = services.Resolve<IConfigurationService>(); var largeCompanySize = configurationService.GetIntValue(ConfigurationKey.LargeCompanySize, ConfigurationFallbackValue.LargeCompanySize); var weight = Math.Min((decimal)company.Employees.Count / (decimal)largeCompanySize, 1m); var desiredSize = person.GetPersonalityValue(PersonalityAttributeId.DesiredCompanySize); var importance = person.GetPersonalityValue(PersonalityAttributeId.CompanySizeImportance); var differential = Math.Abs(desiredSize - weight) * importance; var maxDifferential = configurationService.GetDecimalValue(ConfigurationKey.CompanySizeMaxDifferential, ConfigurationFallbackValue.CompanySizeMaxDifferential); if (differential <= maxDifferential) { return null; } return OfferResponseReason.CompanySize; }
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount) { var configurationService = services.Resolve<IConfigurationService>(); var fastCompanyGrowth = configurationService.GetIntValue(ConfigurationKey.FastCompanyGrowthValue, ConfigurationFallbackValue.FastCompanyGrowthValue); var weight = Math.Min((decimal)company.Prospects.Count / (decimal)fastCompanyGrowth, 1m); var desiredGrowth = person.GetPersonalityValue(PersonalityAttributeId.DesiredCompanyGrowth); var importance = person.GetPersonalityValue(PersonalityAttributeId.CompanyGrowthImportance); var differential = Math.Abs(desiredGrowth - weight) * importance; var maxDifferential = configurationService.GetDecimalValue(ConfigurationKey.CompanyGrowthMaxDifferential, ConfigurationFallbackValue.CompanyGrowthMaxDifferential); if (differential <= maxDifferential) { return null; } return OfferResponseReason.CompanyGrowth; }
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount) { var workload = 0m; if (company.Employees.Any()) { workload = (decimal)company.Projects.Count / (decimal)company.Employees.Count; } var personService = services.Resolve<IPersonService>(); var minWorkload = person.GetPersonalityValue(PersonalityAttributeId.MinimumDesiredEmployeeWorkload); var maxWorkload = person.GetPersonalityValue(PersonalityAttributeId.MaximumDesiredEmployeeWorkload); if (workload >= minWorkload && workload <= maxWorkload) { return null; } return OfferResponseReason.EmployeeWorkload; }
public void ProcessTurn(IHub services) { var gameClockService = services.Resolve<IGameClockService>(); gameClockService.ProcessTurn(); }
public static Employee GetRandomUserCompanyEmployee(IHub services, bool excludeFounder = true) { var companyService = services.Resolve<ICompanyService>(); var company = companyService.UserCompany; Employee output = null; if(excludeFounder) { output = company.Employees.Random(e => !e.IsFounder); } else { output = company.Employees.Random(); } return output; }
public static Employee GetUserCompanyEmployee(IHub services, int personId) { var companyService = services.Resolve<ICompanyService>(); var company = companyService.UserCompany; return company.GetEmployee(personId); }
public static CompanyServiceData CreateNewGame(IHub services, int gameId, int companyCount) { var personRepository = services.Resolve<IPersonRepository>(); var personService = services.Resolve<IPersonService>(); var projectRepository = services.Resolve<IProjectRepository>(); var projectService = services.Resolve<IProjectService>(); var perkService = services.Resolve<IPerkService>(); var companyRepository = services.Resolve<ICompanyRepository>(); var actionService = services.Resolve<IActionService>(); using (var transaction = new RepositoryTransaction(personRepository)) { personRepository.SaveGame(gameId, new PersonServiceData { People = new List<Person>() }); } personService.LoadGame(new LoadGameData { GameId = gameId }); using (var transaction = new RepositoryTransaction(projectRepository)) { projectRepository.SaveGame(gameId, new ProjectServiceData { Projects = new List<Project>() }); } projectService.LoadGame(new LoadGameData { GameId = gameId }); var maxThingCount = 5; personService.GeneratePeople(companyCount * maxThingCount); projectService.GenerateProjects(Industries.FirstOrDefault(), companyCount * maxThingCount); var companies = new List<Company>(); for (var companyIndex = 0; companyIndex < companyCount; companyIndex++) { var cActions = GenerateCompanyActions(actionService.Actions); var company = new Company(cActions) { Id = Utilities.GetRandomInt(), InitialAccuracy = Utilities.GetRandomDecimal(), Money = Utilities.GetRandomDecimal(0, decimal.MaxValue), Name = Utilities.GetRandomString(), UserId = Utilities.GetRandomInt() }; if (companyIndex == 1) { companies[0].Rival = company; } var possibleStars = Utilities.GetRandomInt(1, 1000); company.Reputation.PossibleStars = possibleStars; company.Reputation.EarnedStars = Utilities.GetRandomInt(0, possibleStars); GenerateCompanyEmployees(personService, company, Utilities.GetRandomInt(1, maxThingCount)); GenerateCompanyPerks(perkService, company, Utilities.GetRandomInt(1, maxThingCount)); GenerateCompanyProjects(projectService, company, Utilities.GetRandomInt(1, maxThingCount)); GenerateCompanyProspects(personService, company, Utilities.GetRandomInt(1, maxThingCount)); GenerateCompanyTransactions(company, Utilities.GetRandomInt(1, maxThingCount)); companies.Add(company); } var output = new CompanyServiceData { Companies = companies }; using (var transaction = new RepositoryTransaction(companyRepository)) { companyRepository.SaveGame(gameId, output); } return output; }