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);
}
