public void Create_AttrValuesFields_ForWork(Work _work, WorkTypeEnum type)
{
ChangeTracker.DetectChanges();
int typeID = (int)type;
var oldAttrIds = _work.AttrValues.Select(a => a.AttrID).ToList();
List <int> attrIDs = (from a in WorkTypeAttrs where a.WorkTypeID == typeID select a.AttrID).ToList();
attrIDs.RemoveAll(a => oldAttrIds.Contains(a)); //Удаляем те атрибуты, что была, добавлять будем только новые
List <AttrValue> vals = new List <AttrValue>();
foreach (var a in attrIDs)
{
AttrValue value = new AttrValue();
value.WorkID = _work.ID;
value.AttrID = a; // todo почему здесь не заполняется поле DataType ?
vals.Add(value);
}
AttrValues.AddRange(vals);
try
{
SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
public static string ToHumanReadable(this WorkTypeEnum workType)
{
switch (workType)
{
case WorkTypeEnum.Any:
return("Any");
case WorkTypeEnum.Construction:
return("construction");
case WorkTypeEnum.Manufacturing:
return("manufacturing");
case WorkTypeEnum.Raw:
return("raw");
case WorkTypeEnum.Selling:
return("selling");
}
#if DEBUG
throw new ArgumentException(string.Format("{0} not human readable", workType.ToString()));
#else
return(workType.ToString());
#endif
}
public static double GetWorkSkill(this Citizen citizen, WorkTypeEnum workType)
{
switch (workType)
{
case WorkTypeEnum.Construction:
{
return((double)citizen.Construction);
}
case WorkTypeEnum.Manufacturing:
{
return((double)citizen.Manufacturing);
}
case WorkTypeEnum.Raw:
{
return((double)citizen.Raw);
}
case WorkTypeEnum.Selling:
{
return((double)citizen.Selling);
}
case WorkTypeEnum.Any:
{
return((double)Math.Max(Math.Max(citizen.Construction, citizen.Selling), Math.Max(citizen.Manufacturing, citizen.Raw)));
}
}
throw new ArgumentException("GetWorkSkill");
}
private static double GetCurrentSkill(Citizen citizen, WorkTypeEnum workType)
{
double currentSkill = 0;
switch (workType)
{
case WorkTypeEnum.Construction:
{
currentSkill = (double)citizen.Construction;
break;
}
case WorkTypeEnum.Manufacturing:
{
currentSkill = (double)citizen.Manufacturing;
break;
}
case WorkTypeEnum.Raw:
{
currentSkill = (double)citizen.Raw;
break;
}
case WorkTypeEnum.Selling:
{
currentSkill = (double)citizen.Selling;
break;
}
}
return(currentSkill);
}
public void IncreaseSkill(int citizenID, WorkTypeEnum workType, double amount)
{
var citizen = citizenRepository.GetById(citizenID);
switch (workType)
{
case WorkTypeEnum.Construction:
{
citizen.Construction += (decimal)amount;
break;
}
case WorkTypeEnum.Manufacturing:
{
citizen.Manufacturing += (decimal)amount;
break;
}
case WorkTypeEnum.Raw:
{
citizen.Raw += (decimal)amount;
break;
}
case WorkTypeEnum.Selling:
{
citizen.Selling += (decimal)amount;
break;
}
}
citizenRepository.SaveChanges();
}
public CountryBestJobOffers GetBestAndWorstJobOffers(int countryID, WorkTypeEnum workType)
{
var query = Where(offer => offer.CountryID == countryID);
if (workType != WorkTypeEnum.Any)
{
query = query.Where(offer => offer.Company.WorkTypeID == (int)workType);
}
#pragma warning disable CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null'
//Why am i suppressing warning? Cause it's false! I need to check for null because normalJobOffer may be null sometimes! I cannot do it with ?. because
//query providers do not support those yet.
var salary = query
.Select(offer => new { Salary = (offer.NormalJobOffer.Salary == null ? (decimal)0.0 : offer.NormalJobOffer.Salary)
+ (offer.ContractJobOffer.MinSalary == null ? (decimal)0.0 : offer.ContractJobOffer.MinSalary) });
var minSal = salary
.OrderBy(x => x.Salary);
var maxSal = salary
.OrderByDescending(x => x.Salary);
return((from o in context.JobOffers
select new CountryBestJobOffers()
{
MinimumSalary = minSal.FirstOrDefault().Salary,
MaximumSalary = maxSal.FirstOrDefault().Salary,
MinimumSkill = query.OrderBy(offer => offer.MinSkill).FirstOrDefault().MinSkill,
MaximumSkill = query.OrderByDescending(offer => offer.MinSkill).FirstOrDefault().MinSkill
}).FirstOrDefault());
#pragma warning restore CS0472 // The result of the expression is always the same since a value of this type is never equal to 'null' */
}
private ShortJobOfferViewModel createShortJobOffer(JobOffer jobOffer, WorkTypeEnum workType, CompanyRights companyRights)
{
ShortJobOfferViewModel vm;
switch ((JobTypeEnum)jobOffer.TypeID)
{
case JobTypeEnum.Normal:
vm = new ShortNormalJobOfferViewModel(jobOffer.NormalJobOffer, companyRights);
break;
case JobTypeEnum.Contracted:
vm = new ShortContractJobOfferViewModel(jobOffer.ContractJobOffer, companyRights);
break;
default:
throw new ArgumentException();
}
vm.CanWork = true;
if (SessionHelper.CurrentEntity.GetEntityType() == EntityTypeEnum.Citizen)
{
switch (workType)
{
case WorkTypeEnum.Construction:
vm.CanWork = SessionHelper.CurrentEntity.Citizen.Construction >= jobOffer.MinSkill;
if (!vm.CanWork)
{
vm.CannotWorkReason = "Your skill is not good enough";
}
break;
case WorkTypeEnum.Manufacturing:
vm.CanWork = SessionHelper.CurrentEntity.Citizen.Manufacturing >= jobOffer.MinSkill;
if (!vm.CanWork)
{
vm.CannotWorkReason = "Your skill is not good enough";
}
break;
case WorkTypeEnum.Raw:
vm.CanWork = SessionHelper.CurrentEntity.Citizen.Raw >= jobOffer.MinSkill;
if (!vm.CanWork)
{
vm.CannotWorkReason = "Your skill is not good enough";
}
break;
}
}
else
{
vm.CanWork = false;
vm.CannotWorkReason = "Only citizens can work";
}
vm.Amount = jobOffer.Amount;
vm.JobID = jobOffer.ID;
return(vm);
}
public double GetSkillIncreaseForWork(int citizenID, WorkTypeEnum workType)
{
var citizen = citizenRepository.GetById(citizenID);
double currentSkill = GetCurrentSkill(citizen, workType);
double skillIncrease = calculateSkillIncrease(currentSkill);
return(Math.Round(skillIncrease, 4));
}
public override double Calculate(ProductionPointsCalculateArgs args)
{
WorkTypeEnum workType = args.ProducedProduct.GetWorkType();
double skill = args.Skill;
double distanceModifier = CalculateDistanceModifier(args);
double developmentModifier = CalculateDevelopmentModifier(args);
double peopleModifier = CalculatePeopleModifier(args);
double hpModifier = CalculateHealthModifier(args);
return(Math.Pow(Math.Pow((skill + 1) * distanceModifier, 0.89) * developmentModifier * peopleModifier, 0.125) * hpModifier / 50.0);
}
public static void SearchForWork(WorkTypeEnum workTypeEnum, List <Pawn> pawns)
{
switch (workTypeEnum)
{
case WorkTypeEnum.None: SearchForWorkGeneral(pawns); break;
case WorkTypeEnum.TendWounded: SearchForWorkTendWounded(pawns); break;
case WorkTypeEnum.RescueFallen: SearchForWorkRescueFallen(pawns); break;
case WorkTypeEnum.UnloadCaravan: SearchForWorkUnloadCaravan(pawns); break;
default: return;
}
}
public JsonResult JobMarketMinMax(int countryID, WorkTypeEnum workType)
{
try
{
var country = countryRepository.GetById(countryID);
if (country == null)
{
throw new UserReadableException("Country does not exist!");
}
var bestOffers = jobOfferRepository.GetBestAndWorstJobOffers(country.ID, workType);
var vm = new JobMarketBestViewModel(country, bestOffers);
return(JsonData(vm));
} catch (Exception e)
{
return(JsonDebugOnlyError(e));
}
}
public Work CreateWork(WorkTypeEnum type)
{
switch (type)
{
case WorkTypeEnum.WorkNone:
return(new Work());
case WorkTypeEnum.WorkConsultationsByPhone:
return(new WorkConsultationsByPhone());
case WorkTypeEnum.WorkError:
return(new WorkError());
case WorkTypeEnum.WorkPatch:
return(new WorkPatch());
case WorkTypeEnum.WorkRefractoring:
return(new WorkRefractoring());
}
return(null);
}
public virtual double Calculate(ProductionPointsCalculateArgs args)
{
WorkTypeEnum workType = args.ProducedProduct.GetWorkType();
double skill = args.Skill;
var hpModifier = CalculateHealthModifier(args);
double distanceModifier = CalculateDistanceModifier(args);
double qualityModifier = CalculateQualityModifier(args);
double productModifier = CalculateProductModifier(args);
double developmentModifier = CalculateDevelopmentModifier(args);
double peopleModifier = CalculatePeopleModifier(args);
double rawMultiplier = 1.0;
if (args.ProducedProduct.IsRaw())
{
rawMultiplier = CalculateRawMultiplier(args);
}
return((Math.Pow((skill * productModifier + 1) * qualityModifier * distanceModifier, 0.9 - (double)(args.Quality / 100.0))
* rawMultiplier * developmentModifier) * peopleModifier * hpModifier * 1.5);
}
public Work CreateWork(Work work)
{
WorkTypeEnum type = (WorkTypeEnum)work.WorkTypeID;
switch (type)
{
case WorkTypeEnum.WorkNone:
return(new Work(work));
case WorkTypeEnum.WorkConsultationsByPhone:
return(new WorkConsultationsByPhone(work));
case WorkTypeEnum.WorkError:
return(new WorkError(work));
case WorkTypeEnum.WorkPatch:
return(new WorkPatch(work));
case WorkTypeEnum.WorkRefractoring:
return(new WorkRefractoring(work));
}
return(null);
}
private async Task DoWork(PlayerEntity player)
{
await _mudProvider.ShowMessage(player.Id, $"你正在{player.Status}。。。");
WorkTypeEnum workType = WorkTypeEnum.伐木;
switch (player.Status)
{
case PlayerStatusEnum.伐木:
workType = WorkTypeEnum.伐木;
break;
case PlayerStatusEnum.挖矿:
workType = WorkTypeEnum.挖矿;
break;
case PlayerStatusEnum.打猎:
workType = WorkTypeEnum.打猎;
break;
case PlayerStatusEnum.采药:
workType = WorkTypeEnum.采药;
break;
case PlayerStatusEnum.钓鱼:
workType = WorkTypeEnum.钓鱼;
break;
case PlayerStatusEnum.打工:
workType = WorkTypeEnum.打工;
break;
default:
return;
}
var ids = (await _roomItemDropDomainService.GetAll()).Where(x => x.RoomId == player.RoomId).Select(x => x.ItemDropId).ToList();
var itemDrop = (await _itemDropDomainService.GetAll()).Where(x => ids.Contains(x.Id)).FirstOrDefault(x => x.WorkType == workType);
if (itemDrop == null)
{
return;
}
var itemDropRates = (await _itemDropRateDomainService.GetAll()).Where(x => x.ItemDropId == itemDrop.Id).ToList();
if (itemDropRates?.Count == 0)
{
return;
}
var random = new Random();
int maxWeight = 100;//掉落总权重
var itemDropModels = new List <ItemDropRateModel>();
foreach (var itemDropRate in itemDropRates.OrderBy(x => x.Order))
{
if (itemDropRate.Percent < random.Next(0, 100))
{
continue;
}
int number = random.Next(Math.Min(itemDropRate.MinNumber, itemDropRate.MaxNumber), itemDropRate.MaxNumber + 1);
if (number <= 0)
{
continue;
}
//掉落
maxWeight -= itemDropRate.Weight;
var itemDropModel = new ItemDropRateModel
{
DropType = itemDropRate.DropType,
Number = number,
WareId = itemDropRate.WareId
};
itemDropModels.Add(itemDropModel);
if (maxWeight <= 0)
{
break;
}
}
if (itemDropModels.Count == 0)
{
//没有掉落
return;
}
var playerAttributeChanged = false;
List <string> dropContents = new List <string>();
foreach (var itemDropModel in itemDropModels)
{
switch (itemDropModel.DropType)
{
case ItemDropTypeEnum.潜能:
playerAttributeChanged = true;
player.Pot += itemDropModel.Number;
dropContents.Add($"潜能 +{itemDropModel.Number}");
break;
case ItemDropTypeEnum.经验:
playerAttributeChanged = true;
player.Exp += itemDropModel.Number;
dropContents.Add($"经验 +{itemDropModel.Number}");
break;
case ItemDropTypeEnum.金钱:
playerAttributeChanged = true;
player.Money += itemDropModel.Number;
dropContents.Add($" +{itemDropModel.Number.ToMoney()}");
break;
case ItemDropTypeEnum.物品:
#region MyRegion
int wareId = itemDropModel.WareId;
int number = itemDropModel.Number;
var ware = await _wareDomainService.Get(wareId);
if (ware == null)
{
continue;
}
dropContents.Add($"{ware.Name} X{number}");
var canStack = ware.Category != WareCategoryEnum.武器;
if (canStack)
{
var playerWare = await _playerWareDomainService.Get(x => x.WareId == ware.Id && x.PlayerId == player.Id);
if (playerWare == null)
{
playerWare = new PlayerWareEntity
{
IsBind = false,
IsTemp = false,
Level = 1,
Number = number,
Damage = 0,
PlayerId = player.Id,
Status = WareStatusEnum.卸下,
WareId = wareId,
WareName = ware.Name
};
await _playerWareDomainService.Add(playerWare);
}
else
{
playerWare.Number += number;
await _playerWareDomainService.Update(playerWare);
}
}
else
{
var playerWare = new PlayerWareEntity
{
IsBind = false,
IsTemp = false,
Level = 1,
Number = number,
Damage = 0,
PlayerId = player.Id,
Status = WareStatusEnum.卸下,
WareId = wareId,
WareName = ware.Name
};
await _playerWareDomainService.Add(playerWare);
}
#endregion
break;
}
}
if (playerAttributeChanged)
{
await _bus.RaiseEvent(new PlayerAttributeChangedEvent(player)).ConfigureAwait(false);
}
if (dropContents.Count > 0)
{
await _mudProvider.ShowMessage(player.Id, $"获得{ string.Join("，", dropContents) }。");
}
}
public string GetWorkTypeEnumDescript(WorkTypeEnum workType)
{
return(workType.GetDescription());
}
public Metadata(WorkTypeEnum type)
{
this.MetadataType = type;
this.MetadataSources = new List <MetadataSource>();
}
public void SetType(WorkTypeEnum metadataType)
{
uContact.LoadData(current.Contact);
uInstitution.LoadData(current.Institution, true);
}
public PartialViewResult Offers(int countryID, double minSkill, double maxSkill, double minSalary, double maxSalary, bool?sameRegion, JobOfferTypeEnum offerType, WorkTypeEnum workTypeID, PagingParam pagingParam)
{
pagingParam = pagingParam ?? new PagingParam();
var offers = jobOfferRepository.Where(o => o.CountryID == countryID);
if (offerType != JobOfferTypeEnum.Both)
{
offers = offers.Where(o => o.TypeID == (int)offerType);
}
if (workTypeID != WorkTypeEnum.Any)
{
offers = offers.Where(o => o.Company.WorkTypeID == (int)workTypeID);
}
//if (minSkill.HasValue)
offers = offers.Where(o => o.MinSkill >= (decimal)minSkill);
// if (maxSkill.HasValue)
offers = offers.Where(o => o.MinSkill <= (decimal)maxSkill);
//if (minSalary.HasValue)
offers = offers.Where(o => o.NormalJobOffer.Salary >= (decimal)minSalary || o.ContractJobOffer.MinSalary >= (decimal)minSalary);
//if(maxSalary.HasValue)
offers = offers.Where(o => o.NormalJobOffer.Salary <= (decimal)maxSalary || o.ContractJobOffer.MinSalary <= (decimal)maxSalary);
if (sameRegion == true)
{
int?regionID = SessionHelper.CurrentEntity.GetCurrentRegion()?.ID;
offers = offers.Where(o => o.Company.RegionID == regionID);
}
JobOffersDOMSelector selector = new JobOffersDOMSelector();
IList <JobOfferDOM> processed = offers
.Apply(selector)
.OrderByDescending(o => o.NormalSalary)
.Apply(pagingParam)
.ToList();
var vm = new JobMarketOfferListViewModel(processed, countryID, (int)workTypeID, (int)offerType, minSalary, maxSalary, minSkill, maxSkill,
includeRegionInformation: sameRegion != true, pagingParam: pagingParam);
return(PartialView(vm));
}
public void Update_AttrValuesFields_ForWork(Work _work, WorkTypeEnum oldType, WorkTypeEnum newType)
{
//Delete_AttrValuesFields_ForWork(WorkID); // todo, надо дописать только недостающие атрибуты, т.к. в старых может содержаться важная информация
Create_AttrValuesFields_ForWork(_work, newType);
}
public WorkType(WorkTypeEnum workTypeEnum)
{
this.workTypeEnum = workTypeEnum;
}
