diff --git a/lib/Lacuna/RPC.pm b/lib/Lacuna/RPC.pm
index d8eaa092..de907af7 100644
--- a/lib/Lacuna/RPC.pm
+++ b/lib/Lacuna/RPC.pm
@@ -10,70 +10,91 @@ use Log::Any qw($log);
 has plack_request => ( is => 'rw' );
 
 sub get_session {
-    my ($self, $session_id) = @_;
-    if (ref $session_id eq 'Lacuna::Session') {
-        return $session_id;
-    }
-    else {
-        my $session = Lacuna::Session->new(id=>$session_id);
-        if ($session->empire_id) {
-            $session->extend;
-            return $session;
+    my ($self, $opts) = @_;
+    my $session = ref $opts ? $opts->{session_id} : $opts;
+
+    if (ref $session ne 'Lacuna::Session') {
+        if (ref $session eq 'Lacuna::DB::Result::Empire') {
+            $session = $session->start_session;
         }
         else {
-            confess [1006, 'Session expired.', $session_id];
+            my $session_id = $session;
+            $session = Lacuna::Session->new(id=>$session);
+            if ($session && $session->empire_id) {
+                $session->extend;
+            }
+            else {
+                confess [1006, 'Session expired.', $session_id];
+            }
         }
     }
-}
+    $opts = { session_id => $session->id } unless ref $opts;
 
-sub get_empire_by_session {
-    my ($self, $session_id) = @_;
-    if (ref $session_id eq 'Lacuna::DB::Result::Empire') {
-        return $session_id;
+    if ($opts->{building_id}) {
+        my $building = $self->get_building($session->empire,
+                                           $opts->{building_id},
+                                           %$opts);
+        $session->current_building($building);
+        $session->current_body($building->body);
+        $session->current_empire($session->current_body->empire);
     }
-    else {
-        my $session = $self->get_session($session_id);
-        my $empire = $session->empire;
-        if (defined $empire) {
-            my $throttle = Lacuna->config->get('rpc_throttle') || 30;
-            if (my $delay = Lacuna->cache->get('rpc_block', $session_id)) {
-                confess [1010, 'Too fast response, ' . $empire->name . '!'];
-            }
-            if ($empire->rpc_rate > $throttle) {
-                Lacuna->cache->increment('rpc_limit_'.format_date(undef,'%d'), $empire->id, 1, 60 * 60 * 30);
-                confess [1010, 'Slow down '.$empire->name.'! No more than '.$throttle.' requests per minute.'];
-            }
-            my $max = Lacuna->config->get('rpc_limit') || 2500;
-            if ($empire->rpc_count > $max) {
-                confess [1010, $empire->name.' has already made the maximum number of requests ('.$max.') you can make for one day.'];
-            }
-            my $ipr = real_ip_address($self->plack_request);
-            if (!$session->ip_address) {
-                $log->debug("Missing IP address, adding $ipr");
-                $session->ip_address($ipr);
-                $session->update;
-            }
-            my $ipm = $session->ip_address eq $ipr;
-            my $i = 1;
-            my @caller = caller($i);
-            while (@caller)
-            {
-                last if $caller[0] =~ /Lacuna::RPC/;
-                @caller = caller(++$i);
-            }
-            $log->info(sprintf "ACTUAL:ipr=%s,ipe=%s,ipm=%s,ses=%s,sat:%d,rpc=%s", $ipr, $session->ip_address, $ipm, $session_id, $session->is_sitter ? 1 : 0, $caller[3]);
-            #Lacuna->db->resultset('Lacuna::DB::Result::Log::RPC')->new({
-            #   empire_id    => $empire->id,
-            #   empire_name  => $empire->name,
-            #   module       => ref $self,
-            #   api_key      => $empire->current_session->api_key,
-            #})->insert;
-            return $empire;
+    elsif ($opts->{body_id}) {
+        my $body = $self->get_body($session->empire,
+                                   $opts->{body_id});
+        $session->clear_building;
+        $session->current_body($body);
+        $session->current_empire($session->current_body->empire);
+    }
+
+    $session->current_empire($session->empire)
+        unless $session->current_empire;
+
+    my $empire = $session->current_empire;
+    if (defined $empire) {
+        my $throttle = Lacuna->config->get('rpc_throttle') || 30;
+        if (my $delay = Lacuna->cache->get('rpc_block', $opts->{session_id})) {
+            confess [1010, 'Too fast response, ' . $empire->name . '!'];
         }
-        else {
-            confess [1002, 'Empire does not exist.'];
+        if ($empire->rpc_rate > $throttle) {
+            Lacuna->cache->increment('rpc_limit_'.format_date(undef,'%d'), $empire->id, 1, 60 * 60 * 30);
+            confess [1010, 'Slow down '.$empire->name.'! No more than '.$throttle.' requests per minute.'];
         }
+        my $max = Lacuna->config->get('rpc_limit') || 2500;
+        if ($empire->rpc_count > $max) {
+            confess [1010, $empire->name.' has already made the maximum number of requests ('.$max.') you can make for one day.'];
+        }
+        my $ipr = real_ip_address($self->plack_request);
+        if (!$session->ip_address && $ipr) {
+            $log->debug("Missing IP address, adding $ipr");
+            $session->ip_address($ipr);
+            $session->update;
+        }
+        my $ipm = $session->ip_address eq $ipr;
+        my $i = 1;
+        my @caller = caller($i);
+        while (@caller)
+        {
+            last if $caller[0] =~ /Lacuna::RPC/;
+            @caller = caller(++$i);
+        }
+        $log->info(sprintf "ACTUAL:ipr=%s,ipe=%s,ipm=%s,ses=%s,sat:%d,rpc=%s", $ipr, $session->ip_address, $ipm, $opts->{session_id}, $session->is_sitter ? 1 : 0, $caller[3]);
+        #Lacuna->db->resultset('Lacuna::DB::Result::Log::RPC')->new({
+        #   empire_id    => $empire->id,
+        #   empire_name  => $empire->name,
+        #   module       => ref $self,
+        #   api_key      => $empire->current_session->api_key,
+        #})->insert;
+    }
+    else {
+        confess [1002, 'Empire does not exist.'];
     }
+
+    if ($session->current_body) {
+        $session->current_body->tick;
+        # do we need to discard the changes?
+    }
+
+    return $session;
 }
 
 sub get_body { # makes for uniform error handling, and prevents staleness
@@ -95,7 +116,6 @@ sub get_body { # makes for uniform error handling, and prevents staleness
     if ($body->empire_id ne $empire->id) {
         if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
             if ($body->empire->alliance_id eq $empire->alliance_id) {
-                $body->tick;
                 return $body;
             }
         }
@@ -104,7 +124,6 @@ sub get_body { # makes for uniform error handling, and prevents staleness
     if ($body->id eq $empire->home_planet_id) {
         $empire->home_planet($body);
     }
-    $body->tick;
     return $body;
 }
 
@@ -130,14 +149,12 @@ sub get_building { # makes for uniform error handling, and prevents staleness
         if ($body->empire_id ne $empire->id) { 
             if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
                 if ($body->empire->alliance_id eq $empire->alliance_id) {
-                    $building->discard_changes; # in case it changed due to the tick
                     $building->body($body);
                     return $building;
                 }
             }
             confess [1010, "Can't manipulate a building that you don't own.", $building_id];
         }
-        $building->discard_changes; # in case it changed due to the tick
         $building->body($body);
         return $building;
     }
diff --git a/lib/Lacuna/RPC/Alliance.pm b/lib/Lacuna/RPC/Alliance.pm
index 0304f1c9..f6239066 100644
--- a/lib/Lacuna/RPC/Alliance.pm
+++ b/lib/Lacuna/RPC/Alliance.pm
@@ -15,7 +15,8 @@ sub find {
     unless (length($name) >= 3) {
         confess [1009, 'Alliance name too short. Your search must be at least 3 characters.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session = $self->get_session({session_id => $session_id});
+    my $empire = $session->current_empire;
     my $alliances = Lacuna->db->resultset('Lacuna::DB::Result::Alliance')->search({name => {'like' => $name.'%'}}, {rows=>100});
     my @list_of_alliances;
     my $limit = 100;
@@ -34,7 +35,8 @@ sub find {
 
 sub view_profile {
     my ($self, $session_id, $alliance_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session = $self->get_session({session_id => $session_id});
+    my $empire = $session->current_empire;
     my $alliance = Lacuna->db->resultset('Lacuna::DB::Result::Alliance')->find($alliance_id);
     unless (defined $alliance) {
         confess [1002, 'The alliance you wish to view does not exist.', $alliance_id];
diff --git a/lib/Lacuna/RPC/Body.pm b/lib/Lacuna/RPC/Body.pm
index 66579e21..6bf2ea1c 100644
--- a/lib/Lacuna/RPC/Body.pm
+++ b/lib/Lacuna/RPC/Body.pm
@@ -15,15 +15,17 @@ use feature 'switch';
 
 sub get_status {
     my ($self, $session_id, $body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body =   $session->current_body;
     return $self->format_status($empire, $body);
 }
 
 sub get_body_status {
     my ($self, $args) = @_;
 
-    my $empire = $self->get_empire_by_session($args->{session_id});
+    my $session = $self->get_session({session_id => $args->{session_id}});
+    my $empire = $session->current_empire;
     my $body = Lacuna->db->resultset('Map::Body')->find($args->{body_id});
     confess [1000, 'Cannot find that body.'] unless $body;
 
@@ -35,8 +37,9 @@ sub get_body_status {
 
 sub abandon {
     my ($self, $session_id, $body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
     if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) { 
         my $proposition = Lacuna->db->resultset('Lacuna::DB::Result::Propositions')->new({
             type            => 'AbandonStation',
@@ -64,8 +67,10 @@ sub rename {
         ->no_padding
         ->not_ok(Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->search({name=>$name, 'id'=>{'!='=>$body_id}})->count); # name available
     
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
+
     if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
         unless ($body->parliament->effective_level >= 3) {
             confess [1013, 'You need to have a level 3 Parliament to rename a station.'];
@@ -96,8 +101,9 @@ sub rename {
 
 sub get_buildings {
     my ($self, $session_id, $body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
     if ($body->needs_surface_refresh) {
         $body->needs_surface_refresh(0);
         $body->update;
@@ -135,8 +141,9 @@ sub get_buildings {
 sub repair_list {
     my ($self, $session_id, $body_id, $building_ids) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
 
     if (scalar @$building_ids > 121) {
         confess [1002, 'Invalid number of buildings in argument.'];
@@ -147,10 +154,11 @@ sub repair_list {
         $body->update;
     }
     my @buildings = @{$body->building_cache};
+    my %all_ids = map { $_->id => $_ } @buildings;
 
     my %out;
     for my $bld_id (@{$building_ids}) {
-        my ( $building ) = grep { $_->id == $bld_id } @buildings;
+        my $building = $all_ids{$bld_id};
         next unless $building;
         next unless $building->efficiency < 100;
         my $return;
@@ -192,8 +200,9 @@ sub rearrange_buildings {
       all { ref $_ eq 'HASH' && exists $_->{id} && exists $_->{x} && exists $_->{y} } @$arrangement;
 
 
-  my $empire = $self->get_empire_by_session($session_id);
-  my $body = $self->get_body($empire, $body_id);
+  my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+  my $empire = $session->current_empire;
+  my $body   = $session->current_body;
   my %cur_lay; my %new_lay;
   my %cur_ids; my %new_ids;
   my @miss_in_new; my @miss_in_cur;
@@ -427,8 +436,9 @@ sub check_positions {
 
 sub get_buildable {
     my ($self, $session_id, $body_id, $x, $y, $tag) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
     
     my $building_rs = Lacuna->db->resultset('Lacuna::DB::Result::Building');
 
@@ -518,8 +528,9 @@ sub get_buildable {
 
 sub get_buildable_locations {
     my ($self, $opts) = @_;
-    my $empire = $self->get_empire_by_session($opts->{session_id});
-    my $body = $self->get_body($empire, $opts->{body_id});
+    my $session = $self->get_session($opts);
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
 
     my %args;
     $args{size} = $opts->{size} if $opts->{size} and $opts->{size} ~~ [1,4,9];
@@ -532,7 +543,8 @@ sub get_buildable_locations {
 
 sub view_laws {
     my ($self, $session_id, $body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session = $self->get_session({session_id => $session_id});
+    my $empire = $session->current_empire;
     my $body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')
                 ->find($body_id);
     if ($body and $body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
@@ -561,8 +573,9 @@ sub view_laws {
 sub set_colony_notes
 {
     my ($self, $session_id, $body_id, $opts) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire = $session->current_empire;
+    my $body   = $session->current_body;
     my $notes = $opts->{notes};
 
     #Lacuna::Verify->new(content=>\$notes, throws=>[1000,'Content may not have any of the following characters: @&<>;{}()',$notes])
diff --git a/lib/Lacuna/RPC/Building.pm b/lib/Lacuna/RPC/Building.pm
index 77419450..604a3868 100644
--- a/lib/Lacuna/RPC/Building.pm
+++ b/lib/Lacuna/RPC/Building.pm
@@ -20,8 +20,9 @@ sub to_app_with_url {
 
 sub upgrade {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     # check the upgrade lock
     if ($building->is_upgrade_locked) {
@@ -83,8 +84,9 @@ sub upgrade {
 
 sub view {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $cost = $building->cost_to_upgrade;
     my $can_upgrade = eval{$building->can_upgrade($cost)};
     my $upgrade_reason = $@;
@@ -142,8 +144,9 @@ sub view {
 
 sub build {
     my ($self, $session_id, $body_id, $unclean_x, $unclean_y) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $body_id });
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
 
     my $x = int( $unclean_x );
     my $y = int( $unclean_y );
@@ -235,26 +238,15 @@ sub build {
 
 sub demolish {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     $building->can_demolish;
     if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
         unless ($body->parliament && $body->parliament->effective_level >= 2) {
             confess [1013, 'You need to have a level 2 Parliament to demolish a module.'];
         }
-        my $name = $building->name.' ('.$building->x.','.$building->y.')';
-        my $proposition = Lacuna->db->resultset('Lacuna::DB::Result::Propositions')->new({
-            type            => 'DemolishModule',
-            name            => 'Demolish '.$name,
-            description     => 'Demolish '.$name.' on {Planet '.$body->id.' '.$body->name.'}.',
-            scratch         => { building_id => $building->id },
-            proposed_by_id  => $empire->id,
-        });
-        $proposition->station($body);
-        $proposition->proposed_by($empire);
-        $proposition->insert;
-        confess [1017, 'The demolish order has been delayed pending a parliamentary vote.'];
     }
     $building->demolish;
     $body->tick;
@@ -265,26 +257,16 @@ sub demolish {
 
 sub downgrade {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
+
     $building->can_downgrade;
     if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
         unless ($body->parliament && $body->parliament->effective_level >= 2) {
             confess [1013, 'You need to have a level 2 Parliament to downgrade a module.'];
         }
-        my $name = $building->name.' ('.$building->x.','.$building->y.')';
-        my $proposition = Lacuna->db->resultset('Lacuna::DB::Result::Propositions')->new({
-            type            => 'DowngradeModule',
-            name            => 'Downgrade '.$name,
-            description     => 'Downgrade '.$name.' on {Planet '.$body->id.' '.$body->name.'} from level '.$building->level.' to '.($building->level - 1).'.',
-            scratch         => { building_id => $building->id },
-            proposed_by_id  => $empire->id,
-        });
-        $proposition->station($body);
-        $proposition->proposed_by($empire);
-        $proposition->insert;
-        confess [1017, 'The downgrade order has been delayed pending a parliamentary vote.'];
     }
     $building->downgrade;
     $body->tick;
@@ -293,8 +275,9 @@ sub downgrade {
 
 sub get_stats_for_level {
     my ($self, $session_id, $building_id, $level) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($level < 0 || $level > 100) {
         confess [1009, 'Level must be an integer between 1 and 100.'];
     }
@@ -330,25 +313,12 @@ sub get_stats_for_level {
 
 sub repair {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $costs = $building->get_repair_costs;
     $building->can_repair($costs);
     my $body = $building->body;
-    if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
-        my $name = $building->name.' ('.$building->x.','.$building->y.')';
-        my $proposition = Lacuna->db->resultset('Lacuna::DB::Result::Propositions')->new({
-            type            => 'RepairModule',
-            name            => 'Repair '.$name,
-            description     => 'Repair '.$name.' on {Planet '.$body->id.' '.$body->name.'}.',
-            scratch         => { building_id => $building->id },
-            proposed_by_id  => $empire->id,
-        });
-        $proposition->station($body);
-        $proposition->proposed_by($empire);
-        $proposition->insert;
-        confess [1017, 'The repair order has been delayed pending a parliamentary vote.'];
-    }
     $building->repair($costs);
     return $self->view($empire, $building);
 }
diff --git a/lib/Lacuna/RPC/Building/Archaeology.pm b/lib/Lacuna/RPC/Building/Archaeology.pm
index 649d96b4..4aa940b2 100644
--- a/lib/Lacuna/RPC/Building/Archaeology.pm
+++ b/lib/Lacuna/RPC/Building/Archaeology.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{building}{work}{searching} = $building->work->{ore_type};
     }
@@ -27,8 +28,9 @@ around 'view' => sub {
 
 sub get_glyphs {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $glyphs = $building->body->glyph;
     while (my $glyph = $glyphs->next) {
@@ -48,8 +50,9 @@ sub get_glyphs {
 sub get_glyph_summary {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $glyphs = $building->body->glyph;
     while (my $glyph = $glyphs->next) {
@@ -69,8 +72,9 @@ sub get_glyph_summary {
 
 sub get_ores_available_for_processing {
     my ($self, $session_id, $building_id, $ore) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     return {
         ore                 => $building->get_ores_available_for_processing,
         status              => $self->format_status($empire, $building->body),
@@ -79,10 +83,11 @@ sub get_ores_available_for_processing {
 
 sub search_for_glyph {
     my ($self, $session_id, $building_id, $ore) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->search_for_glyph($ore);
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub assemble_glyphs {
@@ -95,8 +100,9 @@ sub assemble_glyphs {
         confess [1001, "Quantity must be a positive integer"];
     }
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $plan = $building->make_plan($glyphs, $quantity);
     return {
         item_name           => $plan->class->name,
@@ -109,8 +115,9 @@ sub assemble_glyphs {
 
 sub subsidize_search {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "No one is searching."];
@@ -127,13 +134,14 @@ sub subsidize_search {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub view_excavators {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @sites;
     my $level = $building->effective_level;
     my $chances = $building->can_you_dig_it($building->body, $level, 1);
@@ -181,8 +189,9 @@ sub view_excavators {
 
 sub abandon_excavator {
     my ($self, $session_id, $building_id, $site_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $site = Lacuna->db->resultset('Lacuna::DB::Result::Excavators')->find($site_id);
     unless (defined $site) {
         confess [1002, "Excavator Site :".$site_id.": not found."];
@@ -198,9 +207,10 @@ sub abandon_excavator {
 
 sub mass_abandon_excavator {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-	$building->excavators->delete;
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    $building->excavators->delete;
 	return {
         status  => $self->format_status($empire, $building->body),
     }; 
diff --git a/lib/Lacuna/RPC/Building/BlackHoleGenerator.pm b/lib/Lacuna/RPC/Building/BlackHoleGenerator.pm
index bdee9fc8..5d18ddaf 100644
--- a/lib/Lacuna/RPC/Building/BlackHoleGenerator.pm
+++ b/lib/Lacuna/RPC/Building/BlackHoleGenerator.pm
@@ -17,9 +17,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $body = $building->body;
     
     my $throw = 0; my $reason = '';
@@ -265,8 +266,9 @@ sub find_target {
 
 sub get_actions_for {
     my ($self, $session_id, $building_id, $target_params) = @_;
-    my $empire   = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     my ($target, $target_type) = $self->find_target($empire, $target_params);
     my @tasks = bhg_tasks($building);
@@ -677,8 +679,9 @@ sub generate_singularity {
             params        => shift,
         };
     }
-    my $empire    = $self->get_empire_by_session($args->{session_id});
-    my $building  = $self->get_building($empire, $args->{building_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}, building_id => $args->{building_id} });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $task_name = $args->{task_name};
     my $subsidize = $args->{subsidize};
     
@@ -2361,9 +2364,10 @@ sub bhg_tasks {
 
 sub subsidize_cooldown {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-    
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+
     unless ($building->is_working) {
         confess [1010, "BHG is not in cooldown mode."];
     }
@@ -2378,8 +2382,8 @@ sub subsidize_cooldown {
         reason  => 'BHG cooldown subsidy after the fact',
     });
     $empire->update;
-    
-    return $self->view($empire, $building);
+
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(generate_singularity get_actions_for subsidize_cooldown));
diff --git a/lib/Lacuna/RPC/Building/Capitol.pm b/lib/Lacuna/RPC/Building/Capitol.pm
index 3843d0a6..7eefe14c 100644
--- a/lib/Lacuna/RPC/Building/Capitol.pm
+++ b/lib/Lacuna/RPC/Building/Capitol.pm
@@ -15,17 +15,19 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{rename_empire_cost} = $building->rename_empire_cost;
     return $out;
 };
 
 sub rename_empire {
     my ($self, $session_id, $building_id, $name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     if ($empire->essentia < $building->rename_empire_cost) {
         confess [1011, "You don't have enough essentia. You need ".$building->rename_empire_cost."."];
diff --git a/lib/Lacuna/RPC/Building/DeployedBleeder.pm b/lib/Lacuna/RPC/Building/DeployedBleeder.pm
index 96d8772b..b1c7cecc 100644
--- a/lib/Lacuna/RPC/Building/DeployedBleeder.pm
+++ b/lib/Lacuna/RPC/Building/DeployedBleeder.pm
@@ -15,9 +15,9 @@ sub model_class {
 
 around demolish => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    $empire->current_session->check_captcha;
-    return $orig->($self, $empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    $session->check_captcha;
+    return $orig->($self, $session, $building_id);
 };
 
 no Moose;
diff --git a/lib/Lacuna/RPC/Building/Development.pm b/lib/Lacuna/RPC/Building/Development.pm
index 595d6415..abee41b0 100644
--- a/lib/Lacuna/RPC/Building/Development.pm
+++ b/lib/Lacuna/RPC/Building/Development.pm
@@ -16,9 +16,10 @@ sub model_class {
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{build_queue} = $building->format_build_queue;
     $out->{subsidy_cost} = $building->calculate_subsidy;
     return $out;
@@ -27,8 +28,9 @@ around 'view' => sub {
 sub subsidize_build_queue {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->effective_level > 0 and $building->effective_efficiency == 100) {
         confess [1003, "You must have a functional development ministry!"];
     }
@@ -54,8 +56,9 @@ sub subsidize_one_build {
     if (ref($args) ne "HASH") {
         confess [1000, "You have not supplied a hash reference"];
     }
-    my $empire              = $self->get_empire_by_session($args->{session_id});
-    my $building            = $self->get_building($empire, $args->{building_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}, building_id => $args->{building_id} });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->effective_level > 0 and $building->effective_efficiency == 100) {
         confess [1003, "You must have a functional development ministry!"];
     }
@@ -93,8 +96,9 @@ sub cancel_build {
     if (ref($args) ne "HASH") {
         confess [1000, "You have not supplied a hash reference"];
     }
-    my $empire              = $self->get_empire_by_session($args->{session_id});
-    my $building            = $self->get_building($empire, $args->{building_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}, building_id => $args->{building_id} });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $scheduled_building  = Lacuna->db->resultset('Building')->find({id => $args->{scheduled_id}});
     if ($scheduled_building->body_id != $building->body_id) {
         confess [1003, "That building is not on the same planet as your development ministry."];
diff --git a/lib/Lacuna/RPC/Building/DistributionCenter.pm b/lib/Lacuna/RPC/Building/DistributionCenter.pm
index f1e6806c..b8c99488 100644
--- a/lib/Lacuna/RPC/Building/DistributionCenter.pm
+++ b/lib/Lacuna/RPC/Building/DistributionCenter.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{reserve} = {
             resources           => $building->work->{reserved},
@@ -36,18 +37,20 @@ around 'view' => sub {
 
 sub reserve {
     my ($self, $session_id, $building_id, $resources) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->reserve($resources);
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub release_reserve {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->release_reserve;
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(reserve release_reserve get_stored_resources));
diff --git a/lib/Lacuna/RPC/Building/Embassy.pm b/lib/Lacuna/RPC/Building/Embassy.pm
index 0a0a0894..8d5919e5 100644
--- a/lib/Lacuna/RPC/Building/Embassy.pm
+++ b/lib/Lacuna/RPC/Building/Embassy.pm
@@ -13,9 +13,10 @@ sub app_url {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $alliance = eval{$building->alliance};
     if (defined $alliance) {
         $out->{alliance_status} = $alliance->get_status;
@@ -29,12 +30,13 @@ sub model_class {
 
 sub assign_alliance_leader {
     my ($self, $session_id, $building_id, $empire_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($empire_id) {
         confess [1002, 'You must specify which empire you want to take over leadership.'];
     }
-    my $new_leader = Lacuna->db->resultset('Lacuna::DB::Result::Empire')->find($empire_id);
+    my $new_leader = Lacuna->db->resultset('Empire')->find($empire_id);
     unless (defined $new_leader) {
         confess [1002, 'The empire you specified to take over as leader does not exist.'];
     }
@@ -47,8 +49,9 @@ sub assign_alliance_leader {
 
 sub create_alliance {
     my ($self, $session_id, $building_id, $name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $alliance = $building->create_alliance($name);
     return {
         status          => $self->format_status($empire, $building->body),
@@ -58,8 +61,9 @@ sub create_alliance {
 
 sub get_alliance_status {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     return {
         status          => $self->format_status($empire, $building->body),
         alliance        => $building->get_alliance_status,
@@ -68,8 +72,9 @@ sub get_alliance_status {
 
 sub dissolve_alliance {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->dissolve_alliance;
     $empire->discard_changes;
     return {
@@ -79,8 +84,9 @@ sub dissolve_alliance {
 
 sub leave_alliance {
     my ($self, $session_id, $building_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->leave_alliance($message);
     return {
         status          => $self->format_status($empire, $building->body),
@@ -89,21 +95,23 @@ sub leave_alliance {
 
 sub expel_member {
     my ($self, $session_id, $building_id, $member_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-    my $member = Lacuna->db->resultset('Lacuna::DB::Result::Empire')->find($member_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $member = Lacuna->db->resultset('Empire')->find($member_id);
     $building->expel_member($member, $message);
     return $self->get_alliance_status($empire, $building);
 }
 
 sub accept_invite {
     my ($self, $session_id, $building_id, $invite_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot join alliances.'];
     }
     $empire->current_session->check_captcha;
-    my $building = $self->get_building($empire, $building_id);
     unless ($invite_id) {
         confess [1002, 'You must specify an invite id.'];
     }
@@ -122,8 +130,9 @@ sub accept_invite {
 
 sub reject_invite {
     my ($self, $session_id, $building_id, $invite_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($invite_id) {
         confess [1002, 'You must specify an invite id.'];
     }
@@ -139,8 +148,9 @@ sub reject_invite {
 
 sub withdraw_invite {
     my ($self, $session_id, $building_id, $invite_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($invite_id) {
         confess [1002, 'You must specify an invite id.'];
     }
@@ -156,8 +166,9 @@ sub withdraw_invite {
 
 sub send_invite {
     my ($self, $session_id, $building_id, $empire_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($empire_id) {
         confess [1002, 'You must specify which empire you want to invite.'];
     }
@@ -173,8 +184,9 @@ sub send_invite {
 
 sub get_pending_invites {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     return {
         invites         => $building->get_pending_invites,
         status          => $self->format_status($empire, $building->body),
@@ -183,8 +195,9 @@ sub get_pending_invites {
 
 sub get_my_invites {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     return {
         invites         => $building->get_my_invites,
         status          => $self->format_status($empire, $building->body),
@@ -194,8 +207,9 @@ sub get_my_invites {
 
 sub update_alliance {
     my ($self, $session_id, $building_id, $params) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $alliance = $building->update_alliance($params);
     return {
         alliance        => $alliance->get_status,
@@ -205,8 +219,9 @@ sub update_alliance {
 
 sub view_stash {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     my %stored;
     foreach my $resource ('water','energy',FOOD_TYPES,ORE_TYPES) {
@@ -223,24 +238,27 @@ sub view_stash {
 
 sub donate_to_stash {
     my ($self, $session_id, $building_id, $donation) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->alliance->donate($building->body, $donation);
-    return $self->view_stash($empire, $building);
+    return $self->view_stash($session, $building);
 }
 
 sub exchange_with_stash {
     my ($self, $session_id, $building_id, $donation, $request) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->exchange_with_stash($donation, $request);
-    return $self->view_stash($empire, $building);
+    return $self->view_stash($session, $building);
 }
 
 sub view_propositions {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $propositions = $building->propositions->search({ status => 'Pending'});
     while (my $proposition = $propositions->next) {
@@ -255,9 +273,9 @@ sub view_propositions {
 
 sub cast_vote {
     my ($self, $session_id, $building_id, $proposition_id, $vote) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $cache = Lacuna->cache;
     my $lock = 'vote_lock_'.$empire->id;
     if ($cache->get($lock, $proposition_id)) {
diff --git a/lib/Lacuna/RPC/Building/EnergyReserve.pm b/lib/Lacuna/RPC/Building/EnergyReserve.pm
index bf3935fa..93c1e528 100644
--- a/lib/Lacuna/RPC/Building/EnergyReserve.pm
+++ b/lib/Lacuna/RPC/Building/EnergyReserve.pm
@@ -18,8 +18,9 @@ sub dump {
 	if ($amount <= 0) {
 		confess [1009, 'You must specify an amount greater than 0.'];
 	}
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     $body->spend_type('energy', $amount);
     $body->add_type('waste', $amount);
diff --git a/lib/Lacuna/RPC/Building/Entertainment.pm b/lib/Lacuna/RPC/Building/Entertainment.pm
index 7736fda0..a2d3cf4a 100644
--- a/lib/Lacuna/RPC/Building/Entertainment.pm
+++ b/lib/Lacuna/RPC/Building/Entertainment.pm
@@ -17,22 +17,25 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{ducks_quacked} = Lacuna->cache->get('ducks','quacked');
     return $out;
 };
 
 sub get_lottery_voting_options {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    $empire->current_session->check_captcha;
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot enter the lottery.'];
     }
+    $empire->current_session->check_captcha;
     my $cache = Lacuna->cache;
-    my $building = $self->get_building($empire, $building_id); 
     my @list;
     my $config = Lacuna->config;
     my $server_url = $config->get('server_url');
@@ -49,26 +52,30 @@ sub get_lottery_voting_options {
     };
 }
 
+# no point in reinitialising this each time quack is called.
+my @quacks = (
+    'quack',
+    'QUACK',
+    'Quack',
+    'Quack! Quack!',
+    'Quack! Quack! Quack!',
+    'Quack!!!',
+    'Quaaaaaack!',
+    'Q-U-A-C-K',
+    ".(,)=\n~{#}~\n_|V|_",
+    '|\__( o)>',
+    '[kwak]',
+    'noun: the harsh, throaty cry of a duck or any similar sound.',
+    "       ,~~.\n      (  6 )-_,\n (\___ )=='-'\n  \ .   ) )\n   \ `-' /       \n~'`~'`~'`~'`~",
+    "    ,,,,,\n   (o   o)\n    /. .\ \n   (_____)\n     : :\n    ##O##\n  ,,,: :,,,\n _)\ : : /(____\n{  \     /  ___}\n \/)     ((/\n  (_______)\n    :   :\n    :   :\n   / \ / \\n   \"\"\" \"\"\"",
+    "What's up, doc?",
+);
+
 sub duck_quack {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id); 
-    my @quacks = (
-        'quack',
-        'QUACK',
-        'Quack',
-        'Quack! Quack!',
-        'Quack! Quack! Quack!',
-        'Quack!!!',
-        'Quaaaaaack!',
-        'Q-U-A-C-K',
-        ".(,)=\n~{#}~\n_|V|_",
-        '|\__( o)>',
-        '[kwak]',
-        'noun: the harsh, throaty cry of a duck or any similar sound.',
-        "       ,~~.\n      (  6 )-_,\n (\___ )=='-'\n  \ .   ) )\n   \ `-' /       \n~'`~'`~'`~'`~",
-        "    ,,,,,\n   (o   o)\n    /. .\ \n   (_____)\n     : :\n    ##O##\n  ,,,: :,,,\n _)\ : : /(____\n{  \     /  ___}\n \/)     ((/\n  (_______)\n    :   :\n    :   :\n   / \ / \\n   \"\"\" \"\"\"",
-    );
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     Lacuna->cache->increment('ducks', 'quacked', 1, 60 * 60 * 24);
     return $quacks[ rand @quacks ];
 }
diff --git a/lib/Lacuna/RPC/Building/EssentiaVein.pm b/lib/Lacuna/RPC/Building/EssentiaVein.pm
index f060a9c0..5ea8a7e8 100644
--- a/lib/Lacuna/RPC/Building/EssentiaVein.pm
+++ b/lib/Lacuna/RPC/Building/EssentiaVein.pm
@@ -15,9 +15,10 @@ sub model_class {
 
 around view => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
 
     my $body = $building->body;
     $out->{building}{drain_capable} = $body->happiness >= 0 ?
@@ -28,8 +29,9 @@ around view => sub {
 
 sub drain {
     my ($self, $session_id, $building_id, $times) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my $body = $building->body;
     confess [1010, "Cannot drain essentia from unhappy mines."]
diff --git a/lib/Lacuna/RPC/Building/FoodReserve.pm b/lib/Lacuna/RPC/Building/FoodReserve.pm
index 9d151fc9..6bfb6b78 100644
--- a/lib/Lacuna/RPC/Building/FoodReserve.pm
+++ b/lib/Lacuna/RPC/Building/FoodReserve.pm
@@ -16,9 +16,11 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
+
     my %foods;
     my $body = $building->body;
     foreach my $food (FOOD_TYPES) {
@@ -33,15 +35,15 @@ sub dump {
 	if ($amount <= 0) {
 		confess [1009, 'You must specify an amount greater than 0.'];
 	}
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-    my $body = $building->body;
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
     $body->spend_type($type, $amount);
     $body->add_type('waste', $amount);
     $body->update;
     return {
         status      => $self->format_status($empire, $body),
-        };
+    };
 }
 
 __PACKAGE__->register_rpc_method_names(qw(dump));
diff --git a/lib/Lacuna/RPC/Building/GeneticsLab.pm b/lib/Lacuna/RPC/Building/GeneticsLab.pm
index 076af641..e5888b75 100644
--- a/lib/Lacuna/RPC/Building/GeneticsLab.pm
+++ b/lib/Lacuna/RPC/Building/GeneticsLab.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub prepare_experiment {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     return {
         status          => $self->format_status($empire, $building->body),
         survival_odds   => $building->survival_odds,
@@ -30,8 +31,9 @@ sub prepare_experiment {
 
 sub run_experiment {
     my ($self, $session_id, $building_id, $spy_id, $affinity) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($spy_id) {
         confess [1002, 'You have to specify a spy id.'];
     }
@@ -51,8 +53,9 @@ sub run_experiment {
 
 sub rename_species {
     my ($self, $session_id, $building_id, $me) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $me->{name} =~ s{^\s+(.*)\s+$}{$1}xms; # remove extra white space
     Lacuna::Verify->new(content=>\$me->{name}, throws=>[1000,'Species name not available.', 'name'])
         ->length_lt(31)
@@ -61,7 +64,7 @@ sub rename_species {
         ->no_restricted_chars
         ->no_profanity;
 
-    # and the description        
+    # and the description
     Lacuna::Verify->new(content=>\$me->{description}, throws=>[1005,'Description invalid.', 'description'])
         ->length_lt(1025)
         ->no_restricted_chars
diff --git a/lib/Lacuna/RPC/Building/IntelTraining.pm b/lib/Lacuna/RPC/Building/IntelTraining.pm
index 302d131d..50cfb19f 100644
--- a/lib/Lacuna/RPC/Building/IntelTraining.pm
+++ b/lib/Lacuna/RPC/Building/IntelTraining.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $boost = (time < $empire->spy_training_boost->epoch) ? 1.5 : 1;
     my $points_per = $building->effective_level * $boost;
     $out->{spies} = {
diff --git a/lib/Lacuna/RPC/Building/Intelligence.pm b/lib/Lacuna/RPC/Building/Intelligence.pm
index 90906c36..1711cf68 100644
--- a/lib/Lacuna/RPC/Building/Intelligence.pm
+++ b/lib/Lacuna/RPC/Building/Intelligence.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub view_spies {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @spies;
     my $body = $building->body;
@@ -55,8 +56,9 @@ sub view_spies {
 
 sub view_all_spies {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @spies;
     my $body = $building->body;
     my %planets = ( $body->id => $body );
@@ -85,8 +87,9 @@ sub view_all_spies {
 # This call is too intensive for server at this time. Disabled
 # sub view_empire_spies {
 #     my ($self, $session_id, $building_id) = @_;
-#     my $empire = $self->get_empire_by_session($session_id);
-#     my $building = $self->get_building($empire, $building_id);
+#    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+#    my $empire   = $session->current_empire;
+#    my $building = $session->current_building;
 #     my @spies;
 #     my $body = $building->body;
 #     my %planets = ( $body->id => $body );
@@ -114,8 +117,9 @@ sub view_all_spies {
 
 sub subsidize_training {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->efficiency == 100) {
         confess [1010, "You can not subsidize spies when the Intelligence Ministry is in need of repair."];
     }
@@ -142,14 +146,15 @@ sub subsidize_training {
     }
     $building->finish_work->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 
 sub assign_spy {
     my ($self, $session_id, $building_id, $spy_id, $assignment) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->efficiency == 100) {
         confess [1010, "You can not communicate with your spy when the Intelligence Ministry is in need of repair."];
     }
@@ -168,8 +173,9 @@ sub assign_spy {
 
 sub burn_spy {
     my ($self, $session_id, $building_id, $spy_id, $assignment) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $spy = $building->get_spy($spy_id);
     unless (defined $spy) {
         confess [1002, "Spy not found."];
@@ -191,8 +197,9 @@ sub burn_spy {
 
 sub train_spy {
     my ($self, $session_id, $building_id, $quantity) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->efficiency == 100) {
         confess [1010, "You can not train spies when the Intelligence Ministry is in need of repair."];
     }
@@ -243,9 +250,10 @@ sub train_spy {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{spies} = {
         maximum         => $building->max_spies,
         current         => $building->spy_count,
@@ -263,9 +271,10 @@ sub name_spy {
         ->length_lt(31)
         ->length_gt(2)
         ->no_restricted_chars;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-    my $spy = $building->get_spy($spy_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $spy      = $building->get_spy($spy_id);
     $spy->name($name);
     $spy->update;
     return {
diff --git a/lib/Lacuna/RPC/Building/LibraryOfJith.pm b/lib/Lacuna/RPC/Building/LibraryOfJith.pm
index ed64513b..887974f7 100644
--- a/lib/Lacuna/RPC/Building/LibraryOfJith.pm
+++ b/lib/Lacuna/RPC/Building/LibraryOfJith.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub research_species {
     my ($self, $session_id, $building_id, $view_empire_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $view_empire = Lacuna->db->resultset('Lacuna::DB::Result::Empire')->find($view_empire_id);
     
     unless (defined $view_empire) {
diff --git a/lib/Lacuna/RPC/Building/MayhemTraining.pm b/lib/Lacuna/RPC/Building/MayhemTraining.pm
index f4867baa..d9b77b29 100644
--- a/lib/Lacuna/RPC/Building/MayhemTraining.pm
+++ b/lib/Lacuna/RPC/Building/MayhemTraining.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $boost = (time < $empire->spy_training_boost->epoch) ? 1.5 : 1;
     my $points_per = $building->effective_level * $boost;
     $out->{spies} = {
diff --git a/lib/Lacuna/RPC/Building/MercenariesGuild.pm b/lib/Lacuna/RPC/Building/MercenariesGuild.pm
index 60013e45..e8681d60 100644
--- a/lib/Lacuna/RPC/Building/MercenariesGuild.pm
+++ b/lib/Lacuna/RPC/Building/MercenariesGuild.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub get_trade_ships {
     my ($self, $session_id, $building_id, $target_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $target = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($target_id) if $target_id;
     my @ships;
     my $ships = $building->trade_ships;
@@ -40,8 +41,9 @@ sub withdraw_from_market {
         confess [1013, 'A buyer has placed an offer on this trade. Please wait a few moments and try again.'];
     }
     $cache->set('trade_lock',$trade_id,1,5);
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $trade = $building->market->find($trade_id);
     unless (defined $trade) {
         confess [1002, 'Could not find that trade. Perhaps it has already been accepted.'];
@@ -66,8 +68,9 @@ sub accept_from_market {
         $cache->delete('trade_lock',$trade_id);
     };
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a mercenaries guild that has not yet been built.'] unless $building->effective_level > 0;
     confess [1013, 'You cannot use a mercenaries guild that is not fully operational.'] unless $building->effective_efficiency == 100;
 
@@ -135,8 +138,9 @@ sub accept_from_market {
 
 sub add_to_market {
     my ($self, $session_id, $building_id, $spy_id, $ask, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a mercenaries guild that has not yet been built.'] unless $building->effective_level > 0;
     my $cost = sprintf "%.1f", 3 - $building->effective_level * 0.1;
     unless ($empire->essentia >= $cost) {
@@ -156,8 +160,9 @@ sub add_to_market {
 
 sub view_my_market {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||=1;
     my $my_trades = $building->my_market->search(undef, { rows => 25, page => $page_number });
     my @trades;
@@ -179,8 +184,9 @@ sub view_my_market {
 
 sub view_market {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||=1;
     my $all_trades = $building->available_market->search(
         undef,
@@ -216,8 +222,9 @@ sub view_market {
 
 sub get_spies {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $spies = Lacuna->db->resultset('Lacuna::DB::Result::Spies')->search(
         { empire_id => $empire->id, on_body_id => $building->body_id, task => { in => ['Counter Espionage','Idle'] } },
         {
@@ -246,12 +253,13 @@ sub report_abuse {
     unless ($trade_id) {
         confess [1002, 'You have not specified a trade to withdraw.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
     my $cache = Lacuna->cache;
     if ($cache->get('trade_lock', $trade_id)) {
         confess [1013, 'A buyer has placed an offer on this trade. Please wait a few moments and try again.'];
     }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $times_reporting = $cache->increment('empire_reporting_trade_abuse'.DateTime->now->day, $empire->id, 1, 60 * 60 * 24);
     if ($times_reporting > 10) {
         confess [1010, 'You have reported enough abuse for one day.'];
diff --git a/lib/Lacuna/RPC/Building/MiningMinistry.pm b/lib/Lacuna/RPC/Building/MiningMinistry.pm
index 99aa5776..29d73d41 100644
--- a/lib/Lacuna/RPC/Building/MiningMinistry.pm
+++ b/lib/Lacuna/RPC/Building/MiningMinistry.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub view_ships {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ships = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->search({ 
         body_id => $building->body_id, 
         task    => { in => ['Mining', 'Docked']},
@@ -42,8 +43,9 @@ sub view_ships {
 
 sub view_platforms {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $platforms = $building->platforms;
     my @fleet;
     while (my $platform = $platforms->next) {
@@ -82,8 +84,9 @@ sub view_platforms {
 
 sub abandon_platform {
     my ($self, $session_id, $building_id, $platform_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $platform = Lacuna->db->resultset('Lacuna::DB::Result::MiningPlatforms')->find($platform_id);
     unless (defined $platform) {
         confess [1002, "Platform not found."];
@@ -99,18 +102,20 @@ sub abandon_platform {
 
 sub mass_abandon_platform {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-	$building->platforms->delete;
-	return {
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    $building->platforms->delete;
+    return {
         status  => $self->format_status($empire, $building->body),
     }; 
 }
 
 sub add_cargo_ship_to_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
         confess [1002, "Ship not found."];
@@ -135,8 +140,9 @@ sub add_cargo_ship_to_fleet {
 
 sub remove_cargo_ship_from_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
         confess [1002, "Ship not found."];
diff --git a/lib/Lacuna/RPC/Building/MissionCommand.pm b/lib/Lacuna/RPC/Building/MissionCommand.pm
index c9d8556b..9b968087 100644
--- a/lib/Lacuna/RPC/Building/MissionCommand.pm
+++ b/lib/Lacuna/RPC/Building/MissionCommand.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub get_missions {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @missions;
     my $missions = $building->missions;
     my $count;
@@ -51,8 +52,9 @@ sub get_missions {
 
 sub complete_mission {
     my ($self, $session_id, $building_id, $mission_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1002, 'Please specify a mission id.'] unless $mission_id;
     my $mission = $building->missions->find($mission_id);
     confess [1002, 'No such mission.'] unless $mission;
@@ -70,8 +72,9 @@ sub complete_mission {
 
 sub skip_mission {
     my ($self, $session_id, $building_id, $mission_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1002, 'Please specify a mission id.'] unless $mission_id;
     my $mission = $building->missions->find($mission_id);
     confess [1002, 'No such mission.'] unless $mission;
diff --git a/lib/Lacuna/RPC/Building/Network19.pm b/lib/Lacuna/RPC/Building/Network19.pm
index 0c01139a..6e856d42 100644
--- a/lib/Lacuna/RPC/Building/Network19.pm
+++ b/lib/Lacuna/RPC/Building/Network19.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub view_news {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     my @all = ($body->zone, $body->adjacent_zones);
     my @zones;
@@ -54,8 +55,9 @@ sub view_news {
 
 sub restrict_coverage {
     my ($self, $session_id, $building_id, $onoff) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($onoff ne '0' && $onoff ne '1') {
         confess [1009, 'The valid values for onoff are 1 or 0.'];
     }
@@ -79,9 +81,10 @@ sub restrict_coverage {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{restrict_coverage} = $building->body->restrict_coverage;
     return $out;
 };
diff --git a/lib/Lacuna/RPC/Building/Observatory.pm b/lib/Lacuna/RPC/Building/Observatory.pm
index 8a4bc757..59e51c23 100644
--- a/lib/Lacuna/RPC/Building/Observatory.pm
+++ b/lib/Lacuna/RPC/Building/Observatory.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub abandon_probe {
     my ($self, $session_id, $building_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $star = Lacuna->db->resultset('Lacuna::DB::Result::Map::Star')->find($star_id);
     unless (defined $star) {
         confess [ 1002, 'Star does not exist.', $star_id];
@@ -35,8 +36,9 @@ sub abandon_probe {
 
 sub abandon_all_probes {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->probes->delete;
     $empire->clear_probed_stars;
     return {status => $self->format_status($empire, $building->body)};
@@ -44,8 +46,9 @@ sub abandon_all_probes {
 
 sub get_probed_stars {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @stars;
     $page_number ||= 1;
     my $probes = $building->probes->search(undef,{ rows => 30, page => $page_number });
diff --git a/lib/Lacuna/RPC/Building/OracleOfAnid.pm b/lib/Lacuna/RPC/Building/OracleOfAnid.pm
index e6db6b74..17cf3d35 100644
--- a/lib/Lacuna/RPC/Building/OracleOfAnid.pm
+++ b/lib/Lacuna/RPC/Building/OracleOfAnid.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub get_star {
     my ($self, $session_id, $building_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $star = Lacuna->db->resultset('Lacuna::DB::Result::Map::Star')->find($star_id);
     unless (defined $star) {
         confess [1002, "Couldn't find a star."];
@@ -37,8 +38,9 @@ sub get_probed_stars {
         confess [1002, "Page size cannot exceed 200."];
     }
 
-    my $empire      = $self->get_empire_by_session($args->{session_id});
-    my $building    = $self->get_building($empire, $args->{building_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}, building_id => $args->{building_id} });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my @stars;
     my $probes = $building->probes->search(undef,{ rows => $page_size, page => $page_number });
@@ -55,7 +57,7 @@ sub get_probed_stars {
 
 __PACKAGE__->register_rpc_method_names(qw(
     get_star
-    get_probed_stars    
+    get_probed_stars
 ));
 
 
diff --git a/lib/Lacuna/RPC/Building/OreStorage.pm b/lib/Lacuna/RPC/Building/OreStorage.pm
index 284d17f4..a7d34695 100644
--- a/lib/Lacuna/RPC/Building/OreStorage.pm
+++ b/lib/Lacuna/RPC/Building/OreStorage.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my %ores;
     my $body = $building->body;
     foreach my $ore (ORE_TYPES) {
@@ -33,15 +34,16 @@ sub dump {
 	if ($amount <= 0) {
 		confess [1009, 'You must specify an amount greater than 0.'];
 	}
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     $body->spend_type($type, $amount);
     $body->add_type('waste', $amount);
     $body->update;
     return {
         status      => $self->format_status($empire, $body),
-        };
+    };
 }
 
 __PACKAGE__->register_rpc_method_names(qw(dump));
diff --git a/lib/Lacuna/RPC/Building/Park.pm b/lib/Lacuna/RPC/Building/Park.pm
index 366077c7..67653df3 100644
--- a/lib/Lacuna/RPC/Building/Park.pm
+++ b/lib/Lacuna/RPC/Building/Park.pm
@@ -15,9 +15,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{party} = {
             seconds_remaining   => $building->work_seconds_remaining,
@@ -32,16 +33,18 @@ around 'view' => sub {
 
 sub throw_a_party {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->throw_a_party;
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub subsidize_party {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "There is no party."];
@@ -58,7 +61,7 @@ sub subsidize_party {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(throw_a_party subsidize_party));
diff --git a/lib/Lacuna/RPC/Building/Parliament.pm b/lib/Lacuna/RPC/Building/Parliament.pm
index fccd5d9f..17f1b728 100644
--- a/lib/Lacuna/RPC/Building/Parliament.pm
+++ b/lib/Lacuna/RPC/Building/Parliament.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub max_members {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $leader_emp = $building->body->alliance->leader;
     my $leader_planets = $leader_emp->planets;
     my @planet_ids;
@@ -36,8 +37,9 @@ sub max_members {
 
 sub get_stars_in_jurisdiction {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $stars = $building->body->stars->search({},{order_by => "name"});
     while (my $star = $stars->next) {
@@ -51,8 +53,9 @@ sub get_stars_in_jurisdiction {
 
 sub get_bodies_for_star_in_jurisdiction {
     my ($self, $session_id, $building_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($star_id) {
         confess [1002, 'You have to specify a star id.'];
     }
@@ -73,8 +76,9 @@ sub get_bodies_for_star_in_jurisdiction {
 
 sub get_mining_platforms_for_asteroid_in_jurisdiction {
     my ($self, $session_id, $building_id, $asteroid_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my @star_ids = $building->body->stars->get_column('id')->all;
     unless ($asteroid_id) {
@@ -105,7 +109,9 @@ sub get_mining_platforms_for_asteroid_in_jurisdiction {
 
 sub view_laws {
     my ($self, $session_id, $body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
+
     my $body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')
                 ->find($body_id);
     if ($body->isa('Lacuna::DB::Result::Map::Body::Planet::Station')) {
@@ -133,12 +139,13 @@ sub view_laws {
 
 sub propose_fire_bfg {
     my ($self, $session_id, $building_id, $body_id, $reason) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
     $empire->current_session->check_captcha;
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 25) {
         confess [1013, 'Parliament must be level 25 to propose using the BFG.',25];
     }
@@ -178,11 +185,12 @@ sub propose_fire_bfg {
 
 sub propose_writ {
     my ($self, $session_id, $building_id, $title, $writ) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 4) {
         confess [1013, 'Parliament must be level 4 to propose a writ.',4];
     }
@@ -213,11 +221,12 @@ sub propose_writ {
 
 sub propose_transfer_station_ownership {
     my ($self, $session_id, $building_id, $to_empire_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 6) {
         confess [1013, 'Parliament must be level 6 to transfer station ownership.',6];
     }
@@ -255,11 +264,12 @@ sub propose_transfer_station_ownership {
 
 sub propose_repeal_law {
     my ($self, $session_id, $building_id, $law_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 5) {
         confess [1013, 'Parliament must be level 5 to repeal a law.',5];
     }
@@ -291,11 +301,12 @@ sub propose_repeal_law {
 
 sub propose_rename_star {
     my ($self, $session_id, $building_id, $star_id, $star_name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 8) {
         confess [1013, 'Parliament must be level 8 to rename a star.',8];
     }
@@ -337,11 +348,12 @@ sub propose_rename_star {
 
 sub propose_broadcast_on_network19 {
     my ($self, $session_id, $building_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 9) {
         confess [1013, 'Parliament must be level 9 to propose a broadcast.',9];
     }
@@ -371,11 +383,12 @@ sub propose_broadcast_on_network19 {
 
 sub propose_rename_asteroid {
     my ($self, $session_id, $building_id, $asteroid_id, $name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 12) {
         confess [1013, 'Parliament must be level 12 to rename an asteroid.',12];
     }
@@ -417,11 +430,12 @@ sub propose_rename_asteroid {
 
 sub propose_rename_uninhabited {
     my ($self, $session_id, $building_id, $planet_id, $name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 17) {
         confess [1013, 'Parliament must be level 17 to rename an uninhabited planet.',17];
     }
@@ -466,11 +480,12 @@ sub propose_rename_uninhabited {
 
 sub propose_members_only_mining_rights {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 13) {
         confess [1013, 'Parliament must be level 13 to propose members only mining rights.',13];
     }
@@ -494,11 +509,12 @@ sub propose_members_only_mining_rights {
 
 sub propose_members_only_excavation {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 20) {
         confess [1013, 'Parliament must be level 20 to propose members only excavation rights.',20];
     }
@@ -522,11 +538,12 @@ sub propose_members_only_excavation {
 
 sub propose_members_only_colonization {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 18) {
         confess [1013, 'Parliament must be level 18 to propose members only colonization.',18];
     }
@@ -551,11 +568,12 @@ sub propose_members_only_colonization {
 
 sub propose_members_only_stations {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 18) {
         confess [1013, 'Parliament must be level 18 to propose members only stations.',18];
     }
@@ -579,11 +597,12 @@ sub propose_members_only_stations {
 
 sub propose_neutralize_bhg {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 23) {
         confess [1013, 'Parliament must be level 23 to propose to neutralize black hole generators.',23];
     }
@@ -607,11 +626,12 @@ sub propose_neutralize_bhg {
 
 sub allow_bhg_by_alliance {
     my ($self, $session_id, $building_id, $alliance_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 28) {
         confess [1013, 'Parliament must be level 28 to propose to neutralize black hole generators.',28];
     }
@@ -640,11 +660,12 @@ sub allow_bhg_by_alliance {
 
 sub propose_evict_mining_platform {
     my ($self, $session_id, $building_id, $platform_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 14) {
         confess [1013, 'Parliament must be level 14 to evict a mining platform.',14];
     }
@@ -679,11 +700,12 @@ sub propose_evict_mining_platform {
 
 sub propose_evict_excavator {
     my ($self, $session_id, $building_id, $excav_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 21) {
         confess [1013, 'Parliament must be level 21 to evict an excavator.',21];
     }
@@ -718,11 +740,12 @@ sub propose_evict_excavator {
 
 sub propose_elect_new_leader {
     my ($self, $session_id, $building_id, $to_empire_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 11) {
         confess [1013, 'Parliament must be level 11 to elect a new alliance leader.',11];
     }
@@ -757,11 +780,12 @@ sub propose_elect_new_leader {
 
 sub propose_induct_member {
     my ($self, $session_id, $building_id, $empire_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 10) {
         confess [1013, 'Parliament must be level 10 to induct a new alliance member.',10];
     }
@@ -803,11 +827,12 @@ sub propose_induct_member {
 
 sub propose_expel_member {
     my ($self, $session_id, $building_id, $empire_id, $message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 10) {
         confess [1013, 'Parliament must be level 10 to expel an alliance member.',10];
     }
@@ -845,11 +870,12 @@ sub propose_expel_member {
 
 sub propose_taxation {
     my ($self, $session_id, $building_id, $taxes) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 15) {
         confess [1013, 'Parliament must be level 15 to propose taxation.',15];
     }
@@ -878,11 +904,12 @@ sub propose_taxation {
 
 sub propose_foreign_aid {
     my ($self, $session_id, $building_id, $planet_id, $resources) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot create propositions.'];
     }
-    my $building = $self->get_building($empire, $building_id);
     unless ($building->effective_level >= 16) {
         confess [1013, 'Parliament must be level 16 to send out foreign aid packages.',16];
     }
@@ -941,8 +968,9 @@ sub propose_foreign_aid {
 
 sub view_taxes_collected {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $taxes = Lacuna->db->resultset('Lacuna::DB::Result::Taxes')->search({station_id => $building->body_id});
     while (my $tax = $taxes->next) {
diff --git a/lib/Lacuna/RPC/Building/PlanetaryCommand.pm b/lib/Lacuna/RPC/Building/PlanetaryCommand.pm
index 3df436de..c71c3fc3 100644
--- a/lib/Lacuna/RPC/Building/PlanetaryCommand.pm
+++ b/lib/Lacuna/RPC/Building/PlanetaryCommand.pm
@@ -17,9 +17,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{planet} = $building->body->get_status($empire);
     $out->{ore} = $building->body->get_ore_status;
     $out->{food} = $building->body->get_food_status;
@@ -34,8 +35,9 @@ around 'view' => sub {
 sub view_plans {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my @out;
     my $sorted_plans = $building->body->sorted_plans;
@@ -60,8 +62,9 @@ sub view_plans {
 
 sub subsidise_pod_cooldown {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "PCC is not in cooldown mode."];
@@ -78,7 +81,7 @@ sub subsidise_pod_cooldown {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(
diff --git a/lib/Lacuna/RPC/Building/PoliceStation.pm b/lib/Lacuna/RPC/Building/PoliceStation.pm
index 500f63b5..9d406e1f 100644
--- a/lib/Lacuna/RPC/Building/PoliceStation.pm
+++ b/lib/Lacuna/RPC/Building/PoliceStation.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub view_foreign_spies {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @out;
     my $spies = $building->foreign_spies->search(undef,
@@ -44,8 +45,9 @@ sub view_foreign_spies {
 
 sub execute_prisoner {
     my ($self, $session_id, $building_id, $prisoner_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $prisoner = $building->prisoners->find($prisoner_id);
     unless (defined $prisoner) {
         confess [1002,'Could not find that prisoner.'];
@@ -69,8 +71,9 @@ sub execute_prisoner {
 
 sub release_prisoner {
     my ($self, $session_id, $building_id, $prisoner_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $prisoner = $building->prisoners->find($prisoner_id);
     unless (defined $prisoner) {
         confess [1002,'Could not find that prisoner.'];
@@ -94,8 +97,9 @@ sub release_prisoner {
 
 sub view_prisoners {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @out;
     my $spies = $building->prisoners->search(undef,
@@ -124,8 +128,9 @@ sub view_prisoners {
 
 sub view_ships_travelling {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my $body = $building->body;
     my @travelling;
@@ -143,8 +148,9 @@ sub view_ships_travelling {
 
 sub view_foreign_ships {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @fleet;
     my $now = time;
@@ -192,8 +198,9 @@ sub view_foreign_ships {
 
 sub view_ships_orbiting {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @fleet;
     my $now = time;
diff --git a/lib/Lacuna/RPC/Building/PoliticsTraining.pm b/lib/Lacuna/RPC/Building/PoliticsTraining.pm
index 432c8524..d259f7fc 100644
--- a/lib/Lacuna/RPC/Building/PoliticsTraining.pm
+++ b/lib/Lacuna/RPC/Building/PoliticsTraining.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $boost = (time < $empire->spy_training_boost->epoch) ? 1.5 : 1;
     my $points_per = $building->effective_level * $boost;
     $out->{spies} = {
diff --git a/lib/Lacuna/RPC/Building/SSLa.pm b/lib/Lacuna/RPC/Building/SSLa.pm
index 3744fe2b..9aab30ce 100644
--- a/lib/Lacuna/RPC/Building/SSLa.pm
+++ b/lib/Lacuna/RPC/Building/SSLa.pm
@@ -15,9 +15,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{make_plan} = {
         types           => $building->makeable_plans_formatted,
         level_costs     => $building->level_costs_formatted,
@@ -32,17 +33,19 @@ around 'view' => sub {
 
 sub make_plan {
     my ($self, $session_id, $building_id, $type, $level) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->can_make_plan($type, $level);
     $building->make_plan($type, $level);
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub subsidize_plan {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "There is no plan being built."];
@@ -59,7 +62,7 @@ sub subsidize_plan {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 
diff --git a/lib/Lacuna/RPC/Building/Security.pm b/lib/Lacuna/RPC/Building/Security.pm
index d9e1f742..2a8912a4 100644
--- a/lib/Lacuna/RPC/Building/Security.pm
+++ b/lib/Lacuna/RPC/Building/Security.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub view_foreign_spies {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @out;
     my $spies = $building->foreign_spies->search(undef,
@@ -44,8 +45,9 @@ sub view_foreign_spies {
 
 sub execute_prisoner {
     my ($self, $session_id, $building_id, $prisoner_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $prisoner = $building->prisoners->find($prisoner_id);
     unless (defined $prisoner) {
         confess [1002,'Could not find that prisoner.'];
@@ -70,8 +72,9 @@ sub execute_prisoner {
 
 sub release_prisoner {
     my ($self, $session_id, $building_id, $prisoner_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $prisoner = $building->prisoners->find($prisoner_id);
     unless (defined $prisoner) {
         confess [1002,'Could not find that prisoner.'];
@@ -95,8 +98,9 @@ sub release_prisoner {
 
 sub view_prisoners {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @out;
     my $spies = $building->prisoners->search(undef,
diff --git a/lib/Lacuna/RPC/Building/Shipyard.pm b/lib/Lacuna/RPC/Building/Shipyard.pm
index 4ac2f016..3651cc51 100644
--- a/lib/Lacuna/RPC/Building/Shipyard.pm
+++ b/lib/Lacuna/RPC/Building/Shipyard.pm
@@ -18,8 +18,9 @@ sub model_class {
 
 sub view_build_queue {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     $page_number ||= 1;
     my @building;
@@ -54,15 +55,16 @@ sub view_build_queue {
 
 sub subsidize_build_queue {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
 
     my $ships = $building->building_ships;
 
     my $cost = $ships->count;
     unless ($empire->essentia >= $cost) {
-        confess [1011, "Not enough essentia."];    
+        confess [1011, "Not enough essentia."];
     }
 
     $empire->spend_essentia({
@@ -76,14 +78,15 @@ sub subsidize_build_queue {
     }
     $building->finish_work->update;
  
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub delete_build {
     my ($self, $session_id, $building_id, $ship_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     if (!ref $ship_id)
     {
@@ -123,8 +126,9 @@ sub subsidize_ship {
     if (ref($args) ne "HASH") {
         confess [1000, "You have not supplied a hash reference"];
     }
-    my $empire              = $self->get_empire_by_session($args->{session_id});
-    my $building            = $self->get_building($empire, $args->{building_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}, building_id => $args->{building_id} });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building->effective_level > 0 and $building->efficiency == 100) {
         confess [1003, "You must have a functional Space Port!"];
     }
@@ -150,7 +154,7 @@ sub subsidize_ship {
     $scheduled_ship->reschedule_queue;
     $scheduled_ship->finish_construction;
 
-    return $self->view_build_queue($empire, $building);
+    return $self->view_build_queue($session, $building);
 
 }
 
@@ -165,8 +169,9 @@ sub build_ship {
         confess [1001, "Quantity must be a positive integer"];
     }
     my $costs;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body_id     = $building->body_id;
 
     for (1..$quantity) {
@@ -180,7 +185,7 @@ sub build_ship {
         $ship->body_id($body_id);
         $ship->update;
     }
-    return $self->view_build_queue($empire, $building);
+    return $self->view_build_queue($session, $building);
 }
 
 # All buildings must be on the same body
@@ -199,7 +204,8 @@ sub build_ship {
 
 sub build_ships {
     my ($self, $session_id, $opts) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $opts->{building_id} });
+    my $empire   = $session->current_empire;
 
     my $quantity = $opts->{quantity} // 1;
     if ($quantity > 600) { # of course, this would only be reached if the planet had 20 shipyards at level 30
@@ -324,15 +330,16 @@ sub build_ships {
     #    $body->update;
     #}
 
-    #return $self->view_build_queue($empire, $building_view);
+    #return $self->view_build_queue($session, $building_view);
     Lacuna::RPC::Body->new->get_buildings($empire, $body);
 }
 
 
 sub get_buildable {
     my ($self, $session_id, $building_id, $tag) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my %buildable;
     foreach my $type (SHIP_TYPES) {
         my $ship = Lacuna->db->resultset('Ships')->new({type=>$type});
diff --git a/lib/Lacuna/RPC/Building/SpacePort.pm b/lib/Lacuna/RPC/Building/SpacePort.pm
index b50c661b..4fddfe20 100644
--- a/lib/Lacuna/RPC/Building/SpacePort.pm
+++ b/lib/Lacuna/RPC/Building/SpacePort.pm
@@ -51,8 +51,9 @@ sub find_target {
 sub get_fleet_for {
     my ($self, $session_id, $body_id, $target_params) = @_;
 
-    my $empire  = $self->get_empire_by_session($session_id);
-    my $body    = $self->get_body($empire, $body_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $body_id });
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
     my $target  = $self->find_target($target_params);
 
     my $max_berth   = Lacuna->db->resultset('Lacuna::DB::Result::Building')->search( {
@@ -101,8 +102,9 @@ sub get_fleet_for {
 
 sub get_ships_for {
     my ($self, $session_id, $body_id, $target_params) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $body = $self->get_body($empire, $body_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $body_id });
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
     my $target = $self->find_target($target_params);
     my $ships = Lacuna->db->resultset('Lacuna::DB::Result::Ships');
     
@@ -215,7 +217,8 @@ sub get_ships_for {
 
 sub send_ship {
     my ($self, $session_id, $ship_id, $target_params) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     my $target = $self->find_target($target_params);
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
@@ -283,8 +286,9 @@ sub find_arrival {
 sub send_ship_types {
     my ($self, $session_id, $body_id, $target_params, $type_params, $arrival_params) = @_;
 
-    my $empire  = $self->get_empire_by_session($session_id);
-    my $body    = $self->get_body($empire, $body_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $body_id});
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
     my $target  = $self->find_target($target_params);
     my $arrival;
     if ($arrival_params->{earliest}) {
@@ -465,7 +469,8 @@ sub send_ship_types {
 sub send_fleet {
   my ($self, $session_id, $ship_ids, $target_params, $set_speed) = @_;
   $set_speed //= 0;
-  my $empire = $self->get_empire_by_session($session_id);
+  my $session  = $self->get_session({session_id => $session_id});
+  my $empire   = $session->current_empire;
   my $target = $self->find_target($target_params);
   my $max_ships = Lacuna->config->get('ships_per_fleet') || 600;
   if (@$ship_ids > $max_ships) {
@@ -545,8 +550,9 @@ sub send_fleet {
 
 sub recall_ship {
   my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
         confess [1002, 'Could not locate that ship.'];
@@ -574,8 +580,9 @@ sub recall_ship {
 
 sub recall_all {
   my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     my @ships = $body->ships_orbiting->search(undef)->all;
     my @ret;
@@ -608,13 +615,14 @@ sub recall_all {
 
 sub prepare_send_spies {
     my ($self, $session_id, $on_body_id, $to_body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $on_body_id});
+    my $empire   = $session->current_empire;
+    my $on_body  = $session->current_body;
     if ($on_body_id == $to_body_id) {
         confess [1013, "Cannot send spies to one self."];
     }
-    my $on_body = $self->get_body($empire, $on_body_id);
     my $to_body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($to_body_id);
-    
+
     unless ($to_body->empire_id) {
         confess [1009, "Cannot send spies to an uninhabited body."];
     }
@@ -683,11 +691,12 @@ sub prepare_send_spies {
 
 sub send_spies {
     my ($self, $session_id, $on_body_id, $to_body_id, $ship_id, $spy_ids) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $on_body_id});
+    my $empire   = $session->current_empire;
     if ($on_body_id == $to_body_id) {
         confess [1013, "Cannot send spies to one self."];
     }
-    my $on_body = $self->get_body($empire, $on_body_id);
+    my $on_body = $session->current_body();
     my $to_body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($to_body_id);
     
     # make sure it's a valid target
@@ -767,11 +776,12 @@ sub send_spies {
 
 sub prepare_fetch_spies {
     my ($self, $session_id, $on_body_id, $to_body_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $to_body_id});
+    my $empire   = $session->current_empire;
     if ($on_body_id == $to_body_id) {
         confess [1013, "Cannot fetch spies to one self."];
     }
-    my $to_body = $self->get_body($empire, $to_body_id);
+    my $to_body = $session->current_body;
     my $on_body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($on_body_id);
     unless ($on_body->empire_id) {
         confess [1013, "Cannot fetch spies from an uninhabited planet."];
@@ -795,7 +805,7 @@ sub prepare_fetch_spies {
 
     my $dt_parser = Lacuna->db->storage->datetime_parser;
     my $now = $dt_parser->format_datetime( DateTime->now );
-    
+
     my $spies = Lacuna->db->resultset('Lacuna::DB::Result::Spies')->search(
         {
             on_body_id => $on_body->id, 
@@ -829,11 +839,12 @@ sub prepare_fetch_spies {
 
 sub fetch_spies {
     my ($self, $session_id, $on_body_id, $to_body_id, $ship_id, $spy_ids) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id, body_id => $to_body_id});
+    my $empire   = $session->current_empire;
     if ($on_body_id == $to_body_id) {
         confess [1013, "Cannot fetch spies to one self."];
     }
-    my $to_body = $self->get_body($empire, $to_body_id);
+    my $to_body = $session->current_body;
     my $on_body = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($on_body_id);
 
     my $max_berth = $to_body->max_berth;
@@ -899,8 +910,9 @@ sub fetch_spies {
 
 sub view_ships_travelling {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my $body = $building->body;
     my @travelling;
@@ -1020,8 +1032,9 @@ sub view_all_ships {
     $attrs->{rows} = $paging->{items_per_page} if ( defined $paging->{items_per_page} );
     $attrs->{page} = $paging->{page_number} if ( defined $paging->{page_number} );
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body = $building->body;
     my @fleet;
     my $ships = $building->ships->search( $filter, $attrs );
@@ -1039,8 +1052,9 @@ sub view_all_ships {
 
 sub view_foreign_ships {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @fleet;
     my $now = time;
@@ -1092,8 +1106,9 @@ sub view_foreign_ships {
 
 sub view_ships_orbiting {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @fleet;
     my $now = time;
@@ -1141,8 +1156,9 @@ sub view_ships_orbiting {
 
 sub _view_ships {
     my ($self, $session_id, $building_id, $page_number, $method) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @fleet;
     my $now = time;
     my $ships = $building->$method->search({}, {rows=>25, page=>$page_number, join => 'body' });
@@ -1179,7 +1195,6 @@ sub _view_ships {
                     $ship_info{image}      = $ship->image;
                 }
             }
-warn Dumper(\%ship_info); use Data::Dumper;
             push @fleet, \%ship_info;
         }
     }
@@ -1197,8 +1212,9 @@ sub name_ship {
         ->no_profanity
         ->length_lt(31)
         ->no_restricted_chars;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
         confess [1002, "Ship not found."];
@@ -1210,13 +1226,14 @@ sub name_ship {
     $ship->update;
     return {
         status                      => $self->format_status($empire, $building->body),
-    };    
+    };
 }
 
 sub scuttle_ship {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ship = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->find($ship_id);
     unless (defined $ship) {
         confess [1002, "Ship not found."];
@@ -1235,8 +1252,9 @@ sub scuttle_ship {
 
 sub mass_scuttle_ship {
     my ($self, $session_id, $building_id, $ship_ids) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     if (scalar @{$ship_ids} > 6000) {
         confess [ 1099, "More ships than can be docked on one planet!" ];
@@ -1257,8 +1275,9 @@ sub mass_scuttle_ship {
 
 sub view_battle_logs {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||= 1;
     my @logs;
     my $battle_logs = $building->battle_logs->search({}, { rows=>25, page=>$page_number, order_by => => { -desc => 'date_stamp' } });
@@ -1293,9 +1312,10 @@ sub view_battle_logs {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     return $out unless $building->effective_level > 0;
     my $docked = $building->ships->search({ task => 'Docked' });
     my %ships;
diff --git a/lib/Lacuna/RPC/Building/StationCommand.pm b/lib/Lacuna/RPC/Building/StationCommand.pm
index fe68b022..39cbde19 100644
--- a/lib/Lacuna/RPC/Building/StationCommand.pm
+++ b/lib/Lacuna/RPC/Building/StationCommand.pm
@@ -17,9 +17,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     $out->{planet} = $building->body->get_status($empire);
     $out->{ore} = $building->body->get_ore_status;
     $out->{food} = $building->body->get_food_status;
@@ -30,8 +31,9 @@ around 'view' => sub {
 
 sub view_plans {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @out;
     my $sorted_plans = $building->body->sorted_plans;
     foreach my $plan (@$sorted_plans) {
diff --git a/lib/Lacuna/RPC/Building/SubspaceSupplyDepot.pm b/lib/Lacuna/RPC/Building/SubspaceSupplyDepot.pm
index 7e3e4e67..983f0512 100644
--- a/lib/Lacuna/RPC/Building/SubspaceSupplyDepot.pm
+++ b/lib/Lacuna/RPC/Building/SubspaceSupplyDepot.pm
@@ -15,8 +15,9 @@ sub model_class {
 
 sub transmit_food {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->transmit_food;
     return {
         status      => $self->format_status($empire, $building->body),
@@ -32,8 +33,9 @@ sub transmit_food {
 
 sub transmit_energy {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->transmit_energy;
     return {
         status      => $self->format_status($empire, $building->body),
@@ -49,8 +51,9 @@ sub transmit_energy {
 
 sub transmit_ore {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->transmit_ore;
     return {
         status      => $self->format_status($empire, $building->body),
@@ -66,8 +69,9 @@ sub transmit_ore {
 
 sub transmit_water {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->transmit_water;
     return {
         status      => $self->format_status($empire, $building->body),
@@ -83,8 +87,9 @@ sub transmit_water {
 
 sub complete_build_queue {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->complete_build_queue;
     return {
         status      => $self->format_status($empire, $building->body),
diff --git a/lib/Lacuna/RPC/Building/TempleOfTheDrajilites.pm b/lib/Lacuna/RPC/Building/TempleOfTheDrajilites.pm
index 775679ff..9230f370 100644
--- a/lib/Lacuna/RPC/Building/TempleOfTheDrajilites.pm
+++ b/lib/Lacuna/RPC/Building/TempleOfTheDrajilites.pm
@@ -16,8 +16,9 @@ sub model_class {
 
 sub view_planet {
     my ($self, $session_id, $building_id, $planet_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $planet = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($planet_id);
     
     unless (defined $planet) {
@@ -50,8 +51,9 @@ sub view_planet {
 
 sub list_planets {
     my ($self, $session_id, $building_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $star;
     if ($star_id) {
         $star = Lacuna->db->resultset('Lacuna::DB::Result::Map::Star')->find($star_id);
diff --git a/lib/Lacuna/RPC/Building/TheDillonForge.pm b/lib/Lacuna/RPC/Building/TheDillonForge.pm
index 7f0df7e4..41e420d5 100644
--- a/lib/Lacuna/RPC/Building/TheDillonForge.pm
+++ b/lib/Lacuna/RPC/Building/TheDillonForge.pm
@@ -17,8 +17,9 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $out = $orig->($self, $empire, $building);
     if ($building->is_working) {
         my $work = $building->work;
@@ -121,29 +122,32 @@ PLAN:
 
 sub split_plan {
     my ($self, $session_id, $building_id, $plan_class, $level, $extra_build_level, $quantity) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $quantity = $quantity || 1;
 
     $building->split_plan($plan_class, $level, $extra_build_level, $quantity);
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub make_plan {
     my ($self, $session_id, $building_id, $plan_class, $level) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     $building->make_plan($plan_class, $level);
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
-        
+
 sub subsidize {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "Nothing is being done!"];
@@ -162,7 +166,7 @@ sub subsidize {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(split_plan make_plan subsidize));
diff --git a/lib/Lacuna/RPC/Building/TheftTraining.pm b/lib/Lacuna/RPC/Building/TheftTraining.pm
index a4e03de0..546dd35f 100644
--- a/lib/Lacuna/RPC/Building/TheftTraining.pm
+++ b/lib/Lacuna/RPC/Building/TheftTraining.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     my $boost = (time < $empire->spy_training_boost->epoch) ? 1.5 : 1;
     my $points_per = $building->effective_level * $boost;
     $out->{spies} = {
diff --git a/lib/Lacuna/RPC/Building/ThemePark.pm b/lib/Lacuna/RPC/Building/ThemePark.pm
index e5e76fc8..64f609ec 100644
--- a/lib/Lacuna/RPC/Building/ThemePark.pm
+++ b/lib/Lacuna/RPC/Building/ThemePark.pm
@@ -16,9 +16,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{themepark} = {
             food_type_count           => $building->work->{food_type_count},
@@ -31,10 +32,11 @@ around 'view' => sub {
 
 sub operate {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->operate;
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 
diff --git a/lib/Lacuna/RPC/Building/Trade.pm b/lib/Lacuna/RPC/Building/Trade.pm
index 2be0d34c..23d731ce 100644
--- a/lib/Lacuna/RPC/Building/Trade.pm
+++ b/lib/Lacuna/RPC/Building/Trade.pm
@@ -21,8 +21,9 @@ sub model_class {
 
 sub get_trade_ships {
     my ($self, $session_id, $building_id, $target_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $target = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')->find($target_id) if $target_id;
     my @ships;
     my $ships = $building->trade_ships;
@@ -38,8 +39,9 @@ sub get_trade_ships {
 
 sub add_supply_ship_to_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless (defined $building) {
         confess [1002, "Building not found."];
     }
@@ -72,8 +74,9 @@ sub add_supply_ship_to_fleet {
 
 sub add_waste_ship_to_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless (defined $building) {
         confess [1002, "Building not found."];
     }
@@ -106,8 +109,9 @@ sub add_waste_ship_to_fleet {
 
 sub remove_supply_ship_from_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless (defined $building) {
         confess [1002, "Building not found."];
     }
@@ -138,8 +142,9 @@ sub remove_supply_ship_from_fleet {
 
 sub remove_waste_ship_from_fleet {
     my ($self, $session_id, $building_id, $ship_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless (defined $building) {
         confess [1002, "Building not found."];
     }
@@ -171,8 +176,9 @@ sub remove_waste_ship_from_fleet {
 sub get_supply_ships {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my @ships;
     my $ships       = $building->all_supply_ships;
@@ -187,8 +193,9 @@ sub get_supply_ships {
 
 sub get_waste_ships {
     my ($self, $session_id, $building_id) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body        = $building->body;
     # get the local star
     my $target      = Lacuna->db->resultset('Lacuna::DB::Result::Map::Star')->find($body->star_id);
@@ -205,8 +212,9 @@ sub get_waste_ships {
 
 sub view_supply_chains {
     my ($self, $session_id, $building_id) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building) {
         confess [1002, "Cannot find that building."];
     }
@@ -227,11 +235,9 @@ sub view_supply_chains {
 
 sub view_waste_chains {
     my ($self, $session_id, $building_id) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
-    unless ($building) {
-        confess [1002, "Cannot find that building."];
-    }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @waste_chains;
     my $chains      = $building->waste_chains;
     while (my $waste_push = $chains->next) {
@@ -246,11 +252,9 @@ sub view_waste_chains {
 sub delete_supply_chain {
     my ($self, $session_id, $building_id, $supply_chain_id) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
-    unless ($building) {
-        confess [1002, "Cannot find that building."];
-    }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my $chain = Lacuna->db->resultset('Lacuna::DB::Result::SupplyChain')->find($supply_chain_id);
     if ($chain) {
@@ -262,15 +266,9 @@ sub delete_supply_chain {
 sub create_supply_chain {
     my ($self, $session_id, $building_id, $target_id, $resource_type, $resource_hour) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    unless (defined $building_id) {
-        confess [1002, "You must specify a building."];
-    }
-
-    my $building    = $self->get_building($empire, $building_id);
-    unless ($building) {
-        confess [1002, "Cannot find that building."];
-    }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body        = $building->body;
     my $max_chains = $building->effective_level * 3;
     if ($body->out_supply_chains->count >= $max_chains) {
@@ -323,11 +321,9 @@ sub create_supply_chain {
 
 sub update_supply_chain {
     my ($self, $session_id, $building_id, $supply_chain_id, $resource_type, $resource_hour) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
-    unless ($building) {
-        confess [1002, "Cannot find that building."];
-    }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body        = $building->body;
     unless ($supply_chain_id) {
         confess [1002, "You must specify a supply chain id."];
@@ -355,11 +351,9 @@ sub update_supply_chain {
 
 sub update_waste_chain {
     my ($self, $session_id, $building_id, $waste_chain_id, $waste_hour) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
-    unless ($building) {
-        confess [1002, "Cannot find that building."];
-    }
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $body        = $building->body;
     unless ($waste_chain_id) {
         confess [1002, "You must specify a waste chain id."];
@@ -385,8 +379,9 @@ sub update_waste_chain {
 
 sub push_items {
     my ($self, $session_id, $building_id, $target_id, $items, $options) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a trade ministry that has not yet been built.'] unless $building->effective_level > 0;
     my $cache = Lacuna->cache;
     if (! $cache->add('trade_add_lock', $building_id, 1, 5)) {
@@ -443,8 +438,9 @@ sub withdraw_from_market {
     if (! $cache->add('trade_lock', $trade_id, 1, 5)) {
         confess [1013, 'A buyer has placed an offer on this trade. Please wait a few moments and try again.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $trade = $building->market->find($trade_id);
     unless (defined $trade) {
         confess [1002, 'Could not find that trade. Perhaps it has already been accepted.'];
@@ -469,8 +465,9 @@ sub accept_from_market {
         $cache->delete('trade_lock',$trade_id);
     };
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a trade ministry that has not yet been built.'] unless $building->effective_level > 0;
 
     $empire->current_session->check_captcha;
@@ -521,8 +518,9 @@ sub accept_from_market {
 
 sub add_to_market {
     my ($self, $session_id, $building_id, $offer, $ask, $options) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a trade ministry that has not yet been built.'] unless $building->effective_level > 0;
     my $cache = Lacuna->cache;
     if (! $cache->add('trade_add_lock', $building_id, 1, 5)) {
diff --git a/lib/Lacuna/RPC/Building/Transporter.pm b/lib/Lacuna/RPC/Building/Transporter.pm
index c0a35e23..c833f2aa 100644
--- a/lib/Lacuna/RPC/Building/Transporter.pm
+++ b/lib/Lacuna/RPC/Building/Transporter.pm
@@ -18,8 +18,9 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $out = $orig->($self, $empire, $building);
     $out->{transport}{max} = $building->determine_available_cargo_space;
     return $out;
@@ -27,8 +28,9 @@ around 'view' => sub {
 
 sub push_items {
     my ($self, $session_id, $building_id, $target_id, $items) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a transporter that has not yet been built.'] unless $building->effective_level > 0;
     my $cache = Lacuna->cache;
     if (! $cache->add('trade_add_lock', $building_id, 1, 5)) {
@@ -67,8 +69,9 @@ sub push_items {
 
 sub add_to_market {
     my ($self, $session_id, $building_id, $offer, $ask) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a transporter that has not yet been built.'] unless $building->effective_level > 0;
     my $cache = Lacuna->cache;
     if (! $cache->add('trade_add_lock', $building_id, 1, 5)) {
@@ -101,8 +104,9 @@ sub withdraw_from_market {
     if (! $cache->add('trade_lock', $trade_id, 1, 5)) {
         confess [1013, 'A buyer has placed an offer on this trade. Please wait a few moments and try again.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $trade = $building->market->find($trade_id);
     unless (defined $trade) {
         confess [1002, 'Could not find that trade. Perhaps it has already been accepted.'];
@@ -126,8 +130,9 @@ sub accept_from_market {
         $cache->delete('trade_lock',$trade_id);
     };
 
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a transporter that has not yet been built.'] unless $building->effective_level > 0;
 
     $empire->current_session->check_captcha;
@@ -179,8 +184,9 @@ sub accept_from_market {
 
 sub trade_one_for_one {
     my ($self, $session_id, $building_id, $have, $want, $quantity) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     confess [1013, 'You cannot use a transporter that has not yet been built.'] unless $building->effective_level > 0;
     $building->trade_one_for_one($have, $want, $quantity);
     return {
diff --git a/lib/Lacuna/RPC/Building/WasteExchanger.pm b/lib/Lacuna/RPC/Building/WasteExchanger.pm
index e3980f64..20c34583 100644
--- a/lib/Lacuna/RPC/Building/WasteExchanger.pm
+++ b/lib/Lacuna/RPC/Building/WasteExchanger.pm
@@ -15,9 +15,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{recycle} = {
             seconds_remaining   => $building->work_seconds_remaining,
@@ -37,16 +38,18 @@ around 'view' => sub {
 
 sub recycle {
     my ($self, $session_id, $building_id, $water, $ore, $energy, $use_essentia) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->recycle($water, $ore, $energy, $use_essentia);
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub subsidize_recycling {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "The Waste Exchanger isn't recycling anything."];
@@ -63,7 +66,7 @@ sub subsidize_recycling {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(recycle subsidize_recycling));
diff --git a/lib/Lacuna/RPC/Building/WasteRecycling.pm b/lib/Lacuna/RPC/Building/WasteRecycling.pm
index 95ec3618..3d78f36d 100644
--- a/lib/Lacuna/RPC/Building/WasteRecycling.pm
+++ b/lib/Lacuna/RPC/Building/WasteRecycling.pm
@@ -15,9 +15,10 @@ sub model_class {
 
 around 'view' => sub {
     my ($orig, $self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id, skip_offline => 1);
-    my $out = $orig->($self, $empire, $building);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id, skip_offline => 1 });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
+    my $out = $orig->($self, $session, $building);
     if ($building->is_working) {
         $out->{recycle} = {
             seconds_remaining   => $building->work_seconds_remaining,
@@ -37,23 +38,25 @@ around 'view' => sub {
 
 sub recycle {
     my ($self, $session_id, $building_id, $water, $ore, $energy, $use_essentia) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $building->recycle($water, $ore, $energy, $use_essentia);
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 sub subsidize_recycling {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     unless ($building->is_working) {
         confess [1010, "The Recycling Center isn't recycling anything."];
     }
  
     unless ($empire->essentia >= 2) {
-        confess [1011, "Not enough essentia."];    
+        confess [1011, "Not enough essentia."];
     }
 
     $building->finish_work->update;
@@ -63,7 +66,7 @@ sub subsidize_recycling {
     });
     $empire->update;
 
-    return $self->view($empire, $building);
+    return $self->view($session, $building);
 }
 
 __PACKAGE__->register_rpc_method_names(qw(recycle subsidize_recycling));
diff --git a/lib/Lacuna/RPC/Building/WaterStorage.pm b/lib/Lacuna/RPC/Building/WaterStorage.pm
index 838b7f3e..18f53a0c 100644
--- a/lib/Lacuna/RPC/Building/WaterStorage.pm
+++ b/lib/Lacuna/RPC/Building/WaterStorage.pm
@@ -18,9 +18,9 @@ sub dump {
 	if ($amount <= 0) {
 		confess [1009, 'You must specify an amount greater than 0.'];
 	}
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
-    my $body = $building->body;
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $body     = $session->current_body;
     $body->spend_type('water', $amount);
     $body->add_type('waste', $amount);
     $body->update;
diff --git a/lib/Lacuna/RPC/Captcha.pm b/lib/Lacuna/RPC/Captcha.pm
index 2f8eb57b..73477428 100644
--- a/lib/Lacuna/RPC/Captcha.pm
+++ b/lib/Lacuna/RPC/Captcha.pm
@@ -21,8 +21,8 @@ sub fetch {
 
 sub solve {
     my ($self, $session_id, $guid, $solution) = @_;
-    my $session = $self->get_session($session_id);
-    my $empire = $self->get_empire_by_session($session);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $cache = Lacuna->cache;
     if (defined $guid && defined $solution) {                                               # offered a solution
         my $captcha = Lacuna->cache->get_and_deserialize('captcha', $session_id);
diff --git a/lib/Lacuna/RPC/Chat.pm b/lib/Lacuna/RPC/Chat.pm
index fd932df5..0da41d2a 100644
--- a/lib/Lacuna/RPC/Chat.pm
+++ b/lib/Lacuna/RPC/Chat.pm
@@ -12,7 +12,8 @@ use Ouch;
 sub init_chat {
     my ($self, $session_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
 
     my $config = Lacuna->config;
     my $firebase_config = $config->get('firebase');
diff --git a/lib/Lacuna/RPC/Empire.pm b/lib/Lacuna/RPC/Empire.pm
index 834cd9d4..9cddbc64 100644
--- a/lib/Lacuna/RPC/Empire.pm
+++ b/lib/Lacuna/RPC/Empire.pm
@@ -18,7 +18,8 @@ sub find {
     unless (length($name) >= 3) {
         confess [1009, 'Empire name too short. Your search must be at least 3 characters.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     my $empires = Lacuna->db->resultset('Empire')->search({name => {'like' => $name.'%'}}, {rows=>100});
     my @list_of_empires;
     my $limit = 100;
@@ -221,7 +222,8 @@ sub change_password {
         ->length_gt(5)
         ->eq($password2);
 
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     if ($empire->has_current_session && $empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot modify the main account password.'];
     }
@@ -405,12 +407,15 @@ sub found {
 
 sub get_status {
     my ($self, $session_id) = @_;
-    return $self->format_status($self->get_empire_by_session($session_id));
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
+    return $self->format_status($empire);
 }
 
 sub view_profile {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     if ($empire->has_current_session && $empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot modify preferences.'];
     }
@@ -460,7 +465,8 @@ sub view_profile {
 
 sub edit_profile {
     my ($self, $session_id, $profile) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     
     # preferences
     if ($empire->has_current_session && $empire->current_session->is_sitter) {
@@ -667,7 +673,8 @@ sub set_status_message {
         ->not_empty
         ->no_restricted_chars
         ->no_profanity;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     $empire->status_message($message);
     $empire->update;
     return $self->format_status($empire);
@@ -675,7 +682,8 @@ sub set_status_message {
 
 sub view_public_profile {
     my ($self, $session_id, $empire_id) = @_;
-    my $viewer_empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $viewer_empire   = $session->current_empire;
     my $viewed_empire = Lacuna->db->resultset('Empire')->find($empire_id);
     unless (defined $viewed_empire) {
         confess [1002, 'The empire you wish to view does not exist.', $empire_id];
@@ -776,7 +784,8 @@ sub boost_spy_training {
 
 sub boost {
     my ($self, $session_id, $type, $weeks) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     $weeks //= 1;
 
     confess [1001, "Weeks must be a positive integer"]
@@ -803,7 +812,8 @@ sub boost {
 
 sub view_boosts {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     return {
         status  => $self->format_status($empire),
         boosts  => {
@@ -821,7 +831,8 @@ sub view_boosts {
 
 sub enable_self_destruct {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot enable or disable self destruct.'];
     }
@@ -831,7 +842,8 @@ sub enable_self_destruct {
 
 sub disable_self_destruct {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     if ($empire->current_session->is_sitter) {
         confess [1015, 'Sitters cannot enable or disable self destruct.'];
     }
@@ -841,14 +853,16 @@ sub disable_self_destruct {
 
 sub redeem_essentia_code {
     my ($self, $session_id, $code) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     my $amount = $empire->redeem_essentia_code($code);
     return { amount => $amount, status => $self->format_status($empire) };
 }
 
 sub get_invite_friend_url {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     return {
         referral_url    => $empire->get_invite_friend_url,
         status          => $self->format_status($empire),
@@ -857,7 +871,8 @@ sub get_invite_friend_url {
 
 sub invite_friend {
     my ($self, $session_id, $addresses, $custom_message) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     unless ($empire->email) {
         confess [1010, 'You cannot invite friends because you have not set up your email address in your profile.'];
     }
@@ -932,7 +947,8 @@ sub vet_species {
 
 sub redefine_species_limits {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     my $out = $empire->determine_species_limits($empire);
     $out->{status} = $self->format_status($empire);
     return $out;
@@ -940,7 +956,8 @@ sub redefine_species_limits {
 
 sub redefine_species {
     my ($self, $session_id, $me) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
 
     unless ($empire->essentia >= 100) {
         confess [1011, 'You need at least 100 essentia to redefine your species.'];
@@ -1000,7 +1017,8 @@ sub update_species {
 
 sub view_species_stats {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id});
+    my $empire   = $session->current_empire;
     return {
         species => $empire->get_species_stats,
         status  => $self->format_status($empire),
diff --git a/lib/Lacuna/RPC/Firebase.pm b/lib/Lacuna/RPC/Firebase.pm
index 90d35dbd..d2a19ccc 100644
--- a/lib/Lacuna/RPC/Firebase.pm
+++ b/lib/Lacuna/RPC/Firebase.pm
@@ -9,7 +9,8 @@ use WWW::Firebase::TokenGenerator;
 sub get_token {
     my ($self, $session_id) = @_;
 
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $firebase_secret = Lacuna->config->get('firebase/secret');
     unless ($firebase_secret) {
         return { token => '', status => $self->format_status($empire)};
diff --git a/lib/Lacuna/RPC/Inbox.pm b/lib/Lacuna/RPC/Inbox.pm
index bb37fd71..b9a38ffd 100644
--- a/lib/Lacuna/RPC/Inbox.pm
+++ b/lib/Lacuna/RPC/Inbox.pm
@@ -12,11 +12,12 @@ use List::Util qw(none);
 
 sub read_message {
     my ($self, $session_id, $message_id) = @_;
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $message = Lacuna->db->resultset('Lacuna::DB::Result::Message')->find($message_id);
     unless (defined $message) {
         confess [1002, 'Message does not exist.', $message_id];
     }
-    my $empire = $self->get_empire_by_session($session_id);
     unless ($empire->id ~~ [$message->from_id, $message->to_id]) {
         confess [1010, "You can't read a message that isn't yours.", $message_id];
     }
@@ -48,7 +49,8 @@ sub read_message {
 
 sub archive_messages {
     my ($self, $session_id, $message_ids) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $messages = Lacuna->db->resultset('Lacuna::DB::Result::Message')
         ->search(
                  {
@@ -74,7 +76,8 @@ sub archive_messages {
 
 sub trash_messages {
     my ($self, $session_id, $message_ids) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $messages = Lacuna->db->resultset('Lacuna::DB::Result::Message')
         ->search(
                  {
@@ -100,7 +103,8 @@ sub trash_messages {
 
 sub trash_messages_where {
     my ($self, $session_id, $opts) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     if (!$opts->{spec})
     {
         $opts = { spec => [ @_[2..$#_] ] };
@@ -206,7 +210,8 @@ sub send_message {
     Lacuna::Verify->new(content=>\$subject, throws=>[1005,'Message subject must be less than 100 characters.',$subject])->length_lt(100);
     Lacuna::Verify->new(content=>\$body, throws=>[1005,'Message body cannot be empty.',$body])->not_empty;
     Lacuna::Verify->new(content=>\$body, throws=>[1005,'Message body cannot contain HTML tags or entities.',$body])->no_tags;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     if ($options->{in_reply_to}) {
         my $reply_to = Lacuna->db->resultset('Lacuna::DB::Result::Message')->find($options->{in_reply_to});
         unless ($empire->id ~~ [$reply_to->to_id, $reply_to->from_id]) {
@@ -287,7 +292,8 @@ sub send_message {
 sub view_inbox {
     my $self = shift;
     my $session_id = shift;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $where = {
         has_archived    => 0,
         has_trashed     => 0,
@@ -299,7 +305,8 @@ sub view_inbox {
 sub view_archived {
     my $self = shift;
     my $session_id = shift;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $where = {
         has_archived    => 1,
         has_trashed     => 0,
@@ -311,7 +318,8 @@ sub view_archived {
 sub view_trashed {
     my $self = shift;
     my $session_id = shift;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $where = {
         has_archived    => 0,
         has_trashed     => 1,
@@ -323,7 +331,8 @@ sub view_trashed {
 sub view_sent {
     my $self = shift;
     my $session_id = shift;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $where = {
         from_id         => $empire->id,
         to_id           => {'!=' => $empire->id},
@@ -334,7 +343,8 @@ sub view_sent {
 sub view_unread {
     my $self = shift;
     my $session_id = shift;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $where = {
         has_archived    => 0,
         has_read        => 0,
diff --git a/lib/Lacuna/RPC/Map.pm b/lib/Lacuna/RPC/Map.pm
index 9c48caae..ad3eb93b 100644
--- a/lib/Lacuna/RPC/Map.pm
+++ b/lib/Lacuna/RPC/Map.pm
@@ -10,7 +10,8 @@ use List::Util qw(max min);
 
 sub check_star_for_incoming_probe {
     my ($self, $session_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $date = 0;
     my @bodies = $empire->planets->get_column('id')->all;
     my $incoming = Lacuna->db->resultset('Ships')->search({foreign_star_id=>$star_id, task=>'Travelling', type=>'probe', body_id => {in => \@bodies }})->first;
@@ -52,7 +53,8 @@ sub get_star_map {
     if ((abs($args->{top} - $args->{bottom}) * abs($args->{right} - $args->{left})) > 3001) {
         confess [1003, 'Requested area larger than 3001.'];
     }
-    my $empire = $self->get_empire_by_session($args->{session_id});
+    my $session  = $self->get_session({session_id => $args->{session_id}});
+    my $empire   = $session->current_empire;
     my $alliance_id = $empire->alliance_id || 0;
 
     my $out = Lacuna->db->resultset('Map::StarLite')->get_star_map( $alliance_id, $empire->id, $args->{left}, $args->{right}, $args->{bottom}, $args->{top} );
@@ -69,7 +71,8 @@ sub get_stars {
     if ((abs($endx - $startx) * abs($endy - $starty)) > 900) {
         confess [1003, 'Requested area too large.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $stars = Lacuna->db->resultset('Map::Star')->search({y=> {between => [$starty, $endy]}, x=>{between => [$startx, $endx]}});
     my @out;
     while (my $star = $stars->next) {
@@ -80,7 +83,8 @@ sub get_stars {
 
 sub get_star {
     my ($self, $session_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $star = Lacuna->db->resultset('Map::Star')->find($star_id);
     unless (defined $star) {
         confess [1002, "Couldn't find a star."];
@@ -90,7 +94,8 @@ sub get_star {
 
 sub get_star_by_name {
     my ($self, $session_id, $star_name) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $star = Lacuna->db->resultset('Map::Star')->search({name => $star_name})->first;
     unless (defined $star) {
         confess [1002, "Couldn't find a star."];
@@ -100,7 +105,8 @@ sub get_star_by_name {
 
 sub get_star_by_xy {
     my ($self, $session_id, $x, $y) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $star = Lacuna->db->resultset('Map::Star')->search({x=>$x, y=>$y})->first;
     unless (defined $star) {
         confess [1002, "Couldn't find a star."];
@@ -113,7 +119,8 @@ sub search_stars {
     if (length($name) < 3) {
         confess [1009, "Your search term must be at least 3 characters."];
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my @out;
     my $stars = Lacuna->db->resultset('Map::Star')->search({name => { like => $name.'%' }},{rows => 25});
     while (my $star = $stars->next) {
@@ -125,7 +132,8 @@ sub search_stars {
 sub probe_summary_fissures {
     my ($self, $args) = @_;
 
-    my $empire  = $self->get_empire_by_session($args->{session_id});
+    my $session  = $self->get_session({session_id => $args->{session_id} });
+    my $empire   = $session->current_empire;
     my $zone    = $args->{zone};
     my $fissure_rs = Lacuna->db->resultset('Building')->search({
             'me.class'          => 'Lacuna::DB::Result::Building::Permanent::Fissure',
@@ -159,7 +167,8 @@ sub probe_summary_fissures {
 
 sub view_laws {
     my ($self, $session_id, $star_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $star = Lacuna->db->resultset('Map::Star')->find($star_id);
     if ($star and $star->station_id) {
         my $station = Lacuna->db->resultset('Lacuna::DB::Result::Map::Body')
diff --git a/lib/Lacuna/RPC/Stats.pm b/lib/Lacuna/RPC/Stats.pm
index e5a73374..c6831632 100644
--- a/lib/Lacuna/RPC/Stats.pm
+++ b/lib/Lacuna/RPC/Stats.pm
@@ -23,7 +23,8 @@ sub credits {
 
 sub alliance_rank {
     my ($self, $session_id, $by, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     unless ($by ~~ [qw(influence population average_empire_size_rank offense_success_rate_rank defense_success_rate_rank dirtiest_rank)]) {
         $by = 'influence desc,population desc';
     }
@@ -80,7 +81,8 @@ sub find_alliance_rank {
     unless ($by ~~ [qw(average_empire_size_rank offense_success_rate_rank defense_success_rate_rank dirtiest_rank)]) {
         $by = 'average_empire_size_rank';
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $ranks = Lacuna->db->resultset('Lacuna::DB::Result::Log::Alliance')->search(undef,{order_by => $by, rows=>25});
     my $ranked = $ranks->search({alliance_name => { like => $alliance_name.'%'}});
     my @alliances;
@@ -103,7 +105,8 @@ sub find_alliance_rank {
 
 sub empire_rank {
     my ($self, $session_id, $by, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     unless ($by ~~ [qw(empire_size_rank offense_success_rate_rank defense_success_rate_rank dirtiest_rank)]) {
         $by = 'empire_size_rank';
     }
@@ -154,7 +157,8 @@ sub find_empire_rank {
     unless ($by ~~ [qw(empire_size_rank offense_success_rate_rank defense_success_rate_rank dirtiest_rank)]) {
         $by = 'empire_size_rank';
     }
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $ranks = Lacuna->db->resultset('Lacuna::DB::Result::Log::Empire')->search(undef,{order_by => $by, rows=>25});
     my $ranked = $ranks->search({empire_name => { like => $empire_name.'%'}});
     my @empires;
@@ -177,7 +181,8 @@ sub find_empire_rank {
 
 sub colony_rank {
     my ($self, $session_id, $by) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     unless ($by ~~ [qw(population_rank)]) {
         $by = 'population_rank';
     }
@@ -203,7 +208,8 @@ sub colony_rank {
 
 sub spy_rank {
     my ($self, $session_id, $by) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     unless ($by ~~ [qw(level_rank success_rate_rank dirtiest_rank)]) {
         $by = 'level_rank';
     }
@@ -232,7 +238,8 @@ sub spy_rank {
     
 sub weekly_medal_winners {
     my ($self, $session_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
+    my $session  = $self->get_session({session_id => $session_id });
+    my $empire   = $session->current_empire;
     my $winner_rs = Lacuna->db->resultset('Lacuna::DB::Result::Log::WeeklyMedalWinner')->search;
     my @winners;
     while (my $winner = $winner_rs->next) {
diff --git a/lib/Lacuna/Role/IncomingSupplyChains.pm b/lib/Lacuna/Role/IncomingSupplyChains.pm
index c32fe55a..0169bfe5 100644
--- a/lib/Lacuna/Role/IncomingSupplyChains.pm
+++ b/lib/Lacuna/Role/IncomingSupplyChains.pm
@@ -5,8 +5,9 @@ use Moose::Role;
 
 sub view_incoming_supply_chains {
     my ($self, $session_id, $building_id) = @_;
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     unless ($building) {
         confess [1002, "Cannot find that building."];
     }
diff --git a/lib/Lacuna/Role/TraderRpc.pm b/lib/Lacuna/Role/TraderRpc.pm
index 2451be95..110c1a96 100644
--- a/lib/Lacuna/Role/TraderRpc.pm
+++ b/lib/Lacuna/Role/TraderRpc.pm
@@ -7,8 +7,9 @@ use Lacuna::Util qw(randint);
 
 sub view_my_market {
     my ($self, $session_id, $building_id, $page_number) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||=1;
     my $my_trades = $building->my_market->search(undef, { rows => 25, page => $page_number });
     my @trades;
@@ -32,8 +33,9 @@ sub view_my_market {
 
 sub view_market {
     my ($self, $session_id, $building_id, $page_number, $filter) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     $page_number ||=1;
     my $all_trades = $building->available_market->search(
         undef,{
@@ -84,8 +86,9 @@ sub view_market {
 
 sub get_ships {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ships = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->search(
         {body_id => $building->body_id, task => 'docked'},
         {order_by => [ 'type', 'hold_size', 'speed']}
@@ -111,8 +114,9 @@ sub get_ships {
 sub get_ship_summary {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $ships = Lacuna->db->resultset('Lacuna::DB::Result::Ships')->search(
         {body_id => $building->body_id, task => 'docked'},
         {order_by => [ 'type', 'hold_size', 'speed']}
@@ -150,8 +154,9 @@ sub get_ship_summary {
 
 sub get_prisoners {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $dt_parser = Lacuna->db->storage->datetime_parser;
     my $now = $dt_parser->format_datetime( DateTime->now );
 
@@ -178,8 +183,9 @@ sub get_prisoners {
 sub get_plan_summary {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire      = $self->get_empire_by_session($session_id);
-    my $building    = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
 
     my @out;
     my $sorted_plans = $building->body->sorted_plans;
@@ -205,8 +211,9 @@ sub get_plan_summary {
 sub get_glyph_summary {
     my ($self, $session_id, $building_id) = @_;
 
-    my $empire   = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @glyphs   = sort {$a->type cmp $b->type} $building->body->glyph->all;
 
     my @out;
@@ -229,8 +236,9 @@ sub get_glyph_summary {
 
 sub get_stored_resources {
     my ($self, $session_id, $building_id) = @_;
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my @types = (FOOD_TYPES, ORE_TYPES, qw(water waste energy));
     my %out;
     my $body = $building->body;
@@ -252,8 +260,9 @@ sub report_abuse {
     unless ($trade_id) {
         confess [1002, 'You have not specified a trade to withdraw.'];
     }
-    my $empire = $self->get_empire_by_session($session_id);
-    my $building = $self->get_building($empire, $building_id);
+    my $session  = $self->get_session({session_id => $session_id, building_id => $building_id });
+    my $empire   = $session->current_empire;
+    my $building = $session->current_building;
     my $cache = Lacuna->cache;
     if ($cache->get('trade_lock', $trade_id)) {
         confess [1013, 'A buyer has placed an offer on this trade. Please wait a few moments and try again.'];
diff --git a/lib/Lacuna/Session.pm b/lib/Lacuna/Session.pm
index 0fe625ea..886c1351 100644
--- a/lib/Lacuna/Session.pm
+++ b/lib/Lacuna/Session.pm
@@ -20,7 +20,7 @@ sub BUILD {
         $self->api_key($session_data->{api_key});
         $self->empire_id($session_data->{empire_id});
         $self->extended($session_data->{extended});
-        $self->is_sitter($session_data->{is_sitter});
+        $self->_is_sitter($session_data->{is_sitter});
         $self->is_from_admin($session_data->{is_from_admin});
         $self->ip_address($session_data->{ip_address});
     }
@@ -35,11 +35,17 @@ has api_key => (
     is          => 'rw',
 );
 
-has is_sitter => (
+has _is_sitter => (
     is          => 'rw',
     default     => 0,
 );
 
+sub is_sitter {
+    my ($self) = @_;
+    $self->_is_sitter or
+        $self->current_empire && $self->empire_id != $self->current_empire->id;
+}
+
 has is_from_admin => (
     is          => 'rw',
     default     => 0,
@@ -66,7 +72,7 @@ has empire => (
     default     => sub {
         my $self = shift;
         return undef unless $self->has_empire_id;
-        my $empire = Lacuna->db->resultset('Lacuna::DB::Result::Empire')->find($self->empire_id);
+        my $empire = Lacuna->db->resultset('Empire')->find($self->empire_id);
         if (defined $empire) {
             $empire->current_session($self);
         }
@@ -74,6 +80,30 @@ has empire => (
     },
 );
 
+# if we are targeting a specific building,
+# track it here.
+has current_building => (
+    is        => 'rw',
+    predicate => 'has_building',
+    clearer   => 'clear_building',
+    isa       => 'Maybe[Lacuna::DB::Result::Building]',
+);
+
+has current_body =>  (
+    is        => 'rw',
+    predicate => 'has_body',
+    clearer   => 'clear_body',
+    isa       => 'Maybe[Lacuna::DB::Result::Map::Body]',
+);
+
+has current_empire => (
+    is        => 'rw',
+    isa       => 'Maybe[Lacuna::DB::Result::Empire]',
+    default   => sub { shift->empire },
+);
+
+
+
 sub check_captcha {
     my $self = shift;
     my $valid = Lacuna->cache->get('captcha_valid', $self->id);
@@ -92,7 +122,7 @@ sub update {
             empire_id       => $self->empire_id,
             api_key         => $self->api_key,
             extended        => $self->extended,
-            is_sitter       => $self->is_sitter,
+            is_sitter       => $self->_is_sitter,
             is_from_admin   => $self->is_from_admin,
             ip_address      => $self->ip_address,
         },
diff --git a/var/www/public/changes.txt b/var/www/public/changes.txt
index b7f574fd..fe0ec2ca 100644
--- a/var/www/public/changes.txt
+++ b/var/www/public/changes.txt
@@ -2,6 +2,7 @@
  - Mod: Jackpot enhanced.
  - Fix: If parliament missing, better error handling.
  - Fix: Make sure scows display empty cargo on return.
+ - Mod: Reduce some red tape.
 
 3.0915:
  - Fix: Reduce the wild resource fluctuations during planet ticking.