public void Initialize()
{
_cognitiveArchitecture = new CognitiveArchitecture
{
KnowledgeAndBeliefs = { HasBelief = true, HasKnowledge = true },
MessageContent = { CanReceiveBeliefs = true, CanReceiveKnowledge = true },
InternalCharacteristics = { CanLearn = true, CanForget = true, CanInfluenceOrBeInfluence = true }
};
var modelEntity = new KnowledgeModelEntity {
On = true
};
_knowledgeModel = new KnowledgeModel(_agentId, modelEntity, _cognitiveArchitecture, Network,
RandomGenerator.RandomBinary);
_knowledge = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge1 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge2 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledge3 = new Knowledge(Network, MainOrganization.Models, "1", 1);
_taskBits.SetMandatory(new byte[] { 0 });
_taskBits.SetRequired(new byte[] { 0 });
_actorKnowledge0 = new ActorKnowledge(_agentId, _knowledge.EntityId, _knowledge0Bits, 0, -1);
_actorKnowledge1 = new ActorKnowledge(_agentId, _knowledge1.EntityId, _knowledge1Bits, 0, -1);
_actorKnowledge01 = new ActorKnowledge(_agentId, _knowledge2.EntityId, _knowledge01Bits, 0, -1);
_actorKnowledgeFloat = new ActorKnowledge(_agentId, _knowledge3.EntityId, _knowledgeFloatBits, 0, -1);
}
public MicroCourseModel GetMicroCourseInfo(int subjectId, int stageId)
{
using (var metadb = new ModMetaEntities()) {
MicroCourseModel micrcomodel = new MicroCourseModel();
tb_Code_ListTable2 subject = metadb.tb_Code_ListTable2.Where(w => w.ID == subjectId && w.Deleted == 0).FirstOrDefault();
micrcomodel.subjectID = subject.ID;
micrcomodel.subjectName = subject.CodeName;
micrcomodel.knowledgeList = new List <KnowledgeModel>();
List <tb_Code_Knowledge> knowlist = metadb.tb_Code_Knowledge.Where(w => w.SubjectID == subjectId && w.StageID == stageId && w.Deleted == 0 && w.ParentID == 0).OrderBy(o => o.Seq).ToList();
foreach (tb_Code_Knowledge konwledge in knowlist)
{
KnowledgeModel knowledgemodel = new KnowledgeModel();
knowledgemodel.ID = konwledge.ID;
knowledgemodel.stage = konwledge.StageID;
knowledgemodel.subject = konwledge.SubjectID;
knowledgemodel.CodeName = konwledge.CodeName;
knowledgemodel.Children = GetKnowlegeList(metadb, knowledgemodel.ID);
micrcomodel.knowledgeList.Add(knowledgemodel);
}
if (CacheHelper.Get("CataIds") == null)
{
List <tb_Code_Knowledge> listcatas = metadb.tb_Code_Knowledge.Where(w => w.Deleted == 0 && w.SubjectID == subjectId && w.StageID == stageId).OrderBy(o => o.Seq).ToList();
CacheHelper.Insert("CataIds", listcatas);
}
return(micrcomodel);
}
}
/// <summary>
/// Customize the models of the agent
/// After setting the Agent basics models
/// </summary>
public override void SetModels()
{
base.SetModels();
KnowledgeModel.AddKnowledge(((ExampleEnvironment)Environment).ExampleMainOrganization.Knowledge.EntityId,
KnowledgeLevel.Expert,
Cognitive.InternalCharacteristics);
}
public KnowledgeCsView(KnowledgeController controller,
KnowledgeModel model)
{
log.Debug(" cs observer ctor ... ");
this.controller = controller;
this.model = model;
}
/// <summary>
/// Customize the models of the agent
/// After setting the Agent basics models
/// </summary>
public override void SetModels()
{
base.SetModels();
foreach (var knowledgeId in Environment.MainOrganization.ArtifactNetwork.Knowledge.GetEntityIds())
{
KnowledgeModel.AddKnowledge(knowledgeId, MainOrganization.KnowledgeLevel,
Cognitive.InternalCharacteristics);
}
}
/// <summary>
/// Check Knowledge required against the worker expertise
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="knowledgeBit">KnowledgeBit index of the task that must be checked against worker Knowledge</param>
/// <param name="knowledgeModel"></param>
/// <param name="step"></param>
/// <returns>False if the agent is On and if the knowledgeBit is not known enough</returns>
/// <returns>True if the agent is not On or the knowledgeBit is known enough</returns>
public bool CheckKnowledge(IAgentId knowledgeId, byte knowledgeBit, KnowledgeModel knowledgeModel, ushort step)
{
if (knowledgeModel == null)
{
throw new ArgumentNullException(nameof(knowledgeModel));
}
return(!IsAgentOn() || knowledgeModel.KnowsEnough(knowledgeId, knowledgeBit, ThresholdForReacting, step));
}
public KnowledgeEditorViewModel(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
_saveCommand = new DelegateCommand <Window>(window => Accept(window), CanExecuteSaveCommand);
_loadCommand = new DelegateCommand(LoadData);
Knowledge = new KnowledgeModel();
}
/// <summary>
/// Customize the models of the agent
/// After setting the Agent basics models
/// </summary>
public override void SetModels()
{
base.SetModels();
foreach (var knowledgeId in Environment.MainOrganization.ArtifactNetwork.Knowledge.GetEntityIds())
{
KnowledgeModel.AddKnowledge(knowledgeId, KnowledgeLevel.FullKnowledge,
Cognitive.InternalCharacteristics);
BeliefsModel.AddBeliefFromKnowledgeId(knowledgeId, Cognitive.KnowledgeAndBeliefs.DefaultBeliefLevel);
}
}
public void Initialize()
{
_knowledge = new Knowledge(Network, MainOrganization.Models, "1", 1);
_knowledgeModel = new KnowledgeModel(Uid1, new KnowledgeModelEntity(), new CognitiveArchitecture(),
Network, RandomGenerator.RandomBinary)
{
On = true
};
_taskBits.SetMandatory(new byte[] { 0 });
_taskBits.SetRequired(new byte[] { 0 });
}
public KnowledgeTreeView(KnowledgeController controller,
KnowledgeModel model,
KnowledgeControl control)
{
log.Debug(" tree view ctor ... ");
this.controller = controller;
this.model = model;
this.control = control;
// TODO: disable all tabs initially
this.control.Enabled = false;
}
public async Task <bool> DeletedAsync(KnowledgeModel entity)
{
var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge);
var result = await collection.DeleteOneAsync(d => d.ID == entity.ID);
//check the document count
var docs = await collection.Find(new BsonDocument()).ToListAsync();
Console.WriteLine("document count: " + docs.Count);
return(result.DeletedCount == 1);
}
public ActionResult Index(KnowledgeModel model)
{
var degreeList = _bookService.GetDegreeList();
model.DegreeItemList = degreeList.ToSelectItems();
model.DegreeItemList.Insert(0, new SelectListItem()
{
Text = "请选择", Value = "0"
});
model.SubjectItemList.Insert(0, new SelectListItem()
{
Text = "请选择", Value = "0"
});
return(View(model));
}
public async Task <KnowledgeModel> SaveAsync(KnowledgeModel entity)
{
var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge);
await collection.InsertOneAsync(entity as KnowledgeModel);
Console.WriteLine("document added: " + entity.ToJson());
var filter = new BsonDocument();
Console.WriteLine("count:" + collection.CountDocuments(filter).ToString());
return(entity);
}
public async Task <KnowledgeModel> UpdateAsync(KnowledgeModel entity)
{
var collection = MongoClientManager.DataBase.GetCollection <KnowledgeModel>(CollectionNames.Knowledge);
await collection.ReplaceOneAsync(d => d.ID == entity.ID, entity);
Console.WriteLine("document updated: " + entity.ToJson());
var filter = new BsonDocument();
Console.WriteLine("count:" + collection.CountDocuments(filter).ToString());
return(entity);
}
/// <summary>
/// 递归目录节点
/// </summary>
/// <param name="db"></param>
/// <param name="parentId"></param>
/// <returns></returns>
private List <KnowledgeModel> GetKnowlegeList(ModMetaEntities db, int parentId)
{
List <KnowledgeModel> knowledgeList = new List <KnowledgeModel>();
List <tb_Code_Knowledge> tempkonwledgeList = db.tb_Code_Knowledge.Where(w => w.Deleted == 0 && w.ParentID == parentId).OrderBy(o => o.Seq).ToList();
foreach (tb_Code_Knowledge konwledge in tempkonwledgeList)
{
KnowledgeModel knowledgemodel = new KnowledgeModel();
knowledgemodel.ID = konwledge.ID;
knowledgemodel.stage = konwledge.StageID;
knowledgemodel.subject = konwledge.SubjectID;
knowledgemodel.CodeName = konwledge.CodeName;
knowledgemodel.Children = null;
knowledgeList.Add(knowledgemodel);
}
return(knowledgeList);
}
/// <summary>
/// Finalize all the agent's cognitive models
/// </summary>
protected override void FinalizeModels()
{
base.FinalizeModels();
if (KnowledgeModel.On)
{
KnowledgeModel.InitializeExpertise(Schedule.Step);
foreach (var knowledgeId in KnowledgeModel.Expertise.Select(x => x.Target))
{
BeliefsModel.AddBeliefFromKnowledgeId(knowledgeId);
}
}
if (BeliefsModel.On)
{
BeliefsModel.InitializeBeliefs();
}
}
private void AddKnowledge(KnowledgeModel data)
{
if (Developer != null)
{
if (Developer.KnowledgeBase == null)
{
Developer.KnowledgeBase = new ObservableCollection <KnowledgeModel>();
}
if (Developer.KnowledgeBase.Any(p => p.ID == data.ID) ||
Developer.KnowledgeBase.Any(p => p.Language == data.Language && p.Technology == data.Technology))
{
return;
}
Developer.KnowledgeBase.Add(data);
SeletedIndex = 0;
}
}
/// <summary>
/// Initialize all the agent's cognitive models
/// Should be called after SetTemplate and after having customized the cognitive parameters
/// </summary>
protected override void InitializeModels()
{
base.InitializeModels();
// Initialize agent models
KnowledgeModel = new KnowledgeModel(AgentId, Environment.MainOrganization.Models.Knowledge, Cognitive,
Environment.MainOrganization.ArtifactNetwork, Environment.MainOrganization.Models.Generator);
BeliefsModel = new BeliefsModel(AgentId, Environment.MainOrganization.Models.Beliefs, Cognitive,
Environment.MainOrganization.ArtifactNetwork, Environment.MainOrganization.Models.Generator);
LearningModel = new LearningModel(AgentId, Environment.MainOrganization.Models,
Environment.MainOrganization.ArtifactNetwork.Knowledge,
Environment.MainOrganization.ArtifactNetwork.ActorKnowledge, Cognitive,
Environment.MainOrganization.Models.Generator, Environment.RandomLevelValue);
ForgettingModel = new ForgettingModel(AgentId, Environment.MainOrganization.ArtifactNetwork.ActorKnowledge,
Cognitive, Environment.MainOrganization.Models, Environment.RandomLevelValue);
InfluenceModel = new InfluenceModel(Environment.MainOrganization.Models.Influence,
Cognitive, Environment.AgentNetwork, BeliefsModel, Environment.MainOrganization.Models.Generator);
TaskModel = new ActorTaskModel(AgentId, Cognitive, Environment.MainOrganization.ArtifactNetwork);
}
/// <summary>
/// Returns the KnowledgeSetModel that contains this KnowledgeModel
/// </summary>
/// <param name="knowledgeModel"></param>
/// <returns></returns>
public static KnowledgeSetModel GetKnowledgeSet(this KnowledgeModel knowledgeModel)
{
var sets = Game.instance?.model?.knowledgeSets;
if (sets is null || sets.Length == 0)
{
return(null);
}
foreach (var set in sets)
{
if (set.ContainsKnowledgeModel(knowledgeModel))
{
return(set);
}
}
return(null);
}
public void KnowsEnoughTest()
{
var knowledge4 = new Knowledge(Network, MainOrganization.Models, "1", 1);
var actorKnowledge =
new ActorKnowledge(_agentId, knowledge4.EntityId, KnowledgeLevel.BasicKnowledge, 0, -1);
// Non passing test
Assert.IsFalse(KnowledgeModel.KnowsEnough(actorKnowledge, 0, Threshold, 0));
// Passing tests
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, 0, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 0, Threshold, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge0, 1, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge1, 1, Threshold, 0));
Assert.IsFalse(KnowledgeModel.KnowsEnough(_actorKnowledge01, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledge01, 1, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 0, Threshold, 0));
Assert.IsTrue(KnowledgeModel.KnowsEnough(_actorKnowledgeFloat, 1, Threshold, 0));
}
/// <summary>
/// Returns whether or not this KnowledgeSetModel contains <paramref name="containsModel"/>
/// </summary>
/// <param name="set"></param>
/// <param name="containsModel"></param>
/// <returns></returns>
public static bool ContainsKnowledgeModel(this KnowledgeSetModel set, KnowledgeModel containsModel)
{
if (set.tiers == null)
{
return(false);
}
List <KnowledgeLevelModel> levels = new List <KnowledgeLevelModel>();
set.tiers.ForEach(tier => levels.AddRange(tier.levels));
if (levels.Count == 0)
{
return(false);
}
List <KnowledgeModel> knowledgeModels = new List <KnowledgeModel>();
levels.ForEach(level => knowledgeModels.AddRange(level.items));
return(knowledgeModels.Any(model => model.Equals(containsModel)));
}
/// <summary>
/// Check Knowledge required by a task against the worker expertise
/// </summary>
/// <param name="knowledgeId"></param>
/// <param name="taskBitIndexes">KnowledgeBits indexes of the task that must be checked against worker Knowledge</param>
/// <param name="knowledgeModel"></param>
/// <param name="mandatoryCheck"></param>
/// <param name="requiredCheck"></param>
/// <param name="mandatoryIndex"></param>
/// <param name="requiredIndex"></param>
/// <param name="step"></param>
public void CheckKnowledge(IAgentId knowledgeId, TaskKnowledgeBits taskBitIndexes,
KnowledgeModel knowledgeModel,
ref bool mandatoryCheck,
ref bool requiredCheck, ref byte mandatoryIndex, ref byte requiredIndex, ushort step)
{
if (taskBitIndexes is null)
{
throw new ArgumentNullException(nameof(taskBitIndexes));
}
if (knowledgeModel == null)
{
throw new ArgumentNullException(nameof(knowledgeModel));
}
// model is off
if (!IsAgentOn())
{
mandatoryCheck = true;
requiredCheck = true;
return;
}
// agent may don't have the knowledge at all
var actorKnowledge = knowledgeModel.GetActorKnowledge(knowledgeId);
if (actorKnowledge == null)
{
return;
}
mandatoryCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetMandatory(), out mandatoryIndex,
ThresholdForReacting, step);
requiredCheck = knowledgeModel.Check(actorKnowledge, taskBitIndexes.GetRequired(), out requiredIndex,
ThresholdForReacting, step);
}
public async Task <KnowledgeModel> UpdateAsync(KnowledgeModel entity)
{
return(await _repository.UpdateAsync(entity));
}
/// <summary>
/// Customize the models of the agent
/// After setting the Agent basics models
/// </summary>
public override void SetModels()
{
base.SetModels();
KnowledgeModel.AddKnowledge(MainOrganization.Knowledge.EntityId,
MainOrganization.KnowledgeLevel, Cognitive.InternalCharacteristics);
}
private void RemoveKnowledge(KnowledgeModel item)
{
Developer.KnowledgeBase.Remove(item);
}
public KnowledgeStore()
{
_model = new KnowledgeModel();
}
public async Task <bool> DeletedAsync(KnowledgeModel entity)
{
return(await _repository.DeletedAsync(entity));
}
