Buenas, tengo un pequeño problema, estoy terminando un código, y resulta que me aparece un error y no soy capaz de encontrar la solución, quería saber si alguien podría ayudarme.
 
Aquí dejo el error:
 
"Assets/Scripts/Manager.cs(221,20): error CS0161: `Manager.ObtenerInfo(Cuadricula)': not all code paths return a value"
 
Y aquí el código:
 

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class Manager : MonoBehaviour {
public int TamañoX, TamañoY;
GameObject [] _items;
public Cuadricula[,] BidItem;
Cuadricula ItemActual;

public static int minItemsPorEncuentro = 3;
bool Jugando;

void Start () {
   Jugando = true;
   ObtenerItems ();
   Grid ();
   LimpiarGrid();
   Cuadricula.SeleccionItemEvento += SeleccionItem;
}

void OnDisable ()
{
   Cuadricula.SeleccionItemEvento -= SeleccionItem;
}
void Grid () {
      
      BidItem = new Cuadricula [TamañoX, TamañoY];
      for (int x = 0; x < TamañoX; x++) 
      {
         for (int y = 0; y < TamañoY; y++) 
         {
            BidItem [x,y] = Instanciar (x,y);
         }
      }
    }

void LimpiarGrid()
{
   for (int x = 0; x < TamañoX; x++)
   {
      for (int y = 0; y < TamañoY; y++) {
         Encuentros encuentros = ObtenerInfo (BidItem [x, y]);
         if (encuentros.EncuentroValido) {
            Destroy (BidItem [x, y].gameObject);
            BidItem[x,y] = Instanciar (x, y);
            y--;
       }
      }
          }
                     }


Cuadricula Instanciar (int x, int y)
{
   GameObject ItemRandom = _items[Random.Range (0, _items.Length)];
   GameObject NuevoItem = (GameObject) Instantiate (ItemRandom, new Vector3 (x, y, 0f), Quaternion.identity);
   NuevoItem.GetComponent<Cuadricula>().Posicion (x,y);
   return NuevoItem.GetComponent<Cuadricula> ();
}

void SeleccionItem (Cuadricula item)
{
   if (ItemActual == item || !Jugando) {
      return;
   }
   if (ItemActual == null) {
      ItemActual = item;
   }else
   {
      float xDif = Mathf.Abs (item.x - ItemActual.x);
      float yDif = Mathf.Abs (item.y - ItemActual.y);
      if (xDif + yDif == 1)
      {
         StartCoroutine (Cambio (ItemActual, item));
         //cambiar
      }else
      {
         Debug.Log ("Ese cambio no esta permitido");
      }
      ItemActual = null;
   }
}

IEnumerator IntentoEncuentros ( Cuadricula a, Cuadricula b)
{
   Jugando = false;
   yield return StartCoroutine (Cambio (a, b));
   Encuentros EncuentroA = ObtenerInfo (a);
   Encuentros EncuentroB = ObtenerInfo (b);
   
   if(!EncuentroA.EncuentroValido && !EncuentroB.EncuentroValido) {
      yield return StartCoroutine (Cambio (a, b));
      yield break;
   }
   if (EncuentroA.EncuentroValido)
   {
      yield return StartCoroutine (DestruirItems (EncuentroA.Encuentro));
      yield return StartCoroutine (UpdateGrid (EncuentroA));
   } 
   else if (EncuentroB.EncuentroValido)
   {
      yield return StartCoroutine (DestruirItems (EncuentroB.Encuentro));
      yield return StartCoroutine (UpdateGrid (EncuentroB));
   }
   Jugando = true;
}
IEnumerator UpdateGrid (Encuentros encuentro)
{
   if (encuentro.EncuentroStartY == encuentro.EncuentroEndY) {
      for ( int x = encuentro.EncuentroStartX; x <= encuentro.EncuentroEndX; x++){
         for (int y = encuentro.EncuentroStartY; y < TamañoY - 1; y++){
            Cuadricula upIndex = BidItem [x, y + 1];
            Cuadricula current = BidItem [x, y];
            BidItem [x, y] = upIndex;
            BidItem [x, y + 1] = current;
            BidItem [x, y].Posicion (BidItem [x, y].x, BidItem [x, y].y - 1);
         }
         BidItem [x, TamañoY-1] = Instanciar (x, TamañoY - 1);
      }
   }
   else if (encuentro.EncuentroEndX == encuentro.EncuentroStartX){
      int EncuentroHeight = 1 +(encuentro.EncuentroEndY - encuentro.EncuentroStartY);
      for (int y = encuentro.EncuentroStartY + EncuentroHeight; y <= TamañoY - 1; y++){
         Cuadricula lowIndex = BidItem [encuentro.EncuentroStartX, y - EncuentroHeight];
         Cuadricula current = BidItem [encuentro.EncuentroStartX, y];
         BidItem [encuentro.EncuentroStartX, y] = lowIndex;
         BidItem [encuentro.EncuentroStartX, y - EncuentroHeight] = current;
      }
      for (int y = 0; y < TamañoY - EncuentroHeight; y++) {
         BidItem [encuentro.EncuentroStartX, y].Posicion (encuentro.EncuentroStartX, y);
      }
      for (int i = 0; i < encuentro.Encuentro.Count; i++) {
         BidItem [encuentro.EncuentroStartX, (TamañoY-1) - i] = Instanciar (encuentro.EncuentroStartX, (TamañoY -1) -i) ;
      }
   }
   for (int x = 0; x < TamañoX; x++)
   {
      for (int y = 0; y < TamañoY; y++) {
         Encuentros encuentros = ObtenerInfo (BidItem [x, y]);
         if (encuentros.EncuentroValido) {
            yield return new WaitForSeconds (minItemsPorEncuentro);
            yield return StartCoroutine (DestruirItems (encuentros.Encuentro));
            yield return new WaitForSeconds (minItemsPorEncuentro);
            yield return StartCoroutine (UpdateGrid (encuentros));
   
         }
      }
   }
}

IEnumerator DestruirItems ( List <Cuadricula> items)
{
   foreach (Cuadricula i in items) {
      yield return StartCoroutine (i.transform.Escala (Vector3.zero, 0.01f));
      DestroyImmediate (i.gameObject);
   }
}

IEnumerator Cambio ( Cuadricula a, Cuadricula b)
{
   CambioRigidbody (false);
   float DuracionMov = 0.1f;
   Vector3 PosicionItemA = a.transform.position;
   StartCoroutine (a.transform.Move (b.transform.position, DuracionMov));
   StartCoroutine (b.transform.Move (PosicionItemA, DuracionMov));
   yield return new WaitForSeconds (DuracionMov);
   CambioRigidbody (true);
}

void ActualizarValores ( Cuadricula a, Cuadricula b)
{
   Cuadricula TemporalA = BidItem [a.x, a.y];
   BidItem [a.x, a.y] = b;
   BidItem [b.x, b.y] = TemporalA;
   int ViejobX = b.x;
   int ViejobY = b.y;
   b.Posicion (a.x, a.y);
   a.Posicion(ViejobX, ViejobY);
}

List <Cuadricula> BuscarHorizontal ( Cuadricula item)
{
   List <Cuadricula> HItems = new List <Cuadricula>{ item };
   int Left = item.x -1;
   int Right = item.x +1;
   while (Left >= 0 && BidItem [Left, item.y].id == item.id) 
   {
      HItems.Add (BidItem [Left,item.y]);
      Left--;
   }
   while (Right < TamañoX && BidItem [Right, item.y].id == item.id)
   {
      HItems.Add (BidItem [Right,item.y]);
      Right--;
   }
      return HItems;
}
List <Cuadricula> BuscarVertical ( Cuadricula item)
{
   List <Cuadricula> VItems = new List <Cuadricula>{ item };
   int Lower = item.y -1;
   int Upper = item.y +1;
   while (Lower >= 0 && BidItem [item.x, Lower].id == item.id)
   {
      VItems.Add (BidItem [item.x, Lower]);
      Lower--;
   }
   while (Upper < TamañoY && BidItem [item.x, Upper].id == item.id)
   {
      VItems.Add (BidItem [item.x, Upper]);
      Upper++;
   }
      return VItems;
}

Encuentros ObtenerInfo ( Cuadricula item)
{
   Encuentros E = new Encuentros ();
   E.Encuentro = null;
   List <Cuadricula> HEncuentro = BuscarHorizontal (item);
   List <Cuadricula> VEncuentro = BuscarVertical (item);
   if (HEncuentro.Count >= minItemsPorEncuentro && HEncuentro.Count > VEncuentro.Count){
      //informar de los encuentros
      E.EncuentroStartX = ObtenerMinimoX(HEncuentro);
      E.EncuentroEndX = ObtenerMinimoX (HEncuentro);
      E.EncuentroStartY = E.EncuentroEndY = HEncuentro[0].y;
      E.Encuentro = HEncuentro;
   }
   else if (VEncuentro.Count >= minItemsPorEncuentro){
      E.EncuentroStartY = ObtenerMinimoX(VEncuentro);
      E.EncuentroEndY = ObtenerMaximoY(VEncuentro);
      E.EncuentroStartX = E.EncuentroEndY = HEncuentro[0].x;
      E.Encuentro = VEncuentro;
   }
}

int ObtenerMinimoX ( List <Cuadricula> items)
{
   float [] indices = new float [ items.Count];
   for (int i = 0; i < indices.Length; i++) {
      indices  = items .x;
   }
   return (int)Mathf.Min (indices);
}
   

int ObtenerMaximoX ( List <Cuadricula> items)
{
   float [] indices = new float [ items.Count];
   for (int i = 0; i < indices.Length; i++) {
      indices  = items .x;
   }
   return (int) Mathf.Max (indices);
}
   
   
int ObtenerMinimoY ( List <Cuadricula> items)
{
   float [] indices = new float [ items.Count];
   for (int i = 0; i < indices.Length; i++) {
      indices  = items .y;
   }
   return (int) Mathf.Min (indices);
}
   

int ObtenerMaximoY ( List <Cuadricula> items)
{
   float [] indices = new float [ items.Count];
   for (int i = 0; i < indices.Length; i++) {
      indices  = items .y;
   }
   return (int) Mathf.Max (indices);
}
   

void ObtenerItems()
{
   _items = Resources.LoadAll <GameObject> ("Prefabs");
   for ( int i = 0; i < _items.Length; i++) {
      _items.GetComponent <Cuadricula>().id = i;
   }
}

void CambioRigidbody ( bool Estado)
{
   foreach (Cuadricula c in BidItem) {
      c.GetComponent<Rigidbody2D>().isKinematic =!Estado;
}
}


}

 
 

en la funcion obtenerInfo:
 

Encuentros ObtenerInfo ( Cuadricula item)
{
   Encuentros E = new Encuentros ();
   E.Encuentro = null;
   List <Cuadricula> HEncuentro = BuscarHorizontal (item);
   List <Cuadricula> VEncuentro = BuscarVertical (item);
   if (HEncuentro.Count >= minItemsPorEncuentro && HEncuentro.Count > VEncuentro.Count){
      //informar de los encuentros
      E.EncuentroStartX = ObtenerMinimoX(HEncuentro);
      E.EncuentroEndX = ObtenerMinimoX (HEncuentro);
      E.EncuentroStartY = E.EncuentroEndY = HEncuentro[0].y;
      E.Encuentro = HEncuentro;
   }
   else if (VEncuentro.Count >= minItemsPorEncuentro){
      E.EncuentroStartY = ObtenerMinimoX(VEncuentro);
      E.EncuentroEndY = ObtenerMaximoY(VEncuentro);
      E.EncuentroStartX = E.EncuentroEndY = HEncuentro[0].x;
      E.Encuentro = VEncuentro;
   }
}

 
ya te lo dice el error: not all code patj returns a value.....
 
no todos los "caminos" de la funcion devuelven un valor...
 
si te fijas pones:
 
if (hencuentros.count es mayor que.....) y luego pones un else if.... pero te falta el ultimo else....  si no se cumple ninguna de las dos condiciones la funcion no devuleve nada...
 
pon despues del "else if" un "else" en el que devuelvas(return) un "encuentro"
 
algo asi:
 

Encuentros ObtenerInfo ( Cuadricula item)
{
   Encuentros E = new Encuentros ();
   E.Encuentro = null;
   List <Cuadricula> HEncuentro = BuscarHorizontal (item);
   List <Cuadricula> VEncuentro = BuscarVertical (item);
   if (HEncuentro.Count >= minItemsPorEncuentro && HEncuentro.Count > VEncuentro.Count){
      //informar de los encuentros
      E.EncuentroStartX = ObtenerMinimoX(HEncuentro);
      E.EncuentroEndX = ObtenerMinimoX (HEncuentro);
      E.EncuentroStartY = E.EncuentroEndY = HEncuentro[0].y;
      E.Encuentro = HEncuentro;
   }
   else if (VEncuentro.Count >= minItemsPorEncuentro){
      E.EncuentroStartY = ObtenerMinimoX(VEncuentro);
      E.EncuentroEndY = ObtenerMaximoY(VEncuentro);
      E.EncuentroStartX = E.EncuentroEndY = HEncuentro[0].x;
      E.Encuentro = VEncuentro;
   } else { //esto te falta
           return E; //porejemplo, sino crea un "encuentro" a tu gusto... o devuelve un new Encuentros()...
        }
}

 
 
 
ah, en el ultimo "else" (el que te faltaba) tambien puedes poner un "return null" si no quieres que devuelva nada
 
luego tendras que comprobar si es null o no es null antes de "usar" el valor devuelto por la funcion...

en la funcion ObtenerInfo al final antes del } debes poner return E;

Te lo dice el error: En todos los casos debes devolver siempre algún valor.