m-lamonaca/dev-notes
1
0
Fork 0
mirror of https://github.com/m-lamonaca/dev-notes.git synced 2025-04-06 19:06:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Godot scripting starting notes

Browse source
This commit is contained in:
Marcello 2021-09-19 12:10:20 +02:00
parent 8a74634625
commit 76550dfa3c
8 changed files with 243 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
DotNet/ASP.NET/Blazor.md
View file

@ -148,7 +148,7 @@ Project
```cs ```cs
<Router AppAssembly="@typeof(Program).Assembly" PreferExactMatches="@true"> <Router AppAssembly="@typeof(Program).Assembly" PreferExactMatches="@true">
<Found Context="routeData"> // for component routing <Found Context="routeData">
<RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" /> <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
</Found> </Found>
<NotFound> <NotFound>

27
DotNet/ASP.NET/REST API.md
View file

@ -48,25 +48,28 @@ namespace <Namespace>.Profiles
} }
``` ```
In `StartUp.cs`: ## Controller (No View)
Uses [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) to recieve a suitable implementation of `IEntityRepo`,
### Service Lifetimes
- `AddSingleton`: same for every request
- `AddScoped`: created once per client
- `Transient`: new instance created every time
In `Startup.cs`:
```cs ```cs
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services) public void ConfigureServices(IServiceCollection services)
{ {
// other services services.AddControllers();
services.AddScoped<IEntityRepo, EntityRepo>(); // map the interface to its implementation, needed for dependency injection
// let AutoMapper know in what assemblies are the profiles defined
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
// or create a MapperConfiguration
services.AddAutoMapper(cfg => {
cfg.CreateMap<Foo, Bar>();
cfg.AddProfile<FooProfile>();
})
} }
``` ```
### Controller with DTOs ### Request Mappings
```cs ```cs
using <App>.Model; using <App>.Model;

26
DotNet/ASP.NET/WebForms/Page.aspx.cs.md Normal file
View file

@ -0,0 +1,26 @@
# Page.aspx.cs
```cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace Project
{
public partial class Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void Control_Event(object sender, EventAtgs e)
{
// actions on event trigger
}
}
}
```

58
DotNet/ASP.NET/WebForms/Page.aspx.md Normal file
View file

@ -0,0 +1,58 @@
# Page.aspx
The fist loaded page is `Default.aspx` and its undelying code.
```html
<!-- directive -->
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Project.Default" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"> <!-- XML Namespace -->
<head runat="server"> <!-- runat: handle as ASP code -->
<title></title>
</head>
<body>
<!-- web forms require a form tag to be the whole body -->
<form id="form1" runat="server"> <!-- runat: handle as ASP code -->
<div>
</div>
</form>
</body>
</html>
```
## ASP.NET Directives
### Page Directive
```cs
<%@ Page Language="C#" // define language used (can be C# or VB)
AutoEventWireup="true" // automatically create and setup event handlers
CodeBehind="Default.aspx.cs" // define the underlying code file
Inherits="EmptyWebForm.Default" %>
```
## Web Controls
```xml
<asp:Control ID="" runat="server" ...></asp:Control>
<!-- Label: empty text will diplay ID, use empty space as text for empty label -->
<asp:Label ID="lbl_" runat="server" Text=" "></asp:Label>
<!-- TextBox -->
<asp:TextBox ID="txt_" runat="server"></asp:TextBox>
<!-- Button -->
<asp:Button ID="btn_" runat="server" Text="ButtonText" OnClick="btn_Click" />
<!-- HyperLink -->
<asp:HyperLink ID="lnk_" runat="server" NavigateUrl="~/Page.aspx">LINK TEXT</asp:HyperLink>
<!-- LinkButton: POstBackEvent reloads the page -->
<asp:LinkButton ID="lbtHome" runat="server" PostBackUrl="~/Page.aspx" OnClick="lbt_Click">BUTTON TEXT</asp:LinkButton>
<!-- Image -->
<asp:Image ID="img_" runat="server" ImageUrl="~/Images/image.png"/>
<!-- ImageButton -->
<asp:ImageButton ID="imb_" runat="server" ImageUrl="~/Images/image.png" PostBackUrl="~/Page.aspx"/>
<!-- SqlSataSource; connection string specified in Web.config -->
<asp:SqlDataSource ID="sds_" runat="server" ConnectionString="<%$ ConnectionStrings:ConnectionString %>" SelectCommand="SQL Query"></asp:SqlDataSource>
```

2
DotNet/C#/Async Programming.md
View file

@ -160,4 +160,4 @@ protected async void MyButton_Click(object sender, EventArgs e)
// We may actually be on another *thread*, but we have the same ASP.NET request context. // We may actually be on another *thread*, but we have the same ASP.NET request context.
Response.Write("File downloaded!"); Response.Write("File downloaded!");
} }
``` ```

2
DotNet/C#/C#.md
View file

@ -2907,4 +2907,4 @@ In this case, the method must also be declared as `static`.
```cs ```cs
[DllImport("avifil32.dll")] [DllImport("avifil32.dll")]
private static extern void AVIFileInit(); private static extern void AVIFileInit();
``` ```

2
DotNet/C#/Reactive Extensions.md
View file

@ -12,7 +12,7 @@ of an Rx source demand to be given the next item. Instead, Rx uses a *push* mode
Because Rx implements standard LINQ operators, it's possible to write queries against a live source. Rx goes beyond standard LINQ, adding its own operators that take into account the temporal nature of a live event source. Because Rx implements standard LINQ operators, it's possible to write queries against a live source. Rx goes beyond standard LINQ, adding its own operators that take into account the temporal nature of a live event source.
## Foundamental Interfaces ## Fundamental Interfaces
The two most important types in Rx are the `IObservable<T>` and `IObserver<T>` interfaces. The two most important types in Rx are the `IObservable<T>` and `IObserver<T>` interfaces.
They are important enough to be in the System namespace. The other parts of Rx are in the `System.Reactive` NuGet package. They are important enough to be in the System namespace. The other parts of Rx are in the `System.Reactive` NuGet package.

140
DotNet/Godot/Scripting.md Normal file
View file

@ -0,0 +1,140 @@
# Godot Scripting
## Basics
```cs
using Godot;
public class NodeName : NodeType
{
[Export] // make variable visible in inspector
Type variable = value;
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
GetNode("NodeName"); // fetch a child node in the scene
GetNode("ParentNode/ChildNode"); // fetch a child node in the scene
AddToGroup("Group"); // add a node to a group (similar to tags)
GetTree().CallGroup("Group", "Function"); // call Function on all group members
var groupMembers = GetTree().GetNodesInGroup("Group");
}
// Called every frame. 'delta' is the elapsed time since the previous frame.
public override void _Process(float delta)
{
}
public void _OnEmitterSignal() { }
}
```
### Overridable Functions
```cs
public override void _EnterTree()
{
// When the node enters the Scene Tree, it becomes active and this function is called.
// Children nodes have not entered the active scene yet.
// In general, it's better to use _ready() for most cases.
base._EnterTree();
}
public override void _Ready()
{
// This function is called after _enter_tree, but it ensures
// that all children nodes have also entered the Scene Tree,
// and became active.
base._Ready();
}
public override void _ExitTree()
{
// When the node exits the Scene Tree, this function is called.
// Children nodes have all exited the Scene Tree at this point and all became inactive.
base._ExitTree();
}
public override void _Process(float delta)
{
// This function is called every frame.
base._Process(delta);
}
public override void _PhysicsProcess(float delta)
{
// This is called every physics frame.
base._PhysicsProcess(delta);
}
```
### Creating Nodes
```cs
private Sprite _sprite;
public override void _Ready()
{
base._Ready();
_sprite = new Sprite(); // Create a new sprite
AddChild(_sprite); // Add it as a child of this node
_sprite.Free(); // Immediately removes the node from the scene and frees it.
}
```
**Note**: When a node is freed, it also frees all its child nodes.
The safest way to delete a node is by using `Node.QueueFree()`. This erases the node safely during idle.
### Instantiating Scenes
```cs
// STEP 1: load the scene
var scene = GD.Load<PackedScene>("res://scene.tscn"); // Will load when the script is instanced.
// STEP 2: instantiate the scene-node
var node = scene.Instance();
AddChild(node);
```
The advantage of this two-step process is that a packed scene may be kept loaded and ready to use so that it's possible to create as many instances as desired.
This is especially useful to quickly instance several enemies, bullets, and other entities in the active scene.
## Signals
Signals are Godot's version of the *observer* pattern. They allow a node to send out a message that other nodes can listen for and respond to.
Signals are a way to decouple game objects, which leads to better organized and more manageable code. Instead of forcing game objects to expect other objects to always be present, they can instead emit signals that all interested objects can subscribe to and respond to.
```cs
public override _Ready()
{
GetNode("Node").Connect("signal", targetNode, nameof(TargetFunction)); // connect node and signal
}
// Signal Handler
public void OnEmitterSignal() { }
```
### Custom Signals
```cs
public class Node : Node2D
{
[Signal]
public delegate void CustomSignal(Type arg, ...);
public override void _Ready()
{
EmitSignal(nameof(CustomSignal), args);
}
}
```