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:

#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#

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:

#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:

#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#

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#

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)




B#

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...

--[[
    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#

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#

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.

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#