public DicDefineOptForm()
{
InitializeComponent();
Init();
m_netTypeDefine = new ConstantDefine();
entityFiller.DisplayEntity(m_netTypeDefine);
}
private void btnDelete_Click(object sender, EventArgs e)
{
try
{
if (dgv.CurrentRow == null || dgv.CurrentRow.Index < 0)
{
FrmTips.ShowTipsError(AppHelper.MainForm, "未选中任何行！", ContentAlignment.MiddleCenter, 1000);
return;
}
ConstantDefine entity = CGridHelper.GetCurrentData <ConstantDefine>(dgv);
string sql = "DELETE ConstantDefine WHERE ID = @ID";
Hashtable hashtable = new Hashtable();
hashtable.Add("ID", entity.ID);
if (_mssqlHelper.ExcuteNonQuery(sql, hashtable) > 0)
{
FrmTips.ShowTipsSuccess(AppHelper.MainForm, "删除成功！", ContentAlignment.MiddleCenter, 1000);
CGridHelper.DeleteRow(dgv);
}
else
{
FrmTips.ShowTipsError(AppHelper.MainForm, "删除失败！", ContentAlignment.MiddleCenter, 1000);
}
}
catch (Exception ex)
{
FrmTips.ShowTipsError(AppHelper.MainForm, "删除异常！" + ex.Message, ContentAlignment.MiddleCenter, 3000);
}
}
private static Dictionary <string, int> GetSettings()
{
string address = GlobalConfig.RedisCacheAddress;
Dictionary <string, int> dic = new Dictionary <string, int>();
if (string.IsNullOrEmpty(address))
{
ConstantDefine.SetCacheUnUse();
return(dic);
}
var addressArray = address.Split(',');
foreach (var addressA in addressArray)
{
if (!string.IsNullOrEmpty(addressA))
{
var endponints = addressA.Split(':');
if (endponints.Length == 2)
{
dic.Add(endponints[0], Convert.ToInt32(endponints[1]));
}
else
{
dic.Add(endponints[0], 26379);
}
}
}
return(dic);
}
public Task <Tuple <bool, ConstantDefine, string> > SaveConstantDefine(ConstantDefine constantDefine)
{
return(Task.Run(() => {
var msg = "";
var succ = true;
var entity = chargeContext.constantDefines.AsNoTracking().Where(p => p.ID.Equals(constantDefine.ID)).FirstOrDefault();
if (entity != null)
{
chargeContext.constantDefines.Update(constantDefine);
}
else
{
var entity1 = chargeContext.constantDefines.AsNoTracking().Where(p => (p.ConstantName.Equals(constantDefine.ConstantName) ||
p.ConsatntCode.Equals(constantDefine.ConsatntCode)) && p.TypeCode.Equals(constantDefine.TypeCode)).FirstOrDefault();
if (entity1 == null)
{
chargeContext.constantDefines.Add(constantDefine);
}
else
{
succ = false;
msg = "常量名称/代号已存在";
}
}
chargeContext.SaveChanges();
return new Tuple <bool, ConstantDefine, string>(succ, constantDefine, msg);
}));
}
public bool Add <T>(string key, T value, DateTime expiresAt)
{
if (expiresAt <= DateTime.Now)
{
return(false);
}
if (value == null)
{
return(Remove(key));
}
try
{
var db = _redis.GetDatabase();
var json = JsonConvert.SerializeObject(value);
return(db.StringSet(key, json, expiresAt - DateTime.Now));
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(false);
}
public CollectionQuest(string name, string scene, string desc, byte diff, ConstantDefine.CollectionType type, byte number)
: base(name, scene, desc, diff)
{
m_type = ConstantDefine.QuestType.Collect;
m_targetType = type;
m_targetNumber = number;
m_completedNumber = 0;
}
/// <summary>
/// 为采集任务进行事件添加处理程序
/// </summary>
/// <param name="type">需要采集的物品类型（这里采集任务只采一种）</param>
/// <param name="handler"></param>
public void RegisterCollectionQuestEventHandler(ConstantDefine.CollectionType type, UnityAction handler)
{
if (!m_collectionHandlers.ContainsKey(type))
{
var collectEvent = new UnityEvent();
m_collectionHandlers.Add(type, collectEvent);
}
m_collectionHandlers[type].AddListener(handler);
}
public DicDefineOptForm(ConstantDefine netTypeDefine)
{
InitializeComponent();
Init();
m_netTypeDefine = netTypeDefine;
entityFiller.DisplayEntity(m_netTypeDefine);
combDefine.SelectedText = netTypeDefine.ConstantName;
combDefine.SelectedValue = netTypeDefine.TypeCode;
combDefine.Enabled = false;
}
public Task <ResponseModel> SaveConstantDefine(ConstantDefine constantDefine)
{
return(Task.Run(async() =>
{
ResponseModel response = new ResponseModel();
var type = await m_constantService.SaveConstantDefine(constantDefine);
response.Code = type.Item1 ? 1 : 0;
response.Message = type.Item3;
response.Data = type.Item2;
response.DataCount = 1;
return response;
}));
}
public void Dispose()
{
try
{
if (_redis != null)
{
_redis.Dispose();
}
}
catch
{
ConstantDefine.SetCacheUnUse();
}
}
public bool Remove(string key)
{
try
{
var db = _redis.GetDatabase();
return(db.KeyDelete(key));
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(false);
}
public List <string> GetAllItemsFromList(string key)
{
try
{
var db = _redis.GetDatabase();
return(db.ListRange(key).Select(n => n.ToString()).ToList());
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(new List <string>());
}
/// <summary>
/// 删除列表中的数据
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public int RemoveItemFromList(string key, string value)
{
try
{
var db = _redis.GetDatabase();
return(Convert.ToInt32(db.ListRemove(key, value)));
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(-1);
}
public void AddItemToList(string key, string value)
{
try
{
var db = _redis.GetDatabase();
var json = JsonConvert.SerializeObject(value);
db.StringSet(key, json);
db.ListRightPush(key, value);
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
}
/// <summary>
/// 创建Redis缓存
/// </summary>
/// <returns></returns>
public static ILogger CreateTpoLog()
{
try
{
if (ConstantDefine.NotUserLog)
{
return(new NotImpLog());
}
return(new TpoLogger());
}
catch (Exception ex)
{
ConstantDefine.SetNotUserLog();
CreateLog4net().Error("rabbit错误", ex);
}
return(new NotImpLog());
}
public void RemoveItemFromList(string key, List <string> values)
{
try
{
var db = _redis.GetDatabase();
foreach (var value in values)
{
db.ListRemove(key, value);
}
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
}
public T Get <T>(string key)
{
try
{
var db = _redis.GetDatabase();
var value = db.StringGet(key);
if (value.HasValue)
{
return(JsonConvert.DeserializeObject <T>(value));
}
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(default(T));
}
/// <summary>
/// 使用此方法需要在连接中配置allowAdmin=true
/// </summary>
public void FlushAll()
{
try
{
var db = _redis.GetDatabase();
var endPoints = _redis.GetEndPoints();
foreach (var endPoint in endPoints)
{
var server = _redis.GetServer(endPoint);
server.FlushDatabase();
}
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
}
private void btnModify_Click(object sender, EventArgs e)
{
try
{
if (dgv.CurrentRow == null || dgv.CurrentRow.Index < 0)
{
FrmTips.ShowTipsError(AppHelper.MainForm, "未选中任何行！", ContentAlignment.MiddleCenter, 1000);
return;
}
ConstantDefine entity = CGridHelper.GetCurrentData <ConstantDefine>(dgv);
DicDefineOptForm form = new DicDefineOptForm(entity);
if (form.ShowDialog(this) == DialogResult.OK)
{
btnSearch_Click(null, null);
}
}
catch (Exception ex)
{
FrmTips.ShowTipsError(AppHelper.MainForm, "修改异常！" + ex.Message, ContentAlignment.MiddleCenter, 3000);
}
}
public IDictionary <string, Tvalue> GetAll <Tvalue>(IEnumerable <string> keys)
{
try
{
var db = _redis.GetDatabase();
var dic = new Dictionary <string, Tvalue>(keys.Count());
foreach (var key in keys)
{
var value = db.StringGet(key);
dic[key] = JsonConvert.DeserializeObject <Tvalue>(value);
}
return(dic);
}
catch
{
if (_redis != null && _redis.IsConnected)
{
_redis.Dispose();
}
ConstantDefine.SetCacheUnUse();
}
return(null);
}
/// <summary>
/// 创建Redis缓存
/// </summary>
/// <returns></returns>
public static ICache CreateRedisCache()
{
if (ConstantDefine.NotUserCache)
{
return(new NotImpCache());
}
try
{
if (_redis == null)
{
lock (locaRedis)
{
_redis = GetConnectString();
}
}
return(new RedisCache(_redis, connectString));
}
catch
{
ConstantDefine.SetCacheUnUse();
return(new NotImpCache());
}
}
public Potion(ConstantDefine.CollectionType type)
: base(type)
{
bagType = ConstantDefine.BagItemType.Potion;
}
/// <summary>
/// 为讨伐任务进行事件添加处理程序
/// 例如某个任务杀3个史莱姆，那么每杀一个，就出发一次任务进行事件
/// </summary>
/// <param name="types">需要监听其死亡的敌人</param>
/// <param name="handler">事件处理器</param>
public void RegisterCrusadeQuestEventHandler(ConstantDefine.EnemyType[] types, UnityAction<byte, ConstantDefine.EnemyType> handler)
{
for (int i = 0; i < types.Length; i++)
{
if (!m_enemyDeathHandlers.ContainsKey(types[i]))
{
var proceedEvent = new MessageDefine.EnemyDeathEvent();
m_enemyDeathHandlers.Add(types[i], proceedEvent);
}
m_enemyDeathHandlers[types[i]].AddListener(handler);
}
}
public ResponseModel SaveConstantDefine(ConstantDefine constantDefine)
{
return(apiHelper.ReqPost("ConstantDefine/SaveConstantDefine", constantDefine));
}
public void RemoveCollectionQuestEventHandler(ConstantDefine.CollectionType type, UnityAction handler)
{
if (m_collectionHandlers.ContainsKey(type))
{
m_collectionHandlers[type].RemoveListener(handler);
}
}
/// <summary>
/// 监听任务所需击杀的敌人的死亡事件，注册在QuestManager
/// </summary>
protected void UpdateProgress(byte id, ConstantDefine.EnemyType type)
{
for (int i = 0; i < Targets.Count; i++)
{
if (Targets[i].targetType.Equals(type))
{
Targets[i].completedNumber++;
}
}
//检查是否完成
if (CheckCompletion())
{
OnCompleted();
}
}
public MinorHealthPotion(ConstantDefine.CollectionType type)
: base(type)
{
}
/// <summary>
/// 当任务完成时，不再监听
/// </summary>
/// <param name="types">需要监听其死亡的敌人</param>
/// <param name="handler">事件处理器</param>
public void RemoveCrusadeQuestEventHandler(ConstantDefine.EnemyType[] types, UnityAction<byte, ConstantDefine.EnemyType> handler)
{
for (int i = 0; i < types.Length; i++)
{
if (m_enemyDeathHandlers.ContainsKey(types[i]))
{
m_enemyDeathHandlers[types[i]].RemoveListener(handler);
}
}
}
/// <summary>
/// 当某个物品被采集，此函数触发，并将事件转发给任务
/// 每出生一个可采集物品，就注册该函数
/// </summary>
/// <param name="collectionType"></param>
public void ItemCollectedEventHandler(ConstantDefine.CollectionType collectionType)
{
if (m_collectionHandlers.ContainsKey(collectionType))
m_collectionHandlers[collectionType].Invoke();
}
/// <summary>
/// 当某个敌人死亡，此函数触发，并将事件转发给监听该敌人死亡的任务
/// 场景中每出生一个敌人，这个敌人就注册该函数为其死亡事件的监听器
/// </summary>
/// <param name="enemyId">场景中敌人ID</param>
/// <param name="enemyType">敌人类型</param>
public void EnemyDeathEventHandler(byte enemyId, ConstantDefine.EnemyType enemyType)
{
m_enemyDeathHandlers[enemyType].Invoke(enemyId, enemyType);
}
public Equipment(ConstantDefine.CollectionType type)
: base(type)
{
bagType = ConstantDefine.BagItemType.Equipment;
}
public BagItem(ConstantDefine.CollectionType type)
{
itemType = type;
itemInfo = CommonUtility.GetCollectableItemInfoFromXmlByType(type);
}
public Sundry(ConstantDefine.CollectionType type)
: base(type)
{
bagType = ConstantDefine.BagItemType.Sundry;
}
public static ViewableItemInfo GetViewableItemInfoFromXmlByType(ConstantDefine.UnCollectionType type)
{
ViewableItemInfo info;
string path = "/items/item[" + ((byte)type).ToString() + "]/";
XmlElement root = _GetXmlRootElement("item/viewable item");
info.name = root.SelectSingleNode(path + "name").InnerText;
info.info = root.SelectSingleNode(path + "info").InnerText;
return info;
}