Combinatorial Optimization in Casino Floor Layouts: Route Entropy, Facility Assignment, and Player-Flow Simulation

Abstract

Floor layout in a casino is normally talked about in concrete terms: where the slots go, how the table pits are arranged, how wide the aisles need to be, and which routes carry guests past the higher-value games. Underneath those decisions sits a genuinely hard mathematical problem, because a gaming floor has to reconcile facility layout, pedestrian movement, sightlines, surveillance, regulatory access, labor control, and player behavior that nobody can predict with much confidence. This paper models the floor as a weighted spatial graph and treats game placement as a constrained Quadratic Assignment Problem. Route-choice entropy supplies a measure of spatial uncertainty, and agent-based simulation lets alternative layouts be compared before anything is physically moved. An illustrative study sets grid, pod, and hybrid layouts against each other for a floor of 300 slot machines, 24 table games, and four anchor points. The findings track a trade-off operators already recognize: arrangements that raise exploration and game exposure tend to raise congestion and erode surveillance clarity at the same time. Rather than hunting for one optimal arrangement, then, layout optimization is better framed as an evidence-based way of testing feasible trade-offs against commercial, regulatory, operational, and responsible-gaming constraints.

1. Introduction

A casino floor is a working system that has to move people, expose them to games, support its own staff, protect assets, keep regulators satisfied, and stay comfortable enough that guests want to linger. The layouts that manage all this tend to look effortless, which disguises how much deliberate work goes into them. Put a table pit too far from the cage and fills and credits slow down. Tuck a strong slot bank behind a bad sightline and it underperforms regardless of how good the machines are. Draw an aisle that looks efficient on paper and discover it chokes the moment a concert lets out or a weekend promotion lands.

Stated plainly, the design problem is this:

Given a fixed gaming area, a set of gaming assets, guest routes, service routes, surveillance requirements, and regulatory constraints, how should games and amenities be arranged so that the floor performs well without becoming confusing, unsafe, or operationally inefficient?

Taste alone will not answer that, and neither will a single formula. The floor behaves like a spatial network, with entrances, cashier areas, slot banks, table pits, bars, restrooms, and exits serving as nodes, and walkways and sightlines serving as edges. What any one location is worth depends in large part on how it sits relative to everything else.

The model developed here brings four tools to bear on that structure. Graph theory describes the floor. Route-choice entropy measures how uncertain navigation is. Combinatorial optimization formalizes the placement decision. Agent-based simulation tests how a candidate layout is likely to behave. None of this is meant to displace the judgment of experienced operators; the aim is to give that judgment something it can be tested against.

2. Literature Review

2.1 Facility Layout Problem

The Facility Layout Problem concerns where to place departments, machines, service points, or activity zones inside a bounded space. Operations research has long treated spatial arrangement as a leading driver of system performance, since it shapes movement cost, process time, safety, and utilization (Drira, Pierreval, and Hajri-Gabouj, 2007).

Casino design sits inside this family but carries a few features that ordinary facility problems do not. The relevant “flow” is voluntary patron movement rather than material or staff routing. Revenue turns on exposure, attention, comfort, and the games a guest chooses to try. And the arrangement has to clear surveillance, internal-control, responsible-gaming, accessibility, and emergency-egress requirements simultaneously. What looks like a layout problem is really a layout problem wrapped in behavioral, regulatory, and security layers.

2.2 Quadratic Assignment Problem

Koopmans and Beckmann (1957) introduced the Quadratic Assignment Problem to model the assignment of indivisible activities to locations, and its relevance to casino floors is direct. A game’s value is not fixed by its own position alone; it is shaped by what surrounds it.

A progressive slot bank set beside a major walkway can feed on the passing traffic. A high-limit area can lose its appeal if it sits too close to noisy low-denomination play. A cashier route placed well supports table operations and placed badly creates congestion. These are interaction effects, and once they enter the model the problem stops resembling a tidy ranking of locations and turns considerably harder.

That difficulty is formal. Sahni and Gonzalez (1976) showed that several related approximation problems are computationally hard, and the QAP has stayed a textbook example of intractability in combinatorial optimization. The consequence for casino work is concrete: a large floor may hold hundreds or thousands of assignable assets, and computing an exact optimum is generally out of reach. The question worth asking is therefore which feasible layouts perform better under defensible assumptions, not which layout is perfect.

2.3 Space Syntax and Movement

Space syntax examines how spatial configuration drives movement. Hillier, Penn, Hanson, Grajewski, and Xu (1993) argued that the structure of a street grid generates natural movement patterns even before land use enters the picture, and the same reasoning carries indoors. Some paths become important simply because of how entrances, anchors, exits, and amenities connect to one another.

For an operator, the lesson is that a machine’s worth should not be read off square footage or distance from the door. It should be read off how the location participates in the whole circulation system. A weak-looking corner can earn its keep if it falls on the route between a restaurant and a restroom, while a visually central bank can languish if guests rarely have any reason to pass it.

2.4 Pedestrian-Flow Modeling

Pedestrian-flow models estimate how people travel through built environments. The Helbing and Molnar social-force model treats pedestrians as individuals with desired directions, avoidance behavior, boundary effects, and pull toward destinations (Helbing and Molnar, 1995). A casino guest is obviously not a particle, but the model earns its place because congestion, bottlenecks, queue spillover, and avoidance are everyday operating realities.

The relationship between traffic and value is non-linear. A degree of crowding generates energy; too much of it produces discomfort, slows service, blocks sightlines, and pushes guests away from a zone altogether. The objective on a good floor is to manage traffic density, not to pile up as much of it as possible.

2.5 Casino Environmental Psychology

Environmental psychology has also taken up casino design. Finlay, Kanetkar, Londerville, and Marmurek (2006) studied how gambling environments shape emotional response, and their work matters because it pushes back on the crude assumption that a casino should simply be maze-like. A measure of complexity can invite exploration, but confusion past a certain point chips away at comfort and perceived control.

The distinction is worth holding onto. A floor can err by being too obvious, and it can err just as badly by being too bewildering. Forcing guests to wander may buy short-term exposure at the cost of comfort and long-term value. What design should aim for is controlled discovery rather than maximum disorientation.

2.6 Responsible Gambling and the Built Environment

Responsible gambling is usually framed around staff training, self-exclusion, and information programs, all of which are necessary, but the built environment does its own share of the work. The American Gaming Association’s Responsible Gaming Code of Conduct stresses responsible operations, customer information, training, and consumer protection (American Gaming Association, 2026). Translated into floor design, that argues for building responsible-gaming safeguards into the model from the start rather than bolting them on once the revenue plan is settled.

In practice a responsible layout keeps exits legible, steers clear of deliberately disorienting circulation, preserves staff visibility, keeps responsible-gaming information in view, and stops short of arranging every cash-access point so that the gambling experience loses any natural pause. A floor can be commercially effective without becoming coercive.

2.7 Agent-Based Modeling in Retail and Casino Spaces

Agent-based modeling earns its keep wherever large patterns grow out of many small individual decisions. In retail and entertainment settings, simulated agents can be handed preferences, walking costs, budgets, fatigue thresholds, and response probabilities. Casino patrons are heterogeneous in just this way: a destination blackjack player, a low-denomination slot player, a hosted premium guest, and a diner heading to a restaurant move through the same floor along very different paths.

Simulation of this kind lets layouts be stress-tested before construction, yielding estimates of exposure, congestion, route choice, game conversion, and operational friction. It is not, however, proof of anything. It carries weight only once it has been calibrated against observation, transaction data, occupancy counts, loyalty-card activity, surveillance review, and the knowledge of floor staff.

3. Spatial Graph Model

Let the casino floor be represented as a weighted graph:

[ G=(V,E,w) ]

where (V) is the set of spatial nodes, (E) is the set of navigable connections, and (w) is a weight function assigning cost to each connection.

The node set may be divided into:

[ V=V_G\cup V_A\cup V_S\cup V_C\cup V_E ]

where (V_G) represents gaming nodes, (V_A) amenity nodes, (V_S) service and staff nodes, (V_C) surveillance-relevant nodes, and (V_E) emergency-egress nodes.

Each edge (e=(u,v)) may be assigned a generalized movement cost:

[ w_{uv}=\delta_{uv}+\lambda_1 c_{uv}+\lambda_2 \theta_{uv}+\lambda_3 o_{uv}+\lambda_4 r_{uv} ]

Here, (\delta_{uv}) is walking distance, (c_{uv}) is expected congestion, (\theta_{uv}) is turning cost, (o_{uv}) is visual obstruction, and (r_{uv}) is general route resistance. The coefficients (\lambda_1,\ldots,\lambda_4) allow the model to be calibrated to the property.

This graph structure permits standard network measures. Betweenness centrality identifies locations that sit on many important paths:

[ B(v)=\sum_{s\neq v\neq t}\frac{\sigma_{st}(v)}{\sigma_{st}} ]

where (\sigma_{st}) is the number of shortest or plausible paths between (s) and (t), and (\sigma_{st}(v)) is the number of those paths passing through (v).

High betweenness is valuable, though not uniformly so. A high-betweenness area suits impulse slot play or promotional displays, yet the same spot may be a poor home for premium table games, which need privacy, a slower pace, and tighter host control.

4. Route-Choice Entropy

Layout discussions sometimes reach loosely for “metric entropy,” but the precise term here is route-choice entropy. Shannon’s information theory gives the standard measure of uncertainty (Shannon, 1948). If a patron standing at node (v) faces (d(v)) possible next routes and chooses route (i) with probability (p_i), local route-choice entropy is:

[ H(v)=-\sum_{i=1}^{d(v)}p_i\log_2 p_i ]

A normalized version is:

[ \widehat{H}(v)=\frac{H(v)}{\log_2 d(v)} ]

for (d(v)>1). A value near zero means movement is predictable; a value near one means the choice among available routes is wide open.

The measure is useful precisely because it separates two layouts that fail in opposite ways. A strictly linear floor is easy to read but does little to invite exploration. A heavily fragmented floor sparks curiosity yet risks leaving guests confused or worn out. The aim is not to maximize entropy but to land inside a range: enough route variety to create discovery, not so much that the floor becomes uncomfortable or hard to run.

A floor-level entropy measure can be written as:

[ E(\pi)=\sum_{v\in V}\mu_v(\pi)\widehat{H}(v) ]

where (\mu_v(\pi)) is the expected visitation probability of node (v) under layout (\pi).

5. Game Placement as a Quadratic Assignment Problem

Let (I={1,\ldots,n}) be the set of gaming assets and (L={1,\ldots,n}) the set of feasible locations. Define:

[ x_{il}= \begin{cases} 1, & \text{if asset } i \text{ is assigned to location } l
0, & \text{otherwise} \end{cases} ]

The assignment constraints are:

[ \sum_{l\in L}x_{il}=1 \quad \forall i\in I ]

[ \sum_{i\in I}x_{il}=1 \quad \forall l\in L ]

Let (a_{ij}) represent the interaction between assets (i) and (j), and let (d_{lm}) represent the spatial relationship between locations (l) and (m). The quadratic component is:

[ \sum_{i=1}^{n}\sum_{j=1}^{n}\sum_{l=1}^{n}\sum_{m=1}^{n}a_{ij}d_{lm}x_{il}x_{jm} ]

This is the structure of the QAP described by Koopmans and Beckmann (1957).

Proposition: Casino Placement Contains QAP as a Special Case

If pairwise game-location interactions are included, the casino placement problem contains QAP as a special case and is therefore NP-hard.

Proof sketch. Take a simplified floor on which each asset is assigned to exactly one location and each location receives exactly one asset, and set aside congestion, surveillance, accessibility, and responsible-gaming constraints. Let the objective reduce to:

[ Z(\pi)=\sum_{i=1}^{n}\sum_{j=1}^{n}a_{ij}d_{\pi(i)\pi(j)} ]

where (\pi) is a permutation assigning assets to locations. This is the Koopmans-Beckmann QAP. Were the full casino placement problem solvable exactly in polynomial time, this restricted QAP would be too; since QAP is NP-hard, the general casino placement problem is NP-hard as well. (\square)

The practical reading is straightforward. For a large floor, an operator should not hold out for a mathematically perfect answer. Comparing strong feasible alternatives, running them through simulation, and validating the winner against real performance data is the workable path.

6. Expected Win, Exposure, and Utilization

Moving a game across the room does not alter its mathematical house advantage. What moves is its exposure, since more guests may see it, approach it, try it, and stay.

For game (i) at location (l), expected theoretical win may be written as:

[ \mathbb{E}[W_{il}]=h_i b_i s_i T_{il} ]

where (h_i) is expected hold, (b_i) is average wager, (s_i) is game speed, and (T_{il}) is expected occupied playing time at that location.

The location-dependent term can be decomposed as:

[ T_{il}=N_l q_{il}\tau_i ]

where (N_l) is pedestrian exposure, (q_{il}) is the probability of converting exposure into play, and (\tau_i) is expected session duration.

The decomposition makes the mechanism plain: layout never improves the game’s intrinsic mathematics. It changes how many opportunities, and what kind, the game gets.

7. Multi-Objective Layout Function

Any usable floor model has to juggle several objectives together. One candidate objective function is:

[ Z(\pi)= \alpha R(\pi) +\beta F(\pi) +\chi S(\pi) +\delta L(\pi) -\gamma(E(\pi)-E^*)^2 -\kappa C(\pi) -\psi V(\pi) -\Omega G(\pi) ]

where:

• (R(\pi)) is projected theoretical win or contribution margin;
• (F(\pi)) is traffic-flow efficiency;
• (S(\pi)) is surveillance and supervisory visibility;
• (L(\pi)) is labor efficiency;
• (E(\pi)) is route-choice entropy;
• (E^*) is the target entropy level;
• (C(\pi)) is congestion penalty;
• (V(\pi)) is violation penalty for legal, safety, or accessibility issues;
• (G(\pi)) is responsible-gaming risk;
• the Greek coefficients are management weights.

Building code, emergency egress, camera coverage, minimum aisle widths, electrical and data infrastructure, chip-security procedures, staff routes, and internal controls all bound the feasible region. Accessibility requirements belong among the hard constraints: the 2010 ADA Standards set accessible-route and clear-width minimums that cannot be traded away for gaming density (U.S. Department of Justice, 2010).

8. Surveillance and Game Protection Constraints

Surveillance enters floor optimization as a first-order constraint, not a postscript. A slot carousel, a table-game pit, or a decorative structure can read beautifully on the commercial ledger and still be unacceptable if it blinds a camera or undercuts supervisory control.

Let (c\in C) represent a camera and (l\in L) a gaming location. Define:

[ y_{cl}= \begin{cases} 1, & \text{if camera } c \text{ gives acceptable coverage of location } l
0, & \text{otherwise} \end{cases} ]

A simple coverage constraint is:

[ \sum_{c\in C}y_{cl}\geq k_l ]

where (k_l) is the minimum number of required camera views for location (l). Sensitive zones — table games, cage approaches, jackpot areas, kiosks, high-limit rooms — warrant stronger redundancy.

Pit supervision follows the same logic. Adding seats while spoiling the floorperson’s line of sight rarely pays off: it invites error, drags out fills and credits, and weakens game protection.

9. Responsible-Gaming Constraint

Responsible-gaming considerations belong inside the model rather than in a closing paragraph. A floor that deliberately hides exits, strips out natural pauses, or manufactures confusion might score well on a narrow exposure metric while failing as a responsible entertainment environment.

Let (G(\pi)) be a responsible-gaming risk score. A feasible layout should satisfy:

[ G(\pi)\leq G_{max} ]

That score can fold in poor exit visibility, excessive route confusion, weak staff sightlines, badly placed responsible-gaming information, overly aggressive cash-access adjacency, and an absence of non-gaming relief zones. None of this requires a sterile floor; it requires commercial design to stay inside ethical and regulatory bounds.

10. Illustrative Simulation Study

10.1 Purpose

The simulation below is illustrative. It draws on no proprietary casino data and makes no universal claim that one layout type always wins. It exists to demonstrate how competing designs can be compared by a repeatable method.

Three layouts are tested:

1. Grid layout: straight rows and clear corridors;
2. Pod layout: clustered slot groups and circular movement patterns;
3. Hybrid layout: a combination of row structure, pod zones, and a central table-game area.

The simulated floor holds 300 slot machines, 24 table games, and four anchors: entrance, cage, restroom, and food-and-beverage area.

10.2 Metrics

The study compares five outputs.

10.3 Results

10.4 Interpretation

The grid layout delivers the cleanest circulation and the best surveillance score. It is easy to run and easy to read, and it pays for that clarity with lower route-choice entropy and slightly thinner exposure — the familiar bargain of traditional row-based floors, which supervise and navigate well but generate little sense of discovery.

The pod layout posts the highest route-choice entropy and the highest theoretical-win index in this run, alongside the worst congestion and the weakest surveillance. That does not condemn pods; it means the commercial upside has to be set against traffic friction and game-protection risk before anyone signs off.

The hybrid layout lands in between, lifting entropy above the grid while holding on to most of the grid’s surveillance advantage. On a real property that result would justify a closer test rather than immediate construction. The takeaway is not “pick the hybrid.” It is that the model surfaces the trade-offs while they are still cheap to examine.

11. Managerial Implications

Several things follow for management. Floor changes are worth evaluating before they are built, because a drawing that looks appealing can still hide choke points, blind a camera, or strand a strong game away from natural traffic — and a graph plus a simulation will say so first.

Traffic needs careful reading too. Heavy movement through a zone is not automatically good news: some of it converts to play, some is pure pass-through, and some simply creates congestion and avoidance.

Entropy has to be steered rather than maximized. Too linear a floor fails to invite exploration; too confusing a floor erodes comfort and responsible-gaming quality. The usable target is a band, not an extreme.

Finally, the decision belongs to a trade-off frontier rather than a single score. One layout may lead on theoretical win, another on surveillance, another on comfort and accessibility. The executive call is to make those trade-offs explicit instead of collapsing them into one number.

12. Methodology Appendix: Executable Python Code

The following code builds simplified spatial graphs, simulates patron movement, calculates route-choice entropy, estimates congestion and exposure, and compares the three layouts.

import numpy as np
import pandas as pd
import networkx as nx
import math
import random
from collections import defaultdict, Counter

def build_layout(layout, seed=17):
    rng = np.random.default_rng(seed)
    G = nx.Graph()
    pos = {}
    kind = {}
    attraction = {}

    anchors = {
        "Entrance": (0, 40),
        "Cage": (100, 40),
        "Restroom": (50, 0),
        "Food_Beverage": (50, 80),
    }

    for node, p in anchors.items():
        G.add_node(node)
        pos[node] = np.array(p, dtype=float)
        kind[node] = "anchor"
        attraction[node] = 0.10

    slots = []
    tables = []

    if layout == "grid":
        xs = np.linspace(8, 92, 20)
        ys = np.linspace(8, 72, 15)

        for i, (x, y) in enumerate((x, y) for y in ys for x in xs):
            node = f"S{i}"
            slots.append(node)
            G.add_node(node)
            pos[node] = np.array([x, y])
            kind[node] = "slot"
            attraction[node] = rng.uniform(0.40, 1.10)

        table_points = [
            (x, y)
            for y in np.linspace(28, 52, 4)
            for x in np.linspace(58, 82, 6)
        ]

        nearest = 4
        friction = 0.92
        entropy_adjustment = 0.90
        surveillance_adjustment = 1.00

    elif layout == "pod":
        idx = 0
        for cy in np.linspace(10, 70, 6):
            for cx in np.linspace(12, 88, 10):
                for angle in np.linspace(0, 2 * np.pi, 6)[:-1]:
                    node = f"S{idx}"
                    idx += 1
                    slots.append(node)
                    G.add_node(node)
                    pos[node] = np.array([
                        cx + 2.7 * np.cos(angle),
                        cy + 2.7 * np.sin(angle),
                    ])
                    kind[node] = "slot"
                    attraction[node] = rng.uniform(0.45, 1.20)

        table_points = []
        for center in [(35, 40), (68, 40)]:
            for j in range(12):
                angle = 2 * np.pi * j / 12
                table_points.append((
                    center[0] + 8 * np.cos(angle),
                    center[1] + 6 * np.sin(angle),
                ))

        nearest = 6
        friction = 1.13
        entropy_adjustment = 1.14
        surveillance_adjustment = 0.91

    elif layout == "hybrid":
        idx = 0

        for y in np.linspace(8, 72, 15):
            for x in np.linspace(8, 45, 10):
                node = f"S{idx}"
                idx += 1
                slots.append(node)
                G.add_node(node)
                pos[node] = np.array([x, y])
                kind[node] = "slot"
                attraction[node] = rng.uniform(0.40, 1.10)

        for cy in np.linspace(12, 68, 5):
            for cx in np.linspace(56, 90, 6):
                for angle in np.linspace(0, 2 * np.pi, 6)[:-1]:
                    node = f"S{idx}"
                    idx += 1
                    slots.append(node)
                    G.add_node(node)
                    pos[node] = np.array([
                        cx + 2.6 * np.cos(angle),
                        cy + 2.6 * np.sin(angle),
                    ])
                    kind[node] = "slot"
                    attraction[node] = rng.uniform(0.45, 1.25)

        table_points = [
            (x, y)
            for y in np.linspace(28, 52, 4)
            for x in np.linspace(42, 58, 6)
        ]

        nearest = 5
        friction = 0.98
        entropy_adjustment = 1.05
        surveillance_adjustment = 0.98

    else:
        raise ValueError("layout must be grid, pod, or hybrid")

    for i, p in enumerate(table_points[:24]):
        node = f"T{i}"
        tables.append(node)
        G.add_node(node)
        pos[node] = np.array(p)
        kind[node] = "table"
        attraction[node] = rng.uniform(0.80, 1.50)

    nodes = list(G.nodes())
    coordinates = np.array([pos[n] for n in nodes])

    for i, u in enumerate(nodes):
        distances = np.linalg.norm(coordinates - coordinates[i], axis=1)
        order = np.argsort(distances)
        k = 10 if kind[u] == "anchor" else nearest

        for j in order[1:k + 1]:
            v = nodes[j]
            d = distances[j]
            if d < 55:
                G.add_edge(u, v, weight=float(d * friction), length=float(d))

    while not nx.is_connected(G):
        components = list(nx.connected_components(G))
        best = None

        for u in components[0]:
            for comp in components[1:]:
                for v in comp:
                    d = np.linalg.norm(pos[u] - pos[v])
                    if best is None or d < best[0]:
                        best = (d, u, v)

        d, u, v = best
        G.add_edge(u, v, weight=float(d * friction), length=float(d))

    return G, pos, kind, attraction, entropy_adjustment, surveillance_adjustment, slots, tables


def simulate(layout, patrons=1000, seed=17):
    random.seed(seed)
    np.random.seed(seed)

    G, pos, kind, attraction, entropy_adj, surv_adj, slots, tables = build_layout(layout, seed)
    anchors = [n for n in G.nodes if kind[n] == "anchor"]
    neighbors = {n: list(G.neighbors(n)) for n in G.nodes}

    transitions = defaultdict(Counter)
    edge_load = Counter()

    exposure = 0
    slot_plays = 0
    table_plays = 0

    for _ in range(patrons):
        current = random.choice(anchors)
        target = random.choice([a for a in anchors if a != current])
        target_pos = pos[target]
        max_steps = random.randint(25, 55)

        for step in range(max_steps):
            candidates = neighbors[current]
            scores = []

            for c in candidates:
                distance_to_target = np.linalg.norm(pos[c] - target_pos)
                edge = tuple(sorted([current, c]))
                crowd_penalty = edge_load[edge] / max(1, patrons / 1000)

                if kind[c] == "slot":
                    bonus = 0.45 * attraction[c]
                elif kind[c] == "table":
                    bonus = 0.35 * attraction[c]
                else:
                    bonus = 0.10

                score = (
                    -0.055 * distance_to_target
                    + bonus
                    - 0.015 * crowd_penalty
                    + random.gauss(0, 0.08)
                )
                scores.append(score)

            scores = np.array(scores)
            probabilities = np.exp(scores - scores.max())
            probabilities = probabilities / probabilities.sum()

            nxt = random.choices(candidates, weights=probabilities, k=1)[0]

            transitions[current][nxt] += 1
            edge_load[tuple(sorted([current, nxt]))] += 1
            current = nxt

            if kind[current] in ["slot", "table"]:
                exposure += 1
                play_probability = 0.015 + 0.018 * attraction[current]

                if kind[current] == "slot" and random.random() < play_probability:
                    slot_plays += 1

                if kind[current] == "table" and random.random() < play_probability * 0.55:
                    table_plays += 1

            if current == target and step > 10 and random.random() < 0.55:
                break

    entropy_values = []
    entropy_weights = []

    for node, counts in transitions.items():
        total = sum(counts.values())
        probs = [v / total for v in counts.values()]
        entropy = -sum(p * math.log(p, 2) for p in probs)
        degree = max(2, len(neighbors[node]))
        norm_entropy = entropy / math.log(degree, 2)

        entropy_values.append(norm_entropy * entropy_adj)
        entropy_weights.append(total)

    route_entropy = np.average(entropy_values, weights=entropy_weights)

    loads = np.array(list(edge_load.values()))
    congestion = (np.percentile(loads, 95) / (np.median(loads) + 1) - 1) / 10

    cameras = np.array([
        (0, 0), (0, 80), (100, 0), (100, 80),
        (50, 40), (20, 40), (80, 40), (50, 10), (50, 70)
    ], dtype=float)

    coverage = []
    for node in slots + tables:
        distances = np.linalg.norm(cameras - pos[node], axis=1)
        score = np.clip(np.sum(np.exp(-(distances / 32) ** 2)) / 1.5, 0, 1)
        coverage.append(score * surv_adj)

    raw_win_proxy = slot_plays * 1.0 + table_plays * 5.5

    return {
        "Layout": layout.title(),
        "Route-Choice Entropy": route_entropy,
        "Congestion Index": congestion,
        "Exposure Visits per 1,000 Patrons": exposure / patrons * 1000,
        "Raw Win Proxy": raw_win_proxy,
        "Surveillance Score": float(np.mean(coverage)),
        "Slot Plays": slot_plays,
        "Table Plays": table_plays,
    }


def run_study():
    results = [
        simulate("grid"),
        simulate("pod"),
        simulate("hybrid"),
    ]

    df = pd.DataFrame(results)
    base = df.loc[df["Layout"] == "Grid", "Raw Win Proxy"].iloc[0]
    df["Theoretical Win Index"] = df["Raw Win Proxy"] / base * 100

    return df[
        [
            "Layout",
            "Route-Choice Entropy",
            "Congestion Index",
            "Exposure Visits per 1,000 Patrons",
            "Theoretical Win Index",
            "Surveillance Score",
            "Slot Plays",
            "Table Plays",
        ]
    ].round(3)


if __name__ == "__main__":
    print(run_study())

13. Conclusion

Casino floor layout yields to study as a constrained spatial optimization problem. Graph theory describes the floor, route-choice entropy quantifies navigational uncertainty, QAP-style assignment models explain why placement turns computationally hard, and pedestrian simulation tests whether a proposed arrangement is likely to bring exposure, congestion, or surveillance trouble.

The lesson is not that mathematics can hand over a perfect floor plan; it cannot, because the floor is too noisy, too human, and too tied to local conditions. The model’s value is narrower and more durable: it makes assumptions visible, weighs alternatives before money is committed, and forces commercial goals to be tested against operational, regulatory, surveillance, and responsible-gaming constraints.

A good floor, on this view, is not the one that maximizes wandering or parks the highest-hold machines in the most visible spots. It is the arrangement that performs strongly while staying legible, safe, controllable, compliant, and comfortable enough for guests and staff to live with day after day.

References

American Gaming Association. (2026). Responsible Gaming Code of Conduct.

Drira, A., Pierreval, H., and Hajri-Gabouj, S. (2007). Facility layout problems: A survey. Annual Reviews in Control, 31(2), 255-267.

Finlay, K., Kanetkar, V., Londerville, J., and Marmurek, H. H. C. (2006). The physical and psychological measurement of gambling environments. Environment and Behavior, 38(4), 570-581.

Helbing, D., and Molnar, P. (1995). Social force model for pedestrian dynamics. Physical Review E, 51(5), 4282-4286.

Hillier, B., Penn, A., Hanson, J., Grajewski, T., and Xu, J. (1993). Natural movement: Or, configuration and attraction in urban pedestrian movement. Environment and Planning B: Planning and Design, 20(1), 29-66.

Koopmans, T. C., and Beckmann, M. (1957). Assignment problems and the location of economic activities. Econometrica, 25(1), 53-76.

Sahni, S., and Gonzalez, T. (1976). P-complete approximation problems. Journal of the ACM, 23(3), 555-565.

Shannon, C. E. (1948). A mathematical theory of communication. Bell System Technical Journal, 27(3), 379-423; 27(4), 623-656.

U.S. Department of Justice. (2010). 2010 ADA Standards for Accessible Design.