This mod adds Mars People from Metal Slug as enemy. This mod is to test 2 ways animations.

They are weak against Acid/Poison (Max 85 resist).

Discord: https://discord.gg/BwWXygyEyQ

ERM – Features Reel: https://www.youtube.com/watch?v=phLRReAjxHA

###Credit:
Code files license under GNU LGPLv3

All graphics and sounds in this mod are properties of SNK Corporation, Metal Slug series. They are used for experimental
purposes. Graphic assets are converted from the sprites in https://retrogamezone.co.uk/metalslug/creatureenemies.htm

• Enemy Race Manager >= 1.15
• Factorio Standard Library >= 1.4.6
• Factorio Base >= 1.1

• Attack: Laser/Explosion

• Attack: Laser

• Attack: Cold (slow movement)

• Attack: Eletric (1 radius AOE)

• Attack: Laser

• Drops Marspeople / Mini UFOs

• Turret, “Exits” structures

• Attack: Fire

• Attack: Physical

• Attack: Laser/Electric (2 radius AOE)

• Attack: Laser/Electric (3 radius AOE) (slow movement)

Physical resistance: 95
Weak elemental resistance: 85
Elemental resistance: 90

The System Paths Clipboard application is an extended clipboard tool that allows users to store, edit, and conveniently use recently copied file paths. By utilizing the keyboard shortcut Ctrl + C, the application saves system paths (Windows/Linux) into a database, enabling users to easily access and paste them later by clicking on the application icon (the application can also be opened with the Ctrl + left Shift shortcut) and searching for the desired path. The most recently copied path (by default, after copying a path, it becomes the selected one for pasting) or a path chosen from the application window can be pasted at any time using the shortcut Ctrl + B. Within the application, paths can be edited. Using a checkbox, users can choose between edit modes (save as a new path / edit). An edited path (or a newly saved one) that matches an existing path is moved to the top of the list and is not added again to avoid duplicates.

• MainWindow: Manages the user interface and serves as the main window of the application.

• KeyListener: Manages keyboard shortcuts and the copying and pasting of content.

• ClipboardManager: Manages clipboard content and acts as a bridge between the UI and the database.

1. Python: Install Python 3.x. You can download Python from python.org.

2. Libraries: Install required libraries using the following command:

   cd project
   pip install -r requirements.txt

   Application required:

   • pynput

   • pyperclip

   • PyQt5

   • PyAutoGui

1. Download the code: Copy the Paths Manager application code.

     git clone https://github.com/ZuzannaZawartka/system-paths-clipboard.git

2. Run from Terminal or Command Prompt:

   • Open a terminal (Linux/Mac) or command prompt (Windows).

   • Navigate to the directory containing the main.py file of the Clipboard Manager application

     cd project

   • Install required libraries

      pip install -r requirements.txt

   • Run the application by entering the command:

     python main.py

1. Launch the application.

2. The application will appear as an icon in the bottom right corner of the screen (Open the application by clicking the icon or using the Ctrl + Left Shift shortcut )

3. Use keyboard shortcuts (e.g., Ctrl+C, Ctrl+B) to manage the clipboard. Each path copied using Ctrl+C will appear in the application window.

4. Add, remove, and edit stored items using the user interface.

• Application Icon: The application icon was obtained from freepik.com Icon designed by zafdesign

A couple of powershell scripts and a gulpfile.

It parses .item files, grabs fields (blob in this case, but can be extended), and generates tangible content items from those fields.

Example: /sitecore/assets/css_asset.item -> /sitecore/assets/css_asset.css

It also does the inverse, when a change is made to the content item, it updates the associated .item file (right now it creates another version of the field in the item).

Example: /sitecore/assets/css_asset.css-> /sitecore/assets/css_asset.item

It only will update the associated files if there has been a change detected and the field content does not match (so you won’t get stuck in an infinite update loop)

The first use case I thought for this was SXA, or the local development of themes for SXA, to help aid the development workflow around assets that will exist in Sitecore itself (css/js etc). I also figure it could be used outside of that, anywhere where you have assets stored in the file system that you will eventually want in Sitecore (media library for example).

Should be as easy as:

1. Clone, download, whatever, just get these files into your project

2. Update the paths.themeSrc and paths.itemSrc variables in the gulpfile.js

3. npm install to get the needed dependencies (yes this is assuming you have node installed on your local machine)

4. gulp default to start the gulp watchers (yellow is a change to an asset, blue is a change to an item)

git clone --recurse-submodules git@github.com:inaos/iron-array.git

Execute the following commands:

  cp conf/pre-commit .git/hooks/

We use inac cmake build-system in combination with different libraries which can be installed using miniconda3. In particular, one can install LLVM from the numba channel, and MKL and SVML from Intel channel in a cross-platform portable way with:

$ conda install 'llvmdev>=13'
$ conda install -c intel mkl-include
$ conda install -c intel mkl-static
$ conda install -c intel icc_rt    # SVML

Note: it looks like recent versions of conda (when using MacOSX at least) have dependency issues when installing the provious packages. You can find a workaround by using mamba instead. You can install mamba with:

$ conda install mamba -n base -c conda-forge

It is worth noting that conda-forge channel should only be used for installing mamba. In particular, I have detected issues when using the llvmdev package in conda-forge!

Beware: currently ironArray only supports LLVM 11. Also, we strongly suggest to use the numba channel with conda/mamba for installing the LLVM package. In particular, we discourage the use of native LLVM libraries in the system (either using apt, brew or any other packager), even if they are installing LLVM 10 (the numba team seems to be doing a great job in packaging).

• INAC build setup

  • Make sure that you have a configured repository.txt file in ~.inaos\cmake
  • Also you’ll need a directory ~\INAOS (can be empty)

• Create a build folder

     mkdir build
     cd build
  

• Invoke CMAKE, we have to define the generator as well as the build-type

     cmake -G"Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Debug ..
     cmake -G"Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
  

• INAC build setup:

  • Make sure that you have a configured repository.txt file in ~/.inaos/cmake
  • Also you’ll need a directory ~/INAOS (can be empty)

• Create a build folder:

     mkdir build
     cd build
  

• Invoke CMAKE, we have to define the build-type:

     cmake -DCMAKE_BUILD_TYPE=Debug ..
     cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
  

• INAC build setup

  • Make sure that you have a configured repository.txt file in ~/.inaos/cmake
  • Also you’ll need a directory ~/INAOS (can be empty)

• MKL setup. For Ubuntu machines, it is best to use Intel’s Ubuntu repo (but you can use conda packages described above too):

     wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
     apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB
     sudo sh -c 'echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list'
     sudo apt-get update && sudo apt-get install intel-mkl-64bit-2019.X
  

• Create a build folder

     mkdir build
     cd build
  

• Invoke CMAKE, we have to define the build-type, but only two types are supported

     cmake -DCMAKE_BUILD_TYPE=Debug ..
     cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
  

• Some Linux machines (ClearLinux, Gentoo?) require the use of llvm-config utility. You can enforce its use with -DDISABLE_LLVM_CONFIG=False::

     cmake -DCMAKE_BUILD_TYPE=Debug -DDISABLE_LLVM_CONFIG=False ..
     cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DDISABLE_LLVM_CONFIG=False ..
  

Sometimes it is useful to activate the tracing mechanism for debugging purposes. Example:

$ env INAC_TRACE='*' ./perf_vector_expression  -e 1 -E 2 -M 3 -t 10 -l 0 -c 9 -f 2
Time for computing and filling X values: 0.0523 s, 2918.5 MB/s
Time for compressing and *storing* X values: 0.106 s, 1434.1 MB/s
Compression for X values: 152.6 MB -> 11.2 MB (13.6x)
Time for computing and filling Y values: 0.0665 s, 2296.2 MB/s
Time for compressing and *storing* Y values: 0.135 s, 1130.3 MB/s
Compression for Y values: 152.6 MB -> 152.6 MB (1.0x)
[iarray.error] - Error compressing a blosc chunk /Users/faltet/inaos/iron-array/src/iarray_expression.c:853
Error during evaluation.  Giving up...

• For now only element-wise operations are supported in expressions.

• The iron-array library supports disabling the SVML optimization by setting a DISABLE_SVML environment variable to any value. This can be useful for debugging purposes.

Language: PT-BR

Here are my studies and experiments using ANTLR4 (for language analysis). The target code in this case is in C++, and for this a base project is used, which can be found here:

• https://github.com/melchisedech333/antlr4-demonstration-project

Just download the project and leave it in the same directory with the experiments.

Note: the base project directory name must be project, so that the test build scripts can work properly.

If my code has helped you, please consider sponsoring me 💙

• Instructions
• Author
• License

To run a test, just run the script clean-and-build.sh or re-compile.sh followed by the name of the test directory, as in the example below.

./clean-and-build.sh "1 - processing tokens (through visitor)"
./re-compile.sh "1 - processing tokens (through visitor)"

After compiling, parsing is immediately executed, where the syntax file existing in the respective directory is passed as a parameter.

Thus, it is possible to change the test Lexer, Parser and Syntax files, as well as the main.cpp file in their respective directories.

Brief description of the scripts:

• clean.sh – Cleans files from previous builds from the base project. Note: this script does not need parameters.
• clean-and-build.sh – Recompiles 100% of the base project.
• re-compile.sh – Compile the base project without having to compile 100% of the project.

Note: the file compiled by the base project is located inside the project directory, with the name parsing.

Sponsor: melchisedech333
Twitter: Melchisedech333
LinkedIn: Melchisedech Rex
Blog: melchisedech333.github.io

BSD-3-Clause license

A bare-bones music player. Intended to utilize a filesystem to browse your music instead of automatically grouping by artist, album or genre. Focused on gesture controls. Supports CUE sheets, M3U playlists and Internet radio.

Minimum supported Android version: 5.0 (Lollipop, API 21)

Here’s what you can do in SonusPresto:

• play music

• browse your music in the way you have structured it, using the filesystem

• play all files in a selected folder and sub-folders recursively

• open CUE sheets and M3U playlists as folders

• gapless playback

• play Internet radio from M3U playlists

• change a visual theme and language (English/Russian)

• control a playback using touch and swipe gestures on a single button

• listen to the audio from the video files

• delete files and folders

Here’s what SonusPresto can’t do:

• view audio tags or cover art

• quickly set a precise playback position

• view the current playback position in seconds

• use a separate buttons to control a playback (i.e. there’s no separate prev/stop/next/… buttons)

• create custom playlists or manage a playback queue

• basically, anything else that is not listed in the “Features” section 🙂

Disclaimer: new features will most likely never be added.

Here are some quirks:

• the swiping of the bottom button may not work on some devices with specific Android gesture settings

• since SonusPresto doesn’t read tags, it can’t determine actual artist and album name of a music track and instead it just uses folder names for that (except for playlist items)

• SonusPresto may not be compatible with LastFM scrobblers, i.e. it will most likely send incorrect info because it does not use tags

• SonusPresto doesn’t know what formats your device supports, so it will just show every file that has any of the supported extensions (i.e. not all displayed files can actually be played)

Download the latest app version here.

SonusPresto is made with Flutter.

To build this application do the following:

1. Download this repository.

2. Install Flutter and Android SDK. It’s easier to do it from Android Studio.

3. At this point you can already debug the application from Android Studio. To build the release version follow the next steps.

4. Go inside the repository root and create the file android/key.properties based on android/key.template.properties. Fill in all fields. For more information see the official “Signing the app” tutorial.

5. To build the release APK run ./build-apk.sh inside the repository root.

GPLv3

React HOC (higher order component) method, and React Hook for transforming
your favorite components to animate prop values on change.

This package uses Tweenkle for handling
the tweening of prop values. It’s not as full-featured as GSAP,
but it works pretty well for basic value and object tweening.

Via npm

npm install --save react-animate-props

Via Yarn

yarn add react-animate-props

react-animate-props now offers two(!) ways for you to animate the props in both
your class-based, and functional, React components.

useAnimateProps

• prop : Number – Value to animate
• options : Object – Options to define the tween properties to use.

Default options:

{
  delay: 0,                           // Delay to apply before the tween starts
  duration: 1000,                     // Duration of the tween in milliseconds
  ease: Easing.Quad.Out,              // Ease to use for the tween, @see [Tweenkle](https://github.com/ryanhefner/tweenkle) for options
  onAnimateProgress: value => value,  // Callback to use during the tweening process, as well as being able to manipulate the value during the tween
  onAnimateComplete: value => value,  // Callback for when the tween has completed, as well as being able to manipulate the final value of the tween
}

import React from 'react';
import { Easing } from 'tweenkle';
import { useAnimateProps } from 'react-animate-props';

const AnimatedNumberLabel = ({ number }) => {
  const animatedNumber = useAnimateProps(number, {
    ease: Easing.Quad.In,
    delay: 500,
    duration: 1500,
    onAnimateProgress: value => {
      return Math.round(value);
    },
    onAnimateComplete: value => {
      return Math.round(value);
    },
  });

  return <span>{animatedNumber}</span>;
};

export default AnimatedNumberLabel;

animateProps is a higher order component
that allows you to easily create components who’s props animate when changed.

Whether you’re writing a new component, or would like to make an animated version
of an existing component, just export your component and pass it through, animateProps.

• component:Class – Class to apply animateProps logic to.

• defaultProps:Object – Default props declared for the component being animated. (Default: {})

• animatedProps:Object – Object defining which props to animate, and the tween
  settings for each. animateProps uses the Tweenkle
  tweening library, specifically a Tween instance, and you can pass whatever props that
  library supports via the tween settings. You can find out more by reading the
  Tweenkle README.

• onAnimateProgress:Function – Callback available to manipulate the prop before
  it is applied to the state. (Example: (prop, value) => { return { [prop]: value }; })

• onAnimateComplete:Function – Callback fired when the animation for a prop completes.
  (Example: (prop, value, tweensActive) => {})

import React, { Component } from 'react';
import PropTypes from 'prop-types';
import animateProps from 'react-animate-props';
import { Easing } from 'tweenkle';

class AnimatedNumberLabel extends Component {
  render() {
    const {
      number,
    } = this.props;

    return (
      <span>
        {number}
      </span>
    );
  }
}

AnimatedNumberLabel.propTypes = {
  animatedProps: PropTypes.object,
  number: PropTypes.number,
  onAnimateProgress: PropTypes.func,
};

AnimatedNumberLabel.defaultProps = {
  animatedProps: {
    number: {
      ease: Easing.Quad.In,
      delay: 500,
      duration: 1500,
    },
  },
  number: 0,
  onAnimateProgress: (prop, value) => {
    return {
      [prop]: Math.round(value),
    };
  },
  onAnimateComplete: (prop, value, tweensActive) => {
    return {
      [prop]: Math.round(value),
    };
  },
};

export default animateProps(
  AnimatedNumberLabel,
  AnimatedNumberLabel.defaultProps
);

MIT © Ryan Hefner

This library allows Standard MIDI Files (SMF) to be read from an SD card and played through a MIDI interface. SMF can be opened and processed, with MIDI and SYSEX events passed to the calling program through callback functions. This allows the calling application to manage sending to a MIDI synthesizer through serial interface or other output device, such as a MIDI shield.

• SMF playing may be controlled through the library using methods to start, pause and restart playback.
• SMF may be automatically looped to play continuously.
• Time ticks are normally generated by the library during playback, but this can be taken over by the user program if different time or synchronization with external MIDI clock is required.

External dependencies:

• SdFat library found here used by the library to read SMF from the the SD card.
• MIDI interface hardware as described in the library documentation or similar, a USB interface with converter or a MIDI shield.

If you like and use this library please consider making a small donation using PayPal

Library Documentation

gobin-info lists your locally installed Go binaries alongside their version and original Git repository.

It’s kind of like a convenience wrapper around go version -m ... with some niceties on top, like vanity URL resolving.

go install github.com/philippgille/gobin-info@latest

You can run gobin-info in several modes:

• gobin-info /path/to/dir lists info about the Go binaries in a given directory (relative or absolute)
• gobin-info -wd lists info about the Go binaries in your working directory
• gobin-info -gobin lists info about the Go binaries in your $GOBIN directory
• gobin-info -gopath lists info about the Go binaries in your $GOPATH/bin directory
• 🚧 gobin-info -path lists info about the Go binaries in your $PATH (not implemented yet)

It prints a (❓) after the URL in case the URL couldn’t be reliably determined.

Note: gobin-info doesn’t recurse into subdirectories. This might be added with an optional flag in the future.

$ gobin-info -gopath
Scanning /home/johndoe/go/bin
arc         v3.5.1  https://github.com/mholt/archiver
gopls       v0.11.0 https://go.googlesource.com/tools
mage        (devel) https://github.com/magefile/mage
staticcheck v0.3.3  https://github.com/dominikh/go-tools

Most of your CLI tools were probably installed with a package manager like apt or dnf on Linux, Homebrew on macOS, or Scoop on Windows. Then if you want to get the list of your installed tools, you can run apt list --installed, brew list or scoop list to list them, and if you want to know more about one of them you can run apt show ..., brew info ... or scoop info ....

But what about the ones you installed with Go? You installed them with go install ... and they live in $GOPATH/bin or $GOBIN or maybe you move/symlink them to /usr/local/bin or so.

• Now you don’t immediately know the origin of the tools. For example if there’s a binary called arc, is it github.com/mholt/archiver/v3/cmd/arc or github.com/evilsocket/arc/cmd/arc?
• You could run arc --help and it might give a hint what exactly it is, but it’s not reliable
• Or you run go version -m /path/to/arc and among the dozens of output lines you check the path or mod
  • But their values are not https://-prefixed, so you can’t click them in your terminal and have to copy paste them into your browser
  • Then for example arc has the module path github.com/mholt/archiver/v3, which leads to a 404 Not Found error on GitHub because of the v3
  • And for staticcheck the module path is honnef.co/go/tools, which is a vanity URL that doesn’t point to the original Git repository (https://github.com/dominikh/go-tools) and the browser also doesn’t redirect to it

gobin-info makes all of this much easier.