Jump to content

Más en DLAN: Nuestras Traducciones | Otras Traducciones | Mods y modding | Revisiones y Guías | Videojuegos | Arte | Literatura | Rol y Rol por foro e IRC | Mapa de la web
Photo

Buscar criaturas/ubicados en todas las areas con nombre.


3 replies to this topic

#1 Obsidiana

Obsidiana

    Humano

  • Miembro
  • Pip
  • 50 posts

Posted 02 February 2020 - 11:20 PM

Buenas pues como indica el título, ando haciendo un sistemilla bastante chulo de resucitación de pjs con cadáveres en templos o revivires, en el cual se pone el mismo nombre a los ubicados-objetos que el nombre del pj. Y es lo que uso para buscar al jugador.

 

El problema erradica en que estoy intentando hacer, que cuando sales de un area (limbo), se lance un script en el onexit, en el que el script busca en todas las areas del servidor el ubicado que se llama igual que el pj y lo destruye, pero de momento no lo consigo. Tengo el mismo problema con el poder buscar el objeto de los inventarios de los pjs que se llame igual que el pj para que lo borre igualmente.

 

(Las etiquetas no me sirven para esta idea)

 

Alguien sabría decirme como hacerlo? Un abrazo.



#2 Zoraga

Zoraga

    Ancillae

  • Miembro
  • PipPipPip
  • 256 posts

Posted 03 February 2020 - 09:49 AM

¿Esos ubicados u objetos, donde van? si van en los templos, el script quiza podrias ponerlo en el onenter del templo en vez del onexit del limbo, entonces asi poder encontrarlo mas facil dentro del área.


Colaborando en:



Nombre servidor: ES) Rebelión del Submundo
Tipo de servidor: rol/acción/jvj
Jugadores: 1-25
Niveles: 1-30
Base literaria: Reinos Olvidados
IP (conectar directamente): sombrasdefaerun.no-ip.org
Foro: http://usn-rol.foroes.org/



 


#3 Avernum

Avernum

    Humano

  • Miembro
  • Pip
  • 15 posts

Posted 03 February 2020 - 10:15 PM

Hola, 

 

Si he entendido bien, al morir el pj se crea un ubicado donde ha muerto y se le envía a un limbo. Cuando sale de ese limbo aparece en ese ubicado. ¿Es así?

 

Si es así... EDIT: No es así, pero el script te servirá para buscar ese ubicado en el mundo. Mira más abajo para destruir objetos de inventario.

 

Yo pondría una variable object en el jugador y le asignaría ese objeto 

 

//OnDeath
oPJ = GetLastPlayerDied();
location lLocalizacionPJ = GetLocation(oPJ);
object oUbicado = CreateObject(OBJECT_TYPE_PLACEABLE, "TUBICADO", lLocalizacionPJ);
SetLocalObject(oPJ, "UbicadoVar", oUbicado);

Así el pj ya tiene el objeto en sí mismo y no hace falta buscarlo, con lo que te ahorras todo eso.

 

Y luego en el OnExit del Limbo:

object oPJ = GetExitingObject();
//Buscamos el ubicado
object oDondeSaltar = GetLocalObject(oPJ, "UbicadoVar");
//Y saltamos a él
AssignCommand(oPJ, ClearAllActions());
AssignCommand(oPJ, JumpToObject(oDondeSaltar)); //o JumpToLocation...
//o lo destruimos con 
DestroyObject(oDondeSaltar);

Si tienes problemas borrando items en el inventario, te paso esta funcion 

 

// /////////////////////////////////////////////////////////////////////////////
// ContarItemsInventario
// Devuelve el numero de items sItem en el inventario de oTarget, tiene en cuenta stacks
// Ripeado y modificado de nw_i0_plot
//Hacer que cuente todos o algunos, por tipo, etc
// /////////////////////////////////////////////////////////////////////////////
int ContarItemsInventario(object oTarget,string sItem, int iTipoBase = -1)
{
    int nNumItems = 0;object oItem = GetFirstItemInInventory(oTarget);
    while (oItem!=OBJECT_INVALID)
    {
        if (iTipoBase>0)
        {
            if (GetBaseItemType(oItem)==iTipoBase){nNumItems = nNumItems + GetNumStackedItems(oItem);}
        }
        else
        {
            if (GetTag(oItem) == sItem){nNumItems = nNumItems + GetNumStackedItems(oItem);}
        }
        oItem = GetNextItemInInventory(oTarget);
    }
    return nNumItems;
}
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
// DestruirItemsInventario
// Destruye el inventario de un objeto.
// Opcion:
// 1 = Todo
// 2 = 1 Item sItem
// 3 = Todos los items sItem
// 4 = X Items sItem
// Tambien destruye por tipo de objeto (potis, anillos, armas, etc)
// Ejemplos:
// Destruir todo el inventario
// Destruir X potis del inventario, o todas, etc.
// /////////////////////////////////////////////////////////////////////////////
void DestruirItemsInventario(object oTarget = OBJECT_SELF, string sItem = "", int Opcion = 1, int NumItems = 1, int iTipoBase = BASE_ITEM_INVALID)
{
    int iNumItemsDestruidos = 0;
    int iConteoItems        = ContarItemsInventario(oTarget, sItem);
    object oItem            = GetFirstItemInInventory(oTarget);
    int iStackSize          = 0;
    int iTmp                = 0;
    int i=0;

    while (oItem!=OBJECT_INVALID)
    {
        switch(Opcion)
        {
            //Destruir todo el inventario ------------------------------
            case 1:
                    SetPlotFlag(oItem,FALSE);/*SetIsDestroyable(TRUE,FALSE,FALSE);*/
                    DestroyObject(oItem,0.0f);
                    break;
            //Destruir 1 item sItem y salir ----------------------------
            case 2:
                        if (GetTag(oItem) == sItem)
                        {
                            SetPlotFlag(oItem,FALSE);
                            if (GetNumStackedItems(oItem)>1){SetItemStackSize(oItem,GetNumStackedItems(oItem)-1);}else{DestroyObject(oItem,0.0f);}
                            return;
                        }
                    break;
            //Destruir todos los items sItem ---------------------------
            case 3:
                        //Contamos los items
                        if (iNumItemsDestruidos>=iConteoItems){return;}
                        if (GetTag(oItem) == sItem){SetPlotFlag(oItem,FALSE);DestroyObject(oItem,0.0f);iNumItemsDestruidos++;}
                    break;
            //Destruir NumItems sItem teniendo en cuenta stack. Me cago en los stacks. ----------------------------------
            case 4:
                    {
                        if (iNumItemsDestruidos>=NumItems){return;}
                        else
                        {
                            if (GetTag(oItem) == sItem)
                            {
                                i = i + 1;
                                SendMessageToPC(GetFirstPC(), "Recorriendo Objeto iNum: "+IntToString(i));
                                SetPlotFlag(oItem,FALSE);
                                iStackSize = GetNumStackedItems(oItem);
                                SendMessageToPC(GetFirstPC(), "StackSize: "+IntToString(iStackSize)+". Tag: "+sItem);
                                if (iStackSize==1 || iStackSize==0)
                                {
                                    DestroyObject(oItem,0.0f);
                                    iNumItemsDestruidos = iNumItemsDestruidos + 1;
                                    SendMessageToPC(GetFirstPC(), "ItemsDestruidos: "+IntToString(iNumItemsDestruidos));
                                }
                                else if (iStackSize==NumItems)
                                {
                                    DestroyObject(oItem,0.0f);
                                    iNumItemsDestruidos = iNumItemsDestruidos + iStackSize;
                                    SendMessageToPC(GetFirstPC(), "ItemsDestruidosFullStack: "+IntToString(iNumItemsDestruidos));
                                    return;
                                }
                                else if (iStackSize>NumItems)
                                {
                                    iTmp = iStackSize - (NumItems-iNumItemsDestruidos);
                                    SetItemStackSize(oItem, iTmp);
                                    iNumItemsDestruidos = iNumItemsDestruidos + NumItems;
                                    SendMessageToPC(GetFirstPC(), "ItemsDestruidosPlusStack: "+IntToString(iNumItemsDestruidos));
                                    return;
                                }
                                else if (iStackSize<NumItems)
                                {
                                    if (iStackSize>(NumItems-iNumItemsDestruidos)){SetItemStackSize(oItem, iStackSize-(NumItems-iNumItemsDestruidos));}
                                    else
                                    {
                                        DestroyObject(oItem,0.0f);
                                    }
                                    iNumItemsDestruidos = iNumItemsDestruidos + iStackSize;
                                    SendMessageToPC(GetFirstPC(), "ItemsDestruidosPartialStack: "+IntToString(iNumItemsDestruidos));
                                }
                             }
                        }
                    }
                    break;
            //Destruir todos los items de BASE_ITEM_* =  iTipoBase ----------------------------------
            case 5:
                    {
                        if (GetBaseItemType(oItem) == iTipoBase){SetPlotFlag(oItem,FALSE);DestroyObject(oItem,0.0f);}
                    }
                    break;
            //Destruir NumItems items de BASE_ITEM_* =  iTipoBase --ejemplo destruye random d3 potis bwahaha . util para TDHLevelUp, ya que suele inundar de potis ------
            case 6:
                    {
                        if (iNumItemsDestruidos>=NumItems){return;}
                        else
                        {
                        if (GetBaseItemType(oItem) == iTipoBase){SetPlotFlag(oItem,FALSE);DestroyObject(oItem,0.0f);iNumItemsDestruidos++;}
                        }
                    }
                    break;
         }//switch
        oItem = GetNextItemInInventory(oTarget);
    }
}

Puedes modificarlo para que borre por nombre de objeto, pero es siempre mejor por tag... 

 

Si quieres borrar por nombre, yo haría: 

 

//Destruir todo objeto en el inventario del jugador que se llame como él.
object oPJ = GetExitingObject();
string sNombrePJ = GetName(oPJ);
string sNombreItem;
object oItem = GetFirstItemInInventory(oPJ);
    while (oItem!=OBJECT_INVALID)
    {
        sNombreItem = GetName(oItem);
        if (sNombreItem==sNombrePJ)
        {
             DestroyObject(oItem); //Aqui podemos poner un return si queremos destruir 1 solo
        }
        oItem = GetNextItemInInventory(oPJ);
    }


#4 Obsidiana

Obsidiana

    Humano

  • Miembro
  • Pip
  • 50 posts

Posted 03 February 2020 - 11:13 PM

Muy útil!!! Es exactamente lo que buscaba jaja





Reply to this topic



  


A Bragol. Tus amigos te echan de menos.