# Special Types

## Constructors

### NewObject

#### NewObject(typeName: `string`) -> `GameType`

Create a new object of the type given by `typeName`. This type should be an internal game type.

```lua
obj = NewObject("gameObject")
puppet = NewObject("PlayerPuppet")
vec2 = NewObject("Vector2")
vec3 = NewObject("Vector3")
matrix = NewObject("Matrix")
world_transform = NewObject("WorldTransform")
```

{% hint style="info" %}
The geometric types discussed below can also be created with NewObject.
{% endhint %}

### ToVector3

#### ToVector3(values: `table<x: float, y: float, z: float>`) -> `Vector3`

Create a new `Vector3` from a table of `x`, `y`, and `z` floats.

```lua
position = ToVector3{x=-1788, y=-450, z=7.75}
```

| Property   | Description                        |
| ---------- | ---------------------------------- |
| `x: float` | The x-axis component of the vector |
| `y: float` | The y-axis component of the vector |
| `z: float` | The z-axis component of the vector |

{% hint style="info" %}
In Cyberpunk, the Z axis is the up axis.
{% endhint %}

### ToVector4

#### ToVector4(values: `table<x: float, y: float, z: float, w: float>`) -> `Vector4`

Create a new `Vector4` from a table of `x`, `y`, `z`, and `w` floats.

```lua
position = ToVector4{x=-1788, y=-450, z=7.75, w=1}
```

| Property   | Description                        |
| ---------- | ---------------------------------- |
| `x: float` | The x-axis component of the vector |
| `y: float` | The y-axis component of the vector |
| `z: float` | The z-axis component of the vector |
| `w: float` | The w-axis component of the vector |

{% hint style="warning" %}
You may notice that functions like `PlayerPuppet:GetWorldPosition` will return a `Vector4`, even though, intuitively, 3D coordinates only include x, y, and z values. These `Vector4` values are known as [homogenous coordinates](https://en.wikipedia.org/wiki/Homogeneous_coordinates) in graphical programming, useful in matrix transformations.

All you really need to know is that the 4th value, `w`, should always be 1 when you are dealing with 3D coordinates.
{% endhint %}

### ToEulerAngles

#### ToEulerAngles(angles: `table<roll: float, pitch: float, yaw: float>`) -> `EulerAngles`

Create a new `EulerAngles` from a table of `roll`, `pitch`, and `yaw`. Angle values are in degrees.

```lua
rotation = ToEulerAngles{roll=0, pitch=0, yaw=45}

player = Game.GetPlayer()
Game.GetTeleportationFacility():Teleport(player, player:GetWorldPosition(), rotation)
```

| Property       | Description                                                                                                                                         |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| `yaw: float`   | <p>The horizontal angle in degrees along the axis pointing up.</p><p>0 is north, 90 is west, 180 and -180 are south, and -90 is east.</p>           |
| `pitch: float` | <p>The vertical angle in degrees along the axis pointing to the right.</p><p>-90 is down, 0 is straight ahead, and 90 is up.</p>                    |
| `roll: float`  | <p>The roll angle in degrees along the axis pointing forward.</p><p>Positive values rotate anti-clockwise and negative values rotate clockwise.</p> |

### ToQuaternion

#### ToQuaternion(values: `table<i: float, j: float, k: float, r: float>`) -> `Quaternion`

Create a new `Quaternion` from a table of a vector part `i`, `j`, `k`, and a scalar (real) part `r`.

```lua
-- 45 degree rotation about the Z axis (yaw)
rotation = ToQuaternion{i=0, j=0, k=0.383, r=0.924}
```

| Property   | Description                              |
| ---------- | ---------------------------------------- |
| `i: float` | The x-axis component of the quaternion   |
| `j: float` | The y-axis component of the quaternion   |
| `k: float` | The z-axis component of the quaternion   |
| `r: float` | The scalar (real) part of the quaternion |

{% hint style="info" %}
Quaternions are also often expressed with `w, x, y, z` terms, which map to our terms as following:

`w == r`\
`x == i`\
`y == j`\
`z == k`
{% endhint %}

### ToCName

#### ToCName(hash: `table<hash_hi: uint32, hash_lo: uint32>`) -> `CName`

Create a new `CName` from a table of `hash_hi` and `hash_lo`.

```lua
cname = ToCName{hash_hi=0x01234567, hash_lo=0x89abcdef}
```

| Property          | Description                                     |
| ----------------- | ----------------------------------------------- |
| `hash_hi: uint32` | The higher 32 bits of the `CName`'s 64-bit hash |
| `hash_lo: uint32` | The lower 32 bits of the `CName`'s 64-bit hash  |
| `value: string`   | The text value of the `CName`                   |

### ToTweakDBID

#### ToTweakDBID(data: `table<hash: uint32, length: uint8>`) -> `TweakDBID`

Create a new `TweakDBID` from a table of `hash` and `length`.

```lua
id = ToTweakDB{hash=0x01234567, length=12}
```

| Property        | Description                     |
| --------------- | ------------------------------- |
| `hash: uint32`  | The CRC32 hash of the item name |
| `length: uint8` | The length of the item name     |

### ToItemID

#### ToItemID(data: `table<id: TweakDBID, rng_seed: uint32, unknown: uint16, maybe_type: uint8>`) -> `ItemID`

Create an `ItemID` from a table of `id`, `rng_seed`, an unknown field `unknown`, and an unknown field `maybe_type`.

```lua
dbid = ToTweakDB{hash=0x01234567, length=12}
itemid = ToItemID{id=dbid, rng_seed=0x01234567}
```

| Property            | Description                                                      |
| ------------------- | ---------------------------------------------------------------- |
| `id: TweakDBID`     | The TweakDBID referenced by this ItemID                          |
| `tdbid: TweakDBID`  | Alias for `id`                                                   |
| `rng_seed: uint32`  | The RNG (random number generation) seed used for loot generation |
| `unknown: uint16`   | Unknown field                                                    |
| `maybe_type: uint8` | Unknown field, possibly a type                                   |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://wiki.redmodding.org/cyber-engine-tweaks/cet-functions/special-types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
