ElementSystem.m

function varargout = ElementSystem(action, varargin)
   
    switch lower(action)
        case 'hasadvantage'
            varargout{1} = hasAdvantage(varargin{1}, varargin{2});
            
        case 'getname'
            varargout{1} = getName(varargin{1});
            
        case 'getcolor'
            varargout{1} = getColor(varargin{1});
            
        case 'getspriteid'
            varargout{1} = getSpriteId(varargin{1});
            
        case 'getstrengths'
            varargout{1} = getStrengths(varargin{1});
            
        case 'getweaknesses'
            varargout{1} = getWeaknesses(varargin{1});
            
        case 'getdamagemultiplier'
            varargout{1} = getDamageMultiplier(varargin{1}, varargin{2});
            
        case 'calculateattack'
            [varargout{1}, varargout{2}] = calculateAttack(varargin{1}, varargin{2}, varargin{3});
            
        case 'getrandom'
            varargout{1} = randi([1, 4]);  % Fire, Earth, Lightning, Wind
            
        case 'getrandomwithneutral'
            varargout{1} = randi([1, 5]);  % Include Neutral
            
        case 'displaymatchup'
            displayMatchup(varargin{1}, varargin{2});
            
        case 'getconstants'
            % Return all element constants as a struct
            c = struct();
            c.FIRE = 1;
            c.EARTH = 2;
            c.LIGHTNING = 3;
            c.WIND = 4;
            c.NEUTRAL = 5;
            c.NAMES = {'FIRE', 'EARTH', 'LIGHTNING', 'WIND', 'NEUTRAL'};
            c.COLORS = {'red', 'brown', 'yellow', 'cyan', 'white'};
            varargout{1} = c;
            
        otherwise
            error('ElementSystem: Unknown action "%s"', action);
    end
end



function advantage = hasAdvantage(attacker, defender)
    % HASADVANTAGE - Check if attacker element beats defender element
    %
    % Inputs:
    %   attacker - Element ID of attacker (1-5)
    %   defender - Element ID of defender (1-5)
    %
    % Output:
    %   advantage - true if attacker beats defender, false otherwise
    %
    % Rules:
    %   FIRE (1) beats everything except Neutral
    %   EARTH (2) beats LIGHTNING (3)
    %   LIGHTNING (3) beats WIND (4)
    %   WIND (4) beats EARTH (2)
    %   NEUTRAL (5) is impartial - no advantages
    
    % Neutral never has advantage and nothing has advantage over it
    if attacker == 5 || defender == 5
        advantage = false;
        return;
    end
    
    % Fire beats everything (except neutral, handled above)
    if attacker == 1
        advantage = true;
        return;
    end
    
    % Earth beats Lightning
    if attacker == 2 && defender == 3
        advantage = true;
        return;
    end
    
    % Lightning beats Wind
    if attacker == 3 && defender == 4
        advantage = true;
        return;
    end
    
    % Wind beats Earth
    if attacker == 4 && defender == 2
        advantage = true;
        return;
    end
    
    advantage = false;
end

function name = getName(elementId)
    % GETNAME - Get the name string for an element ID
    %
    % Input:
    %   elementId - Element ID (1-5)
    %
    % Output:
    %   name - String name of element ('FIRE', 'EARTH', etc.)
    
    names = {'FIRE', 'EARTH', 'LIGHTNING', 'WIND', 'NEUTRAL'};
    if elementId >= 1 && elementId <= 5
        name = names{elementId};
    else
        name = 'UNKNOWN';
    end
end

function color = getColor(elementId)
    % GETCOLOR - Get the display color for an element
    %
    % Input:
    %   elementId - Element ID (1-5)
    %
    % Output:
    %   color - Color string for use in plots/text ('red', 'brown', etc.)
    
    colors = {'red', 'brown', 'yellow', 'cyan', 'white'};
    if elementId >= 1 && elementId <= 5
        color = colors{elementId};
    else
        color = 'gray';
    end
end

function spriteId = getSpriteId(elementId)
    % GETSPRITEID - Get sprite sheet ID for element
    %
    % Input:
    %   elementId - Element ID (1-5)
    %
    % Output:
    %   spriteId - Sprite ID to use in game engine
    %
    % Note: Default mapping is 1:1 (element 1 = sprite 1)
    %       Modify spriteIds array to match your sprite sheet
    
    spriteIds = [1, 2, 3, 4, 5];  % Modify these to match your sprites!
    if elementId >= 1 && elementId <= 5
        spriteId = spriteIds(elementId);
    else
        spriteId = 5;  % Default to neutral
    end
end

function beats = getStrengths(elementId)
    % GETSTRENGTHS - Get array of elements this element beats
    %
    % Input:
    %   elementId - Element ID (1-5)
    %
    % Output:
    %   beats - Array of element IDs that this element is strong against
    
    switch elementId
        case 1  % FIRE beats everything except neutral
            beats = [2, 3, 4];
        case 2  % EARTH beats LIGHTNING
            beats = 3;
        case 3  % LIGHTNING beats WIND
            beats = 4;
        case 4  % WIND beats EARTH
            beats = 2;
        case 5  % NEUTRAL beats nothing
            beats = [];
        otherwise
            beats = [];
    end
end

function beatenBy = getWeaknesses(elementId)
    % GETWEAKNESSES - Get array of elements that beat this element
    %
    % Input:
    %   elementId - Element ID (1-5)
    %
    % Output:
    %   beatenBy - Array of element IDs that this element is weak against
    
    switch elementId
        case 1  % FIRE - nothing beats fire
            beatenBy = [];
        case 2  % EARTH - beaten by FIRE, WIND
            beatenBy = [1, 4];
        case 3  % LIGHTNING - beaten by FIRE, EARTH
            beatenBy = [1, 2];
        case 4  % WIND - beaten by FIRE, LIGHTNING
            beatenBy = [1, 3];
        case 5  % NEUTRAL - nothing beats it
            beatenBy = [];
        otherwise
            beatenBy = [];
    end
end

function multiplier = getDamageMultiplier(attackerElement, defenderElement)
    % GETDAMAGEMULTIPLIER - Get damage multiplier for element matchup
    %
    % Inputs:
    %   attackerElement - Element ID of attacker (1-5)
    %   defenderElement - Element ID of defender (1-5)
    %
    % Output:
    %   multiplier - Damage multiplier (1.5 advantage, 0.75 disadvantage, 1.0 neutral)
    %
    % Note: For Fire attacks, use calculateAttack() instead to get recoil
    
    if hasAdvantage(attackerElement, defenderElement)
        multiplier = 1.5;  % 50% bonus damage
    elseif hasAdvantage(defenderElement, attackerElement)
        multiplier = 0.75;  % 25% reduced damage
    else
        multiplier = 1.0;  % Neutral matchup
    end
end

function [damageDealt, recoilTaken] = calculateAttack(attackerElement, defenderElement, baseDamage)
    % CALCULATEATTACK - Calculate damage dealt and recoil taken
    %
    % Inputs:
    %   attackerElement - Element ID of attacker (1-5)
    %   defenderElement - Element ID of defender (1-5)
    %   baseDamage      - Base damage amount before multipliers
    %
    % Outputs:
    %   damageDealt - Final damage to deal to defender
    %   recoilTaken - Damage attacker takes (only Fire has recoil)
    %
    % Special: Fire does 2x damage but takes 10% recoil
    
    if attackerElement == 1 && defenderElement ~= 5  % Fire attacking non-neutral
        damageDealt = floor(baseDamage * 2.0);   % 2x damage
        recoilTaken = floor(damageDealt * 0.10); % 10% recoil
    else
        % Normal element calculations
        multiplier = getDamageMultiplier(attackerElement, defenderElement);
        damageDealt = floor(baseDamage * multiplier);
        recoilTaken = 0;
    end
end

function displayMatchup(attackerElement, defenderElement)
    % DISPLAYMATCHUP - Print element matchup info to console
    %
    % Inputs:
    %   attackerElement - Element ID of attacker (1-5)
    %   defenderElement - Element ID of defender (1-5)
    %
    % Prints formatted matchup information
    
    attackerName = getName(attackerElement);
    defenderName = getName(defenderElement);
    
    if attackerElement == 5 || defenderElement == 5
        fprintf('%s vs %s: NEUTRAL - No effect (1.0x damage)\n', attackerName, defenderName);
    elseif attackerElement == 1
        fprintf('%s vs %s: FIRE ATTACK! (2.0x damage, 10%% recoil)\n', attackerName, defenderName);
    elseif hasAdvantage(attackerElement, defenderElement)
        fprintf('%s has ADVANTAGE over %s! (1.5x damage)\n', attackerName, defenderName);
    elseif hasAdvantage(defenderElement, attackerElement)
        fprintf('%s has DISADVANTAGE against %s! (0.75x damage)\n', attackerName, defenderName);
    else
        fprintf('%s vs %s: Neutral matchup (1.0x damage)\n', attackerName, defenderName);
    end
end