private void SetResourcesSinExplotar(TipoRecurso recursoDeseado)
{
List <Vector3> recursos = StageData.currentInstance.GetPartidaActual().JugadorActual.posicionRecursosEncontrados;
foreach (Vector3 v in recursos)
{
AddRecursoSinExplotar(v);
}
/*Node[,] grafo = StageData.currentInstance.grafoTotal;
* List<Unidad> unidades_jugador = StageData.currentInstance.GetPartidaActual().JugadorActual.unidadesDisponibles;
* List<Vector3> posRecursosSinExplorar = new List<Vector3> ();
* foreach (Unidad u in unidades_jugador)
* {
* //Aqui esta como quie muy harcodeado lol xd.
* List<Node> VisionDeNodos = Control.GetNodosAlAlcance (u.Nodo, 5);
* foreach (Node n in VisionDeNodos)
* {
* if (n.GetPlayerInfluence(StageData.currentInstance.GetPartidaActual().JugadorActual.idJugador) != 1 &&
* n.resourceType == recursoDeseado && n.unidad != null)
* {
* AddRecursoSinExplotar (n.position);
* }
* }
* }*/
}
public void SumarRecursos(TipoRecurso idRecurso, int cantidad)
{
switch (idRecurso)
{
case TipoRecurso.Food:
comida += cantidad;
break;
case TipoRecurso.Wood:
madera += cantidad;
break;
case TipoRecurso.Steel:
metal += cantidad;
break;
case TipoRecurso.Rock:
piedra += cantidad;
break;
case TipoRecurso.AllTypeResource:
comida += cantidad;
madera += cantidad;
metal += cantidad;
piedra += cantidad;
break;
}
}
/// <summary>
/// Método Priavdo encargado de Inicializar los Atributos dado un Id Configuración, Tipo Recurso, Id Tipo Unidad, Id Sub Tipo
/// </summary>
/// <param name="id_configuracion_asignacion_recurso">Id Configuración Recurso</param>
/// <param name="tipo">Tipo Recurso</param>
/// <param name="id_tipo_unidad">Tipo Unidad</param>
/// <param name="id_sub_tipo">Id Sub Tipo</param>
/// <returns></returns>
public bool cargaAtributosInstancia(int id_configuracion_asignacion_recurso, TipoRecurso tipo, int id_tipo_unidad,
int id_sub_tipo)
{
//Declarando Objeto de Retorno
bool result = false;
//Armando Objeto de Parametros
object[] param = { 5, 0, id_configuracion_asignacion_recurso, tipo, id_tipo_unidad, id_sub_tipo, 0, 0, false, "", "" };
//Obteniendo Resultado del SP
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{ //Validando Origen de Datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{ //Recorriendo cada Fila
foreach (DataRow dr in ds.Tables["Table"].Rows)
{ //Asignando Valores
this._id_configuracion_asignacion_recurso_tipo = Convert.ToInt32(dr["Id"]);
this._id_configuracion_asignacion_recurso = Convert.ToInt32(dr["IdConfiguracionRecurso"]);
this._id_tipo_recurso = Convert.ToByte(dr["IdTipoRecurso"]);
this._id_tipo_unidad = Convert.ToInt32(dr["IdTipoUnidad"]);
this._id_sub_tipo_unidad = Convert.ToInt32(dr["IdSubTipoUnidad"]);
this._cantidad = Convert.ToByte(dr["Cantidad"]);
this._habilitar = Convert.ToBoolean(dr["Habilitar"]);
}
//Asignando Resultado a Positivo
result = true;
}
}
//Devolviendo Objeto de Retorno
return(result);
}
public bool GuardarTipoRecurso(TipoRecurso tiporecurso)
{
using (var transaction = db.Database.BeginTransaction())
{
try
{
if (tiporecurso.Pk_Id_TipoRecurso > 0)
{
ModificarTipoRecurso(tiporecurso);
}
else
{
db.Tbl_Tipo_Recurso.Add(tiporecurso);
}
db.SaveChanges();
transaction.Commit();
return(true);
}
catch (Exception)
{
transaction.Rollback();
return(false);
}
}
}
public void Atualizar(TipoRecurso tiporecurso)
{
using (var contexto = new AjudaDigitalContext())
{
contexto.Entry(tiporecurso).State = System.Data.Entity.EntityState.Modified;
contexto.SaveChanges();
}
}
public void Adicionar(TipoRecurso tiporecurso)
{
using (var context = new AjudaDigitalContext())
{
context.tiporecurso.Add(tiporecurso); //adicionando o objeto afinidade da classeAjudaDigitalContext
context.SaveChanges();
}
}
// POST: TipoRecurso/Delete/5
//[HttpPost, ActionName("Delete")]
//[ValidateAntiForgeryToken]
public ActionResult DeleteConfirmed(int id)
{
TipoRecurso tipoRecurso = db.Tbl_Tipo_Recurso.Find(id);
db.Tbl_Tipo_Recurso.Remove(tipoRecurso);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Cadastrar(Recurso recurso, TipoRecurso tiporecurso)// entidade login recebe o que o usuario digitou
{
RecursoDao recursodao = new RecursoDao();
recurso.TipoRecurso = tiporecurso; // estamos passando o que o usuario digitou para o login da entidade
recursodao.Adicionar(recurso); // adicionando ao banco todos os campos digitados pelo usuario
return(RedirectToAction("Index", "Recurso"));
}
public static TipoRecurso MapToModel(TipoRecursoViewModel tipoRecursoViewModel)
{
TipoRecurso tipoRecurso = new TipoRecurso()
{
idTipoRecurso = tipoRecursoViewModel.idTipoRecurso,
Descr = tipoRecursoViewModel.Descr
};
return(tipoRecurso);
}
public static TipoRecursoViewModel MapToViewModel(TipoRecurso tipoRecurso)
{
TipoRecursoViewModel tipoRecursoViewModel = new TipoRecursoViewModel()
{
idTipoRecurso = tipoRecurso.idTipoRecurso,
Descr = tipoRecurso.Descr
};
return(tipoRecursoViewModel);
}
//[ValidateAntiForgeryToken]
public ActionResult Edit([Bind(Include = "Pk_Id_TipoRecurso,Descripcion_Tipo_Recurso")] TipoRecurso tipoRecurso)
{
if (ModelState.IsValid)
{
db.Entry(tipoRecurso).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoRecurso));
}
public ActionResult Create([Bind(Include = "id,descricao,tipo")] TipoRecurso tipoRecurso)
{
if (ModelState.IsValid)
{
db.tiporecurso.Add(tipoRecurso);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoRecurso));
}
public CompartilhadoModel(Compartilhado compartilhado)
: base(compartilhado)
{
this.EnderecoIp = compartilhado.EnderecoIp;
this.BaseDeDados = compartilhado.BaseDeDados;
this.EspacoEmDisco = compartilhado.EspacoEmDisco;
this.Processadores = compartilhado.Processadores;
this.Memoria = compartilhado.Memoria;
this.BackupDiario = compartilhado.BackupDiario;
this.BackupIncremental = compartilhado.BackupIncremental;
this.TipoRecurso = compartilhado.TipoRecurso;
}
public static void InsertarTipoRecurso(TipoRecurso tipoRecurso)
{
RBVDataContext contextoRBV = new RBVDataContext();
contextoRBV.tipoRecursos.InsertOnSubmit(new tipoRecurso
{
tipoRecurso1 = tipoRecurso.NombreTipoRecurso,
Descripcion = tipoRecurso.Descripcion,
Acciones = tipoRecurso.Acciones
});
contextoRBV.SubmitChanges();
}
public static void ActualizarTipoRecurso(TipoRecurso tipoRecurso)
{
RBVDataContext contextoRBV = new RBVDataContext();
tipoRecurso tipoRecursoAnterior = new tipoRecurso();
tipoRecursoAnterior = contextoRBV.tipoRecursos.SingleOrDefault(p => p.idTipoRecurso == tipoRecurso.IdTipoRecurso);
tipoRecursoAnterior.tipoRecurso1 = tipoRecurso.NombreTipoRecurso;
tipoRecursoAnterior.Descripcion = tipoRecurso.Descripcion;
tipoRecursoAnterior.Acciones = tipoRecurso.Acciones;
contextoRBV.SubmitChanges();
}
//[ValidateAntiForgeryToken]
public ActionResult Create(TipoRecurso tipoRecurso)
{
bool restpuestaGuardado = TipoRecursoServices.GuardarTipoRecurso(tipoRecurso);
if (restpuestaGuardado)
{
ViewBag.Mensajes = "Exito en el registro";
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
// GET: TipoRecurso/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoRecurso tipoRecurso = db.Tbl_Tipo_Recurso.Find(id);
if (tipoRecurso == null)
{
return(HttpNotFound());
}
return(View(tipoRecurso));
}
public Node(Vector3 pos, bool water)
{
queuePosition = NO_ESTA_EN_LISTA_ABIERTOS;
Cost = float.PositiveInfinity;
resourceType = TipoRecurso.NullResourceType;
unidad = null;
arrayVecinos = new List<Pareja>();
position = pos;
Water = water;
route = null;
influencePlayers = new List<List<int>> ();
currentResources = new List<TipoRecurso> (1);
AddAllPlayersToInfluences();
}
public static TipoRecurso ConsultarTipoRecurso(short IdTipoRecurso)
{
RBVDataContext contextoRBV = new RBVDataContext();
TipoRecurso tipoRecurso = new TipoRecurso();
var tipoRec = (from tiporec in contextoRBV.tipoRecursos
where tiporec.idTipoRecurso == IdTipoRecurso
select new TipoRecurso
{
IdTipoRecurso = tiporec.idTipoRecurso,
NombreTipoRecurso = tiporec.tipoRecurso1,
Descripcion = tiporec.Descripcion
});
tipoRecurso = tipoRec.SingleOrDefault();
return(tipoRecurso);
}
//Metodo para Modificar el Tipo de Recurso.
public void ModificarTipoRecurso(TipoRecurso tiporecurso)
{
using (var transaction = db.Database.BeginTransaction())
{
try
{
if (tiporecurso != null)
{
db.Entry(tiporecurso).State = EntityState.Modified;
}
else
{
db.Tbl_Tipo_Recurso.Add(tiporecurso);
db.SaveChanges();
transaction.Commit();
}
}
catch (Exception)
{
transaction.Rollback();
}
}
}
public ActionResult CadastrarTipoRecurso(TipoRecursoViewModel tipoRecursoViewmodel)
{
TipoRecurso model = null;
try
{
model = TipoRecursoViewModel.MapToModel(tipoRecursoViewmodel);
//this.speDominioService.InserirTipoRecurso(model);
BL.TipoRecurso.InserirTipoRecurso(model);
TempData["Sucesso"] = true;
TempData["SucessoMessage"] = "Cadastro de Tipo de Recurso realizado com sucesso.";
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = (ex.GetType().Name == "CustomException") ? ex.Message : "Erro ao cadastrar Tipo de Recurso";
Logging.getInstance().Error(TempData["ErrorMessage"].ToString(), ex);
}
return(RedirectToAction("Index"));
}
public Compartilhado(int id,
string nome,
decimal valorMensal,
SituacaoRecurso situacao,
bool interno,
string enderecoIp,
bool baseDeDados,
decimal espacoEmDisco,
int processadores,
decimal memoria,
bool backupDiario,
bool backupIncremental,
TipoRecurso tipoRecurso) :
base(id, nome, valorMensal, situacao, interno)
{
this.EnderecoIp = enderecoIp;
this.BaseDeDados = baseDeDados;
this.EspacoEmDisco = espacoEmDisco;
this.Processadores = processadores;
this.Memoria = memoria;
this.BackupDiario = backupDiario;
this.BackupIncremental = backupIncremental;
this.TipoRecurso = tipoRecurso;
}
public static void InsertarTipoRecurso(TipoRecurso tipoRecurso)
{
Datos.MaestrosDA.InsertarTipoRecurso(tipoRecurso);
}
public void SetResourceType(TipoRecurso nuevoTipo)
{
resourceType = nuevoTipo;
}
public bool GuardarTipoRecurso(TipoRecurso tiporecurso)
{
return(TiporecursoRepositorio.GuardarTipoRecurso(tiporecurso));
}
public void SetResourceToNode (TipoRecurso nuevoRecurso)
{
resourceType = nuevoRecurso;
}
public Recurso(string nombre, TipoRecurso tipo)
{
this.nombre = nombre;
this.tipo = tipo;
}
/// <summary>
/// Constructor encargado de Inicializar los Atributos dado un Id de Registro
/// </summary>
/// <param name="id_configuracion_asignacion_recurso">Id Configuracion</param>
/// <param name="tipo">Tipo Recurso</param>
/// <param name="id_tipo_unidad">Id Tipo Unidad</param>
/// <param name="id_sub_tipo">Id Subtipo</param>
public ConfiguracionAsignacionRecursoTipo(int id_configuracion_asignacion_recurso, TipoRecurso tipo, int id_tipo_unidad, int id_sub_tipo)
{ //Invocando Método de Carga
cargaAtributosInstancia(id_configuracion_asignacion_recurso, tipo, id_tipo_unidad, id_sub_tipo);
}
public bool ComenzarTurno(ref int puntosAsig)
{
// Buscamos ahora a los aldeanos disponibles.
int totalAldeanos = 0;
puntosDispo = puntosAsig;
foreach (Unidad un in StageData.currentInstance.GetPartidaActual().JugadorActual.unidadesDisponibles)
{
if (un.IdUnidad == TipoUnidad.Worker)
{
totalAldeanos++;
}
}
if (totalAldeanos < 3)
{
numeroAldeanosMINIMOS = true;
}
else
{
numeroAldeanosMINIMOS = false;
}
//numeroAldeanosMINIMOS = StageData.currentInstance.GetPartidaActual().JugadorActual.Aldeanos < 1;
recursoMinimoActual = StageData.currentInstance.GetPartidaActual().JugadorActual.GetMenorTipoRecurso();
recursosSinExplotar.Clear();
//print("COMIENZA ROL RECOLECTOR");
if (numeroAldeanosMINIMOS)
{
numeroCreaciones = puntosAsig / StageData.COSTE_PA_CREAR_ALDEANO;
if (numeroCreaciones > 3)
{
numeroCreaciones = 3;
}
if (numeroCreaciones > 0)
{
StartCoroutine("CrearAldeano");
return(true);
}
else
{
return(false);
}
//Empieza la corutina de crear los aldeanos.
}
/*if (partidaActual.JugadorActual.posicionRecursosEncontrados.Count < 3)
* {
* //Mandamos a la peña a recoger recursos, para ello dedicaremos los recursos a Explorador.
* }*/
else
{
int movimientosDisponibles = puntosDispo / StageData.COSTE_PA_MOVER_UNIDAD;
if (movimientosDisponibles > 0)
{
StartCoroutine("PrepararOrdenesAldeanos");
StartCoroutine("MoverAldeanos");
return(true);
}
else
{
return(false);
}
}
//Comprobamos si necesitamos recursos mínimos, para cumplir necesidades mínimas.
}
public static void ActualizarTipoRecurso(TipoRecurso tipoRecurso)
{
Datos.MaestrosDA.ActualizarTipoRecurso(tipoRecurso);
}
