public static GameLevel_VictoryProto ToProto(byte[] buffer)
{
using (MMO_MemoryStream ms = new MMO_MemoryStream(buffer))
{
GameLevel_VictoryProto proto = new GameLevel_VictoryProto();
proto.GameLevelId = ms.ReadInt();
proto.Grade = (byte)ms.ReadByte();
proto.Star = (byte)ms.ReadByte();
proto.Exp = ms.ReadInt();
proto.Gold = ms.ReadInt();
proto.KillMonsterCount = ms.ReadInt();
for (int i = 0; i < proto.KillMonsterCount; i++)
{
MonsterItem monsterItem = new MonsterItem();
monsterItem.MonsterId = ms.ReadInt();
monsterItem.MonsterCount = ms.ReadInt();
proto.KillMonsterList.Add(monsterItem);
}
proto.ReceiveGoodsCount = ms.ReadInt();
for (int i = 0; i < proto.ReceiveGoodsCount; i++)
{
ReceiveGoodsItem goodsItem = new ReceiveGoodsItem();
goodsItem.GoodsType = (byte)ms.ReadByte();
goodsItem.GoodsId = ms.ReadInt();
goodsItem.GoodsCount = ms.ReadInt();
proto.ReceiveGoodsList.Add(goodsItem);
}
return(proto);
}
}
public static GameLevel_VictoryProto GetProto(byte[] buffer)
{
GameLevel_VictoryProto proto = new GameLevel_VictoryProto();
using (MMO_MemoryStream ms = new MMO_MemoryStream(buffer))
{
proto.GameLevelId = ms.ReadInt();
proto.Grade = (byte)ms.ReadByte();
proto.Star = (byte)ms.ReadByte();
proto.Exp = ms.ReadInt();
proto.Gold = ms.ReadInt();
proto.KillTotalMonsterCount = ms.ReadInt();
proto.KillMonsterList = new List <MonsterItem>();
for (int i = 0; i < proto.KillTotalMonsterCount; i++)
{
MonsterItem _KillMonster = new MonsterItem();
_KillMonster.MonsterId = ms.ReadInt();
_KillMonster.MonsterCount = ms.ReadInt();
proto.KillMonsterList.Add(_KillMonster);
}
proto.GoodsTotalCount = ms.ReadInt();
proto.GetGoodsList = new List <GoodsItem>();
for (int i = 0; i < proto.GoodsTotalCount; i++)
{
GoodsItem _GetGoods = new GoodsItem();
_GetGoods.GoodsType = (byte)ms.ReadByte();
_GetGoods.GoodsId = ms.ReadInt();
_GetGoods.GoodsCount = ms.ReadInt();
proto.GetGoodsList.Add(_GetGoods);
}
}
return(proto);
}
private void AddRoundRoleMonsterInfo(MonsterItem monsterItem)
{
if (m_NormalScene)
{
m_RoundRoleCreateInfo.Add(monsterItem);
}
}
public void GetData()
{
MonsterItemParent = Instantiate(MonsterItemParentPrefab, GetComponent <MainMenu>().MainMenuPanel.transform);
foreach (Monster temp in AllMonsters)
{
if (!MonsterList.Contains(temp.MonsterName))
{
MonsterList.Add(temp.MonsterName);
GameObject go = Instantiate(MonsterItemPrefab, MonsterItemParent.transform);
MonsterItem monsterItem = go.GetComponent <MonsterItem>();
monsterItem.MonsterSprite.sprite = temp.GetComponent <SpriteRenderer>().sprite;
monsterItem.anim.runtimeAnimatorController = temp.GetComponent <Animator>().runtimeAnimatorController;
monsterItem.MonsterName.text = temp.MonsterName;
monsterItem.MonsterHP.text = temp.HP.ToString();
monsterItem.MonsterATK.text = temp.Atk.ToString();
monsterItem.MonsterDEF.text = temp.Def.ToString();
monsterItem.MonsterGolds.text = temp.Golds.ToString();
monsterItem.MonsterEXP.text = temp.Exp.ToString();
int damageValue = temp.GetDemageValue(player.ATK, player.DEF);
if (damageValue < 0)
{
monsterItem.MonsterDemageValue.text = "不可敌";
}
else
{
monsterItem.MonsterDemageValue.text = damageValue.ToString();
}
}
}
}
public void CacheSpecialEnemy(int id)
{
EZ.Data.Monster monsterData = Global.gApp.gGameData.MosterData;
MonsterItem monsterItem = monsterData.Get(id);
Monster monster = m_PlayerMgr.CreateMonsterForceCreate(monsterItem);
monster.InitForCache(m_MainPlayer, null, monsterItem);
}
private Monster CreateMonster(MonsterItem monsterItem)
{
GameObject monster = Global.gApp.gResMgr.InstantiateObj(monsterItem.path);
Monster monsterComp = monster.GetComponent <Monster>();
monsterComp.transform.SetParent(Global.gApp.gRoleNode.transform);
return(monsterComp);
}
public void CacheMonster(MonsterItem monsterItem, int count)
{
for (int i = 0; i < count; i++)
{
Monster monsterNode = CreateMonster(monsterItem);
Recycle(monsterItem, monsterNode);
}
}
public Monster CreateMonsterForceCreate(MonsterItem monsterItem)
{
m_GuidRef++;
Monster monster = m_MonsterCache.GetMonsterForceCreate(monsterItem);
monster.SetGuid(m_GuidRef);
return(monster);
}
public static MonsterItem GetData(int templateID)
{
if (mInstance == null)
{
mInstance = new MonsterItem();
}
mInstance.templateID = templateID;
return mInstance;
}
/// <summary>
/// 获取指定类型成员坐标
/// </summary>
/// <param name="type"></param>
/// <param name="index"></param>
/// <returns></returns>
public Vector3 GetMemberPositon(MonsterType type, int index)
{
if (items.ContainsKey(type) && items[type].ContainsKey(index))
{
MonsterItem tt = items[type][index].GetComponent <MonsterItem>();
return(tt.pointText.transform.position);
}
return(Vector3.zero);
}
/// <summary>
/// 场景中加载怪物模型（单个添加）
/// </summary>
/// <returns>The load point.</returns>
/// <param name="info">Info.</param>
/// <param name="index">Index.</param>
/// <param name="callback">Callback.</param>
public void SceneLoadPoint(MonsterType type, MonsterInfo info, int index)
{
if (mapId == 0)
{
LogMgr.LogError("请先选择地图！");
return;
}
if (!parentObj.ContainsKey(type) || parentObj[type] == null)
{
GameObject p = (GameObject)UnityEngine.Object.Instantiate(CoreEntry.gResLoader.Load(_parentPrefab));
p.name = parentStr[type];
p.transform.position = Vector3.zero;
parentObj[type] = p;
}
MonsterItem tt = new MonsterItem();
if (!items.ContainsKey(type))
{
items[type] = new Dictionary <int, GameObject>();
}
if (items[type].ContainsKey(info.index))
{
tt = items[type][info.index].GetComponent <MonsterItem>();
tt.SetV(info);
}
else
{
GameObject obj = (GameObject)Instantiate(CoreEntry.gResLoader.Load(_itemPrefab));
obj.name = info.name.ToString();
tt = obj.GetComponent <MonsterItem>();
obj.transform.parent = parentObj[type].transform;
tt.RefreshData(info);
items[type][info.index] = obj;
}
// if (!items.ContainsKey(type))
// {
// items[type] = new List<GameObject>();
// }
//if (items[type].Count >= index + 1) {
// tt = items[type][index].GetComponent<MonsterItem>();
// tt.SetV(info[index]);
//} else {
// GameObject obj = (GameObject)UnityEngine.Object.Instantiate(Resources.Load(itemStrPath[type]));
// obj.name = index.ToString();
// tt = obj.GetComponent<MonsterItem>();
// obj.transform.parent = parentObj[type].transform;
// tt.RefreshData(info[index]);
// items[type].Add(obj);
//}
// tt.gameObject.name = item.Value[i].name;
// return info [index];
}
private void GenerateCreateInfo()
{
m_CreateInfo.Capacity = Mathf.Min(m_CreateInfo.Capacity, m_MonsterCount);
m_Monsters.Capacity = Mathf.Max(m_Monsters.Capacity, m_MonsterCount / 2);
EZ.Data.Monster monsterData = Global.gApp.gGameData.MosterData;
if (m_RandomType == RandomType.RandCreateInfo)
{
int countIndex = 0;
foreach (int enemyId in m_WaveData.enemyID)
{
int eId = enemyId;
if (DebugMgr.GetInstance().MonsterId > 0)
{
eId = DebugMgr.GetInstance().MonsterId;
}
MonsterItem monsterItem = monsterData.Get(eId);
if (monsterItem == null)
{
Debug.LogError("EnemyId " + eId + " does not exist!");
continue;
}
var count = Mathf.CeilToInt(m_WaveData.enemyNum[countIndex] * Game.PlayerDataMgr.singleton.StageWaveFactor);
for (int i = 0; i < count; i++)
{
m_CreateInfo.Add(monsterItem);
}
m_WaveMgr.CacheMonster(eId, count);
countIndex++;
}
}
else if (m_RandomType == RandomType.RandMonster)
{
int enemyIdCount = m_WaveData.enemyID.Length;
int enemyCount = Mathf.CeilToInt(m_WaveData.enemyNum[0] * Game.PlayerDataMgr.singleton.StageWaveFactor);
for (int i = 0; i < enemyCount; i++)
{
int enemyIndex = Random.Range(0, enemyIdCount);
int enemyId = m_WaveData.enemyID[enemyIndex];
if (DebugMgr.GetInstance().MonsterId > 0)
{
enemyId = DebugMgr.GetInstance().MonsterId;
}
MonsterItem monsterItem = monsterData.Get(enemyId);
if (monsterItem == null)
{
Debug.LogError("EnemyId " + enemyId + " does not exist!");
continue;
}
m_CreateInfo.Add(monsterItem);
m_WaveMgr.CacheMonster(enemyId, 1);
}
}
//CacheMonster();
}
public void Recycle(MonsterItem monsterItem, Monster monster)
{
List <Monster> monsters;
if (!m_MonsterCache.TryGetValue(monsterItem.tag, out monsters))
{
monsters = new List <Monster>();
m_MonsterCache[monsterItem.tag] = monsters;
}
monster.transform.position = new Vector3(1000, 0, 0);
monsters.Add(monster);
}
private bool CreateMonsterImp(MonsterItem monsterItem, GameObject bornNode, BornNodeType bornType)
{
if (bornType == BornNodeType.Scene)
{
return(CreateScenePointMonsterImp(monsterItem, bornNode));
}
else if (bornType == BornNodeType.Area)
{
return(CreateSceneAreatMonsterImp(monsterItem, bornNode));
}
return(false);
}
private void CacheMonster()
{
return;
EZ.Data.Monster monsterData = Global.gApp.gGameData.MosterData;
foreach (int enemyId in m_WaveData.enemyID)
{
MonsterItem monsterItem = monsterData.Get(enemyId);
Monster monster = m_WaveMgr.CreateMonster(monsterItem);
monster.InitForCache(m_MainPlayer, this, monsterItem);
}
}
private void CheckPassData()
{
PassItem[] items = Global.gApp.gGameData.PassData.items;
foreach (PassItem passItem in items)
{
foreach (int waveId in passItem.waveID)
{
WaveItem waveData = Global.gApp.gGameData.WaveData.Get(waveId);
if (waveData == null)
{
Debug.LogError("PassData " + passItem.id + " 的 " + "waveData " + waveId + "不存在 ");
continue;
}
EZ.Data.Monster monsterData = Global.gApp.gGameData.MosterData;
if (waveData.enemyNum.Length > 1)
{
if (waveData.enemyNum.Length != waveData.enemyID.Length)
{
Debug.LogError("waveData " + waveData.id + "配置错误 ememy count 不等于 ememyId count");
continue;
}
foreach (int enemyId in waveData.enemyID)
{
MonsterItem monsterItem = monsterData.Get(enemyId);
if (monsterItem == null)
{
Debug.LogError("waveData " + waveData.id + " EnemyId " + enemyId + " does not exist!");
continue;
}
}
}
else
{
if (waveData.enemyNum.Length == 0)
{
Debug.LogError("waveData " + waveData.id + "配置错误 ememy count 未配置");
continue;
}
}
int totalCount = 0;
foreach (int count in waveData.enemyNum)
{
totalCount += count;
}
if (totalCount == 0)
{
Debug.LogError("waveData " + waveData.id + " Enemy 数量为0 !");
}
}
}
Debug.Log("=============ok nor error===========");
}
private void CacheMonster()
{
EZ.Data.Monster monsterData = Global.gApp.gGameData.MosterData;
foreach (KeyValuePair <int, int> keyValuePair in m_InitCacheMonster)
{
MonsterItem monsterItem = monsterData.Get(keyValuePair.Key);
for (int i = 0; i < keyValuePair.Value; i++)
{
Monster monster = m_PlayerMgr.CreateMonsterForceCreate(monsterItem);
monster.InitForCache(m_MainPlayer, null, monsterItem);
}
}
m_InitCacheMonster.Clear();
m_InitCacheMonster = null;
}
public Monster CreateMonsterFromCacheInfo(MonsterItem monsterItem, bool forceCreate = false)
{
if (m_FrameCreateCount > 0)
{
Monster monster = CreateMonster(monsterItem, forceCreate);
if (monster != null)
{
m_FrameCreateCount--;
}
return(monster);
}
else
{
return(null);
}
}
public Monster CreateMonster(MonsterItem monsterItem, bool forceCreate = false)
{
if (CurCreateMonsterCount < MaxCreateCount || forceCreate)
{
CurCreateMonsterCount++;
if (monsterItem.tag != m_SpecialEnemyId)
{
m_StartCreateMonster = true;
}
return(m_PlayerMgr.CreateMonster(monsterItem));
}
else
{
return(null);
}
}
public Monster GetMonster(MonsterItem monsterItem)
{
List <Monster> monsters;
Monster monster;
if (m_MonsterCache.TryGetValue(monsterItem.tag, out monsters))
{
if (monsters.Count > 0)
{
monster = monsters[0];
monsters.RemoveAt(0);
return(monster);
}
}
monster = CreateMonster(monsterItem);
return(monster);
}
private bool CreateScenePointMonsterImp(MonsterItem monsterItem, GameObject bornNode)
{
Monster monster = m_WaveMgr.CreateMonster(monsterItem);
if (monster != null)
{
Vector3 position = bornNode.transform.position;
position.z = 0;
monster.transform.position = position;
m_Monsters.Add(monster);
monster.Init(m_MainPlayer, this, monsterItem);
return(true);
}
else
{
AddRoundRoleMonsterInfo(monsterItem);
return(false);
}
}
private void InitOnceInfo(GameObject player, EZ.Data.MonsterItem monsterItem)
{
if (m_PlayerGo != null)
{
return;
}
if (SkinePlayerAnim != null)
{
SkinePlayerAnim.Init();
}
m_OriLayer = gameObject.layer;
m_BodyNode = transform.Find(GameConstVal.BodyNode);
m_HpNode = transform.Find(GameConstVal.HpNode);
m_AiBase = GetComponents <AiBase>();
m_MonsterId = monsterItem.tag;
m_PlayerGo = player;
m_Player = player.GetComponent <Player>();
m_MonsterItem = monsterItem;
m_Rigidbody2D = GetComponent <Rigidbody2D>();
m_OriMass = m_Rigidbody2D.mass;
m_Collider2D = GetComponent <Collider2D>();
m_AiPauseAct = GetComponentInChildren <AIPauseAct>();
m_OriScale = transform.localScale;
m_OriSpeed = monsterItem.aniSpeed;
if (monsterItem.type == (int)MonsterType.Boss)
{
int skillLevel = Global.gApp.gSystemMgr.GetSkillMgr().GetSkillLevel(GameConstVal.SExBossHarm);
Skill_dataItem skillLevelData = Global.gApp.gGameData.SkillDataConfig.Get(skillLevel);
m_DamageParam = (skillLevelData == null) ? 1f : skillLevelData.skill_exbossharm[0];
m_DeadthBackAct = false;
}
if (monsterItem.type == (int)MonsterType.Normal)
{
m_IsNormalMonster = true;
}
else
{
m_IsNormalMonster = false;
}
}
public Dictionary <int, MonsterItem> ReadEnemy()
{
Dictionary <int, MonsterItem> monsterAttacks = new Dictionary <int, MonsterItem>();
string str = EnemyTextAsset.ToString();
string[] hangstr = str.Split('\n');
foreach (string hang in hangstr)
{
MonsterItem monsterAttack = new MonsterItem();
string[] liestr = hang.Split('\t');
monsterAttack.Id = int.Parse(liestr[0]);
monsterAttack.Name = liestr[1];
monsterAttack.timeBetweenAttacks = float.Parse(liestr[2]);
monsterAttack.attackDamage = int.Parse(liestr[3]);
monsterAttacks.Add(monsterAttack.Id, monsterAttack);
}
return(monsterAttacks);
}
public void SceneLoadPoint(Dictionary <MonsterType, Dictionary <int, MonsterInfo> > all)
{
foreach (var item in all)
{
if (!parentObj.ContainsKey(item.Key) || parentObj[item.Key] == null)
{
GameObject p = (GameObject)UnityEngine.Object.Instantiate(CoreEntry.gResLoader.Load(_parentPrefab));
p.name = parentStr[item.Key];
p.transform.position = Vector3.zero;
parentObj[item.Key] = p;
}
if (!items.ContainsKey(item.Key))
{
items[item.Key] = new Dictionary <int, GameObject>();
}
if (item.Value.Count > 0)
{
foreach (var _item in item.Value)
{
MonsterItem tt = new MonsterItem();
if (items[item.Key].ContainsKey(_item.Value.index))
{
tt = items[item.Key][_item.Value.index].GetComponent <MonsterItem>();
tt.RefreshData(_item.Value);
}
else
{
GameObject obj = (GameObject)UnityEngine.Object.Instantiate(CoreEntry.gResLoader.Load(_itemPrefab));
obj.name = _item.Value.name.ToString();
tt = obj.GetComponent <MonsterItem>();
obj.transform.parent = parentObj[item.Key].transform;
tt.RefreshData(_item.Value);
items[item.Key][_item.Value.index] = obj;
}
}
}
}
}
private bool CreateSceneAreatMonsterImp(MonsterItem monsterItem, GameObject bornNode)
{
Monster monster = m_WaveMgr.CreateMonster(monsterItem);
if (monster != null)
{
Vector3 localScale = bornNode.transform.localScale;
float x = Random.Range(-0.5f, 0.5f);
float y = Random.Range(-0.5f, 0.5f);
Vector3 posOffset = new Vector3(localScale.x * x, localScale.y * y, 0);
Vector3 position = bornNode.transform.position + posOffset;
position.z = 0;
monster.transform.position = position;
m_Monsters.Add(monster);
monster.Init(m_MainPlayer, this, monsterItem);
return(true);
}
else
{
AddRoundRoleMonsterInfo(monsterItem);
return(false);
}
}
//lockExterAdd = true lock push item to RoundRoleMonsterInfo and call CreateMonsterFromCacheInfo limit by frameCreate count
private bool CreateRoundMonsterImp(MonsterItem monsterItem, BornNode bornNode, bool lockExterAdd = false)
{
if (bornNode.GetIsOutMap())
{
Monster monster = null;
if (!lockExterAdd)
{
monster = m_WaveMgr.CreateMonster(monsterItem);
}
else
{
monster = m_WaveMgr.CreateMonsterFromCacheInfo(monsterItem);
}
if (monster != null)
{
Vector3 position = bornNode.transform.position;
position.z = 0;
monster.transform.position = position;
m_Monsters.Add(monster);
monster.Init(m_MainPlayer, this, monsterItem);
return(true);
}
else
{
if (!lockExterAdd)
{
AddRoundRoleMonsterInfo(monsterItem);
return(false);
}
}
}
else
{
int count = m_RoundRoleBornNodes.Length;
int symbol = Random.Range(0, 1000);
int bornIndex = Random.Range(0, count);
if (symbol > 500)
{
symbol = 1;
}
else
{
symbol = -1;
bornIndex += count;
}
for (int i = 0; i < count; i++)
{
int newIndex = bornIndex % count;
BornNode newNode = m_RoundRoleBornNodes[newIndex];
if (newNode.GetIsOutMap())
{
Monster monster = null;
if (!lockExterAdd)
{
monster = m_WaveMgr.CreateMonster(monsterItem);
}
else
{
monster = m_WaveMgr.CreateMonsterFromCacheInfo(monsterItem);
}
if (monster != null)
{
Vector3 position = newNode.transform.position;
position.z = 0;
monster.transform.position = position;
m_Monsters.Add(monster);
monster.Init(m_MainPlayer, this, monsterItem);
return(true);
}
else
{
if (!lockExterAdd)
{
AddRoundRoleMonsterInfo(monsterItem);
}
return(false);
}
}
bornIndex += symbol;
}
}
if (!lockExterAdd)
{
AddRoundRoleMonsterInfo(monsterItem);
}
return(false);
}
public Monster GetMonsterForceCreate(MonsterItem monsterItem)
{
return(CreateMonster(monsterItem));
}
//生成并保存XML文件
public void SaveMonsterXml(int mapW, int mapH, int mapSize)
{
if (parentObj == null)
{
LogMgr.LogError("场景中未载入怪物，请先添加或加载怪物");
return;
}
string filePath = Application.dataPath + @"/ResData/Data/MapData/" + @"" + mapId + ".xml";
if (!File.Exists(filePath))
{
XmlData xmldata1 = new XmlData();
xmldata1.CreateXml(filePath);
// LogMgr.LogError("文件不存在=" + filePath);
return;
}
XmlData xmldata = new XmlData();
filePath = @"Data/MapData/" + mapId;
//open的是resource资源
xmldata.OpenXmlInEditor(filePath);
//删除所有的节点
xmldata.RemoveAllChild();
// int serverIndex = 0;
//List<GameObject> _objs = new List<GameObject>();
XmlElement firstElm = xmldata.GetEmptyElement("First");
firstElm.SetAttribute("mapW", mapW.ToString());
firstElm.SetAttribute("mapH", mapH.ToString());
// firstElm.SetAttribute("tileSize", mapSize.ToString());
firstElm.SetAttribute("mapId", mapId.ToString());
foreach (KeyValuePair <MonsterType, Dictionary <int, GameObject> > tt in items)
{
XmlElement typeElm = xmldata.GetEmptyElement(tt.Key.ToString());
foreach (var item in tt.Value)
{
MonsterItem monster = item.Value.GetComponent <MonsterItem>();
XmlElement newElm = xmldata.GetEmptyElement("table");
newElm.SetAttribute("id", tt.Key == MonsterType.birth ? 1.ToString() : monster.info.id.ToString()); //出生点 无id
newElm.SetAttribute("index", monster.info.index.ToString());
newElm.SetAttribute("type", ((int)monster.info.enumType).ToString());
newElm.SetAttribute("wave_index", monster.info.wave_index.ToString());
newElm.SetAttribute("intervalTime", monster.info.interval_time.ToString());
newElm.SetAttribute("x", item.Value.transform.position.x.ToString());
newElm.SetAttribute("y", item.Value.transform.position.y.ToString());
newElm.SetAttribute("z", item.Value.transform.position.z.ToString());
double dir = (Math.PI * (item.Value.transform.eulerAngles.y)) / 180f; //传弧度
newElm.SetAttribute("dir", dir.ToString());
newElm.SetAttribute("modelId", monster.info.modelId.ToString());
if (tt.Key == MonsterType.point)
{
if (monster.info.pointRalations.Count > 0)
{
List <string> stringPointList = monster.info.pointRalations.ConvertAll <string>(x => x.ToString());
string points = string.Join(",", (string[])stringPointList.ToArray());
newElm.SetAttribute("pointRalations", points);
}
}
typeElm.AppendChild(newElm);
//LogMgr.LogError("坐标: (" + (int)item.Value.transform.position.x + "," + (int)item.Value.transform.position.z + ") 的角度: " + item.Value.transform.eulerAngles.y +
// " 弧度为: " + dir);
}
firstElm.AppendChild(typeElm);
}
//XmlElement typeElm2 = xmldata.GetEmptyElement(MonsterType.specail.ToString());
//firstElm.AppendChild(typeElm2);
xmldata.InsertElement(firstElm);
xmldata.SaveXml();
}
public override async Task <IEnumerable <Item> > GetFilteredItemsAsync(CancellationToken token = default)
{
var challengeComparer = new ChallengeComparer();
var type = Filters.SingleOrDefault(filter => filter.Key == FilterKeys.Type).SelectedKey ?? "";
var minChallenge = ChallengeConverter(Filters.SingleOrDefault(filter => filter.Key == FilterKeys.MinChallenge).SelectedKey) ?? "0 (0 PX)";
var maxChallenge = ChallengeConverter(Filters.SingleOrDefault(filter => filter.Key == FilterKeys.MaxChallenge).SelectedKey) ?? "30 (155000 PX)";
var size = Filters.SingleOrDefault(filter => filter.Key == FilterKeys.Size).SelectedKey ?? "";
var source = Filters.SingleOrDefault(filter => filter.Key == FilterKeys.Source).SelectedKey ?? "";
var terrain = Filters.SingleOrDefault(filter => filter.Key == FilterKeys.Terrain).SelectedKey ?? "";
token.ThrowIfCancellationRequested();
try
{
await StoreViewModel.SemaphoreLibrary.WaitAsync();
using (var context = await StoreViewModel.GetLibraryContextAsync())
{
//Expression<Func<MonsterItem, bool>> funcSize = m => true;
//if (!string.IsNullOrEmpty(size))
//{
// funcSize = m => m.Size == size;
//}
//Expression<Func<MonsterItem, bool>> funcFamily = m => Expression.Equal( m.Family, Expression.Constant(this.Family));
//var funcAll = Expression.AndAlso(funcSize.Body, funcFamily.Body);
//var lambdaAll = Expression.Lambda<Func<MonsterItem, bool>>(funcAll, funcSize.Parameters[0]);
//return context.Monsters.Where(lambdaAll).ToList();
return(context.Monsters.AsEnumerable().Where(monster =>
(string.IsNullOrEmpty(this.Family) || (monster.Family != null && monster.Family.ToLower().Equals(this.Family.ToLower()))) &&
(string.IsNullOrEmpty(size) || (monster.Size != null && monster.Size.ToLower().Equals(size.ToLower()))) &&
(string.IsNullOrEmpty(type) || (monster.Type != null && monster.Type.ToLower().Contains(type.ToLower()))) &&
(string.IsNullOrEmpty(terrain) || (monster.Terrain != null && monster.Terrain.ToLower().Contains(terrain.ToLower()))) &&
(
(string.IsNullOrEmpty(minChallenge) || monster.XP >= MonsterItem.ChallengeToXP(minChallenge)) &&
(string.IsNullOrEmpty(maxChallenge) || monster.XP <= MonsterItem.ChallengeToXP(maxChallenge))
) &&
(
monster.NormalizedName.ToLower().Contains(Helpers.RemoveDiacritics(SearchText ?? string.Empty).ToLower()) ||
monster.NormalizedAltName.ToLower().Contains(Helpers.RemoveDiacritics(SearchText ?? string.Empty).ToLower())
)
//MatchEquals(monster.Family, this.Family) &&
//MatchContains(monster.Type, type) &&
//MatchEquals(monster.Size, size) &&
//MatchContains(monster.Terrain, terrain) &&
//MatchRange(monster.Challenge, minChallenge, maxChallenge, challengeComparer) &&
//MatchSearch(monster)
).OrderBy(monster => monster.NormalizedName).ToList());
}
}
catch
{
return(new List <Item>());
}
finally
{
StoreViewModel.SemaphoreLibrary.Release();
}
}
public override void InitForCache(GameObject player, Wave wave, MonsterItem monsterItem)
{
base.InitForCache(player, wave, monsterItem);
CacheDeadthEffect(1);
}
public void Recycle(MonsterItem monsterItem, Monster monster)
{
m_MonsterCache.Recycle(monsterItem, monster);
}
