หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

โลโก้

CI

ภาษาการเขียนโปรแกรม UCode

ภาษาการเขียนโปรแกรมระดับสูงออกแบบมาให้เขียนได้อย่างรวดเร็วเพื่อรวบรวมและทำงาน

UCode เป็นภาษาการเขียนโปรแกรมที่ออกแบบมาเพื่อฝังลงในซอฟต์แวร์ที่มีอยู่เช่นเครื่องยนต์เกมในขณะที่เป็นภาษาระดับต่ำที่มีคุณสมบัติที่ทันสมัยและระดับสูง

ส่วนใหญ่

  • ไม่จำเป็นต้องมีตัวเก็บขยะเช่น C#
  • เสนอฟังก์ชั่นมากกว่า Lua
  • ใช้งานง่ายกว่า C ++
  • ใช้พลังงานคอมไพล์เวลาเพื่อลดแผ่นหม้อไอน้ำ

หลักการออกแบบ/เสาหลัก

  • เรียบง่ายดีกว่าซับซ้อน
  • abstractions zero-overhead
    • คุณไม่จ่ายเงินสำหรับสิ่งที่คุณไม่ได้ใช้
    • สิ่งที่คุณใช้นั้นมีประสิทธิภาพเท่าที่คุณสามารถเขียนได้ด้วยมืออย่างสมเหตุสมผล
  • มีประสิทธิผล
    • เวลารวบรวมที่ปรับขนาดได้
    • เครื่องมือที่เชื่อถือได้
    • เส้นโค้งการเรียนรู้แบบค่อยเป็นค่อยไป
  • นำกลับมาใช้ใหม่ได้
    • พารามิเตอร์
    • รวบรวมพลังเวลา

ภาษาการเขียนโปรแกรมที่รองรับ

  • C ++ // ที่เก็บนี้
  • สนิม // การจับคู่กับการเกิดสนิมที่มีการใช้สำนวนและเครื่องมือที่เกี่ยวข้องกับสนิมสำหรับ ucodelang
  • zig // zig binding พร้อม zig wappers และเครื่องมือที่เกี่ยวข้องกับ zig สำหรับ ucodelang
  • c // เพียงแค่คัดลอก ucodelangcapi.h และขโมยไลบรารีคงที่จากรุ่น

คุณสมบัติ

มุ่งเน้นและมีความเชี่ยวชาญอย่างสมบูรณ์ในการพัฒนาเกมและเครื่องยนต์เกม

คุณสมบัติ Langue

  • ตัวสร้าง destructor
  • คัดลอกตัวสร้าง
  • ย้ายความหมาย
  • enums สนิม
  • เลื่อนลอย
  • ไม่มีการแปลงโดยนัย
  • การดำเนินการที่ไม่ปลอดภัยนั้นอยู่เบื้องหลังการจัดสรรหน่วยความจำอยู่เบื้องหลังคำหลักที่ไม่ปลอดภัย
  • สนิมเหมือนลักษณะ (กำลังดำเนินการ)
  • ไปเหมือนพร้อมกัน (กำลังดำเนินการ)
  • ใช้งานง่าย (ทำงานบน) และ JSON (ทำงาน) การทำให้เป็นอนุกรมในห้องสมุดมาตรฐาน
  • ไม่มีมาโคร
  • โอเปอเรเตอร์มากเกินไป
  • ฟังก์ชั่นมากเกินไป
  • เรื่องสั้น
  • ระบบแท็กที่ระบุเช่น C#
  • ข้อผิดพลาดพื้นฐานของความตื่นตระหนกและค่า
  • การวิเคราะห์เวลาที่รวบรวมได้ดี
  • ห้องสมุดมาตรฐานที่ออกแบบมาสำหรับการพัฒนาเกม
  • ระบบโมดูล

และอื่น ๆ

ห้องสมุด/รันไทม์ freatures

  • Sandboxing รันไทม์เสริม
  • รันไทม์ที่ยืดหยุ่น
    • รหัสสามารถ jited ตีความหรือ precompiled เป็นรหัสเนทีฟทั้งหมดที่ทำงานบนรันไทม์เดียวกัน
    • รูปแบบการทำเกลียวรันไทม์สามารถสร้างขึ้นสำหรับรูปแบบการทำเกลียวใด ๆ (ตามงาน, ลูปเหตุการณ์, etcetera)
  • แบ็กเอนด์ WASM
  • แบ็กเอนด์ C11
  • โค้ดจะรวบรวมไปยัง Native Executables สำหรับ Linux (Working on), Windows (ทำงานบน) และ Mac (ทำงานกับ)
  • สามารถดูคลาสทั้งหมด funcions ลักษณะหลังจากรวบรวม
  • สามารถตัดเอาท์พุทออกคลาสที่ไม่จำเป็นได้
  • สามารถตกใจได้ถ้าคุณชอบ
  • การดีบัก
  • ระบบโมดูล

freatures tooling

  • การสร้างผลผูกพันอัตโนมัติ
  • เซิร์ฟเวอร์ภาษา (กำลังดำเนินการ)

ทำไมต้องใช้ภาษาการเขียนโปรแกรมนี้

ภาษานี้ถูกสร้างขึ้นเนื่องจากการขาดภาษาสคริปต์ที่เหมาะสมสำหรับ GameEngine ที่อนุญาตให้คุณควบคุมระดับต่ำในหน่วยความจำและง่ายต่อการวิเคราะห์เพื่อการสะท้อน

ตัวอย่างเช่น 

 $Vec2:
 float x;
 float y;

$Weapon;

$Player:
 Vec2 pos;
 Weapon[] Weapons;

หลังจากรวบรวมเราจะได้รับข้อมูลแอสเซมบลีที่สามารถใช้เพื่อดูคลาสทั้งหมดฟังก์ชั่นและฟิลด์ ดังนั้นจึงสามารถใช้ในผู้ตรวจการของคุณเช่นเอ็นจิ้นเกมยอดนิยม

ข้อความด้านล่างถือว่าคุณรวบรวมสำหรับ 64 CPU VM คือ CPU Agnostic ยกเว้นขนาดตัวชี้ CPU มันจะต้องมีการรวบรวมสำหรับ 64 บิตหรือ 32 บิตซึ่งเป็นเรื่องเล็กน้อยที่ต้องทำ 

 $Vec2:   //class size 8
 float x;//field offset 0
 float y;//field offset 4

$Weapon;//size 0

$Player: //class size 32
 Vec2 pos;//field offset 0
 Vector<Weapon> Weapons;//field offset [8-12 depending if the compiler added padding]

$Vector<Weapon>: //class size 24
 Weapon[&] _Data; //field offset 0
 uintptr _Size; //field offset 8
 uintptr _Capacity; //field offset 16

เราต้องการข้อมูลแอสเซมบลี C# แต่ด้วยการควบคุมระดับต่ำของ C ++ เหนือหน่วยความจำและไม่มีตัวเก็บขยะ C#

นอกจากนี้เนื่องจากเรากำลังทำภาษาใหม่เราสามารถเรียนรู้ข้อผิดพลาดภาษาที่ผ่านมาด้วยการใช้ตัวเลือกประเภทผลลัพธ์และประเภทตัวแปร enum และลบข้อยกเว้นและอื่น ๆ

แม้จะถูกสร้างขึ้นสำหรับเครื่องยนต์เกม UCode ไม่จำเป็นต้องใช้ VM แต่ก็สามารถใช้งานได้ด้วยตัวเองและสามารถรวบรวมได้โดยตรงกับ C, WASM และไลบรารีแพลตฟอร์มพื้นเมือง

หรือโดยตรงไปยังรหัสเครื่องจักรดั้งเดิมเมื่อเสร็จสิ้น

ทำไมคุณไม่ควรใช้ภาษาการเขียนโปรแกรมนี้

หากกรณีการใช้งานของคุณต้องการภาษาขนาดเล็กเท่านั้นและจะไม่ใช้เวลาส่วนใหญ่ในภาษาสคริปต์ที่คุณใช้ Lua

หากคุณต้องการการพิมพ์แบบคงที่และ C ++ ระดับต่ำ แต่ก็โอเคที่จะมีตัวเก็บขยะใช้ Mono C# หรือ Terra

ดาวน์โหลดและเอกสารประกอบ

เว็บไซต์

สนามเด็กเล่น

เอกสาร

ส่วนขยาย vscode

เริ่มต้นสำหรับผู้ใช้

วิธีเพิ่มลงในโครงการ C ++ ของคุณ

การดาวน์โหลด

รันต่อไปนี้ในเทอร์มินัลของคุณเพื่อติดตั้งบน Linux/MacOS 

 curl -L https://github.com/LostbBlizzard/UCodeLang/releases/latest/download/install.sh | sh

หรือดาวน์โหลดและเรียกใช้ ucodelangsetup.exe บนรุ่นล่าสุดสำหรับ Windows

ตัวอย่าง (ผู้ใช้) 

 use ULang;//include standard Library.

|main[] -> int:
 int a = 10;
 int b = 20;

 var c = a + b;
 
 int[] List;

 List.Push(c);
 
 int&? LastItem = List.Back();

 match LastItem:
  Option(out myvalue):
  
    if myvalue == 30:
       Fmt::Print("myvalue does equal 30");
     
  Null: panic("List size was 0");

ตัวอย่างระบบองค์ประกอบเอนทิตี

สิ่งนี้สามารถเกิดขึ้นได้ใน UCODEIDE/SRC/AppObject/ECSEXAMPLE.HPP และ UCODEIDE/SRC/AppObject/Test.UC 

 use API;//Imgui,Vec2,Time
use ECS;//Component,Entity

$Player[Component]:
 float Speed = 1;
 |Start[this&]:
  entity().position2d() = [2,5];



 |Update[this&] -> void:
  
  var& pos = entity().position2d();//get rereference to entity position.
  float deltatime = Time::DeltaTime();
  
  if Imgui::KeyDown(ImKey::W):
    pos.Y += Speed * deltatime;
    
  if Imgui::KeyDown(ImKey::S):
    pos.Y -= Speed * deltatime;
  
  if Imgui::KeyDown(ImKey::A):
    pos.X -= Speed * deltatime;
  
  if Imgui::KeyDown(ImKey::D):
    pos.X += Speed * deltatime;

ตัวอย่าง (ผู้ดำเนินการ) 

# include < UCodeLang/UCodeLang.hpp >

int main ()
{
  const char * MyUCode = " |main[] => 1; " ;

  UCodeLang::Compiler myCompiler;
  auto comilerRet = myCompiler. CompileText (MyUCode);


  if (!comilerRet. IsError ())
  { 
    // your ucode was Compiled
    UCodeLang::RunTimeLangState State;

    UCodeLang::RunTimeLib Lib;
    Lib. Init (comilerRet. GetValue (). OutPut . value ()); // initialize RunTimeLib using our Compiled code.


    State. AddLib (&Lib); // Add RunTimeLib
    State. LinkLibs (); // Link libraries
   
    UCodeLang::Interpreter interpreter;
    interpreter. Init (&State);

    interpreter. Call (StaticVariablesInitializeFunc); // initialize our Static Variables.
    interpreter. Call (ThreadVariablesInitializeFunc); // initialize thread local/Interpreter local Variables.

    int Value = interpreter. RCall < int >( " main " ); // Call main
    std::cout << " Got Value " << Value;


    interpreter. Call (ThreadVariablesUnLoadFunc); // Call Thread local Variables destructors.
    interpreter. Call (StaticVariablesUnLoadFunc); // Call Static Variables destructors.
  }
  else 
  {
    // your code some how failed to compile
  }
}

การพึ่งพาอาศัยกัน

Ucodelang มีการพึ่งพา Zycore และ Zydis สำหรับเหตุผลการดีบักและการสร้างรหัส x86

ทั้งสองมีการวางแผนที่จะลบออก

โครงสร้างไฟล์โครงการ / การมีส่วนร่วมของ GitHub

เพื่อสร้างโครงการเพียงดาวน์โหลดไฟล์หรือเรียกใช้ 

 git clone https://github.com/LostbBlizzard/UCodeLang.git

 cd ./UCodeLang

หลังจากได้รับไฟล์โครงการรัน

  • ไฟล์ InstallTools.bat (ถ้าคุณอยู่บน Windows) 
 InstallTools.bat
  • ไฟล์ InstallTools.sh (ถ้าคุณอยู่บน Linux หรือ MacOS) 
 ./InstallTools.sh

ขั้นตอนสุดท้ายไม่จำเป็นถ้าคุณไม่จำเป็นต้องสร้าง uCodeide

วิ่งครั้งต่อไป

  • ไฟล์ VS_2019.BAT (ถ้าคุณใช้ VS 2019) เพื่อสร้างไฟล์ VS และเปิดโครงการใน Visual Studio 
 ./VS_2019.bat
  • ไฟล์ vs_2022.bat (ถ้าคุณใช้ VS 2022) เพื่อสร้างไฟล์โครงการ VS และเปิดโครงการใน Visual Studio 
 ./VS_2022.bat
  • ไฟล์ gnu_make.bat (ถ้าคุณใช้ GCC บน Windows) และเรียกใช้ "Make" เพื่อสร้าง 
 ./GNU_Make.sh

 make
  • ไฟล์ gnu_make.sh (ถ้าคุณใช้ GCC บน Linux หรือ Mac) และเรียกใช้ "Make" เพื่อสร้าง หรือวิ่ง 
 ./GNU_Make.sh

 make
  • ไฟล์ xcode.sh (ถ้าคุณใช้ XCode) และเปิดโครงการใน XCode 
 ./XCode.sh

โครงสร้างโครงการไฟล์เป็นแบบนี้

  • /การพึ่งพา

    • "มีการปฏิบัติการครั้งแรก"

  • /UC

    • "คือเครื่องมือบรรทัดคำสั่ง"
    • "สิ่งที่ผู้ใช้ใช้ในการสร้างไฟล์ UCODE และเรียกใช้ UCODE"

  • /ucapp

    • "สนามเด็กเล่นทดสอบ"
    • /src
      • "ใช้สิ่งนี้เมื่อทำการทดสอบและดีบักคุณสมบัติ"
      • "ฉันไม่สนใจอะไรมากเกินไปสำหรับสิ่งที่เกิดขึ้นที่นี่"
    • /การทดสอบ
      • "ฟังก์ชั่นการทดสอบและทดสอบหน่วย"

  • /Ucodeapi

    • "ไฟล์ UCODE มากมาย"
    • "มีไลบรารีมาตรฐานและไลบรารีอื่น ๆ "

  • /Ucodelang

    • "แกนกลางของ Ucode-lang ถ้าคุณใช้สิ่งนี้เป็นไลบรารีเพิ่มสิ่งนี้ลงในไดเรกทอรีรวมของคุณ"

    • /การพึ่งพา

      • "decompilers สำหรับการทดสอบ"

    • /ucodeanalyzer

      • "คลาส/ฟังก์ชั่นสำหรับ UCodelanguagesever"
      • "เครื่องมือสำหรับการวิเคราะห์ Ucodelang"

    • /Ucodelang

      • /การรวบรวม
        • "UCode ได้รับการรวบรวม"
      • /แลงคอร์
        • "ผู้ช่วยและสิ่งอื่น ๆ "
      • /รันไทม์
        • "ล่ามของคุณเป็นนักเขียนบทกวีของคุณและรันไทม์สด"
        • "คอมไพเลอร์ jit-interpreter อยู่ใน Ucodelang/รวบรวม/ย้อนกลับ"

  • /UCodelanguagesever

    • "ภาษาที่รันได้"
    • /src
      • "รหัส"

  • /UCodelanguageseverlib

    • "ภาษาตัดกับ JSON และโปรโตคอลเซิร์ฟเวอร์ภาษา"
    • /การพัฒนา JSON
      • "ห้องสมุด JSON"
    • /src
      • "รหัส"

  • /UCodeDocumentation

    • "UcodeDocumentation คือ"
    • /มาตรฐาน
      • "สร้างขึ้นจาก /UCODEAPI /UCODEDOCUMENTATION"

  • /ucodeide

    • "การใช้งานของมันสำหรับการทดสอบสิ่งที่ยากที่จะทดสอบโดยใช้ดีบั๊ก"
    • "มันเรียกว่า Ucodeide แต่มันเป็นเพียงเครื่องมือทดสอบภายใน"

  • /ucodewebsite

    • "ucodewebsite เป็นฉันไม่ใช่นักพัฒนาเว็บดังนั้นมันอาจเป็นเพียงขั้นต่ำที่เปลือยเปล่า"

โครงการมีความหมายเกินไปมีการพึ่งพาน้อยที่สุดเท่าที่จะเป็นไปได้เพราะมันมีความหมายที่จะเพิ่มลงในบทกวี C ++ ใด ๆ

ใช้แท็บปัญหา GitHub สำหรับข้อบกพร่อง ใช้การอภิปราย GitHub เพื่อพูดคุยเกี่ยวกับภาษาและคุณสมบัติใหม่และการออกแบบภาษา ยังรักษามันให้เป็นพลเรือน

อย่าอายที่จะวิพากษ์วิจารณ์ว่าสิ่งต่าง ๆ ถูกนำไปใช้อย่างไรฉันรู้ว่ารหัสสามารถดีขึ้นในสถานที่

การวิจารณ์เชิงสร้างสรรค์ยินดีต้อนรับ (อย่ารุนแรงเกินไป)

โปรดถามคำถามเกี่ยวกับโครงการใด ๆ เพราะฉันแทบจะไม่ได้บันทึกอะไรเลย

สาขาหลักสำหรับการเผยแพร่และคุณสมบัติคือที่ที่ฉันทำการพัฒนาจริง

วิสัยทัศน์สุดท้ายของโครงการมีแบ็กเอนด์สำหรับ

  • UCODEVM (Interpreter, Jitinterpreter, NativeAnterpreter)

  • C11

  • การใช้เว็บ

  • Windows (Native Executable),

  • Linux (Native Conecutable),

  • MacOS (Native Consacutable),

  • x86

  • x86_64

  • แขน

  • ARM64

การให้เครดิต

ภาษาได้รับการออกแบบและพัฒนาโดย Lostblizzard บน GitHub

ที่ปัจจุบันรักษาไฟล์

  • การใช้ภาษา Ucodelang cplusplus ของภาษา

UcodegameEngine (กำลังดำเนินการ) เหตุผลหลักที่ภาษาทำ

QA

  • ถาม: Ucodelang คล้ายกับ C ++ และ Rust มากทำไมไม่ใช้ Rust หรือ C ++?

    ตอบ: C ++ ถูกรวบรวมเกินไปของภาษาและไม่สามารถวิเคราะห์ได้หลังจากรวบรวม (โดยไม่ต้องแฮ็คคอมไพเลอร์) คุณสมบัติหน่วยความจำที่อยู่ในความพิถีพิถันนั้นไม่ได้มีประโยชน์สำหรับกรณีการใช้งานของฉันและตัวชี้อัจฉริยะ C ++ เป็นสิ่งที่ฉันต้องการ

  • ถาม: ทำไมจึงเขียนใน C ++

    ตอบ: เอ็นจิ้นเกมส่วนใหญ่และเอ็นจิ้นเกมของฉันโดยเฉพาะเขียนใน C ++. C ++ ยังคงเป็นเครื่องมือที่ดีที่สุดสำหรับการสร้างเอ็นจิ้นเกม

  • ถาม: ทำไมไม่ใช้ LLVM สำหรับแบ็กเอนด์ของคุณ

    ตอบ: LLVM มีขนาดใหญ่เกินไปในการพึ่งพาและการเขียนแบ็กเอนด์ของฉันเองทำให้ฉันมีข้อแก้ตัวที่ดีในการเรียนรู้เกี่ยวกับคอมพิวเตอร์ (เหตุผลที่ทำให้ฉันสร้างเอ็นจิ้นเกม) นอกจากนี้คุณเพียงแค่ส่งออกข้อความประกอบ LLVM

  • ถาม: ทำไมพื้นที่สีขาวที่สำคัญ?

    ตอบ: ดูเหมือนว่าน่าสนใจก็ดูดีกว่า

  • ถาม: คุณสมบัตินักฆ่า Ucodelang คืออะไร

    ตอบ: Ucodelang ไม่ใช่เรื่องใหญ่ต่อไป แต่เป็นเพียงเครื่องมือที่ทำขึ้นสำหรับกรณีการใช้งานเฉพาะของฉันมันใช้ส่วนที่ดีที่สุดจากภาษาที่ฉันชอบและพยายามที่จะลบส่วนเกิน มันมีการปรับปรุงและปรับปรุง C ++ ในบางวิธี

  • ถาม: UCode หมายถึงอะไร?

    ตอบ: คำว่า UCODE ไม่มีความหมายอะไรเลยและไม่มีประวัติมันเป็นเพียงชื่อที่ฉันสร้างขึ้นสำหรับแนวคิดภาษาการเขียนโปรแกรมหากคุณต้องการความหมายจริง ๆ เมื่อความคิดนั้นทำให้มันยืนสำหรับรหัสที่ไม่ได้ลงชื่อตามคำหลัก C/C ++ ที่ไม่ได้ลงนาม

  • ถาม: คุณชอบ C ++ ไหม?

    ตอบ: ฉันชอบมากพอที่จะใช้เวลาหนึ่งปีในการใช้ภาษาใหม่โดยใช้มัน แต่ไม่เพียงพอที่จะทำให้ผู้ใช้ของฉันสำหรับเครื่องมือเกมของฉันใช้มัน (ขออภัย Unreal) ฉันชอบ C ++ จริงๆ แต่ฉันก็ตระหนักถึงข้อบกพร่องของมัน

  • ถาม: จะทำอย่างไรต่อไปและเมื่อใด

  • ตอบ: เมื่อพื้นที่เก็บข้อมูลเปิดขึ้น (โดยเฉพาะอย่างยิ่งในวันที่ 1/2/2023 ครบรอบหนึ่งปีของการทำโครงการ JIT) คุณสมบัติส่วนใหญ่จะทำและไม่ได้วางแผนที่จะเพิ่มมากขึ้นเว้นแต่ว่ามันจะดีเกินไป ฉันจะอยู่ใกล้ ๆ ปีพิเศษเพื่อให้สถาปัตยกรรมและแบ็กเอนด์อื่น ๆ เสร็จสิ้นและ stabitly ณ จุดนั้นโครงการจะเสร็จสิ้นและฉันสามารถทำงานกับเอ็นจิ้นเกมนั้นและไปทำงานกับสิ่งที่ยิ่งใหญ่และดีกว่าฉันเชื่อว่าการเพิ่มคุณสมบัติจำนวนมากอาจทำให้ภาษาแย่ลง

  • ถาม: ความคิดเห็นของคุณเกี่ยวกับภาษาการเขียนโปรแกรมใหม่

  • ตอบ: ยิ่ง merrier มากขึ้นโดยเฉพาะอย่างยิ่งสำหรับภาษาระบบ ทุกภาษาทดลองยิ่งเราทดลองภาษาที่ดีขึ้นโดยเราเรียนรู้จากความผิดพลาดที่นั่น

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด