stock strreplace(string[], find, replace)
{
    for(new i=0; string[i]; i++)
    {
        if(string[i] == find)
        {
            string[i] = replace;
        }
    }
}

strreplace(string[], find[], replace[])
{
    new stringFound = strfind(string, find);
    if(stringFound > -1)
    {
        strdel(string, stringFound, strlen(find));
        strins(string, replace, stringFound);
    }
    return string;
}

stock strreplace(string[], const search[], const replacement[], bool:ignorecase = false, pos = 0, limit = -1, maxlength = sizeof(string)){
    // No need to do anything if the limit is 0.
    if (limit == 0) return 0;
    new
             sublen = strlen(search),
             replen = strlen(replacement),
        bool:packed = ispacked(string),
             maxlen = maxlength,
             len = strlen(string),
             count = 0
    ;
    // "maxlen" holds the max string length (not to be confused with "maxlength", which holds the max. array size).
    // Since packed strings hold 4 characters per array slot, we multiply "maxlen" by 4.
    if (packed) maxlen *= 4;

    // If the length of the substring is 0, we have nothing to look for..
    if (!sublen) return 0;

    // In this line we both assign the return value from "strfind" to "pos" then check if it's -1.
    while (-1 != (pos = strfind(string, search, ignorecase, pos))) {
        // Delete the string we found
        strdel(string, pos, pos + sublen);

        len -= sublen;

        // If there's anything to put as replacement, insert it. Make sure there's enough room first.
        if (replen && len + replen < maxlen) {
            strins(string, replacement, pos, maxlength);

            pos += replen;
            len += replen;
        }

        // Is there a limit of number of replacements, if so, did we break it?
        if (limit != -1 && ++count >= limit)
            break;
    }
    return count;
}

stock str_replace(const needle[], const replace[], haystack[], needlen = sizeof(needle), haylen = sizeof(haystack))
{
    new 
        count,
        index = strfind(haystack, needle, true);
    
    while(index != -1)
    {
        strdel(haystack, index, index + (needlen - 1));
        strins(haystack, replace, index, haylen);
        
        index = strfind(haystack, needle, true);
        count++;
    }
    return count;
}

new string[] = "1 bla bla bla";

str_replace("1", "first aid kit", string);

print(string); // first aid kit bla bla bla