public Funding BuyPackageByUserId(int userId, int packageId)
{
var user = dbContext.Set <User>().Where(u => u.Id == userId).Include(f => f.Fundings).SingleOrDefault();
var fundingExists = dbContext.Set <Funding>().Where(u => u.UserId == userId).Where(p => p.PackageId == packageId).SingleOrDefault();
if (fundingExists == null)
{
var newFund = new Funding()
{
PackageId = packageId, UserId = userId
};
var package = dbContext.Set <Package>().Where(p => p.Id == packageId).Include(p => p.Project).SingleOrDefault();
var project = dbContext.Set <Project>().Find(package.ProjectId);
project.CurrentFund += package.Price;
project.TimesFunded += 1;
user.Fundings.Add(newFund);
dbContext.Update(user);
dbContext.Update(project);
dbContext.SaveChanges();
return(newFund);
}
else
{
return(null);
}
}
public List <Funding> ConvertFundingFromDTO(List <FundingDTO> fundingDTO)
{
using (var db = new CrowDoDB())
{
foreach (var item in fundingDTO)
{
Funding funding = new Funding
{
Number = item.Number
};
Member member = db.Members.Where(x => x.Code.Equals(item.Backer)).FirstOrDefault();
if (member == null)
{
continue;
}
funding.Backer = member;
Project project = db.Projects.Where(x => x.Code.Equals(item.Project)).FirstOrDefault();
if (project == null)
{
continue;
}
funding.Project = project;
Packages packages = db.Packages.Where(x => x.Code.Equals(item.Package)).FirstOrDefault();
if (packages == null)
{
continue;
}
funding.Package = packages;
db.Fundings.Add(funding);
}
db.SaveChanges();
return(db.Fundings.ToList());
}
}
/// <summary>
/// Upgrades the tier to the next level.
/// </summary>
public void UnlockNextTier()
{
int tierCount = productionTiers.Count;
//Pay for the upgrade
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
{
if (IsTechUnlocked() && Funding.CanAfford(unlockCost))
{
Funding.Instance.AddFunds(-unlockCost, TransactionReasons.Vessels);
}
else
{
ScreenMessages.PostScreenMessage(WBIRefinery.kCannotAffordUpgrade, WBIRefinery.kMessageDuration, ScreenMessageStyle.UPPER_CENTER);
return;
}
}
//Now get the next tier and load it.
if (!IsMaxTier())
{
currentTier += 1;
Load(productionTiers[currentTier]);
}
}
/// <summary>
///
/// </summary>
/// <param name="funding"></param>
/// <returns></returns>
public async Task <bool> FundNoobWallet(Funding funding)
{
var wallet = GetWalletById(funding.DestinationId);
if (funding.CurrencyId == wallet.CurrencyId)
{
wallet.Balance += funding.Amount;
_transactionRepository.CreateTransaction(TransactionType.Credit, funding.Amount, wallet.Id,
wallet.CurrencyId);
}
else
{
var targetCode = _currencyRepository.GetCurrencyCode(wallet.CurrencyId);
var sourceCode = _currencyRepository.GetCurrencyCode(funding.CurrencyId);
var newAmount = await CurrencyRate.ConvertCurrency(sourceCode, targetCode, funding.Amount);
wallet.Balance += newAmount ?? 0;
_transactionRepository.CreateTransaction(TransactionType.Credit, newAmount ?? 0, wallet.Id, funding.CurrencyId);
}
return(await UpdateWallet(wallet));
}
public async Task AddAmountAsync_AllParamsAreCorrect_Ok()
{
//arrange
Guid fundingId = Guid.NewGuid();
Guid investorId = Guid.NewGuid();
decimal amount = 5000;
Funding funding = new Funding
{
Id = Guid.NewGuid(),
Name = "Fund 1",
Description = "The description of the Fund 1",
GoalAmount = 75000
};
_repository.GetFundingAsync(Arg.Any <Guid>()).Returns(funding);
//act
IFundingService service = new FundingService(_repository);
await service.AddAmountAsync(fundingId, investorId, amount);
//assert
Assert.Equal(amount, funding.CollectedAmount);
Assert.Contains(investorId, funding.InvestorIds);
await _repository.Received(1).AddAmountAsync(funding, investorId, amount);
}
public void DeleteEnrollment_DeletesDanglingSubObjects()
{
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = new Enrollment();
var child = new Child();
var funding = new Funding();
enrollment.Id = 1;
funding.Enrollment = enrollment;
funding.EnrollmentId = enrollment.Id;
enrollment.Child = child;
var enrollmentRepo = new EnrollmentRepository(context);
var fundingRepo = new FundingRepository(context);
enrollmentRepo.AddEnrollment(enrollment);
Assert.Equal(EntityState.Added, context.Entry(enrollment).State);
enrollmentRepo.DeleteEnrollment(enrollment);
Assert.Equal(EntityState.Detached, context.Entry(funding).State);
Assert.Equal(EntityState.Added, context.Entry(child).State);
Assert.Equal(EntityState.Detached, context.Entry(enrollment).State);
}
}
public void SaveFundingTest()
{
String tempFolder = Path.GetTempPath();
FundingsResult result = _api.GetFundings(new GetFundingsRequest {
Page = 0
});
Assert.AreEqual(Result.Success, result.Result);
Assert.AreEqual(1, result.Pages);
Assert.IsTrue(result.Fundings.Count >= 1);
Funding funding = result.Fundings[0];
String name = tempFolder + funding.Filename + ".cvs";
// Delete the file, if it exists:
File.Delete(name);
Assert.IsFalse(File.Exists(name));
// Save the file and check its existence:
_api.SaveFunding(funding, tempFolder);
Assert.IsTrue(File.Exists(name));
}
private void OnSubscription(SubscribedResponse response)
{
_streams.SubscriptionSubject.OnNext(response);
var channelId = response.ChanId;
// ********************
// ADD HANDLERS BELOW
// ********************
switch (response.Channel)
{
case "ticker":
_channelIdToHandler[channelId] = (data, config) =>
Ticker.Handle(data, response, config, _streams.TickerSubject);
break;
case "trades":
//if pair is null means that is funding
if (response.Pair == null)
{
_channelIdToHandler[channelId] = (data, config) =>
Funding.Handle(data, response, config, _streams.FundingsSubject);
}
else
{
_channelIdToHandler[channelId] = (data, config) =>
Trade.Handle(data, response, config, _streams.TradesSubject, _streams.TradesSnapshotSubject);
}
break;
case "candles":
_channelIdToHandler[channelId] = (data, config) =>
Candles.Handle(data, response, _streams.CandlesSubject);
break;
case "book":
_channelIdToHandler[channelId] = (data, config) =>
Book.Handle(data, response, config, _streams.BookSubject, _streams.BookSnapshotSubject, _streams.BookChecksumSubject);
break;
case "status":
if (response.Key.StartsWith("deriv"))
{
_channelIdToHandler[channelId] = (data, config) =>
DerivativePairStatus.Handle(data, response, _streams.DerivativePairSubject);
}
if (response.Key.StartsWith("liq"))
{
_channelIdToHandler[channelId] = (data, config) =>
LiquidationFeedStatus.Handle(data, response, _streams.LiquidationFeedSubject);
}
break;
//default:
// Log.Warning($"Missing subscription handler '{response.Channel}'");
// break;
}
}
public void DeleteEnrollment_DeletesDanglingSubObjects()
{
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = new Enrollment();
var child = new Child();
var funding = new Funding();
enrollment.Id = 1;
funding.Enrollment = enrollment;
funding.EnrollmentId = enrollment.Id;
enrollment.Child = child;
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var fundingRepo = new FundingRepository(context);
enrollmentRepo.AddEnrollment(enrollment);
Assert.Equal(EntityState.Added, context.Entry(enrollment).State);
enrollmentRepo.DeleteEnrollment(enrollment);
Assert.Equal(EntityState.Detached, context.Entry(funding).State);
Assert.Equal(EntityState.Added, context.Entry(child).State);
Assert.Equal(EntityState.Detached, context.Entry(enrollment).State);
}
}
private static void ReContract(RMKerbal disputekerbal)
{
if (!Funding.CanAfford((float)disputekerbal.Salary + (float)disputekerbal.OwedSalary))
{
return;
}
Funding.Instance.AddFunds(-(disputekerbal.Salary + disputekerbal.OwedSalary), TransactionReasons.CrewRecruited);
disputekerbal.Timelastsalary = Planetarium.GetUniversalTime();
disputekerbal.SalaryContractDispute = false;
disputekerbal.SalaryContractDisputeProcessed = true;
disputekerbal.SalaryContractDisputePeriods = 0;
disputekerbal.PayriseRequired = 0d;
disputekerbal.OwedSalary = 0d;
//If they are a tourist (dispute) and not dead (DeepFreeze frozen/comatose) set them back to crew
if (disputekerbal.Type != ProtoCrewMember.KerbalType.Tourist ||
disputekerbal.Status == ProtoCrewMember.RosterStatus.Dead)
{
return;
}
disputekerbal.Type = ProtoCrewMember.KerbalType.Crew;
disputekerbal.Kerbal.type = ProtoCrewMember.KerbalType.Crew;
disputekerbal.Trait = disputekerbal.RealTrait;
disputekerbal.Kerbal.trait = disputekerbal.RealTrait;
KerbalRoster.SetExperienceTrait(disputekerbal.Kerbal, disputekerbal.Kerbal.trait);
RMKerbal.RegisterExperienceTrait(disputekerbal);
}
public static Funding CreateFunding(
HedwigContext context,
FundingSource source = FundingSource.CDC,
Enrollment enrollment = null,
ReportingPeriod firstReportingPeriod = null,
ReportingPeriod lastReportingPeriod = null,
FundingSpace fundingSpace = null
)
{
enrollment = enrollment ?? EnrollmentHelper.CreateEnrollment(context);
fundingSpace = fundingSpace ??
FundingSpaceHelper.CreateFundingSpace(context, enrollment.Site.OrganizationId);
var funding = new Funding
{
EnrollmentId = enrollment.Id,
Source = source,
FirstReportingPeriodId = firstReportingPeriod != null ? firstReportingPeriod.Id : null as int?,
LastReportingPeriodId = lastReportingPeriod != null ? lastReportingPeriod.Id : null as int?,
FundingSpaceId = fundingSpace != null ? fundingSpace.Id : null as int?
};
context.Fundings.Add(funding);
context.SaveChanges();
return(funding);
}
private async Task ValidateAsync(Funding funding, Guid investorId, decimal amount)
{
if (amount < MinInvestedAmount)
{
throw new ArgumentException("The invested amount cannot be smalled than 100€.");
}
if (amount > MaxInvestedAmount)
{
throw new ArgumentException("The invested amount cannot bigger than 10000€.");
}
if (funding == null)
{
throw new ArgumentException("Funding does not exist.");
}
if (funding.InvestorIds.Contains(investorId))
{
throw new ArgumentException("The investor already invested.");
}
if (funding.CollectedAmount + amount > funding.GoalAmount)
{
throw new ArgumentException("The goal amount exceeded.");
}
}
public void buySailSeconds()
{
if (timeToBuy > 0)
{
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
{
if (Funding.CanAfford(timeToBuy * laserCost))
{
secBought += timeToBuy;
print("[Sprite Mod] Bought " + timeToBuy + " seconds for " + (laserCost * timeToBuy) + " funds");
ScreenMessages.PostScreenMessage("-" + (laserCost * timeToBuy) + " funds", 2.0f, ScreenMessageStyle.UPPER_CENTER);
Funding.Instance.AddFunds(-(laserCost * timeToBuy), TransactionReasons.None);
timeToBuy = 0;
}
else
{
ScreenMessages.PostScreenMessage("Not enough money", 5.0f, ScreenMessageStyle.UPPER_CENTER);
}
}
else
{
secBought += timeToBuy;
print("[Sprite Mod] Bought " + timeToBuy + " seconds");
timeToBuy = 0;
}
}
}
/// <summary>
/// Updates the production of the resource.
/// </summary>
public void UpdateProduction(double elapsedTime)
{
if (!isRunning)
{
return;
}
if (resourceDef == null)
{
return;
}
double unitsPerFrame = (unitsPerDay / WBIRefinery.SecondsPerDay) * elapsedTime;
double resourceCost;
//Make sure we have enough room
if (unitsPerFrame + amount > maxAmount)
{
unitsPerFrame = maxAmount - amount;
}
//Add the produced units if we can afford them
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
{
resourceCost = resourceDef.unitCost * unitCostMultiplier * unitsPerFrame;
if (Funding.CanAfford((float)resourceCost))
{
Funding.Instance.AddFunds(-resourceCost, TransactionReasons.Vessels);
amount += unitsPerFrame;
}
//Can't afford it so stop production
else
{
isRunning = false;
}
}
//Just add the units
else
{
amount += unitsPerFrame;
}
//If we're full then we're done.
if (amount >= maxAmount)
{
isRunning = false;
}
//If we have a limited production run then record what we've produced.
if (limitProduction)
{
unitsToProduce -= unitsPerFrame;
if (unitsToProduce <= 0)
{
unitsToProduce = 0;
isRunning = false;
}
}
}
public void _15_Funding()
{
AttachToProcess(Processes.Encompass, 5);
FundingWorksheet.OpenForm_FromToolsTab().txt_FundsOrdered_SendKeys("").txt_FundsSent_SendKeys("");
Funding.Open_FromLogTab().chk_Finish_Check();
}
public async Task InsertOrReplaceAsync(Funding funding)
{
var entity = new FundingEntity(GetPartitionKey(), GetRowKey());
Mapper.Map(funding, entity);
await _storage.InsertOrReplaceAsync(entity);
}
public void AddFunding(Funding fund)
{
using (var db = new CrowDoDB())
{
db.Fundings.Add(fund);
db.SaveChanges();
}
}
private void DepositFunds(int playerInput)
{
if (!Funding.CanAfford(playerInput))
{
return;
}
balance += playerInput;
Funding.Instance.AddFunds(-playerInput, TransactionReasons.None);
}
public void UpdateEnrollment_AddsFundings()
{
Enrollment enrollment;
FundingSpace fundingSpace;
using (var context = new TestHedwigContextProvider().Context)
{
enrollment = EnrollmentHelper.CreateEnrollment(context);
fundingSpace = FundingSpaceHelper.CreateFundingSpace(
context,
organizationId: enrollment.Site.OrganizationId,
source: FundingSource.CDC,
ageGroup: enrollment.AgeGroup.Value
);
}
Funding funding = new Funding
{
EnrollmentId = enrollment.Id,
Source = FundingSource.CDC,
FundingSpaceId = fundingSpace.Id
};
Assert.Null(enrollment.Fundings);
enrollment.Fundings = new List <Funding> {
funding
};
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var enrollmentDTO = mapper.Map <Enrollment, EnrollmentDTO>(enrollment);
enrollmentRepo.UpdateEnrollment(enrollment, enrollmentDTO);
context.SaveChanges();
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var retrievedEnrollment = enrollmentRepo.GetEnrollmentById(enrollment.Id);
Assert.NotEmpty(retrievedEnrollment.Fundings);
var retrievedFunding = retrievedEnrollment.Fundings.FirstOrDefault();
Assert.Equal(funding.Id, retrievedFunding.Id);
}
}
public async Task <Funding> SelectById(int id)
{
Funding funding = new Funding();
funding = await db.Funding.AsNoTracking()
.FirstOrDefaultAsync(f => f.Id == id);
return(funding);
}
protected void drawRushJobButton(EditorBayItem editorBayItem)
{
//Rush jobs only apply to Career games.
if (HighLogic.CurrentGame.Mode != Game.Modes.CAREER)
{
return;
}
Color oldColor = GUI.backgroundColor;
ShipConstruct ship = EditorLogic.fetch.ship;
int totalMaxReliability = 100 * editorBayItem.breakablePartCount;
int baseQuality = editorBayItem.totalQuality + editorBayItem.totalIntegrationAdded;
int maxQuality = editorBayItem.totalQuality + editorBayItem.totalIntegrationAdded + editorBayItem.totalIntegrationToAdd;
float rushJobCost = editorBayItem.rushJobCost * (1.0f - ((float)baseQuality / (float)maxQuality));
//Rush Job button (Career only?)
GUILayout.BeginHorizontal();
GUI.backgroundColor = XKCDColors.ColorTranslator.FromHtml("#c3fa70");
if (GUILayout.Button(fundsIcon, buttonOptions))
{
//Can we afford it?
if (Funding.CanAfford(rushJobCost))
{
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER && !BARISScenario.showDebug)
{
Funding.Instance.AddFunds(-rushJobCost, TransactionReasons.Any);
}
//Add the integration cap to the base quality, and clear the cap.
if (editorBayItem.totalIntegrationToAdd > 0)
{
editorBayItem.totalIntegrationAdded = editorBayItem.totalIntegrationToAdd;
editorBayItem.totalIntegrationToAdd = 0;
}
//Delete the KAC alarm if any
if (KACWrapper.AssemblyExists && KACWrapper.APIReady && !string.IsNullOrEmpty(editorBayItem.KACAlarmID))
{
KACWrapper.KAC.DeleteAlarm(editorBayItem.KACAlarmID);
}
//Load the vessel
loadVessel(editorBayItem, false);
}
else //Inform user
{
BARISScenario.Instance.LogPlayerMessage(Localizer.Format(BARISScenario.CannotAffordRushMsg));
}
}
GUI.backgroundColor = oldColor;
fundsIcon = selectFundsIcon();
//Rush job cost
GUILayout.Label("<color=white><b>" + Localizer.Format(BARISScenario.CostLabel) + "</b>" + string.Format("{0:n0}", rushJobCost) + "</color>");
GUILayout.EndHorizontal();
}
/// <inheritdoc />
public async Task AddAmountAsync(Guid fundingId, Guid investorId, decimal amount)
{
Funding funding = await _repository.GetFundingAsync(fundingId);
await ValidateAsync(funding, investorId, amount);
funding.CollectedAmount += amount;
funding.InvestorIds.Add(investorId);
await _repository.AddAmountAsync(funding, investorId, amount);
}
public bool PurchaseConfig(PartUpgradeHandler.Upgrade upgd)
{
if (Funding.CanAfford(upgd.entryCost))
{
Funding.Instance?.AddFunds(-upgd.entryCost, TransactionReasons.RnDPartPurchase);
PartUpgradeManager.Handler.SetUnlocked(upgd.name, true);
return(true);
}
return(false);
}
/// <summary>
/// Determines whether or not the player can afford to unlock the node
/// </summary>
/// <returns>True if the player can afford the upgrade, false if not.</returns>
public bool CanAffordUnlock()
{
if (HighLogic.CurrentGame.Mode != Game.Modes.CAREER && HighLogic.CurrentGame.Mode != Game.Modes.SCIENCE_SANDBOX)
{
return(true);
}
else
{
return(Funding.CanAfford(unlockCost));
}
}
private void ProcessContractDispute(ProtoCrewMember crew, KeyValuePair <string, RMKerbal> kerbal, double currentTime, bool start, bool extend)
{
// They will continue to work for RMLifeSpan.Instance.rmGameSettings.MaxContractDisputePeriods of salaryperiod, with a payrise that must be accepted each time. All backpay is accrued.
// Or they quit/strike after RMLifeSpan.Instance.rmGameSettings.MaxContractDisputePeriods or if user does not accept the payrise.
RmUtils.LogMessage($"RosterManagerLifeSpanAddon.CheckSalary unable to pay {crew.name} salary.", "info", RMSettings.VerboseLogging);
if (start) //Start a new contract dispute
{
ScreenMessages.PostScreenMessage($"{Localizer.Format("#autoLOC_RM_1103")} {crew.name}", 5.0f, ScreenMessageStyle.UPPER_CENTER); // #autoLOC_RM_1103 = Insufficient funds to pay {0} salary at this time.
kerbal.Value.SalaryContractDispute = true;
kerbal.Value.RealTrait = kerbal.Value.Trait;
//Start processing dispute, increase the periods we have been in dispute, user must accept payrise as well (if they don't the kerbal Quits) and calculate and store their backpay owed.
ExtendContractDispute(crew, kerbal);
}
else // Process existing contract dispute
{
//Check if we have funds now?
//If we have pay them.
//Else extend the contract dispute.
if (Funding.CanAfford((float)kerbal.Value.Salary + (float)kerbal.Value.OwedSalary))
{
Funding.Instance.AddFunds(-(kerbal.Value.Salary + kerbal.Value.OwedSalary), TransactionReasons.CrewRecruited);
kerbal.Value.Timelastsalary = currentTime;
kerbal.Value.SalaryContractDispute = false;
kerbal.Value.SalaryContractDisputeProcessed = true;
kerbal.Value.SalaryContractDisputePeriods = 0;
kerbal.Value.PayriseRequired = 0d;
kerbal.Value.OwedSalary = 0d;
//If they are a tourist (dispute) and not dead (DeepFreeze frozen/comatose) set them back to crew
if (kerbal.Value.Type == ProtoCrewMember.KerbalType.Tourist && crew.rosterStatus != ProtoCrewMember.RosterStatus.Dead)
{
kerbal.Value.Type = ProtoCrewMember.KerbalType.Crew;
crew.type = ProtoCrewMember.KerbalType.Crew;
kerbal.Value.Trait = kerbal.Value.RealTrait;
crew.trait = kerbal.Value.RealTrait;
KerbalRoster.SetExperienceTrait(crew, crew.trait);
RMKerbal.RegisterExperienceTrait(kerbal.Value);
}
RmUtils.LogMessage($"RosterManagerLifeSpanAddon.CheckSalary paid {crew.name} salary.", "info", RMSettings.VerboseLogging);
RmUtils.LogMessage($"RosterManagerLifeSpanAddon.CheckSalary contract dispute ended {crew.name}", "info", RMSettings.VerboseLogging);
ScreenMessages.PostScreenMessage(
$"{crew.name} {Localizer.Format("#autoLOC_RM_1104")} {kerbal.Value.Salary + kerbal.Value.OwedSalary}", 5.0f, ScreenMessageStyle.UPPER_CENTER); // #autoLOC_RM_1104 = Paid {0} salary of {1}
ScreenMessages.PostScreenMessage($"{crew.name} {Localizer.Format("#autoLOC_RM_1105")}", 5.0f, ScreenMessageStyle.UPPER_CENTER); // #autoLOC_RM_1105 = {0} contract dispute ended.
}
else //Can't end dispute
{
if (!extend)
{
return;
}
kerbal.Value.Timelastsalary = currentTime;
ExtendContractDispute(crew, kerbal);
}
}
}
internal void ThawFrozenCrew(String FrozenCrew, Guid vesselID)
{
Utilities.Log("DeepFreezeEvents ThawFrozenCrew = " + FrozenCrew + "," + vesselID);
bool fundstaken = false;
ProtoCrewMember kerbal = HighLogic.CurrentGame.CrewRoster.Unowned.FirstOrDefault(a => a.name == FrozenCrew);
if (kerbal != null)
{
Vessel vessel = FlightGlobals.Vessels.Find(v => v.id == vesselID);
// Utilities.Log_Debug("vessel mainbody" + vessel.mainBody.name + " is homeworld? " + vessel.mainBody.isHomeWorld);
if (vessel == null ||
(vessel.mainBody.isHomeWorld &&
(vessel.situation == Vessel.Situations.LANDED || vessel.situation == Vessel.Situations.PRELAUNCH || vessel.situation == Vessel.Situations.SPLASHED)))
{
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
{
if (Funding.CanAfford(DFsettings.KSCcostToThawKerbal))
{
Funding.Instance.AddFunds(-DFsettings.KSCcostToThawKerbal, TransactionReasons.Vessels);
fundstaken = true;
Utilities.Log("Took funds to thaw kerbal");
}
else
{
Utilities.Log("Not enough funds to thaw kerbal");
ScreenMessages.PostScreenMessage("Insufficient funds to thaw " + kerbal.name + " at this time", 5.0f, ScreenMessageStyle.UPPER_LEFT);
return;
}
}
kerbal.type = ProtoCrewMember.KerbalType.Crew;
kerbal.rosterStatus = ProtoCrewMember.RosterStatus.Assigned;
Utilities.Log_Debug("Kerbal " + kerbal.name + " " + kerbal.type + " " + kerbal.rosterStatus);
kerbal.ArchiveFlightLog();
kerbal.rosterStatus = ProtoCrewMember.RosterStatus.Available;
Utilities.Log_Debug("Kerbal " + kerbal.name + " " + kerbal.type + " " + kerbal.rosterStatus);
if (!fundstaken)
{
ScreenMessages.PostScreenMessage(kerbal.name + " was found and thawed out", 5.0f, ScreenMessageStyle.UPPER_LEFT);
}
else
{
ScreenMessages.PostScreenMessage(kerbal.name + " was found and thawed out " + DFsettings.KSCcostToThawKerbal.ToString("########0") + " funds deducted from account", 5.0f, ScreenMessageStyle.UPPER_CENTER);
}
DFgameSettings.KnownFrozenKerbals.Remove(kerbal.name);
}
else
{
Utilities.Log("Cannot thaw, vessel still exists " + vessel.situation + " at " + vessel.mainBody.bodyName);
ScreenMessages.PostScreenMessage("Cannot thaw " + kerbal.name + " vessel still exists " + vessel.situation + " at " + vessel.mainBody.bodyName, 5.0f, ScreenMessageStyle.UPPER_CENTER);
}
}
}
/// <summary>
/// Checks if the funcding exists
/// </summary>
/// <param name="funding">An instance of <see cref="Funding"/></param>
/// <returns></returns>
public async Task <bool> CheckIfTheInvestmentExist(Funding funding)
{
// check if the funding exists in the db
var dbFunding = await(_digitalInvestDbContext.Fundings.Where(f => f.ProjectId == funding.ProjectId && f.InvestorId == funding.InvestorId)).FirstOrDefaultAsync();
if (dbFunding == null)
{
return(false);
}
return(true);
}
//"Outsourcing" is when a player pays to freeze time for a number of minutes.
//This allows the player to make crafts faster when in a hurry, but at an increased cost.
public void Outsource()
{
//return if player cannot afford or is already outsourcing.
if (!Funding.CanAfford(settings.outsourceCost) ||
OutsourceTimer().HasValue)
{
return;
}
Funding.Instance.AddFunds(-settings.outsourceCost, TransactionReasons.None);
lastUpdate = DateTime.MaxValue;
lastOutsource = DateTime.Now;
}
/// <inheritdoc />
public async Task AddAmountAsync(Funding funding, Guid investorId, decimal amount)
{
Funding entity = _fundings.Single(f => f.Id == funding.Id);
entity.CollectedAmount = funding.CollectedAmount;
entity.InvestorIds = funding.InvestorIds;
_fundingInvestors.Add(new FundingInvestor
{
FundingId = funding.Id,
InvestorId = investorId,
Amount = amount
});
}
internal void handleUpgrade()
{
int oldLevel = getMember <int>("level");
KCTDebug.Log($"Upgrading from level {oldLevel}");
string facilityID = GetFacilityID();
KCT_UpgradingBuilding upgrading = new KCT_UpgradingBuilding(facilityID, oldLevel + 1, oldLevel, facilityID.Split('/').Last());
upgrading.isLaunchpad = facilityID.ToLower().Contains("launchpad");
if (upgrading.isLaunchpad)
{
upgrading.launchpadID = KCT_GameStates.ActiveKSC.ActiveLaunchPadID;
if (upgrading.launchpadID > 0)
{
upgrading.commonName += KCT_GameStates.ActiveKSC.ActiveLPInstance.name;
}
}
if (!upgrading.AlreadyInProgress())
{
float cost = getMember <float>("upgradeCost");
if (Funding.CanAfford(cost))
{
Funding.Instance.AddFunds(-cost, TransactionReasons.Structures);
KCT_GameStates.ActiveKSC.KSCTech.Add(upgrading);
upgrading.SetBP(cost);
upgrading.cost = cost;
ScreenMessages.PostScreenMessage("Facility upgrade requested!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
KCTDebug.Log($"Facility {facilityID} upgrade requested to lvl {oldLevel + 1} for {cost} funds, resulting in a BP of {upgrading.BP}");
}
else
{
KCTDebug.Log("Couldn't afford to upgrade.");
ScreenMessages.PostScreenMessage("Not enough funds to upgrade facility!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
}
}
else if (oldLevel + 1 != upgrading.currentLevel)
{
ScreenMessages.PostScreenMessage("Facility is already being upgraded!", 4.0f, ScreenMessageStyle.UPPER_CENTER);
KCTDebug.Log($"Facility {facilityID} tried to upgrade to lvl {oldLevel+1} but already in list!");
}
_menu.Dismiss(KSCFacilityContextMenu.DismissAction.None);
}
public SavedGameState()
{
money = gameManager.Instance.getMoney();
funding = gameManager.Instance.getFunding();
time = gameManager.Instance.getTime();
pendingRequests = gameManager.Instance.getPendingRequests();
currentBase = gameManager.Instance.getCurrentBaseNum();
availableId = gameManager.Instance.getAvailableId();
availableWeapons = gameManager.Instance.getAvailableWeapons();
unresearchedWeapons = gameManager.Instance.getUnresearchedWeapons();
nameList = gameManager.Instance.getNameList();
// set random with new
bases = gameManager.Instance.getBases();
activeLevel = gameManager.Instance.getLevel();
missionsSuccess = gameManager.Instance.getMissionSuccess();
missionsFailed = gameManager.Instance.getMissionFailed();
CiviliansKilled = gameManager.Instance.CiviliansKilled;
CiviliansSaved = gameManager.Instance.CiviliansSaved;
}
//This is where we instantiate every variables for a new game
public void startState()
{
print ("Creating a new game state.");
//Set variables relevent to game manager
money = 500000;
funding = new Funding();
time = System.DateTime.Now;
// variable used to create new soldiers.
availableId = 0;
//Calling the new scene
setLevel("WorldMap");
nameList = createNameList();
missionsSuccess = 0;
missionsFailed = 0;
}
// Start from saved game
public void setState(SavedGameState save)
{
this.money = save.money;
this.funding = save.funding;
this.time = save.time;
this.pendingRequests = save.pendingRequests;
this.currentBase = save.currentBase;
this.availableId = save.availableId;
this.availableWeapons = save.availableWeapons;
this.unresearchedWeapons = save.unresearchedWeapons;
this.nameList = save.nameList;
this.random = new System.Random();
this.bases = save.bases;
missionsSuccess = save.missionsSuccess;
missionsFailed = save.missionsFailed;
CiviliansKilled = save.CiviliansKilled;
CiviliansSaved = save.CiviliansSaved;
setLevel("WorldMap");
}
