[RESOLVIDO] limite de posicionamento

No jogo 2D que eu to fazendo a tela é estatica e o personagem segue a posição do clique, entao para mim limitar a posição do player eu coloquei esse codigo abaixo:

if (transform.position.x > 3) {
   transform.position = new Vector3 (3f, transform.position.y, transform.position.z);
}
if (transform.position.x < -3) {
   transform.position = new Vector3 (-3f, transform.position.y, transform.position.z);
}

esse codigo esta funcional no unity porem quando jogo para celulares com diferentes tamanhos de tela isso é alterado um pouquinho. Alguém sabe como arrumar? ou se esse é o modo errado de fazer alguem sabe qual é o certo?

Desculpe, mas só pra eu poder entender melhor. Você está querendo limitar a posição do personagem na Horizontal, certo? A área limite por onde o jogador pode se movimentar no eixo x seria a mesma que a câmera pode ver?

isso, exatamente

Eu sugiro que você crie uma função que altere os valores máximo e mínimo que você já tem de acordo com a resolução da tela.

tipo pegar o screen.width e fazer ele ser o limite?

eu tava tentando fazer aqui mais nao faço a minima ideia de como fazer isso kkkkkkkkkkkk. Pode me ajudar?

fiz um script aqui mais ou menos pra fazer um clamp com a área visível da camera
usando o ScreenToWorldPoint com parâmetros Screen.width e Screen.height ele vai retorna os pontos exato das extremidade da camera mais como o transform se localiza no centro do objeto objeto ficaria assim usando o limite



para que isso não aconteça basta fazer uma variável para adicionar um valor extra que na maioria da vezes pode ser o scale divido por dois o tamanho do colisor o pode se manualmente mesmo segue o ex

Código:

using UnityEngine;
using System.Collections;

public class Clamp : MonoBehaviour
{

    public Vector2 offset = new Vector2(0.5f, 0.5f);
    public Vector3 usefulValue = Vector2.zero;// valor do limite calculado

    private Vector2 limit = Vector2.zero;
    private Camera _Camera;

    void Start()
    {
        _Camera = Camera.main;
        limit = _Camera.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height, 0));
    }

    void Update()
    {
        
        transform.Translate(Input.GetAxis("Horizontal") * Vector2.right * Time.deltaTime * 5);
        transform.Translate(Input.GetAxis("Vertical") * Vector2.up * Time.deltaTime * 5);
        usefulValue = (limit - offset);

        if (transform.position.x <= -usefulValue.x)
            transform.position = new Vector2(-usefulValue.x, transform.position.y);
        else if (transform.position.x >= usefulValue.x)
            transform.position = new Vector2(usefulValue.x, transform.position.y);
        else if (transform.position.y <= -usefulValue.y)
            transform.position = new Vector2(transform.position.x, -usefulValue.y);
        else if (transform.position.y >= usefulValue.y)
            transform.position = new Vector2(transform.position.x, usefulValue.y);

    }
}

a variável usefulValue e o valor limite da camera

nao ta funcionando nao, agr nao sei se nao funciona pq ta errado mesmo ou se nao funciona pq nao entendi nada e nao soube adaptar kkkkkkkkkkk

Como não funcionou O.o ?
eu testei aqui e funciona como esperado
Como você esta fazendo ?

eu fiz exatamente como ta ai e coloquei dentro do metodo de movimentação do player, mas ele fico preso no canto da tela

Poste a forma que esta fazendo

Código:

public class PlayerBehaviour : MonoBehaviour {

   public float speedMove;
   public int auxDirection;

   // testes

   public Vector2 offSet = new Vector2 (0.5f, 0.5f);
   public Vector3 limitCamera = Vector2.zero;

   public Vector2 limit = Vector2.zero;
   // testes
   void Start () {
      limit = Camera.main.ScreenToWorldPoint (new Vector3 (Screen.width, Screen.height, 0));
   }

   void FixedUpdate () {
      speedMove = 10 * Time.deltaTime;
      Move ();
   }

   void Move () {
   
      if (auxDirection != 0)
         transform.Translate (Vector2.right * speedMove * auxDirection);

      limitCamera = (offSet - limit);

      if (transform.position.x <= -limitCamera.x)
         transform.position = new Vector2 (-limitCamera.x, transform.position.y);
      else if (transform.position.x >= limitCamera.x)
         transform.position = new Vector2 (limitCamera.x, transform.position.y);
   }

   public void SetDirectionMove (int direction) {
      auxDirection = direction;

      if (auxDirection == 1)
         transform.localScale = new Vector3 (1, 1, 1);
      if (auxDirection == -1)
         transform.localScale = new Vector3 (-1, 1, 1);

   }
}

 foi assim

você quer limitar as "paredes" do seu cenário, isto? quer que o player não saia da tela?

isso

independente do tamanho da tela

Isto não costuma ser feito em jogos, pois um limite proporcional a tela acabará distorcendo o jogo. pense que um campo em um tablet tem dimenções 5x5, já no seu celular, tem dimensões 3x5. Algo vai ficar errado não?

Tem como postar uma print do que você está tentando fazer? Geralmente se limita a área do jogador e desloca-se a camera para acompanhar o movimento dele, e faz-se modificações neste princípio de acordo com a necessidade. Mas trabalhar com um limite "maleável" de acordo com a resolução não costuma ser uma boa ideia.

Eu nao sei como coloca imagem no comentario. Mais o jogo eh assim: O personagem começa posicionado no centro da tela, vc pode se movimentar apenas na horizontal. Caem itens de cima, esses itens podem ser ou nao comestiveis, no canto superior de tela tem uma barrinha que mostra sua vida e pontuação atual.
O que eu preciso fazer e´com que o personagem nao saia da tela, com o codigo que eu coloquei no primeiro comentario funciona, porém o valor varia de tela pra tela, qual a maneira certa de fazer isso?

A maneira correta seria manter o limite fixo, e o cenário fixo, e alterar apenas o tamanho do campo de visão da sua camera de acordo com a tela do usuário.

poderia me ensinar a fazer isso? codigo comentado ou entao um tutorial no canal, eu agradeceria muito.

Isto seria uma dúvida para ser tirada via skype...

O problema está na maneira que você está pensando na estrutura do seu jogo. O jeito que o weslley falou seria o mais próximo do que você almeja, mas eu desaconselho a ficar mexendo no posicionamento de colliders e outras coisas de acordo com o tamanho da tela, pois isto geralmente gera problemas.

O seu game deve ser projetado de maneira que o cenário fique fixo, e você deve variar apenas o campo de visão da sua camera.

Quer ver o cenário todo de maneira que ele caiba exatamente? então basta fixar uma proporção fixa de tela para o seu jogo quando for escolher as configurações de compilação dele.

mas se eu limitar a proporção da tela quando for compilar ai o posicionamento vai ficar certo para todos os celulares?

pq o jogo eh bem simples mesmo, eu nem to usando nenhum tipo de colisor pra parar o personagem, apenas to checando a posição mesmo.

Então, quando você está desenvolvendo jogos, tem que ter em mente que o seu cenário deve ser FIXO. Isto evitará MUITOOOOS problemas, e deve ser levado meio que como regra.

O correto seria montar o jogo sem se preocupar com as "proporções", apenas faça, coloque colisores aonde tem que estar, coloque limites aonde tem que ter, etc.

O ajuste da visão deve ser feito na camera mesmo. A maioria dos jogos de celular que possuem um cenário fixo (aonde a camera não anda), tem cenário a mais, para caso a tela seja maior do que o padrão... Então, caso a câmera foque para fora do seu bloco de jogo, ela deve ver apenas este "cenario a mais". Os colisores continuam onde estão, tudo continua onde está.

Na aba do jogo, você pode ir em um campo que geralmente está escrito "Free Aspect", aonde você seleciona as resoluções possíveis... Você deve projetar o jogo testando em várias resoluções, e vendo se os elemento principais aparecem em todas as resoluções. Se em alguma resolução você não estiver vendo parte do cenário essencial, aumente o campo de visão... já se em alguma resolução, você estiver vendo cenário a mais, apenas faça algo para aparecer naquele espaço, umas nuvens, qualquer coisa que tenha a ver com o jogo, apenas para preencher o espaço.

Não há muitas maneiras descentes de se lidar com esta "mudança de resoluções", por que geralmente os jogos são feitos para Camera livre, então você renderiza o que está vendo. 

Jogos com camera fixa tendem a ter este problema, e a solução geralmente eh fazer cenário adicional para as partes excedentes que você pode vir a enxergar.

Eu sei que é post antigo mais eu fiz oque o rapaz queria agora e deu certo em todas as telas.
Caso alguem tenha a mesma duvida =)
     

Código:

  limite = _Camera.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height, 0));

        telaTamanho = ((limite.x * 26)/100) - limite.x;

        Debug.Log(telaTamanho); 
        Debug.Log(limite); 

        if (joystick_.transform.position.x <= telaTamanho)
        {
            joystick_.transform.position = new Vector3(telaTamanho, joystick_.transform.position.y, joystick_.transform.position.z);
        }