async def init_buttplug():
nonlocal dev
client = ButtplugClient('Waves Client')
connector = ButtplugClientWebsocketConnector('ws://127.0.0.1:12345')
client.device_added_handler += on_device_added
await client.connect(connector)
with warnings.catch_warnings():
warnings.simplefilter('ignore', category=RuntimeWarning)
client.request_log('Off')
await client.start_scanning()
while dev == None:
await asyncio.sleep(0.5)
await client.stop_scanning()
log.debug('device ready')
return client
async def main():
global devices
global client
global connector
client = ButtplugClient("League of Legends")
connector = CustomWebsocketConnection("ws://127.0.0.1:12345")
client.device_added_handler += device_added
client.device_removed_handler += device_removed
try:
await client.connect(connector)
except ButtplugClientConnectorError as e:
print("Could not connect to server (check Intiface desktop), exiting: {}".format(e.message))
return
await scan_and_pick_device()
queue = SimpleQueue()
queue2 = SimpleQueue()
lol = League_Thread(queue)
lol.start()
bu = Buttplug_Thread(queue, chosen_device, queue2)
bu.start()
while True:
item = queue2.get()
#print(item)
if item == "stop":
await chosen_device.send_stop_device_cmd()
else:
await chosen_device.send_vibrate_cmd(item)
async def vibrate(self, intensity=0.5, duration=0.3):
self.intensity = intensity
self.duration = duration
# create client
client = ButtplugClient(self.name)
# connect to websocket of the intiface
connector = ButtplugClientWebsocketConnector(self.ws)
# add event handler
client.device_added_handler += self.device_added
# asyncio
# connect to device
try:
await client.connect(connector)
except ButtplugClientConnectorError as e:
print("Could not connect to server, exiting: {}".format(e.message))
return
# get logs
await client.request_log(ButtplugLogLevel.debug)
# search for devices
await client.start_scanning()
# wait
task = asyncio.create_task(self.cancel_me())
try:
await task
except asyncio.CancelledError:
pass
# ctrl-c -> stop
await client.stop_scanning()
# Now that we've done that, we just disconnect and we're done!
await client.disconnect()
def __init__(self):
self.running = False
self.level = 0
self.last_sent_level = 0
# B******g Client
self.bp_client = ButtplugClient('Drone Control 1')
self.bp_connector = ButtplugClientWebsocketConnector(
'ws://127.0.0.1:12345')
self.bp_device = None
self.bp_client.device_added_handler += self._device_added
self.bp_client.device_removed_handler += self._device_removed
asyncio.get_event_loop().run_until_complete(
self._init_buttplug_client())
def __init__(self):
self.running = False
self.level = 0
self.last_sent_level = 0
# Required for Kontroller
self.kontrol = None
self.channel = None
# B******g Client
self.bp_client = ButtplugClient("Drone Control 1")
self.bp_connector = ButtplugClientWebsocketConnector(
"ws://127.0.0.1:12345")
self.bp_device = None
threading.Thread(target=self._init_buttplug_client_thread,
daemon=True).start()
logging.debug("Buttvibe Started")
async def main():
# And now we're in the main function.
#
# First, we'll need to set up a client object. This is our conduit to the
# server.
#
# We create a Client object, passing it the name we want for the client.
# Names are shown in things like the Intiface Desktop Server GUI.
client = ButtplugClient("Test Client")
# Now we have a client called "Test Client", but it's not connected to
# anything yet. We can fix that by creating a connector. Connectors
# allow clients to talk to servers through different methods, including:
#
# - Websockets
# - IPC (Not currently available in Python)
# - WebRTC (Not currently available in Python)
# - TCP/UDP (Not currently available in Python)
#
# For now, all we've implemented in python is a Websocket connector, so
# we'll use that.
connector = ButtplugClientWebsocketConnector("ws://127.0.0.1:12345")
# This connector will connect to Intiface Desktop on the local machine,
# using the default port for insecure websockets.
#
# There's one more step before we connect to a client, and that's
# setting up an event handler.
client.device_added_handler += device_added
client.device_removed_handler += device_removed
# Whenever we connect to a client, we'll instantly get a list of devices
# already connected (yes, this sometimes happens, mostly due to windows
# weirdness). We'll want to make sure we know about those.
#
# Finally, we connect.
try:
await client.connect(connector)
except ButtplugClientConnectorError as e:
logging.error("Could not connect to server, exiting: {}".format(
e.message))
return
# If this succeeds, we'll be connected. If not, we'll probably have some
# sort of exception thrown of type ButtplugClientConnectorException
#
# Let's receive log messages, since they're a handy way to find out what
# the server is doing. We can choose the level from the ButtplugLogLevel
# object.
# await client.request_log(ButtplugLogLevel.info)
# Now we move on to looking for devices.
await client.start_scanning()
# This will tell the server to start scanning for devices, and returns
# while it's scanning. If we get any new devices, the device_added_task
# function that we assigned as an event handler earlier will be called.
#
# Since everything interesting happens after devices have connected, now
# all we have to do here is wait. So we do, asynchronously, so other things
# can continue running. Now that you've made it this far, go look at what
# the device_added_task does.
task = asyncio.create_task(cancel_me())
try:
await task
except asyncio.CancelledError:
pass
# Ok so someone hit Ctrl-C or something and we've broken out of our task
# wait. Let's tell the server to stop scanning.
await client.stop_scanning()
# Now that we've done that, we just disconnect and we're done!
await client.disconnect()
logging.info("Disconnected, quitting")
def __init__(self, bot):
self.bot = bot
self.buttplug_client = ButtplugClient("Lewd Bot")