internal int saveSize(Models.Size size)
{
using (SqlConnection sqlConnection = new SqlConnection(connectionString))
{
using (SqlCommand command = new SqlCommand("sp_CreateSize", sqlConnection))
{
try
{
sqlConnection.Open();
command.CommandType = CommandType.StoredProcedure;
if (size.SizeId == null)
{
command.Parameters.AddWithValue("@Id", DBNull.Value);
}
else
{
command.Parameters.AddWithValue("@Id", size.SizeId);
}
command.Parameters.AddWithValue("@GoodId", size.GoodId);
command.Parameters.AddWithValue("@Price", size.Price);
command.Parameters.AddWithValue("@Name", size.Name);
return(Convert.ToInt32(command.ExecuteScalar()));
}
catch (Exception ex)
{
throw ex;
}
}
}
}
public ActionResult SizeCreate(string Title)
{
Size size = new Models.Size();
size.Title = Title;
db.Sizes.Add(size);
db.SaveChanges();
return(RedirectToAction("Size"));
}
public override Models.Pizza Make(Models.Size s, List <Models.Topping> t)
{
Data.Entities.Crust chicagoCrustDB = _db.Crust.Find(3);
Models.Crust chicagoCrustModel = new Models.Crust(chicagoCrustDB.Name, chicagoCrustDB.Price)
{
Id = chicagoCrustDB.CrustId
};
Models.Pizza pizza = new Models.Pizza()
{
Size = s,
Crust = chicagoCrustModel
};
foreach (Models.Topping topping in t)
{
pizza.AddTopping(topping);
}
return(pizza);
}
public string PaperSize(float w, float h)
{
Models.Size A3 = new Models.Size {
Height = 1190F, Width = 841F
};
Models.Size A4 = new Models.Size {
Height = 841F, Width = 595F
};
if (w == A3.Width && h == A3.Height)
{
return("A3");
}
if (w == A4.Width && h == A4.Height)
{
return("A4");
}
return("letter");
}
internal List <Models.Size> getSizeByGoodId(int?id)
{
using (SqlConnection sqlConnection = new SqlConnection(connectionString))
{
using (SqlCommand command = new SqlCommand("sp_GetSizeByGoodId", sqlConnection))
{
try
{
sqlConnection.Open();
command.CommandType = CommandType.StoredProcedure;
if (id == null)
{
command.Parameters.AddWithValue("@Id", DBNull.Value);
}
else
{
command.Parameters.AddWithValue("@Id", id);
}
SqlDataReader rdr = command.ExecuteReader();
List <Models.Size> goodsList = new List <Models.Size>();
while (rdr.Read())
{
Models.Size size = new Models.Size();
size.SizeId = Convert.ToInt32(rdr["Id"]);
size.GoodId = Convert.ToInt32(rdr["GoodId"]);
size.Name = rdr["Name"].ToString();
size.Price = Convert.ToDecimal(rdr["Price"].ToString());
goodsList.Add(size);
}
return(goodsList);
}
catch (Exception ex)
{
throw ex;
}
}
}
}
internal static MobPrototypeData ParseMobData(ref StringReader sr, string areaFile, ref int lineNum, string firstLine)
{
Logging.Log.Debug(String.Format("ParseMobData() called for area {0} starting on line {1}", areaFile, lineNum));
// Instantiate variables for the method
MobPrototypeData outMob = new MobPrototypeData();
string lineData = firstLine;
// First, pull the VNUM, then set it if it's valid
int vnum = Data.ParseVNUM(lineData);
if (!vnum.Equals(0))
{
outMob.VNUM = vnum;
}
else
{
return(null);
}
Logging.Log.Debug(String.Format("Found mob definition for vnum {0} beginning on line {1}", outMob.VNUM, lineNum));
// Read the mob name - technically we should just read 'til we get a tilde, but it looks like they're always on one line anyway...
outMob.Name = sr.ReadLine().TrimEnd('~');
lineNum++;
// Next, read the short description; again, a single line
outMob.ShortDescription = sr.ReadLine().TrimEnd('~');
lineNum++;
// Then, read the long description
outMob.LongDescription = Data.ReadLongText(sr, ref lineNum, areaFile, outMob.VNUM);
// Finally, read yet another description
outMob.Description = Data.ReadLongText(sr, ref lineNum, areaFile, outMob.VNUM);
// TODO: Capitalize the first letter of LongDescription and Description. Or don't, I'm not your dad.
// Next, parse the race
string mobRaceName = sr.ReadLine().TrimEnd('~');
lineNum++;
Race mobRace = Consts.Races.RaceTable.SingleOrDefault(r => r.Name.ToLower().Equals(mobRaceName.ToLower()));
// If we can't find the race, log a warning and return null
if (mobRace == null)
{
Logging.Log.Error(String.Format("Encountered unknown race {0} for mob {1} of area {2} on line {3}", mobRaceName, outMob.VNUM, areaFile, lineNum));
return(null);
}
else
{
// Otherwise, store the race
outMob.Race = mobRace;
// Race defaults a number of flags; set these now
outMob.Form = outMob.Race.Form;
outMob.Parts = outMob.Race.Parts;
outMob.Actions = outMob.Race.Actions;
outMob.AffectedBy = outMob.Race.Affects;
outMob.Immunity = outMob.Race.Immunities;
outMob.Resistance = outMob.Race.Resistances;
outMob.Vulnerability = outMob.Race.Vulnerabilities;
}
// Split the next line into an array that should have four elements
lineData = sr.ReadLine();
lineNum++;
string[] splitLine = lineData.Split(' ');
// Expect four segments
if (splitLine.Length != 4)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid act/aff/align/group line, expected 4 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
int parsedValue = 0;
// First segment, action flags - also add IsNPC to all mobs
outMob.Actions |= AlphaConversions.ConvertROMAlphaToActionFlag(splitLine[0]) | ActionFlag.IsNPC;
// Second segment, affected by flags
outMob.AffectedBy = AlphaConversions.ConvertROMAlphaToAffectedByFlag(splitLine[1]);
// Third segment, alignment
if (!Int32.TryParse(splitLine[2], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing alignment for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[2], lineNum));
return(null);
}
else
{
outMob.Alignment = Convert.ToInt32(splitLine[2]);
}
// Fourth segment, group
if (!Int32.TryParse(splitLine[3], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing group number for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[3], lineNum));
return(null);
}
else
{
outMob.Group = Convert.ToInt32(splitLine[3]);
}
// Read the next line and split - expect six segments
lineData = sr.ReadLine();
lineNum++;
splitLine = lineData.Split(' ');
if (splitLine.Length != 6)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid level/hit/health/mana/damage/dtype line, expected 6 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment, level
if (!Int32.TryParse(splitLine[0], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing level for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[0], lineNum));
return(null);
}
else
{
outMob.Level = Convert.ToInt32(splitLine[0]);
}
// Second segment, hitroll
if (!Int32.TryParse(splitLine[1], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing hitroll for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[1], lineNum));
return(null);
}
else
{
outMob.HitRoll = Convert.ToInt32(splitLine[1]);
}
// Third segment, hit dice
DiceRoll dice;
if (!DiceRoll.TryParse(splitLine[2], out dice))
{
Logging.Log.Error(String.Format("Error parsing hit dice for mobile {0} in area {1}: invalid dice roll string ({2}) encountered on line {3}", outMob.VNUM, areaFile, splitLine[2], lineNum));
return(null);
}
else
{
outMob.Health = dice;
}
// Fourth segment, mana dice
if (!DiceRoll.TryParse(splitLine[3], out dice))
{
Logging.Log.Error(String.Format("Error parsing mana dice for mobile {0} in area {1}: invalid dice roll string ({2}) encountered on line {3}", outMob.VNUM, areaFile, splitLine[3], lineNum));
return(null);
}
else
{
outMob.Mana = dice;
}
// Fifth segment, damage dice
if (!DiceRoll.TryParse(splitLine[4], out dice))
{
Logging.Log.Error(String.Format("Error parsing damage dice for mobile {0} in area {1}: invalid dice roll string ({2}) encountered on line {3}", outMob.VNUM, areaFile, splitLine[4], lineNum));
return(null);
}
else
{
outMob.Damage = dice;
}
// Sixth segment, damage type - check that we have a matching damage type with the given abbreviation
DamageType dtype = Consts.DamageTypes.AttackTable.SingleOrDefault(d => d.Abbreviation.Equals(splitLine[5].Trim()));
if (dtype == null)
{
Logging.Log.Error(String.Format("Error parsing damage type for mobile {0} in area {1}: unknown damage type {2} specified on line {4}", outMob.VNUM, areaFile, splitLine[5], lineNum));
return(null);
}
else
{
outMob.DamageType = dtype;
}
// Read the next line and split again, armor classes - expect four segments
lineData = sr.ReadLine();
lineNum++;
splitLine = lineData.Split(' ');
if (splitLine.Length != 4)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid level/hit/health/mana/damage/dtype line, expected 4 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment, piercing AC
if (!Int32.TryParse(splitLine[0], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing piercing AC for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[0], lineNum));
return(null);
}
else
{
outMob.ArmorRating.Pierce = Convert.ToInt32(splitLine[0]);
}
// Second segment, bashing AC
if (!Int32.TryParse(splitLine[1], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing bashing AC for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[1], lineNum));
return(null);
}
else
{
outMob.ArmorRating.Bash = Convert.ToInt32(splitLine[1]);
}
// Third segment, slashing AC
if (!Int32.TryParse(splitLine[2], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing slashing AC for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[2], lineNum));
return(null);
}
else
{
outMob.ArmorRating.Slash = Convert.ToInt32(splitLine[2]);
}
// Fourth segment, exotic AC
if (!Int32.TryParse(splitLine[3], out parsedValue))
{
Logging.Log.Error(String.Format("Error parsing exotic AC for mobile {0} in area {1}: non-numeric value {2} encountered on line {3}", outMob.VNUM, areaFile, splitLine[3], lineNum));
return(null);
}
else
{
outMob.ArmorRating.Exotic = Convert.ToInt32(splitLine[3]);
}
// Read the next line and split again, offense/imm/res/vuln flags - expect four segments
lineData = sr.ReadLine();
lineNum++;
splitLine = lineData.Split(' ');
if (splitLine.Length != 4)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid offense/imm/res/vuln line, expected 4 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment, offense flags
outMob.Offense |= AlphaConversions.ConvertROMAlphaToOffensiveFlag(splitLine[0]);
// Second segment, immunity flags
outMob.Immunity |= AlphaConversions.ConvertROMAlphaToImmunitylag(splitLine[1]);
// Third segment, resistance flags
outMob.Resistance |= AlphaConversions.ConvertROMAlphaToResistanceFlag(splitLine[2]);
// Fourth segment, vulnerability flags
outMob.Vulnerability |= AlphaConversions.ConvertROMAlphaToVulnerabilityFlag(splitLine[3]);
// Read the next line and split again, start pos/default pos/sex/wealth - epect four segments
lineData = sr.ReadLine();
lineNum++;
splitLine = lineData.Split(' ');
if (splitLine.Length != 4)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid start pos/default pos/sex/wealth line, expected 4 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment, start position
Position startPos = Consts.Positions.PositionTable.SingleOrDefault(p => p.ShortName.Equals(splitLine[0]));
if (startPos == null)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid start position \"{2}\" found on line {3}", outMob.VNUM, areaFile, splitLine[0], lineNum));
return(null);
}
else
{
outMob.StartingPosition = startPos;
}
// Second segment, default position
Position defPos = Consts.Positions.PositionTable.SingleOrDefault(p => p.ShortName.Equals(splitLine[1]));
if (startPos == null)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid default position \"{2}\" found on line {3}", outMob.VNUM, areaFile, splitLine[1], lineNum));
return(null);
}
else
{
outMob.DefaultPosition = defPos;
}
// Third segment, gender
Gender mobGender = Consts.Gender.GenderTable.SingleOrDefault(g => g.Name.Equals(splitLine[2]));
if (mobGender == null)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid gender \"{2}\" found on line {3}", outMob.VNUM, areaFile, splitLine[2], lineNum));
return(null);
}
else
{
outMob.Gender = mobGender;
}
// Fourth segment, wealth
int wealth = 0;
if (!Int32.TryParse(splitLine[3], out wealth))
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid wealth \"{2}\" found on line {3}, expected an integer", outMob.VNUM, areaFile, splitLine[3], lineNum));
return(null);
}
else
{
outMob.Wealth = wealth;
}
// Read the next line and split again, form/parts/size/material - epect four segments
lineData = sr.ReadLine();
lineNum++;
splitLine = lineData.Split(' ');
if (splitLine.Length != 4)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid start pos/default pos/sex/wealth line, expected 4 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment, form
outMob.Form |= AlphaConversions.ConvertROMAlphaToFormFlag(splitLine[0]);
// Second segment, parts
outMob.Parts |= AlphaConversions.ConvertROMAlphaToPartFlag(splitLine[1]);
// Third segment, size
Models.Size mobSize = Consts.Size.SizeTable.SingleOrDefault(s => s.Name.Equals(splitLine[2]));
if (mobSize == null)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid size \"{2}\" found on line {3}", outMob.VNUM, areaFile, splitLine[2], lineNum));
return(null);
}
else
{
outMob.Size = mobSize;
}
// Fourth segment, material
outMob.Material = splitLine[3];
// Peek ahead to the next line, see if it starts with F, which tells us to un-set some flags
while ((char)sr.Peek() == 'F')
{
// Read the line
lineData = sr.ReadLine();
lineNum++;
// Split the line, expect 3 segments
splitLine = lineData.Split(' ');
if (splitLine.Length != 3)
{
Logging.Log.Error(String.Format("Error parsing mobile {0} in area {1}: invalid flag modification line, expected 3 segments but got {2} - value {3} on line {4}", outMob.VNUM, areaFile, splitLine.Length, lineData, lineNum));
return(null);
}
// First segment is line identifier, ignore it. Second segment is which flag to modify, third segment is flag(s) to remove.
switch (splitLine[1])
{
case "act": // Actions
Logging.Log.Debug(String.Format("Removing action flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Actions &= ~AlphaConversions.ConvertROMAlphaToActionFlag(splitLine[2]);
break;
case "aff": // AffectedBy
Logging.Log.Debug(String.Format("Removing affected by flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.AffectedBy &= ~AlphaConversions.ConvertROMAlphaToAffectedByFlag(splitLine[2]);
break;
case "off": // Offense
Logging.Log.Debug(String.Format("Removing offense flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Offense &= ~AlphaConversions.ConvertROMAlphaToOffensiveFlag(splitLine[2]);
break;
case "imm": // Immunities
Logging.Log.Debug(String.Format("Removing immunity flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Immunity &= ~AlphaConversions.ConvertROMAlphaToImmunitylag(splitLine[2]);
break;
case "res": // Resistances
Logging.Log.Debug(String.Format("Removing restistance flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Resistance &= ~AlphaConversions.ConvertROMAlphaToResistanceFlag(splitLine[2]);
break;
case "vul": // Vulnerabilities
Logging.Log.Debug(String.Format("Removing vulnerability flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Vulnerability &= ~AlphaConversions.ConvertROMAlphaToVulnerabilityFlag(splitLine[2]);
break;
case "for": // Form
Logging.Log.Debug(String.Format("Removing form flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Form &= ~AlphaConversions.ConvertROMAlphaToFormFlag(splitLine[2]);
break;
case "par": // Parts
Logging.Log.Debug(String.Format("Removing parts flags {0} from mob {1} in area {2} on line {3}", splitLine[2], outMob.VNUM, areaFile, lineNum));
// Remove flags
outMob.Parts &= ~AlphaConversions.ConvertROMAlphaToPartFlag(splitLine[2]);
break;
default:
Logging.Log.Warn(String.Format("Encountered unexpected mob flag modifier type {0} for mob {1} in file {2} on line {3}", splitLine[1], outMob.VNUM, areaFile, lineNum));
break;
}
}
Logging.Log.Debug(String.Format("Mobile {0} in area {1} loaded", outMob.VNUM, areaFile));
return(outMob);
}
