def draw_gui(self, camera, data, timeline):
io = imgui.get_io()
if not io.want_capture_mouse:
x = imgui.get_mouse_pos().x
y = camera.viewport()[1] - imgui.get_mouse_pos().y
p = camera.unproject(x, y)
i = timeline.intersect(p[0])
if i[0]:
date = timeline.index_date(i[1])
if date is not None:
df = data[data.Date == date]
wp = x + 20, camera.viewport()[1] - y - 100
imgui.set_next_window_position(wp[0], wp[1])
imgui.set_next_window_bg_alpha(0.8)
imgui.begin(
"pointer", False, imgui.WINDOW_NO_MOVE
| imgui.WINDOW_NO_TITLE_BAR | imgui.WINDOW_NO_RESIZE
| imgui.WINDOW_ALWAYS_AUTO_RESIZE)
imgui.text("Date: " + str(date))
for index, row in df.iterrows():
imgui.separator()
imgui.text(row["Pattern"] + ": " +
str(row["CandleTime"]))
imgui.end()
pass
def draw_table(data, *selected_row):
imgui.columns(len(data.columns) + 1, "##table")
imgui.separator()
imgui.text("")
imgui.next_column()
for c in data.columns:
imgui.text(c)
imgui.next_column()
imgui.separator()
# fill with data
i = 0
for _, row in data.iterrows():
label = str(i)
clicked, _ = imgui.selectable(label=label,
selected=selected_row == i,
flags=imgui.SELECTABLE_SPAN_ALL_COLUMNS,
)
if clicked:
selected_row = i
hovered = imgui.is_item_hovered()
imgui.next_column()
for c in data.columns:
imgui.text(row[c])
imgui.next_column()
i += 1
def render_alert(alertItem):
alert, count = alertItem
imgui.text(str(count))
imgui.next_column()
alert.render()
imgui.next_column()
imgui.separator()
def render(self, *args):
imgui.columns(2, 'fileLlist')
imgui.separator()
pathlist = os.listdir(os.curdir)
pathlist.insert(0, os.pardir)
pathlist.insert(0, os.curdir)
length = len(pathlist)
selected = [False] * length
for i in range(length):
_, selected[i] = imgui.selectable(pathlist[i], selected[i])
imgui.next_column()
size = os.path.getsize(pathlist[i])
imgui.text(str(size)+' byte')
imgui.next_column()
if(selected[i] is True):
self.path = os.path.abspath(pathlist[i])
print('clicked ' + pathlist[i])
if os.path.isdir(self.path):
os.chdir(self.path)
break
imgui.next_column()
imgui.columns(1)
return {'path': self.path}
def render_new_drawing_popup(window):
"Settings for creating a new drawing."
if window._new_drawing:
imgui.open_popup("New drawing")
w, h = window.get_size()
imgui.set_next_window_size(200, 120)
imgui.set_next_window_position(w // 2 - 100, h // 2 - 60)
if imgui.begin_popup_modal("New drawing")[0]:
imgui.text("Creating a new drawing.")
imgui.separator()
changed, new_size = imgui.drag_int3("Shape",
*window._new_drawing["shape"],
min_value=1,
max_value=2048)
if changed:
window._new_drawing["shape"] = new_size
if imgui.button("OK"):
window.really_create_drawing()
imgui.close_current_popup()
imgui.same_line()
if imgui.button("Cancel"):
window._new_drawing = None
imgui.close_current_popup()
imgui.end_popup()
def draw(self):
imgui.begin("Example: Columns - File list")
imgui.columns(4, 'fileList')
imgui.separator()
imgui.text("ID")
imgui.next_column()
imgui.text("File")
imgui.next_column()
imgui.text("Size")
imgui.next_column()
imgui.text("Last Modified")
imgui.next_column()
imgui.separator()
imgui.set_column_offset(1, 40)
imgui.next_column()
imgui.text('FileA.txt')
imgui.next_column()
imgui.text('57 Kb')
imgui.next_column()
imgui.text('12th Feb, 2016 12:19:01')
imgui.next_column()
imgui.next_column()
imgui.text('ImageQ.png')
imgui.next_column()
imgui.text('349 Kb')
imgui.next_column()
imgui.text('1st Mar, 2016 06:38:22')
imgui.next_column()
imgui.columns(1)
imgui.end()
def to_imgui(self, file_entry: FileEntry, padding: int):
for entry in file_entry.entries:
start, end = self.range_for_entry(entry, padding)
for i in range(start, end + 1):
if i >= self.max_line:
break
text = self.content[i]
in_range = i in range(entry.begin_line, entry.end_line + 1)
if in_range:
imgui.push_style_color(imgui.COLOR_TEXT, 0.0, 1.0, 0.0)
imgui.text("{0:03d} {1}".format(i, text))
if in_range:
imgui.pop_style_color(1)
if entry is not file_entry.entries[-1]:
imgui.spacing()
imgui.separator()
imgui.spacing()
def update(self):
bitmap = self._renderer.bitmap
if bitmap is None:
return
imgui.begin("Tiny Renderer")
imgui.image(bitmap.get_texture_id(), bitmap.get_width(),
bitmap.get_height())
imgui.end()
imgui.begin("Rendering")
_, self._render_mode = imgui.combo("Rendering Mode", self._render_mode,
self._render_mode_captions)
_, self._light_mode = imgui.combo("Lighting Mode", self._light_mode,
self._light_mode_captions)
imgui.separator()
if imgui.button("Render"):
t = time.time()
self.on_click_render()
self._time_to_render = time.time() - t
imgui.label_text("", f"Time to render: {self._time_to_render: .2f}s")
imgui.separator()
imgui.end()
def _show_custom_ui(self):
preview = "<none>"
if self.connected_node is not None:
preview = self.connected_node.name
if imgui.begin_combo("", preview):
nodes = self.SetVar.instances[self.graph.parent]
is_selected = self.connected_node is None
opened, selected = imgui.selectable("<none>", is_selected)
if opened:
self.name = ""
if is_selected:
imgui.set_item_default_focus()
imgui.separator()
for node in sorted(nodes, key=lambda node: node.name):
if not node.valid:
continue
is_selected = node == self.connected_node
opened, selected = imgui.selectable(node.name, is_selected)
if opened:
self.name = node.name
if is_selected:
imgui.set_item_default_focus()
imgui.end_combo()
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(512, 512, imgui.ONCE)
imgui.begin("Example: simple popup modal")
if imgui.button("Open Modal popup"):
imgui.open_popup("select-popup")
imgui.same_line()
if imgui.begin_popup_modal("select-popup")[0]:
imgui.text("Select an option:")
imgui.separator()
imgui.selectable("One")
imgui.selectable("Two")
imgui.selectable("Three")
imgui.end_popup()
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def _draw_component(self, entity, component_name, component_name_display):
if not entity.has_component(component_name):
return
treeNodeFlags = imgui.TREE_NODE_DEFAULT_OPEN | imgui.TREE_NODE_FRAMED | imgui.TREE_NODE_ALLOW_ITEM_OVERLAP | imgui.TREE_NODE_FRAME_PADDING
component = entity.get_component(component_name)
# contentRegionAvailable = imgui.get_content_region_available()
# lineHeight =
imgui.push_style_var(imgui.STYLE_FRAME_PADDING, (4, 4))
imgui.separator()
open = imgui.tree_node(component_name_display, treeNodeFlags)
imgui.pop_style_var()
# TODO imgui.same_line(contentRegionAvailable.x - lin)
imgui.same_line()
if imgui.button("+"):
imgui.open_popup("ComponentSettings")
removeComponent = False
if imgui.begin_popup("ComponentSettings"):
if menu_item_clicked("Remove component"):
removeComponent = True
imgui.end_popup()
if open:
getattr(self, "_draw_component_%s" % component_name)(component)
imgui.tree_pop()
if removeComponent:
entity.remove_component(component_name)
def onDrawGuiCallback(self, args):
if self.visible:
if imgui.begin("Combat Assist##combatassist_mainwindo", (450,300)):
player = BigWorld.player()
imgui.text("Combat script : ")
selectedChanged, self.combatSelectedIndex = imgui.combo("##combatassist_combatcombo", self.combatSelectedIndex, combats.LOADED_COMBATS.keys())
if selectedChanged:
combats.LOADED_COMBATS.keys()[self.combatSelectedIndex]
self.combatRotationName = combats.LOADED_COMBATS.keys()[self.combatSelectedIndex]
roplus.log("Using combat script : " + self.combatRotationName)
imgui.sameLine()
if imgui.button("Reload##grinder_reload_scripts", (imgui.getContentRegionAvail()[0], 24)):
combats.reloadCombatModules()
imgui.separator()
if self.combatSelectedIndex == -1:
imgui.text("Select a combat script first ...")
else:
if imgui.checkbox("Enable combat", self.rotationEnabled):
self.rotationEnabled = not self.rotationEnabled
if imgui.checkbox("Only attack in combat targets", self.combatCheck):
self.combatCheck = not self.combatCheck
if imgui.checkbox("Allow combat script to use movements", self.handleMovements):
self.handleMovements = not self.handleMovements
if imgui.checkbox("Automatically target attackers (Not implemented)", self.autoTargetEnemies):
self.autoTargetEnemies = not self.autoTargetEnemies
imgui.end()
def main():
window = impl_glfw_init()
impl = GlfwRenderer(window)
font_scaling_factor = fb_to_window_factor(window)
io = impl.io
# clear font atlas to avoid downscaled default font
# on highdensity screens. First font added to font
# atlas will become default font.
io.fonts.clear()
# set global font scaling
io.font_global_scale = 1. / font_scaling_factor
# dictionary of font objects from our font directory
fonts = {
os.path.split(font_path)[-1]: io.fonts.add_font_from_file_ttf(
font_path, FONT_SIZE_IN_PIXELS * font_scaling_factor,
io.fonts.get_glyph_ranges_latin())
for font_path in FONTS_DIR
}
secondary_window_main_font = random.choice(list(fonts.values()))
impl.refresh_font_texture()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.begin("Window with multiple custom fonts", True)
imgui.text("This example showcases font usage on text() widget")
for font_name, font in fonts.items():
imgui.separator()
imgui.text("Font:{}".format(font_name))
with imgui.font(font):
imgui.text("This text uses '{}' font.".format(font_name))
imgui.end()
with imgui.font(secondary_window_main_font):
imgui.begin("Window one main custom font", True)
imgui.text("This window uses same custom font for all widgets")
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def render_alert(alertItem):
alert, count = alertItem
if not alert in ignoredAlerts:
imgui.text(str(count))
imgui.next_column()
alert.render()
imgui.next_column()
imgui.separator()
def ProgramInfoPopup():
with imgui.font(largefont):
imgui.text("軟體資訊")
imgui.separator()
imgui.bullet_text("版本: 0.1 alpha")
imgui.bullet_text("開發: PUF STUDIO")
imgui.bullet_text("Email: [email protected]")
imgui.bullet_text("Git Repo: https://github.com/even311379/PdfParserGUI")
def _render_gui(self):
w, h = self.get_size()
imgui.new_frame()
if self.stroke_tool and self.stroke_tool.show_rect:
if self.stroke_tool.rect:
rect = self.stroke_tool.rect
p0 = self._to_window_coords(*rect.topleft)
p1 = self._to_window_coords(*rect.bottomright)
ui.render_selection_rectangle(self, p0, p1)
with imgui.font(self._font):
ui.render_menu(self)
if self.drawing:
imgui.set_next_window_size(115, h - 20)
imgui.set_next_window_position(w - 115, 20)
imgui.begin("Sidebar",
False,
flags=(imgui.WINDOW_NO_TITLE_BAR
| imgui.WINDOW_NO_RESIZE
| imgui.WINDOW_NO_MOVE))
ui.render_tools(self.tools, self.icons)
imgui.separator()
ui.render_palette(self.drawing)
imgui.separator()
ui.render_layers(self.view)
imgui.end()
ui.render_unsaved_exit(self)
ui.render_unsaved_close_drawing(self)
render_plugins_ui(self.drawing)
ui.render_new_drawing_popup(self)
if self._error:
imgui.open_popup("Error")
if imgui.begin_popup_modal("Error")[0]:
imgui.text(self._error)
if imgui.button("Doh!"):
self._error = None
imgui.close_current_popup()
imgui.end_popup()
imgui.render()
imgui.end_frame()
data = imgui.get_draw_data()
self.imgui_renderer.render(data)
def _show_custom_context(self):
# called from ui-node to add custom entries in nodes context menu
# called only when that context menu is visible
has_state = len(self.spec.initial_state) != 0
has_presets = len(self.spec.presets) != 0
if has_state:
imgui.separator()
if imgui.button("reset state"):
self.reset_state(force=True)
imgui.same_line()
if imgui.button("randomize state"):
self.randomize_state(force=True)
changed, self.allow_state_randomization = imgui.checkbox(
"allow state randomization", self.allow_state_randomization)
if has_presets:
imgui.separator()
if imgui.button("default preset"):
self.reset_preset(force=True)
imgui.same_line()
if imgui.button("random preset"):
self.randomize_preset(force=True)
imgui.same_line()
if imgui.button("choose preset..."):
imgui.open_popup("choose_preset")
if imgui.begin_popup("choose_preset"):
for name, values in self.spec.presets:
if imgui.button(name):
self.set_preset(values)
imgui.end_popup()
changed, self.allow_preset_randomization = imgui.checkbox(
"allow preset randomization", self.allow_preset_randomization)
if imgui.button("copy current as preset"):
# copy only keys that are contained in (first) preset
# TODO see how this behavior works
keys = None if not has_presets else list(
self.spec.presets[0][1].keys())
values = OrderedDict()
for port_id, value in self.values.items():
if not is_input(port_id):
continue
name = port_name(port_id)
if keys is not None and name not in keys:
continue
values[name] = value.value
preset = ["name", values]
clipboard.copy(json.dumps(preset))
def _edit_field_arcs(self, field_geometry: GeometryFieldSize):
while len(self._field_arc_expanded) < len(field_geometry.field_arcs):
self._field_arc_expanded.append(False)
while len(self._field_arc_expanded) > len(field_geometry.field_arcs):
del self._field_arc_expanded[-1]
imgui.text("Field Arcs")
imgui.separator()
arcs_to_delete = []
for i, arc in enumerate(field_geometry.field_arcs):
expanded, visible = imgui.collapsing_header(
arc.name,
True,
imgui.TREE_NODE_DEFAULT_OPEN
if self._field_arc_expanded[i] else 0,
)
if not visible:
arcs_to_delete.append(i)
if expanded:
self._field_arc_expanded[i] = True
changed, value = imgui.input_text(f"Name##{i}", arc.name, 255)
if changed:
arc.name = value
changed, values = imgui.input_float2("Center", arc.center.x,
arc.center.y)
if changed:
arc.center.x, arc.center.y = values
changed, values = imgui.input_float(f"Radius##{i}", arc.radius)
if changed:
if value > 0:
arc.radius = value
else:
self._log.error(
f"Arc radius must be > 0. Got {arc.radius}")
changed, values = imgui.input_float2(
f"Start Angle, End Angle##{i}", arc.a1, arc.a2)
if changed:
arc.a1, arc.a2 = sorted(values)
changed, value = imgui.input_float(f"Thickness##{i}",
arc.thickness)
if changed:
if value > 0:
arc.thickness = value
else:
self._log.error("Field arc must have thickness > 0. "
f"Got {arc.thickness}")
for arc in arcs_to_delete[::-1]:
del field_geometry.field_arcs[arc]
del self._field_arc_expanded[arc]
if imgui.button("Add field arc"):
new_arc = field_geometry.field_arcs.add()
new_arc.radius = 1000
new_arc.thickness = 10
self._field_arc_expanded.append(False)
def render(self, *args):
if 'fileInfo' in args[0][0][0]:
self.info = args[0][0][0]['fileInfo'][0]
imgui.columns(2, 'info')
imgui.separator()
for name in self.info:
imgui.text(name)
imgui.next_column()
imgui.text(self.info[name])
imgui.next_column()
imgui.columns(1)
return {}
def show_outputs_popup(iggraph):
if imgui.begin_popup_modal("Outputs")[0]:
output_nodes = iggraph.get_output_nodes()
for output_node in output_nodes:
if imgui.tree_node(output_node.inputs["parameter name"].text):
value = output_node.outputs["output"]
display_parameter(value,True)
imgui.tree_pop()
imgui.separator()
if imgui.button("ok"):
imgui.close_current_popup()
imgui.end_popup()
def __call__(self, ball_filter: BasicBallFilter):
if not self.visible:
return
_, self.visible = imgui.begin("Ball Filter Controls", True)
rerun_filter = imgui.button("Rerun Filter")
changed, value = imgui.input_float("Start timestamp",
self.start_timestamp)
if changed:
self.is_dirty = True
self.start_timestamp = value
self._draw_initial_state()
self._draw_initial_P()
imgui.separator()
changed, value = imgui.input_float("Friction deceleration",
ball_filter.friction_decel)
if changed:
if value >= 0:
self.is_dirty = True
ball_filter.friction_decel = value
else:
self._log.error(
f"Friction deceleration must be >= 0. Got {value}")
changed, value = imgui.input_float("Friction deadzone",
ball_filter.friction_deadzone,
format="%e")
if changed:
if value >= 0:
self.is_dirty = True
ball_filter.friction_deadzone = value
else:
self._log.error(f"Friction deadzone must be >= 0. Got {value}")
changed, value = imgui.input_float("Process Variance",
ball_filter.process_variance)
if changed:
if value >= 0:
self.is_dirty = True
ball_filter.process_variance = value
else:
self._log.error(f"Process variance must be >= 0. Got {value}")
self._draw_R(ball_filter)
imgui.end()
return rerun_filter
def ParserStaticsWidget():
imgui.push_text_wrap_position(600)
if os.path.isfile('ParseResult.log'):
with imgui.font(largefont):
imgui.text("結果")
with open('ParseResult.log', 'r') as f:
imgui.text(f.read())
imgui.separator()
imgui.text("Run a hierarchical clustering to check how many potential groups?")
if imgui.button("RUN"):
subprocess.run(["python","Subprocesses/CheckGroup.py"])
else:
imgui.text("尚未解析推甄資料中的成績單內容")
def draw(self):
imgui.begin(self.title)
imgui.text("Some text with bullets")
imgui.bullet_text("Bullet A")
imgui.bullet_text("Bullet A")
imgui.separator()
imgui.text("Another text with bullets")
imgui.bullet_text("Bullet A")
imgui.bullet_text("Bullet A")
imgui.end()
def configurationInterface(self):
imgui.text_wrapped(self.description)
imgui.spacing()
if not self.started:
if imgui.button("Start"):
self.start()
else:
if imgui.button("Stop"):
self.stop()
imgui.spacing()
imgui.separator()
imgui.spacing()
def _edit_field_lines(self, field_geometry: GeometryFieldSize):
while len(self._field_line_expanded) < len(field_geometry.field_lines):
self._field_line_expanded.append(False)
while len(self._field_line_expanded) > len(field_geometry.field_lines):
del self._field_line_expanded[-1]
imgui.text("Field Lines")
imgui.separator()
lines_to_delete = []
for i, line in enumerate(field_geometry.field_lines):
expanded, visible = imgui.collapsing_header(
f"{line.name}##{i}",
True,
imgui.TREE_NODE_DEFAULT_OPEN
if self._field_line_expanded[i] else 0,
)
if not visible:
lines_to_delete.append(i)
if expanded:
self._field_line_expanded[i] = True
changed, value = imgui.input_text(f"Name##{i}", line.name, 255)
if changed:
line.name = value
changed, values = imgui.input_float2(f"P1##{i}", line.p1.x,
line.p1.y)
if changed:
line.p1.x, line.p1.y = values[0], values[1]
changed, values = imgui.input_float2(f"P2##{i}", line.p2.x,
line.p2.y)
if changed:
line.p2.x, line.p2.y = values[0], values[1]
changed, value = imgui.input_float(f"Thickness##{i}",
line.thickness)
if changed:
if value > 0:
line.thickness = value
else:
self._log.error("Field line must have thickness > 0. "
f"Got {line.thickness}")
else:
self._field_line_expanded[i] = False
for line in lines_to_delete[::-1]:
del field_geometry.field_lines[line]
del self._field_line_expanded[line]
if imgui.button("Add field line"):
new_line = field_geometry.field_lines.add()
new_line.thickness = 10
self._field_line_expanded.append(False)
def render(self):
imgui.columns(2, 'alertList')
imgui.set_column_offset(1, 45)
imgui.text("Count")
imgui.next_column()
imgui.text("Alert")
imgui.next_column()
imgui.separator()
# ToDo: In the future dont revert this, and simple have it lock scroll
# to bottom like a terminal? Might be more effort than it's worth.
list(map(render_alert, reversed(alerts.items())))
imgui.text("Count")
imgui.next_column()
imgui.text("Alert")
imgui.next_column()
imgui.columns(1)
def _edit_field_size(self, field_geometry: GeometryFieldSize):
imgui.text("Field Size")
imgui.separator()
# Field Length
changed, value = imgui.input_int("Field Length",
field_geometry.field_length)
if changed:
if value >= 0:
field_geometry.field_length = value
else:
self._log.error(
f"Field length cannot be negative. Got {value}.")
# Field Width
changed, value = imgui.input_int("Field Width",
field_geometry.field_width)
if changed:
if value >= 0:
field_geometry.field_width = value
else:
self._log.error(
f"Field width cannot be negative. Got {value}.")
# Goal Width
changed, value = imgui.input_int("Goal Width",
field_geometry.goal_width)
if changed:
if value >= 0:
field_geometry.goal_width = value
else:
self._log.error(f"Goal width cannot be negative. Got {value}.")
# Goal Depth
changed, value = imgui.input_int("Goal Depth",
field_geometry.goal_depth)
if changed:
if value >= 0:
field_geometry.goal_depth = value
else:
self._log.error(f"Goal depth cannot be negative. Got {value}.")
# Boundary Width
changed, value = imgui.input_int("Boundary Width",
field_geometry.boundary_width)
if changed:
if value >= 0:
field_geometry.boundary_width = value
else:
self._log.error(
f"Boundary width cannot be negative. Got {value}.")
def draw(self):
imgui.begin("Example: simple popup modal")
if imgui.button("Open Modal popup"):
imgui.open_popup("select-popup")
imgui.same_line()
if imgui.begin_popup_modal("select-popup")[0]:
imgui.text("Select an option:")
imgui.separator()
imgui.selectable("One")
imgui.selectable("Two")
imgui.selectable("Three")
imgui.end_popup()
imgui.end()
def draw(self):
imgui.begin("Example: simple popup")
if imgui.button("select"):
imgui.open_popup("select-popup")
imgui.same_line()
if imgui.begin_popup("select-popup"):
imgui.text("Select one")
imgui.separator()
imgui.selectable("One")
imgui.selectable("Two")
imgui.selectable("Three")
imgui.end_popup()
imgui.end()
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(512, 512, imgui.ONCE)
imgui.begin("Example: Columns - File list")
imgui.columns(4, 'fileLlist')
imgui.separator()
imgui.text("ID")
imgui.next_column()
imgui.text("File")
imgui.next_column()
imgui.text("Size")
imgui.next_column()
imgui.text("Last Modified")
imgui.next_column()
imgui.separator()
imgui.set_column_offset(1, 40)
imgui.next_column()
imgui.text('FileA.txt')
imgui.next_column()
imgui.text('57 Kb')
imgui.next_column()
imgui.text('12th Feb, 2016 12:19:01')
imgui.next_column()
imgui.next_column()
imgui.text('ImageQ.png')
imgui.next_column()
imgui.text('349 Kb')
imgui.next_column()
imgui.text('1st Mar, 2016 06:38:22')
imgui.next_column()
imgui.columns(1)
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def onDrawGuiCallback(self, *args, **kw):
if self.window_visable:
try:
if imgui.begin('AutoLoot {0} - {1}##Entity_mainwindow'.format(autoloot.__version__, autoloot.__author__), (600,350)):
# button bar
if imgui.checkbox('Enable Auto-Loot', self.enabled_auto_loot):
self.enabled_auto_loot = not self.enabled_auto_loot
if imgui.collapsingHeader('Available Loot ({0} items)'.format(len(self.bot.items))):
imgui.columns(4)
for item in self.bot.items:
if not item:
continue
imgui.text(item.roleName)
imgui.nextColumn()
if item.__module__ == 'DroppedItem':
try:
imgui.text('Lootable' if item._checkPickItem(self.bot.p) else 'Not Lootable')
except AttributeError:
imgui.text('Not _checkPickItem')
else:
imgui.text('Openable?')
imgui.nextColumn()
imgui.text('{0}'.format(self.bot.p.position.distTo(item.position)))
imgui.nextColumn()
if imgui.button('Go To {0}##NavToEntity'.format(item.__module__)):
nav.moveToEntityPathFind(item)
imgui.nextColumn()
imgui.separator()
imgui.columns(1)
if imgui.collapsingHeader('Debug All Entities'):
for entity_name, entities in sorted(self.bot.entities.iteritems()):
for entity in entities:
imgui.columns(5)
imgui.separator()
imgui.text('{0}'.format(entity_name))
imgui.nextColumn()
imgui.text('{0}'.format(entity.id))
imgui.nextColumn()
if entity_name == 'DroppedItem' and hasattr(entity, '_checkPickItem') and entity._checkPickItem(self.bot.p):
imgui.text('{0}'.format('Lootable'))
elif not entity_name == 'DroppedItem':
imgui.text('No Data Available')
else:
imgui.text('Not your Loot!')
imgui.nextColumn()
if entity and hasattr(entity, 'position') and self.bot.p and hasattr(self.bot.p, 'position'):
imgui.text('{0}'.format(self.bot.p.position.distTo(entity.position)))
else:
imgui.text('No Position Information')
imgui.nextColumn()
if imgui.button('NavToEntity##NavToEntity'):
nav.moveToEntityPathFind(entity)
imgui.nextColumn()
imgui.columns(1)
imgui.end()
except Exception:
import traceback
for line in traceback.format_exc().splitlines():
roplus.log(line)
self.window_visable = False
