In MQL4, whether you’re developing an indicator or an expert advisor (EA), the core logic defines how your program interacts with market data, makes trading decisions, and manages positions. Here’s an outline of how you might structure the logic for both types of programs:

Indicator Logic:

1. Initialization (OnInit()):

• In the OnInit() function, set up your indicator’s parameters, styles, and other initial settings.

int OnInit() {
    // Indicator parameters and settings
    IndicatorShortName("Custom Indicator");
    SetIndexBuffer(0, customBuffer);
    SetIndexStyle(0, DRAW_LINE);
    // ...
    return(INIT_SUCCEEDED);
}

2. Calculating Indicator Values (OnCalculate()):

• This function is where you calculate and update your indicator’s values based on market data. You specify the logic for your custom indicator’s calculations here.

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]) {
    // Calculate indicator values
    for (int i = prev_calculated; i < rates_total; i++) {
        // Update customBuffer with calculated values
        customBuffer[i] = CalculateCustomValue(open[i], close[i], high[i], low[i]);
    }
    return(rates_total);
}

EA (Expert Advisor) Logic:

1. Initialization (OnInit()):

• In the OnInit() function for an EA, set initial parameters, load settings, and perform any necessary setup before trading begins.

int OnInit() {
    // Load settings and initialize variables
    // ...
    return(INIT_SUCCEEDED);
}

2. Main Trading Logic (OnTick()):

• The OnTick() function is the core of an EA, where you define the rules for entering and exiting trades based on your strategy.

void OnTick() {
    // Check conditions and make trading decisions
    if (/* Condition for trade entry */) {
        // OpenTrade() function or code to open a trade
    } else if (/* Condition for trade exit */) {
        // CloseTrade() function or code to close a trade
    }
}

3. Trade Execution Functions:

• These functions handle trade execution, modifying trades, or closing positions based on the conditions defined in OnTick().

void OpenTrade() {
    // Code to open a trade
}

void CloseTrade() {
    // Code to close a trade
}

Tips for Indicator and EA Logic:

• Define Entry and Exit Conditions: Clearly define the conditions for opening and closing trades based on your trading strategy.
• Risk Management: Incorporate risk management techniques such as stop-loss and take-profit levels in your trading logic.
• Testing and Optimization: Thoroughly test your indicator or EA using historical data and optimize parameters to ensure its performance meets your expectations.
• Error Handling: Implement error handling mechanisms to manage unexpected scenarios or errors during execution.

Whether building an indicator or an EA, the logic defines the behavior of your program within the MetaTrader platform. By structuring your logic logically and efficiently, you can create robust and reliable tools for trading automation or analysis in MQL4.