Hoyo GPP Prep

[Timothyoung97]

This issue comprises of some preparation contents made for interviews

[Timothyoung97]

Networking Question

OSI

---

Address Resolution Protocol (ARP)

---

Swtich vs Router, IP vs MAC

---

Link Layer

Cyclic Redundancy Check (CRC32)
MAC Address

---

Internet Control Message Protocol (ICMP) Network Layer

---

IPv4

---

NAT

---

RIP

---

IP Addr

---

Dynamic Host Configuration Protocol (APP layer, runs on UDP)

Also provides details IP of:

• First Hop router
• Local DNS Server

---

UDP vs TCP

TCP (Transmission Control Protocol) and UDP (User Datagram Protocol) are two widely used transport layer protocols in computer networks. Here are the main differences between TCP and UDP:

• Connection-Oriented vs. Connectionless:
  TCP is a connection-oriented protocol. It establishes a connection between the sender and receiver before transmitting data, ensuring reliable and ordered delivery of data packets.
  UDP is a connectionless protocol. It does not establish a connection before sending data and does not guarantee delivery or order of data packets. UDP is often used for real-time applications where speed is more important than reliability.

• Reliability:
  TCP provides reliable delivery of data. It includes features like error checking, retransmission of lost packets, and flow control to ensure all data is successfully delivered in order.
  UDP does not guarantee reliable delivery. It does not perform error checking or retransmission of lost packets, so it is possible for packets to be lost or arrive out of order.

• Packet Structure:
  TCP uses a packet structure with additional headers for sequence numbers, acknowledgment numbers, checksums, and other control information to manage the connection and ensure reliability.
  UDP has a simpler packet structure with minimal overhead. It includes source port, destination port, length, and checksum fields, but does not include sequence numbers or acknowledgment mechanisms.

• Flow Control and Congestion Control:
  TCP implements flow control and congestion control mechanisms to manage the rate of data transmission and avoid network congestion.
  UDP does not have built-in flow control or congestion control. Applications using UDP need to implement their own flow control mechanisms if necessary.

• Usage:
  TCP is commonly used for applications that require reliable and ordered delivery of data, such as web browsing, email, file transfer (FTP), and streaming media.
  UDP is used for real-time applications where low latency and speed are critical, such as online gaming, video streaming, VoIP (Voice over IP), DNS (Domain Name System), and SNMP (Simple Network Management Protocol).

In summary, TCP provides reliable, ordered, and connection-oriented communication with additional overhead and mechanisms for error recovery and flow control. UDP, on the other hand, offers faster and connectionless communication with minimal overhead but lacks reliability and error recovery mechanisms. The choice between TCP and UDP depends on the specific requirements of the application, such as the importance of reliability, latency, and speed.

---

Port Num

Here are some common examples of port numbers and their typical usage:

• Port 80 (HTTP):
  Used for HTTP (Hypertext Transfer Protocol) traffic, which is the protocol used for serving web pages.
  When you access a website using a web browser, the browser communicates with the web server over port 80 by default.

• Port 443 (HTTPS):
  Used for HTTPS (Hypertext Transfer Protocol Secure) traffic, which is the secure version of HTTP.
  HTTPS encrypts the data transferred between the client (browser) and the server, providing a secure communication channel.
  It's commonly used for online transactions, login pages, and any sensitive data transfer over the web.

• Port 22 (SSH):
  Used for SSH (Secure Shell) protocol, which provides secure access to a remote computer over an encrypted connection.
  SSH is commonly used for remote administration, file transfer, and secure communication between computers.

• Port 25 (SMTP):
  Used for SMTP (Simple Mail Transfer Protocol) traffic, which is the protocol used for sending email messages between servers.
  Port 25 is used by mail servers to send outgoing email messages to other mail servers.

• Port 67 (DHCP):
  Port 67 is used by DHCP servers to receive DHCPDISCOVER and DHCPREQUEST messages from DHCP clients.

• Port 68 (DHCP):
  Port 68 is used by DHCP clients to receive DHCPOFFER, DHCPACK, and DHCPNAK messages from DHCP servers.

• Port 587 (SMTP Submission):
  Used for SMTP Submission, which is an alternative port for sending email messages from email clients (e.g., Outlook, Thunderbird) to mail servers.
  Port 587 is commonly used for sending email from email clients to mail servers with encryption and authentication.

• Port 110 (POP3):
  Used for POP3 (Post Office Protocol version 3) traffic, which is a protocol used by email clients to retrieve email messages from a mail server.
  POP3 is used for downloading emails to the client's computer or device.

• Port 143 (IMAP):
  Used for IMAP (Internet Message Access Protocol) traffic, which is another protocol used by email clients to retrieve email messages from a mail server.
  IMAP allows clients to manage emails on the server, sync folders, and access email from multiple devices while keeping messages on the server.

• Port 3306 (MySQL):
  Used for MySQL database server traffic, which is a popular relational database management system.
  Port 3306 is used by MySQL clients to connect to the MySQL server and perform database operations.

These are just a few examples of common port numbers and their associated protocols. Different applications and services use specific port numbers for communication, and understanding these port numbers can help in network configuration and troubleshooting.

---

DNS Resource Record

DNS（Domain Name System）记录是DNS服务器上存储的数据项，用于将域名解析为对应的IP地址或其他网络服务信息。常见的DNS记录类型包括：

• A记录（Address Record）： 将域名解析为IPv4地址。例如，将域名www.example.com解析为IP地址192.0.2.1。
• AAAA记录（IPv6 Address Record）： 将域名解析为IPv6地址。例如，将域名www.example.com解析为IPv6地址2001:db8::1。
• CNAME记录（Canonical Name Record）： 用于创建域名的别名，将一个域名指向另一个域名。例如，将www.example.com的CNAME记录指向example.com，实现域名的重定向。
• MX记录（Mail Exchange Record）： 用于指定邮件服务器的优先级和地址，实现邮件的路由和传递。例如，将example.com的MX记录指向邮件服务器的IP地址。
• NS记录（Name Server Record）： 用于指定域名的DNS服务器，指定哪些DNS服务器负责解析该域名。例如，将example.com的NS记录指向DNS服务器的域名或IP地址。
• TXT记录（Text Record）： 用于存储任意文本信息，常用于验证域名所有权、配置SPF记录等。例如，用于验证域名所有权的TXT记录中包含一段特定的文本字符串。
• PTR记录（Pointer Record）： 用于反向DNS查找，将IP地址解析为对应的域名。例如，将IP地址192.0.2.1的PTR记录解析为www.example.com。
• SRV记录（Service Record）： 用于指定提供特定网络服务的主机和端口号。例如，将_sip._tcp.example.com的SRV记录指定为10 0 5060 sip.example.com，表示提供SIP服务的主机是sip.example.com，端口号为5060。

这些DNS记录类型可以组合使用，以实现域名到IP地址的解析、邮件传递、服务发现等功能。通过管理DNS记录，可以控制域名的解析行为和网络服务的路由，保证网络通信的正常进行。

What happens after you enter www.google.com

在浏览器中输入并按下“www.google.com”后，通常会经历以下步骤才能显示谷歌的网页：

• 域名解析（DNS解析）： 浏览器首先会将输入的域名“www.google.com”解析成对应的IP地址。这个过程由操作系统的DNS解析器完成，它会向DNS服务器发送查询请求，获取到谷歌服务器的IP地址。
• 建立TCP连接： 浏览器使用获取到的IP地址，通过TCP协议与谷歌服务器的Web服务器建立连接。这个过程包括TCP的三次握手，确保浏览器和服务器之间的通信通道建立成功。
• 发送HTTP请求： 一旦TCP连接建立成功，浏览器就会向谷歌服务器发送一个HTTP请求，请求获取谷歌网站的内容。请求中包含了请求的方法（GET、POST等）、请求头部（Header）、可能的请求体（Body）等信息。
• 服务器处理请求： 谷歌服务器接收到浏览器发送的HTTP请求后，会进行请求处理。这可能包括从数据库中获取数据、动态生成网页内容、执行服务器端的逻辑等。
• 服务器发送HTTP响应： 谷歌服务器根据浏览器的请求，生成相应的HTTP响应。HTTP响应包括响应状态码、响应头部（Header）、响应体（Body）等信息。通常，谷歌服务器会返回HTML、CSS、JavaScript等文件给浏览器。
• 接收和解析响应： 浏览器接收到谷歌服务器发送的HTTP响应后，会开始解析响应内容。浏览器会根据响应中的HTML文件构建DOM树，加载并解析CSS、JavaScript等资源，并开始渲染页面。
• 页面渲染： 浏览器根据解析的HTML、CSS和JavaScript文件，进行页面布局和渲染。这包括加载图片、执行JavaScript代码、应用CSS样式等过程，最终呈现出谷歌的网页内容。
• 显示页面： 当页面渲染完成后，浏览器会将生成的页面内容显示在用户的屏幕上，用户就可以看到谷歌的网页了。

整个过程包括了DNS解析、建立TCP连接、发送HTTP请求、服务器处理请求、接收和解析响应、页面渲染和显示页面等步骤，确保用户能够顺利访问和浏览网页内容。

---

User Verification

游戏客户端实现用户身份验证或会话管理等功能通常涉及以下步骤和技术：

• 登录界面： 游戏客户端通常会有一个登录界面，用户需要输入用户名和密码进行身份验证。
• 发送登录请求： 客户端通过网络协议（如HTTP、HTTPS）向服务器发送登录请求，包括用户提供的用户名和密码等信息。
• 服务器验证： 服务器接收到登录请求后，会对用户提供的用户名和密码进行验证。验证可以通过数据库查询、加密算法等方式进行。
• 生成会话令牌： 如果用户身份验证成功，服务器会生成一个会话令牌（Session Token）并返回给客户端。会话令牌通常是一个加密的字符串，用于标识用户的会话状态。
• 存储会话令牌： 客户端通常会将会话令牌存储在本地，比如使用本地存储（LocalStorage）、加密存储或安全存储（Secure Storage）等方式存储会话令牌。
• 发送会话令牌： 客户端在后续的请求中会将会话令牌作为参数或消息头发送给服务器，以表明用户的身份和会话状态。
• 会话管理： 服务器在接收到带有会话令牌的请求后，会根据会话令牌来验证用户的身份和会话状态。如果会话令牌有效且用户已经登录，则服务器会处理请求；否则，服务器可能会返回未授权或会话过期等错误。
• 定期更新会话令牌： 为了提高安全性，客户端通常会定期更新会话令牌，以防止会话令牌被恶意盗取或滥用。

上述流程是一个简化的用户身份验证和会话管理的实现过程。实际应用中，还可能涉及到一些安全性和稳定性的考虑，比如使用HTTPS协议保证通信安全、使用加密算法保护用户密码和会话令牌、处理会话过期和异常情况等。

---

Cookie

游戏客户端可能会使用Cookie来实现一些功能或记录一些信息，但与网站应用不同，游戏客户端通常不会使用Cookie来实现用户身份验证或会话管理等功能。下面是一些游戏客户端可能会使用的Cookie类型：

• 游戏配置信息： 游戏客户端可能会使用Cookie来存储玩家的游戏设置和偏好，比如音量设置、画面效果、控制设置等。
• 记住登录状态： 一些在线游戏可能会在客户端保存一个记住登录状态的Cookie，以便下次打开游戏时自动登录到玩家的账号。
• 广告和分析： 游戏客户端可能会使用Cookie来追踪玩家的游戏行为，以便进行广告投放或游戏数据分析。
• 游戏进度和存档： 一些游戏可能会使用Cookie来保存玩家的游戏进度和存档信息，以便在不同设备上同步游戏数据。
• 本地存储： 除了Cookie外，游戏客户端还可以使用本地存储（LocalStorage）或数据库来存储一些数据，比如游戏设置、进度、缓存的资源等。

需要注意的是，游戏客户端通常不会使用Cookie来存储敏感信息，如用户密码等。对于敏感信息的处理，游戏客户端通常会使用更安全的方式，比如加密存储、安全传输等。

---

HTTP Reponse

HTTP响应状态码是指在客户端发送请求后，服务器返回的表示请求处理结果的数字代码。状态码通常分为以下几个类别：

• 1xx：信息性状态码，表示请求已经接收并且服务器正在处理。
  100：Continue（继续），表示客户端可以继续发送请求体。
  101：Switching Protocols（切换协议），表示服务器已经理解客户端的请求，并将通过Upgrade消息头通知客户端切换协议。

• 2xx：成功状态码，表示服务器成功接收、理解并处理了客户端的请求。
  200：OK，表示请求成功处理。
  201：Created，表示请求已经成功并且服务器创建了新的资源。
  204：No Content，表示服务器成功处理了请求，但没有返回任何内容。

• 3xx：重定向状态码，表示需要客户端采取进一步的操作来完成请求。
  301：Moved Permanently，永久重定向。
  302：Found，临时重定向。
  304：Not Modified，客户端的缓存资源仍然有效。

• 4xx：客户端错误状态码，表示客户端发送的请求有误或无法完成。
  400：Bad Request，客户端发送了一个错误的请求。
  401：Unauthorized，请求未授权，需要进行身份验证。
  403：Forbidden，服务器理解请求，但拒绝执行。
  404：Not Found，请求的资源不存在。
  5xx：服务器错误状态码，表示服务器在处理请求时发生了错误。

• 500：Internal Server Error，服务器遇到了一个未知的错误。
  502：Bad Gateway，服务器作为网关或代理时从上游服务器收到了无效的响应。
  503：Service Unavailable，服务器暂时无法处理请求，通常是由于过载或维护。

这些状态码在HTTP协议中有明确的规定，客户端和服务器可以根据不同的状态码进行相应的处理和反馈，以确保通信过程的正常进行和信息的正确传递。

---

TCP Triple Handshake

TCP 三次握手（three-way handshake）对于建立可靠的网络连接至关重要。这个过程确保了通信双方的同步和可靠性，以下是其重要性：

• 建立连接： 三次握手允许客户端和服务器之间建立起可靠的连接。通过这个过程，双方确认彼此的身份并同意开始数据传输。
• 确认双方可达： 在握手的第一步，客户端向服务器发送 SYN 包（同步包），服务器收到后回复 SYN-ACK 包（同步-确认包），这确保了双方都能收到对方的消息，从而确认连接的可达性。
• 同步序列号： 在握手的过程中，双方交换了初始序列号（Sequence Number），这个序列号在后续的数据传输中用于确认和排序数据包，确保数据的有序传输。
• 防止重复连接： 三次握手可以防止因网络延迟或丢包而导致的误认为连接已建立的情况。只有在三次握手完成后，双方才认为连接已经确立。
• 处理半开连接： 三次握手过程中，如果任一方未收到确认，会触发超时机制并重新发送握手包，以确保连接的建立或中断。这有助于处理可能出现的半开连接问题。

总体来说，TCP 三次握手确保了通信的可靠性和顺序性，对于构建稳定的网络连接至关重要。

---

TCP 4 times handshake

TCP 的四次握手（four-way handshake）是在连接关闭时的重要过程，它确保了连接的可靠关闭和资源释放。以下是四次握手的重要性：

• 完整关闭连接： 四次握手确保了连接的完整关闭。在这个过程中，客户端和服务器都有机会确认彼此已经完成数据传输，并且没有剩余的数据在传输中。
• 释放资源： 四次握手允许双方释放连接相关的资源，包括缓冲区、状态信息等。这样可以避免资源浪费和不必要的占用，确保系统资源的有效利用。
• 可靠关闭连接： 通过四次握手，双方都能确认对方已经接收到了关闭请求，并且确认了自己也没有剩余的数据需要传输。这种可靠的关闭方式可以防止数据丢失或被意外丢弃。
• 处理半关闭连接： TCP 允许一方关闭连接而另一方仍然可以发送数据，称为半关闭状态。四次握手中的最后一步允许双方完成半关闭状态的处理，确保连接的完全关闭。
• 处理异常情况： 在网络通信中可能出现各种异常情况，如网络故障、超时等。四次握手中的每一步都有超时机制和重传机制，可以处理这些异常情况，保证连接关闭的可靠性。

综上所述，TCP 四次握手是确保连接可靠关闭和资源释放的重要步骤，对于网络通信的稳定性和效率至关重要。

---

DIff HTTPS vs. HTTP

HTTPS（Hypertext Transfer Protocol Secure）和 HTTP（Hypertext Transfer Protocol）是用于在网络上传输数据的两种协议，它们之间的主要区别包括以下几点：

• 安全性： HTTPS 是加密的 HTTP。HTTPS 使用 SSL/TLS 协议对数据进行加密，使得传输过程中的数据被加密，更难以被窃听和篡改，提高了数据传输的安全性。
• 端口： HTTP 默认使用端口80进行通信，而 HTTPS 默认使用端口443。这使得服务器能够区分 HTTP 请求和 HTTPS 请求，并且可以针对这两种协议进行不同的处理。
• 加密方式： HTTPS 使用 SSL/TLS 协议来加密数据传输。SSL/TLS 使用公钥加密（对称加密）和私钥解密（非对称加密）的方式，保证了数据在传输过程中的机密性和完整性。
• 信任机制： HTTPS 通过数字证书来验证服务器的身份，确保通信双方的身份可信。这种信任机制可以防止中间人攻击和伪造网站。
• SEO 影响： HTTPS 在搜索引擎优化（SEO）方面具有优势。搜索引擎通常更倾向于排名使用 HTTPS 协议的网站，因为它提供了更安全的用户体验。
• 性能影响： HTTPS 加密和解密数据会增加服务器和客户端的计算负载，可能会稍微影响性能。但是随着硬件和加密算法的改进，这种影响已经大大降低。

综上所述，HTTPS相对于HTTP更安全、更可信，适合传输敏感数据和进行安全的网络通信。

---

Diff TCP vs HTTPS

TCP (Transmission Control Protocol) and HTTPS (Hypertext Transfer Protocol Secure) are different protocols used in computer networking, and they serve different purposes.

TCP (Transmission Control Protocol):

• TCP is a fundamental protocol in the Internet Protocol Suite (TCP/IP) and operates at the transport layer.
• It provides reliable, ordered, and error-checked delivery of data between applications running on devices connected to a network.‘
• TCP handles the establishment of a connection, data transmission, acknowledgment of received data, and connection termination.
• It is connection-oriented, meaning it establishes a connection before transmitting data and ensures data integrity and delivery.

HTTPS (Hypertext Transfer Protocol Secure):

• HTTPS is an extension of HTTP (Hypertext Transfer Protocol) used for secure communication over a computer network, typically the internet.
  It operates at the application layer and uses the underlying TCP protocol for data transmission.
• HTTPS is designed to provide secure communication by encrypting the data exchanged between the client (such as a web browser) and the server (such as a website).
• It uses SSL/TLS protocols to establish a secure connection, encrypting data to prevent unauthorized access or interception by malicious parties.
• HTTPS is commonly used for secure transactions, such as online banking, e-commerce, and sensitive data transfer, to ensure privacy and data integrity.

In summary, TCP is a lower-level protocol responsible for reliable data transmission, while HTTPS is a higher-level protocol that adds security features, including encryption, to the communication process between clients and servers, typically used in web browsing and secure online transactions.

---

Multiplayer Game Arch

多人网游游戏实现多人同步通常采用以下技术和策略：

• 客户端-服务器架构： 大多数多人网游采用客户端-服务器（Client-Server）架构。客户端负责用户界面和输入，服务器负责游戏逻辑和数据存储，通过网络进行通信。
• 实时通信协议： 游戏客户端和服务器之间使用实时通信协议，如TCP或UDP。TCP提供可靠的数据传输，适用于需要保证数据完整性和顺序性的情况；UDP则提供了更低延迟的传输，适用于实时性要求较高的游戏场景。
• 状态同步： 游戏服务器维护整个游戏世界的状态，并将状态信息发送给所有连接的客户端。客户端接收到状态信息后，更新本地的游戏状态，以保持与服务器同步。
• 差值更新： 为了减少网络带宽和数据传输量，游戏通常采用差值更新（Interpolation）和预测性更新（Prediction）技术。差值更新指的是只发送状态的变化部分，而不是每次发送完整的状态信息；预测性更新则是根据已知信息预测未来的状态，以减少等待服务器响应的时间。
• 客户端端预测： 一些游戏还会在客户端进行预测性计算，比如预测玩家的移动和行为。客户端会先执行这些预测性计算，然后等待服务器的确认或修正。这可以减少延迟并提高游戏的实时性。
• 同步策略： 游戏开发者需要设计合适的同步策略，包括处理网络延迟、解决冲突、处理断线重连等情况。例如，采用插值（Interpolation）和插补（Extrapolation）来平滑处理状态变化，避免突变和卡顿。

综合利用这些技术和策略，多人网游可以实现较好的多人同步效果，保证玩家在游戏中获得良好的体验和互动性。

---

Debug Networking

判断从服务器到客户端导致客户端接收不到更新的问题可以采取以下步骤：

• 网络连接测试： 首先，确保服务器和客户端之间的网络连接是稳定的。可以通过 ping 测试或其他网络诊断工具检查连接是否正常，以及是否存在丢包或延迟等问题。
• 日志和错误信息： 在服务器和客户端的日志中查看是否有相关的错误信息或警告，这可能会指示通信问题或其他异常情况。
• 数据包分析： 使用网络分析工具（如Wireshark）来捕获服务器和客户端之间的数据包，分析数据包的流量和内容，检查是否有丢包、重传、延迟等现象。
• 同步状态检查： 在服务器端和客户端代码中增加日志或调试信息，记录同步状态和数据更新的情况，以便排查是否有数据丢失或错误的情况。
• 版本一致性： 确保服务器和客户端的游戏版本是一致的，不同版本可能导致通信协议不兼容或数据解析错误。
• 网络调试工具： 使用网络调试工具（如Fiddler、Charles等）来监控服务器和客户端之间的通信，检查请求和响应的内容和状态。
• 排除代码问题： 检查服务器端和客户端代码，排除可能导致数据更新失败的代码逻辑或bug，比如数据发送失败、更新频率过低等问题。

通过以上方法结合调试和分析，可以逐步定位问题所在，找出导致客户端接收不到更新的具体原因，并进行相应的修复和优化。

---

问怎么理解粘包，如何解决（完全不懂）

[Timothyoung97]

Security Question

反作弊软件是一种专门设计用于防止游戏作弊行为的软件。它们通常结合了多种技术和策略，旨在监控游戏进程、检测作弊程序，并采取相应的防御措施。下面是反作弊软件通常采取的一些技术和方法：

• 进程监控： 反作弊软件会监控游戏进程的运行情况，包括进程启动、内存访问、文件操作等。通过检测游戏进程的行为，可以发现是否有作弊程序注入或运行。
• 内存扫描： 反作弊软件会对游戏进程的内存进行扫描，检测是否有作弊程序的存在。这包括扫描内存中的代码、数据结构、变量等，以识别作弊行为的迹象。
• 模式识别： 反作弊软件通过模式识别技术来识别作弊程序的特征模式。这可能包括特定的内存结构、代码片段、调用方式等，通过识别这些模式可以发现作弊行为。
• 行为分析： 反作弊软件会对玩家的游戏行为进行分析，比如击杀率、移动速度、射击精准度等。异常的游戏行为可能暗示玩家使用了作弊程序，反作弊软件会对此进行警告或封锁处理。
• 数据校验： 反作弊软件会对游戏数据进行校验，确保数据的合法性和完整性。比如，验证玩家的装备、属性、金币等数据是否合法，防止通过修改数据来作弊。
• 网络监控： 一些反作弊软件还会监控游戏的网络通信，检测是否有非法的网络请求或数据传输。这可以防止通过网络传输作弊数据或指令。
• 黑名单管理： 反作弊软件会维护一个作弊者的黑名单，记录已知的作弊程序、作弊行为及其特征，对于被列入黑名单的玩家采取相应的封锁措施。

总的来说，反作弊软件通过监控、检测、识别和防御等多种技术手段，来防止游戏中的作弊行为，维护游戏的公平性和竞技性。这些技术通常需要不断更新和改进，以应对不断演变的作弊手段和挑战。

[Timothyoung97]

Gameplay Question

游戏3C是指游戏中的三个重要要素，即Character（角色）、Camera（摄像机）和Control（控制）。这些要素在游戏设计和开发中扮演着关键的角色，影响着玩家的游戏体验和游戏的可玩性。

• Character（角色）： 角色是游戏中玩家或AI控制的游戏角色，包括玩家扮演的主角、NPC（非玩家角色）和敌对角色等。角色的设计包括外观、能力、动作、交互等方面，影响着玩家对游戏的情感连接和角色扮演体验。
• Camera（摄像机）： 摄像机是游戏中用于显示游戏场景的视角控制器。摄像机的设计影响着玩家对游戏世界的观察和感知，包括视角选择、视野范围、视角切换、跟随目标等。良好的摄像机设计可以提高游戏的可玩性和沉浸感。
• Control（控制）： 控制是指玩家对游戏角色的操作和控制方式。这包括键盘、鼠标、手柄等输入设备的设计和响应，以及角色的移动、攻击、交互等行为。良好的控制设计可以提高游戏的操作流畅度和玩家体验。

游戏3C的设计需要综合考虑角色的特性、摄像机的视角和控制方式，以提供丰富、流畅、易于操作的游戏体验。良好的游戏3C设计可以增强游戏的沉浸感、可玩性和乐趣，是游戏开发中重要的方面之一。

---

对于设计一个范围性的攻击，可以使用设计模式中的命令模式（Command Pattern）来实现。命令模式可以将请求封装成一个对象，从而允许将请求的发送者和接收者解耦，同时支持对请求的参数化和队列化操作。

以下是使用命令模式设计范围性攻击的一种实现方式：

• 定义命令接口： 首先，定义一个命令接口（Command），其中包含一个执行命令的方法（execute()），以及可能需要的其他方法或属性。例如：

public interface Command {
    void execute();
}

• 实现具体命令类： 创建具体的命令类来实现范围性攻击的逻辑。这个类可以包含攻击的范围、伤害值、效果等信息，并实现命令接口中的执行方法。例如：

public class RangeAttackCommand implements Command {
    private int damage;
    private int range;
    private List<Character> targets;

    public RangeAttackCommand(int damage, int range, List<Character> targets) {
        this.damage = damage;
        this.range = range;
        this.targets = targets;
    }

    @Override
    public void execute() {
        for (Character target : targets) {
            // 对目标造成伤害
            target.takeDamage(damage);
        }
    }
}

• 创建命令发送者： 创建一个命令发送者（Invoker），用于发送命令并执行。发送者可以持有一个或多个命令对象，并在需要时调用其执行方法。例如：

public class Player {
    private Command rangeAttackCommand;

    public void setRangeAttackCommand(Command command) {
        this.rangeAttackCommand = command;
    }

    public void performRangeAttack() {
        if (rangeAttackCommand != null) {
            rangeAttackCommand.execute();
        }
    }
}

• 使用者使用命令模式： 在游戏中，玩家可以选择进行范围性攻击，通过创建具体的命令对象并设置给命令发送者来实现。例如：

// 创建玩家对象和敌人列表
Player player = new Player();
List<Character> enemies = new ArrayList<>();
enemies.add(new Enemy());
enemies.add(new Enemy());

// 创建范围攻击命令并设置给玩家
Command rangeAttack = new RangeAttackCommand(50, 5, enemies);
player.setRangeAttackCommand(rangeAttack);

// 玩家发起范围攻击
player.performRangeAttack();

通过上述设计，使用命令模式可以有效地实现范围性攻击，将攻击请求和执行解耦，并支持灵活的参数化操作，提高了游戏系统的可扩展性和可维护性。

[Timothyoung97]

Game Engine Usage

Perf Optimisation

游戏变得卡顿可能有多种原因，以下从游戏引擎的角度进行分析可能的原因：

• 性能瓶颈： 可能存在性能瓶颈导致游戏卡顿。这些瓶颈可能包括过多的渲染操作（如绘制复杂的场景、大量的特效）、过多的物理计算（如碰撞检测、物体移动）、大量的资源加载（如纹理、模型）、过多的计算操作（如AI计算、动画计算）等。需要通过性能分析工具（如Profiler）来确定性能瓶颈的具体位置。
• 内存管理问题： 如果游戏引擎内存管理不当，可能会导致内存泄漏或内存碎片问题，从而影响游戏的性能。特别是在长时间运行或频繁加载/卸载资源的情况下，内存管理问题可能会更加明显。
• 渲染优化不足： 渲染是游戏中消耗性能最大的部分之一。如果渲染优化不足，比如没有使用批处理、没有合理使用LOD（Level of Detail）技术、没有使用合适的渲染技术（如GPU Instancing、Deferred Rendering）等，都可能导致游戏卡顿。
• 脚本执行效率低下： 如果游戏中使用了大量的脚本（如Lua、JavaScript等），而脚本执行效率低下，会影响游戏的性能。需要对脚本进行优化，比如减少脚本执行的频率、优化脚本代码等。
• 资源管理问题： 资源管理不当也可能导致游戏卡顿。比如资源加载过程中频繁的IO操作、资源未正确释放导致内存占用过高等。
  渲染分辨率和帧率设置： 游戏引擎中的渲染分辨率和帧率设置可能过高，超出了硬件的承载能力，导致游戏卡顿。需要根据目标硬件的性能来调整渲染设置。

综上所述，游戏卡顿可能是由于性能瓶颈、内存管理问题、渲染优化不足、脚本执行效率低下、资源管理问题等多种因素导致的。需要通过性能分析工具和调试工具来定位具体的问题，并采取相应的优化措施来提升游戏的性能和流畅度。

---

Collision

在游戏引擎中判断手雷弹的攻击范围内是否包括敌人通常可以通过碰撞检测和区域检测来实现。以下是一些常见的方法：

• 碰撞检测： 使用游戏引擎提供的碰撞检测功能来判断手雷弹的攻击范围是否与敌人的碰撞体发生碰撞。如果手雷弹的碰撞体与敌人的碰撞体相交或重叠，说明敌人处于攻击范围内。
• 区域检测： 在游戏中可以预先定义攻击范围的区域，比如一个球形或圆形区域。然后使用游戏引擎提供的区域检测功能来检测敌人是否在这个区域内。如果敌人的位置在攻击范围的区域内，说明敌人受到了攻击。
• 射线检测： 使用射线检测来判断手雷弹的攻击范围内是否有敌人。发射一条射线从手雷弹的位置向攻击范围内的方向，检测射线与敌人之间是否存在碰撞。如果射线与敌人发生了碰撞，说明敌人在攻击范围内。
• 网格化检测： 将游戏场景网格化，并在网格中标记手雷弹的攻击范围和敌人的位置。然后通过网格化的方式来检测攻击范围内是否有敌人，这种方法适用于大规模的场景和复杂的碰撞检测需求。

这些方法可以结合使用，根据游戏的具体需求和场景来选择合适的检测方式。例如，在实时性要求高的游戏中，可以使用快速的碰撞检测方法；而在需要精确判断的情况下，可以使用射线检测或区域检测等方法。

---

ECS

ECS（Entity-Component-System）是一种游戏引擎常用的设计模式，它将游戏对象拆分成实体（Entity）、组件（Component）和系统（System），每个部分都有特定的责任和功能。以下是游戏引擎使用ECS设计的一些原因：

• 高度模块化： ECS设计模式将游戏对象分解成独立的组件，每个组件负责特定的功能或特征。这种模块化的设计使得游戏对象的功能更清晰、更易于管理和扩展。
• 松耦合性： 在ECS中，实体（Entity）仅仅是一个标识符，不包含任何具体的行为或数据。组件（Component）则负责实体的功能，而系统（System）则负责管理组件和处理游戏逻辑。这种松耦合的设计使得各个部分可以独立开发、测试和修改，降低了系统的耦合度。
• 性能优化： ECS设计模式可以提高游戏引擎的性能。由于组件是独立的数据结构，系统可以针对特定的组件进行批量处理，减少了数据访问的次数，提高了游戏的运行效率。
• 灵活性和可扩展性： ECS模式使得游戏引擎具有很高的灵活性和可扩展性。通过添加、删除或替换组件，可以轻松地修改游戏对象的行为和外观。同时，可以根据需要添加新的系统来处理特定的功能，而不会影响其他部分的代码。
• 适合大规模项目： 对于大规模的游戏项目，ECS设计模式更加适用。它使得团队可以分工合作，各个部分独立开发，减少了开发过程中的冲突和合并问题。

总的来说，游戏引擎使用ECS设计模式能够提高游戏的性能、灵活性和可维护性，适合于复杂的游戏项目开发和管理。

---

ECS

想象一下你正在开发一个城市建设类的游戏，其中有各种不同类型的建筑物，比如住宅区、商业区、工业区等。你可以使用ECS设计模式来管理这些建筑物。

实体（Entity）： 在游戏中，每个建筑物可以作为一个实体。例如，一个住宅区实体代表一个住宅区建筑物。

组件（Component）： 每种建筑物都有不同的属性和特征，这些可以表示为组件。比如，建筑物可以有“位置”组件表示其在游戏世界中的坐标位置，还可以有“生产力”组件表示其每天产生的资源数量。

系统（System）： 系统负责管理组件和处理游戏逻辑。比如，你可以有一个“建筑物管理系统”，它负责管理所有建筑物的生命周期、资源产出、交互等。另外，你可以有一个“交互系统”，负责处理玩家与建筑物的交互，比如点击建筑物显示详细信息、升级建筑物等。

通过ECS设计模式，你可以轻松地添加新的建筑物类型或调整现有的建筑物属性，而不会影响其他部分的代码。比如，你可以添加一个新的“公园”建筑物类型，只需要创建对应的实体并添加相应的组件即可，而无需修改现有的系统代码。

这样的设计使得游戏开发更加灵活、可扩展，同时也提高了代码的可维护性和可读性，适用于需要管理大量复杂实体和交互的游戏项目。

[Timothyoung97]

Graphics Question

手游通常不使用延迟渲染（Deferred Rendering）的主要原因是出于性能和资源管理的考虑。延迟渲染是一种高级的渲染技术，它能够处理大量的光照和材质细节，但在移动设备上实现延迟渲染可能存在以下挑战：

• 内存消耗： 延迟渲染需要维护大量的缓冲区和纹理，包括G缓冲区、法线缓冲区、深度缓冲区等。这些缓冲区的占用会增加内存消耗，而移动设备的内存资源相对有限，可能无法满足延迟渲染所需的大量内存。
• 性能开销： 延迟渲染需要进行多次渲染通道，包括几何数据的渲染、光照计算、后处理等，这会增加渲染的计算量和性能开销。移动设备的处理能力相对于PC或主机来说较低，可能无法承担延迟渲染带来的性能开销。
• 功耗和发热： 延迟渲染可能需要更多的计算资源和显存带宽，这会增加设备的功耗和发热，降低设备的续航时间和稳定性，不利于移动设备的用户体验。
• 移动设备特性： 移动设备的屏幕分辨率和显示效果相对于PC或主机来说有限，延迟渲染所带来的光照和材质细节可能无法完全体现在移动设备的屏幕上，因此在性价比上可能不划算。

因此，为了在移动设备上获得更好的性能和用户体验，手游通常会选择更轻量级的渲染技术，如提前渲染（Forward Rendering）、简化的光照模型、减少渲染通道等，以确保游戏在移动设备上运行流畅且效果良好。

---

Rendering Techniques used in Genshin Impact For Console
https://www.docswell.com/s/UnityJapan/KWRPQ5-210617-unity-dojo20211mihoyozhenzhongyi#p1

---

Instanced Rendering（实例化渲染）是一种用于优化渲染性能的技术，特别适用于需要大量重复对象的场景，比如在游戏中大量相同模型的渲染。

实例化渲染的优化性能主要体现在以下几个方面：

• 减少绘制调用： 实例化渲染通过将多个相同的对象合并为一个批次进行渲染，减少了绘制调用的次数。传统的渲染方式可能需要为每个对象进行单独的绘制调用，而实例化渲染可以将多个对象合并为一个绘制调用，减少了CPU到GPU之间的通信开销和调用次数。

• 减少顶点数据传输： 实例化渲染可以通过使用实例化数组来存储对象的位置、旋转、缩放等信息，而不是为每个对象单独传输顶点数据。这样可以减少GPU对于顶点数据的读取和传输开销，提高了渲染效率。

• 合并渲染状态： 实例化渲染可以将多个对象的渲染状态合并为一个批次进行渲染，如材质、纹理、光照等。这样可以减少渲染状态的切换和设置开销，提高了渲染效率。

• 利用硬件优化： 实例化渲染是现代GPU硬件支持的特性，可以充分利用硬件的并行处理能力。GPU可以同时处理多个实例化对象的渲染指令，提高了渲染效率和吞吐量。

总的来说，实例化渲染通过减少绘制调用、顶点数据传输、渲染状态切换等开销，充分利用GPU硬件的并行处理能力，从而优化了渲染性能，特别适用于大规模重复对象的渲染场景，如森林中的树木、城市中的建筑等。

[Timothyoung97]

C++ Questions

++i和i++的区别，作为类的成员函数重载时候前置++和后置++有啥区别？

• i++ is post increment, meaning "uses the current value, increment afterwards"
• ++i is pre-increment, meaning "increment on the current value, then use afterwards".

前置++

• 前置++表示先将对象的值加1，然后返回递增后的值。在重载前置++时，一般会返回递增后的对象的引用（指针）。

• 前置++的操作顺序是先执行递增操作，然后再返回递增后的值。

  class MyClass {
  public:
      MyClass& operator++() {
          // 前置++操作，先递增值，再返回递增后的对象
          ++value;
          return *this;
      }
  private:
      int value;
  };
  
  MyClass obj;
  ++obj;  // 使用前置++，递增obj的值
  

后置++

• 后置++表示先返回对象的当前值，然后再将对象的值加1。在重载后置++时，一般会返回递增前的对象的副本（值）。

• 后置++的操作顺序是先返回当前值，然后再执行递增操作。

  class MyClass {
  public:
      MyClass operator++(int) {
          // 后置++操作，先返回当前对象的值，再递增值
          MyClass temp = *this;
          ++value;
          return temp;
      }
  private:
      int value;
  };
  
  MyClass obj;
  obj++;  // 使用后置++，返回obj的值，然后递增obj的值
  

---

指针常量和常量指针

指针常量: pointer-to-const, a pointer that is pointing to an address that holds a constant

• A pointer to a constant is declared using the const keyword before the data type. It means that the pointer itself is not constant, but the data it points to is constant and cannot be modified through that pointer.

• 语法形式为const int* ptr或int const* ptr，表示ptr是一个指向常量int的指针，可以用来指向不同的int变量，但不能通过ptr修改指向的int变量的值。

  const int* ptrToConst;  // Pointer to a constant integer
  int num = 10;
  ptrToConst = #  // Allowed: pointer points to the constant integer 'num'
  *ptrToConst = 20;  // Not allowed: trying to modify the constant integer

常量指针: const-pointer, a constant pointer that cannot change where it is being pointed to.

• A constant pointer is declared using the const keyword after the asterisk (*) in the pointer declaration. It means that the pointer itself is constant, and once initialized to point to a memory location, it cannot be modified to point to another location.

  int* const constPtr;  // Constant pointer to an integer
  int num1 = 10, num2 = 20;
  constPtr = &num1;  // Allowed: constant pointer initialized to point to 'num1'
  constPtr = &num2;  // Not allowed: cannot change the constant pointer to point to 'num2'
  *constPtr = 30;  // Allowed: modifying the value at the memory location pointed by constPtr

---

const修饰成员函数有什么作用

• Const Member Functions and Const Objects:
  When a member function is declared as const, it indicates that the function does not modify the state of the object on which it is called. This is particularly useful when working with const objects, as it ensures that calling a const member function won't change the object's state.

• Const-Correctness:
  Using const with member functions helps enforce const-correctness in your codebase. It makes the intent clear that certain functions are meant to be used with const objects and should not modify object state.

• Accessing Data Members:
  Inside a const member function, you can access data members of the object but cannot modify them unless they are declared as mutable. This ensures that the object's state remains unchanged when calling const member functions.

  class MyClass {
  private:
      int value;
  
  public:
      // Non-const member function
      void setValue(int newValue) {
          value = newValue;
      }
  
      // Const member function to get the value
      int getValue() const {
          return value;
      }
  };
  
  int main() {
      const MyClass obj;  // Creating a const object
  
      // Calling a const member function on a const object is allowed
      int val = obj.getValue();  // This is fine, as getValue() is const
  
      // obj.setValue(10);  // Error: setValue() is not const and cannot be called on a const object
  
      return 0;
  }

• Read-only Access Guarantee. Declaring a member function as const indicates that the function does not modify the object's state. It promises that the function will not change any non-static data members of the class or call any non-const member functions.

• Const member functions can be called on const objects. This allows const objects to access member functions that do not modify the object's state.

  class MyClass {
  public:
      int getValue() const {
          // This function promises not to modify any data members
          return value;
      }
  private:
      int value;
  };
  
  const MyClass obj;
  int val = obj.getValue();  // Allowed, because getValue() is declared const

• Declaring member functions as const helps in detecting accidental modifications to const objects or const references, as the compiler will generate an error if a const member function attempts to modify the object.

  class MyClass {
  public:
      void setValue(int newValue) const {
          // Error: const member function cannot modify data members
          value = newValue;  // Compiler error
      }
  private:
      int value;
  };
  

---

虚函数相关，子类的虚指针和各个成员是如何分布的，虚函数表里是啥样的（难受。。全忘了）

In object-oriented programming with C++ and similar languages, virtual functions and virtual tables (vtables) play a crucial role in implementing polymorphism. Here's an explanation in English:

Virtual Functions and Polymorphism:

• Virtual functions allow derived classes to override base class methods, enabling polymorphic behavior where the appropriate method is called based on the actual object type at runtime.
• When a base class declares a function as virtual, it allows any derived class to provide its own implementation of that function.

Virtual Function Pointer in Subclasses:

• Each instance of a class with virtual functions (including derived classes) typically contains a hidden pointer called the virtual function pointer (vptr).
• The vptr points to a virtual table (vtable), which is an array of function pointers.
  In subclasses, the vptr is typically located at the beginning of the object's memory layout, before any other member variables.

Memory Layout of Subclasses:

The memory layout of a subclass instance includes the following components:

• Virtual function pointer (vptr): Points to the vtable for dynamic dispatch of virtual functions.
• Base class sub-object: Contains the members inherited from the base class.
• Derived class members: Additional members specific to the derived class.

Virtual Function Table (Vtable):

• The vtable is a static array of function pointers maintained by the compiler for each class with virtual functions.
• Each entry in the vtable corresponds to a virtual function declared in the class.
• The vtable is shared among all instances of a class and is typically stored in read-only memory.

Vtable Structure:

• The vtable contains function pointers for each virtual function declared in the class.
• When a subclass overrides a virtual function, the corresponding entry in the vtable is updated to point to the overridden function in the subclass.
• The order of function pointers in the vtable matches the order of virtual functions as they appear in the class declaration.

Dynamic Dispatch:

• When a virtual function is called on an object through a base class pointer or reference, the actual function to be executed is determined at runtime based on the object's dynamic type.
• This dynamic dispatch is achieved by dereferencing the object's vptr to access the appropriate entry in the vtable and then calling the corresponding function.

In summary, virtual functions and vtables allow for runtime polymorphism by enabling dynamic dispatch of function calls based on the actual object type. The vptr in subclass instances points to the vtable, which contains function pointers for virtual functions, facilitating the correct execution of overridden functions in derived classes.

Examples

https://pabloariasal.github.io/2017/06/10/understanding-virtual-tables/

Note that vtables exist at the class level, meaning there exists a single vtable per class, and is shared by all instances.

when a call to a virtual function on an object is performed, the vpointer of the object is used to find the corresponding vtable of the class. Next, the function name is used as index to the vtable to find the correct (most specific) routine to be executed. Done!

Virtual Destructors

#include <iostream>

class Base
{
public:
  ~Base()
  {
    std::cout << "Destroying base" << std::endl;
  }
};

class Derived : public Base
{
public:
  Derived(int number)
  {
    some_resource_ = new int(number);
  }

  ~Derived()
  {
    std::cout << "Destroying derived" << std::endl;
    delete some_resource_;
  }

private:
  int* some_resource_;
};

int main()
{
  Base* p = new Derived(5);
  delete p;
}


// result
// > Destroying base

Making Base’s destructor virtual will result in the expected behavior:

// > Destroying derived
// > Destroying base

---

问vector和list的区别，空间分布上的区别

Vector (std::vector):

• Vector is implemented as a dynamic array that grows or shrinks automatically when elements are added or removed.
• Memory in a vector is allocated as a contiguous block, meaning all elements are stored in adjacent memory locations.
• Insertions and deletions at the end of a vector (push_back, pop_back) are efficient because they involve constant time amortized complexity.
• However, inserting or deleting elements in the middle of a vector requires shifting elements, which can be costly for large vectors.

List (std::list):

• List is implemented as a doubly linked list, where each element contains pointers to the previous and next elements.
• Memory allocation in a list is not contiguous; each element is allocated independently, and they are linked together through pointers.
• Insertions and deletions at any position in a list are efficient because they only require adjusting pointers, not shifting elements.
• However, accessing elements in a list is slower compared to a vector because elements are not stored contiguously, leading to potentially higher cache misses.

In summary, the key differences in space distribution between std::vector and std::list are:

• Vector stores elements in a contiguous block of memory, while list does not have contiguous storage.
• Vector allows efficient access to elements but may incur overhead during insertions and deletions in the middle.
• List supports efficient insertions and deletions at any position but may have slower element access due to non-contiguous storage.

The choice between vector and list depends on the specific requirements of the application, such as the frequency of insertions, deletions, and element access operations.

---

问vector是怎么扩容的

When a std::vector in C++ needs to expand its capacity to accommodate more elements, it follows a process known as reallocation and growth strategy. Here's an explanation in English of how std::vector expands:

• Initial Capacity:
  • When you create a std::vector, it starts with an initial capacity that typically depends on the implementation and system settings. For example, it might start with space for a certain number of elements, like 10.
• Adding Elements:
  • As you add elements to the vector using push_back, it keeps track of the number of elements and compares it to the current capacity.
• Capacity Check:
  • When you attempt to add an element that exceeds the current capacity, the vector needs to expand to accommodate the new element.
• Reallocation and Growth:
  • The vector uses a growth strategy to determine how much to increase its capacity.
  • Common growth strategies include doubling the capacity (e.g., if the current capacity is 10, it may increase to 20), or increasing by a certain percentage (e.g., adding 50% more capacity).
  • The choice of growth strategy can impact performance and memory usage.
  • Doubling the capacity is a common strategy because it provides amortized constant time complexity for push_back operations.
• Copying Elements:
  • To expand the capacity, the vector allocates a new block of memory with the increased capacity.
  • It then copies the existing elements from the old memory block to the new one, ensuring they remain in the same order.
• Deallocating Old Memory:
  • After copying the elements, the vector deallocates the old memory block to free up resources.
  • The new capacity becomes the current capacity, and the vector can continue adding elements without needing to expand again until it reaches the new capacity.

---

问unordered_map的空间复杂度

• Number of Elements (n):
  • Let's denote the number of elements stored in the unordered_map as 'n'. The space complexity directly depends on 'n'.
• Load Factor (LF):
  • The load factor (LF) of an unordered_map is the ratio 'n / b', where 'b' is the number of buckets in the hash table.
  • The load factor determines how full the hash table is. A higher load factor means the hash table is more densely populated with elements.
• Bucket Count (b):
  • The number of buckets 'b' in the hash table is typically larger than or equal to 'n' (the number of elements).
  • Ideally, a good hash function and a suitable load factor ensure that 'b' is proportional to 'n' but not too large or too small, balancing memory usage and performance.
• Space Complexity:
  • The space complexity of an unordered_map can be approximated as O(n) in the worst-case scenario, where every element is stored in a separate bucket.
  • However, due to the hash table's ability to distribute elements across buckets based on the hash values, the average-case space complexity is often better than O(n).
  • The actual space complexity depends on factors such as the hash function's quality, the load factor, and the implementation details of the hash table.

In summary, the space complexity of std::unordered_map is typically O(n) in the worst case, but it can be more efficient in practice due to its hash table implementation, which aims to distribute elements evenly across buckets to optimize memory usage and access times.

---

Wrong implementation

class A
{
    public:
        int &x;
};

• In C++, it's not possible to directly initialize a reference member in the constructor initializer list of a class. References must be initialized at the point of declaration and cannot be re-assigned to refer to a different object once initialized.
• Therefore, the code you provided would result in a compilation error because the reference member int& x in class A is not initialized in the constructor initializer list or at the point of declaration.

class A {
public:
    int& x = someInteger; // Initialized at the point of declaration
};

inline是不是一定会被替换？（一脸懵逼）

vector 特点 resize & reserve （忘记了，二面蒙蔽）

explicit

宏定义

[Timothyoung97]

Round 1

• i++ vs ++i
• C++ smart pointers
• Quick Sort Algorithm
• Deadlock
• Dangling Pointer
• Virtual Function Table
• Path searching algorithm (BFS, DFS, Dijkstra, A Star)
• How to make a car move in game
• Lazy loading of items in game, 3D mesh, Oct tree

Leetcode:
Longest connecting sets of words, last letter must be the same as the first letter of the other word.

[Timothyoung97]

https://blog.csdn.net/techforward/article/details/135956548