using CommonAI.Zone;
using CommonAI.Zone.Helper;
using CommonAI.Zone.ZoneEditor;
using CommonAI.ZoneClient.Agent;
using CommonLang;
using CommonLang.Concurrent;
using CommonLang.Log;
using CommonLang.Property;
using CommonLang.Vector;
using pomelo.area;
using pomelo.chat;
using pomelo.connector;
using Pomelo.DotNetClient;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using XmdsBattleClient.Client;
using XmdsBattleClientBot.Bot;
using XmdsBattleClientBot.XmdsBot;
namespace XmdsBotTest.Runner
{
public class BotRunner : IDisposable
{
protected readonly ListLogger events;
protected readonly BotClient bot;
protected readonly AddBotConfig add;
protected readonly int index;
protected XmdsNetClient client
{
get { return bot.Client; }
}
protected readonly AtomicReference<string> status = new AtomicReference<string>("");
private HashMap<Type, RunnerModule> modules = new HashMap<Type, RunnerModule>();
public BotClient Bot { get { return bot; } }
public string RoleName { get { return bot.RoleName; } }
public string SceneName { get { return bot.SceneName; } }
public Pomelo.DotNetClient.NetWorkState NetState { get { return bot.NetState; } }
public string Status { get { return status.Value; } }
public BotRunner() {
}
public BotRunner(BotClient bot, int index, AddBotConfig add)
{
this.events = new ListLogger("event bot[" + bot.Account + "]");
this.add = add;
this.index = index;
this.bot = bot;
this.bot.event_OnStart += on_start;
this.bot.event_OnStop += on_stop;
this.bot.event_OnUpdate += on_update;
this.bot.event_OnBattleUpdate += on_bs_update;
this.bot.Client.GameSocket.IsSaveResponse = true;
this.bot.Client.OnBeginEnterScene += on_gs_begin_enter_scene;
this.bot.Client.OnBattlePlayerReady += on_bs_actor_ready;
this.bot.Client.GameSocket.NetWorkStateChangedEvent += GameSocket_NetWorkStateChangedEvent;
//this.bot.Client.LoginHandler.AddIpMapping(bot.Config.GetIpMapping());
foreach (var mt in RunnerModule.GetSubTypes())
{
RunnerModule _module = ReflectionUtil.CreateInstance(mt, this) as RunnerModule;
modules.Add(mt, _module);
}
}
public void Start()
{
bot.Start();
}
public void Stop()
{
bot.Stop();
}
public void Dispose()
{
bot.Dispose();
modules.Clear();
}
public override string ToString()
{
return bot.Account;
}
public void PopLogs(List<string> list)
{
events.PopLogs(list);
}
//--------------------------------------------------------------------------------------------------------
private void test_entry(EntryRequest request, Action<PomeloException, EntryResponse> cb, object option)
{
// var _socket = client.GateSocket;
// MemoryStream ms = new MemoryStream();
// _socket.Serializer.Serialize(ms, request);
// var req = new byte[ms.Length];
// Array.Copy(ms.GetBuffer(), req, ms.Length);
// var route = EventTypes.GetRequestKey(typeof(EntryRequest));
// _socket.onRequestStart(route, option);
// _socket.request_binary(route, req, (err, rsp) =>
// {
// MemoryStream rs = new MemoryStream(rsp);
// var rsp_type = EventTypes.GetResponseType(route);
// var response = _socket.Serializer.Deserialize(rs, null, rsp_type);
// _socket.onRequestEnd(route, err, response, option);
// cb(err, response as EntryResponse);
// });
}
private void GameSocket_NetWorkStateChangedEvent(NetWorkState obj)
{
//if (obj == NetWorkState.DISCONNECTED)
//{
// new Thread(() =>
// {
// Thread.Sleep(5000);
// events.Info("waiting 5 sec reconnect...");
// //if (!bot.Client.GameSocket.IsConnected)
// {
// reconnect();
// }
// }).Start();
//}
}
public void reconnect()
{
new Thread(() =>
{
bot.QueueTask(() =>
{
bot.Stop();
});
int wait = bot.Random.Next(100, 3000);
events.Info("waiting " + wait + "ms...");
Thread.Sleep(wait);
bot.QueueTask(() =>
{
bot.connect(()=> {
on_start(bot);
});
});
}).Start();
}
public void connect()
{
if (bot.NetState != NetWorkState.CONNECTED) {
status.Value = "重连中....";
new Thread(() =>
{
bot.QueueTask(() =>
{
bot.Stop();
});
bot.QueueTask(() =>
{
bot.connect(() =>
{
status.Value = "连接成功...";
on_start(bot);
});
});
}).Start();
} else
{
MessageBox.Show("该客户端已经连接，无需再连");
}
}
/// <summary>
/// 离开副本
/// </summary>
public void leaveScene()
{
bot.Client.GameSocket.fightLevelHandler.leaveDungeonRequest((err, res)=>{
if(err != null)
{
MessageBox.Show("该场景不是副本，无法离开");
}
});
}
//--------------------------------------------------------------------------------------------------------
protected virtual void on_start(BotClient obj)
{
events.Info("Bot started");
obj.login(start_enter_server, (err)=>
{
obj.register(start_enter_server, on_error);
});
}
protected virtual void on_stop(BotClient obj)
{
events.Info("Bot stoped");
}
protected virtual void on_update(BotClient obj)
{
foreach (var m in modules.Values) { m.OnUpdate(); }
}
protected virtual void on_bs_update(CommonAI.ZoneClient.ZoneActor obj)
{
}
protected virtual void on_error(Exception err)
{
events.Error(err.Message, err);
//将错误信息显示到当前状态
status.Value = err.Message;
}
public virtual void log_response(string info, Exception err, dynamic r)
{
if (err != null)
events.Error(info + " : " + err.Message);
else if (r != null)
events.Log(info + " : " + r.s2c_code + " : " + r.s2c_msg);
}
public CommonAI.Data.XmdsUnitPro LastSelectUnitPro { get; private set; }
protected virtual void start_enter_server()
{
bot.gate_EnterServer(on_gate_enter_server, (err) =>
{
events.Error(err.Message);
if (err is PomeloException)
{
var pe = err as PomeloException;
if (pe.Code == 500)
{
reconnect();
return;
}
}
});
}
protected virtual void start_re_enter_server()
{
events.Log("gate re enter server");
bot.gate_ReEnterServer((e)=>
{
if (e.s2c_players.Count > 0)
{
events.Log("gate bind player");
bot.gate_BindPlayer(e.s2c_players[0].id, on_gate_bind_player, on_error);
}
},
(err) =>
{
events.Error(err.Message);
if (err is PomeloException)
{
var pe = err as PomeloException;
if (pe.Code == 500)
{
reconnect();
return;
}
}
});
}
protected virtual void on_gate_enter_server(EntryResponse e)
{
events.Log("gate enter server done : player count = " + e.s2c_players.Count);
bot.QueueTask((System.Action)(() =>
{
if (e.s2c_players.Count > 0)
{
events.Log("gate bind player");
bot.gate_BindPlayer(e.s2c_players[0].id, this.on_gate_bind_player, this.on_error);
}
else
{
//this.LastSelectUnitPro = global::CommonAI.Data.XmdsUnitPro.None;
this.LastSelectUnitPro = CUtils.RandomEnumValue<global::CommonAI.Data.XmdsUnitPro>(bot.Random);
if (LastSelectUnitPro == global::CommonAI.Data.XmdsUnitPro.None)
{
LastSelectUnitPro = global::CommonAI.Data.XmdsUnitPro.Sword;
}
string name = CUtils.GetRandomInArray(add.RoleNameFormat, bot.Random);
if (add.RandomRoleName || name == null)
{
events.Log("gate get random name");
bot.gate_GetRandomName((int)LastSelectUnitPro, this.on_gate_get_random_name, this.on_error);
}
else
{
if (name.Contains("{0}"))
name = string.Format(name, index.ToString(add.digit_format));
events.Log("gate create role : " + name);
bot.gate_CreateRole((int)LastSelectUnitPro, name, this.on_gate_create_role, (err) =>
{
on_error(err);
events.Log("gate get random name");
bot.gate_GetRandomName((int)LastSelectUnitPro, this.on_gate_get_random_name, this.on_error);
});
}
}
}));
}
protected virtual void on_gate_get_random_name(GetRandomNameResponse e)
{
events.Log("gate get random name done");
bot.QueueTask(() =>
{
if (string.IsNullOrEmpty(e.s2c_name))
{
events.Log("gate get random name");
bot.gate_GetRandomName((int)LastSelectUnitPro, on_gate_get_random_name, on_error);
}
else
{
events.Log("gate create role : " + e.s2c_name);
bot.gate_CreateRole((int)LastSelectUnitPro, e.s2c_name, on_gate_create_role, (err) =>
{
on_error(err);
events.Log("gate get random name");
bot.gate_GetRandomName((int)LastSelectUnitPro, on_gate_get_random_name, on_error);
});
}
});
}
protected virtual void on_gate_create_role(CreatePlayerResponse e)
{
events.Log("gate create role done : " + e.s2c_player.name);
bot.QueueTask(() =>
{
events.Log("gate bind player : " + e.s2c_player.name);
bot.gate_BindPlayer(e.s2c_player.id, on_gate_bind_player, on_error);
});
}
protected virtual void on_gate_bind_player(BindPlayerResponse e)
{
events.Log("gate bind player done : " + e.s2c_player.name);
foreach (var m in modules.Values) { m.OnGateBindPlayer(e); }
}
//--------------------------------------------------------------------------------------------------------
protected virtual void on_gs_begin_enter_scene(XmdsBattleClient.Battle.XmdsBattleClient obj)
{
this.CurrentMoveAgent = null;
this.CurrentRandomMoveTarget = null;
events.Log("gs begin enter scene done");
if (bot.Client.BattleClient != null)
{
bot.Client.BattleClient.Layer.ActorAdded += on_bs_actor_added;
}
bot.gs_EnterScene(on_gs_enter_scene, on_error);
}
protected virtual void on_gs_enter_scene(EnterSceneResponse response)
{
events.Log("bs enter scene done : " + response.s2c_instanceId);
bot.LineIndex = response.s2c_areaIndex;
bot.SendUnitGuard(true);
foreach (var m in modules.Values) { m.OnGameEnterScene(response); }
}
private void on_bs_actor_ready(CommonAI.ZoneClient.ZoneLayer layer, CommonAI.ZoneClient.ZoneActor actor)
{
foreach (var m in modules.Values)
{
m.OnBattleActorReady(layer, actor);
}
}
private void on_bs_actor_added(CommonAI.ZoneClient.ZoneLayer layer, CommonAI.ZoneClient.ZoneActor actor)
{
actor.OnDoEvent += on_bs_actor_do_event;
layer.AddTimePeriodicMS(5000, (t) =>
{
check_move();
});
}
private void on_bs_actor_do_event(CommonAI.ZoneClient.ZoneObject obj, CommonAI.Zone.ObjectEvent e)
{
if (e is UnitDeadEvent)
{
if (e.object_id == bot.CurrentZoneActor.ObjectID)
{
on_actor_dead(bot.CurrentZoneActor, e as UnitDeadEvent);
}
}
}
private void on_actor_dead(CommonAI.ZoneClient.ZoneActor actor, UnitDeadEvent e)
{
do_relive(2);
foreach (var m in modules.Values) { m.OnBattleActorDead(actor, e); }
}
//--------------------------------------------------------------------------------------------------------
public virtual void do_relive(int type)
{
bot.Client.GameSocket.playerHandler.reliveRequest(type, (e, r) =>
{
log_response("reliveRequest done : ", e, r);
});
}
//--------------------------------------------------------------------------------------------------------
#region GM
private void sendCMD(string cmd, Action<PomeloException, SendChatResponse> cb)
{
//bot.Client.GameSocket.chatHandler.sendChatRequest(1, cmd, "", "", cb);
}
public virtual void do_gm_add_exp(int exp)
{
sendCMD("@gm add exp " + exp, (e, r) =>
{
log_response("do_gm_add_exp done : ", e, r);
});
}
public virtual void do_gm_add_upexp(int exp)
{
sendCMD("@gm add upexp " + exp, (e, r) =>
{
log_response("do_gm_add_upexp done : ", e, r);
});
}
public virtual void do_gm_add_diamond(int exp)
{
sendCMD("@gm add diamond " + exp, (e, r) =>
{
log_response("do_gm_add_diamond done : ", e, r);
});
}
public virtual void do_gm_add_gold(int exp)
{
sendCMD("@gm add gold " + exp, (e, r) =>
{
log_response("do_gm_add_gold done : ", e, r);
});
}
public virtual void do_gm_finish_task(int taskTemplateID)
{
sendCMD("@gm finishTask " + taskTemplateID, (e, r) =>
{
log_response("do_gm_finish_task done : ", e, r);
});
}
public virtual void do_gm_unlock_bag(int num)
{
sendCMD("@gm unlock " + num, (e, r) =>
{
log_response("do_gm_unlock_bag done : ", e, r);
});
}
/************************************************************************/
/* 模拟充值成功回调 */
/************************************************************************/
public virtual void do_gm_pay_success(String orderId)
{
sendCMD("@gm paySuccess " + orderId, (e, r) =>
{
log_response("do_gm_pay_success done : ", e, r);
});
}
public virtual void do_gm_open_func()
{
sendCMD("@gm openFunc", (e, r) =>
{
log_response("do_gm_open_func done : ", e, r);
});
}
public virtual void do_gm_add_skin() {
sendCMD("@gm allSkin",(e,r) => {
log_response("do_gm_add_skin done : ", e, r);
});
}
public virtual void do_gm_add_item(string code, int num)
{
sendCMD("@gm add " + code + " " + num, (e, r) =>
{
log_response("do_gm_add_item done : ", e, r);
});
}
public virtual void do_gm_add_item()
{
//sendCMD("@gm add lclot1-test 1", (e, r) =>
//{
// log_response("do_gm_add_item done : ", e, r);
//});
//sendCMD("@gm add lweap1-test 1", (e, r) =>
//{
// log_response("do_gm_add_item done : ", e, r);
//});
}
#endregion
//--------------------------------------------------------------------------------------------------------
#region Task
public virtual BotClient.QuestData do_seek_task(int questID, BotClient.QuestData.SeekAction action)
{
var quest = bot.CurrentQuestManager.GetQuest(questID);
if (quest != null)
{
events.Log("do_seek_task : " + quest);
quest.Seek(action);
}
return quest;
}
public virtual BotClient.QuestData do_seek_expect_task(BotClient.QuestData.QuestStatus expect, BotClient.QuestData.SeekAction action, bool random = false)
{
BotClient.QuestData q = null;
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.TRUNK, expect, action, random)) != null)
{
events.Log("do_seek_expect_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.INVALID, expect, action, random)) != null)
{
events.Log("do_seek_expect_task : " + q);
return q;
}
return q;
}
public virtual BotClient.QuestData do_seek_random_task(BotClient.QuestData.SeekAction action, bool random = false)
{
BotClient.QuestData q = null;
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.TRUNK, BotClient.QuestData.QuestStatus.CAN_FINISH, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.TRUNK, BotClient.QuestData.QuestStatus.IN_PROGRESS, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.TRUNK, BotClient.QuestData.QuestStatus.NEW, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.INVALID, BotClient.QuestData.QuestStatus.CAN_FINISH, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.INVALID, BotClient.QuestData.QuestStatus.IN_PROGRESS, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
if ((q = bot.CurrentQuestManager.SeekExpectTask(BotClient.QuestData.QuestType.INVALID, BotClient.QuestData.QuestStatus.NEW, action, random)) != null)
{
events.Log("do_seek_random_task : " + q);
return q;
}
return q;
}
public virtual void do_update_quest_status(BotClient.QuestData quest)
{
events.Log("do_update_quest_status : " + quest + " : " + quest.State);
bot.Client.GameSocket.taskHandler.updateTaskStatusRequest(quest.TemplateID, (int)quest.Kind, (err, msg) =>
{
if (err != null)
events.Error("updateTaskStatusRequest error : " + err.Message);
else
events.Log("updateTaskStatusRequest done : " + msg.s2c_code + " : " + msg.s2c_msg);
});
}
public virtual void do_accept_quest(BotClient.QuestData quest, Action<Exception> error = null)
{
if (client.BattleActor != null)
{
events.Log("do_accept_quest : " + quest + " : " + quest.State);
client.GameSocket.taskHandler.acceptTaskRequest(quest.TemplateID, (int)quest.Kind, client.BattleActor.ObjectID.ToString(), (err, msg) =>
{
if (err != null)
{
events.Error("acceptTaskRequest error : " + err.Message);
if (error != null) error(err);
}
else
{
events.Log("acceptTaskRequest done : " + msg.s2c_code + " : " + msg.s2c_msg);
}
});
}
}
public virtual void do_submit_task(BotClient.QuestData quest, Action<Exception> error = null)
{
if (client.BattleActor != null)
{
events.Log("do_submit_task : " + quest + " : " + quest.State);
client.GameSocket.taskHandler.submitTaskRequest(quest.TemplateID, (int)quest.Kind, 0, client.BattleActor.ObjectID.ToString(), (err, msg) =>
{
if (err != null)
{
events.Error("submitTaskRequest error : " + err.Message);
if (error != null) error(err);
}
else
{
events.Log("submitTaskRequest done : " + msg.s2c_code + " : " + msg.s2c_msg);
}
});
}
}
#endregion
//--------------------------------------------------------------------------------------------------------
#region Move
public ActorMoveAgent CurrentMoveAgent { get; private set; }
public SceneObjectData CurrentRandomMoveTarget { get; private set; }
private Vector2 mLastPos = new Vector2();
private void check_move()
{
float min_step = client.DataRoot.Templates.CFG.OBJECT_MOVE_TO_MIN_STEP_SEC;
bool not_move = MathVector.getDistance(mLastPos.X, mLastPos.Y, bot.CurrentZoneActor.X, bot.CurrentZoneActor.Y) < min_step;
mLastPos.SetX(bot.CurrentZoneActor.X);
mLastPos.SetY(bot.CurrentZoneActor.Y);
if (not_move)
{
CurrentRandomMoveTarget = null;
if (CurrentMoveAgent != null)
CurrentMoveAgent.Stop();
CurrentMoveAgent = null;
}
}
private SceneObjectData do_bs_actor_random_move_regions<R>(List<R> list, bool attack, float min_distance) where R : SceneObjectData
{
var player = bot.CurrentZoneActor;
var layer = bot.CurrentZoneLayer;
if (player != null && layer.IsLoaded)
{
try
{
bot.SendUnitGuard(attack);
if (CurrentRandomMoveTarget == null ||
MathVector.getDistance(player.X, player.Y, CurrentRandomMoveTarget.X, CurrentRandomMoveTarget.Y) <= min_distance ||
layer.FindPath(player.X, player.Y, CurrentRandomMoveTarget.X, CurrentRandomMoveTarget.Y) == null)
{
CUtils.RandomList<R>(bot.Random, list);
foreach (var rg in list)
{
if (player.Parent.FindPath(player.X, player.Y, rg.X, rg.Y) != null)
{
events.Log("do_bs_actor_random_move_region : " + rg.Name);
if (!attack)
{
do_start_move_agent(rg.X, rg.Y, min_distance);
}
else
{
player.SendUnitAttackMoveTo(rg.X, rg.Y, attack);
}
CurrentRandomMoveTarget = rg;
return rg;
}
}
}
else if (bot.CurrentZoneActor.CurrentState == UnitActionStatus.Idle)
{
if (!attack)
{
do_start_move_agent(CurrentRandomMoveTarget.X, CurrentRandomMoveTarget.Y, min_distance);
}
else
{
player.SendUnitAttackMoveTo(CurrentRandomMoveTarget.X, CurrentRandomMoveTarget.Y, attack);
}
return CurrentRandomMoveTarget;
}
}
catch (Exception err)
{
events.Error(err.Message, err);
}
}
return null;
}
public virtual SceneObjectData do_bs_actor_random_move_region(bool attack = true, float min_distance = 0.1f)
{
return do_bs_actor_random_move_regions<RegionData>(bot.CurrentRegionManager.AllRegions(), attack, min_distance);
}
public virtual SceneObjectData do_bs_actor_random_move_transport(bool attack = true, float min_distance = 0.1f)
{
return do_bs_actor_random_move_regions<SceneObjectData>(bot.CurrentRegionManager.AllTransports(), attack, min_distance);
}
public virtual ActorMoveAgent do_start_move_agent(float x, float y, float distance, bool force_trans = false)
{
if (CurrentMoveAgent != null)
{
CurrentMoveAgent.Stop();
}
CurrentMoveAgent = new ActorMoveAgent(x, y, distance);
bot.CurrentZoneActor.AddAgent(CurrentMoveAgent);
bot.SendUnitGuard(false);
if (CurrentMoveAgent.Result == CommonAI.RTS.Manhattan.AstarManhattan.FindPathResult.Destination)
{
bot.CurrentRegionManager.CheckTrans(1, force_trans);
}
else if (CurrentMoveAgent.IsEnd)
{
bot.CurrentZoneActor.SendUnitAttackMoveTo(x, y, false);
}
return CurrentMoveAgent;
}
#endregion
//--------------------------------------------------------------------------------------------------------
#region Pick
public virtual CommonAI.ZoneClient.ZoneItem do_try_pick_nearest_item(out Vector2 move_to)
{
move_to = null;
if (bot.CurrentZoneActor.CurrentState != UnitActionStatus.Pick)
{
var item = bot.CurrentZoneLayer.GetNearPickableItem(bot.CurrentZoneActor);
if (item != null)
{
events.Log("try pick nearest item : " + item.Info.Name);
if (MathVector.getDistance(bot.CurrentZoneActor.X, bot.CurrentZoneActor.Y, item.X, item.Y) < item.RadiusSize)
{
bot.CurrentZoneActor.SendUnitPickObject(item.ObjectID);
return item;
}
else
{
move_to = new Vector2(item.X, item.Y);
}
}
}
return null;
}
public virtual CommonAI.ZoneClient.ZoneItem do_start_pick_any_item()
{
if (bot.CurrentZoneActor.CurrentState != UnitActionStatus.Pick)
{
var item = bot.CurrentZoneLayer.GetNearPickableItem(bot.CurrentZoneActor);
if (item != null)
{
events.Log("do pick item : " + item.Info.Name);
bot.CurrentZoneActor.SendUnitPickObject(item.ObjectID);
return item;
}
}
return null;
}
#endregion
#region BagAndEquip
#endregion
//--------------------------------------------------------------------------------------------------------
public abstract class RunnerModule
{
public string module_name = "模块名";
private static HashMap<Type, bool> s_SubModules = new HashMap<Type, bool>();
public static List<Type> GetSubTypes()
{
var ret = new List<Type>();
foreach (var mt in typeof(RunnerModule).Assembly.GetTypes())
{
if (mt.IsSubclassOf(typeof(RunnerModule)) && !mt.IsAbstract)
{
ret.Add(mt);
}
}
return ret;
}
/// <summary>
/// 获取类中的属性值
/// </summary>
/// <param name="FieldName"></param>
/// <param name="obj"></param>
/// <returns></returns>
public string GetModelValue(string FieldName, object obj)
{
try
{
Type Ts = obj.GetType();
object o = Ts.GetProperty(FieldName).GetValue(obj, null);
string Value = Convert.ToString(o);
if (string.IsNullOrEmpty(Value)) return null;
return Value;
}
catch
{
return null;
}
}
public static void SetModuleEnable(Type type, bool value)
{
s_SubModules[type] = value;
}
public static bool GetModuleEnable(Type type)
{
bool enable = false;
if (s_SubModules.TryGetValue(type, out enable))
{
return enable;
}
return false;
}
static RunnerModule()
{
foreach (var mt in GetSubTypes())
{
s_SubModules.Add(mt, true);
}
}
private bool m_Enable;
protected BotClient bot { get; private set; }
protected BotRunner runner { get; private set; }
protected XmdsNetClient client { get; private set; }
protected Logger log { get; private set; }
public bool Enable { get { return m_Enable; } }
public void autoJoinTeam()
{
if(IsCanJoin)
{
autoJoinTeamRequest();
}
}
public virtual void autoJoinTeamRequest()
{
}
protected virtual int rand()
{
return 20;
}
public bool IsCanJoin
{
get { return Enable && bot.IsFree && (runner.CurrentMoveAgent == null) && bot.Random.Next(100) < rand(); }
}
public RunnerModule() {
}
public RunnerModule(BotRunner r)
{
this.runner = r;
this.bot = r.Bot;
this.client = bot.Client;
this.log = r.events;
this.m_Enable = GetModuleEnable(GetType());
}
public void SetStatus(string st)
{
runner.status.Value = st;
}
internal void OnUpdate()
{
bool enable = GetModuleEnable(GetType());
if (m_Enable != enable)
{
m_Enable = enable;
OnEnableChanged(enable);
}
}
protected virtual void OnEnableChanged(bool enable) { }
protected internal virtual void OnGateBindPlayer(BindPlayerResponse e) { }
protected internal virtual void OnGameEnterScene(EnterSceneResponse response) { }
protected internal virtual void OnBattleActorReady(CommonAI.ZoneClient.ZoneLayer layer, CommonAI.ZoneClient.ZoneActor actor) { }
protected internal virtual void OnBattleActorDead(CommonAI.ZoneClient.ZoneActor actor, UnitDeadEvent e) { }
}
}
}