In earlier versions of the game, sending this caused your cells
        to split into lots of small cells and die.
164383
def send_explode(self):
        
        self.send_struct('<B', 20)
        self.player.own_ids.clear()
        self.player.cells_changed()
        self.ingame = False
        self.subscriber.on_death()
307587
public void destroy() {
    if (dead) return;
    dead = true;

    List<MortarScope> snapshot = new ArrayList<>(children.values());
    for (MortarScope child : snapshot) {
      child.destroy();
    }

    for (Scoped s : tearDowns) {
      s.onExitScope();
    }
    tearDowns.clear();

    Set<String> keys = services.keySet();
    for (String key : keys) {
      services.put(key, "Dead service");
    }
    if (parent != null) {
      parent.children.remove(getName());
    }
  }
709616
def _die(self, msg, lnum):
        """"""
        raise Exception("**FATAL {FILE}({LNUM}): {MSG}\n".format(
            FILE=self.obo_file, LNUM=lnum, MSG=msg))
425201
def send_respawn(self):
        
        nick = self.player.nick
        self.send_struct('<B%iH' % len(nick), 0, *map(ord, nick))
1272241
public boolean sendAndDestroy(Socket socket, int flags)
    {
        boolean ret = send(socket, flags);
        if (ret) {
            destroy();
        }
        return ret;
    }
506054
function() {
      
      var i, length, field;
      
      // Recursively destroy inputs
      for (i = 0, length = this.inputs.length ; i < length ; i++) {
         field = this.inputs[i];
         field.destroy();
      }
      
      // Destroy group itself
      inputEx.Group.superclass.destroy.call(this);
      
   }
341639
public void destroy() {
        for (int j = 0; j < mApplications.length; j++) {
            if (mApplications[j] != null) {
                mApplications[j].destroy();
            }
        }
    }
1308681
function (dt) {

        if (me.input.isKeyPressed("left"))    {
            this.body.force.x = -this.body.maxVel.x;
            this.renderable.flipX(true);
        } else if (me.input.isKeyPressed("right")) {
            this.body.force.x = this.body.maxVel.x;
            this.renderable.flipX(false);
        } else {
            this.body.force.x = 0;
        }

        if (me.input.isKeyPressed("jump")) {
            this.body.jumping = true;
            if (this.multipleJump <= 2) {
                // easy "math" for double jump
                this.body.force.y = -this.body.maxVel.y * this.multipleJump++;
                me.audio.play("jump", false);
            }
        }
        else {

            this.body.force.y = 0;

            if (!this.body.falling && !this.body.jumping) {
                // reset the multipleJump flag if on the ground
                this.multipleJump = 1;
            }
            else if (this.body.falling && this.multipleJump < 2) {
                // reset the multipleJump flag if falling
                this.multipleJump = 2;
            }
        }

        // apply physics to the body (this moves the entity)
        this.body.update(dt);

        // check if we fell into a hole
        if (!this.inViewport && (this.pos.y > me.video.renderer.getHeight())) {
            // if yes reset the game
            me.game.world.removeChild(this);
            me.game.viewport.fadeIn("#fff", 150, function(){
                me.audio.play("die", false);
                me.levelDirector.reloadLevel();
                me.game.viewport.fadeOut("#fff", 150);
            });
            return true;
        }

        // handle collisions against other shapes
        me.collision.check(this);

        // check if we moved (an "idle" animation would definitely be cleaner)
        if (this.body.vel.x !== 0 || this.body.vel.y !== 0 ||
            (this.renderable && this.renderable.isFlickering())
        ) {
            this._super(me.Entity, "update", [dt]);
            return true;
        }

        return false;
    }
1298964
def fatal(message = nil, ex = nil, data = nil, &block)
      log(FATAL, message, ex, data, block)
    end
1191060
function killer(data) {
			grunt.log.write(data);
			if (ti.killed) {
				return;
			} else if (success && success(data)) {
				ti.kill();
				grunt.log.ok('titanium run successful');
			} else if (failure && failure(data)) {
				ti.kill();
				grunt.fail.warn('titanium run failed');
			}
		}
928082
function() {
        if (this.strategies) {
            var strategy, i, len;
            for(i=0, len=this.strategies.length; i<len; i++) {
                strategy = this.strategies[i];
                if(strategy.autoDestroy) {
                    strategy.destroy();
                }
            }
            this.strategies = null;
        }
        if (this.protocol) {
            if(this.protocol.autoDestroy) {
                this.protocol.destroy();
            }
            this.protocol = null;
        }
        this.destroyFeatures();
        this.features = null;
        this.selectedFeatures = null;
        this.unrenderedFeatures = null;
        if (this.renderer) {
            this.renderer.destroy();
        }
        this.renderer = null;
        this.geometryType = null;
        this.drawn = null;
        OpenLayers.Layer.prototype.destroy.apply(this, arguments);  
    }
420312
def fight(self, moves=10):
        
        for i in range(1, moves):
            # player 1
            result, dmg = self.calc_move(self.c1, self.c2)
            print (self.c1.name + ' ' + result + ' for ' + str(dmg))
            self.c1.sta = self.c1.sta - dmg
            if self.is_character_dead(self.c1):
                print(self.c1.name + ' has died')
                return
            # player 2
            result, dmg = self.calc_move(self.c2, self.c1)
            print (self.c2.name + ' ' + result + ' for ' + str(dmg))
            self.c2.sta = self.c2.sta - dmg
            if self.is_character_dead(self.c2):
                print(self.c2.name + ' has died')
                return
674008
function destroy() {
         me.pool.push(this.fontScale);
         this.fontScale = undefined;
         me.pool.push(this.fontData);
         this.fontData = undefined;

         this._super(me.Renderable, "destroy");
       }
847714
def killCells(i, options, tm):
  

  # Kill cells if called for
  if options.simulation == "killer":

    if i == options.switchover:
      print "i=",i,"Killing cells for the first time!"
      tm.killCells(percent = options.noise)

    if i == options.secondKill:
      print "i=",i,"Killing cells again up to",options.secondNoise
      tm.killCells(percent = options.secondNoise)

  elif options.simulation == "killingMeSoftly" and (i%100 == 0):
    steps = (options.secondKill - options.switchover)/100
    nsteps = (options.secondNoise - options.noise)/steps
    noise = options.noise + nsteps*(i-options.switchover)/100
    if i in xrange(options.switchover, options.secondKill+1):
      print "i=",i,"Killing cells!"
      tm.killCells(percent = noise)
162437
def die(arg, msg = nil, error_code = nil)
			msg, error_code = nil, msg if msg.kind_of?(Integer)
			if msg
				$stderr.puts "Error: argument --#{@specs[arg].long} #{msg}."
			else
				$stderr.puts "Error: #{arg}."
			end
			if @educate_on_error
				$stderr.puts
				educate $stderr
			else
				$stderr.puts "Try --help for help."
			end
			exit(error_code || -1)
		end
339069
function() {
        // for now, nothing special to do here.
        OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments);

        // Remove from memory the Zoomify pyramid - is that enough?
        this.tileCountUpToTier.length = 0;
        this.tierSizeInTiles.length = 0;
        this.tierImageSize.length = 0;

    }
1207873
@GuardedBy("this")
  private void rehashIfNeeded() {
    int currentSize = table.length;
    if (currentSize - count >= currentSize / (MAX_EXPECTED_COLLISION_COUNT + 1)) {
      // Still enough overhead.
      return;
    }

    Object[] oldTable = table;
    // Grow the table so it increases by 1 / GROWTH_DENOMINATOR.
    int newSize = currentSize + currentSize / GROWTH_DENOMINATOR;

    table = new Object[newSize];
    count = 0;

    for (Object element : oldTable) {
      if (element != null) {
        intern(element);
      }
    }
  }