[quote=luistiagos][quote]
Desenho:666/576
Camera:666/576
Desenho:666/576
Camera:666/576
Desenho:666/576
[/quote]
:evil: :evil: :evil: :evil: [/quote]
hahahaha… que coisa terrivel, nem tinha visto. (Sai capeta)
[quote=erickzanardo][quote=Michel.Montenegro]Tentei manter tudo na mesma Thread, que é a do jogo, funcionou?
Sim! Mas com um problema, quando dava sleep( valor) ou qualquer outro meio como usando o delta com count o jogo “parava”, resultando em o personagem saltando de 32 em 32 pixels, ao invez de andar suavemente de N em N pixels até chegar em 32, ai me vi forçado a criar uma Thread para fazer isso por fora, sem dar sleep na Thread principal.
Basicamente este foi o motivo de ter criado outra thread, mas aceito sugestões para mudar isso, melhorar sempre ^^
Mas deixo claro que tentei assim nocomeço, e me vi obrigado a mudar.[/quote]
Então, realmente se você der um sleep na thread principal ele vai dar esse efeito, do personagem não deslizar.
O que você tem que fazer é usar o delta para calcular a quantidade de pixels que ele vai andar por atualização.
Eu brinquei um pouco com o Slick2d, e pelo que me lembro, o delta é quantos milis-segundos se passaram entre esta atualização, e a anterior, eu não vou lembrar agora exatamente qual é o cálculo, pois na minha engine eu estou fazendo um esquema diferente, mas, eu peguei um código velho meu aqui que usei o slick e é mais ou menos assim, o timePassed é o delta em questão.
// Move para a esquerada
if(input.isKeyDown(Input.KEY_RIGHT)) {
if(getX() < (Config.PLAYABLE_AREA - getImage().getWidth())) {
setX(getX() + ((timePassed / 1000f) * 300f));
}
}
Eu não lembro agora da onde eu tirei este cálculo, mas funcionou, huashusahusahusa
espero que ajude
[]s
[/quote]
Eu testei com delta logo de cara, mas não rolou. 
Mas vou re-tentar depois, sim, agora to aplicando pathfinder no projeto e to achando que vai sair mais rapido do que o previsto (graças ao nosso amigo do CodeAndCoke). 
Me fala mais sobre tua engine, o que pretende fazer?
Codigo fonte da minha classe que gerencia o movimento. Para capturar odelta só preciso usar um “world.getDelta();” em qualquer lugar do codigo abaixo.
package game.cliente.systems;
import game.cliente.components.PlayerHero;
import game.cliente.components.Transform;
import game.cliente.components.Velocity;
import game.cliente.connections.HostConnect;
import game.cliente.core.ManagerMap;
import game.cliente.utils.Util;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Input;
import com.artemis.ComponentMapper;
import com.artemis.Entity;
import com.artemis.EntityProcessingSystem;
/**
*
* @author Michel Montenegro
* @edited Pedro Silva Moreira - PeJuGe
*
*/
public class MovementSystem extends EntityProcessingSystem {
private GameContainer container;
private ComponentMapper<Transform> transformMapper;
private ComponentMapper<Velocity> velocityMapper;
private ComponentMapper<PlayerHero> playerHeroMapper;
private HostConnect hostConnect;
@SuppressWarnings("unused")
private ManagerMap managerMap;
private boolean walking = false;
private boolean enterThread = false;
private MovimentSystemThread movimentSystemThread;
@SuppressWarnings("unchecked")
public MovementSystem(GameContainer container, ManagerMap managerMap,
HostConnect hostConnect) {
super(Transform.class, Velocity.class, PlayerHero.class);
this.container = container;
this.hostConnect = hostConnect;
this.managerMap = managerMap;
}
@Override
public void initialize() {
velocityMapper = new ComponentMapper<Velocity>(Velocity.class,
world.getEntityManager());
transformMapper = new ComponentMapper<Transform>(Transform.class,
world.getEntityManager());
playerHeroMapper = new ComponentMapper<PlayerHero>(PlayerHero.class,
world.getEntityManager());
}
@Override
protected void process(Entity e) {
if (container.getInput().isKeyDown(Input.KEY_LEFT)) {
move(e, Util.KEY_ARROW_LEFT);
} else if (container.getInput().isKeyDown(Input.KEY_RIGHT)) {
move(e, Util.KEY_ARROW_RIGHT);
} else if (container.getInput().isKeyDown(Input.KEY_UP)) {
move(e, Util.KEY_ARROW_UP);
} else if (container.getInput().isKeyDown(Input.KEY_DOWN)) {
move(e, Util.KEY_ARROW_DOWN);
} else if (container.getInput().isKeyDown(Input.KEY_ESCAPE)) {
this.hostConnect.send("quit/");
}
}
public void move(Entity e, int direction) {
if (walking)
return;
Velocity velocity = velocityMapper.get(e);
PlayerHero playerHero = playerHeroMapper.get(e);
Transform t = transformMapper.get(e);
t.setUltimaSetaPrecionada(direction);
int x = (int) t.getX();
int y = (int) t.getY();
if (!ManagerMap.entityWallCollisionWith(x, y, direction)) {
walking = true;
if (movimentSystemThread == null) {
movimentSystemThread = new MovimentSystemThread(t, direction,
velocity);
movimentSystemThread.start();
enterThread = true;
} else {
movimentSystemThread.updateThread(t, direction, velocity);
enterThread = true;
}
this.hostConnect.sendChannel("m/" + this.hostConnect.getLogin()
+ "/" + playerHero.getClasseId() + "/" + direction + "/"
+ playerHero.getName() + "/" + x + "/" + y + "/",
Util.CHANNEL_MAP);
}
}
@Override
protected boolean checkProcessing() {
return true;
}
public class MovimentSystemThread extends Thread {
private Transform transform = null;
private int direction;
private Velocity velocity;
public MovimentSystemThread(Transform ftransform, int fdirection,
Velocity fvelocity) {
transform = ftransform;
transform.setLocation(transform.getX() - transform.getX()
% Util.TILE_SIZE, transform.getY() - transform.getY()
% Util.TILE_SIZE);
direction = fdirection;
velocity = fvelocity;
}
public void updateThread(Transform ftransform, int fdirection,
Velocity fvelocity) {
transform = ftransform;
// Na criação da entidade heroi resovi isto.
// transform.setLocation(transform.getX() - transform.getX() %
// Util.tileSize, transform.getY() - transform.getY() %
// Util.tileSize);
direction = fdirection;
velocity = fvelocity;
}
@Override
public void run() {
while (true) {
if (enterThread == true) {
int ftimes = Util.TILE_SIZE / velocity.getVelocity();
do {
switch (direction) {
case Util.KEY_ARROW_DOWN:
transform.addY(velocity.getVelocity());
break;
case Util.KEY_ARROW_UP:
transform.addY(-velocity.getVelocity());
break;
case Util.KEY_ARROW_LEFT:
transform.addX(-velocity.getVelocity());
break;
case Util.KEY_ARROW_RIGHT:
transform.addX(velocity.getVelocity());
break;
default:
return;
}
if (((direction == Util.KEY_ARROW_DOWN || direction == Util.KEY_ARROW_UP) && transform
.getY() % Util.TILE_SIZE != 0)
|| ((direction == Util.KEY_ARROW_LEFT || direction == Util.KEY_ARROW_RIGHT) && transform
.getX() % Util.TILE_SIZE != 0)) {
try {
sleep(500 / ftimes);
} catch (InterruptedException e) {
System.out.println("testando.");
}
}
} while (transform.getX() % Util.TILE_SIZE != transform
.getY() % Util.TILE_SIZE);
walking = false;
enterThread = false;
// Não remova, obrigatorio para manter uma estabilidade caso
// o player fique pressionando sem parar as teclas
try {
sleep(500 / ftimes);
} catch (InterruptedException e) {
System.out.println("testando.");
}
}
}
}
}
}