private void AddOutlines(GenericItem item, string allowedCatalogId, ICollection<Outline> outlines) { // Add physical outline if (IsAllowedCatalog(item.CatalogId, allowedCatalogId)) { var outline = CreateOutline(item.CatalogId); outline.Items.AddRange(item.Parents.Select(ConvertToOutlineItem)); outline.Items.Add(ConvertToOutlineItem(item)); outlines.Add(outline); } // Add virtual outlines for parent links var lastItem = ConvertToOutlineItem(item); var parents = new List<OutlineItem>(); foreach (var parent in item.Parents.Reverse()) { parents = parents.Select(Clone).ToList(); parents.Insert(0, ConvertToOutlineItem(parent, true)); AddOutlinesForLinks(parent.Links, parents, lastItem, allowedCatalogId, outlines); } // Add virtual outlines for item links lastItem = ConvertToOutlineItem(item, true); AddOutlinesForLinks(item.Links, null, lastItem, allowedCatalogId, outlines); }
public void TestItemRescorer() { Rescorer<Item> rescorer = NullRescorer<Item>.Instance; Assert.IsNotNull(rescorer); Item item = new GenericItem<String>("test"); Assert.AreEqual(1.0, rescorer.Rescore(item, 1.0)); Assert.AreEqual(1.0, rescorer.Rescore(null, 1.0)); Assert.AreEqual(0.0, rescorer.Rescore(item, 0.0)); Assert.IsTrue(Double.IsNaN(rescorer.Rescore(item, Double.NaN))); }
public void TestInferrer() { User user1 = GetUser("test1", 3.0, -2.0, 5.0); Item item = new GenericItem<String>("3"); List<User> ul = new List<User>(); ul.Add(user1); DataModel model = new GenericDataModel(ul); PreferenceInferrer inferrer = new AveragingPreferenceInferrer(model); double inferred = inferrer.InferPreference(user1, item); Assert.AreEqual(2.0, inferred); }
bool MatchesFilter(GenericItem item, string parent = "") { var builder = new StringBuilder(); if (parent.Length > 0) { builder.AppendFormat("{{{0}}}", parent); } builder.AppendFormat("{{{0}}}", item.Id); builder.AppendFormat("dlc{0}", item.Dlc); builder.AppendLine(); builder.Append(item.Name.Replace("\n", " ")); builder.Append(item.Description.Replace("\n", " ")); builder.Append(item.Knowledge.Replace("\n", " ")); return(MatchesFilter(builder.ToString())); }
public override HandlerRequest Handle(HandlerRequest handlerRequest) { String cleanLine = handlerRequest.Line.Replace("\n", ""); String[] typeSplit = cleanLine.Split('-'); if (typeSplit[0] != "GenericItem") { return(nextHandler?.Handle(handlerRequest)); } String[] values = typeSplit[1].Split(','); GenericItem genericItem = new GenericItem(values[0], Convert.ToInt32(values[1]), Convert.ToInt32(values[2]), Convert.ToInt32(values[3]), Convert.ToBoolean(values[4])); handlerRequest.ListOfCharacter[handlerRequest.ListOfCharacter.Count - 1].AddItem(genericItem); return(handlerRequest); }
public void ShowTooltip(GenericItem item, Vector3 position) { if (item != null) { itemNameText.text = item.Name; descText.text = item.Desc; slotText.text = item.equipmentType.ToString(); gameObject.SetActive(true); tooltip.transform.position = position; } else { Debug.Log("Nothing here, cap'n"); } }
public bool RemoveItem(GenericItem item) { for (int i = 0; i < equipmentSlots.Length; i++) { if (equipmentSlots[i].Item == item) { equipmentSlots[i].Item = null; equippedItems.Remove(item); pam.MeleeWeapon = null; pam.RangedWeapon = null; return(true); } } return(false); }
/// <summary> /// Checks if the given item is in the given side and position. /// </summary> /// <param name="side"></param> /// <param name="pos"></param> /// <param name="item"></param> /// <returns></returns> public bool isItemAccessible(BeltSide side, BeltPos pos, GenericItem item) { ItemController SLOT_ITEM = GetItem(side, pos); if (SLOT_ITEM == null) { return(false); } else if (SLOT_ITEM.INFO == item) { return(true); } else { return(false); } }
public virtual GenericItem RemoveItem(string itemID) { for (int i = 0; i < itemSlots.Length; i++) { GenericItem item = itemSlots[i].Item; if (item != null && item.ID == itemID) { itemSlots[i].Amount--; if (itemSlots[i].Amount == 0) { itemSlots[i].Item = null; } return(item); } } return(null); }
public void Equip(GenericItem item) { if (inventory.RemoveItem(item)) { GenericItem previousItem; if (equipmentPanel.AddItem(item, out previousItem)) { if (previousItem != null) { inventory.AddItem(previousItem); } } else { inventory.AddItem(item); } } }
private BaseItem GetTileForModule(Module m) { BaseItem tile = null; ModuleParameter widget = m.GetProperty("Widget.DisplayModule"); if (widget != null && !String.IsNullOrEmpty(widget.Value)) { switch (widget.Value) { case "homegenie/generic/sensor": case "homegenie/generic/temperature": tile = new SensorItem(); break; case "homegenie/generic/doorwindow": tile = new DoorWindowItem(); break; default: tile = new GenericItem(); break; } } else { switch (m.DeviceType) { case "Sensor": case "Temperature": tile = new SensorItem(); break; case "DoorWindow": tile = new DoorWindowItem(); break; default: tile = new GenericItem(); break; } } return(tile); }
/// <summary> /// Attempts to add an item to the inventory. /// Doesn't actually decrement, just checks if it is possible. /// </summary> /// <returns>True if possible, false if not.</returns> public bool AttemptAddItem(GenericItem ITEM, int COUNT) { //Iterate over all contained items for (int i = 0; i < contained_items.Length; i++) { //Check if its the item we want, and it has less than the max stack size. //If it is the max stack size we can ignore it and find other items. //Whenever we reach this if statement, we will always return and terminate this function call. if (contained_items[i] != null && contained_items[i] == ITEM && item_counts[i] < ITEM.STACK_SIZE) { // Increment the given index i by COUNT. // If the COUNT pushes the stack over max stack size, call AddItem again with the difference when we add as much as we can. // If adding the full count will not go over stack size, jsut add it. if (item_counts[i] + COUNT <= contained_items[i].STACK_SIZE) { return(true); } // If it will go over, add as much as we can then call this function again. else { //Get the difference that is going to be a new stack. int diff = item_counts[i] + COUNT - contained_items[i].STACK_SIZE; //There is some left over, try and add it. return(AttemptAddItem(contained_items[i], diff)); } } } //If we've reached this point, there are no copies of the item that aren't at max stack size. //Get all empty indexes. List <int> EMPTIES = GetAllEmptyIndexes(); //Check if the count of the empty indexes list multiplied the stack size of the item is greater or equal to the count. if (EMPTIES.Count * ITEM.STACK_SIZE >= COUNT) { return(true); } //If we reach this point, we can't fit all these items in. Return false. return(false); }
private IEnumerator SpawnEnemyRoutine(GenericItem portal, Enemy enemy, Vector2 location) { yield return(new WaitForSeconds(0.875f)); GenericItem silhouette = this.silhouettes.Pop(location); // TODO: set same scale as enemy? silhouette.instance.GetComponent <SpriteRenderer>().sprite = enemy.silhouette; yield return(new WaitForSeconds(0.5f)); portal.Return(); silhouette.Return(); EnemyPoolItem item = enemy.pool.Pop(location); DamageTaker taker = item.instance.GetComponent <DamageTaker>(); item.instance.GetComponent <EnemyTracker>().difficulty = enemy.difficulty; item.instance.GetComponent <EnemyTracker>().parent = this; taker.OnDie.AddListener(this.OnEnemyDie); }
/// <summary> /// Returns if the item is contained within this belt. /// </summary> /// <param name="item"></param> /// <returns></returns> public bool ContainsItem(GenericItem item) { foreach (ItemController EC in LEFT_BELT) { if (EC.INFO == item) { return(true); } } foreach (ItemController EC in RIGHT_BELT) { if (EC.INFO == item) { return(true); } } return(false); }
public virtual bool RemoveItem(GenericItem item) { for (int i = 0; i < itemSlots.Length; i++) { if (itemSlots[i].Item == item) { itemSlots[i].Amount--; genericItems.Remove(item); if (itemSlots[i].Amount == 0) { itemSlots[i].Item = null; genericItems.Remove(item); } return(true); } } return(false); }
public static DataResult SaveItem(string collection, GenericItem item) { try { var json = JsonConvert.SerializeObject(item.DynamicProperties); var filePath = HostingEnvironment.MapPath($"~/App_Data/{collection}/{item.id}.json"); if (File.Exists(filePath)) { File.Delete(filePath); } File.WriteAllText(filePath, json); return(DataResult.Successul); } catch (Exception ex) { return(DataResult.Fail(ex)); } }
public void ExcecuteTest() { Elf character = new Elf("TestCharacter", 50, 10, 40); Wizard Secondcharacter = new Wizard("TestCharacter", 50, 10, 40); GenericItem item = new GenericItem("TestItem", 10, 10, 0, false); character.AddItem(item); List <Item> listOfItem = new List <Item>(); listOfItem.Add(item); List <Character> listOfCharacter = new List <Character>(); listOfCharacter.Add(character); listOfCharacter.Add(Secondcharacter); ExchangeEncounter exchangeEncounter = new ExchangeEncounter(listOfCharacter, listOfItem); exchangeEncounter.Excecute(); Assert.AreEqual(character.GetItems().Count, 0); Assert.AreEqual(Secondcharacter.GetItems()[0], item); }
/// <summary> /// Method that loads a random item /// </summary> private void loadItem() { bool assigned = false; for (int i = 0; i < database.itemDatabase.itemList.Count && !assigned; i++) { if (management.randomBoolean(0.8f)) { itemDrop = database.itemDatabase.itemList[i]; assigned = true; } if (i == database.itemDatabase.itemList.Count - 1) { i = 0; } } goldDrop = Random.Range(1, 50); }
public async Task <bool> SendItemAddedOrUpdated( User user, GenericItem item, string listSyncId, ShoppingListPermissionType permission) { try { string userJson = JsonConvert.SerializeObject(user.WithoutPassword()); string itemJson = JsonConvert.SerializeObject(item); List <string> users = GetUsersWithPermissionsFiltered(user, listSyncId, permission); await _hubContext.Clients.Users(users).SendAsync("ItemAddedOrUpdated", userJson, listSyncId, itemJson); return(true); } catch (Exception ex) { Console.Error.WriteLine("SendItemAddedOrUpdated {0}", ex); return(false); } }
private GenericItem GetCategoryItem(string categoryId, bool convertParents) { var category = GetCategory(categoryId); var result = new GenericItem { Id = category.Id, SeoObjectType = category.SeoObjectType, CatalogId = category.CatalogId, Links = category.Links, }; if (convertParents) { result.Parents = category.Parents .Select(c => ConvertToGenericItem(c, false)) .ToList(); } return(result); }
/// <summary> /// Handles getting input from inventory. /// </summary> /// <param name="IN_INV"></param> public void InputFromInventory(IInventory IN_INV) { //Find the item we would extract if it is possible. GenericItem EXTRACT_CANDIDATE = IN_INV.AttemptExtractItem(); Debug.Log(EXTRACT_CANDIDATE); //If we have a candidate, try to add it. if (EXTRACT_CANDIDATE != null) { //Attempt to add item. int remainder = INV.AddSingleItem(EXTRACT_CANDIDATE); //If remainder is 0, it succeeded. Actually decrement target inventory now. if (remainder == 0) { IN_INV.ExtractSingleItem(EXTRACT_CANDIDATE); } } EXTRACT_TIMER = (1 / EXTRACT_SPEED) / 2; }
public void TestSimple() { Item item1 = new GenericItem <String>("1"); Item item2 = new GenericItem <String>("2"); Item item3 = new GenericItem <String>("3"); Item item4 = new GenericItem <String>("4"); List <GenericItemCorrelation.ItemItemCorrelation> correlations = new List <GenericItemCorrelation.ItemItemCorrelation>(4); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item2, 0.5)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item1, 0.6)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item1, 0.5)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item3, 0.3)); GenericItemCorrelation itemCorrelation = new GenericItemCorrelation(correlations); Assert.AreEqual(1.0, itemCorrelation.GetItemCorrelation(item1, item1)); Assert.AreEqual(0.6, itemCorrelation.GetItemCorrelation(item1, item2)); Assert.AreEqual(0.6, itemCorrelation.GetItemCorrelation(item2, item1)); Assert.AreEqual(0.3, itemCorrelation.GetItemCorrelation(item1, item3)); Assert.IsTrue(Double.IsNaN(itemCorrelation.GetItemCorrelation(item3, item4))); }
protected void FilterCommand(GridViewCommandEventArgs e) { GridViewRow row = (e.CommandSource as Control).Parent.Parent as GridViewRow; string filterExpression = string.Empty; foreach (TemplateField tf in gvManager.Columns) { GenericItem item = tf.HeaderTemplate as GenericItem; if (item == null) { continue; } foreach (DictionaryEntry de in item.ExtractValues(row)) { string key = "[" + de.Key + "]"; string value; if (de.Value == DBNull.Value) { value = " IS NULL"; } else if (de.Value.GetType() == typeof(string)) { value = " LIKE '%" + de.Value.ToString() + "%' "; } else if (de.Value.GetType() == typeof(DateTime)) { value = "='" + de.Value.ToString() + "'"; } else { value = "=" + de.Value.ToString(); } filterExpression += " AND " + key + value; } } filterExpression = GridviewHelper.getFilter(filterExpression); ViewState[this.ClientID + "FilterExpression"] = filterExpression; }
/// <summary> /// Extracts item with given inserter. /// Only decrements this inventory, does not add to the inserter's inventory. /// Returns the item if successful, else null; /// </summary> /// <param name="item"></param> /// <param name="inserter"></param> /// <returns></returns> public GenericItem ExtractItem(GenericItem item, Extractor inserter) { //Side the inserter is using InsertSide insert_side = inserter.OUTPUT_SIDE; InsertDir insert_dir = GetInsertDir(inserter.GetComponent <GridController>()); BeltSide side = GetBeltSide(insert_dir, insert_side); BeltPos pos = GetBeltPos(insert_dir, insert_side); //Get the relevant list. List <ItemController> LIST = GetSideList(side); //Get the relevant index. int index = GetIndex(side, pos); //Save the item to be returned GenericItem item_ret = LIST[(int)pos].INFO; //Update side list. LIST[(int)pos].DespawnObject(); LIST[(int)pos] = null; return(item_ret); }
public void Craft(IItemContainer itemContainer) { if (CanCraft(itemContainer)) { foreach (ItemAmount itemAmount in Materials) { for (int i = 0; i < itemAmount.Amount; i++) { GenericItem oldItem = itemContainer.RemoveItem(itemAmount.Item.ID); oldItem.Destroy(); } } foreach (ItemAmount itemAmount in Results) { for (int i = 0; i < itemAmount.Amount; i++) { itemContainer.AddItem(itemAmount.Item.GetCopy()); FindObjectOfType <AudioManager>().Play("Craft"); //CRAFTING ITEM SOUND } } } }
public List <GenericItem> GetItemAll() { StringBuilder oSQL = new StringBuilder(); oSQL.Append("SELECT ItemCode, ItemName FROM OITM T0 "); DbCommand dbCommand = this.dataBase.GetSqlStringCommand(oSQL.ToString()); List <GenericItem> items = new List <GenericItem>(); using (this.reader = this.dataBase.ExecuteReader(dbCommand)) { while (this.reader.Read()) { GenericItem item = new GenericItem(); item.ItemCode = this.reader.IsDBNull(0) ? "" : this.reader.GetValue(0).ToString(); item.ItemName = this.reader.IsDBNull(1) ? "" : this.reader.GetValue(1).ToString(); items.Add(item); } } return(items); }
/// <summary> /// This second AddItem method is for adding an item to a specific slot, /// called by player when clicking on the UI. /// Returns remainder of items that couldn't be placed. /// 0 is returned if everything is placed. /// </summary> /// <param name="item_index"></param> /// <param name="count"></param> /// <param name="ITEM"></param> /// <returns></returns> public int AddItem(int item_index, int count, GenericItem ITEM) { // If the item slot is empty, just set that slot to that item. if (contained_items[item_index] == null) { contained_items[item_index] = ITEM; //IF the count of the item is greater than the max stack size, we need to only put enough to go here. if (count <= ITEM.STACK_SIZE) { item_counts[item_index] = count; return(0); } else //Since the count is greater than stack size, just place a full stack and return remainder. { item_counts[item_index] = ITEM.STACK_SIZE; return(count - ITEM.STACK_SIZE); } } //If the item slot is not empty, only do something if it's the same item. else if (contained_items[item_index] == ITEM) { //If the number we're trying to put in plus the stack we're interacting with is less than or equal to the max stack size, just put it in. if (count + item_counts[item_index] <= ITEM.STACK_SIZE) { item_counts[item_index] += count; return(0); } else //Since the count plus the current stack is greater than max stack size, place as much as we can and return remainder. { item_counts[item_index] = ITEM.STACK_SIZE; return(count - ITEM.STACK_SIZE); } } //If we reach this point, we couldn't add any in because we clicked on slot with an item not the same as ours. return(count); }
private void Update() { if (isInRange && !isEmpty && InputManager.Interact()) { GenericItem itemCopy = item.GetCopy(); //Item tooltip isn't appearing if (inventory.AddItem(itemCopy)) { FindObjectOfType <AudioManager>().Play("ItemPickup"); amount--; if (amount == 0) { isEmpty = true; spriteRenderer.enabled = false; chestRenderer.sprite = open; FindObjectOfType <AudioManager>().Play("ChestOpen"); } } else { itemCopy.Destroy(); } } }
/** * {@inheritDoc} */ public double Evaluate(RecommenderBuilder recommenderBuilder, DataModel dataModel, double trainingPercentage, double evaluationPercentage) { if (recommenderBuilder == null) { throw new ArgumentNullException("recommenderBuilder is null"); } if (dataModel == null) { throw new ArgumentNullException("dataModel is null"); } if (double.IsNaN(trainingPercentage) || trainingPercentage <= 0.0 || trainingPercentage >= 1.0) { throw new ArgumentException("Invalid trainingPercentage: " + trainingPercentage); } if (double.IsNaN(evaluationPercentage) || evaluationPercentage <= 0.0 || evaluationPercentage > 1.0) { throw new ArgumentException("Invalid evaluationPercentage: " + evaluationPercentage); } log.Info("Beginning evaluation using " + trainingPercentage + " of " + dataModel); int numUsers = dataModel.GetNumUsers(); ICollection<User> trainingUsers = new List<User>(1 + (int) (trainingPercentage * (double) numUsers)); IDictionary<User, ICollection<Preference>> testUserPrefs = new Dictionary<User, ICollection<Preference>>(1 + (int) ((1.0 - trainingPercentage) * (double) numUsers)); foreach (User user in dataModel.GetUsers()) { if (random.NextDouble() < evaluationPercentage) { ICollection<Preference> trainingPrefs = new List<Preference>(); ICollection<Preference> testPrefs = new List<Preference>(); Preference[] prefs = user.GetPreferencesAsArray(); foreach (Preference pref in prefs) { Item itemCopy = new GenericItem<String>(pref.Item.ID.ToString()); Preference newPref = new GenericPreference(null, itemCopy, pref.Value); if (random.NextDouble() < trainingPercentage) { trainingPrefs.Add(newPref); } else { testPrefs.Add(newPref); } } if (log.IsDebugEnabled) { log.Debug("Training against " + trainingPrefs.Count + " preferences"); log.Debug("Evaluating accuracy of " + testPrefs.Count + " preferences"); } if (trainingPrefs.Count > 0) { User trainingUser = new GenericUser<String>(user.ID.ToString(), trainingPrefs); trainingUsers.Add(trainingUser); if (testPrefs.Count > 0) { testUserPrefs.Add(trainingUser, testPrefs); } } } } DataModel trainingModel = new GenericDataModel(trainingUsers); Recommender recommender = recommenderBuilder.BuildRecommender(trainingModel); double result = GetEvaluation(testUserPrefs, recommender); log.Info("Evaluation result: " + result); return result; }
private static OutlineItem ConvertToOutlineItem(GenericItem item, bool hasVirtualParent) { return new OutlineItem { Id = item.Id, SeoObjectType = item.SeoObjectType, HasVirtualParent = hasVirtualParent, }; }
public InventoryItem(GenericItem item, int quantity) { this.itemReference = item; this.quantity = quantity; }
public List <List <GenericItem> > Generate(int CountofGeneration, double ProbabilityofCrosover = 0.8, double ProbabilityofMutation = 0.2, int Elitism = 1) { int CountofCrosover = (Data.Subjects.Count - Elitism) / 2; // CountofGeneration bool[] LocalFitness = new bool[5]; int RangeSum = 0; for (int i = 1; i <= CountofGeneration; i++) { RangeSum += i; } List <List <GenericItem> >[] list = new List <List <GenericItem> > [5]; // uznajemy 10 osobnikow na ktorych pracujemy , uznajemy narazie 6 lekcji w ciagu dnia Random rand = new Random(); for (int k = 0; k < 5; k++) { list[k] = new List <List <GenericItem> >(); for (int i = 0; i < CountofGeneration; i++) { var ChromosomList = new List <GenericItem>(); for (int j = 0; j < Data.Subjects.Count; j++) { var item = new GenericItem { Id = j, Subject = Data.Subjects[rand.Next(0, Data.Subjects.Count)], Time = Data.Times[rand.Next(0, Data.Times.Count)], Room = Data.Rooms[rand.Next(0, Data.Rooms.Count)] }; item.TeacherId = rand.Next(1, item.Subject.Teachers.Count + 1); ChromosomList.Add(item); } list[k].Add(ChromosomList); } ; } List <List <GenericItem> >[] generation = new List <List <GenericItem> > [5]; for (int i = 0; i < CountofGeneration; i++) { for (int k = 0; k < 5; k++) { generation[k] = new List <List <GenericItem> >(); var FitnessValue = Fitness(list[k], Schedules, k).ToArray(); // przystosowania var RangeArray = new int[FitnessValue.Length]; // tablica rang chromosomu o danym id - nr miejsca w tablicy var ProbabilityParent = new double[FitnessValue.Length]; // prawdopodobienstwo rodzica for (int j = 0; j < FitnessValue.Length; j++) { RangeArray[FitnessValue[j].ChromosomID] = j + 1; } for (int j = 0; j < FitnessValue.Length; j++) { ProbabilityParent[FitnessValue[j].ChromosomID] = ((-RangeArray[FitnessValue[j].ChromosomID] + CountofGeneration + 1) / (double)RangeSum); } var RandomArray = new double[FitnessValue.Length + 1]; RandomArray[0] = 0; // tablica sum czesciowych do losowania zostania rodzicem for (int j = 1; j <= FitnessValue.Length; j++) { RandomArray[j] = RandomArray[j - 1] + ProbabilityParent[j - 1]; } int[] tab = new int[Elitism]; for (int j = 0; j < Elitism; j++) { generation[k].Add(list[k][FitnessValue[j].ChromosomID]); if (FitnessValue[j].Fitness == 1) { LocalFitness[k] = true; } list[k][FitnessValue[j].ChromosomID] = null; } if (LocalFitness[k] == true) { continue; } int crossover = (CountofGeneration - Elitism) / 2; //krzyzowanie for (int j = 0; j < crossover; j++) { _ = new List <GenericItem>(); _ = new List <GenericItem>(); double propparent1 = rand.NextDouble(); double propparent2 = rand.NextDouble(); List <GenericItem> item = null; List <GenericItem> crossItem = null; for (int r = 1; r < RandomArray.Length; r++) { if (propparent1 > RandomArray[r - 1] && propparent1 < RandomArray[r]) { item = list[k][r - 1]; break; } } for (int r = 1; r < RandomArray.Length; r++) { if (propparent2 > RandomArray[r - 1] && propparent2 < RandomArray[r]) { crossItem = list[k][r - 1]; break; } } if (crossItem == item || crossItem == null || item == null) { continue; } var ChromosomTempList = new List <GenericItem>(); var ChromosomTempList1 = new List <GenericItem>(); if (rand.NextDouble() > ProbabilityofCrosover) { continue; } for (int gi = 0; gi < item.Count - 1; gi++) { for (int gl = 0; gl < item.Count - 1; gl++) { GenericItem temp = new GenericItem(); if (item[gl].Time.Start > item[gi].Time.Start) { temp = item[gl]; item[gl] = item[gi]; item[gi] = temp; } } } for (int gi = 0; gi < item.Count - 1; gi++) { for (int gl = 0; gl < item.Count - 1; gl++) { GenericItem temp = new GenericItem(); if (crossItem[gl].Time.Start > crossItem[gi].Time.Start) { temp = crossItem[gl]; crossItem[gl] = crossItem[gi]; crossItem[gi] = temp; } } } int howMany = rand.Next(0, Data.Subjects.Count); //krzyzowanie for (int l = 0; l < howMany; l++) { ChromosomTempList.Add(item[l]); ChromosomTempList1.Add(crossItem[l]); } for (int l = howMany; l < Data.Subjects.Count; l++) { ChromosomTempList.Add(crossItem[l]); ChromosomTempList1.Add(item[l]); } list[k][list[k].IndexOf(item)] = null; list[k][list[k].IndexOf(crossItem)] = null; generation[k].Add(ChromosomTempList); generation[k].Add(ChromosomTempList1); } for (int j = 0; j < list[k].Count; j++) { double mutation = rand.NextDouble(); if (mutation < ProbabilityofMutation && list[k][j] != null) { int typemutation = rand.Next(0, 3); int currentmutation = rand.Next(0, Data.Subjects.Count); switch (typemutation) { case 1: list[k][j][currentmutation].Room = Data.Rooms[rand.Next(0, Data.Rooms.Count)]; break; case 2: list[k][j][currentmutation].Subject = Data.Subjects[rand.Next(0, Data.Subjects.Count)]; break; case 3: list[k][j][currentmutation].TeacherId = rand.Next(0, list[k][j][currentmutation].Subject.Teachers.Count); break; } generation[k].Add(list[k][j]); } } for (int j = generation[k].Count; j < CountofGeneration; j++) { var ChromosomList = new List <GenericItem>(); for (int m = 0; m < Data.Subjects.Count; m++) { var item = new GenericItem { Id = m, Subject = Data.Subjects[rand.Next(0, Data.Subjects.Count)], Time = Data.Times[rand.Next(0, Data.Times.Count)], Room = Data.Rooms[rand.Next(0, Data.Rooms.Count)] }; item.TeacherId = rand.Next(1, item.Subject.Teachers.Count + 1); ChromosomList.Add(item); } generation[k].Add(ChromosomList); } } list = generation.Clone() as List <List <GenericItem> >[]; } for (int i = 0; i < 5; i++) { for (int j = 0; j < Data.Subjects.Count - 1; j++) { for (int k = 0; k < Data.Subjects.Count - 1; k++) { GenericItem temp = new GenericItem(); if (list[i][0][k].Time.Start > list[i][0][k + 1].Time.Start) { temp = list[i][0][k]; list[i][0][k] = list[i][0][k + 1]; list[i][0][k + 1] = temp; } } } } return(GetTeacherNames(new List <List <GenericItem> > { list[0][0], list[1][0], list[2][0], list[3][0], list[4][0] })); }
protected AGenericDocItem(AMemberItem parent, string name, XElement element) : base(parent, CleanName(name, GetGenericNames(element)), element) { Generics = GenericItem.GetFrom(this); }
private void ItemClicked(TableView sender, GenericItem itemListItem) { ItemSelected?.Invoke(itemListItem.item); }
/// <summary> /// Loads its abilities, and gets a random item drop /// </summary> private void firstEnable() { bool assigned = false; for (int i = 0; i < database.enemyDatabase.enemies.Count && !assigned; i++) { if (management.randomBoolean(0.8f) && !isBoss && !database.enemyDatabase.enemies[i].type.Equals("boss")) { enemyStats = new EnemyClass(database.enemyDatabase.enemies[i]); assignAbilities(); assigned = true; } else if (isBoss && database.enemyDatabase.enemies[i].type.Equals("boss")) { enemyStats = new EnemyClass(database.enemyDatabase.enemies[i]); assignAbilities(); assigned = true; } if (i == database.enemyDatabase.enemies.Count - 1) { i = 0; } } assigned = false; if (!isBoss) { hasDrop = management.randomBoolean(0.95f); //Poner un 0.95 } else { hasDrop = true; } if (hasDrop) { for (int i = 0; i < database.itemDatabase.itemList.Count && !assigned; i++) { if (management.randomBoolean(0.9f)) { itemDrop = database.itemDatabase.itemList[i]; database.itemDatabase.itemList.RemoveAt(i); assigned = true; } if (i == database.itemDatabase.itemList.Count - 1) { i = 0; } } } else { itemDrop = null; } switch (gameDataManager.lvl) { case 2: enemyStats.attack = enemyStats.attack * 1.25f; enemyStats.defense = enemyStats.defense * 1.25f; enemyStats.totalHealth = enemyStats.totalHealth * 1.25f; enemyStats.totalMana = enemyStats.totalMana * 1.25f; enemyStats.currentHealth = enemyStats.totalHealth; enemyStats.currentMana = enemyStats.totalMana; enemyStats.goldDrop = enemyStats.goldDrop * 1.25f; break; case 3: enemyStats.attack = enemyStats.attack * 1.75f; enemyStats.defense = enemyStats.defense * 1.75f; enemyStats.totalHealth = enemyStats.totalHealth * 1.75f; enemyStats.totalMana = enemyStats.totalMana * 1.75f; enemyStats.currentHealth = enemyStats.totalHealth; enemyStats.currentMana = enemyStats.totalMana; enemyStats.goldDrop = enemyStats.goldDrop * 1.75f; break; case 4: enemyStats.attack = enemyStats.attack * 2.5f; enemyStats.defense = enemyStats.defense * 2.5f; enemyStats.totalHealth = enemyStats.totalHealth * 2.5f; enemyStats.totalMana = enemyStats.totalMana * 2.5f; enemyStats.currentHealth = enemyStats.totalHealth; enemyStats.currentMana = enemyStats.totalMana; enemyStats.goldDrop = enemyStats.goldDrop * 2.5f; break; case 5: enemyStats.attack = enemyStats.attack * 3.5f; enemyStats.defense = enemyStats.defense * 3.5f; enemyStats.totalHealth = enemyStats.totalHealth * 3.5f; enemyStats.totalMana = enemyStats.totalMana * 3.5f; enemyStats.currentHealth = enemyStats.totalHealth; enemyStats.currentMana = enemyStats.totalMana; enemyStats.goldDrop = enemyStats.goldDrop * 3.5f; break; } //Debug.Log("Enemy: " + enemyStats.name + " + " + transform.name); //if (hasDrop) //{ // Debug.Log("Item: " + itemDrop.name); //} //for (int i = 0; i < abilities.Count; i++) //{ // Debug.Log(abilities[i].name); //} }
private GenericItem ConvertToGenericItem(IHasOutlines obj, bool convertParents = true) { GenericItem result = null; var category = obj as Category; if (category != null) { result = GetCategoryItem(category.Id, convertParents); } var product = obj as CatalogProduct; if (product != null) { result = new GenericItem { Id = product.Id, SeoObjectType = product.SeoObjectType, CatalogId = product.CatalogId, Parents = new List<GenericItem>(), Links = new List<CategoryLink>(product.Links), }; if (product.CategoryId != null) { var productCategory = GetCategoryItem(product.CategoryId, convertParents); result.Parents.AddRange(productCategory.Parents); result.Parents.Add(productCategory); } } return result; }
private GenericItem GetCategoryItem(string categoryId, bool convertParents) { var category = GetCategory(categoryId); var result = new GenericItem { Id = category.Id, SeoObjectType = category.SeoObjectType, CatalogId = category.CatalogId, Links = category.Links, }; if (convertParents) { result.Parents = category.Parents .Select(c => ConvertToGenericItem(c, false)) .ToList(); } return result; }
private static OutlineItem ConvertToOutlineItem(GenericItem item) { return ConvertToOutlineItem(item, false); }
public void TestRescorer() { List<User> users = new List<User>(3); users.Add(GetUser("test1", 0.1, 0.2)); users.Add(GetUser("test2", 0.2, 0.3, 0.3, 0.6)); users.Add(GetUser("test3", 0.4, 0.4, 0.5, 0.9)); DataModel dataModel = new GenericDataModel(users); Item item1 = new GenericItem<String>("0"); Item item2 = new GenericItem<String>("1"); Item item3 = new GenericItem<String>("2"); Item item4 = new GenericItem<String>("3"); ICollection<GenericItemCorrelation.ItemItemCorrelation> correlations = new List<GenericItemCorrelation.ItemItemCorrelation>(6); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item2, 1.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item3, 0.5)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item4, 0.2)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item3, 0.7)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item4, 0.5)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item3, item4, 0.9)); ItemCorrelation correlation = new GenericItemCorrelation(correlations); Recommender recommender = new GenericItemBasedRecommender(dataModel, correlation); IList<RecommendedItem> originalRecommended = recommender.Recommend("test1", 2); IList<RecommendedItem> rescoredRecommended = recommender.Recommend("test1", 2, new ReversingRescorer<Item>()); Assert.IsNotNull(originalRecommended); Assert.IsNotNull(rescoredRecommended); Assert.AreEqual(2, originalRecommended.Count); Assert.AreEqual(2, rescoredRecommended.Count); Assert.AreEqual(originalRecommended[0].Item, rescoredRecommended[1].Item); Assert.AreEqual(originalRecommended[1].Item, rescoredRecommended[0].Item); }
private static ItemBasedRecommender buildRecommender2() { List<User> users = new List<User>(4); users.Add(GetUser("test1", 0.1, 0.3, 0.9, 0.8)); users.Add(GetUser("test2", 0.2, 0.3, 0.3, 0.4)); users.Add(GetUser("test3", 0.4, 0.3, 0.5, 0.1, 0.1)); users.Add(GetUser("test4", 0.7, 0.3, 0.8, 0.5, 0.6)); DataModel dataModel = new GenericDataModel(users); ICollection<GenericItemCorrelation.ItemItemCorrelation> correlations = new List<GenericItemCorrelation.ItemItemCorrelation>(10); Item item1 = new GenericItem<String>("0"); Item item2 = new GenericItem<String>("1"); Item item3 = new GenericItem<String>("2"); Item item4 = new GenericItem<String>("3"); Item item5 = new GenericItem<String>("4"); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item2, 1.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item3, 0.8)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item4, -0.6)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item5, 1.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item3, 0.9)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item4, 0.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item2, item2, 1.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item3, item4, -0.1)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item3, item5, 0.1)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item4, item5, -0.5)); ItemCorrelation correlation = new GenericItemCorrelation(correlations); return new GenericItemBasedRecommender(dataModel, correlation); }
private static ItemBasedRecommender buildRecommender() { DataModel dataModel = new GenericDataModel(GetMockUsers()); ICollection<GenericItemCorrelation.ItemItemCorrelation> correlations = new List<GenericItemCorrelation.ItemItemCorrelation>(2); Item item1 = new GenericItem<String>("0"); Item item2 = new GenericItem<String>("1"); Item item3 = new GenericItem<String>("2"); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item2, 1.0)); correlations.Add(new GenericItemCorrelation.ItemItemCorrelation(item1, item3, 0.5)); ItemCorrelation correlation = new GenericItemCorrelation(correlations); return new GenericItemBasedRecommender(dataModel, correlation); }