public override async Task <TResult> Run <TResult>(Func <Task <TResult> > action)
{
if (TaskInvokationVerification())
{
return(await TaskInvoker.Invoke(action, _TimeOut, this));
}
else
{
throw new OpenStateException();
}
}
public override void Run(Action action)
{
if (TaskInvokationVerification())
{
TaskInvoker.Invoke(action, _TimeOut, this);
}
else
{
throw new OpenStateException();
}
}
public override async Task Run(Func <Task> action)
{
if (TaskInvokationVerification())
{
await TaskInvoker.Invoke(action, _TimeOut, this);
}
else
{
throw new OpenStateException();
}
}
public static Ped GetInstancePed(this TaskInvoker taskInvoker)
{
PropertyInfo p = taskInvoker.GetType().GetProperty("Ped", BindingFlags.NonPublic | BindingFlags.Instance);
if (p != null)
{
Ped instancePed = (Ped)p.GetMethod.Invoke(taskInvoker, null);
return(instancePed);
}
return(null);
}
public static Task VehicleEscort(this TaskInvoker taskInvoker, Vehicle vehicle, Vehicle targetVehicle, EscortMode mode, float speed, VehicleDrivingFlags style, float minimumDistance, float noRoadsDistance)
{
Ped ped = taskInvoker.GetInstancePed();
if (ped != null)
{
NativeFunction.CallByName <uint>("TASK_VEHICLE_ESCORT", ped, vehicle, targetVehicle, (int)mode, speed, (int)style, minimumDistance, 0, noRoadsDistance);
return(Task.GetTask(ped, "TASK_VEHICLE_ESCORT"));
}
return(null);
}
/// <summary>
/// Test for the implementation of the command pattern
/// </summary>
private static void CommandTest()
{
ITaskReceiver taskRepository = new TaskReceiver();
TaskInvoker taskManager = new TaskInvoker();
ICommand addTaskCommand1 = new AddTaskCommand(taskRepository, "Read Qurran 30min");
ICommand addTaskCommand2 = new AddTaskCommand(taskRepository, "Read book 30min");
ICommand addTaskCommand3 = new AddTaskCommand(taskRepository, "Sport 20min");
ICommand markTaskCompletedCommand = new MarkTaskCompleteCommand(taskRepository, "Read Qurran 30min");
ICommand displayAllTasks = new DisplayAllTasksDetailsCommand(taskRepository);
taskManager.Execute(addTaskCommand1);
taskManager.Execute(addTaskCommand2);
taskManager.Execute(addTaskCommand3);
taskManager.Execute(markTaskCompletedCommand);
taskManager.Execute(displayAllTasks);
}
private async void toolRun_Click(object sender, EventArgs e)
{
if (this.isRun)
{
return;
}
if (!this.editor.Save())
{
return;
}
if (this.isRun)
{
return;
}
this.txtResult.Text = "";
this.txtResult.ForeColor = Color.Black;
this.isRun = true;
this.SetRunSetting();
this.stat.Start();
this.LabStatus.Text = "正在执行...";
var scriptFile = this.editor.SelectedItem.BindFile.FullName;
var source = new TaskSource();
await new System.Threading.Tasks.TaskFactory().StartNew(() =>
{
try
{
using (tasks = new SnailCore.Sync.Parallel(this.runSetting.UserCount))
{
tasks.ForEach <int>(new int[this.runSetting.UserCount], (item) =>
{
try
{
// 启动一个用户客户端
using (var invoker = new TaskInvoker(scriptFile))
{
invoker.AddHostObj("console", this);
invoker.AddHostObj("log", this);
invoker.AddHostObj("stat", this.stat);
invoker.AddHostObj("source", source);
this.stat.addUser();
var runResult = false;
try
{
runResult = invoker.Run();
}
catch (Exception ex)
{
this.SetResult(false, ex.ToString() + "\r\n", true);
runResult = false;
}
this.stat.addUser(-1);
}
}
catch (Exception ex)
{
this.SetResult(false, ex.ToString() + "\r\n", true);
}
});
}
}
catch (Exception ex)
{
this.SetResult(false, ex.ToString() + "\r\n", true);
}
finally
{
this.isRun = false;
this.LabStatus.BeginInvoke(new MethodInvoker(() =>
{
this.LabStatus.Text = "已结束";
}));
SetRunStatus();
}
});
source.Dispose();
this.isRun = false;
}
public override void Try()
{
TaskInvoker.InvokePlanified(
() => _TryCloseTheGate(),
_ReTimeOut);
}
public override async Task <TResult> Run <TResult>(Func <Task <TResult> > action)
{
return(await TaskInvoker.InvokeAsync <TResult>(action, _TimeOut, this));
}
public override async Task Run(Func <Task> action)
{
await TaskInvoker.InvokeAsync(action, _TimeOut, this);
}
public override TResult Run <TResult>(Func <TResult> action)
{
return(TaskInvoker.Invoke <TResult>(action, _TimeOut, this));
}
public override void Run(Action action)
{
TaskInvoker.Invoke(action, _TimeOut, this);
}
private void UpdateVehicleMountedWeapon()
{
if (WeaponDataProvider.DoesVehicleSeatHaveGunPosition((VehicleHash)VehicleHash, VehicleSeat))
{
var delay = 30;
//if ((VehicleHash) VehicleHash == GTA.Native.VehicleHash.Rhino) delay = 300;
if (Game.GameTime - _lastVehicleAimUpdate > delay)
{
Function.Call(Hash.TASK_VEHICLE_AIM_AT_COORD, Character, AimCoords.X, AimCoords.Y,
AimCoords.Z);
_lastVehicleAimUpdate = Game.GameTime;
}
if (IsShooting)
{
if (((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino &&
DateTime.Now.Subtract(_lastRocketshot).TotalMilliseconds > 1000) ||
((VehicleHash)VehicleHash != GTA.VehicleHash.Rhino))
{
_lastRocketshot = DateTime.Now;
var baseTurretPos =
MainVehicle.GetOffsetInWorldCoords(
WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash, false));
var doesBaseTurretDiffer =
WeaponDataProvider.DoesVehiclesMuzzleDifferFromVehicleGunPos(
(VehicleHash)VehicleHash);
var barrellLength = WeaponDataProvider.GetVehicleTurretLength((VehicleHash)VehicleHash);
var speed = 0xbf800000;
var hash = WeaponHash.CombatPDW;
if ((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino)
{
hash = (WeaponHash)1945616459;
}
Vector3 tPos = baseTurretPos;
if (
WeaponDataProvider.DoesVehicleHaveParallelWeapon((VehicleHash)VehicleHash, false) &&
VehicleSeat == 1)
{
var muzzle = WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash,
false);
tPos =
MainVehicle.GetOffsetInWorldCoords(new Vector3(muzzle.X * -1f, muzzle.Y, muzzle.Z));
}
if (doesBaseTurretDiffer)
{
var kekDir = (AimCoords - tPos);
kekDir.Normalize();
var rot = Main.DirectionToRotation(kekDir);
var newDir = Main.RotationToDirection(new Vector3(0, 0, rot.Z));
newDir.Normalize();
tPos = tPos +
newDir *
WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash, true)
.Length();
}
var turretDir = (AimCoords - tPos);
turretDir.Normalize();
var start = tPos + turretDir * barrellLength;
var end = start + turretDir * 100f;
_lastStart = start;
_lastEnd = end;
var damage = WeaponDataProvider.GetWeaponDamage(WeaponHash.Minigun);
if ((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino)
{
damage = 210;
}
if (IsFriend())
{
damage = 0;
}
Function.Call(Hash.SHOOT_SINGLE_BULLET_BETWEEN_COORDS, start.X, start.Y, start.Z, end.X,
end.Y, end.Z, damage, true, (int)hash, Character, true, false, speed);
}
}
}
else if (!WeaponDataProvider.DoesVehicleSeatHaveMountedGuns((VehicleHash)VehicleHash) || VehicleSeat != -1)
{
if (Character.Weapons.Current.Hash != (WeaponHash)CurrentWeapon)
{
//Function.Call(Hash.GIVE_WEAPON_TO_PED, Character, CurrentWeapon, 999, true, true);
//Function.Call(Hash.SET_CURRENT_PED_WEAPON, Character, CurrentWeapon, true);
//Character.Weapons.Give((WeaponHash)CurrentWeapon, -1, true, true);
//Character.Weapons.Select((WeaponHash) CurrentWeapon);
Character.Weapons.RemoveAll();
Character.Weapons.Give((WeaponHash)CurrentWeapon, -1, true, true);
}
if (IsShooting || IsAiming)
{
if (!_lastDrivebyShooting)
{
Function.Call(Hash.SET_PED_CURRENT_WEAPON_VISIBLE, Character, false, false, false, false);
Function.Call(Hash.TASK_DRIVE_BY, Character, 0, 0, AimCoords.X, AimCoords.Y, AimCoords.Z,
0, 0, 0, unchecked ((int)FiringPattern.SingleShot));
}
else
{
Function.Call(Hash.SET_PED_CURRENT_WEAPON_VISIBLE, Character, true, false, false, false);
Function.Call(Hash.SET_DRIVEBY_TASK_TARGET, Character, 0, 0, AimCoords.X, AimCoords.Y, AimCoords.Z);
}
var rightSide = (VehicleSeat + 2) % 2 == 0;
if (WeaponDataProvider.NeedsFakeBullets(CurrentWeapon))
{
const string rightDict = "veh@driveby@first_person@passenger_right_handed@throw";
const string leftDict = "veh@driveby@first_person@driver@throw";
string drivebyDict = rightSide ? rightDict : leftDict;
Function.Call(Hash.TASK_PLAY_ANIM_ADVANCED, Character, Util.Util.LoadDict(drivebyDict),
"sweep_low", Character.Position.X, Character.Position.Y, Character.Position.Z, Character.Rotation.X,
Character.Rotation.Y, Character.Rotation.Z, -8f, -8f, -1, 0, rightSide ? 0.6f : 0.3f, 0, 0);
}
if (IsShooting)
{
Function.Call(Hash.SET_PED_INFINITE_AMMO_CLIP, Character, true);
Function.Call(Hash.SET_PED_AMMO, Character, CurrentWeapon, 10);
if (AimPlayer != null && AimPlayer.Position != null)
{
AimCoords = AimPlayer.Position;
AimPlayer = null;
}
if (!WeaponDataProvider.NeedsFakeBullets(CurrentWeapon))
{
Function.Call(Hash.SET_PED_SHOOTS_AT_COORD, Character, AimCoords.X, AimCoords.Y, AimCoords.Z,
true);
}
else if (DateTime.Now.Subtract(_lastRocketshot).TotalMilliseconds > 500)
{
_lastRocketshot = DateTime.Now;
var damage = WeaponDataProvider.GetWeaponDamage((WeaponHash)CurrentWeapon);
var speed = 0xbf800000;
var weaponH = (WeaponHash)CurrentWeapon;
if (IsFriend())
{
damage = 0;
}
var start = Character.GetBoneCoord(rightSide ? Bone.SKEL_R_Hand : Bone.SKEL_L_Hand);
var end = AimCoords;
Function.Call(Hash.SHOOT_SINGLE_BULLET_BETWEEN_COORDS, start.X, start.Y, start.Z,
end.X,
end.Y, end.Z, damage, true, (int)weaponH, Character, false, true, speed);
}
}
_lastVehicleAimUpdate = Game.GameTime;
_lastDrivebyShooting = IsShooting || IsAiming;
Ped PlayerChar = Game.Player.Character;
if (Function.Call <bool>(Hash.HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY, PlayerChar, Character, true))
{
int boneHit = -1;
var boneHitArg = new OutputArgument();
if (Function.Call <bool>(Hash.GET_PED_LAST_DAMAGE_BONE, PlayerChar, boneHitArg))
{
boneHit = boneHitArg.GetResult <int>();
}
LocalHandle them = new LocalHandle(Character.Handle, HandleType.GameHandle);
JavascriptHook.InvokeCustomEvent(api =>
api.invokeonLocalPlayerDamaged(them, CurrentWeapon, boneHit /*, playerHealth, playerArmor*/));
}
Function.Call(Hash.CLEAR_ENTITY_LAST_DAMAGE_ENTITY, Character);
Function.Call(Hash.CLEAR_ENTITY_LAST_DAMAGE_ENTITY, PlayerChar);
}
if (!IsShooting && !IsAiming && _lastDrivebyShooting && Game.GameTime - _lastVehicleAimUpdate > 200)
{
TaskInvoker task = Character.Task;
task.ClearAll();
task.ClearSecondary();
Function.Call(Hash.CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK, Character);
//Function.Call(Hash.TASK_DRIVE_BY, Character, 0, 0, 0, 0, 0, 0, 0, 0, 0);
//Function.Call(Hash.SET_DRIVEBY_TASK_TARGET, Character, 0, 0, 0, 0, 0);
task.ClearLookAt();
//GTA.UI.Screen.ShowNotification("Done shooting");
//GTA.UI.Screen.ShowSubtitle("Done Shooting1", 300);
_lastDrivebyShooting = false;
}
}
}
public override void Try(CircuitBreaker circuitBreaker)
{
TaskInvoker.InvokePlanified(
() => StateToggle.TryClose(this),
_TimeOut);
}
