public double PercentSimilarTo(this string myself, string other)
{
var longest = (double)Math.Max(myself.Length, other.Length);
return EditDistanceCalculations.CalculateLevenshteinDistance(myself, other) / longest;
}
| Worst names: cs arr sb awos |
Bad names: custs array stringBuilder accounts |
Good names: birthdaysToday selectedIndexes warningMessage accountsWithoutOwners |
public function toMemento():Dynamic
{
return {
x:x,
y:y,
vx:velocity.x,
vy:velocity.y,
maxSpeed: maxSpeed,
maxAge: maxAge,
type: type,
plantType: plantType,
age: age,
};
}
public static function fromMemento(o:Dynamic):Fruit
{
var c = new Fruit(o.x, o.y, o.type);
c.velocity.x = o.vx;
c.velocity.y = o.vy;
c.maxSpeed = o.maxSpeed;
c.maxAge = o.maxAge;
c.age = o.age;
c.plantType = o.plantType;
return c;
}
public function toMemento():Dynamic
{
return {
need: "NeedToEatFruit",
target: target == null ? null : target.toMemento(),
}
}
public static function fromMemento(o:Dynamic):Need
{
var n = new NeedToEatFruit();
n.target = o.target == null ? null : Fruit.fromMemento(o.target);
return n;
}
package;
class CreatureController
{
public function new()
{
}
public function update(creature:Creature):Void
{
var lowestScore = 1.0;
var lowestNeed = creature.needs[0];
for (i in 0 ... creature.needs.length)
{
if (creature.needScores[i] > lowestScore)
continue;
lowestScore = creature.needScores[i];
lowestNeed = creature.needs[i];
}
lowestNeed.update(creature);
}
}
class Weapon
{
public var name:String;
public var attack:int = 10;
public var defense:int = 10;
public var speed:Number = 1.0;
public var heavy:Boolean = false;
public var tags:Array = ["weapon"];
/* skipping constructor and a "describe" function that prints the values */
}
var weapons:Array = [
new Weapon("stick"),
new Weapon("sword", { attack: +2, defense: +2 } ),
new Weapon("club", { speed: -0.25, heavy: true } ),
new Weapon("knife", { attack: -2, tags: ["sharp"] } )
];
for each (var weapon:Weapon in weapons)
trace(weapon.describe());
stick = { attack=10, defense=10, speed=1, heavy=false, tags=weapon}
sword = { attack=12, defense=12, speed=1, heavy=false, tags=weapon}
club = { attack=10, defense=10, speed=0.75, heavy=true, tags=weapon}
knife = { attack=8, defense=10, speed=1, heavy=false, tags=weapon,sharp}
public function expand(receiver:Object, expansions:Object):Object
{
if (receiver == null || expansions == null)
return receiver;
for (var property:String in expansions)
{
if (receiver[property] == null)
continue;
var value:Object = expansions[property];
if (value is Number || value is int)
{
receiver[property] += value;
}
else if (value is Array)
{
for each (var element:Object in value)
receiver[property].push(element);
}
else
{
receiver[property] = value;
}
}
return receiver;
}
public function Weapon(name:String, values:Object = null)
{
this.name = name;
Util.expand(this, values);
}
| Extract Method | Extract Class | |
|---|---|---|
| Mess | Unless there's a lot of duplication that you can quickly remove, the class size stays about the same. | Immediately reduces the class size by moving code to a new class. The compiler will tell you what it depends on and what depends on it. |
| Power | You get a new method:
|
You get a new class:
|
| Concepts | Small, local, procedural:
|
Large, project-wide, object oriented:
|
public interface ICustomization
{
void Customize(IFixture fixture);
}
var fixture = new Fixture() .Customize(new DomainCustomization());
public interface Feature
{
function addTo(grid:WorldGrid):void;
}
var grid:WorldGrid = new WorldGrid(width, height); grid.add(new Shore()); grid.add(new Lake()); grid.add(new Lake()); grid.add(new Island()); // etc.
public void onClick(int x, int y){
if (currentTool == PAINT)
canvas.paint(x, y);
else if (currentTool == BLUR)
canvas.blur(x, y);
else if (currentTool == ERASE)
canvas.erase(x, y);
else if (currentTool == LINE && lineStart == null)
lineStart = new Point(x, y);
else if (currentTool == LINE && lineStart != null) {
canvas.drawLine(lineStart.x, linesStart.y, x, y);
lineStart = null;
}
}
public void onClick(int x, int y){
currentTool.onClick(x, y);
}
class PaintTool extends GuiTool {
@Override
public void onClick(Canvas canvas, int x, int y){
canvas.paint(x,y);
}
}
class LineTool implements GuiTool {
private Point startPoint;
@Override
public void onClick(Canvas canvas, int x, int y){
if (startPoint == null)
startPoint = new Point(x, y);
else {
canvas.drawLine(startPoint.x, startPoint.y, x,y);
}
}
public void goHome(){
if (homeLocation != null)
goTo(homeLocation.x, homeLocation.y);
else if (leader != null)
follow(leader);
else if (group != null)
follow(group.getRandomMember());
else
wander();
}
public void goHome(){
home.goTo();
}
public class StationaryHome implements AgentHome {
private Agent agent;
private Point home;
public StationaryHome(Agent agent, Point home){
this.agent = agent;
this.home = home;
}
@Override
public void goTo(){
agent.goTo(home);
}
}
Once you have the different states, then the agent no longer needs all of those extra variables and is made much simpler. It also disallows states that don't make sense: what does it mean if an agent has a location it considers home and a group it considers home? If that's not a valid situation then you need to make sure you never end up with both. If it is a valid situation then you can just create a new state object that handles it.