653 lines
19 KiB
Plaintext
653 lines
19 KiB
Plaintext
note
|
|
description: "[
|
|
A {VIEW} that corresponds to the game board in Victory
|
|
In the Pacific (VITP). This view has widgets that hold
|
|
and allow control of game actions (e.g. movement, attacks,
|
|
repositions, etc) of game elements (e.g. ships, control
|
|
markers, ports, etc.)
|
|
]"
|
|
author: "Jimmy J. Johnson"
|
|
|
|
class
|
|
BOARD_VIEW
|
|
|
|
inherit
|
|
|
|
VITP_CELL_VIEW
|
|
redefine
|
|
create_interface_objects,
|
|
initialize,
|
|
add_actions,
|
|
set_target,
|
|
draw,
|
|
pick_notified_operations,
|
|
pick_ended_operations
|
|
end
|
|
|
|
FONT_AND_COLOR_CONSTANTS
|
|
export
|
|
{NONE}
|
|
all
|
|
undefine
|
|
default_create,
|
|
copy
|
|
end
|
|
|
|
POSITION_CONSTANTS
|
|
export
|
|
{NONE}
|
|
all
|
|
undefine
|
|
default_create,
|
|
copy
|
|
redefine
|
|
playing_area_ratio
|
|
end
|
|
|
|
create
|
|
make
|
|
|
|
feature {NONE} -- Initialization
|
|
|
|
create_interface_objects
|
|
-- Create objects to be used by `Current' in `initialize'
|
|
-- Implemented by descendants to create attached objects
|
|
-- in order to adhere to void-safety due to the implementation bridge pattern.
|
|
do
|
|
print ("BOARD_VIEW.create_interface_objects %N")
|
|
Precursor {VITP_CELL_VIEW}
|
|
print ("%T BOARD_VIEW.create_interface_objects before creating widget_factory %N")
|
|
create widget_factory.make (game)
|
|
print ("%T BOARD_VIEW.create_interface_objects after creatingh widget_factory %N")
|
|
-- create dot
|
|
-- create bounding_figure
|
|
-- Create for Void safety
|
|
-- create mouse_offset
|
|
create last_mouse_position
|
|
-- create containers
|
|
create task_force_widgets.make (100)
|
|
create highlighted_widgets.make
|
|
-- create the corner points used to determine the scale factor
|
|
create top_left_dot
|
|
create bottom_right_dot
|
|
-- create container for the grid cells (rows, columns)
|
|
-- create cell_array.make (playing_area_height // cell_size,
|
|
|
|
end
|
|
|
|
initialize
|
|
-- Called after `Default_create'
|
|
do
|
|
Precursor {VITP_CELL_VIEW}
|
|
-- world.extend (dragging_arrow)
|
|
-- dragging_arrow.hide
|
|
-- -- create the `handle'
|
|
-- create handle
|
|
-- world.extend (handle)
|
|
build_border
|
|
-- Attack widgets go on top of all other widgets except the dots
|
|
-- build_corner_dots
|
|
-- Place the dots from {POSITION_CONSTANTS} into Current
|
|
-- The dots move based on scaling of the view, allowing
|
|
-- cell positions to be determined regardless of the
|
|
-- actual size of the view.
|
|
add_widgets
|
|
world.extend (top_left_dot)
|
|
world.extend (bottom_right_dot)
|
|
end
|
|
|
|
add_widgets
|
|
-- Add the sea areas, ports, and unit widgets to the `world',
|
|
-- hiding the unit widgets until needed
|
|
local
|
|
wf: like widget_factory
|
|
t: like widget_factory.widgets
|
|
w: VITP_WIDGET
|
|
do
|
|
wf := widget_factory
|
|
-- Add sea areas first
|
|
t := wf.sea_area_widgets
|
|
from t.start
|
|
until t.after
|
|
loop
|
|
-- world.extend (t.item_for_iteration)
|
|
add_model (t.item_for_iteration)
|
|
t.forth
|
|
end
|
|
-- Add ports
|
|
t := wf.port_widgets
|
|
from t.start
|
|
until t.after
|
|
loop
|
|
-- world.extend (t.item_for_iteration)
|
|
add_model (t.item_for_iteration)
|
|
t.forth
|
|
end
|
|
-- Add unit widgets
|
|
t := wf.attack_widgets
|
|
from t.start
|
|
until t.after
|
|
loop
|
|
w := t.item_for_iteration
|
|
print ("{BOARD_VIEW}.add_widgets: Adding " + w.target.name + " at (" + w.x.out + ", " + w.y.out + ") %N")
|
|
-- world.extend (w)
|
|
add_model (w)
|
|
-- w.hide
|
|
t.forth
|
|
end
|
|
end
|
|
|
|
build_corner_dots
|
|
-- Create the two dots that will mark the top-left and bottom-right corners of
|
|
-- the board. These aid calculation of the current scaling factor and scolling
|
|
do
|
|
top_left_dot.set_x_y (playing_area_left, playing_area_top)
|
|
bottom_right_dot.set_x_y (playing_area_right, playing_area_bottom)
|
|
top_left_dot.set_line_width (10)
|
|
bottom_right_dot.set_line_width (10)
|
|
world.extend (top_left_dot)
|
|
world.extend (bottom_right_dot)
|
|
end
|
|
|
|
add_actions
|
|
-- Add actions to the widgets
|
|
local
|
|
w: ATTACK_UNIT_WIDGET
|
|
do
|
|
-- Do not call precursor
|
|
-- asia_widget.pointer_button_press_actions.force_extend (agent toggle_land)
|
|
-- pointer_motion_actions.extend (agent on_pointer_moved)
|
|
-- pointer_button_release_actions.extend (agent on_button_released)
|
|
end
|
|
|
|
build_border
|
|
-- Put a border around the game board to hide some of the land overhangs
|
|
local
|
|
poly: EV_MODEL_POLYGON
|
|
s: INTEGER
|
|
bw, bh: INTEGER_32
|
|
c: EV_COLOR
|
|
do
|
|
s := 5
|
|
c := Medium_grey
|
|
bw := board_width
|
|
bh := board_height
|
|
-- top
|
|
create poly.default_create
|
|
poly.set_line_width (0)
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, 0))
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, 0))
|
|
poly.set_background_color (c)
|
|
poly.set_foreground_color (c)
|
|
world.extend (poly)
|
|
-- botton
|
|
create poly.default_create
|
|
poly.set_line_width (0)
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, bh))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, bh))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, bh + s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, bh + s))
|
|
poly.set_background_color (c)
|
|
poly.set_foreground_color (c)
|
|
world.extend (poly)
|
|
-- left
|
|
create poly.default_create
|
|
poly.set_line_width (0)
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (0, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (0, bh + s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (-s, bh + s))
|
|
poly.set_background_color (c)
|
|
poly.set_foreground_color (c)
|
|
world.extend (poly)
|
|
-- right
|
|
create poly.default_create
|
|
poly.set_line_width (0)
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, -s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw + s, bh + s))
|
|
poly.extend_point (create {EV_COORDINATE}.make (bw, bh + s))
|
|
poly.set_background_color (c)
|
|
poly.set_foreground_color (c)
|
|
world.extend (poly)
|
|
end
|
|
|
|
feature -- Basic operations
|
|
|
|
set_target (a_item: like game)
|
|
-- Associate `a_item' with Current.
|
|
do
|
|
Precursor (a_item)
|
|
-- Build a polygon that defines the boundary of current for which we
|
|
-- find the centerpoint, the `dot'. Other widgets can then be built
|
|
-- and if desired placed in Current relative to `dot'
|
|
widget_factory.set_game (game)
|
|
-- paint
|
|
-- set_pebble (a_item)
|
|
-- set_accept_cursor (sub_pixmap (bounding_box))
|
|
end
|
|
|
|
draw
|
|
-- Redraw the view
|
|
-- This means the game has changed in some way
|
|
-- (e.g. a ship was added).
|
|
do
|
|
if not is_view_empty then
|
|
-- update_attack_widgets
|
|
-- should be no need to draw the whole view unless the game
|
|
-- was changed.
|
|
end
|
|
end
|
|
|
|
feature -- Access
|
|
|
|
widget_factory: ALL_WIDGETS_FACTORY
|
|
-- Holds all the widgets on the board
|
|
|
|
playing_area_ratio: REAL_64
|
|
-- Ratio of the playing_area_width' to the [possibly]
|
|
-- scaled size of the `playing_area_width'. Default = one,
|
|
-- but redefined here to use the distance between the
|
|
-- two corner dots.
|
|
do
|
|
Result := playing_area_width / (bottom_right_dot.x - top_left_dot.x)
|
|
end
|
|
|
|
feature -- Query
|
|
|
|
cell_at (a_x, a_y: INTEGER_32): VITP_CELL
|
|
-- The cell at the screen coordinates `a_x', `a_y'
|
|
local
|
|
x, y: INTEGER_32
|
|
do
|
|
x := ((a_x * playing_area_ratio) / cell_size).truncated_to_integer + 1
|
|
y := ((a_y * playing_area_ratio) / cell_size).truncated_to_integer + 1
|
|
Result := game.cell (x, y)
|
|
end
|
|
|
|
screen_coordinates (a_cell: VITP_CELL): TUPLE [x, y: INTEGER_32]
|
|
-- The screen coordinates corresponding to `a_cell'
|
|
local
|
|
x, y: INTEGER_32
|
|
do
|
|
x := ((a_cell.index.x * cell_size) / playing_area_ratio).truncated_to_integer
|
|
y := ((a_cell.index.y * cell_size) / playing_area_ratio).truncated_to_integer
|
|
Result := [x, y]
|
|
end
|
|
|
|
feature -- Status report
|
|
|
|
is_forwarding: BOOLEAN
|
|
-- Has a widget been brought to the top?
|
|
|
|
is_dragging: BOOLEAN
|
|
-- Are we in the process of sliding a widget or a group of widgets?
|
|
|
|
-- is_picking: BOOLEAN
|
|
-- -- Are we in the process of a pick-and-put operation?
|
|
|
|
is_repositioning: BOOLEAN
|
|
-- Is a widget being repositioned?
|
|
|
|
is_moving: BOOLEAN
|
|
-- Is a unit being moved to a new location?
|
|
|
|
is_highlighting: BOOLEAN
|
|
-- Is a widget or group of widgets being emphasized?
|
|
|
|
is_highlighting_location: BOOLEAN
|
|
-- Is one or more port widgets being emphasized?
|
|
|
|
is_highlighting_units: BOOLEAN
|
|
-- Is one or more unit widgets being emphasized?
|
|
|
|
is_highlighting_task_force: BOOLEAN
|
|
-- Is one or more {TASK_FORCE_WIDGET}s being emphasized?
|
|
|
|
is_processing_task_force: BOOLEAN
|
|
-- A {TASK_FORCE_WIDGET} is being clicked/move/released
|
|
|
|
feature -- Actions
|
|
|
|
pick_notified_operations (a_target: ANY)
|
|
-- React to the pick of `a_target' from some view
|
|
local
|
|
sop: like game.sequence_of_play
|
|
set: LINKED_SET [PORT]
|
|
p: PORT
|
|
pw: PORT_WIDGET
|
|
do
|
|
Precursor (a_target)
|
|
print ("{BOARD_VIEW}.pick_notified_operations on {" + generating_type.name + "}%N")
|
|
sop := game.sequence_of_play
|
|
if sop.is_reinforcement_step and then attached {ATTACK_UNIT} a_target as t then
|
|
set := t.reinforceable_ports
|
|
print ("%T undimming " + set.count.out + " areas %N")
|
|
from set.start
|
|
until set.after
|
|
loop
|
|
p := set.item
|
|
print ("%T%T making " + p.name + " brighter %N")
|
|
pw := widget_factory.port_widgets.definite_item (p)
|
|
pw.set_dimming_level ({DIMABLE}.bright)
|
|
pw.activate_drop_action
|
|
highlighted_widgets.extend (pw)
|
|
set.forth
|
|
end
|
|
-- application.process_graphical_events
|
|
end
|
|
end
|
|
|
|
pick_ended_operations
|
|
-- React to the end of a pick and drop operation
|
|
do
|
|
Precursor
|
|
print ("{BOARD_VIEW}.pick_ended_operations on {" + generating_type.name + "} %N")
|
|
from highlighted_widgets.start
|
|
until highlighted_widgets.after
|
|
loop
|
|
highlighted_widgets.item.deactivate_drop_action
|
|
highlighted_widgets.item.restore_dimming_level
|
|
highlighted_widgets.forth
|
|
end
|
|
highlighted_widgets.wipe_out
|
|
end
|
|
|
|
on_pointer_enter (a_widget: VITP_WIDGET)
|
|
-- React to a pointer entering `a_widget'
|
|
local
|
|
tfw: TASK_FORCE_WIDGET
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_pointer_enter: on " + a_widget.target.name + " %N")
|
|
-- if attached {ATTACK_UNIT_WIDGET} a_widget as w then
|
|
-- if w.unit.is_task_force then
|
|
-- tfw := task_force_widgets.widget (w.unit.task_force)
|
|
-- forward_widget_to_top (w, tfw)
|
|
-- end
|
|
-- end
|
|
end
|
|
|
|
on_pointer_leave (a_widget: VITP_WIDGET)
|
|
-- React to a pointer leaving a `a_widget'
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_pointer_leave: on " + a_widget.target.name + " %N")
|
|
-- if is_forwarding then
|
|
-- restore_forwarded_widget
|
|
-- end
|
|
end
|
|
|
|
on_button_pressed (a_widget: VITP_WIDGET; ax: INTEGER; ay: INTEGER; a_button: INTEGER)
|
|
-- React to a pointer button pressed notification from `a_widget'
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_button_pressed: button " + a_button.out +
|
|
" pressed at (" + ax.out + ", " + ay.out + ") on " + a_widget.target.name + " %N")
|
|
-- last_mouse_position.set_precise (ax, ay)
|
|
-- if is_forwarding then
|
|
-- restore_forwarded_widget
|
|
-- end
|
|
-- if a_button = 1 then
|
|
-- if attached {ATTACK_UNIT_WIDGET} a_widget as w then
|
|
-- highlight_unit (w.unit)
|
|
-- begin_widget_reposition (w, ax, ay)
|
|
-- elseif attached {LOCATION_WIDGET} a_widget as w then
|
|
-- highlight_location (w.location)
|
|
-- highlight_location_occupants (w.location)
|
|
-- end
|
|
-- end
|
|
end
|
|
|
|
on_button_double_pressed (a_widget: VITP_WIDGET; ax: INTEGER; ay: INTEGER; a_button: INTEGER)
|
|
-- React to a pointer button released notification from `a_widget'
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_button_double_pressed: button " + a_button.out +
|
|
" double-pressed at (" + ax.out + ", " + ay.out + ") on " + a_widget.target.name + "%N")
|
|
if a_button = 1 then
|
|
if attached {TASK_FORCE_WIDGET} a_widget as w and then
|
|
not w.point_on_bounding_figure (ax, ay) then
|
|
if w.is_stacked then
|
|
w.tile
|
|
else
|
|
w.stack
|
|
end
|
|
-- Next lines to prevent undesired movement
|
|
is_repositioning := false
|
|
end
|
|
end
|
|
end
|
|
|
|
on_button_released (a_widget: VITP_WIDGET; ax: INTEGER; ay: INTEGER; a_button: INTEGER)
|
|
-- React to a pointer button released notification from `a_widget'
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_button_released: button " + a_button.out + " pressed at (" + ax.out + ", " + ay.out + ") %N")
|
|
if is_highlighting_location then
|
|
normalize_locations
|
|
end
|
|
if is_highlighting_units then
|
|
normalize_units
|
|
end
|
|
if is_repositioning then
|
|
-- finish_widget_reposition
|
|
end
|
|
end
|
|
|
|
on_pointer_motion (a_widget: VITP_WIDGET; ax, ay: INTEGER)
|
|
-- React to a pointer move notification from `a_widget'
|
|
do
|
|
io.put_string ("BOARD_WORLD.on_notify_pointer_motion: at (" + ax.out + ", " + ay.out + ") %N")
|
|
-- if is_repositioning then
|
|
---- last_mouse_position.set_position (ax, ay)
|
|
-- -- Adjust for difference in the location of `active_widget' and `last_mouse_position'
|
|
---- if can_reposition (ax, ay) then
|
|
---- set_pointer_style (create {EV_POINTER_STYLE}.make_predefined ({EV_POINTER_STYLE_CONSTANTS}.Standard_cursor))
|
|
---- reposition_active_widget (ax, ay)
|
|
---- else
|
|
---- set_pointer_style (create {EV_POINTER_STYLE}.make_predefined ({EV_POINTER_STYLE_CONSTANTS}.No_cursor))
|
|
---- end
|
|
-- end
|
|
end
|
|
|
|
feature -- Basic operations
|
|
|
|
position_task_force_widget (a_widget: TASK_FORCE_WIDGET)
|
|
-- Place `a_widget' on the board so it does not overlap other
|
|
-- widgets, possibly moving other widgets.
|
|
do
|
|
|
|
end
|
|
|
|
position_widget (a_widget: ATTACK_UNIT_WIDGET)
|
|
-- Ensure each widget is postioned according to its position,
|
|
-- perhaps repositioning it to accomodate other widgets.
|
|
do
|
|
|
|
end
|
|
|
|
feature --{WIDGET_FACTORY} -- Basic operations
|
|
|
|
on_flip_widget (a_widget: SHIP_WIDGET)
|
|
-- Toggle the raiding status of `a_widget'
|
|
do
|
|
io.put_string ("on_flip_raider /n")
|
|
a_widget.flip
|
|
ensure
|
|
ship_status_toggled: a_widget.ship.is_raiding = not (old a_widget.ship.is_raiding)
|
|
end
|
|
|
|
board_coordinate_to_model_position (a_position: EV_COORDINATE): VITP_POSITION
|
|
-- `a_position' converted to the model's coordinate system
|
|
require
|
|
position_exists: a_position /= Void
|
|
local
|
|
brp, tlp: EV_COORDINATE
|
|
p: EV_COORDINATE
|
|
x_size, y_size: REAL_64
|
|
long, lat: REAL_64
|
|
do
|
|
p := a_position
|
|
brp := bottom_right_dot.point
|
|
tlp := top_left_dot.point
|
|
x_size := brp.x_precise - tlp.x_precise
|
|
y_size := brp.y_precise - tlp.y_precise
|
|
long := (p.x_precise - tlp.x_precise) * (board_right / x_size)
|
|
lat := (p.y_precise - tlp.y_precise) * (board_bottom / y_size)
|
|
create Result.set_xy (long.truncated_to_integer, lat.truncated_to_integer)
|
|
end
|
|
|
|
highlight_location (a_location: LOCATION)
|
|
-- Brighten the widget corresponding to `a_location'
|
|
require
|
|
location_exists: a_location /= Void
|
|
local
|
|
w: VITP_WIDGET
|
|
do
|
|
w := widget_factory.widgets.definite_item (a_location)
|
|
if world.has (w) then
|
|
w.set_dimming_level ({DIMABLE}.Bright)
|
|
w.paint
|
|
highlighted_widgets.extend (w)
|
|
is_highlighting_location := true
|
|
end
|
|
end
|
|
|
|
highlight_location_occupants (a_location: LOCATION)
|
|
-- Brighten the widgets corresponding to the occupants of `a_location'
|
|
require
|
|
location_exists: a_location /= Void
|
|
local
|
|
u_list: LINKED_SET [ATTACK_UNIT]
|
|
w: VITP_WIDGET
|
|
do
|
|
u_list := a_location.units
|
|
from u_list.start
|
|
until u_list.after
|
|
loop
|
|
w := widget_factory.widgets.definite_item (u_list.item)
|
|
w.set_dimming_level ({DIMABLE}.Bright)
|
|
w.paint
|
|
highlighted_widgets.extend (w)
|
|
u_list.forth
|
|
end
|
|
is_highlighting_units := true
|
|
end
|
|
|
|
highlight_unit (a_unit: ATTACK_UNIT)
|
|
-- Brighten the widget corresponding to `a_unit'
|
|
require
|
|
unit_exists: a_unit /= Void
|
|
local
|
|
tfw: TASK_FORCE_WIDGET
|
|
w: VITP_WIDGET
|
|
do
|
|
-- if a_unit.is_task_force then
|
|
-- tfw := task_force_widgets.widget (a_unit.task_force)
|
|
-- if tfw.is_stacked then
|
|
-- w := tfw
|
|
-- else
|
|
-- w := world.attack_widgets.widget (a_unit)
|
|
-- end
|
|
-- else
|
|
-- w := world.attack_widgets.widget (a_unit)
|
|
-- end
|
|
w := widget_factory.widgets.definite_item (a_unit)
|
|
w.set_dimming_level ({DIMABLE}.Bright)
|
|
w.paint
|
|
highlighted_widgets.extend (w)
|
|
is_highlighting_units := true
|
|
end
|
|
|
|
normalize_locations
|
|
-- Restor all location widgets to a normal brightness level
|
|
local
|
|
w: LOCATION_WIDGET
|
|
do
|
|
-- from world.location_widgets.start
|
|
-- until world.location_widgets.after
|
|
-- loop
|
|
-- w := world.location_widgets.item_for_iteration
|
|
-- w.set_dimming_level ({DIMABLE}.Normal)
|
|
-- w.paint
|
|
-- world.location_widgets.forth
|
|
-- end
|
|
-- is_highlighting_location := false
|
|
end
|
|
|
|
normalize_units
|
|
-- Restore all attack widgets to a normal brightness level
|
|
local
|
|
w: ATTACK_UNIT_WIDGET
|
|
do
|
|
-- from world.attack_widgets.start
|
|
-- until world.attack_widgets.after
|
|
-- loop
|
|
-- w := world.attack_widgets.item_for_iteration
|
|
-- w.set_dimming_level ({DIMABLE}.Normal)
|
|
-- w.paint
|
|
-- world.attack_widgets.forth
|
|
-- end
|
|
-- is_highlighting_units := false
|
|
end
|
|
|
|
feature --{VITP_WIDGET} -- Implementation
|
|
|
|
task_force_widgets: VITP_WIDGET_TABLE [TASK_FORCE_WIDGET, TASK_FORCE]
|
|
|
|
last_mouse_position: EV_COORDINATE
|
|
-- For possible restoration to the location where the reposition began
|
|
|
|
forwarded_widget: detachable ATTACK_UNIT_WIDGET
|
|
-- A widget that has been brought to the top of its owner
|
|
|
|
forwarded_widget_owner: detachable VITP_WIDGET
|
|
-- The widget in which `forwarded_widget' resides
|
|
|
|
highlighted_widgets: LINKED_SET [VITP_WIDGET]
|
|
-- The widgets with the focus
|
|
|
|
top_left_dot: EV_MODEL_DOT
|
|
-- A dot at top left of the board, that will scale and scroll with the view,
|
|
-- whose position when compared with `bottom_right_dot' provides a scale
|
|
-- factor used to position widgets
|
|
|
|
bottom_right_dot: EV_MODEL_DOT
|
|
-- See `top_left_dot'
|
|
|
|
feature {NONE} -- Implementation
|
|
|
|
-- X_stacking_increment: INTEGER
|
|
-- -- The distance in pixels to offset a stacked widget in the x direction
|
|
-- local
|
|
-- w: ATTACK_UNIT_WIDGET
|
|
-- do
|
|
-- -- Since we base this distance on the current size of a ship widget,
|
|
-- -- we must ensure we have a widget from which to calculate the value.
|
|
-- check not world.attack_widgets.is_empty then
|
|
-- w := world.attack_widgets.iteration_item (1)
|
|
---- Result := (w.tile_size / 10).rounded
|
|
-- Result := (w.tile_size / 10).rounded
|
|
-- end
|
|
-- end
|
|
|
|
-- Y_stacking_increment: INTEGER
|
|
-- -- The distance in pixels to offset a stacked widget in the x direction
|
|
-- local
|
|
-- w: ATTACK_UNIT_WIDGET
|
|
-- do
|
|
-- -- Since we base this distance on the current size of a ship widget,
|
|
-- -- we must ensure we have a widget from which to calculate the value.
|
|
-- check not world.attack_widgets.is_empty then
|
|
-- w := world.attack_widgets.iteration_item (1)
|
|
---- Result := (w.tile_size / 10).rounded
|
|
-- Result := (w.tile_size / 10).rounded
|
|
-- end
|
|
-- end
|
|
|
|
|
|
--feature {NONE} -- Implemetation
|
|
|
|
-- target_imp: detachable VITP_GAME
|
|
-- -- Detachable implementation of `target' for void safety
|
|
|
|
end
|