I need to make the main menu where I can press 1 to play one game and 2 to another game. I already have two while loops for games, but have no idea how to write it in one code.
You can separate each of the game's main loops with functions. First you can create a GUI window. One of the most common and easy GUI windows to use is tkinter. Import it at the top of you code with from tkinter import *. You could create a simple GUI like this:
global window
window = Tk()
window.title("Choose Game")
GAbutton = Button(window, text="Game One", width=10, command=GameOne)
GAbutton.grid(row=0, column=0, sticky=W)
GBbutton = Button(window, text="Game Two", width=10, command=GameTwo)
GBbutton.grid(row=1, column=0, sticky=W)
The command is the name of the function. Full code could look like:
from tkinter import *
import pygame
def GameOne():
window.destroy()
#Your first game goes here
def GameTwo():
window.destroy()
#Your second game goes here
global window
window = Tk()
window.title("Choose Game")
GAbutton = Button(window, text="Game One", width=10, command=GameOne)
GAbutton.grid(row=0, column=0, sticky=W)
GBbutton = Button(window, text="Game Two", width=10, command=GameTwo)
GBbutton.grid(row=1, column=0, sticky=W)
All you need to do is to make sure that each game is in the same indentation level as the comment.
Related
With pyautogui I'm trying to locate a object in a screenshot that is being taken but I can't find a way
from pyautogui import *
import pyautogui
import time
import keyboard
import random
import win32api, win32con
time.sleep(2)
ims = pica = pyautogui.screenshot(region=(569,381,800,450))
iml = pyautogui.screenshot(region=(1040,295,100,30))
def click(x,y):
win32api.SetCursorPos((x,y))
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,0,0)
#Color of center: (255, 219, 195)
while keyboard.is_pressed('q') == False:
flag = 0
pyautogui.screenshot(region=(1040,295,100,30))
ims.save(r"C:\Users\Billy Bong\Desktop\python\saveimage.png")
pica = pyautogui.screenshot(region=(569,381,800,450))
ims.save(r"C:\Users\Billy Bong\Desktop\python\saveimage2.png")
time.sleep (2)
pyautogui.locateAllOnScreen("saveimage.png", confidence=0.6)
print (cords)
pyautogui.click (cords)
time.sleep (10)
break
Here is the minimal code for locating an object on the screen, you should have the image of the object.
import pyautogui as py
import keyboard
while True:
img = py.locateOnScreen("object.png", confidence=0.9) # add path to your object image here
print(img)
if keyboard.is_pressed('q'):
break
there is something i found out about pyautogui if u gonna use locateonscreen or locateallonscreen the image u asking him to locate must be in same folder u running the script from (according to my experience from using VS-code) and idk if there is a way to tell it to set a path for the image u wanna search to (something) so for the current time make sure u include all images u search for in same folder that the script is running from for me it is (E:\coding\game) cuz i make auto bots for games i like
btw locateallonscreenn prints out a list, the "cords" but idk if "pyautogui.click (cords)
" understand that and if it is going to click all the x,y in cords or not
I am trying to display both an image and a box with an Entry widget. I can do that, but the window is so large that the widget at the bottom is mostly out of view. I have tried several calls to set the window's size or unmaximize it, but they seem to have no effect. I determined that the problem only occurs when the image is large, but still wonder how to display a large image in a resizable window or, for that matter, to make any changes to the window's geometry from code. All the function call I tried seem to have no effect.
Here is my code:
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from gi.repository import GdkPixbuf
from urllib.request import urlopen
class Display(object):
def __init__(self):
self.window = Gtk.Window()
self.window.connect('destroy', self.destroy)
self.window.set_border_width(10)
# a box underneath would be added every time you do
# vbox.pack_start(new_widget)
vbox = Gtk.VBox()
self.image = Gtk.Image()
response = urlopen('http://1.bp.blogspot.com/-e-rzcjuCpk8/T3H-mSry7PI/AAAAAAAAOrc/Z3XrqSQNrSA/s1600/rubberDuck.jpg').read()
pbuf = GdkPixbuf.PixbufLoader()
pbuf.write(response)
pbuf.close()
self.image.set_from_pixbuf(pbuf.get_pixbuf())
self.window.add(vbox)
vbox.pack_start(self.image, False, False, 0)
self.entry = Gtk.Entry()
vbox.pack_start(self.entry, True,True, 0)
self.image.show()
self.window.show_all()
def main(self):
Gtk.main()
def destroy(self, widget, data=None):
Gtk.main_quit()
a=Display()
a.main()
Most of the posted information seems to pertain to Gtk2 rather than Gtk3, but there is a solution: to use a pix buf loader and set the size:
from gi.repository import Gtk, Gdk, GdkPixbuf
#more stuff
path = config['DEFAULT']['datasets']+'working.png'
with open(path,'rb') as f:
pixels = f.read()
loader = GdkPixbuf.PixbufLoader()
loader.set_size(400,400)
loader.write(pixels)
pb = GdkPixbuf.Pixbuf.new_from_file(path)
self.main_image.set_from_pixbuf(loader.get_pixbuf())
loader.close()
I want to be able to change C++ display text from an HTML txt file, is this possible to do?
your issue is your using pack and grid. pack and grid do the same thing but grid lets you choose where to put it. you can only use one or the other in a canvas. also you had hello and goodbye in the same spot on grid(). heres your fixed code:
from tkinter import *
from tkinter import ttk
label = None
def change1():
global label
label.config(text="Hello World!")
def change2():
global label
label.config(text="Goodbye World!")
def main():
global label
rootWindow = Tk()
label = ttk.Label(rootWindow, text="Hello World!")
label.grid(row=0, column=0)
button1 = ttk.Button(rootWindow, text="Hello!", command=change1)
button1.grid(row=0, column=1)
button2 = ttk.Button(rootWindow, text="Bye!", command=change2)
button2.grid(row=0, column=2)
rootWindow.mainloop()
main()
your problem is that you are using both .grid() and .pack() the difference is that in .grid you can choose where to put your button or whatever while in .pack() it places it automatically. this is why I will recommend you to use the .grid() option.
I'm having trouble creating widgets in a Jupyter notebook that update when other widget values are changed. This is the code I've been playing around with:
from ipywidgets import interact, interactive, fixed
import ipywidgets as widgets
from IPython.display import display
def func(arg1,arg2):
print arg1
print arg2
choice = widgets.ToggleButtons(description='Choice:',options=['A','B'])
display(choice)
metric = widgets.Dropdown(options=['mercury','venus','earth'],description='Planets:')
text = widgets.Text(description='Text:')
a = interactive(func,
arg1=metric,
arg2=text,
__manual=True)
def update(*args):
if choice.value == 'A':
metric = widgets.Dropdown(options=['mercury','venus','earth'],description='Planets:')
text = widgets.Text(description='Text:')
a.children = (metric,text)
else:
metric = widgets.Dropdown(options=['monday','tuesday','wednesday'],description='Days:')
text2 = widgets.Textarea(description='Text2:')
a.children = (metric,text2)
choice.observe(update,'value')
display(a)
The resulting widgets metric and text do change based whether A or B is selected, but the problem is that the "Run func" button goes away as soon as I change to B. I've tried adding the __manual attribute immediately before display(a), adding it within update, and several other places. How do I change the children of the widget box without overwriting the fact that I want to manually run the function?
I am trying to find the simplest example of a custom widget being written for Gtk-3.
So far the best thing I've found is this (using PyGTK), but it seems to be targeted to Gtk-2.
BTW: I don't care the language it is written in, but if we can avoid C++, much better!
Python3 Gtk3 it is, then:
from gi.repository import Gtk
class SuperSimpleWidget(Gtk.Label):
__gtype_name__ = 'SuperSimpleWidget'
Here is a non-trivial example that actually does something, namely paints its background and draws a diagonal line through it. I'm inheriting from Gtk.Misc instead of Gtk.Widget to save some boilerplate (see below):
class SimpleWidget(Gtk.Misc):
__gtype_name__ = 'SimpleWidget'
def __init__(self, *args, **kwds):
super().__init__(*args, **kwds)
self.set_size_request(40, 40)
def do_draw(self, cr):
# paint background
bg_color = self.get_style_context().get_background_color(Gtk.StateFlags.NORMAL)
cr.set_source_rgba(*list(bg_color))
cr.paint()
# draw a diagonal line
allocation = self.get_allocation()
fg_color = self.get_style_context().get_color(Gtk.StateFlags.NORMAL)
cr.set_source_rgba(*list(fg_color));
cr.set_line_width(2)
cr.move_to(0, 0) # top left of the widget
cr.line_to(allocation.width, allocation.height)
cr.stroke()
Finally, if you really want to derive from Gtk.Widget then you also have to set up a drawing background. Gtk.Misc does that for you, but Gtk.Widget could be a container that doesn't actually draw anything itself. But inquiring minds want to know, so you could do it like so:
from gi.repository import Gdk
class ManualWidget(Gtk.Widget):
__gtype_name__ = 'ManualWidget'
def __init__(self, *args, **kwds):
# same as above
def do_draw(self, cr):
# same as above
def do_realize(self):
allocation = self.get_allocation()
attr = Gdk.WindowAttr()
attr.window_type = Gdk.WindowType.CHILD
attr.x = allocation.x
attr.y = allocation.y
attr.width = allocation.width
attr.height = allocation.height
attr.visual = self.get_visual()
attr.event_mask = self.get_events() | Gdk.EventMask.EXPOSURE_MASK
WAT = Gdk.WindowAttributesType
mask = WAT.X | WAT.Y | WAT.VISUAL
window = Gdk.Window(self.get_parent_window(), attr, mask);
self.set_window(window)
self.register_window(window)
self.set_realized(True)
window.set_background_pattern(None)
Edit and to actually use it:
w = Gtk.Window()
w.add(SimpleWidget())
w.show_all()
w.present()
import signal # enable Ctrl-C since there is no menu to quit
signal.signal(signal.SIGINT, signal.SIG_DFL)
Gtk.main()
Or, more fun, use it directly from the ipython3 REPL:
from IPython.lib.inputhook import enable_gtk3
enable_gtk3()
w = Gtk.Window()
w.add(SimpleWidget())
w.show_all()
w.present()
Here's a tutorial about writing a GTK 3 custom container widget in C: http://ptomato.name/advanced-gtk-techniques/html/custom-container.html It's probably more complicated than you need for writing a simple widget. You might also check out the migration guide from GTK 2 to 3: https://developer.gnome.org/gtk3/stable/gtk-migrating-2-to-3.html
SO far the best reference to:
- understand Gobject (from wich gtk widget derive)
- have some boiler code and c code
https://developer.gnome.org/gobject/stable/howto-gobject.html
I know it's not Python written, but converting from c to python is a piece of cake
(what matter is the algorithm, not the language)