This is my first attempt for smooth tile scrolling in Slick. The offx/offy coordinates are not entirely correct for hero, smaller than the tile image but it's a good start the "smooth" part comes from shx/shy variables which offset the rendering position. The code is after the break:

Update: Check the project source code page at Google Code: http://code.google.com/p/jmuonline/

 
package scroller;
 
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.tiled.TiledMap;
 
/**
 *
 * @author aquilax
 */
public class Scroller2 extends BasicGame{
 
  private TiledMap map = null;
  private Hero hero = null;
 
  final static int screenw = 432;
  final static int screenh = 336;
  final static int centerx = screenw/2;
  final static int centery = screenh/2;
  final static int visx = 9;
  final static int visy = 7;
  final static float halfvisx = visx/2;
  final static float halfvisy = visy/2;
 
  private int tileW;
  private int tileH;
  private int mapW;
  private int mapH;
  private boolean[][] blocked;
  private int offx;
  private int offy;
 
  public Scroller2(){
    super("Scroller2");
  }
 
  @Override
  public void init(GameContainer container) throws SlickException {
    map = new TiledMap("data/testone.tmx");
    tileW = map.getTileWidth();
    tileH = map.getTileHeight();
    mapW = map.getWidth();
    mapH = map.getHeight();
    fillBlocked(map);
    hero = new Hero("data/hero.png");
    hero.speed = 1;
    hero.xtile = Integer.parseInt(map.getMapProperty("herox", "16"));
    hero.ytile = Integer.parseInt(map.getMapProperty("heroy", "8"));
 
    hero.xpos = centerx - hero.awidth/2;
    hero.ypos = centery - hero.aheight/2;
 
    offx = hero.xtile*tileW;
    offy = hero.ytile*tileH;
  }
 
  @Override
  public void update(GameContainer container, int delta) throws SlickException {
    Input input = container.getInput();
    if (input.isKeyDown(Input.KEY_LEFT)) {
      moveChar(hero, -1, 0);
    }
    if (input.isKeyDown(Input.KEY_RIGHT)) {
      moveChar(hero, +1, 0);
    }
    if (input.isKeyDown(Input.KEY_UP)) {
      moveChar(hero, 0, -1);
    }
    if (input.isKeyDown(Input.KEY_DOWN)) {
      moveChar(hero, 0, +1);
    }
  }
 
  public void render(GameContainer container, Graphics g) throws SlickException {
    int shx = (int)(offx/tileW)*tileW - offx;
    int shy = (int)(offy/tileH)*tileH - offy;
    map.render(shx, shy, (int)(offx/tileW-halfvisx), (int)(offy/tileH-halfvisy), visx+1, visy+1);
    hero.draw(hero.xpos, hero.ypos);
    g.setColor(Color.red);
    g.drawString("offx "+offx, 300, 10);
    g.drawString("offy "+offy, 300, 30);
  }
 
  public static void main(String[] args) throws SlickException {
    AppGameContainer app = new AppGameContainer(new Scroller2());
    app.setDisplayMode(screenw, screenh, false);
    app.start();
  }
 
  private void fillBlocked(TiledMap map) {
    blocked = new boolean[mapW][mapH];
    for(int x = 0; x < mapW; x++){
      for (int y = 0; y < mapH; y++){
        blocked[x][y]  = "true".equals(map.getTileProperty(map.getTileId(x, y, 0), "blocked", "false"));
      }
    }
  }
 
  private void moveChar(Hero ob, int dirx, int diry) {
    offx += (int)(dirx*ob.speed);
    offy += (int)(diry*ob.speed);
  }
}
 

 
int R = 20;  //radius
int speed = 2;  // speed
 
int t = 0;
float x;
float y;
int offx = 0;
int offy = 0;
 
void setup(){
  size(80,80);
  offx = width/2;
  offy = height/2;
  background(0);
  strokeWeight(7);
}
 
void draw(){
  filter(BLUR,1);
  stroke(#FF0000);
  x = sin(radians(t))*R+offx;
  y = cos(radians(t))*R+offy;
  point (x,y);
  stroke(#00FF00);
  x = sin(radians(t+120))*R+offx;
  y = cos(radians(t+120))*R+offy;
  point (x,y);
  stroke(#0000FF);
  x = sin(radians(t+240))*R+offx;
  y = cos(radians(t+240))*R+offy;
  point (x,y);
  t += speed;
}
 

 
int R = 130;         //Outer radius
int r = 15;          //Iner radius
int O = 7;           //Offset
float swidth = 0.2;  // Stroke width
int iter = 500;      // Numer of iterations
 
float x;
float y;
float ox = 0;
float oy = 0;
int offx;
int offy;
int t = 0;
 
void setup(){
  size(400,400);
  offx = width/2;
  offy = height/2;
  colorMode(HSB, iter);
  strokeWeight(swidth);
  background(0);
  smooth();
}
 
void draw(){
  if (t <= iter){
    x = (R+r)*cos(t) - (r+O)*cos(((R+r)/r)*t)+offx;
    y = (R+r)*sin(t) - (r+O)*sin(((R+r)/r)*t)+offy;
    stroke(t, iter/1.5, iter);
    //point (x, y);  //<- points
    if (ox != 0 && oy != 0){
      line (ox, oy, x, y);  //<-lines
    }
    ox = x;
    oy = y;
    t++;
  }
}
 

 
float noiseScale=0.02;
int tsize = 250;
 
void setup() {
  size(640, 480, P3D);
  background(0);
  rotateX(radians(45));
 
  beginShape(POINTS);
  for(int x=0; x < tsize; x++) {
    for(int y=0; y < tsize; y++){
      float noiseVal = noise(x*noiseScale, y*noiseScale);
      int t = int(noiseVal*255);
      stroke(165, 80, 10);
      if (t >180 ){
        stroke(0, 0, t);
      }
      // add some randomness to the snow to make it more realistic
      if (t <60 +random(20)){
        stroke(255, 255, 255);
      }
      vertex(width/2+x-tsize/2, height/2+y-tsize/2, -noiseVal*60);
    }
  }
  endShape();
}
 
void draw(){
}