Program.cs

usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}
usingButtplug.Client;
usingButtplug.Core;
usingButtplug.Core.Messages;
usingButtplug.Client.Connectors.WebsocketConnector;
usingLanguageExt;
usingstaticLanguageExt.Prelude;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Threading.Tasks;
usingSystem.Threading;
usingSystem.IO;

namespaceskybutt
{
internalclassProgram
{
privatestaticasyncTaskWaitForKey()
{
Console.WriteLine("Press any key to continue.");
while(!Console.KeyAvailable)
{
awaitTask.Delay(1);
}
Console.ReadKey(true);
}

privatestaticasyncTaskRunExample(stringlogFile)
{
// Now that we've seen all of the different parts of Buttplug, let's
// put them together in a small program.
//
// This program will:
// - Create an embedded (or possibly websocket) connector
// - Scan, this time using real Managers, so we'll see devices
// (assuming you have them hooked up)
// - List the connected devices for the user
// - Let the user select a device, and trigger some sort of event on
// that device (vibration, thrusting, etc...).

// As usual, we start off with our connector setup. We really don't
// need access to the connector this time, so we can just pass the
// created connector directly to the client.
//var client = new ButtplugClient("skybutt client",
// new ButtplugEmbeddedConnector("skybutt server"));

// If you want to use a websocket client and talk to a websocket
// server instead, uncomment the following line and comment the one
// above out. Note you will need to turn off TLS/SSL on the server.

varclient=newButtplugClient("skybutt client",new
ButtplugWebsocketConnector(newUri("ws://localhost:12345/buttplug")));

awaitclient.ConnectAsync();

// At this point, if you want to see everything that's happening,
// uncomment this block to turn on logging. Warning, it might be
// pretty spammy.

// void HandleLogMessage(object aObj, LogEventArgs aArgs) {
// Console.WriteLine($"LOG: {aArgs.Message.LogMessage}"); }
// client.Log += HandleLogMessage; await client.RequestLogAsync(ButtplugLogLevel.Debug);

// Now we scan for devices. Since we didn't add any Subtype Managers
// yet, this will go out and find them for us. They'll be reported in
// the logs as they are found.
//
// We'll scan for devices, and print any time we find one.
voidHandleDeviceAdded(objectaObj,DeviceAddedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceAdded+=HandleDeviceAdded;

voidHandleDeviceRemoved(objectaObj,DeviceRemovedEventArgsaArgs)
{
Console.WriteLine($"Device connected: {aArgs.Device.Name}");
}

client.DeviceRemoved+=HandleDeviceRemoved;

// The structure here is gonna get a little weird now, because I'm
// using method scoped functions. We'll be defining our scanning
// function first, then running it just to find any devices up front.
// Then we'll define our command sender. Finally, with all of that
// done, we'll end up in our main menu

// Here's the scanning part. Pretty simple, just scan until the user
// hits a button. Any time a new device is found, print it so the
// user knows we found it.
asyncTaskScanForDevices()
{
Console.WriteLine("Scanning for devices until key is pressed.");
Console.WriteLine("Found devices will be printed to console.");
awaitclient.StartScanningAsync();
awaitWaitForKey();

// Stop scanning now, 'cause we don't want new devices popping up anymore.
awaitclient.StopScanningAsync();
}

// Scan for devices before we get to the main menu.
awaitScanForDevices();

// Now we define the device control menus. After we've scanned for
// devices, the user can use this menu to select a device, then
// select an action for that device to take.
asyncTaskControlDevice()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintvaginalDeviceChoice;
if(options.Length()==1)
{
vaginalDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose vaginal device: ");
if(!uint.TryParse(Console.ReadLine(),outvaginalDeviceChoice)||
!options.Contains(vaginalDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}
uintanalDeviceChoice;
if(options.Length()==1)
{
analDeviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose anal device: ");
if(!uint.TryParse(Console.ReadLine(),outanalDeviceChoice)||
!options.Contains(analDeviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

varvaginalDevice=client.Devices.First(dev =>dev.Index==vaginalDeviceChoice);
foreach(varminvaginalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

varanalDevice=client.Devices.First(dev =>dev.Index==analDeviceChoice);
foreach(varminanalDevice.AllowedMessages)
{
Console.WriteLine($"Device message: {m.Key} -> {m.Value}");
}

Console.WriteLine("Watching Controller Rumble log file");
awaitWatchLogFileAsync(logFile,client,vaginalDevice,analDevice);
}

asyncTaskControlDeviceRandom()
{
// Controlling a device has 2 steps: selecting the device to
// control, and choosing which command to send. We'll just list
// the devices the client has available, then search the device
// message capabilities once that's done to figure out what we
// can send. Note that this is using the Device Index, which is
// assigned by the device manager and may not be sequential
// (which is why we can't just use an array index).

// Of course, if we don't have any devices yet, that's not gonna work.
if(!client.Devices.Any())
{
Console.WriteLine("No devices available. Please scan for a device.");
return;
}

varoptions=newList<uint>();

foreach(vardevinclient.Devices)
{
Console.WriteLine($"{dev.Index}. {dev.Name}");
options.Add(dev.Index);
}
uintdeviceChoice;
if(options.Length()==1)
{
deviceChoice=client.Devices.Head().Index;
}else
{
Console.WriteLine("Choose a device: ");
if(!uint.TryParse(Console.ReadLine(),outdeviceChoice)||
!options.Contains(deviceChoice))
{
Console.WriteLine("Invalid choice");
return;
}
}

vardevice=client.Devices.First(dev =>dev.Index==deviceChoice);

awaitRunRandom(client,device);
}

// And finally, we arrive at the main menu. We give the user the
// choice to scan for more devices (in case they forgot to turn them
// on earlier or whatever), run a command on a device, or just quit.
while(true)
{
Console.WriteLine("1. Scan For More Devices\n2. Run Skyrim vibrator\n3. Randomly vibrate\n4. Quit\nChoose an option: ");
if(!uint.TryParse(Console.ReadLine(),outvarchoice)||
(choice==0||choice>4))
{
Console.WriteLine("Invalid choice, try again.");
continue;
}

switch(choice)
{
case1:
awaitScanForDevices();
continue;
case2:
awaitControlDevice();
continue;
case3:
awaitControlDeviceRandom();
continue;
case4:
return;

default:
// Due to the check above, we'll never hit this, but eh.
continue;
}
}
}

staticasyncTaskRunRandom(ButtplugClientclient,ButtplugClientDevicedevice)
{
varrnd=newRandom();
while(true)
{
vardelay=rnd.NextDouble()*0.5+rnd.NextDouble()*rnd.NextDouble()*10.0;
try
{
if(IsVorze(device))
{
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(rnd.Next(101)),rnd.Next(2)==0?true:false);
}else
{
boolshouldStop=rnd.NextDouble()<0.35;
doublestrength=shouldStop?0:rnd.NextDouble();
awaitdevice.SendVibrateCmd(strength);
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine($"Device error: {e}");
device=awaitAttemptReconnect(client,device);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
device=awaitAttemptReconnect(client,device);
}
awaitTask.Delay(TimeSpan.FromSeconds(delay));
}
}

staticasyncTask<ButtplugClientDevice>AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
Console.WriteLine("Attempting to reconnect device"+device.Name);
awaitclient.StartScanningAsync();
returnawait_AttemptReconnect(client,device);
}

staticasyncTask<ButtplugClientDevice>_AttemptReconnect(ButtplugClientclient,ButtplugClientDevicedevice)
{
awaitTask.Delay(500);
vardeviceOption=client.Devices.Find(d =>d.Name.Equals(device.Name));
returnawaitdeviceOption.Match((ButtplugClientDeviced)=>
{
client.StopScanningAsync();
returnTask.FromResult(d);
},async()=>
{
returnawait_AttemptReconnect(client,device);
});
}

staticasyncTaskWatchLogFileAsync(stringfilename,ButtplugClientclient,ButtplugClientDevicevaginalDevice,ButtplugClientDeviceanalDevice)
{
varwh=newAutoResetEvent(false);
varfsw=newFileSystemWatcher(".");
fsw.Filter=filename;
fsw.EnableRaisingEvents=true;
fsw.Changed+=(s,e)=>wh.Set();

varfs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
fs.Seek(0,SeekOrigin.End);

// Watch the file
VibrateStatuscurrentSetting=VibrateStatus.Stopped();
using(varsr=newStreamReader(fs))
{
while(true)
{
// Reset position for new file
if(fs.Position>fs.Length)
fs.Seek(0,SeekOrigin.Begin);

strings=sr.ReadLine();
if(s!=null)
{
boolisAnal=s.Contains("JNAnal");
boolisVaginal=s.Contains("JNVaginal");
if(isAnal||isVaginal)
{
vardeviceToSendTo=isAnal?analDevice:vaginalDevice;
Either<Exception,VibrateCommand>vlOrE=ParseVibrateLine(s);
Console.WriteLine("[RumbleLog] "+vlOrE);
awaitvlOrE.Match(async vl =>
{
try
{
if(vlisVibrateStart)
{
currentSetting=awaitHandleVibrateStart(deviceToSendTo,vlasVibrateStart,currentSetting);
}
elseif(vlisVibrateStop)
{
awaitHandleVibrateStop(deviceToSendTo);
currentSetting=VibrateStatus.Stopped();
}
}
catch(ButtplugDeviceExceptione)
{
Console.WriteLine(e);
Console.WriteLine("Device disconnected.");
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
catch(Exceptione)
{
Console.WriteLine("Unknown exception, attempting reconnect anyway. Exception: "+e);
deviceToSendTo=awaitAttemptReconnect(client,deviceToSendTo);
}
},async e =>Console.WriteLine(e));
}
}
else
{
wh.WaitOne(10);
}
}
}

// TODO end loop
//wh.Close();
}

privatestaticasyncTask<VibrateStatus>HandleVibrateStart(ButtplugClientDevicedevice,VibrateStartvs,VibrateStatusstatus)
{
if(IsVorze(device))
{
varnewDirection=random(2)==0?true:false;
awaitdevice.SendVorzeA10CycloneCmd(Convert.ToUInt32(vs.strength*100),newDirection);
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVorzeA10CycloneCmd(StrengthToVorzeRotation(status.strength),status.direction);
returnstatus;
},()=>newVibrateStatus(vs.strength,newDirection));
}
else
{
awaitdevice.SendVibrateCmd(vs.strength);
// TODO handle intervals
returnawaitvs.time.MatchAsync(async time =>
{
awaitTask.Delay(time);
awaitdevice.SendVibrateCmd(status.strength);
returnstatus;
},()=>newVibrateStatus(vs.strength,false));
}
}

privatestaticboolIsVorze(ButtplugClientDevicedevice)
{
returndevice.AllowedMessages.ContainsKey(typeof(VorzeA10CycloneCmd));
}

privatestaticUInt32StrengthToVorzeRotation(doublestrength)
{
returnConvert.ToUInt32(Math.Pow(strength,2)*80);
}

privatestaticasyncTaskHandleVibrateStop(ButtplugClientDevicedevice)
{
awaitdevice.StopDeviceCmd();
}

staticEither<Exception,VibrateCommand>ParseVibrateLine(strings)
{
Arr<string>parts=newArr<string>(s.ToLower().Split(' '));
if(parts.Contains("start"))
{
Map<string,string>dict=newMap<string,string>(parts.Filter(s_ =>s_.Contains("=")).Map(p =>
{
string[]pp=p.Split('=');
return(pp.First(),pp.Last());
}));
try
{
returnRight<VibrateCommand>(newVibrateStart(
dict["type"],dict.Find("time").Map(Double.Parse),dict.Find("interval").Map(Double.Parse),Double.Parse(dict["strength"])));
}
catch(Exceptione)
{
returnLeft(e);
}
}
elseif(parts.Contains("stop"))
returnRight<VibrateCommand>(newVibrateStop());
else
returnRight<VibrateCommand>(newVibrateNone());
}

classVibrateStatus
{
publicdoublestrength;
publicbooldirection;

publicVibrateStatus(doublestrength,booldirection)
{
this.strength=strength;
this.direction=direction;
}

publicstaticVibrateStatusStopped()
{
returnnewVibrateStatus(0,true);
}
}

interfaceVibrateCommand{}

classVibrateStart:VibrateCommand
{
privateconstdoubleStrengthFactor=100;
publicstringtype;
publicOption<TimeSpan>time;
publicOption<TimeSpan>interval;
publicdoublestrength;

publicVibrateStart(stringtype,Option<double>time,Option<double>interval,doublestrength)
{
this.type=type;
this.time=time.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.interval=interval.Bind(t =>t==-1?None:Some(TimeSpan.FromSeconds(t)));
this.strength=strength/StrengthFactor;
}

publicoverridestringToString()
{
return"VibrateStart(type: "+type+", time: "+time+", strength: "+strength+")";
}
}

classVibrateStop:VibrateCommand{}

classVibrateNone:VibrateCommand{}

// Since not everyone is probably going to want to run under C# 7.1+,
// we'll use a non-async Main and call to a Wait()'d task. C# 8 can't
// come soon enough.
privatestaticvoidMain()
{
stringlogFile=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"My Games","Skyrim","Logs","Script","User","Controller Rumble.0.log");
// Setup a client, and wait until everything is done before exiting.
RunExample(logFile).Wait();
}
}
}