public ActionResult NewArmorLot(NewArmorLotModel model)
{
if (ModelState.IsValid)
{
using (var db = new BGS_DBContext()) {
string userIdentityId = User.Identity.GetUserId();
var seller = db.Users.Single(u => u.Id == userIdentityId);
for (int i = 0; i < model.LotCount; i++)
{
ArmorModel newArmorModelModel = GameUtilCreater.ArmorModelFromModel(model);
db.ArmorModels.Add(newArmorModelModel);
db.SaveChanges();
var lot = new LotModel()
{
Seller = seller,
ItemId = newArmorModelModel.Id,
Price = model.Price,
SellerId = seller.GameId,
Status = LotStatus.Available,
Type = LotType.Armor
};
db.LotModels.Add(lot);
db.SaveChanges();
newArmorModelModel.LotId = lot.Id;
}
db.SaveChanges();
return(RedirectToAction("Index", "Market"));
}
}
ModelState.AddModelError("", "Что то не правильно");
return(View(model));
}
private bool BindArmorModel <TArmorModel>(TArmorModel model) where TArmorModel : ArmorModel, new()
{
if (model != null)
{
return(this.BindArmorModelCheckedNonNull(model));
}
ArmorModel model2 = this.defaultArmorModelGroup[ArmorModelSlotUtility.GetArmorModelSlotForClass <TArmorModel>()];
return((model2 != null) && this.BindArmorModelCheckedNonNull(model2));
}
public bool Contains(ArmorModel model)
{
if (model == null)
{
return(false);
}
if (!this.awake)
{
ArmorModelGroup defaultArmorModelGroup = this.defaultArmorModelGroup;
return((defaultArmorModelGroup != null) && (defaultArmorModelGroup[model.slot] == model));
}
return(this.models[model.slot] == model);
}
private bool BindArmorModel(ArmorModel model, ArmorModelSlot slot)
{
if (model == null)
{
ArmorModel model2 = this.defaultArmorModelGroup[slot];
return((model2 != null) && this.BindArmorModelCheckedNonNull(model2));
}
if (model.slot != slot)
{
Debug.LogError("model.slot != " + slot, model);
return(false);
}
return(this.BindArmorModelCheckedNonNull(model));
}
public bool Contains(ArmorModel model)
{
if (!model)
{
return(false);
}
if (this.awake)
{
return(this.models[model.slot] == model);
}
ArmorModelGroup armorModelGroups = this.defaultArmorModelGroup;
return(!armorModelGroups ? false : armorModelGroups[model.slot] == model);
}
private bool BindArmorModel <TArmorModel>(TArmorModel model)
where TArmorModel : ArmorModel, new()
{
if (model)
{
return(this.BindArmorModelCheckedNonNull(model));
}
ArmorModel item = this.defaultArmorModelGroup[ArmorModelSlotUtility.GetArmorModelSlotForClass <TArmorModel>()];
if (!item)
{
return(false);
}
return(this.BindArmorModelCheckedNonNull(item));
}
private bool BindArmorModel(ArmorModel model, ArmorModelSlot slot)
{
if (model)
{
if (model.slot == slot)
{
return(this.BindArmorModelCheckedNonNull(model));
}
Debug.LogError(string.Concat("model.slot != ", slot), model);
return(false);
}
ArmorModel item = this.defaultArmorModelGroup[slot];
return(!item ? false : this.BindArmorModelCheckedNonNull(item));
}
public ArmorModelSlotMask BindArmorGroup(ArmorModelGroup group)
{
ArmorModelSlotMask mask = 0;
if (group != null)
{
for (ArmorModelSlot slot = ArmorModelSlot.Feet; slot < ((ArmorModelSlot)4); slot = (ArmorModelSlot)(((int)slot) + 1))
{
ArmorModel model = group[slot];
if ((model != null) && this.BindArmorModelCheckedNonNull(model))
{
mask |= slot.ToMask();
}
}
}
return(mask);
}
public ArmorModelSlotMask BindArmorGroup(ArmorModelGroup group)
{
ArmorModelSlotMask mask = (ArmorModelSlotMask)0;
if (group)
{
for (ArmorModelSlot i = ArmorModelSlot.Feet; (int)i < 4; i = (ArmorModelSlot)((byte)i + (byte)ArmorModelSlot.Legs))
{
ArmorModel item = group[i];
if (item && this.BindArmorModelCheckedNonNull(item))
{
mask = mask | i.ToMask();
}
}
}
return(mask);
}
public void EquipShield(ItemType itemType) //Equip our shield in the shield pos
{
GameObject newShieldObject = EquipItem(itemType, ItemData.EquipPosition.ShieldHand, ShieldParent, ref m_EquippedShield);
if (newShieldObject == null)
{
return;
}
ArmorModel armorModel = newShieldObject.GetComponent <ArmorModel>();
if (armorModel == null)
{
Debug.LogWarning("No ArmorModel for this shield");
return;
}
m_Character.Health.RegisterArmor(armorModel);
}
private bool BindArmorModelCheckedNonNull(ArmorModel model)
{
ArmorModel censoredModel;
ArmorModelSlot slot = model.slot;
if (!rebindingCensorship)
{
ArmorModel model2 = this.models[slot];
if (model2 == model)
{
return(false);
}
}
ActorMeshRenderer renderer = this.renderers[slot];
if (censored)
{
censoredModel = model.censoredModel;
if (censoredModel == null)
{
censoredModel = model;
}
}
else
{
censoredModel = model;
}
if (renderer.actorRig != censoredModel.actorRig)
{
return(false);
}
if (!base.enabled)
{
renderer.renderer.enabled = true;
}
renderer.Bind(censoredModel.actorMeshInfo, censoredModel.sharedMaterials);
if (!base.enabled)
{
renderer.renderer.enabled = false;
}
this.models[slot] = model;
return(true);
}
public ArmorModelSlotMask BindArmorGroup(ArmorModelGroup group, ArmorModelSlotMask slotMask)
{
if (!this.awake)
{
if (group == null)
{
return(0);
}
return(this.Initialize(group.armorModelMemberMap, slotMask));
}
ArmorModelSlotMask mask = 0;
foreach (ArmorModelSlot slot in slotMask.EnumerateSlots())
{
ArmorModel model = group[slot];
if ((model != null) && this.BindArmorModelCheckedNonNull(model))
{
mask |= slot.ToMask();
}
}
return(mask);
}
private bool BindArmorModelCheckedNonNull(ArmorModel model)
{
ArmorModel armorModel;
ArmorModelSlot armorModelSlot = model.slot;
if (!ArmorModelRenderer.rebindingCensorship && this.models[armorModelSlot] == model)
{
return(false);
}
ActorMeshRenderer item = this.renderers[armorModelSlot];
if (!ArmorModelRenderer.censored)
{
armorModel = model;
}
else
{
armorModel = model.censoredModel;
if (!armorModel)
{
armorModel = model;
}
}
if (item.actorRig != armorModel.actorRig)
{
return(false);
}
if (!base.enabled)
{
item.renderer.enabled = true;
}
item.Bind(armorModel.actorMeshInfo, armorModel.sharedMaterials);
if (!base.enabled)
{
item.renderer.enabled = false;
}
this.models[armorModelSlot] = model;
return(true);
}
public ArmorModelSlotMask BindArmorGroup(ArmorModelGroup group, ArmorModelSlotMask slotMask)
{
if (!this.awake)
{
if (!group)
{
return(0);
}
return(this.Initialize(group.armorModelMemberMap, slotMask));
}
ArmorModelSlotMask mask = (ArmorModelSlotMask)0;
ArmorModelSlot[] armorModelSlotArray = slotMask.EnumerateSlots();
for (int i = 0; i < (int)armorModelSlotArray.Length; i++)
{
ArmorModelSlot armorModelSlot = armorModelSlotArray[i];
ArmorModel item = group[armorModelSlot];
if (item && this.BindArmorModelCheckedNonNull(item))
{
mask = mask | armorModelSlot.ToMask();
}
}
return(mask);
}
public static void InitializeItems()
{
foreach (GameObject equipment in Resources.LoadAll("Equipment/Weapon"))
{
WeaponModel model = equipment.gameObject.GetComponent <WeaponModel>();
//Debug.Log($"{model.name}, {model.type}, {model.id}, {equipment.name}, {model.HitboxName}, {model.MovesetName}");
Weapons.Add(new Weapon(model.name, model.type, model.id, new WeaponProps(model.Damage, model.BaseAttackSpeed), equipment.name, model.HitboxName, model.MovesetName));
}
foreach (TextAsset text in Resources.LoadAll <TextAsset>("Equipment/ArmorModels/Head"))
{
//Debug.Log(text.text);
ArmorModel model = (ArmorModel)JsonUtility.FromJson <ArmorModel>(text.text);
//Debug.Log($"{model.Name}, {model.Type}, {model.Id}, {model.MeshName}, {model.Gender}");
Armor.Add(new Armor(model.Name, (EquipmentTypes)Enum.Parse(typeof(EquipmentTypes), model.Type), model.Id, new ArmorProps(model.Armor), model.MeshName));
}
foreach (TextAsset text in Resources.LoadAll <TextAsset>("Equipment/ArmorModels/Body"))
{
ArmorModel model = (ArmorModel)JsonUtility.FromJson <ArmorModel>(text.text);
Armor.Add(new Armor(model.Name, (EquipmentTypes)Enum.Parse(typeof(EquipmentTypes), model.Type), model.Id, new ArmorProps(model.Armor), model.MeshName));
}
foreach (TextAsset text in Resources.LoadAll <TextAsset>("Equipment/ArmorModels/Legs"))
{
ArmorModel model = (ArmorModel)JsonUtility.FromJson <ArmorModel>(text.text);
Armor.Add(new Armor(model.Name, (EquipmentTypes)Enum.Parse(typeof(EquipmentTypes), model.Type), model.Id, new ArmorProps(model.Armor), model.MeshName));
}
foreach (TextAsset text in Resources.LoadAll <TextAsset>("Equipment/ArmorModels/Feet"))
{
ArmorModel model = (ArmorModel)JsonUtility.FromJson <ArmorModel>(text.text);
Armor.Add(new Armor(model.Name, (EquipmentTypes)Enum.Parse(typeof(EquipmentTypes), model.Type), model.Id, new ArmorProps(model.Armor), model.MeshName));
}
foreach (TextAsset text in Resources.LoadAll <TextAsset>("Equipment/ArmorModels/Hands"))
{
ArmorModel model = (ArmorModel)JsonUtility.FromJson <ArmorModel>(text.text);
Armor.Add(new Armor(model.Name, (EquipmentTypes)Enum.Parse(typeof(EquipmentTypes), model.Type), model.Id, new ArmorProps(model.Armor), model.MeshName));
}
}
private void LoadArmorModels()
{
Dictionary <int, ArmorModel> armorsModels = ItemService.GetAllArmorModelsDict();
foreach (KeyValuePair <int, ArmorModel> modelPair in armorsModels)
{
StatsSet set = new StatsSet();
ArmorModel model = modelPair.Value;
Armor armor = new Armor(set)
{
Type = Utilz.GetEnumFromString(model.ArmorType, ArmorTypeId.None),
ItemId = model.ItemId,
Name = model.Name,
BodyPart = Slots[model.BodyPart],
Sellable = model.Sellable,
Dropable = model.Dropable,
Destroyable = model.Destroyable,
Tradable = model.Tradeable,
Weight = model.Weight,
Duration = model.Duration
};
Armors.Add(modelPair.Key, armor);
}
}
private ArmorModelSlotMask Initialize(ArmorModelMemberMap memberMap, ArmorModelSlotMask memberMask)
{
ActorMeshRenderer actorMeshRenderer;
this.awake = true;
string rendererName = ArmorModelSlot.Head.GetRendererName();
ActorRig item = this.defaultArmorModelGroup[ArmorModelSlot.Head].actorRig;
actorMeshRenderer = (!this.originalRenderer ? ActorMeshRenderer.CreateOn(base.transform, rendererName, item, this.boneStructure.rigOrderedTransformArray, base.gameObject.layer) : ActorMeshRenderer.Replace(this.originalRenderer, item, this.boneStructure.rigOrderedTransformArray, rendererName));
this.renderers[ArmorModelSlot.Head] = actorMeshRenderer;
for (ArmorModelSlot i = ArmorModelSlot.Feet; i < ArmorModelSlot.Head; i = (ArmorModelSlot)((byte)i + (byte)ArmorModelSlot.Legs))
{
this.renderers[i] = actorMeshRenderer.CloneBlank(i.GetRendererName());
}
for (ArmorModelSlot j = ArmorModelSlot.Feet; j < ArmorModelSlot.Head; j = (ArmorModelSlot)((byte)j + (byte)ArmorModelSlot.Legs))
{
ActorMeshRenderer item1 = this.renderers[j];
if (item1)
{
item1.renderer.enabled = base.enabled;
}
}
ArmorModelSlotMask mask = (ArmorModelSlotMask)0;
ArmorModelGroup armorModelGroups = this.defaultArmorModelGroup;
if (!armorModelGroups)
{
ArmorModelSlot[] armorModelSlotArray = memberMask.EnumerateSlots();
for (int k = 0; k < (int)armorModelSlotArray.Length; k++)
{
ArmorModelSlot armorModelSlot = armorModelSlotArray[k];
ArmorModel armorModel = memberMap.GetArmorModel(armorModelSlot);
if (armorModel && this.BindArmorModelCheckedNonNull(armorModel))
{
mask = mask | armorModelSlot.ToMask();
}
}
}
else
{
for (ArmorModelSlot l = ArmorModelSlot.Feet; (int)l < 4; l = (ArmorModelSlot)((byte)l + (byte)ArmorModelSlot.Legs))
{
if (memberMask.Contains(l))
{
ArmorModel armorModel1 = memberMap.GetArmorModel(l);
if (!armorModel1 || !this.BindArmorModelCheckedNonNull(armorModel1))
{
goto Label1;
}
mask = mask | l.ToMask();
goto Label0;
}
Label1:
ArmorModel item2 = armorModelGroups[l];
if (item2)
{
this.BindArmorModelCheckedNonNull(item2);
}
Label0:
}
}
return(mask);
}
public CharacterCombatModel GenerateMirrorNpc()
{
ctx = new ProjectStrawberryEntities();
npcLevel = model.Level;
npcAttribute = 60 + (npcLevel - 1) * 15;
var mainHandWeaponType = model.MainHand.WeaponType.Name.ToLower();
if (model.MainHand != null)
{
npcAttribute -= model.MainHand.ReqWeaponMastery;
}
if (model.OffHand.shld != null)
{
vitality = Math.Round(npcAttribute * 0.50);
strength = Math.Round(npcAttribute * 0.25);
block = Math.Round(npcAttribute * 0.25);
}
else if (mainHandWeaponType == "axe")
{
vitality = Math.Round(npcAttribute * 0.55);
strength = Math.Round(npcAttribute * 0.25);
quickness = Math.Round(npcAttribute * 0.10);
evasion = Math.Round(npcAttribute * 0.05);
parry = Math.Round(npcAttribute * 0.05);
axe = model.Axe;
}
else if (mainHandWeaponType == "dagger")
{
vitality = Math.Round(npcAttribute * 0.50);
strength = Math.Round(npcAttribute * 0.25);
evasion = Math.Round(npcAttribute * 0.25);
dagger = model.Dagger;
}
else if (mainHandWeaponType == "mace")
{
vitality = Math.Round(npcAttribute * 0.40);
strength = Math.Round(npcAttribute * 0.40);
parry = Math.Round(npcAttribute * 0.20);
mace = model.Mace;
}
else if (mainHandWeaponType == "polearm")
{
vitality = Math.Round(npcAttribute * 0.50);
strength = Math.Round(npcAttribute * 0.35);
evasion = Math.Round(npcAttribute * 0.15);
polearm = model.Polearm;
}
else if (mainHandWeaponType == "spear")
{
vitality = Math.Round(npcAttribute * 0.50);
strength = Math.Round(npcAttribute * 0.30);
quickness = Math.Round(npcAttribute * 0.20);
spear = model.Spear;
}
else if (mainHandWeaponType == "sword")
{
vitality = Math.Round(npcAttribute * 0.45);
strength = Math.Round(npcAttribute * 0.30);
parry = Math.Round(npcAttribute * 0.25);
sword = model.Sword;
}
else
{
vitality = Math.Round(npcAttribute * 0.65);
strength = Math.Round(npcAttribute * 0.35);
}
var npc = new CharacterCombatModel()
{
Name = firstName + " " + lastName,
Vitality = (int)vitality,
Axe = (int)axe,
Block = (int)block,
Dagger = (int)dagger,
Evasion = (int)evasion,
Health = (int)vitality,
Level = npcLevel,
Mace = (int)mace,
Parry = (int)parry,
Polearm = (int)polearm,
Quickness = (int)quickness,
Spear = (int)spear,
Stamina = (int)stamina,
Strength = (int)strength,
Sword = (int)sword,
};
var fist = new WeaponModel()
{
MinimumDamage = 0,
MaximumDamage = 0,
Name = "fist",
TwoHanded = false,
WeaponType = new WeaponTypeModel()
{
Name = "else"
},
};
var skin = new ArmorModel()
{
ArmorValue = 0,
Name = "skin",
};
if (model.MainHand != null)
{
npc.MainHand = model.MainHand;
}
else
{
npc.MainHand = fist;
}
if (model.OffHand != null && !model.MainHand.TwoHanded)
{
npc.OffHand = model.OffHand;
}
npc.Equipment = model.Equipment;
return(npc);
}
//Add armor to player
public void RegisterArmor(ArmorModel armor)
{
m_ArmorModels.Add(armor);
}
private ArmorModelSlotMask Initialize(ArmorModelMemberMap memberMap, ArmorModelSlotMask memberMask)
{
ActorMeshRenderer renderer;
this.awake = true;
string rendererName = ArmorModelSlot.Head.GetRendererName();
ActorRig actorRig = this.defaultArmorModelGroup[ArmorModelSlot.Head].actorRig;
if (this.originalRenderer != null)
{
renderer = ActorMeshRenderer.Replace(this.originalRenderer, actorRig, this.boneStructure.rigOrderedTransformArray, rendererName);
}
else
{
renderer = ActorMeshRenderer.CreateOn(base.transform, rendererName, actorRig, this.boneStructure.rigOrderedTransformArray, base.gameObject.layer);
}
this.renderers[ArmorModelSlot.Head] = renderer;
for (ArmorModelSlot slot = ArmorModelSlot.Feet; slot < ArmorModelSlot.Head; slot = (ArmorModelSlot)(((int)slot) + 1))
{
this.renderers[slot] = renderer.CloneBlank(slot.GetRendererName());
}
for (ArmorModelSlot slot2 = ArmorModelSlot.Feet; slot2 < ArmorModelSlot.Head; slot2 = (ArmorModelSlot)(((int)slot2) + 1))
{
ActorMeshRenderer renderer2 = this.renderers[slot2];
if (renderer2 != null)
{
renderer2.renderer.enabled = base.enabled;
}
}
ArmorModelSlotMask mask = 0;
ArmorModelGroup defaultArmorModelGroup = this.defaultArmorModelGroup;
if (defaultArmorModelGroup != null)
{
for (ArmorModelSlot slot3 = ArmorModelSlot.Feet; slot3 < ((ArmorModelSlot)4); slot3 = (ArmorModelSlot)(((int)slot3) + 1))
{
if (memberMask.Contains(slot3))
{
ArmorModel armorModel = memberMap.GetArmorModel(slot3);
if ((armorModel != null) && this.BindArmorModelCheckedNonNull(armorModel))
{
mask |= slot3.ToMask();
continue;
}
}
ArmorModel model2 = defaultArmorModelGroup[slot3];
if (model2 != null)
{
this.BindArmorModelCheckedNonNull(model2);
}
}
return(mask);
}
foreach (ArmorModelSlot slot4 in memberMask.EnumerateSlots())
{
ArmorModel model = memberMap.GetArmorModel(slot4);
if ((model != null) && this.BindArmorModelCheckedNonNull(model))
{
mask |= slot4.ToMask();
}
}
return(mask);
}
public void UnregisterArmor( ArmorModel armor )
{
m_ArmorModels.Remove( armor );
}
//Remove armor from player
public void UnregisterArmor(ArmorModel armor)
{
m_ArmorModels.Remove(armor);
}
public List <Round> BattleNPC(int player1Id, int player1Forfeit, int?player2Id, int?player2Forfeit)
{
var ctx = new ProjectStrawberryEntities();
var random = new Random();
var generate = new CombatTextGenerator();
var ccm = new CharacterModelGenerator();
// Generate Player1 model and properties
var player1 = new CharacterCombatModel();
player1 = ccm.ModelizeCharacter(player1Id);
double player1HitChanceMainHand = PlayerHitChance(player1);
double player1HitChanceOffHand = PlayerHitChance(player1);
double player1ParryChance = diminishing_returns(player1.Parry, 7.5);
double player1DodgeChance = diminishing_returns(player1.Evasion, 7.5);
double player1BlockChance = diminishing_returns(player1.Block, 7.5);
bool player1HasShield = player1.OffHand.shld != null;
bool player1HasWeapon = player1.MainHand != null && player1.OffHand.wep != null;
// Generate Player2 model and properties
var player2 = new CharacterCombatModel();
if (player2Id != null)
{
player2 = ccm.ModelizeCharacter((int)player2Id);
}
else
{
var gen = new NpcGenerator(player1, random.Next(0, 47), random.Next(0, 71));
player2 = gen.GenerateMirrorNpc();
player2Forfeit = 20;
}
double player2HitChanceMainHand = PlayerHitChance(player2);
double player2HitChanceOffHand = PlayerHitChance(player2);
double player2ParryChance = diminishing_returns(player2.Parry, 7.5);
double player2DodgeChance = diminishing_returns(player2.Evasion, 7.5);
double player2BlockChance = diminishing_returns(player2.Block, 7.5);
bool player2HasShield = player2.OffHand.shld != null;
bool player2HasWeapon = player2.MainHand != null && player2.OffHand.wep != null;
// Combatlog properties
List <Round> fullFight = new List <Round>();
int roundNr = 0;
string roundLog = "";
string spoiler = "";
bool keepFighting = true;
bool player1HasHighestQuickness = player1.Quickness >= player2.Quickness;
bool player1Won = false;
bool player2Won = false;
while (keepFighting)
{
int combatflavorindex = 2;
int damage = 0;
int bonusDamage = 0;
int minDamage = 0;
int maxDamage = 0;
roundNr++;
// Player1 # of attacks + Avoidance chance
bool player1AttackWithMainHand = false;
bool player1AttackWithOffHand = false;
AttacksPlayerCanDoThisRound(player1, ref player1AttackWithMainHand, ref player1AttackWithOffHand);
// Player2 # of attacks.
bool player2AttackWithMainHand = false;
bool player2AttackWithOffHand = false;
AttacksPlayerCanDoThisRound(player2, ref player2AttackWithMainHand, ref player2AttackWithOffHand);
if (player1HasHighestQuickness)
{
if (keepFighting && player1AttackWithMainHand)
{
bonusDamage = player1.Strength / 10;
minDamage = player1.MainHand.MinimumDamage + bonusDamage;
maxDamage = player1.MainHand.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player1.MainHand.WeaponType.Name);
var bodyPart = player2.Equipment.FirstOrDefault(e => e.ArmorTypeId == bodyPartId);
if (bodyPart == null)
{
bodyPart = new ArmorModel()
{
ArmorValue = 0, Name = "skin"
};
}
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player1HitChanceMainHand, player2DodgeChance, player2ParryChance, player2BlockChance, player2HasShield, player2HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player1.Name, player2.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player2.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player1.Name, player2.Name, player1.MainHand.Name.ToLower(), player2.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player1.Name, player2.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player1.Name, player1.MainHand.Name, player2.Name, random.Next(0, 1));
}
player1AttackWithMainHand = false;
}
else if (keepFighting && player1AttackWithOffHand)
{
bonusDamage = player1.Strength / 10;
minDamage = player1.OffHand.wep.MinimumDamage + bonusDamage;
maxDamage = player1.OffHand.wep.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player1.OffHand.wep.Name);
var bodyPart = player2.Equipment.FirstOrDefault(e => e.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player1HitChanceMainHand, player2DodgeChance, player2ParryChance, player2BlockChance, player2HasShield, player2HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player1.Name, player2.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player2.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player1.Name, player2.Name, player1.MainHand.Name.ToLower(), player2.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player1.Name, player2.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player1.Name, player1.MainHand.Name, player2.Name, random.Next(0, 1));
}
player1AttackWithOffHand = false;
}
// Check if Player2 forfeits
if (player2.Health <= player2.Vitality * (player2Forfeit / 100))
{
keepFighting = false;
player1Won = true;
}
if (keepFighting && player2AttackWithMainHand)
{
bonusDamage = player2.Strength / 10;
minDamage = player2.MainHand.MinimumDamage + bonusDamage;
maxDamage = player2.MainHand.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player2.MainHand.Name);
var bodyPart = player1.Equipment.FirstOrDefault(ec => ec.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player2HitChanceMainHand, player1DodgeChance, player1ParryChance, player1BlockChance, player1HasShield, player1HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player2.Name, player1.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player1.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player2.Name, player1.Name, player2.MainHand.Name.ToLower(), player1.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player2.Name, player1.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player2.Name, player2.MainHand.Name, player1.Name, random.Next(0, 1));
}
player2AttackWithMainHand = false;
}
else if (keepFighting && player2AttackWithOffHand)
{
bonusDamage = player2.Strength / 10;
minDamage = player2.OffHand.wep.MinimumDamage + bonusDamage;
maxDamage = player2.OffHand.wep.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player2.OffHand.wep.Name);
var bodyPart = player1.Equipment.FirstOrDefault(ec => ec.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player2HitChanceMainHand, player1DodgeChance, player1ParryChance, player1BlockChance, player1HasShield, player1HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player2.Name, player1.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player1.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player2.Name, player1.Name, player2.MainHand.Name.ToLower(), player1.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player2.Name, player1.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player2.Name, player2.MainHand.Name, player1.Name, random.Next(0, 1));
}
player2AttackWithOffHand = false;
}
// Check if player1 forfeits
if (player1.Health <= player1.Vitality * (player1Forfeit / 100))
{
keepFighting = false;
player2Won = true;
}
}
else
{
if (keepFighting && player2AttackWithMainHand)
{
bonusDamage = player2.Strength / 10;
minDamage = player2.MainHand.MinimumDamage + bonusDamage;
maxDamage = player2.MainHand.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player2.MainHand.Name);
var bodyPart = player1.Equipment.FirstOrDefault(ec => ec.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player2HitChanceMainHand, player1DodgeChance, player1ParryChance, player1BlockChance, player1HasShield, player1HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player2.Name, player1.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player1.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player2.Name, player1.Name, player2.MainHand.Name.ToLower(), player1.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player2.Name, player1.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player2.Name, player2.MainHand.Name, player1.Name, random.Next(0, 1));
}
player2AttackWithMainHand = false;
}
else if (keepFighting && player2AttackWithOffHand)
{
bonusDamage = player2.Strength / 10;
minDamage = player2.OffHand.wep.MinimumDamage + bonusDamage;
maxDamage = player2.OffHand.wep.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player2.OffHand.wep.Name);
var bodyPart = player1.Equipment.FirstOrDefault(ec => ec.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player2HitChanceMainHand, player1DodgeChance, player1ParryChance, player1BlockChance, player1HasShield, player1HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player2.Name, player1.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player1.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player2.Name, player1.Name, player2.MainHand.Name.ToLower(), player1.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player2.Name, player1.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player2.Name, player2.MainHand.Name, player1.Name, random.Next(0, 1));
}
player2AttackWithOffHand = false;
}
// Check if player 1 forfeits
if (player1.Health <= player1.Vitality * (player1Forfeit / 100))
{
keepFighting = false;
player2Won = true;
}
if (keepFighting && player1AttackWithMainHand)
{
bonusDamage = player1.Strength / 10;
minDamage = player1.MainHand.MinimumDamage + bonusDamage;
maxDamage = player1.MainHand.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player1.MainHand.Name);
var bodyPart = player2.Equipment.FirstOrDefault(al => al.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player1HitChanceMainHand, player2DodgeChance, player2ParryChance, player2BlockChance, player2HasShield, player2HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player1.Name, player2.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player2.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player1.Name, player2.Name, player1.MainHand.Name.ToLower(), player2.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player1.Name, player2.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player1.Name, player1.MainHand.Name, player2.Name, random.Next(0, 1));
}
player1AttackWithMainHand = false;
}
else if (keepFighting && player1AttackWithOffHand)
{
bonusDamage = player1.Strength / 10;
minDamage = player2.OffHand.wep.MinimumDamage + bonusDamage;
maxDamage = player2.OffHand.wep.MaximumDamage + bonusDamage;
var bodyPartId = DiceForBodyPart(random.Next(1, 97), player2.OffHand.wep.Name);
var bodyPart = player2.Equipment.FirstOrDefault(al => al.ArmorTypeId == bodyPartId);
if (minDamage - bodyPart.ArmorValue < 0)
{
minDamage = 0;
}
else
{
minDamage -= bodyPart.ArmorValue;
}
if (maxDamage - bodyPart.ArmorValue < 0)
{
maxDamage = 0;
}
else
{
maxDamage -= bodyPart.ArmorValue;
}
string action = WhatHappenedThatHit(player1HitChanceMainHand, player2DodgeChance, player2ParryChance, player2BlockChance, player2HasShield, player2HasWeapon, random);
if (action == "h")
{
damage = random.Next(minDamage, maxDamage + 1);
roundLog += generate.CombatTextMaleAttacker(player1.Name, player2.Name, damage, bodyPart.Name, random.Next(0, combatflavorindex));
player2.Health -= damage;
}
else if (action == "b")
{
roundLog += generate.CombatTextBlock(player1.Name, player2.Name, player1.MainHand.Name.ToLower(), player2.OffHand.shld.Name, random.Next(0, 1));
}
else if (action == "p")
{
roundLog += generate.CombatTextParry(player1.Name, player2.Name, random.Next(0, 1));
}
else if (action == "d")
{
roundLog += generate.CombatTextDodge(player1.Name, player1.MainHand.Name, player2.Name, random.Next(0, 1));
}
player1AttackWithOffHand = false;
}
// check if player2 forfeits
if (player2.Health <= player2.Vitality * (player2Forfeit / 100))
{
keepFighting = false;
player1Won = true;
}
}
if (!keepFighting)
{
if (player1Won)
{
roundLog += player2.Name + " choose to yield, " + player1.Name + " wins the duel.";
spoiler = player1.Name + " defeated " + player2.Name + " in a random duel.";
}
if (player2Won)
{
roundLog += player1.Name + " choose to yield, " + player2.Name + " wins the duel.";
spoiler = player2.Name + " defeated " + player1.Name + " in a random duel.";
}
}
var round = new Round()
{
RoundNr = roundNr,
Log = roundLog,
};
fullFight.Add(round);
roundLog = string.Empty;
}
if (player1.Health < 0)
{
int survivalDice = random.Next(1, 6);
bool characterDied = FateOfCharacter(survivalDice, player1);
if (characterDied)
{
player1.Alive = false;
roundNr++;
var round = new Round()
{
RoundNr = roundNr,
Log = player1.Name + " dies from the wounds ",
};
}
}
else if (player2.Health < 0)
{
int survivalDice = random.Next(1, 6);
bool characterDied = FateOfCharacter(survivalDice, player2);
if (characterDied)
{
player2.Alive = false;
roundNr++;
var round = new Round()
{
RoundNr = roundNr,
Log = player2.Name + " dies from the wounds ",
};
}
}
SaveCombatLogToDatabase(ctx, fullFight, player1, spoiler);
if (player2Id != null)
{
SaveCombatLogToDatabase(ctx, fullFight, player2, spoiler);
}
ctx.Arenas.Remove(ctx.Arenas.FirstOrDefault(a => a.CharacterId == player1.Id));
if (ctx.Arenas.Any(a => a.CharacterId == player2Id))
{
ctx.Arenas.Remove(ctx.Arenas.FirstOrDefault(a => a.CharacterId == player2.Id));
}
if (player1Won)
{
UpdateCharacterStats(player1);
}
else
{
if (player2Id != null)
{
UpdateCharacterStats(player2);
}
}
ctx.SaveChanges();
return(fullFight);
}
public void RegisterArmor( ArmorModel armor )
{
m_ArmorModels.Add( armor );
}
public ActionResult BuyLot(int lotId)
{
using (var db = new BGS_DBContext())
{
var id = User.Identity.GetUserId();
var lot = db.LotModels.Single(p => p.Id == lotId);
User user = db.Users.Single(u => u.Id == id);
if (user.AccountBalance - lot.Price > 0)
{
switch (lot.Type)
{
default: throw new Exception("No this lot");
case LotType.Unit:
UnitModel unitModel = db.UnitModels.Single(u => u.LotId == lotId);
unitModel.LotId = null;
unitModel.Owner = user;
break;
case LotType.Armor:
ArmorModel armorModel = db.ArmorModels.Single(u => u.LotId == lotId);
armorModel.LotId = null;
armorModel.Owner = user;
break;
case LotType.Accessory:
AccessoryModel accessoryModel = db.AccessoryModels.Single(u => u.LotId == lotId);
accessoryModel.LotId = null;
accessoryModel.Owner = user;
break;
case LotType.Weapon:
WeaponModel weaponModel = db.WeaponModels.Single(u => u.LotId == lotId);
weaponModel.LotId = null;
weaponModel.Owner = user;
break;
case LotType.Storage:
StorageModel storageModel = db.StorageModels.Single(u => u.LotId == lotId);
storageModel.LotId = null;
storageModel.Owner = user;
break;
case LotType.Modification:
AimModificationModel aim = db.AimModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
MagazineModificationModel magazine = db.MagazineModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
BarrelModificationModel barrel = db.BarrelModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
ButtModificationModel butt = db.ButtModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
if (aim != null)
{
aim.LotId = null; aim.Owner = user;
}
if (magazine != null)
{
magazine.LotId = null; magazine.Owner = user;
}
if (barrel != null)
{
barrel.LotId = null; barrel.Owner = user;
}
if (butt != null)
{
butt.LotId = null; butt.Owner = user;
}
break;
}
lot.Status = LotStatus.Closed;
lot.BuyerId = user.GameId;
user.AccountBalance -= lot.Price;
lot.Seller.AccountBalance += lot.Price;
db.SaveChanges();
return(RedirectToAction("Index", "Market",
new { buy = $"Лот #{lot.Id} успешно куплен за {lot.Price}$4" }));
}
else
{
return(RedirectToAction("Index", "Market",
new { error = "У вас не хватает средств для этой покупки" }));
}
}
}
