public KissyKissyAction(bool hasActionCommand, int numAttacks, int damagePerAttack, Elements damageElement, bool piercing, bool sideDirect, HeightStates[] heightsAffected) { Name = "Kissy-Kissy"; //None of the enemies that use this move ever perform a charge; it makes sense to me to make it use up a charge MoveInfo = new MoveActionData(null, "Absorb health from your opponent.", MoveResourceTypes.FP, 0, CostDisplayTypes.Shown, MoveAffectionTypes.Other, TargetSelectionMenu.EntitySelectionType.Single, true, heightsAffected, User.GetOpposingEntityType()); ContactTypes contactType = ContactTypes.SideDirect; if (sideDirect == false) { contactType = ContactTypes.TopDirect; } DamageInfo = new DamageData(damagePerAttack, damageElement, piercing, contactType, ContactProperties.None, null, false, false, DefensiveActionTypes.None, DamageEffects.None); SetMoveSequence(new KissyKissySequence(this, numAttacks)); EnableActionCommand = hasActionCommand; if (hasActionCommand == true) { //If Kissy-Kissy has an Action Command, it can't be Guarded or Superguarded DamageInfo.DefensiveOverride = DefensiveActionTypes.Guard | DefensiveActionTypes.Superguard; actionCommand = new MashButtonCommand(MoveSequence, 100d, 10d, MashButtonCommand.InfiniteTime, Microsoft.Xna.Framework.Input.Keys.A); } }
public SiteContact(ContactTypes type, String siteID) : base(Table, Database.Instance) { PrimaryKeyColumns = PrimaryKeys; int contactNum = 0; switch (type) { case ContactTypes.Foreman: contactNum = 0; break; case ContactTypes.Supervisor1: contactNum = 1; break; case ContactTypes.Supervisor2: contactNum = 2; break; case ContactTypes.SupplyAuth: contactNum = 3; break; } SetValue(Fields.contactType.ToString(), contactNum); SetValue(Fields.siteID.ToString(), siteID); SetValue(Fields.Name.ToString(), ""); SetValue(Fields.Email.ToString(), ""); SetValue(Fields.Phone.ToString(), ""); isNew = true; }
public async Task <IActionResult> PutContactTypes([FromRoute] int id, [FromBody] ContactTypes contactTypes) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != contactTypes.ContactTypeID) { return(BadRequest()); } _context.Entry(contactTypes).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ContactTypesExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
static void Main(string[] args) { Dictionary <string, Person> dict = new Dictionary <string, Person>(); ContactTypes contactSimple = ContactTypes.Billing; ContactTypes multipleContacts = ContactTypes.Work | ContactTypes.Home; KeyValuePair <string, string> t = new KeyValuePair <string, string>("key", "value"); Dictionary <string, string> dict2 = new Dictionary <string, string>() { { "key1", "val1" }, { "key2", "val2" } }; System.Text.StringBuilder builder = new StringBuilder(); for (int i = 0; i < 1000; i++) { builder.AppendFormat("loop i is {0}", i.ToString()); builder.AppendLine("tyaye"); builder.AppendLine("tyaye"); } Test tst = new Test(); Person steven = new Person("Steven", 17); Person jemel = new Person("Jemel", 83); SuperHero batman = new SuperHero("Batman", 35, "None!?"); var x = 0; }
public IActionResult AddContact([FromForm] ContactPM model) { var user = _phoneBookContext.Users.Include(q => q.ContactTypes).FirstOrDefault(p => p.ID == model.UserID); if (user != null) { if (user.ContactTypes == null) { ContactTypes contactTypes = new ContactTypes(); contactTypes.Email = model.Email; contactTypes.Phone = model.Phone; contactTypes.Location = model.Location; contactTypes.UserID = model.UserID; _phoneBookContext.ContactTypes.Add(contactTypes); _phoneBookContext.SaveChanges(); return(Ok($"ID'si {model.UserID} olan kişiye iletişim bilgisi eklendi!")); } else { return(BadRequest($"ID'si {model.UserID} olan kişinin zaten iletişim bilgisi var!(güncelleme istenmemiş)")); } } else { return(BadRequest($"ID'si {model.UserID} olan kişi bulunamadı!")); } }
private void LoadPickerData() { try { ContactTypes = AppData.ConfigModel.ContactTypes(AppData.PropertyModel.SelectedProperty.Organisation); foreach (var res in ContactTypes.OrderBy(x => x.Description).ToList()) { Pkr_CustomerType.Items.Add(res.Description); } if (AppData.PropertyModel.SelectedRecord.Record.Record.Customers.Count > 0) { Pkr_CustomerType.SelectedIndex = Pkr_CustomerType.Items.IndexOf( AppData.PropertyModel.SelectedRecord.Record.Record.Customers[0].CustomerTypeDescription); } else { Pkr_CustomerType.SelectedIndex = 0; } } catch (Exception ex) { LogTracking.LogTrace(ex.ToString()); } }
/// <summary> /// Determines the result of contact, based on the type of contact made, when it's made with this entity. /// <para>Contacts that aren't a Success are prioritized over any Payback. /// If a ContactResult of Success is found, then the Payback for this entity is added if it exists /// and the ContactResult becomes a PartialSuccess.</para> /// </summary> /// <param name="attacker">The entity attacking this one</param> /// <param name="contactType">The type of contact made with this entity</param> /// <returns>A ContactResultInfo containing the result of the interaction</returns> public ContactResultInfo GetContactResult(BattleEntity attacker, ContactTypes contactType) { ContactResultInfo contactResultInfo = Interactions.GetContactResult(attacker, contactType, GetAllPhysAttributes(), attacker.EntityProperties.GetContactExceptions(contactType)); //On a Success, check if this Entity has any Payback and add it if so if ((contactResultInfo.ContactResult == ContactResult.Success || contactResultInfo.ContactResult == ContactResult.PartialSuccess) && HasPayback() == true) { PaybackHolder paybackholder; //Factor in the contact's Payback on a PartialSuccess if (contactResultInfo.ContactResult == ContactResult.PartialSuccess) { paybackholder = GetPayback(contactResultInfo.Paybackholder); } //Get only the BattleEntity's Payback on a Success else { paybackholder = GetPayback(); } //Since there's Payback, the result is now a PartialSuccess contactResultInfo.ContactResult = ContactResult.PartialSuccess; contactResultInfo.Paybackholder = paybackholder; } return(contactResultInfo); }
/// <summary> /// Gets the result of a ContactType on a set of PhysicalAttributes /// </summary> /// <param name="attacker">The BattleEntity performing the attack</param> /// <param name="contactType">The ContactType performed</param> /// <param name="physAttributes">The set of PhysicalAttributes to test against</param> /// <param name="attributesToIgnore">A set of PhysicalAttributes to ignore</param> /// <returns>A ContactResultInfo of the interaction</returns> public static ContactResultInfo GetContactResult(BattleEntity attacker, ContactTypes contactType, PhysicalAttributes[] physAttributes, params PhysicalAttributes[] attributesToIgnore) { //Return the default value if (ContactTable.ContainsKey(contactType) == false || physAttributes == null) { Debug.LogWarning($"{nameof(physAttributes)} array is null or {nameof(ContactTable)} does not contain the ContactType {contactType}!"); return(ContactResultInfo.Default); } //Look through the attributes and find the first match for (int i = 0; i < physAttributes.Length; i++) { Dictionary <PhysicalAttributes, ContactResultInfo> tableForContact = ContactTable[contactType]; PhysicalAttributes attribute = physAttributes[i]; //If this attribute is ignored, move onto the next if (attributesToIgnore?.Contains(attribute) == true) { continue; } if (tableForContact.ContainsKey(attribute) == true) { ContactResultInfo contactResult = tableForContact[attribute]; //If the ContactResult is a Success if the entity has the same PhysicalAttribute as the one tested, set its result to Success if (contactResult.SuccessIfSameAttr == true && attacker.EntityProperties.HasPhysAttributes(true, attribute) == true) { contactResult.ContactResult = ContactResult.Success; } return(contactResult); } } return(ContactResultInfo.Default); }
public List<ContactType> Get(ContactTypes request) { ContactTypeRepository repository = GetContactTypeRepository(); List<ContactTypeEntity> entities = repository.Read(); return entities.TranslateToResponse(); }
/// <summary> /// Determines if this instance of <see cref="User" /> is also a contact for an organization. Users are considered a /// contact if any of the fields typically associated with a Contact record are present. /// </summary> public bool IsUserAlsoContact() { return(AssociatedEntities != null && AssociatedEntities.Any() || ContactTypes != null && ContactTypes.Any() || !string.IsNullOrEmpty(PrimaryPhoneNumber) || !string.IsNullOrEmpty(MobilePhoneNumber) || !string.IsNullOrEmpty(Title) || PhysicalAddress != null && !PhysicalAddress.IsEmpty()); }
/// <summary> /// Returns a set of PhysicalAttributes to ignore when the BattleEntity makes contact /// </summary> /// <param name="contactType">The type of contact this BattleEntity made</param> /// <returns>An array of PhysicalAttributes this BattleEntity can ignore when making contact, otherwise an empty array</returns> public PhysicalAttributes[] GetContactExceptions(ContactTypes contactType) { //Return an empty array if no exceptions exist for this type of contact if (ContactExceptions.ContainsKey(contactType) == false) { return(new PhysicalAttributes[0]); } return(ContactExceptions[contactType].ToArray()); }
/// <summary> /// Method used to add a contact by absolute position /// </summary> /// <param name="position">Absolute position of contact <see cref="PointF"/></param> /// <param name="contactType">Contact type to create <see cref="ContactTypes"/></param> /// <param name="heading"></param> /// <param name="speed"></param> /// <param name="altitude"></param> /// <returns></returns> protected IReferencePoint CreateContactAtPoint(PointF position, ContactTypes contactType, double heading = 0.00, double speed = 0.00, double altitude = 0.00) { var contactFactory = new ContactCreator(); var newContact = contactFactory.Create(RadarReceiver, position, heading, altitude, speed, contactType); Logger.Info($"Creating contact: {contactType} as a plotted contact at {position}"); newContact.ReferencePointChanged += NewContact_ReferencePointChanged; RadarReceiver.AddContact(newContact); newContact.Start(); return(newContact); }
public EditProfileVM GetEditProfileVM() { var user = AuthService.CurrentUser; var result = new EditProfileVM { User = AuthService.CurrentUser, }; SetDictionaries(result); if (result.User != null) { var contactsVM = result.Contacts; if (user.IsCompany) { contactsVM.Phone = GetContact(user.Company.UserContacts, ContactTypes.Phone); contactsVM.Mobile = GetContact(user.Company.UserContacts, ContactTypes.Mobile); contactsVM.WorkPhone = GetContact(user.Company.UserContacts, ContactTypes.WorkPhone); result.UserAddress = user.Company.UserAddresses.FirstOrDefault(); } else { result.UserAddress = user.UserAddresses.FirstOrDefault(); contactsVM.Socials = GetSocials(user.UserContacts); InitPhones(user, contactsVM); } } else { result.User = new User(); } if (result.UserAddress == null) { result.UserAddress = new UserAddress(); } if (result.Company == null) { result.Company = new Company(); } result.ContactTypes = UserContractTypeService.GetAll() .Where(uct => ContactTypes.ForProfile().Contains(uct.ContactTypeID)) .ToList(); return(result); }
public async Task <IActionResult> PostContactTypes([FromBody] ContactTypes contactTypes) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.ContactTypes.Add(contactTypes); await _context.SaveChangesAsync(); return(CreatedAtAction("GetContactTypes", new { id = contactTypes.ContactTypeID }, contactTypes)); }
/// <summary> /// Adds a contact exception to the entity /// </summary> /// <param name="contactType"></param> /// <param name="physAttribute"></param> public void AddContactException(ContactTypes contactType, PhysicalAttributes physAttribute) { //Add a new key if one doesn't exist if (ContactExceptions.ContainsKey(contactType) == false) { ContactExceptions.Add(contactType, new List <PhysicalAttributes>()); } //Add to the list ContactExceptions[contactType].Add(physAttribute); Debug.Log($"Added contact exception on {Entity.Name} for the {physAttribute} PhysicalAttribute during {contactType} contact!"); }
protected override void Init() { RuleFor(x => x.Contact).Must((contact, x) => { if (x.IsEmpty()) { return(true); } var regexp = new Regex(ContactTypes.GetRegExp(contact.ContactTypeID)); return(regexp.IsMatch(x)); } ).WithMessage("Не верный формат"); }
private void plotPanel_MouseDoubleClick(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Right) { ContactTypes contactType = ContactTypes.AirUnknown; var typeToPlot = $"{selectType.Text}{selectClass.Text}"; var absolutePosition = new PointF(e.X, e.Y); if (Enum.TryParse(typeToPlot, out contactType)) { var newContact = CreateContactAtPoint(absolutePosition, contactType, decimal.ToInt32(contactCourse.Value), decimal.ToInt32(contactSpeed.Value)); RefreshContactList(); } } }
public async Task KeyValues() { var contactTypes = new ContactTypes(); var keyValues = await contactTypes.KeyValuesAsync(); int count = 0; int oldId = 0; string oldName = null; foreach (var keyValue in keyValues) { int id = int.Parse(keyValue.Key); Assert.Greater(id, oldId); oldId = id; Assert.False(string.IsNullOrEmpty(keyValue.Value)); Assert.AreNotEqual(oldName, keyValue.Value); oldName = keyValue.Value; count++; } Assert.AreEqual(20, count); }
private List <UserContact> GetSocials(EntitySet <UserContact> contacts) { var allSocials = ContactTypes.GetAllSocialServices(); var currentContacts = contacts .Where(x => allSocials.Contains(x.ContactTypeID)); var forAdd = allSocials.Where(x => currentContacts.All(y => y.ContactTypeID != x)); if (forAdd.Any()) { var userContacts = UserContractTypeService.GetByPK(forAdd.Cast <object>()) .ToList() .Select(x => new UserContact { ContactTypeID = x.ContactTypeID, UserContactType = x }); currentContacts = currentContacts.Union(userContacts).ToList(); } return(currentContacts.OrderBy(x => allSocials.IndexOf(x.ContactTypeID)).ToList()); }
public void RemoveContactException(ContactTypes contactType, PhysicalAttributes physAttribute) { if (ContactExceptions.ContainsKey(contactType) == false) { Debug.LogError($"Cannot remove {physAttribute} from the exception list on {Entity.Name} for {contactType} because no list exists!"); return; } bool removed = ContactExceptions[contactType].Remove(physAttribute); if (removed == true) { Debug.Log($"Removed {physAttribute} attribute exception on {Entity.Name} for {contactType} contact!"); } //If there are no PhysicalAttributes in the exceptions list for this ContactType, remove the key if (ContactExceptions[contactType].Count == 0) { ContactExceptions.Remove(contactType); } }
public static void AddContacts(User user, Student student) { var email = user.Email; if (student.StudentEmails.All(se => se.Email != email)) { student.StudentEmails.Add(CreateStudentEmail(email)); } var phones = user.UserContacts.ToList() .Where(uc => !uc.Contact.IsEmpty() && ContactTypes.Phones().Contains(uc.ContactTypeID) && student.StudentPhones.All(sp => sp.PhoneNumber != uc.Contact)); foreach (var phone in phones) { var phoneTypeTC = ContactTypes.GetPhoneTypeTC(phone.ContactTypeID); var phoneNumber = phone.Contact; student.StudentPhones.Add(CreateStudentPhone(phoneTypeTC, phoneNumber)); } }
public static Contact Create(ContactTypes contactType) { switch (contactType) { case ContactTypes.Organization: return(new OrganizationContact()); case ContactTypes.Person: return(new PersonContact()); case ContactTypes.User: return(new UserContact()); case ContactTypes.Carrier: return(new CarrierContact()); case ContactTypes.Provider: return(new ProviderContact()); default: throw new UnexpectedSwitchValueException(contactType); } }
public virtual Contact GetContactByType(ContactTypes contactType) { return(this.Contacts.Single(x => x.Contact.ContactTypeID == contactType).Contact); }
/// <summary> /// Load a contact from a file. /// </summary> /// <param name="fileName">The file that contains the contact data to load.</param> /// <exception cref="InvalidDataException"> /// The specified file exists but doesn't doesn't represent a valid contact. /// </exception> /// <exception cref="FileNotFoundException"> /// The specified file couldn't be found. /// </exception> /// <exception cref="UnauthorizedAccessException"> /// The specified file couldn't be opened for an unknown reason. It may be that it's /// opened within incompatible sharing permissions. Retrying the operation at a later /// time may succeed. /// </exception> public Contact(string fileName) { Verify.IsNotNull(fileName, "fileName"); Verify.IsApartmentState(ApartmentState.STA, _exceptionStringBadThreadId); // make the path absolute. fileName = IOPath.GetFullPath(fileName); _contactProperties = ContactLoader.GetContactFromFile(fileName); _sharedProperties = true; // Only really need to compute the hash if we change the contact... _sourceHash = _contactProperties.StreamHash; Path = fileName; Id = ContactId.GetRuntimeId(ContactIds.Default.Value, Path); _originalName = Names.Default.FormattedName; _type = GetTypeFromExtension(fileName); }
private void SaveDetails() { try { SRiCustomer customer = new SRiCustomer(); if (ContactsDetails.Count == 0) { customer.Name = Lbl_Name.Text; customer.RecordKeyVal = ""; customer.KeyVal = ""; customer.Address = EdAddress.Text; Contact = new List <SRiContact>() { new SRiContact() { ContactType = "PHONEH", ContactDescription = "Phone", ContactAddress = Lbl_Phone.Text, SRRecKeyVal = "", CustomerKeyVal = "", KeyVal = "" }, new SRiContact() { ContactType = "EMAIL", ContactDescription = "Email", ContactAddress = Lbl_Email.Text, SRRecKeyVal = "", CustomerKeyVal = "", KeyVal = "" }, new SRiContact() { ContactType = "MOBILE", ContactDescription = "Mobile", ContactAddress = Lbl_Moblie.Text, SRRecKeyVal = "", CustomerKeyVal = "", KeyVal = "" } }; customer.CustomerType = ContactTypes.Where(x => x.Description == Pkr_CustomerType.Items[Pkr_CustomerType.SelectedIndex]).Select(x => x.Code).FirstOrDefault(); customer.Contacts = Contact; AppData.PropertyModel.SelectedRecord.Record.Record.Customers.Add(customer); } else { if (AppData.PropertyModel.SelectedRecord.Record.Record.Customers.Count > 0) { foreach (var item in AppData.PropertyModel.SelectedRecord.Record.Record.Customers) { item.Name = Lbl_Name.Text; item.Address = EdAddress.Text; item.CustomerType = ContactTypes.Where( x => x.Description == Pkr_CustomerType.Items[Pkr_CustomerType.SelectedIndex]) .Select(x => x.Code) .FirstOrDefault(); foreach (var contcat in item.Contacts) { if (contcat.ContactType == "PHONEH") { contcat.ContactAddress = Lbl_Phone.Text; } if (contcat.ContactType == "EMAIL") { contcat.ContactAddress = Lbl_Email.Text; } if (contcat.ContactType == "MOBILE") { contcat.ContactAddress = Lbl_Moblie.Text; } } } } } AppData.PropertyModel.SelectedRecord.CreateMappings(); Exception error; AppData.PropertyModel.SaveCustomer(out error); _customerLists = new CreateCustomerList(); ContactsDetails = _customerLists.Details; // update UI in Listview SplitView.CenterPopupContent.DismisPopup(); UpdateContact?.Invoke(ContactsDetails); } catch (Exception ex) { LogTracking.LogTrace(ex.ToString()); } }
public Contact(ContactTypes tp, string contact) { ContactType = tp; ContactGegevens = contact; }
private void _PopulateKnownContacts(ContactTypes type) { Assert.IsNotNull(_loader); Assert.IsNotNull(_dispatcher); Assert.IsTrue(_dispatcher.CheckAccess()); Assert.IsNotNull(_knownContacts); Assert.AreEqual(0, _knownContacts.Count); // Go through all contacts associated with the manager and make the mapping of file paths to the ContactIds. foreach (var entry in _loader.GetPropertiesCollection(type)) { // Not using these contacts for very long. Don't need the ContactManager parameter. using (var contact = new Contact(null, entry.Value, entry.Key)) { ContactInfo info = default(ContactInfo); info.Id = contact.Id; string pathNormalized = contact.Path.ToUpperInvariant(); info.LastWrite = File.GetLastWriteTime(pathNormalized); _knownContacts.Add(pathNormalized, info); } } }
public IList<Contact> GetContactCollection(ContactTypes typeFilter) { _Validate(false); IList<Contact> list = new List<Contact>(); foreach (KeyValuePair<string, IContactProperties> prop in _contactCache.GetPropertiesCollection(typeFilter)) { Contact c = new Contact(this, prop.Value, prop.Key); list.Add(c); } return list; }
/// <summary> /// /// </summary> /// <param name="startAbsolutePosition">Absolute position where the contact is plotted from</param> /// <param name="contactType"></param> /// <param name="polarCoord">Bearing and range from absolute position for the new contact</param> /// <param name="heading"></param> /// <param name="speed"></param> /// <param name="altitude"></param> /// <returns></returns> public IReferencePoint CreateContactAtPolarCoordinate(PointF startAbsolutePosition, ContactTypes contactType, PolarCoordinate polarCoord, double heading = 0.00, double speed = 0.00, double altitude = 0.00) { var relativePosition = startAbsolutePosition.GetRelativePosition(RadarReceiver.ViewPortExtent); var newRelativePosition = CoordinateConverter.CalculatePointFromDegrees(relativePosition, polarCoord, CoordinateConverter.ROUND_DIGITS); var newAbsolutePosition = newRelativePosition.GetAbsolutePosition(RadarReceiver.ViewPortExtent); return(CreateContactAtPoint(newAbsolutePosition, contactType, heading, speed, altitude)); }
/// <summary> /// Gets the result of a ContactType on a set of PhysicalAttributes. /// </summary> /// <param name="attackerPhysAttributes">The attacker's set of PhysicalAttributes.</param> /// <param name="contactType">The ContactType performed.</param> /// <param name="contactProperty">The ContactProperty of the contact.</param> /// <param name="victimPaybacks">The victim's set of Paybacks to test against.</param> /// <param name="attackerContactExceptions">The attacker's contact exceptions; the set PhysicalAttributes to ignore.</param> /// <returns>A ContactResultInfo of the interaction.</returns> public static ContactResultInfo GetContactResult(IList <PhysicalAttributes> attackerPhysAttributes, ContactTypes contactType, ContactProperties contactProperty, IList <PaybackHolder> victimPaybacks, params PhysicalAttributes[] attackerContactExceptions) { //Return the default value if (victimPaybacks == null || victimPaybacks.Count == 0) { return(ContactResultInfo.Default); } /*0. Initialize a list of Paybacks, called PaybackList * 1. Go through all of the Victim's Paybacks * 2. Check if the Payback's PaybackContacts contains the ContactType of the attack * 3a. If so, check if the Attacker has any ContactExceptions for the Payback's PhysAttribute * 4a. If so, ignore it and continue * 4b. If not, check if the Payback covers any of the attack's ContactProperties * 5a. If so, check if the Attacker has the same PhysAttribute as the Payback's * 6a. If so, examine the SamePhysAttrResult and go to 7a * 6b. If not, examine the PaybackContactResult and go to 7a * 7a. If the ContactResult is a Failure, return that Payback value * 7b. If the ContactResult is a Success, ignore it and continue * 7c. If the ContactResult is a PartialSuccess, add it to PaybackList and continue * 4c. If not, ignore it and continue * 3b. If not, continue */ //The Paybacks that will be combined List <PaybackHolder> combinedPaybacks = new List <PaybackHolder>(); //Look through the Paybacks for (int i = 0; i < victimPaybacks.Count; i++) { PaybackHolder payback = victimPaybacks[i]; //Check if the Payback covers this ContactType if (payback.PaybackContacts != null && payback.PaybackContacts.Contains(contactType) == true) { //If there are contact exceptions for this PhysicalAttribute, ignore this Payback if (attackerContactExceptions.Contains(payback.PhysAttribute) == true) { continue; } //Check if the Payback covers the ContactProperty if (payback.ContactProperties != null && payback.ContactProperties.Contains(contactProperty) == false) { continue; } ContactResult contactResult = payback.PaybackContactResult; //Check if the Attacker has the PhysicalAttribute the Payback is associated with, and adjust the ContactResult if so if (attackerPhysAttributes.Contains(payback.PhysAttribute) == true) { contactResult = payback.SamePhysAttrResult; } //If a Failure, use this Payback if (contactResult == ContactResult.Failure) { return(new ContactResultInfo(payback, contactResult)); } //If a PartialSuccess, add it to the list else if (contactResult == ContactResult.PartialSuccess) { combinedPaybacks.Add(payback); } } } //Combine all the Paybacks in the list PaybackHolder finalPayback = PaybackHolder.CombinePaybacks(combinedPaybacks); return(new ContactResultInfo(finalPayback, finalPayback.PaybackContactResult)); }
/// <summary>Internal only constructor for Contact.</summary> /// <param name="manager"></param> /// <param name="properties"></param> /// <param name="fileName"></param> internal Contact(ContactManager manager, IContactProperties properties, string fileName) { Assert.IsNotNull(properties); Verify.IsNeitherNullNorEmpty(fileName, "fileName"); // Caller should have ensured this is canonicalized... Assert.AreEqual(fileName, IOPath.GetFullPath(fileName)); _manager = manager; _contactProperties = properties; _sharedProperties = true; _sourceHash = _contactProperties.StreamHash; _type = GetTypeFromExtension(fileName); Path = fileName; Id = ContactId.GetRuntimeId(ContactIds.Default.Value, Path); _originalName = Names.Default.FormattedName; }
public static InteractionResult GetDamageInteractionOld(InteractionParamHolder interactionParam) { InteractionResult finalInteractionResult = new InteractionResult(); BattleEntity attacker = interactionParam.Attacker; BattleEntity victim = interactionParam.Victim; ContactTypes contactType = interactionParam.ContactType; Elements element = interactionParam.DamagingElement; StatusChanceHolder[] statuses = interactionParam.Statuses; int damage = interactionParam.Damage; bool piercing = interactionParam.Piercing; //Get contact results ContactResultInfo contactResultInfo = victim.EntityProperties.GetContactResult(attacker, contactType); ContactResult contactResult = contactResultInfo.ContactResult; //Retrieve an overridden type of Elemental damage to inflict based on the Victim's PhysicalAttributes //(Ex. The Ice Power Badge only deals Ice damage to Fiery entities) ElementOverrideHolder newElement = attacker.EntityProperties.GetTotalElementOverride(victim); if (newElement.Element != Elements.Invalid) { //Add the number of element overrides to the damage if the element used already exists as an override and the victim has a Weakness //to the Element. This allows Badges such as Ice Power to deal more damage if used in conjunction with attacks //that deal the same type of damage (Ex. Ice Power and Ice Smash deal 2 additional damage total rather than 1). //If any new knowledge is discovered to improve this, this will be changed //Ice Power is the only Badge of its kind across the first two PM games that does anything like this if (element == newElement.Element && victim.EntityProperties.HasWeakness(element) == true) { damage += newElement.OverrideCount; } element = newElement.Element; } /*Get the total damage dealt to the Victim. The amount of Full or Half Payback damage dealt to the Attacker * uses the resulting damage value from this because Payback uses the total damage that would be dealt to the Victim. * This occurs before factoring in elemental resistances/weaknesses from the Attacker*/ ElementDamageResultHolder victimElementDamage = GetElementalDamage(victim, element, damage); int unscaledVictimDamage = victimElementDamage.Damage; //Subtract damage reduction (P-Up, D-Down and P-Down, D-Up Badges) unscaledVictimDamage -= victim.BattleStats.DamageReduction; //Check if the attack hit. If not, then don't consider defensive actions bool attackHit = interactionParam.CantMiss == true ? true : attacker.AttemptHitEntity(victim); //Defense added from Damage Dodge Badges upon a successful Guard int damageDodgeDefense = 0; //Defensive actions take priority. If the attack didn't hit, don't check for defensive actions BattleGlobals.DefensiveActionHolder?victimDefenseData = null; if (attackHit == true) { victimDefenseData = victim.GetDefensiveActionResult(unscaledVictimDamage, statuses, interactionParam.DamageEffect); } if (victimDefenseData.HasValue == true) { unscaledVictimDamage = victimDefenseData.Value.Damage; statuses = victimDefenseData.Value.Statuses; //If the Defensive action dealt damage and the contact was direct //the Defensive action has caused a Failure for the Attacker (Ex. Superguarding) if ((contactType == ContactTypes.TopDirect || contactType == ContactTypes.SideDirect) && victimDefenseData.Value.ElementHolder.HasValue == true) { contactResult = ContactResult.Failure; } //Factor in the additional Guard defense for all DefensiveActions (for now, at least) damageDodgeDefense = victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DamageDodge); } //Subtract Defense on non-piercing damage if (piercing == false) { int totalDefense = victim.BattleStats.TotalDefense + damageDodgeDefense; unscaledVictimDamage -= totalDefense; } int scaledVictimDamage = unscaledVictimDamage; //Factor in Double Pain for the Victim scaledVictimDamage *= (1 + victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.DoublePain)); //Factor in Last Stand for the Victim, if the Victim is in Danger or Peril if (victim.IsInDanger == true) { //PM rounds down, whereas TTYD rounds up. We're going with the latter //TTYD always ceilings the value (Ex. 3.2 turns to 4) int lastStandDivider = (1 + victim.GetEquippedBadgeCount(BadgeGlobals.BadgeTypes.LastStand)); scaledVictimDamage = (int)Math.Ceiling(scaledVictimDamage / (float)lastStandDivider); } /*If the Victim is Invincible, ignore all damage and Status Effects * If the Attacker is Invincible, ignore all Payback damage and Status Effects * * It won't ignore the Payback's effects automatically; that has to be done manually by adding * contact exceptions or something else*/ //Clamp Victim damage scaledVictimDamage = UtilityGlobals.Clamp(scaledVictimDamage, BattleGlobals.MinDamage, BattleGlobals.MaxDamage); #region Victim Damage Dealt //Calculating damage dealt to the Victim if (contactResult == ContactResult.Success || contactResult == ContactResult.PartialSuccess) { //Get the Status Effects to inflict on the Victim StatusChanceHolder[] victimInflictedStatuses = GetFilteredInflictedStatuses(victim, statuses); //Check if the Victim is Invincible. If so, ignore all damage and Status Effects if (victim.EntityProperties.GetAdditionalProperty <bool>(AdditionalProperty.Invincible) == true) { scaledVictimDamage = 0; victimElementDamage.InteractionResult = ElementInteractionResult.Damage; victimInflictedStatuses = null; } finalInteractionResult.VictimResult = new InteractionHolder(victim, scaledVictimDamage, element, victimElementDamage.InteractionResult, contactType, piercing, victimInflictedStatuses, attackHit, DamageEffects.None); } #endregion #region Attacker Damage Dealt //Calculating damage dealt to the Attacker if (contactResult == ContactResult.Failure || contactResult == ContactResult.PartialSuccess) { //The damage the Attacker dealt to the Victim int damageDealt = unscaledVictimDamage; PaybackHolder paybackHolder = contactResultInfo.Paybackholder; //Override the PaybackHolder with a Defensive Action's results, if any if (victimDefenseData.HasValue == true && victimDefenseData.Value.ElementHolder.HasValue == true) { damageDealt = victimDefenseData.Value.ElementHolder.Value.Damage; paybackHolder = new PaybackHolder(PaybackTypes.Constant, victimDefenseData.Value.ElementHolder.Value.Element, damageDealt); } //Get the damage done to the Attacker, factoring in Weaknesses/Resistances ElementDamageResultHolder attackerElementDamage = GetElementalDamage(attacker, paybackHolder.Element, damageDealt); //Get Payback damage - Payback damage is calculated after everything else, including Constant Payback. //However, it does NOT factor in Double Pain or any sort of Defense modifiers. int paybackDamage = paybackHolder.GetPaybackDamage(attackerElementDamage.Damage); //If Constant Payback, update the damage value to use the element if (paybackHolder.PaybackType == PaybackTypes.Constant) { paybackDamage = GetElementalDamage(attacker, paybackHolder.Element, paybackDamage).Damage; } //Clamp Attacker damage attackerElementDamage.Damage = UtilityGlobals.Clamp(paybackDamage, BattleGlobals.MinDamage, BattleGlobals.MaxDamage); //Get the Status Effects to inflict StatusChanceHolder[] attackerInflictedStatuses = GetFilteredInflictedStatuses(attacker, paybackHolder.StatusesInflicted); //Check if the Attacker is Invincible. If so, ignore all damage and Status Effects if (attacker.EntityProperties.GetAdditionalProperty <bool>(AdditionalProperty.Invincible) == true) { attackerElementDamage.Damage = 0; attackerElementDamage.InteractionResult = ElementInteractionResult.Damage; attackerInflictedStatuses = null; } finalInteractionResult.AttackerResult = new InteractionHolder(attacker, attackerElementDamage.Damage, paybackHolder.Element, attackerElementDamage.InteractionResult, ContactTypes.None, true, attackerInflictedStatuses, true, DamageEffects.None); } #endregion return(finalInteractionResult); }
/// <summary> /// Get the file extensions associated with given ContactTypes. /// </summary> /// <param name="type">The ContactTypes to get the extensions for. /// This can be a bitwise combination of multiple ContactTypes.</param> /// <returns> /// Returns the file extensions associated with the given ContactType. /// If more than one type is contained in the parameter, the multiple /// extensions are returned in a string split by the pipe character ('|'). /// </returns> /// <exception cref="System.ArgumentException"> /// If the given type is ContactTypes.None or contains bits outside the valid /// range of ContactTypes.All. /// </exception> public static string GetExtensionsFromType(ContactTypes type) { return _GetExtensionsFromType(type, true); }
public IContact CreateContact(ISensor detectedBy, PointF position, double heading, double altitude, double speed, ContactTypes contactType, Action processContact = null) { Logger.Info($"{detectedBy} requesting to create a {contactType} contact at {position} traveling {heading}° at {speed} knts."); var newContact = (IContact)Activator.CreateInstance(typeof(Contact), new object[] { detectedBy, position }); newContact.Heading = heading; newContact.Altitude = altitude; newContact.Speed = speed; newContact.ContactType = contactType; newContact.CustomUpdateDuration = 2500; return(newContact); }
public static void SendSubmissionEmail(Contact contactEntity, ContactTypes contactFormType) { string toAddress = contactFormType == ContactTypes.ContactUs ? Settings.ContactSubmissionEmailAddress : contactFormType == ContactTypes.HomeValuationRequest ? Settings.HomeValuationEmailAddress : Settings.MaintenanceRequestEmailAddress; string templatePath = contactFormType == ContactTypes.ContactUs ? EmailTemplates.ContactSubmission : contactFormType == ContactTypes.HomeValuationRequest ? EmailTemplates.HomeValuation : EmailTemplates.MaintenanceRequest; string propertyInfo = string.Empty; string microsite = string.Empty; ShowcaseItem showcaseItem = null; if (contactEntity.ShowcaseItemID.HasValue) { showcaseItem = Classes.Showcase.ShowcaseItem.GetByID(contactEntity.ShowcaseItemID.Value, new string[] { "Agent", "Showcase.CMMicrosite", "Team", "Address" }); if (showcaseItem.AgentID.HasValue) { toAddress = showcaseItem.Agent.Email; } else if (showcaseItem.TeamID.HasValue) { toAddress = showcaseItem.Team.Email; } else { toAddress = Classes.Contacts.Settings.DefaultAgentContactEmail; } templatePath = EmailTemplates.PropertyInfoRequest; propertyInfo = showcaseItem.Address.FormattedAddress + (showcaseItem.MlsID.HasValue ? "<br />MLS ID #" + showcaseItem.MlsID : ""); microsite = showcaseItem.Showcase.CMMicrosite.Name.ToLower().Replace(" ", "-"); } else if (contactEntity.AgentID.HasValue) { Classes.Media352_MembershipProvider.User agent = Classes.Media352_MembershipProvider.User.GetByID(contactEntity.AgentID.Value, new[] { "UserOffice.Office" }); if (agent.UserOffice != null && agent.UserOffice.Any(o => o.Office != null && o.Office.Active)) { toAddress = agent.Email; } else { toAddress = Classes.Contacts.Settings.DefaultAgentContactEmail; } templatePath = EmailTemplates.ContactAgentSubmission; } else if (contactEntity.TeamID.HasValue) { Classes.Media352_MembershipProvider.Team team = Classes.Media352_MembershipProvider.Team.GetByID(contactEntity.TeamID.Value); toAddress = team.Email; templatePath = EmailTemplates.ContactAgentSubmission; } if (string.IsNullOrWhiteSpace(toAddress)) { return; } string contactMethodName = ContactMethod.GetByID(contactEntity.ContactMethodID).Name; MailMessage email = new MailMessage(); email.IsBodyHtml = true; email.From = new MailAddress(Globals.Settings.FromEmail); //TODO: Remove this when done testing. Put in place to prevent spamming of meybohm agents if (System.Web.HttpContext.Current.IsDebuggingEnabled && toAddress.ToLower().EndsWith("@meybohm.com")) { toAddress = "*****@*****.**"; } email.To.Add(toAddress); if (contactFormType == ContactTypes.PropertyInformation && toAddress != Settings.PropertyInfoCCEmailAddress) { email.CC.Add(Settings.PropertyInfoCCEmailAddress); } else if (contactFormType == ContactTypes.Agent && toAddress != Settings.AgentContactCCEmailAddress) { email.CC.Add(Settings.AgentContactCCEmailAddress); } Classes.StateAndCountry.Address addressEntity = null; if (contactEntity.AddressID.HasValue) { addressEntity = Classes.StateAndCountry.Address.GetByID(contactEntity.AddressID.Value, new string[] { "State" }); } email.Body = EmailTemplateService.HtmlMessageBody(templatePath, new { FirstName = contactEntity.FirstName, LastName = contactEntity.LastName, Address1 = (addressEntity != null ? addressEntity.Address1 : string.Empty), Address2 = (addressEntity != null ? addressEntity.Address2 : string.Empty), City = (addressEntity != null ? addressEntity.City : string.Empty), State = (addressEntity != null ? addressEntity.State.Name : string.Empty), Zip = (addressEntity != null ? addressEntity.Zip : string.Empty), Message = contactEntity.Message, ContactMethod = contactMethodName, Email = contactEntity.Email, PhoneOrEmail = (contactEntity.ContactMethodID == (int)ContactMethods.Email ?"": "Phone: " + contactEntity.Phone), ContactTime = ContactTime.GetByID(contactEntity.ContactTimeID).Name, PropertyInfo = propertyInfo, Microsite = microsite }); string subjectText = contactEntity.ShowcaseItemID.HasValue ? "Property Information Request" : contactFormType == ContactTypes.ContactUs ? "Contact Form Submission" : contactFormType == ContactTypes.HomeValuationRequest ? "Home Valuation Request" : contactFormType == ContactTypes.MaintenanceRequest ? "Maintenance Request" : "Contact Agent Submission"; if (showcaseItem != null) { if (showcaseItem.ShowcaseID == (int)MeybohmShowcases.AugustaRentalHomes || showcaseItem.ShowcaseID == (int)MeybohmShowcases.AikenRentalHomes) { subjectText += " - Lease"; } } email.Subject = Globals.Settings.SiteTitle + " - " + subjectText; // Apply MLS ID and address information to the subject line if this is a property information // request. if (showcaseItem != null && (showcaseItem.MlsID != null || showcaseItem.Address != null)) { string subjectDetails = "["; if (showcaseItem.MlsID != null) { subjectDetails += showcaseItem.MlsID; } if (showcaseItem.MlsID != null && showcaseItem.Address != null) { subjectDetails += " - "; } if (showcaseItem.Address != null) { subjectDetails += showcaseItem.Address.Address1; } subjectDetails += "] Property Information Request"; if (showcaseItem.ShowcaseID == (int)MeybohmShowcases.AugustaRentalHomes || showcaseItem.ShowcaseID == (int)MeybohmShowcases.AikenRentalHomes) { subjectDetails += " - Lease"; } email.Subject = subjectDetails; } SmtpClient smtp = new SmtpClient(); smtp.Send(email); }
private static bool _IsValidSingleContactType(ContactTypes type, bool isUnknownOK) { return type == ContactTypes.Contact || type == ContactTypes.Organization || type == ContactTypes.Group || (isUnknownOK ? (type == ContactTypes.None) : false); }
public static MailContact[] AddContactType(this IEnumerable <MailContact> contacts, ContactTypes type) { if (contacts == null || !contacts.Any()) { return(new MailContact[] { }); } var list = new List <MailContact>(); foreach (var contact in contacts) { contact.ContactType = type; list.Add(contact); } return(list.ToArray()); }
private static string _GetExtensionsFromType(ContactTypes type, bool allowMultiset) { // Verify that the type doesn't contain bits outside the valid range and it contains // at least one bit inside the valid range. if ((ContactTypes.None != (type & ~ContactTypes.All)) || (ContactTypes.None == (type & ContactTypes.All))) { throw new ArgumentException("The provided ContactType is not within the valid range.", "type"); } if (_typeMap.Count == 0) { _typeMap.Add(ContactTypes.Organization, ".organization"); _typeMap.Add(ContactTypes.Contact, ".contact"); _typeMap.Add(ContactTypes.Group, ".group"); } string ext; if (!_typeMap.TryGetValue(type, out ext) && allowMultiset) { ext = null; // Not a single value, check if we should try to compose a set. if ((type & ContactTypes.All) != 0) { var extBuilder = new StringBuilder(); foreach (ContactTypes key in _typeMap.Keys) { if ((type & key) != 0) { extBuilder.Append(_typeMap[key]).Append("|"); } } // If nothing is returned then it's bad args. if (0 != extBuilder.Length) { ext = extBuilder.ToString(0, extBuilder.Length - 1); } } } // Checked this above. The type should have yielded a result. Assert.Implies(allowMultiset, null != ext); return ext; }
public IEnumerable<KeyValuePair<string, IContactProperties>> GetPropertiesCollection(ContactTypes typeFilter) { if (typeFilter == ContactTypes.None) { // Not a valid filter. // Not appropriate to throw an exception but not going to yield any results. yield break; } // This will throw exceptions for invalid enumeration values. string[] extensions = Contact.GetExtensionsFromType(typeFilter).Split('|'); Assert.AreNotEqual(0, extensions.Length); foreach (string ext in extensions) { // Should be of the format ".extension". Need to change to "*.extension" for FindFile. Assert.AreEqual('.', ext[0]); string findExt = "*" + ext; // DirectoryInfo.GetDirectories/GetFiles doesn't work here. // For one, the recursive version of GetDirectories doesn't check for reparse points, // so it can end up in an infinite loop. // Secondly, GetFiles goes through and returns the full list, and since this enumerator // is likely to bail early that's unnecessarily expensive. // So instead this is done mostly manually, and FindFirstFile/FindNextFile are P/Invoked. foreach (FileInfo file in FileWalker.GetFiles(new DirectoryInfo(_manager.RootDirectory), findExt, _manager.UseSubfolders)) { string path = file.FullName; string normalizedPath = path.ToUpperInvariant(); // Try to find a cached copy of the properties. // If it's not available go to disk. IContactProperties properties; if (!_TryGetCachedFile(normalizedPath, out properties)) { DateTime lastModifiedUtc; if (_TryLoadPropertiesFromFile(path, out properties, out lastModifiedUtc)) { // If we got a contact from the file then store it so we don't have to // go to disk next time. _fileCache.Add(normalizedPath, new _CacheEntry(path, lastModifiedUtc, properties)); } } if (null != properties) { yield return new KeyValuePair<string, IContactProperties>(path, properties); } } } }
/// <summary> /// Create a new Contact associated with this manager. /// </summary> /// <param name="type">The type of contact to create. Must be a valid enumeration value.</param> /// <returns>Returns a new Contact associated with this manager.</returns> /// <remarks> /// This is similar to creating a contact with Contact's constructor, except that CommitChanges /// will work despite that there is no file initially backing the contact. After CommitChanges is /// called on the contact can later be loaded by Id with this manager.<para/> /// The contact is not considered to be part of this manager until it has been committed. /// </remarks> public Contact CreateContact(ContactTypes type) { return new Contact(this, type); }
/// <summary> /// Internal only constructor for ContactManager. /// </summary> /// <param name="manager">The associated ContactManager instance.</param> /// <param name="type">The type of the contact to create.</param> /// <remarks> /// This allows the contacts returned by IContactCollection to be managed by this class. /// The manager is associated with the contact, which allows for Save to be called without /// the contact being initially backed by a path. /// </remarks> internal Contact(ContactManager manager, ContactTypes type) { Verify.IsApartmentState(ApartmentState.STA, _exceptionStringBadThreadId); if (!_IsValidSingleContactType(type, false)) { throw new ArgumentException("The provided type must be of a legal single value (also not ContactTypes.None).", "type"); } _manager = manager; _contactProperties = new WriteableContactPropertiesAlias(); // The IContactProperties is disposable by this object. //_sharedProperties = false; // New contact, no file name associated with the Id. Id = ContactId.GetRuntimeId(ContactIds.Default.Value, null); // _path = null; _originalName = string.Empty; _type = type; // New contact, so no worries of conflicting changes on save. // _sourceHash = null; }
public Contact(ContactTypes type) : this((ContactManager)null, type) { }
/// <summary> /// Load a contact from a stream. /// </summary> /// <param name="stream">The stream with the Contact contents to load.</param> /// <param name="type"> /// The type of the contact to create. ContactTypes.None is valid for this constructor. /// </param> /// <remarks> /// This is the only Contact constructor where ContactTypes.None is a valid type parameter. /// </remarks> public Contact(Stream stream, ContactTypes type) { Verify.IsNotNull(stream, "stream"); Verify.IsApartmentState(ApartmentState.STA, _exceptionStringBadThreadId); if (!_IsValidSingleContactType(type, true)) { throw new ArgumentException("ContactType must be a valid single value for this constructor (ContactTypes.None is OK).", "type"); } _type = type; // // Default values are implicitly set by the runtime (CodeAnalysis tools flag unnecessary default initializations). // // Loading a contact from a stream, so there's no path and the user can't commit changes directly. // _sourceHash = null; // _path = null; // Shouldn't need this either (only used for Commit) // _originalName = null; stream.Position = 0; // No reason to assume that because we're being loaded from a stream that this // is going to be modified. Go ahead and delay building the DOM. // CONSDIER: Adding a flag indicating intention to write. _contactProperties = new ReadonlyContactProperties(stream); // The IContactProperties is disposable by this object. //_sharedProperties = false; Id = ContactId.GetRuntimeId(ContactIds.Default.Value, null); }
public ContactWatcherSingular(Dispatcher dispatcher, ContactLoader loader, string directory, ContactTypes type, ContactWatcherEventCallback callback) { Assert.IsNotNull(dispatcher); // It's expected that this is created on the same thread as the manager, // so don't need to go through the dispatcher for methods invoked in the constructor. Assert.IsTrue(dispatcher.CheckAccess()); Assert.IsNotNull(loader); Assert.IsFalse(string.IsNullOrEmpty(directory)); Assert.IsNotNull(callback); Assert.IsTrue(Enum.IsDefined(typeof(ContactTypes), type)); Assert.AreNotEqual(ContactTypes.All, type); Assert.AreNotEqual(ContactTypes.None, type); _dispatcher = dispatcher; _rootDirectory = directory; _loader = loader; _notify = callback; _findExtension = "*" + Contact.GetExtensionsFromType(type); // This is why creating this object is expensive: // In order to be able to give accurate change notifications we need to know all the contacts that are present at the beginning. _knownContacts = new Dictionary<string, ContactInfo>(); // _pushedFrames = 0; _frame = new DispatcherFrame { Continue = false }; // Create the timer, but only signal it if we're going to need to reprocess an update. _timer = new Timer(); _timer.Tick += delegate { if (!_stopProcessing) { // Not invoked by the FileSystemWatcher, so don't push a frame here. _dispatcher.Invoke(DispatcherPriority.Background, (ThreadStart)_ReprocessPendingUpdate); } }; _timer.Interval = TimeSpan.FromMilliseconds(_TimerMsDelay); _timer.IsEnabled = false; _PopulateKnownContacts(type); _fileWatch = new FileSystemWatcher(_rootDirectory, _findExtension) { IncludeSubdirectories = true, NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Attributes, }; // There's some extra indirection required here because the manager requires thread affinity. _fileWatch.Changed += FileSystemWatcher_OnChanged; _fileWatch.Created += FileSystemWatcher_OnCreated; _fileWatch.Deleted += FileSystemWatcher_OnDeleted; _fileWatch.Renamed += FileSystemWatcher_OnRenamed; _fileWatch.EnableRaisingEvents = true; }
/// <summary> /// Creates a Contact /// </summary> /// <param name="detectedBy"></param> /// <param name="position"></param> /// <param name="heading"></param> /// <param name="altitude"></param> /// <param name="speed"></param> /// <param name="contactType"></param> /// <param name="processContact"></param> /// <returns></returns> public Contact Create(ISensor detectedBy, PointF position, double heading, double altitude, double speed, ContactTypes contactType, Action processContact = null) { return(new Contact(detectedBy, position) { Heading = heading, Altitude = altitude, Speed = speed, ContactType = contactType }); }