# Raw Documentation

## Main methods:

### PhotonFramework

#### PhotonFramework:Start()

This method must be called before any interaction is done with the framework, as it prepares all aspects of it.

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local PhotonFramework = ReplicatedStorage:WaitForChild("PhotonFramework"):WaitForChild("PhotonFramework")
PhotonFramework:Start()
```

### PhotonFramework.Objects

The Objects subtable is used to interact with both built-in objects and custom-made objects.

#### PhotonFramework.Objects:NewClass(ClassName:string,Class:table)

This method is used to create a new class, which can then be interacted with via the `PhotonFramework.Objects:GetClass` method.

```lua
PhotonFramework.Objects:NewClass("Demo Class",require(path.to.class))
```

{% hint style="warning" %}
Notice: the table supplied must contain a `.new` method, as the classes can be used to construct objects.  The `.new` method should return some form of data (either a metatable or a value).
{% endhint %}

#### PhotonFramework.Objects:GetClass(ClassName:string)

This method can be used to get the stored class data for any class that has been added to the framework (internal, custom, etc).

```lua
local DemoClass = PhotonFramework.Objects:GetClass("Demo Class")
```

#### PhotonFramework.Objects:AssignClass(Object:instance,ClassName:string)

This method is used to bind and construct a class with the supplied object.

```lua
PhotonFramework.Objects:AssignClass(workspace.SomePart,"Demo Class")
```

{% hint style="info" %}
The class will have the `.new` method called, and with the supplied object passed as the only argument.
{% endhint %}

#### PhotonFramework.Objects:GetObjectClass(Object:instance)

This method will return the class bound to the object via the `PhotonFramework.Objects:AssignClass` method.

```lua
local DemoClass = PhotonFramework.Objects:GetObjectClass(workspace.SomePart)
```

### PhotonFramework.Services

The services subtable is used to interact with services within the framework, both custom and built-in.

#### PhotonFramework.Services:GetService(ServiceName:string)

This method can be used to get a service from the framework, either a built-in one or custom one.

```lua
local CalculationService = PhotonFramework.Services:GetService("CalculationService")
```

#### PhotonFramework.Services:CreateService(ServiceName:string,Service:table,BootState:bool)

This method can be used to create a custom service within the framework.

```lua
local ServiceTable = {}
function ServiceTable:Initialize()
    print("Service initialized")
end
function ServiceTable:ping()
    print("pong")
end

PhotonFramework.Services:CreateService("CustomService",ServiceTable,false)

-- In a different script
local CustomService = PhotonFramework.Services:GetService("CustomService")
CustomService:ping() -- prints "pong"
```

{% hint style="danger" %}
The `BootState` property should never be set to true, as it is internally used during startup to index all services, then initialize them at the same time.
{% endhint %}

## Services:

### CalculationService

CalculationService is a service that's purpose is to make physics-based calculations within the engine easy to do.

```lua
local CalculationService = PhotonFramework.Services:GetService("CalculationService")
```

#### CalculationService:GetProjectileMotionAtTime(timeValue:number,projectileInitialPosition:Vector3,projectileInitialVelocity:Vector3)

This method will return the position of a theoretical (since there is no actual projectile passed in the arguments) position at x time (timeValue).  This can be used to model a projectile's path effectively.

```lua
local position = CalculationService:GetProjectileMotionAtTime(3,Vector3.new(0,5,0),Vector3.new(50,50,0))
```

### InstanceService

InstanceService allows for easy instance creation, while it does not contain much, it's the backbone of some more complex services.

```lua
local InstanceService = PhotonFramework.Services:GetService("InstanceService")
```

#### InstanceService:Create(ClassName:string,Properties:any,Callback)

This method will create an instance with a set of defined properties, and a callback if supplied.

```lua
InstanceService:Create("Part",{
		Anchored = true;
		Material = Enum.Material.Neon;
		Parent = workspace;
	},function(part)
	while task.wait() do
		part.CFrame = part.CFrame*CFrame.Angles(0,math.rad(1),0)
	end
end)
-- the Callback property is optional.
```

### SharedService

SharedService allows for data to be easily synced across multiple scripts.  It's a big table basically.

```lua
local SharedService = PhotonFramework.Services:GetService("SharedService")
```

#### SharedService:GetValue(key:any)

This is used to retrieve a value from the service.

```lua
local value = SharedService:GetValue(true) -- Value keys can be anything really.
```

#### SharedService:SetValue(key:any,value:any)

This is used to store a value in the service.

```lua
SharedService:SetValue(true,{"ok","it's true"})
```

### UIService

This service can be used to create advanced UIs easily with scripts.

```lua
local UIService = PhotonFramework.Services:GetService("UIService")
```

#### UIService:Create(ClassType:string)

This method can be used to create a UIService tree, which contains data to render a GUI.

```lua
local UIData = UIService:Create("ScreenGui") -- basically define the GUI type here.
```

#### UIService:Object(object:string,properties:table,children:table,connections:table,callback)

This method is used to create a UI object (such as a text button), which can then be added to a UI tree.

```lua
local object = UIService:Object("TextButton",{
    Text = "Hi";
},{
    MouseButton1Click = function()
        print("click")
    end;
},function(button)
    print(button.Name)
end)
```

#### UIService:Add(object:instance,tree:table)

This method is used to add an object to a UI tree.

```lua
UIService:Add(object,UIData)
```

#### UIService:Render(container:Instance,tree:table)

This method is used to render a UI tree.

```lua
UIService:Render(game:GetService("Players").LocalPlayer.PlayerGui,UIData)
```

### UUIDService

UUIDService is a service that allows the creation of a unique string (for said server, does not save). 

```lua
local UUIDService = PhotonFramework.Services:GetService("UUIDService")
```

#### UUIDService:GenerateUUID(length:number)

This method generates a random, unique string that is the supplied length long.

```lua
local response = UUIDService:GenerateUUID(5)
print(response) -- response will be a random string of characters.
```

#### UUIDService:GenerateUUIDCustomCharacters(length:number,characters:table)

This method generates a string of characters from a custom list.

```lua
local response = UUIDService:GenerateUUIDCustomCharacters(5,{"a","b",1,2,3})
```

This concludes the API documentation *for now*.


---

# 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://madonoxrblx.gitbook.io/photonframework-docs/raw-documentation.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.