void ExecAction(SingleAction actionInfo)
{
if (_mMCtrl && actionInfo.ActionType != MonsterAction.None)
{
switch (actionInfo.ActionType)
{
case MonsterAction.Forward:
_mMCtrl.Forward(ActionCallBack, actionInfo.ExecTime, actionInfo.Speed);
break;
case MonsterAction.Back:
_mMCtrl.Back(ActionCallBack, actionInfo.ExecTime, actionInfo.Speed);
break;
case MonsterAction.Left:
_mMCtrl.Left(ActionCallBack, actionInfo.ExecTime, actionInfo.Speed);
break;
case MonsterAction.Right:
_mMCtrl.Right(ActionCallBack, actionInfo.ExecTime, actionInfo.Speed);
break;
case MonsterAction.Jump:
_mMCtrl.Jump(ActionCallBack);
break;
case MonsterAction.MoveDirtion:
_mMCtrl.MoveDirtion(actionInfo.Dirtion, ActionCallBack, actionInfo.ExecTime, actionInfo.Speed);
break;
}
}
}
public SystemTimeValidator(INtpClient ntpClient, IModals modals, ILogger logger)
{
_ntpClient = ntpClient;
_modals = modals;
_logger = logger;
_validateAction = new SingleAction(ValidateTime);
}
public DnsClient(IDnsClients dnsClients, INetworkInterfaces networkInterfaces)
{
_dnsClients = dnsClients;
_refreshDnsClient = new SingleAction(RefreshDnsClient);
networkInterfaces.NetworkAddressChanged += NetworkAddressChanged;
}
public AlternativeHostHandler(
DohClients dohClients,
MainHostname mainHostname,
IAppSettings appSettings,
string apiHost)
{
_mainHostname = mainHostname;
_dohClients = dohClients;
_appSettings = appSettings;
_apiHost = apiHost;
_activeBackendHost = apiHost;
_fetchProxies = new SingleAction(FetchProxies);
}
public StreamingServicesUpdater(
StreamingServicesStorage streamingServicesStorage,
IApiClient apiClient,
IScheduler scheduler,
Common.Configuration.Config config)
{
_streamingServicesStorage = streamingServicesStorage;
_apiClient = apiClient;
_timer = scheduler.Timer();
_timer.Interval = config.StreamingServicesUpdateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(UpdateStreamingServices);
}
public ClientConfig(
IAppSettings appSettings,
IScheduler scheduler,
IApiClient apiClient,
Common.Configuration.Config config)
{
_appSettings = appSettings;
_apiClient = apiClient;
_timer = scheduler.Timer();
_timer.Interval = config.ClientConfigUpdateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(UpdateAction);
}
public UserLocationService(
IApiClient api,
IUserStorage userStorage,
INetworkInterfaces networkInterfaces)
{
_api = api;
_userStorage = userStorage;
_updateAction = new SingleAction(UpdateAction);
_delayedUpdateAction = new SingleAction(DelayedUpdateAction);
networkInterfaces.NetworkAddressChanged += NetworkInterfaces_NetworkAddressChanged;
}
/// <summary>
/// Implements transport callback
/// </summary>
/// <param name="requestArgs"></param>
/// <param name="callback"></param>
public void SendAsynchronous(TransferData.ContentMode contentMode, HttpRequestArgs requestArgs, SingleAction<HttpResponseArgs> callback)
{
ShowDebugInfo(System.Reflection.MethodBase.GetCurrentMethod(), contentMode, requestArgs);
TransferData td = new TransferData(false)
{
m_contentMode = contentMode,
m_synchronous = false,
m_requestArgs = requestArgs,
m_callback = callback
};
AddToTransferData(td);
}
public AnnouncementService(
IAppSettings appSettings,
IScheduler scheduler,
IApiClient apiClient,
IAnnouncementCache announcementCache,
TimeSpan updateInterval)
{
_appSettings = appSettings;
_announcementCache = announcementCache;
_apiClient = apiClient;
_timer = scheduler.Timer();
_timer.Interval = updateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(Fetch);
}
public AlternativeHostHandler(
ILogger logger,
DohClients dohClients,
MainHostname mainHostname,
IAppSettings appSettings,
GuestHoleState guestHoleState,
string apiHost)
{
_logger = logger;
_guestHoleState = guestHoleState;
_mainHostname = mainHostname;
_dohClients = dohClients;
_appSettings = appSettings;
_apiHost = apiHost;
_activeBackendHost = apiHost;
_fetchProxies = new SingleAction(FetchProxies);
}
public ServerUpdater(
IScheduler scheduler,
Config appConfig,
ServerManager serverManager,
ApiServers apiServers,
ICollectionStorage <LogicalServerContract> serverCache)
{
_serverManager = serverManager;
_apiServers = apiServers;
_serverCache = serverCache;
_timer = scheduler.Timer();
_timer.Interval = appConfig.ServerUpdateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(UpdateServers);
}
public ServersUpdater(
ILogger logger,
IScheduler scheduler,
Config appConfig,
ServerManager serverManager,
CachedServersProvider serversProvider)
{
_logger = logger;
_serverManager = serverManager;
_serversProvider = serversProvider;
_timer = scheduler.Timer();
_timer.Interval = appConfig.ServerUpdateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(UpdateServers);
}
public UserLocationService(
IApiClient api,
IUserStorage userStorage,
INetworkInterfaces networkInterfaces,
UserAuth userAuth,
GuestHoleState guestHoleState)
{
_userAuth = userAuth;
_guestHoleState = guestHoleState;
_api = api;
_userStorage = userStorage;
_updateAction = new SingleAction(UpdateAction);
_delayedUpdateAction = new SingleAction(DelayedUpdateAction);
networkInterfaces.NetworkAddressChanged += NetworkInterfaces_NetworkAddressChanged;
}
void StartMonsterStruggle()
{
if (null == _struggleActions)
{
Debug.Log("AnalogMonsterStruggle: _struggleActions is null!");
return;
}
if (_struggleActions.Count > 0)
{
_curActionInfo = _struggleActions.Dequeue();
ExecAction(_curActionInfo);
IsTameSucceed = false;
}
else
{
IsTameSucceed = true;
}
}
public OpenVpnConnection(
ILogger logger,
OpenVpnProcess process,
ManagementClient managementClient)
{
_logger = logger;
_process = process;
_managementClient = managementClient;
_managementClient.VpnStateChanged += ManagementClient_StateChanged;
_managementClient.TransportStatsChanged += ManagementClient_TransportStatsChanged;
_managementPorts = new OpenVpnManagementPorts();
_randomStrings = new RandomStrings();
_connectAction = new SingleAction(ConnectAction);
_connectAction.Completed += ConnectAction_Completed;
_disconnectAction = new SingleAction(DisconnectAction);
_disconnectAction.Completed += DisconnectAction_Completed;
}
/// <summary> 生成模拟怪物挣扎行为时间轴 </summary>
void GenerateStruggleActions()
{
if (null == _actionSeedDic)
{
return;
}
//怪物的Bounds
Bounds bounds = GetMonsterBounds();
//怪物体积
float monsterBulk = bounds.size.x * bounds.size.y * bounds.size.z;
//怪物体积Clamp
monsterBulk = Mathf.Clamp(monsterBulk, TameMonsterConfig.instance.MonsterBulkRange.Min, TameMonsterConfig.instance.MonsterBulkRange.Max);
//怪物体积占比
float bulkProportion = (monsterBulk - TameMonsterConfig.instance.MonsterBulkRange.Min) / (TameMonsterConfig.instance.MonsterBulkRange.Max - TameMonsterConfig.instance.MonsterBulkRange.Min);
//体积占比转换为行为数占比
float actionSize = bulkProportion * TameMonsterConfig.instance.MonsterStruggleActionSizeRange.Max;
//行为数Clamp
StruggleActionTotal = (int)Mathf.Clamp(actionSize, TameMonsterConfig.instance.MonsterStruggleActionSizeRange.Min, TameMonsterConfig.instance.MonsterStruggleActionSizeRange.Max);
_struggleActions = new Queue <SingleAction>();
MonsterAction actionType;
Vector3 dirtion = Vector3.one;
for (int i = 0; i < StruggleActionTotal; i++)
{
actionType = GetRandomAction();
if (_actionSeedDic.ContainsKey(actionType))
{
if (actionType == MonsterAction.MoveDirtion)
{
dirtion = GetRandomDirtion();
}
SingleAction tempInfo = new SingleAction(actionType, _actionSeedDic[actionType].RandomTime, _actionSeedDic[actionType].RandomSpeed, dirtion);
//随机挣扎行为时间轴加到队列
_struggleActions.Enqueue(tempInfo);
}
}
}
public WireGuardConnection(
ILogger logger,
ProtonVPN.Common.Configuration.Config config,
IService wireGuardService,
TrafficManager trafficManager,
StatusManager statusManager,
IX25519KeyGenerator x25519KeyGenerator)
{
_logger = logger;
_config = config;
_wireGuardService = wireGuardService;
_trafficManager = trafficManager;
_statusManager = statusManager;
_x25519KeyGenerator = x25519KeyGenerator;
_trafficManager.TrafficSent += OnTrafficSent;
_statusManager.StateChanged += OnStateChanged;
_connectAction = new SingleAction(ConnectAction);
_connectAction.Completed += OnConnectActionCompleted;
_disconnectAction = new SingleAction(DisconnectAction);
_disconnectAction.Completed += OnDisconnectActionCompleted;
}
public ServerUpdater(
IScheduler scheduler,
Common.Configuration.Config appConfig,
ServerManager serverManager,
IApiServers apiServers,
ICollectionStorage <LogicalServerContract> serverCache,
ServerLoadUpdater serverLoadUpdater,
IAppSettings appSettings)
{
_serverManager = serverManager;
_apiServers = apiServers;
_serverCache = serverCache;
_appSettings = appSettings;
_timer = scheduler.Timer();
_timer.Interval = appConfig.ServerUpdateInterval.RandomizedWithDeviation(0.2);
_timer.Tick += Timer_OnTick;
_updateAction = new SingleAction(UpdateServers);
serverLoadUpdater.ServerLoadsUpdated += OnServerLoadsUpdated;
}
public void Awake()
{
agentScript = this.gameObject.GetComponent <AgentActions>();
//******************************************************************************************************************//
//******************************************************************************************************************//
// Declaring a decision and assigning it to a decision node
// This process is repeated for the following decisions as well
Decision health_high = new Decision(Decisions.IsHealthHigherThan25Percent);
DecisionNode health_high_decision = new DecisionNode(health_high);
Decision is_agent_in_sight = new Decision(Decisions.IsOpponentInSight);
// Two nodes are created to perform 'Agent in Sight' decisions on both
// situations: when the health is low and when it isn't
DecisionNode in_sight_with_less_health_decision = new DecisionNode(is_agent_in_sight);
DecisionNode in_sight_with_more_health_decision = new DecisionNode(is_agent_in_sight);
// Child nodes are being added
// This is how the tree expands
health_high_decision.AddFalseChild(in_sight_with_less_health_decision);
health_high_decision.AddTrueChild(in_sight_with_more_health_decision);
//******************************************************************************************************************//
//******************************************************************************************************************//
Decision is_health_kit_in_sight = new Decision(Decisions.IsHealthKitInSight);
DecisionNode is_health_kit_in_sight_decision = new DecisionNode(is_health_kit_in_sight);
// An action is created and assigned to an action node
// This process is repeated for the following actions as well
SingleAction flee_from_opponent = new SingleAction(Actions.FleeFromOpponent, 0);
ActionNode flee_from_opponent_action = new ActionNode(flee_from_opponent);
// If our health is less and agent is in sight, flee.
// Else, look for health kit
in_sight_with_less_health_decision.AddFalseChild(is_health_kit_in_sight_decision);
in_sight_with_less_health_decision.AddTrueChild(flee_from_opponent_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
SingleAction random_wander = new SingleAction(Actions.RandomWander, 0);
ActionNode random_wander_action = new ActionNode(random_wander);
SingleAction move_towards_health_kit = new SingleAction(Actions.MoveTowardsHealthKit, 0);
ActionNode move_towards_health_kit_action = new ActionNode(move_towards_health_kit);
// If health kit in in sight, move towards it. Else, execute random wander
is_health_kit_in_sight_decision.AddFalseChild(random_wander_action);
is_health_kit_in_sight_decision.AddTrueChild(move_towards_health_kit_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
Decision is_power_up_picked = new Decision(Decisions.IsPowerUpPicked);
DecisionNode is_power_up_picked_decision = new DecisionNode(is_power_up_picked);
Decision is_opponent_fleeing = new Decision(Decisions.IsOpponentFleeing);
DecisionNode is_opponent_fleeing_decision = new DecisionNode(is_opponent_fleeing);
// If we have more health and enemy is in sight, check if it's fleeing. If not,
// then, check if we already picked a power up
in_sight_with_more_health_decision.AddFalseChild(is_power_up_picked_decision);
in_sight_with_more_health_decision.AddTrueChild(is_opponent_fleeing_decision);
//******************************************************************************************************************//
//******************************************************************************************************************//
Decision is_power_up_in_sight = new Decision(Decisions.IsPowerUpInSight);
DecisionNode is_power_up_in_sight_decision = new DecisionNode(is_power_up_in_sight);
// If we haven't picked it up, then look for one. Else, execute random wander
is_power_up_picked_decision.AddFalseChild(is_power_up_in_sight_decision);
is_power_up_picked_decision.AddTrueChild(random_wander_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
SingleAction move_towards_power_up = new SingleAction(Actions.MoveTowardsPowerUp, 0);
ActionNode move_towards_power_up_action = new ActionNode(move_towards_power_up);
// If a pick up is in sight, then move towards it. Else, execute random wander
is_power_up_in_sight_decision.AddFalseChild(random_wander_action);
is_power_up_in_sight_decision.AddTrueChild(move_towards_power_up_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
Decision is_attack_power_higher = new Decision(Decisions.IsAttackPowerHigher);
DecisionNode is_attack_power_higher_decision = new DecisionNode(is_attack_power_higher);
// If the opponent is not fleeing, check if our attack power is higher. Else, execute random wander
is_opponent_fleeing_decision.AddFalseChild(is_attack_power_higher_decision);
is_opponent_fleeing_decision.AddTrueChild(random_wander_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
Decision is_in_attack_distance = new Decision(Decisions.IsInAttackDistance);
DecisionNode is_in_attack_distance_decision = new DecisionNode(is_in_attack_distance);
// If our attack power is equal or higher than the opponent, check if we're in attack range.
// Else, flee from sight
is_attack_power_higher_decision.AddFalseChild(flee_from_opponent_action);
is_attack_power_higher_decision.AddTrueChild(is_in_attack_distance_decision);
//******************************************************************************************************************//
//******************************************************************************************************************//
SingleAction move_towards_agent = new SingleAction(Actions.MoveTowardsOpponent, 0);
ActionNode move_towards_agent_action = new ActionNode(move_towards_agent);
SingleAction attack_opponent = new SingleAction(Actions.AttackOpponent, 0.15f);
ActionNode attack_opponent_action = new ActionNode(attack_opponent);
// If we're not in attack distance, then move towards opponent. Else, attack the
// opponent
is_in_attack_distance_decision.AddFalseChild(move_towards_agent_action);
is_in_attack_distance_decision.AddTrueChild(attack_opponent_action);
//******************************************************************************************************************//
//******************************************************************************************************************//
// Assigning the root node with the health check decision
decision_tree = new DecisionTree(health_high_decision);
// Assigning random wander as the default action
action_executor = new ActionExecutor(random_wander);
}
public StatusManager(ILogger logger, string logPath)
{
_logger = logger;
_ringLogger = new RingLogger(logPath);
_receiveLogsAction = new SingleAction(ReceiveLogsAction);
}
public TrafficManager(string adapterName, ILogger logger)
{
_adapterName = adapterName;
_logger = logger;
_updateBytesTransferredAction = new SingleAction(UpdateBytesTransferred);
}
// A function to add actions into the sequence
public void AddAction(SingleAction s_act)
{
sequence.Add(s_act);
}
public override void SendTextAsync(HttpRequestArgs requestArgs, SingleAction<HttpResponseArgs> callback)
{
SendContentAsynchronous(TransferData.ContentMode.Text, requestArgs, callback);
}
/// <summary>
/// Implements transport callback
/// </summary>
public new void SendAsync(HttpRequestArgs requestArgs, SingleAction<HttpResponseArgs> callback)
{
SendContentAsynchronous(TransferData.ContentMode.Binary, requestArgs, callback);
}
