灵动 MC 的官方网站 2.1.2 版

LightingMC 2.1.2

部署实例： https://minecraft.neboer.site

灵动 mc 是一个 Minecraft 公益服务器，成立于 2015 年。我们专注于原版的生存体验，并紧跟游戏版本更新。
服务器里有专门的技术人员和管理团队，我们拥有有爱的玩家社区，完善的服务器生态。
灵动 mc 专注于公益服，并且会始终积极推动 Minecraft 社区的发展！

我们致力于为广大玩家提供新鲜、活力、安全、有趣的 minecraft 游戏体验，在玩家共同的努力下，让多人原版生存也可以激动人心！

Vue3，纯前端，静态页面。

没有使用框架和组件库，所采用的依赖有

• Vue3
• Vite工具
• fontawesome
• lightgallery
• vuepress

在部署之前需要进行配置，配置的具体步骤如下：

首先，确定部署的目标网站名称，比如 https://minecraft.neboer.site ，作为网站的前缀，这个前缀简写成<prefix>。

1. 修改src/config.json，将imageBedPrefix改成<prefix>/img
2. 修改src/config.json，将docHomepage改成<prefix>/doc
3. 修改docs/src/.vuepress/config.js，将base改成/doc/
4. 修改docs/src/.vuepress/config.js，将themeConfig.nav[0].link改成<prefix>

站点部署在 https://minecraft.neboer.site 上，此设置可以通过配置文件调整。

1. 在当前目录下执行 yarn build，生成/dist。
2. 在/docs下执行yarn build，生成/docs/src/.vuepress/dist
3. 在部署目录下新建根路径<root-folder>/，这个是 Web 的根目录。
4. 将/dist/内的全部内容递归拷贝到<root-folder>/下。
5. 新建文件夹<root-folder>/doc，将/docs/src/.vuepress/dist内全部内容拷贝到<root-folder>/doc/下。
6. 新建文件夹<root-folder>/img，将/src/assets/images/gallery/内的两个文件夹ori和thumbnail拷贝到<root-folder>/img/下。
7. 将静态文件目录<root-folder>部署到目标站点。

src/assets目录下的内容并未提供，但你可以在 https://minecraft.neboer.site 上获取。

本网站 https://minecraft.neboer.site 基于GPL-3.0协议开源，其中的内容（文字和图片）以CC-BY协议发布。

Note: this repository is infrequently maintained.

Prerequisite: NPM and Node.js

• Install via Git Clone

  • git clone https://github.com/salesforce/refocus-collector.git
  • cd refocus-collector
  • npm install
  • npm link
  • try command refocus-collector or refocus-collector --help

  Usage: refocus-collector [command] [options]

Start collector for name, refocus url, API token, proxy for refocus and proxy for data source. refocusProxy and dataSourceProxy are optional arguments
start --collectorName --refocusUrl --accessToken --refocusProxy --dataSourceProxy

Stop given collector
stop  --collectorName --refocusProxy

Show status of collector
status  --collectorName --refocusProxy

Deregister given collector
deregister  --collectorName --refocusProxy

Reregister given collector. refocusProxy is an optional argument
reregister  --collectorName --refocusUrl --accessToken --refocusProxy

Display help for [cmd]
help [cmd]

Options:

-n, --collectorName     specify the name of the collector
-h, --help     output usage information
-V, --version  output the version number

Examples:

$ refocus-collector --help
$ refocus-collector start --collectorName=PRD_Collector_12345 --refocusUrl=https://refocus.foo.com --accessToken=eygduyguygijfdhkfjhkfdhg --refocusProxy=http://abcproxy.com --dataSourceProxy=http://xyzproxy.com
$ refocus-collector stop --collectorName=PRD_Collector_12345
$ refocus-collector status --collectorName=PRD_Collector_12345
$ refocus-collector deregister --collectorName=PRD_Collector_12345
$ refocus-collector reregister --collectorName=PRD_Collector_12345 --refocusUrl=https://refocus.foo.com --accessToken=eygduyguygijfdhkfjhkfdhg --refocusProxy=http://abcproxy.com

• Introduction to Collectors
• Introduction to Sample Generators

• 1.1.1
  • Simplify the heartbeat payload – send up all the process info, not just delta from last heartbeat
• 1.2.0
  • Reuse authentication token among generator clones until it expires.

Unity Package that provide easings functions, to specify the rate of change of a parameter over time.

Objects in real life don’t just start and stop instantly, and almost never move at a constant speed. When we open a drawer, we first move it quickly, and slow it down as it comes out. Drop something on the floor, and it will first accelerate downwards, and then bounce back up after hitting the floor. This package provide functions to implement that.

You can visualize the different easing functions that have been implemented in this repo with this website : easings.net.
Here is a preview :

You can be install this package via the Unity Package Manager (UPM). In the top left of the Packages window, navigate to Add Package -> Add package from git URL and paste https://gitlab.com/Eyap/gamelibrary.easings.git.

For the documentation please read Easings.md.

Initial work of the easing functions made by Antony Woods (teamwoods.org), provided under the DWTFWT Public License.

This package is released under the MPL-2.0 License, see LICENSE.md.

War Of Independence-1971 (WOI-1971) is an SDL-based action game written in C language. Simple, clear, and easily customizable code made this game distinctive. Based on the Bangladeshi people’s war of independence against Pakistani military forces in 1971. The bravery of the Bangladeshi Freedom Fighters is honored with great reverence in this game.

1. Downloading the Game Resources: Download directly on your linux device (Ubuntu based or similiar) as zip or using “git clone” https://github.com/AbdullahArean/WOI-1971
2. Installing in the Device: Go to “WOI-1971” Folder (Newly Cloned or downloaded) through Terminal and run the following command

        ./install.sh

3. Play and enjoy the game Give The Following command

    ./WOI-1971 

or,

    make play

1. Download: You can directly download the following script and run it in our device (Debian-based).No Prerequisite Needed. https://drive.google.com/uc?export=download&id=1i8SkAuo6q7Sa-TxaRrtHTkzQQLEEKnMv

2. Install & Run: Go to Download Folder and Open Terminal and Type The Following:

  chmod +x gameinstall.sh && ./gameinstall.sh

The story behind the game is about the War of Independence of Bangladesh in 1971. The Hindu-Muslim communal tensions fanned by the British colonial rulers to perpetuate their hold on India had led to the partition of India in 1947. Pakistan was created as a separate homeland for Muslims. The Province of East Pakistan was physically separated from West Pakistan by a thousand miles. Pakistan, therefore, was an unrealistic state from the very beginning. The Pakistani ruling elite controlled by the military elite subjugated the Bengalis politically, culturally and economically and therefore the disillusionment with the new nation was not surprising. In the first-ever national Parliamentary elections held in 1970 based on a one-man-one-vote basis, the Bengali nationalist forces led by Bangabandhu Sheikh Mujibur Rahman won a landslide victory and his party, the Awami League became the majority party in the whole of Pakistan. However, in an attempt to crush this nationalistic movement, the Pakistani Military Junta unleashed a systematic genocide against the Bengali people on the fateful night of March 25, 1971. The Junta received support only from a handful of religion-based local parties and religious fundamentalists. Then the war began. The Hero of this game is a freedom fighter named “Aresan” whose objective is to free Bangladesh from the Pakistani Military Junta. Gamers will try to kill all of them while not hurting any innocent Bengali. The enemies will also fire and if the bullet touches the hero, the health will decrease. If a Gamer kills a certain number of Military (earns a certain number of points), he will conquer that place and the next battle place will be unlocked. In this game, the battle place would be many historical places of Bangladesh. So the main objective of the gamer in a word is “Freeing the Bengalis” as well as “Freeing Bangladesh”.

1. Making an simple yet interesting action game on Bangladesh War of Independence 1971, tributinng the freedom fighters
2. Attractive graphics and animation along with interactive sound
3. Well organized and documented code to easily understand and further development

1. Simple, clear and easily customizable code in a structured and modularized manner with proper commenting.
2. Easy installation in Debian-Based Computers and one-click installation process Direct Install and Play (bash script will download everything required)
3. Memory efficient design and Same performance in every device (if possible to play)
4. One Command Game update & upgrade to the latest release feature with “./update.h command”
5. A Loading page with the game logo (Custom Created)
6. Attractive and dynamic menu options to control the game
7. Showing Instructions on the created window
8. Challenging Levels with Multiple Enemy Types
9. Here are Innocent People too. If the hero kills them, he will get a penalty. And There is also an interesting feature, that players have shields, which will protect it from firing damage.
10. Crispy Sound System Specifications and sound on/off feature
11. There is also a Story page where we can see and learn about some stories related to our independence war.
12. Simple yet interesting game logic and 100% control
13. Powerful hero and its simultaneous health and game-score update and display
14. Displaying High Score on the created window
15. A last page is designed to get Usernames(i.e. who is playing) by clicking the “Save Score” option 16.Online presence of code with powerful GitHub Repository with informative Readme.md. Clean GitHub Workflow with best practices of git.

1. main.cpp : Calling a struct Game variable and using its functions init(), running(), handleEvents(), update(), and render() in the main() function for initializing, running loop, handling the events, updating the game and game objects and rendering the objects respectively. Moreover, we are quitting the game by calling the destroy_window() function from the ‘Game’ structure.
2. bullet.h :A structure for bullets of the player with two functions “Bulletfire” and “update”. Bullet first time rendered in Bulletfire function. In the update function, bullet position changes, and all the enemies, tanks and innocent is checked if hit by the bullet or not. After that update of player health, score, enemy health executed accordingly.
3. ebullet.h :A structure for bullets of the enemy (enemy & tank) with two functions “Bulletfire” and “update”. Bullet first time rendered in Bulletfire function. In the update function, bullet position changes, and the player is checked if hit by the bulet or not. After that update of player health, the score executed accordingly.
4. clean.h :Destroying window and renderer by using the function Clean() and quitting all the subsystems such as video, audio, image, font.
5. constants.h :All the constants and SDL-related directory is linked there, and building c preprocessors. For this reason, these include does not need to do in the rest of the files, we used constants.h .
6. game.h :This file contains game structure with four major functions, initialization, handle events, update, render where many header files are included and many functions are called. checker function if game is running is to easily access the game state.
7. gameplay.h :Here “gameplay.h” is the main header file with multiple functions, that truly makes the gameplay. All the necessary files are included here and called here. Player, enemy, tank, innocent is called here according to game logic. Level-wise distribution of work will be found here.
8. player.h :Player structure denoting the main character of the game, render, draw and update the player. There is also shield maintenance. If the shield is on it is displayed. Player movement can be done along all the direction. Flexible player position input and render made the game more interesting. There is also a function to return the position of the Player.
9. enemy.h :A structure is made for rendering and loading the enemy as well as keep track of its position and velocity.
10. tank.h :In this section, the tank is being rendered and loaded. Moreover, Kept the tracking of the tank’s current position along with its velocity.
11. innocent.h :These three structures are the same type of function with slight differences, quite similar to player.h, they have their own function to init, render, handle events and update themselves. it can return its position and update its health accordingly. This function enables us to access its private variable can be accessed from any file easily
12. texturemanager.h :Loading textures and rendering them in this section made easy by this header file. One line code now can do a lot of works.
13. sound.h :Some sound-related variables and some built-in functions related to the sound/audio system have been used to control the sound system.
14. mainmenu.h :There are Continue, New Game, Highest Score, Settings and Story options in the main menu which are rendered and updated there.
15. last page.h :The header is used to render and update the Replay, Next Level, Save Score and Exit buttons in the last page.
16. highscore.h :The code for showing the top 5 scores has been implemented in this section by calling high() function.
17. pause.h :Rendering and updating the Continue, Exit and Main Menu options.
18. settings.h :Controlling the sound system by using logic and can go back to the main menu.
19. instruction.h :This header has been implemented to show the instructions and congratulations messages on the created window.
20. font.h : A FontManager structure is created to load the font and display them on the created window by using two different functions.
21. initialization.h :Initialized all the subsystems used in the whole game(i.e. audio, image, font etc).
22. install.sh :Simple bash scripting file to install of the game along with the dependencies . SDL2 Library and Github will be installed if not in the Linux device and Will Clone the remote github repository, then build the project making an executable “WOI-1971” file.
23. update.sh :Simple bash scripting file to install the latest update of the game project. The github repository is the main source now. the file will discard all the changes user made to the code and will pullall the latest changes developer made in the main github repository.

1. Abdullah Ibne Hanif Arean Linkedin Profile Roll No: FH-12 (Reg. No: 2019-917-795), Team Leader

   1. Graphics Designing (Inkscape, Photoshop, Blender)
   2. Version Control (Git/GitHub)
   3. Logic design and implementation
   4. Structured Game Source Code Writing in C
   5. Page Showing Code, Dynamic Menu, Character Coding
   6. Game Deployment & update

2. Mehadi Hasan Roll No: SH-60(Reg. No: 2019-517-843), Team Member

   1. Logic Design
   2. Structured Game Source Code Writing in C
   3. Font, File Handling, Sound, Instruction Coding
   4. Code Testing and Bug Fixing

• C/C++ – Basic coding of the game done in c!
• VS Code – Free. Built on open source yet powerful IDE!
• SDL2 – cross-platform development library designed to provide low level access!
• Inkscape – professional quality vector graphics software and open source!
• Git/GitHub – software development and version control using Git!
• Bash– Unix shell and command language
• Markdown – lightweight markup language for creating formatted text!

1. Movement of the characters donot have attractive animation, graphics is yet to be developed
2. As it is written in C only, no upgraded feature of c++ is available
3. Written in C,in structured manner, no object oriented code written or used.
4. Replay of the game still to develop

The War of Independence is a great event in the national history of Bangladesh. There are a few games developed on this event though 50 years passed of our independence. It is high time we made a stunning game on this event and made the world aware of the heroism of the Bangladeshi people in 1971. The game will be developed in a 2D SDL2/C++ initially for the project, but we have aspirations to make it across all platforms(Android, IOS, Windows) 3D game using the power of Unreal Engine, Unity, Autodesk, Blender etc. later on.

https://github.com/AbdullahA971rean/WOI-1971

https://sourceforge.net/projects/woi-1971/

https://www.facebook.com/War-Of-Independence-1971-104790995115376

https://lazyfoo.net/tutorials/SDL/ https://www.packtpub.com/product/sdl-game-development/ https://www.parallelrealities.co.uk/

https://www.freepik.com/

Free Software, Hell Yeah!

Apart from learning new language and technology,this game-project taught us collaboration, pressure handling, peer communication and many other important qualities a software enginner should have. I hope we could implement these learning in our life in future.

GenBerry is a shell script which provide a minimal gentoo image for Raspberry Pi 0, 0W 1B, 2B, 3B, 3B+ and 4B in 32 or 64 bit version. You can see it as a bootable and usable stage4 image. The other boards have not been tested yet. By default, you will have the latest kernel and stage3. It can also use qemu in order to performs further installation and configuration tasks.

You can install the system directly on a or build an to put on several card or build a to share on a network.

You can customize it with hostname, keyboard layout, timezone, kernel config, config.txt and filesystem type. You can also enable the communications or the .

You can use it with any Linux distribution, BSD or macOS X except for functions requiring qemu which need a gentoo based system.

Take a tour on the (always a wiP) for more specific documentation.

• An internet connection
• A crossdev environment to compile the kernel:
  • aarch64-linux-gnu (rpi 3, 3+, 4)
  • armv7a-linux-gnueabihf (rPi 2, 3, 3+, 4)
  • armv6j-linux-gnueabihf (rpi 0, 0W, 1)
• qemu static installed and packaged (optional: here you need a gentoo based system)

You have to clone the repository and switch to the root of the project:

git clone https://github.com/dervishe-/GenBerry.git
cd ./GenBerry

GenBerry comes with several configuration files located in the GenBerry/Configs directory. As GenBerry needs those files to perform its tasks, if you want to execute it outside de GenBerry directory you will have to specify the Configs directory location .

You can use the to configure the script or directly with CLI options.

There are two types of options, the short ones which take an argument and the long ones without any arguments

• Create a simple sdcard for rpi4 on /dev/mmcblk0:

sudo ./GenBerry

• Create an image for rPi 3B+ in 32 bit mode with f2fs and the kernel sources:

sudo ./GenBerry --build-image -M 32 -f f2fs -b 3P --add-kernel-src

This will generate a GenBerry_3P-32.img file in the work dir.

• -M 32 means select 32 bit mode
• -f f2fs means use f2fs as filesystem for the root partitions (instead of ext4)
• -b 3P means build for raspberry Pi 3B+

You can use this image after, this way:

sudo dd if=GenBerry_3P-32.img of=/dev/yoursdcard status=progress

Once your card is ready, plug it in you Pi and boot. Then you have two possibilities:

• If you used qemu options, well, just do what you want. There’s nothing more to do :).
• If you didn’t used qemu options, your pi will execute a firstRun.start script located in /etc/local.d/ The content of this script is available . Basically, it will run udhcpc on eth0, sync the time, emerge dhcpcd, and wpa_supplicant if wlan0 exists, delete itself and reboot.

BEWARE: This part of the first boot could be very very long depending of your board as firstRun.start emerge some packages. Let the things go quietly at its end 😉 You can follow live what’s going on with the log file (tail -f …)

After this reboot, your pi will be available thrue eth0 or wlan0 if you gave a wpa_supplicant.conf in option.

Do not hesitate to fill a ticket if you have suggestions, bug reports, found the documentation not clear, or saw english faults (as you can read, my english is far from perfect 😉 )

• https://wiki.gentoo.org/wiki/Raspberry_Pi
• https://wiki.gentoo.org/wiki/Raspberry_Pi_3_64_bit_Install
• https://wiki.gentoo.org/wiki/Raspberry_Pi4_64_Bit_Install
• https://www.raspberrypi.org/documentation/linux/kernel/building.md
• https://www.raspberrypi.org/documentation/configuration/config-txt/boot.md
• https://www.framboise314.fr/le-port-serie-du-raspberry-pi-3-pas-simple/
• https://socialcompare.com/fr/comparison/raspberrypi-models-comparison
• http://wiki.openmoko.org/wiki/USB_Networking
• https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html#ARM-Options
• https://wiki.gentoo.org/wiki/GCC_optimization
• https://developer.arm.com/architectures/instruction-sets/floating-point
• https://ownyourbits.com/2018/06/13/transparently-running-binaries-from-any-architecture-in-linux-with-qemu-and-binfmt_misc/

• Change partitions scheme
• Silent mode
• Update kernel helper
• Boot on USB
• For Pi4 activate USB attached SCSI
• Install the script
• Access point template
• Better sources managment for the rpi firmwares
• Add possibility to use systemd

Of course, this script is given without any warantly. Use it at your own risks.

• The logo is from Luis Espinosa

A TUI (Text User Interface) for Managing and Searching with Meilisearch from the terminal.

⚠️This project has been archived and is no longer supported

Installing with pipx is recommended.

pipx install meilisearch-tui

Alternatively Meilisearch TUI can be installed with pip.

pip install meilisearch-tui

Start the TUI by running

meilisearch

If you are using Meilisearch v1.7.0+ you can optionally use hybrid search by starting by passing the -h or --hybrid-search flag.

meilisearch -h

The first time you start the app you will need to enter the server address and master key (if using one) into the configuration. If the MEILI_HTTP_ADDR and/or MEILI_MASTER_KEY environment variables are set, these values will be used for the meilisearch_url and master_key.

If you have not already created an index and loaded data, first add an index on the Add Index tab of the Index Management screen. Then data can be loaded from the ‘Load Data` tab.

To search, click on the index in the sidebar you want to search on, by default the first index will be selected. Then type the desired search.

Contributions to this project are welcome. If you are interested in contributing please see our contributing guide

Communicate with your Apple Watch apps over the React Native bridge.

Note: This library does not allow you to write your Apple Watch apps in React Native but rather allows your RN iOS app to communicate with a watch app written in Obj-C/Swift. If you want to build a Wear OS app using react-native refer to react-native-wear-connectivity.

http://mtford.co.uk/react-native-watch-connectivity/

The featured screenshot is from the example app. To run the example:

git clone https://github.com/mtford90/react-native-watch-connectivity.git
cd react-native-watch-connectivity/example
yarn install
cd ios
pod install
cd ..
yarn ios # Run app
open ios/RNWatchExample.xcworkspace # Run watch app from Xcode

npm install react-native-watch-connectivity --save
# or
yarn add react-native-watch-connectivity

Note: this library now supports autolinking for RN 0.60+.

For RN <0.60 link via:

react-native link

Or else add the xcodeproj or .h/.m files directly to your project via XCode

Or you can link the library manually by adding node_modules/react-native-watch-connectivity/ios/RNWatch.xcodeproj to your project and ensuring that libRNWatch.a is present in the Link Binary With Libraries build phase.

Alternatively, if you’re using CocoaPods, you can add the following to your Podfile:

pod 'RNWatch', :path => '../node_modules/react-native-watch-connectivity'

and run pod install.

This library has been successfully used in Expo apps (Bare Workflow with EAS Build).

The Amazon Customer Reviews Dataset is a large dataset with size > 20GB.
However, for this analysis, I’ve used a subset of this dataset named
“amazon_reviews_us_Beauty_v1_00.tsv”

marketplace: 2 letter country code of the marketplace where the review was written.

customer_id: Random identifier that can be used to aggregate reviews written by a single author.

review_id: The unique ID of the review.

product_id: The unique Product ID the review pertains to. In the multilingual dataset the reviews for the same product in different countries can be grouped by the same product_id.

product_parent: Random identifier that can be used to aggregate reviews for the same product.

product_title: Title of the product.

product_category: Broad product category that can be used to group reviews
(also used to group the dataset into coherent parts).

star_rating: The 1-5 star rating of the review.

helpful_votes: Number of helpful votes.

total_votes: Number of total votes the review received.

Vine: Review was written as part of the Vine program.

verified_purchase: The review is on a verified purchase.

review_headline: The title of the review.

review_body: The review text.

review_date: The date the review was written.

This library allows you to send and receive simple command messages via Bluetooth Low Energy.

Messages are sent as Bluetooth advertisement packets – no active connection or pairing is required.

• 128bit AES encryption: All messages are transmitted encrypted using 128bit AES encryption.
• NONCE: Each message contains a random NONCE value that increases the entropy of the encrypted message.
• Rolling code: Each message is provided with a rolling code to prevent replay attacks.

A receiver can (theoretically) manage up to 65,536 different remote controls and process 4,294,967,296 different or 32 simultaneous commands (the interpretation is left to the application / user).

Currently this library is neither registered with Arduino nor PlatformIO and therefore has to be installed / included manually.

Download the repository as a ZIP file. Then select Sketch / Include Library / Add .ZIP library... in the ArduinoIDE menu and select the downloaded ZIP file.

Add the following to your platformio.ini:

lib_deps = 
  https://github.com/sivar2311/ESP32-BLE-RemoteControl.git

This library depends on NimBLE-Arduino.

This chapter needs to be recreated as there have been fundamental changes. Until then, please have a look at the examples.