Introduction
Sngine is a robust platform for building social networks. One of its most significant strengths is its modular and well-organized codebase, which makes it relatively easy to customize. However, if not done correctly, adding custom functions can lead to broken features or system instability. This guide provides a detailed, step-by-step approach to extending Sngine's functionality without jeopardizing its integrity. By following these guidelines, you'll learn how to add custom functions in a maintainable and scalable way.

Understanding Sngine's Core Codebase

Before diving into customizations, it's crucial to understand how Sngine's architecture is structured. Here’s a breakdown of its key components:

1. Core Folders

• Includes: Contains core libraries, classes, and helper functions.
• Templates: Houses the Smarty template files that manage the front-end.
• Content: Static resources like CSS, JavaScript, and images.

2. Core Files

• includes/class-user.php: Handles user-related functionalities.
• includes/class-db.php: Manages database interactions.
• index.php: The entry point for the application.

3. Modular Design

Sngine uses a modular approach, meaning you can add functionalities without modifying core files, as long as you use hooks and plugins strategically.

Step 1: Plan Your Custom Functionality

Before making any changes, determine:

• What problem your custom function solves.
• How it integrates with existing Sngine functionalities.
• Whether it will require database changes or front-end adjustments.

Example: Adding a "Last Seen" Feature

Suppose you want to display the last time a user was active. This involves:

• Adding a database field for tracking last activity.
• Updating the field whenever the user performs an action.
• Displaying the information on their profile.

Step 2: Create a Backup

Never skip this step. Make sure to:

1. Backup your Sngine files and database.
2. Use version control tools like Git to track changes.

Step 3: Add Database Changes (if Required)

Custom functionalities often require database modifications. For our "Last Seen" example:

1. Modify the Database:
   sql

   Copy code

   ALTER TABLE users ADD COLUMN last_seen DATETIME DEFAULT NULL;
2. Verify the Change: Run the query and ensure the last_seen field is added to the users table.

Step 4: Extend Core Classes

Avoid editing core files directly. Instead:

• Use class-user.php to extend the get_user_data() method.
• Save new logic in separate files.

Example Code:

Step 5: Add Custom Functions

Store your custom functions in a separate file to avoid conflicts during Sngine updates.

Create a New File:

1. Go to the includes folder.
2. Create a new file, e.g., class-custom-functions.php.

Example Function:

Step 6: Hook into Existing Features

Use existing Sngine hooks or Smarty templates to integrate your function.

Updating index.php:

Add this to update the last_seen field whenever the user performs an action:

Step 7: Modify Front-End Templates

To display the new feature, you need to modify the relevant Smarty templates.

Example:

1. Open the profile.tpl file in the templates folder.
2. Add the following code:
   smarty

   Copy code

   <div class="user-last-seen"> Last Seen: {$user_last_seen|default:"Not available"} </div>
3. Pass the variable from PHP:
   php

   Copy code

   $smarty->assign('user_last_seen', get_last_seen($user->_data['user_id']));

Step 8: Test Thoroughly

Testing is vital to ensure your custom function works seamlessly with the existing codebase.

Checklist:

• Verify database changes.
• Test the function for different user scenarios.
• Check for conflicts with existing features.
• Ensure the changes persist after a Sngine update.

Step 9: Document Your Changes

Proper documentation ensures future updates or debugging sessions go smoothly.

Include:

• Purpose of the function.
• Modified files.
• Database queries executed.

Conclusion

Adding custom functions in Sngine can significantly enhance your platform’s capabilities, but it must be done carefully to maintain codebase integrity. Always use hooks, modular files, and proper documentation to ensure your customizations are maintainable and upgrade-friendly.