Edit F-Curves in Cinema 4D

2024-01-26 10:37 UTC gpt-4 Open in ChatGPT ↗

In Cinema 4D, subdividing an animation’s F-Curve, which is essentially the curve representing the interpolation of keyframes in an animation, can be done for smoother transitions or more refined control over the animation. However, the process isn’t typically referred to as “subdividing” in the context of F-Curves. Instead, you might be looking to refine or edit the curve for better control over the animation.

Here’s how you can edit or refine an F-Curve in Cinema 4D:

Accessing the F-Curve Editor: Open the Timeline by going to Window -> Timeline (Dope Sheet). Switch to the F-Curve mode by clicking the F-Curve button.
Selecting Keyframes: In the F-Curve editor, you can select the keyframes of the animation you want to edit. Click on a keyframe to select it.
Editing Keyframes: Once a keyframe is selected, you can move it to change the timing or the value of the keyframe. This will effectively change the shape of the F-Curve.
Adding Keyframes: If you want more control points on your F-Curve, you can add more keyframes. This can be done by right-clicking on the F-Curve and choosing ‘Add Keyframe’ at the desired point, or by manually setting a keyframe in the main viewport.
Adjusting the Tangents: To smooth out the animation or to create more abrupt changes, you can adjust the tangents of the keyframes. This is done by dragging the handles that appear when a keyframe is selected in the F-Curve editor.
Using Interpolation Types: Cinema 4D allows you to change the interpolation type (like linear, step, ease in/out) for keyframes, which can drastically change the animation’s feel.
Auto Tangents: For automatic smoothing, you can use the ‘Auto Tangents’ feature which adjusts the tangents of the selected keyframes automatically for a smoother transition.

Remember, the key to effective animation in Cinema 4D is often in fine-tuning the F-Curves to get the exact motion you desire. If you’re looking to create a more complex or nuanced animation, spending time in the F-Curve editor is a must.

Adding a keyframe every nth frame in Cinema 4D can be a useful technique for creating consistent or rhythmic animations. This process can be automated with the use of Cinema 4D’s Timeline and some basic scripting, or it can be done manually. Here’s a guide on how to achieve this:

Manual Method:

Open the Timeline: Go to Window → Timeline (Dope Sheet) to open the timeline window.
Select Your Object: In the Objects Manager, select the object or parameter that you want to keyframe.
Move to the Starting Frame: In the timeline or the main project window, move the playhead to the frame where you want your first keyframe.
Create the First Keyframe: Set the desired value for your object at this frame and create a keyframe. You can typically do this by right-clicking on the parameter and selecting “Add Keyframe” or by using the keyframe button in the interface.
Advance Frames: Move the playhead forward by your desired ‘n’ number of frames.
Repeat Keyframing: Set the desired value for your object at this new frame position and create another keyframe.
Continue the Process: Keep moving the playhead forward by ‘n’ frames and adding keyframes until you cover the desired duration of your animation.

Scripting Method:

If you’re comfortable with a bit of scripting, you can automate this process. Cinema 4D’s scripting language is Python, and you can use it to add keyframes programmatically.

Open the Script Manager: Go to Script → Script Manager.
Create a New Script: Write a Python script that loops through the timeline, advancing ‘n’ frames at a time, and sets a keyframe at each step.

Here is a basic example of what that script might look like:

import c4d

# Function to add a keyframe
def add_keyframe(doc, obj, frame):
    doc.AddUndo(c4d.UNDOTYPE_NEW, obj)
    c4d.SetKeyframe(obj)

# Main function
def main():
    start_frame = 0   # Start frame
    end_frame = 100   # End frame
    step = 10         # Step in frames

    obj = doc.GetActiveObject()  # Get the selected object
    if not obj:
        return

    for frame in range(start_frame, end_frame + 1, step):
        doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))  # Move to the frame
        add_keyframe(doc, obj, frame)  # Add a keyframe

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

This script will add a keyframe to the currently selected object every 10 frames from frame 0 to 100. Adjust start_frame, end_frame, and step as needed.

After you run the script, make sure to manually adjust values at each keyframe as needed, since this script will simply set a keyframe without changing any parameter values.

Remember, scripting can be a powerful tool in Cinema 4D for automating repetitive tasks and can save a significant amount of time in complex projects.

The error you’re encountering in your Cinema 4D script indicates that the c4d module does not have an attribute named SetKeyframe. This is likely because SetKeyframe is not a direct method of the c4d module. In Cinema 4D’s Python API, setting a keyframe involves a different approach.

To set a keyframe in Cinema 4D using Python, you generally need to:

Create a c4d.CKey object (a keyframe).
Set the necessary attributes (like time, value) on this keyframe.
Insert the keyframe into the appropriate c4d.CTrack (the track that holds the keyframes for a specific parameter).

Here’s a corrected approach to the add_keyframe function:

import c4d

def add_keyframe(doc, obj, frame, parameter_id):
    # Get the animation track for the specified parameter
    track = obj.FindCTrack(parameter_id)
    if not track:
        track = c4d.CTrack(obj, parameter_id)
        obj.InsertTrackSorted(track)

    # Create a key and set its time
    key = c4d.CKey()
    keyframe_time = c4d.BaseTime(frame, doc.GetFps())
    key.SetTime(track, keyframe_time)

    # Insert the key into the track
    seq = track.GetCurve()
    seq.InsertKey(key)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0   # Start frame
    end_frame = 100   # End frame
    step = 10         # Step in frames
    parameter_id = c4d.ID_BASEOBJECT_POSITION_X  # Example parameter

    obj = doc.GetActiveObject()  # Get the selected object
    if not obj:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, parameter_id)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this corrected version:

The add_keyframe function now also takes a parameter_id, which specifies the parameter for which you’re adding the keyframe (e.g., position, rotation).
The function checks if there’s already a track for the given parameter. If not, it creates one.
The keyframe is created, its time is set, and then it’s inserted into the sequence of the track.

This approach should resolve the AttributeError you were encountering. Remember to adjust the parameter_id to the specific parameter you want to animate. The example uses c4d.ID_BASEOBJECT_POSITION_X as a placeholder.

The error you’re experiencing is due to an incorrect attribute reference: c4d.ID_BASEOBJECT_POSITION_X. This specific attribute does not exist in the Cinema 4D Python API. In Cinema 4D, the position, rotation, and scale of an object are typically accessed through their respective c4d.DescID values, which consist of a sequence of c4d.DescLevel elements.

To correctly reference the position, rotation, or scale in a keyframing context, you need to construct the appropriate c4d.DescID. Here is how you can do it for the X position of an object:

import c4d

def add_keyframe(doc, obj, frame, desc_id):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key = track.GetCurve().AddKey(c4d.BaseTime(frame, doc.GetFps()))
    if key is None:
        return

    # Set the value for the keyframe (optional, depending on your needs)
    # key['key'].SetValue(track.GetCurve(), your_value)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0   # Start frame
    end_frame = 100   # End frame
    step = 10         # Step in frames

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this script:

The DescID for the X position of the object is created using c4d.DescID and c4d.DescLevel. Here, c4d.ID_BASEOBJECT_POSITION is a general ID for position, and c4d.VECTOR_X specifies the X component of the position.
The add_keyframe function is modified to accept this DescID.
The script will add a keyframe at the specified frames for the X position of the selected object.

This approach should resolve the AttributeError and allow you to correctly add keyframes to the desired parameter. Remember, you can adjust the DescID construction for different parameters like Y or Z position, rotation, or scale as needed.

Setting the value of a keyframe in Cinema 4D using Python involves a few additional steps within the keyframe creation process. When you create a keyframe, you’re not only specifying the time at which it occurs but also the value of the parameter at that keyframe.

Let’s modify the previous script to include setting the keyframe value. In this example, I’ll demonstrate how to set a value for the X position of an object:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()
    key = curve.AddKey(key_time)[1]  # AddKey returns a tuple

    if key is None:
        return

    # Set the value for the keyframe
    key.SetValue(curve, value)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0   # Start frame
    end_frame = 100   # End frame
    step = 10         # Step in frames
    x_value = 100     # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this script:

The add_keyframe function now also takes a value parameter, which is the value you want to set for the keyframe.
The SetValue method of the CKey object is used to set the value of the keyframe. This value corresponds to the parameter being animated (in this case, the X position of the object).
I’ve included an x_value variable in the main function to demonstrate setting a specific value. You can adjust this value as needed for your animation.

This script will add a keyframe every step frames from start_frame to end_frame, setting the X position of the selected object to x_value at each keyframe. You can adapt this script for other parameters by changing the DescID and the value.

The KeyError: 1 in your script indicates an issue with accessing the second item of a tuple or list, which in this context is likely related to the line key = curve.AddKey(key_time)[1]. This error suggests that the AddKey method is not returning a tuple with two elements as expected.

In some versions of Cinema 4D, the AddKey method may behave differently. Let’s revise the script to handle this correctly:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()

    # AddKey and handle the result appropriately
    result = curve.AddKey(key_time)
    if isinstance(result, tuple):
        key = result[1]  # For versions that return a tuple
    else:
        key = result  # For versions where AddKey returns the key directly

    if key is None:
        return

    # Set the value for the keyframe
    key.SetValue(curve, value)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0   # Start frame
    end_frame = 100   # End frame
    step = 10         # Step in frames
    x_value = 100     # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this revised script:

The return value of curve.AddKey(key_time) is now checked to see if it’s a tuple. If it is, the second item of the tuple is used (as per the original assumption). If not, it’s assumed that AddKey returned the key directly.
This change should ensure compatibility with different versions of Cinema 4D where the behavior of AddKey might vary.

This approach should resolve the KeyError and allow the script to run without issues in your version of Cinema 4D.

The error you’re encountering, 'dict' object has no attribute 'SetValue', suggests that there’s a mistake in the way the script is attempting to set the value of the keyframe. In Cinema 4D’s Python API, setting the value of a keyframe is a bit more involved than directly calling SetValue on the key object.

To correct this, you’ll need to modify the script to properly access and set the value of the keyframe. Here’s how you can do it:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()

    # AddKey and handle the result appropriately
    result = curve.AddKey(key_time)
    if isinstance(result, tuple):
        key = result[1]  # For versions that return a tuple
    else:
        key = result  # For versions where AddKey returns the key directly

    if key is None:
        return

    # Access the key's value and set it
    key_data = key.GetGeData()
    key_data.SetFloat(value)
    key.SetGeData(curve, key_data)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0   # Start frame
    end_frame = 2500  # End frame
    step = 159        # Step in frames
    x_value = 800     # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this revised script:

The key_data variable holds the GeData of the keyframe.
The value of the keyframe is set using key_data.SetFloat(value). This method is used because the X position is a float value. If you’re dealing with other data types, you might need to use a different Set method (like SetVector for vectors).
The modified GeData is then applied back to the keyframe using key.SetGeData(curve, key_data).

This approach should resolve the AttributeError and correctly set the value of each keyframe according to your specified values.

The error 'dict' object has no attribute 'GetGeData' suggests that the key object being used is not the correct type for accessing keyframe data as expected. In Cinema 4D’s Python API, handling keyframe data typically involves working with the c4d.CKey class. Let’s correct the script to properly handle the keyframe creation and value setting:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()

    # Add a key at the specified time
    key_index = curve.AddKey(key_time)[1].GetNidx()
    key = curve.GetKey(key_index)

    if key is None:
        return

    # Set the value for the keyframe
    value_data = c4d.Vector(value, 0, 0)  # Assuming we're modifying the X component
    key.SetValue(curve, value_data)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this script, I made the following changes:

After adding a key using curve.AddKey(key_time), I used the returned key index to access the keyframe with curve.GetKey(key_index). This ensures we’re working with a c4d.CKey object.
The value for the keyframe is set using a c4d.Vector, as position data in Cinema 4D is typically represented as a vector. Since we’re modifying the X component, value is used for the X position, and 0 for Y and Z.

This script should now correctly create keyframes at the specified frames and set the X position of the selected object to the provided x_value. If you’re modifying a different parameter (like rotation or scale), the approach to setting the value would be similar, but you might need to adjust the c4d.Vector or use a different data type as appropriate for that parameter.

The KeyError: 1 error in your script occurs when trying to access the second element of the tuple returned by curve.AddKey(key_time). It seems that the method doesn’t return a tuple in your version of Cinema 4D, which is causing the script to fail. Let’s adjust the script to handle this correctly:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()

    # Add a key at the specified time
    key = curve.AddKey(key_time).GetKey()  # Get the key directly

    if key is None:
        return

    # Set the value for the keyframe
    value_data = c4d.Vector(value, 0, 0)  # Assuming we're modifying the X component
    key.SetValue(curve, value_data)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this revised script:

The AddKey method is now expected to return a c4d.CKey object directly. The .GetKey() method is called on the result of AddKey to obtain the key object.
The rest of the script remains the same, with the key’s value being set to a c4d.Vector representing the new position value.

This version of the script should be compatible with your version of Cinema 4D and should successfully create and set keyframes at the specified intervals.

The error 'dict' object has no attribute 'GetKey' indicates that the AddKey method is returning a dictionary, and not a key object or a tuple as previously assumed. This seems to be specific to your version of Cinema 4D. We need to adapt the script to this behavior.

In Cinema 4D’s Python API, the returned dictionary from AddKey usually contains information about the operation, including the index of the newly added key. We can use this index to retrieve the key object from the curve. Here’s how you can modify the script:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create the key and set its time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    curve = track.GetCurve()

    # Add a key at the specified time
    result = curve.AddKey(key_time)
    if not result["ok"]:
        return

    # Retrieve the key using its index
    key_index = result["keyIndex"]
    key = curve.GetKey(key_index)

    if key is None:
        return

    # Set the value for the keyframe
    value_data = c4d.Vector(value, 0, 0)  # Assuming we're modifying the X component
    key.SetValue(curve, value_data)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this revised script:

After calling AddKey, we now check the returned dictionary for the "ok" key to ensure the key was added successfully.
We then use the "keyIndex" key from the dictionary to get the index of the new key and retrieve the key object from the curve using GetKey(key_index).
The rest of the process remains the same, setting the value for the keyframe and updating the scene.

This approach should be compatible with the behavior of AddKey in your version of Cinema 4D and should resolve the AttributeError.

The KeyError: 'ok' suggests that the AddKey method isn’t returning a dictionary with the expected keys (‘ok’ and ‘keyIndex’). This behavior seems to be different from standard documentation and might be specific to your version of Cinema 4D or the context in which the script is being executed.

Given this unusual behavior, let’s try a different approach to add and set the keyframes. We’ll use a more direct method of creating a keyframe, setting its properties, and then inserting it into the curve. Here’s the updated script:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Create a new key
    key = c4d.CKey()
    if key is None:
        return

    # Set the key time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    key.SetTime(track.GetCurve(), key_time)

    # Set the value for the keyframe
    value_data = c4d.Vector(value, 0, 0)  # Assuming we're modifying the X component
    key.SetValue(track.GetCurve(), value_data)

    # Insert the key into the curve
    track.GetCurve().InsertKey(key)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this script, the changes are:

We create a c4d.CKey object directly.
Set the time and value of the key.
Then insert this key into the curve of the track.

This approach avoids relying on the return value of AddKey and directly manages the key creation and insertion process. This should work in standard Cinema 4D environments and hopefully aligns better with the version and context you are working in.

The TypeError: must be real number, not c4d.Vector suggests that the function SetValue expects a real number (float or integer) instead of a c4d.Vector. This is likely because we are trying to set the value of a single component (like X position), which should be a single real number, not a vector.

Let’s adjust the script to set the value correctly:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Access the curve on the track
    curve = track.GetCurve()

    # Create a key at the specified time
    key = curve.AddKey(c4d.BaseTime(frame, doc.GetFps()))[1].GetKey()
    if key is None:
        return

    # Set the value for the keyframe
    key.SetValue(curve, value)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this revised script:

When setting the value for the keyframe (key.SetValue(curve, value)), we directly use the value variable, which is expected to be a real number. This should be the value for the specific property (like the X position) you’re animating.
The previous use of c4d.Vector is removed, as it is unnecessary for setting a single-component value.

This script should correctly set the X position keyframe values for your selected object at the specified intervals. Ensure x_value is set to the desired numerical value for each keyframe.

The recurring KeyError: 1 indicates that the AddKey function is not returning a tuple with an indexable second element, contrary to what we previously assumed. The precise return value of this function seems to be different in your version of Cinema 4D.

In light of this, let’s revert to using the InsertKey method, which is another way to create and insert a keyframe in Cinema 4D. This method might be more compatible with your version of Cinema 4D:

import c4d

def add_keyframe(doc, obj, frame, desc_id, value):
    # Create or retrieve the track for the specified parameter
    track = obj.FindCTrack(desc_id)
    if track is None:
        track = c4d.CTrack(obj, desc_id)
        obj.InsertTrackSorted(track)

    # Access the animation curve on the track
    curve = track.GetCurve()

    # Create a new key
    key = c4d.CKey()
    if key is None:
        return

    # Set the key time
    key_time = c4d.BaseTime(frame, doc.GetFps())
    key.SetTime(curve, key_time)

    # Set the value for the keyframe
    key.SetValue(curve, value)

    # Insert the key into the curve
    curve.InsertKey(key)

    # Notify Cinema 4D of the change
    c4d.EventAdd()

# Example usage
def main():
    start_frame = 0    # Start frame
    end_frame = 2500   # End frame
    step = 159         # Step in frames
    x_value = 800      # Example value for X position

    # Construct the DescID for the X position
    x_pos_id = c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
                          c4d.DescLevel(c4d.VECTOR_X))

    obj = doc.GetActiveObject()  # Get the selected object
    if obj is None:
        return

    for frame in range(start_frame, end_frame + 1, step):
        add_keyframe(doc, obj, frame, x_pos_id, x_value)

    c4d.EventAdd()

# Execute main function
if __name__=='__main__':
    main()

In this script:

We create a c4d.CKey object directly, set its time, and value.
Then we insert this key into the animation curve using curve.InsertKey(key). This method is generally more straightforward and should work regardless of the version.

This approach should correctly handle keyframe creation and avoid the issues encountered with the AddKey method. Please ensure that the x_value is set to the desired numerical value for the X position you wish to animate.