Mensajes

El problema con 64 bits pasa porque esta expresión:

Código (cpp) [Seleccionar] Expandir

(1<<i)

tiene el tipo del operando izquierdo (la constante literal 1), o sea int. En otras palabras, en realidad estás efectuando el desplazamiento sobre un valor de 32 bits. Si conviertes ese 1 a int64_t, debería funcionar.

Si era eso gracias, tema solucionado.


B#

Gracias a ambos por responder, he cambiado el código para realizar el mismo problema con operaciones de 32 bits y si funciona perfectamente:

Código (cpp) [Seleccionar] Expandir

#include <cstdio>
#include <cstdint>

int32_t SumadorCompleto(int32_t A,int32_t B,int8_t TamanioBits=(sizeof(int32_t)*8))
{
    int32_t Resultado;
    int32_t PrimeraOp;
    int32_t SegundaOp;
    int32_t i;
    int8_t CarryActual;
    CarryActual^=CarryActual;
    Resultado^=Resultado;
    for(i^=i;i<TamanioBits;i++)
    {
        PrimeraOp=((A>>i)&1)^((B>>i)&1);
        SegundaOp=(PrimeraOp&1)^(CarryActual&1);
        Resultado|=(SegundaOp<<i)&(1<<i);
        CarryActual=(PrimeraOp&1)&&(CarryActual&1)||((((A>>i)&1)&&((B>>i)&1))&1);
    }
    return Resultado;
}

int main()
{
    int32_t A=4,B=-7;
    printf("A:%i + B:%i = %i\n",A,B,SumadorCompleto(A,B));
    return 0;
}



Me doy por vencido espero no necesitar números con 64 bits en mis proyectos reales...


B#

[(No puedo subir el código en Pascal porque el foro no lo permite)]

Primero antes que nada buenos días/noches.

Bueno digamos que estaba muy aburrido y me puse a generar un código que sume en Complemento a 2:

Código (cpp) [Seleccionar] Expandir

#include <cstdio>
#include <cstdint>

int64_t SumadorCompleto(int64_t A,int64_t B,uint8_t TamanioBits=(sizeof(int64_t)*8))
{
   int64_t Resultado;
   int64_t PrimeraOp;
   int64_t SegundaOp;
   int64_t i;
   int64_t CarryActual;
   CarryActual^=CarryActual;
   Resultado^=Resultado;
   for(i^=i;i<TamanioBits;i++)
   {
       PrimeraOp=((A>>i)&1)^((B>>i)&1);
       SegundaOp=(PrimeraOp&1)^(CarryActual&1);
       Resultado|=(SegundaOp<<i)&(1<<i);
       CarryActual=(PrimeraOp&1)&&(CarryActual&1)||((((A>>i)&1)&&((B>>i)&1))&1);
   }
   return Resultado;
}

int main()
{
   int64_t A=4,B=-7;
   printf("A:%li + B:%li = %li\n",A,B,SumadorCompleto(A,B));
   return 0;
}

Si lo pruebo con ambos números enteros pequeños 4 y 7 el código funciona perfectamente, ahora el problema es cuando pongo un número entero gigante o negativo el código no funciona:



Dije quizás sea un error de GCC voy a probar otro compilador diferente y de diferente lenguaje como Pascal:

(No puedo subir el código en Pascal porque el foro no lo permite)

(Solución temporal o hasta que alguien lo verifique lo subo en imagenes)




Lo cuál ocurre lo mismo:



Pero lo que me inquietó es que pasado los 31 bits de desplazamiento no parece realizar operaciones al menos de manera correcta:



Mi duda es hay alguna manera de llegar a desplazar más bits correctamente, o yo tengo algún error y no me dí cuenta todavía del error o ¿También es una limitación de los procesadores esto?


B#

A ver que pasa con GCC:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>

struct _hdr
{
   char data1;
   double data2;
   char* data3;
};

struct _hdr __attribute__((__cdecl__)) foo()
{
   struct _hdr instance;
instance.data1 = 'A';
instance.data2 = 45.04;
instance.data3 = (char*)"PROBANDO 123";
   return instance;
}

int __attribute__((noinline)) __attribute__((__cdecl__)) foo2(int a, int b)
{
   return 0;
}

int main(int argc,char*argv[])
{
   struct _hdr estructura;
   int entero=foo2(1,2);
   estructura=foo();
   printf("%c %.2f %s %i\n",estructura.data1,estructura.data2,estructura.data3,entero);
   return 0;
}

Al parecer una función común y corriente como foo2 en cdecl funciona perfectamente, pero es interesante ver lo que pasa con foo:



Está pasando un puntero como argumento, lo interesante es que al parecer GCC cambia la convención a tipo stdcall:



Si arreglo y paso como parametro el puntero a la estructura vemos como el descompilador funciona casi retornando el mismo código original:



Por lo que en este caso aunque además de retornar la dirección del puntero (aunque no es usado) a la estructura también trabaja con un argumento oculto.


B#

[exploit]

quería saber si un exploit puede llegar a agregar nueva información a una base de datos de un web

Un exploit es un código que se ejecuta en la máquina objetivo abusando de una vulnerabilidad con el fin de enviar un "código a ejecutar", el "código a ejecutar" usualmente llamado payload puede en teoría ser casi cualquier cosa siempre que el proceso de la máquina objetivo pueda ejecutarlo...


B#

y sobre lo de redactar códigos; será que en un futuro cercano cualquiera podrá crear un programa con solo señalar que es lo que quiere y en que lenguaje???...

Don Machacador ese supuesto "futuro cercano" comenzó hace un año bien y permite en realidad programar con describir en un solo texto.

En el video se puede apreciar HTML con CSS (aunque no es del todo perfecto ya que en la parte de tablas se confunde)

[youtube=640,360]https://www.youtube.com/watch?v=TjUvMQvrjrg[/youtube]


B#

Entonces quería saber para que propósito exactamente lo utilizarían... ¿Para que sirve el LUA y en qué se podría usar mejor?

Yo lo utilizo en mis cheats para añadir funcionalidad extra sin tener que re-compilar el cheat de nuevo, o para permitir a terceros que añadan funcionalidad personalizada...

Este es un ejemplo de un aimbot que funciona en mi cheat externo (un poco desactualizado) para Counter-Strike 1.6 (version build 4554), claro está que tiene la librería ImGui y funciones extras agregadas por mí que trabajan para añadirle Callbacks...

Código (lua) [Seleccionar] Expandir

--[[
   Author: BloodSharp
   Description: Custom Aimbot for Crianosfera Hack v5 External edition
]]

-- Main default settings
local bCustomAimbot = false
local bRenderOrigin = false
local bPrioritizeIfSomeOneIsAtShortDistance = true
local iAimingMethod = 0 -- Field of View: 0 / Distance: 1
local iAimTeam = 0 -- Enemies: 0 / Teammates: 1 / All: 2
local colorNonTarget = ImColor(255, 255, 255, 255) -- White color
local colorAimTarget = ImColor(0, 255, 0, 255) -- Green color

local iTargetAimbot = -1


-- I need to write W2S function this way because the wrapper that I use don't support arguments as references
local function WorldToScreen(vInput, vOutput)
if Utils.ConvertToScreen(vInput) then
local vConverted = Utils.GetLastConvertedToScreenVector()
vOutput.x = vConverted.x
vOutput.y = vConverted.y
return true
end
return false
end

local function DotProduct(vFirstVector, vSecondVector)
   return (vFirstVector.x * vSecondVector.x + vFirstVector.y * vSecondVector.y + vFirstVector.z * vSecondVector.z)
end

local function AngleBetween(vForward, vDifference)
   local vNormalizedForward = vForward:Normalize()
   local vNormalizedDifference = vDifference:Normalize()
   return (math.acos(DotProduct(vNormalizedForward, vNormalizedDifference)) * (180 / math.pi))
end

local function VectorAngles(forward, angles)
local tmp
local yaw
local pitch

if forward.y == 0 and forward.x == 0 then
yaw = 0
if forward.z > 0 then
pitch = 270
else
pitch = 90
end
else
yaw = (math.atan(forward.y, forward.x)) * 180 / math.pi
if yaw < 0 then
yaw = yaw + 360
end

tmp = math.sqrt(forward.x * forward.x + forward.y * forward.y)
pitch = (math.atan(-forward.z, tmp)) * 180 / math.pi
if pitch < 0 then
pitch = pitch + 360
end
end

angles.x = pitch
angles.y = yaw
angles.z = 0

while angles.x < -89 do
angles.x = angles.x + 180
angles.y = angles.y + 180
end
while angles.x > 89 do
angles.x = angles.x - 180
angles.y = angles.y + 180
end
while angles.y < -180 do
angles.y = angles.y + 360
end
while angles.y > 180 do
angles.y = angles.y - 360
end
end

local function VerifyTeam(index)
   if (iAimTeam == 0) and (LocalPlayer.GetTeam() ~= EntityManager.GetTeam(index)) then
       return true
   elseif (iAimTeam == 1) and (LocalPlayer.GetTeam() == EntityManager.GetTeam(index)) then
       return true
   elseif (iAimTeam == 2) then
       return true
   end
   return false
end

-- Inside the Lua Scripts tab...
local function OnRenderMenu()
   if ImGui.TreeNode("Custom Aimbot##CUSTOM_AIMBOT", true) then
       bCustomAimbot = ImGui.Checkbox("Enable##CUSTOM_AIMBOT", bCustomAimbot)
       ImGui.BeginGroup()
       bRenderOrigin = ImGui.Checkbox("Show origin##CUSTOM_AIMBOT", bRenderOrigin)
       bPrioritizeIfSomeOneIsAtShortDistance = ImGui.Checkbox("Prioritize short distance##CUSTOM_AIMBOT", bPrioritizeIfSomeOneIsAtShortDistance)
       colorAimTarget.Value = ImGui.ColorEdit4("AimOrigin##CUSTOM_ESP", colorAimTarget.Value, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaBar)
       ImGui.EndGroup()

       ImGui.SameLine()
       ImGui.BeginGroup()
       ImGui.PushItemWidth(120)
       iAimingMethod = ImGui.Combo("Aiming method##CUSTOM_AIMBOT", iAimingMethod, "Field of View\0Distance\0\0")
       iAimTeam = ImGui.Combo("Aim team##CUSTOM_AIMBOT", iAimTeam, "Enemies\0Teammates\0All\0\0")
       colorNonTarget.Value = ImGui.ColorEdit4("NonAimOrigin##CUSTOM_ESP", colorNonTarget.Value, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaBar)
       ImGui.PopItemWidth()
       ImGui.EndGroup()

       ImGui.NewLine()
       ImGui.TreePop()
   end
end

-- Rendering at the screen...
local function OnRenderBackground()
   if bRenderOrigin then
       for index = 1, 32 do
           if index ~= LocalPlayer.GetIndex() then
               if EntityManager.IsAlive(index) then
                   local vOrigin = EntityManager.GetOrigin(index)
                   local vOrigin2D = Vector2D(0, 0)
                   if WorldToScreen(vOrigin, vOrigin2D) then
                       local originColor = ImColor(0, 0, 0, 0)
                       if index == iTargetAimbot then
                           originColor = colorAimTarget
                       else
                           originColor = colorNonTarget
                       end
                       ImGui.Render.AddRectFilled(ImVec2(vOrigin2D.x - 2, vOrigin2D.y - 2), ImVec2(vOrigin2D.x + 2, vOrigin2D.y + 2), originColor:ToImU32(), 0, ImDrawCornerFlags_All)
                   end
               end
           end
       end
   end
end

-- At update function, use only logical functions here...
local function OnUpdate()
   iTargetAimbot = -1
   if bCustomAimbot then
       if LocalPlayer.IsAlive() then
           local flBestFOV = 360
           local flBestDistance = 8192
           local vForward = LocalPlayer.GetForwardVector()
           local vEye = LocalPlayer.GetEyePosition()

           if bPrioritizeIfSomeOneIsAtShortDistance then
               for index = 1, 32 do
                   if index ~= LocalPlayer.GetIndex() then
                       if EntityManager.IsAlive(index) then
                           if VerifyTeam(index) then
                               local flPlayerDistance = EntityManager.GetActualDistance(index)
                               -- 220 Units equals 10 Units from EntityManager.GetDistance(index)
                               if (flPlayerDistance <= 220) and (flPlayerDistance < flBestDistance) then
                                   flBestDistance = flPlayerDistance
                                   iTargetAimbot = index
                               end
                           end
                       end
                   end
               end
           end

           if iTargetAimbot == -1 then
               for index = 1, 32 do
                   if index ~= LocalPlayer.GetIndex() then
                       if EntityManager.IsAlive(index) then
                           if VerifyTeam(index) then
                               if iAimingMethod == 0 then
                                   local vPlayerOrigin = EntityManager.GetOrigin(index)
                                   local vDifference = vPlayerOrigin - vEye
                                   local flPlayerFOV = AngleBetween(vForward, vDifference)
                                   if flPlayerFOV < flBestFOV then
                                       flBestFOV = flPlayerFOV
                                       iTargetAimbot = index
                                   end
                               elseif iAimingMethod == 1 then
                                   local flPlayerDistance = EntityManager.GetActualDistance(index)
                                   if flPlayerDistance < flBestDistance then
                                       flBestDistance = flPlayerDistance
                                       iTargetAimbot = index
                                   end
                               end
                           end
                       end
                   end
               end
           end

           if iTargetAimbot ~= -1 then
               local vAimAngles = Vector(0, 0, 0)
               local vAimTargetOrigin = EntityManager.GetOrigin(iTargetAimbot)

               VectorAngles(vAimTargetOrigin - vEye, vAimAngles)

               if (LocalPlayer.GetButtons() & IN_ATTACK) == IN_ATTACK then
                   LocalPlayer.SetViewAngles(vAimAngles)
               end
           end
       end
   end
end

local function OnLoadSettings(szFile)
   bCustomAimbot = Utils.LoadBooleanInSection(szFile, "CustomAimbot", "Enable")
   bRenderOrigin = Utils.LoadBooleanInSection(szFile, "CustomAimbot", "Origin")
   bPrioritizeIfSomeOneIsAtShortDistance = Utils.LoadBooleanInSection(szFile, "CustomAimbot", "PrioritizeShortDistance")
   iAimingMethod = Utils.LoadIntegerInSection(szFile, "CustomAimbot", "Method")
   iAimTeam = Utils.LoadIntegerInSection(szFile, "CustomAimbot", "Team")
   colorNonTarget = Utils.LoadColorInSection(szFile, "CustomAimbot", "ColorNonTarget")
   colorAimTarget = Utils.LoadColorInSection(szFile, "CustomAimbot", "ColorTarget")
end

local function OnSaveSettings(szFile)
   Utils.SaveBooleanInSection(szFile, "CustomAimbot", "Enable", bCustomAimbot)
   Utils.SaveBooleanInSection(szFile, "CustomAimbot", "Origin", bRenderOrigin)
   Utils.SaveBooleanInSection(szFile, "CustomAimbot", "PrioritizeShortDistance", bPrioritizeIfSomeOneIsAtShortDistance)
   Utils.SaveIntegerInSection(szFile, "CustomAimbot", "Method", iAimingMethod)
   Utils.SaveIntegerInSection(szFile, "CustomAimbot", "Team", iAimTeam)
   Utils.SaveColorInSection(szFile, "CustomAimbot", "ColorNonTarget", colorNonTarget)
   Utils.SaveColorInSection(szFile, "CustomAimbot", "ColorTarget", colorAimTarget)
end

Hooks.RegisterCallback(CH5_CALLBACK_AT_RENDERING_MENU, OnRenderMenu)
Hooks.RegisterCallback(CH5_CALLBACK_AT_RENDERING_BACKGROUND, OnRenderBackground)
Hooks.RegisterCallback(CH5_CALLBACK_AT_UPDATE, OnUpdate)
Hooks.RegisterCallback(CH5_CALLBACK_AT_LOAD_SETTINGS, OnLoadSettings)
Hooks.RegisterCallback(CH5_CALLBACK_AT_SAVE_SETTINGS, OnSaveSettings)


B#

Me podrían ayudar urge gracias todo debe estar en unos código

Se te puede ayudar, pero no hacer la tarea (de esa manera nunca se aprende), mostrá hasta donde llegaste y de ahí en adelante se te puede ayudar...


B#

Buenas gente del foro, les quería aportar un mini juego laberinto fps que porté a Linux utilizando la librería ncurses además agregando algunos colores:




El código para Linux puede verse acá:
https://github.com/Agustin-dos-Santos/CommandLineFPS

Pero si lo quieren el código original para Windows (Visual Studio) les dejo el repositorio original y el video de como fue hecho originalmente:
https://www.youtube.com/watch?v=xW8skO7MFYw
https://github.com/OneLoneCoder/CommandLineFPS


B#

Por ejemplo: "2 de oro", "1 de espada". Necesito vincular el nombre con la imagen de la carta.

Si ya tenés el nombre en un vector podés utilizar cada elemento del vector de nombres y añadirle la extensión cuando lo necesites.

Código (java) [Seleccionar] Expandir

for(int i=0;i<vectorNombres.length;i++) {
    JButton btn = new JButton("");
    btn.setIcon(new ImageIcon(Class.class.getResource("recursos/cartas" + vectorNombres[i] + ".png")));
    ventanaPrincipal.add(btn);
}


B#