Notifications are used to inform users on specific events in the system. ASP.NET Boilerplate provides a pub/sub based real time notification infrastructure.
There are two ways of sending notifications to users:
There are also two types of notifications:
A notification generally include a notification data. For example: "Notify me if a user sends me a friendship request" notification may have two data properties: sender user name (which user sent this friendship request) and request note (a note that user did write in the request). It's obvious that the notification data type is tightly coupled to notification types. Different notification types have different data types.
Notification data is optional. Some notifications may not require a data. There are some pre-defined notification data types those can be enough for most cases. MessageNotificationData can be used for simple messages and LocalizableMessageNotificationData can be used for localizable and parametric notification messages. We will see example usage in later sections.
There are 5 levels of notification severity, defined in NotificationSeverity enum: Info, Success, Warn, Error and Fatal. Default value is Info.
See Notification Store section for more information on notification persistence.
INotificationSubscriptionManager provides API to subscribe to notifications. Examples:
public class MyService : ITransientDependency
{
private readonly INotificationSubscriptionManager _notificationSubscriptionManager;
public MyService(INotificationSubscriptionManager notificationSubscriptionManager)
{
_notificationSubscriptionManager = notificationSubscriptionManager;
}
//Subscribe to a general notification
public async Task Subscribe_SentFrendshipRequest(long userId)
{
await _notificationSubscriptionManager.SubscribeAsync(userId, "SentFrendshipRequest");
}
//Subscribe to an entity notification
public async Task Subscribe_CommentPhoto(long userId, Guid photoId)
{
await _notificationSubscriptionManager.SubscribeAsync(userId, "CommentPhoto", new EntityIdentifier(typeof(Photo), photoId));
}
}
First, we injected INotificationSubscriptionManager. First method subscribe to a general notification. User wants to get notified when someone sends a friendship request. Second one subscribes to a notification related to a specific entity (Photo). User wants to get notified if anyone write comment to a specified photo.
Every notification type should have unique names (like SentFrendshipRequest and CommentPhoto in the samples)
INotificationSubscriptionManager has also UnsubscribeAsync, IsSubscribedAsync, GetSubscriptionsAsync... methods to manage subscriptions.
INotificationPublisher is used to publish notifications. Examples:
public class MyService : ITransientDependency
{
private readonly INotificationPublisher _notiticationPublisher;
public MyService(INotificationPublisher notiticationPublisher)
{
_notiticationPublisher = notiticationPublisher;
}
//Send a general notification to a specific user
public async Task Publish_SentFrendshipRequest(string senderUserName, string friendshipMessage, long targetUserId)
{
await _notiticationPublisher.PublishAsync("SentFrendshipRequest", new SentFrendshipRequestNotificationData(senderUserName, friendshipMessage), userIds: new[] { targetUserId });
}
//Send an entity notification to a specific user
public async Task Publish_CommentPhoto(string commenterUserName, string comment, Guid photoId, long photoOwnerUserId)
{
await _notiticationPublisher.PublishAsync("CommentPhoto", new CommentPhotoNotificationData(commenterUserName, comment), new EntityIdentifier(typeof(Photo), photoId), userIds: new[] { photoOwnerUserId });
}
//Send a general notification to all subscribed users with a specified severity level
public async Task Publish_LowDisk(int remainingDiskInMb)
{
//Example "LowDiskWarningMessage" content for English -> "Attention! Only {remainingDiskInMb} MBs left on the disk!"
var data = new LocalizableMessageNotificationData(new LocalizableString("LowDiskWarningMessage", "MyLocalizationSourceName"));
data["remainingDiskInMb"] = remainingDiskInMb;
await _notiticationPublisher.PublishAsync("System.LowDisk", data, severity: NotificationSeverity.Warn);
}
}
In the first example, we published a notification to a single user. SentFrendshipRequestNotificationData should be derived from NotificationData like that:
[Serializable]
public class SentFrendshipRequestNotificationData : NotificationData
{
public string SenderUserName { get; set; }
public string FriendshipMessage { get; set; }
public SentFrendshipRequestNotificationData(string senderUserName, string friendshipMessage)
{
SenderUserName = senderUserName;
FriendshipMessage = friendshipMessage;
}
}
In the second example, we sent a notification to a specific user for a specific entity. Notification data classes don't need to be serialzable normally (since JSON serialization is used by default). But it's suggested to mark it as serializable since you may need to move notifications between applications and may want to use binary serialization in the future. Also, as declared before, notification data is optional and may not be required for all notifications.
Note: If we publish a notification to specific users, they don't need to be subscribed to those notifications.
In the third example, we did not define a dedicated notification data class. instead, directly used built-in LocalizableMessageNotificationData with dictionary based data and published notification as 'Warn'. LocalizableMessageNotificationData can store dictionary-based arbitrary data (this is also true for custom notification data classes since they also inherit from NotificationData class). We used "remainingDiskInMb" as argument on localization. Localization message can include these arguments (like "Attention! Only {remainingDiskInMb} MBs left on the disk!" in the example). We will see how to localize it in the Client Side section.
IUserNotificationManager is used to manage notifications of users. It has methods to get, update or delete notifications for a user. You can use it to prepare a notification list page for your application.
While you can use IUserNotificationManager to query notifications, we generally want to push real time notifications to the client.
Notification system uses IRealTimeNotifier to send real time notifications to users. This can be implemented with any type of real time communication system. It's implemented using SignalR in a seperated package. Startup templates have already SignalR installed. See SignalR Integration document for more information.
Note: Notification system calls IRealTimeNotifier asynchronously in a background job. So, notifications may be sent with a small delay.
ASP.NET Boilerplate triggers a global event in the client side. You can register like that to get notifications:
abp.event.on('abp.notifications.received', function (userNotification) {
console.log(userNotification);
});
abp.notifications.received event is triggered for each received real time notification. You can register to this event as shown above to get notifications. See javascript event bus documentation for more information on events. An example incoming notification JSON for "System.LowDisk" example:
{
"userId": 2,
"state": 0,
"notification": {
"notificationName": "System.LowDisk",
"data": {
"message": {
"sourceName": "MyLocalizationSourceName",
"name": "LowDiskWarningMessage"
},
"type": "Abp.Notifications.LocalizableMessageNotificationData",
"properties": {
"remainingDiskInMb": "42"
}
},
"entityType": null,
"entityTypeName": null,
"entityId": null,
"severity": 0,
"creationTime": "2016-02-09T17:03:32.13",
"id": "0263d581-3d8a-476b-8e16-4f6a6f10a632"
},
"id": "4a546baf-bf17-4924-b993-32e420a8d468"
}
In this object;
Surely, you will not just log the notification. You can use notification data to show notification information to the user. Example:
abp.event.on('abp.notifications.received', function (userNotification) {
if (userNotification.notification.data.type === 'Abp.Notifications.LocalizableMessageNotificationData') {
var localizedText = abp.localization.localize(
userNotification.notification.data.message.name,
userNotification.notification.data.message.sourceName
);
$.each(userNotification.notification.data.properties, function (key, value) {
localizedText = localizedText.replace('{' + key + '}', value);
});
alert('New localized notification: ' + localizedText);
} else if (userNotification.notification.data.type === 'Abp.Notifications.MessageNotificationData') {
alert('New simple notification: ' + userNotification.notification.data.message);
}
});
To be able to process notification data, we should check the data type. This example simple gets message from notification data. For the localized message (LocalizableMessageNotificationData), we are localizing the message and replacing parameters. For simple message (MessageNotificationData), we directly get the message. Surely, in a real project, we will not use alert function. We can use abp.notify api to show nice UI notifications. Startup templates include the code to show UI notifications when a push notification is received.
Notification system uses INotificationStore to persist notifications. This should be implemented in order to make notification system properly working. You can implement it yourself or use module-zero which already implements it.
You don't have to define a notification before usage. You can just use any notification name without defining it. But, defining it may bring you some additional benefits. For example, you can then investigate all notifications in your application. In this case, we can define a notification provider for our module as shown below:
public class MyAppNotificationProvider : NotificationProvider
{
public override void SetNotifications(INotificationDefinitionContext context)
{
context.Manager.Add(
new NotificationDefinition(
"App.NewUserRegistered",
displayName: new LocalizableString("NewUserRegisteredNotificationDefinition", "MyLocalizationSourceName"),
permissionDependency: new SimplePermissionDependency("App.Pages.UserManagement")
)
);
}
}
"App.NewUserRegistered" is unique name of the notification. We defined a localizable displayName (then we can show it while subscribing to the notification on UI). And finally, we declared that this notification is available to a user only if he has "App.Pages.UserManagement" permission.
There are also some other parameters, you can investigate in the code. Only notification name is required for a notification definition.
After defining such a notification provider, we should register it in PreInitialize event of our module, as shown below:
public class AbpZeroTemplateCoreModule : AbpModule
{
public override void PreInitialize()
{
Configuration.Notifications.Providers.Add<MyAppNotificationProvider>();
}
//...
}
Finally, you can inject and use INotificationDefinitionManager in your application to get notification definitions.


Projection Pursuit (PP) algorithm for dimension reduction based on Gaussian Mixture Models (GMMs) for density estimation using Genetic Algorithms (GAs) to maximise an approximated negentropy index.
| Version: | 1.0.1 |
| Depends: | R (≥ 3.4) |
| Imports: | Rcpp (≥ 0.12.5), mclust (≥ 5.0), GA (≥ 3.1), ggplot2 (≥ 2.2.1), ggthemes (≥ 3.4.0), cli, crayon |
| LinkingTo: | Rcpp, RcppArmadillo (≥ 0.7) |
| Suggests: | knitr (≥ 1.8) |
| Published: | 2018-10-15 |
| Author: | Alessio Serafini [aut, cre], Luca Scrucca [aut] |
| Maintainer: | Alessio Serafini <srf.alessio at gmail.com> |
| BugReports: | https://github.com/luca-scr/ppgmmga/issues |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://github.com/luca-scr/ppgmmga |
| NeedsCompilation: | yes |
| Citation: | ppgmmga citation info |
| Materials: | README NEWS |
| CRAN checks: | ppgmmga results |
| Reference manual: | ppgmmga.pdf |
| Vignettes: |
A quick tour of ppgmmga |
| Package source: | ppgmmga_1.0.1.tar.gz |
| Windows binaries: | r-devel: ppgmmga_1.0.1.zip, r-release: ppgmmga_1.0.1.zip, r-oldrel: ppgmmga_1.0.1.zip |
| OS X binaries: | r-release: ppgmmga_1.0.1.tgz, r-oldrel: ppgmmga_1.0.1.tgz |
| Old sources: | ppgmmga archive |
Please use the canonical form https://CRAN.R-project.org/package=ppgmmga to link to this page.


About
I'm a first year EECS doctorate student at the Massachusetts Institute of Technology. I work in the Computer Science and Artificial Intelligence Laboratory with the Learning and Intelligent Systems group. I graduated from UC Santa Cruz with a Computer Engineering major this spring. During my tenure there, I researched with the Bionics Lab under Jacob Rosen PhD on Dental Robotics.


Let’s walk through all the steps required to make a simple game in Lobster by making a shooter in the same vein as “Geometry Wars”: enemies come at you from all directions, and you have to keep shooting them until you invariably.. die. Sound like fun?
You can follow along just looking at the code and screenshots below,
or by loading up samples/shooter_tutorial/tut*.lobster
and
trying them out yourself.
Decent experience in at least one other programming language required. Minor familiarity with Lobster is required (this tutorial won’t explain all the basics, and focuses mostly on the graphics aspect). No need to know how games work, though minor math knowledge may help.
Let’s start by creating a blank canvas for us to draw on. Something like this:
Impressively.. empty.
import vec
import color
import gl
fatal(gl_window("Shooter Tutorial", 640, 480))
while gl_frame() and gl_button("escape") != 1:
gl_clear(color_black)
gl_window
is our graphics initialization routine, and is
the first thing we need to do before we can access any other graphics
functionality. We specify a title and a size, though note that these are
merely suggestions: on desktop platforms the user may resize/maximize
our window, and on mobile platforms they just determine landscape vs
portrait orientation, whereas the resolution is determined by the device
itself.
gl_window
returns an error string if something goes
wrong (and things can go wrong, behind the scenes this call boots up an
OpenGL engine including compiling shaders and what not), and
fatal
is a utility function defined in
std.lobster
that we’re including that will quit the program
and show the error string if available.
Once we’re up and running, this while loop is our frame
loop. Games work by rendering the current state of the game
repeatedly to the screen, preferrably fast (30-60 times per second),
giving the impression of smooth animation. gl_frame
is the
core of all of this: it makes sure we advance to rendering the next
frame, and checks for input etc. If the user clicks the close button or
otherwise terminates the app, gl_frame
will return
false
, which is our signal to quit the game. Additionally,
we want the user to be able to quit if they press the escape key, so we
check for that too.
Then inside the frame loop, we clear the screen (remember that we
draw repeatedly), and then we’re ready to draw. color_black
is a constant from color.lobster
, representing a 4
component RGBA.
So now we can start drawing, right? Well, we also have to determine where and how we want to draw:
Look at that! This is starting to look impressive! Check out those polygons!
import std
import vec
import color
import gl
fatal(gl_window("Shooter Tutorial", 640, 480))
let worldsize = 20.0
while gl_frame() and gl_button("escape") != 1:
gl_clear(color_black)
gl_color(color_white)
gl_translate(float(gl_window_size()) / 2.0)
gl_scale(gl_window_size().y / worldsize)
gl_circle(1, 6)
Before we can actually draw, we have to talk about coordinate
systems. By default, coordinates in Lobster correspond directly to
pixels, with (0,0) in the upper left corner (a left-handed coordinate
system), and the total number of pixels depending on the device (or the
user), which during any frame is given by gl_window_size
.
While working directly with pixel sizes may be useful for some
applications, generally, we want games to be scalable, meaning they
should roughly look the same irrespective of what device they run
on.
There is no universal way to do this for games however, because besides different resolutions, you have the more problematic issue of different aspect ratios, varying from 4:3 on the iPad (relatively square) to 3:2, 16:10 and 16:9 (longitudinal) on most desktops and other mobile devices. Your game should ideally look good on that whole range. If you only aim for one ratio, you’ll get borders or things cut off on the other ratios. What works best depends on your game content.
Here we’ll take a simple approach: make the middle of the screen our coordinate system origin, and rendering outward enough from there that we have all ratios covered.
gl_translate changes our coordinate system, and is used throughout
graphics rendering in Lobster to render things at different portions of
the screen. Here we move from upper-left to the middle of the screen by
translating by half the gl_window_size
.
Then we have to determine how much of the game world we want to show. We don’t want that related to pixels either, as we don’t want people with smaller screens see less of the game. The computer doesn’t care about real world sizes like feet or meters, so we can make up whatever number we want. It is useful however to pick a number, since that means if we later want to show more or less of the gameworld, we just have to change one number. Here we say we want the screen to be able to fit at least 20 units, and we make this relative to the y resolution of the screen (we’re assuming that’ll be the smaller one of the two).
Now we can finally draw! Let’s put down a temporary graphic for the
player. gl_circle
draws circles around the current origin,
with the first argument being the radius (see how we’re using the world
scale for this?), and the second argument is the number of sides.
Setting this to something low like 6 actually gets us a hexagon rather
than a circle.
Pfew, that’s a lot of talk just for a circle, but we’re getting somewhere. Next up, let’s move our player around. Because games are supposed to be… interactive
It moved! I swear!
import std
import vec
import color
import gl
fatal(gl_window("Shooter Tutorial", 640, 480))
let worldsize = 20.0
var playerpos = float2_0
let playerspeed = 10
while gl_frame() and gl_button("escape") != 1:
gl_clear(color_black)
gl_color(color_white)
gl_translate(float(gl_window_size()) / 2.0)
let scale = gl_window_size().y / worldsize
gl_scale(scale)
let dir = float2 { (gl_button("d") >= 1) - (gl_button("a") >= 1),
(gl_button("s") >= 1) - (gl_button("w") >= 1) }
let newpos = playerpos + normalize(dir) * gl_delta_time() * playerspeed
if not any(abs(newpos) > float(gl_window_size()) / scale / 2):
playerpos = newpos
gl_translate(playerpos):
gl_circle(1, 6)
To make our player move, we added 2 new variables:
playerpos
and playerspeed
. We initialize the
former with a vector constant from vec.lobster
:
float2_0
means all zeroes.
We first figure out which direction the player wants to move by
checking the current state of the WASD keys: by combining the boolean
values (0 / 1) for each direction, both DA and SW give us a -1 / 0 / 1
value which conveniently corresponds to a directional vector
(dir
).
Now, we can’t just add this vector to the player and be done with it, we have to take into account:
If the player tries to move in both x and y directions at once,
the magnitude of the dir
vector is sqrt(2) instead of 1,
and thus the player would move faster! We want him to move in all
directions at equal speed. normalize
ensure we have a
vector of length 1. You wouldn’t believe how many games have this bug in
it!
Remember how the code inside the while loop is our frame? Well,
depending on the device, we have no idea how many frames per second
we’re actually running at. If we simply move a fixed amount each frame,
we’ll end up moving faster on faster computers! Yet another common bug
that we’ll avoid by multiplying our vector by
gl_delta_time
, which is the number of seconds (usually a
fraction of a second, e.g. 0.033 at 30 FPS) that has passed since the
last frame we rendered. The result is that we’ll now move 1 unit (the
length of the vector) per second exactly, regardless of how fast or slow
our machine is rendering.
Of course, “1 unit per second” may well be too slow for our intended game, so we factor in our own player speed. We can tweak it later.
Last, but not least, once the player can move, we have to worry
about him staying within the game world. What we have to do, is a very
simple form of collision detection. Collision detection can be
very difficult to program, but here we start by just checking the
boundaries of the screen. Note that I put our new position in a separate
variable, this is such that we will only make it the new player position
if we’re still inside the world. I also created a variable for the scale
we set, so that we can use it to know where the screen boundaries are.
We first take the absolute value of our new position (so we only have to
check one quadrant of the world). Notice how pretty much everything in
Lobster works on vectors? This makes it easy to write game code without
repeating your code for x and y all over the place. We compute the size
of a quadrant, and compare. <
here gives us a vector of
booleans, to check if any coordinates (x or y) were out of bounds, we
use any
. If this succeeds, we only then actually move the
player. pfew!
Now we have computed a new position, we have to make sure it has an
effect. We do this by translating our player position from the middle to
where we want to now draw our hexagon. Note something special about this
gl_translate
: it has a block of code following it (notice
the :
) much like if
or for
.
gl_translate
here actually works like a control structure:
it first translates, then executes the body, then resets the
translation. This is because what we want to render afterwards (enemies
perhaps) should not be rendered relative to the player, but relative to
what we had before the player (the world origin). If that sounds
confusing, it may become clearer later with more code. Stacking all
these transformations is one of the more confusing things about games
programming, but it is also rather powerful once you get the hang of
it.
What happens as I move the mouse cursor in a clockwise arc around the player from 12 to 3.
import std
import vec
import color
import gl
fatal(gl_window("Shooter Tutorial", 640, 480))
let worldsize = 20.0
var playerpos = float2_0
let playerspeed = 10
class bullet:
pos:float2
dir:float2
let firerate = 0.1
let bulletspeed = 15
var bullets = []
var lastbullet = gl_time()
while gl_frame() and gl_button("escape") != 1:
gl_clear(color_black)
gl_color(color_white)
gl_translate(float(gl_window_size()) / 2.0)
let scale = gl_window_size().y / worldsize
gl_scale(scale)
let dir = float2 { (gl_button("d") >= 1) - (gl_button("a") >= 1),
(gl_button("s") >= 1) - (gl_button("w") >= 1) }
let newpos = playerpos + normalize(dir) * gl_delta_time() * playerspeed
if not any(abs(newpos) > float(gl_window_size()) / scale / 2):
playerpos = newpos
let tomouse = normalize(gl_local_mouse_pos(0) - playerpos)
if lastbullet < gl_time():
bullets.push(bullet { playerpos, tomouse })
lastbullet += firerate
for(bullets) b:
b.pos += b.dir * gl_delta_time() * bulletspeed
gl_translate b.pos:
gl_color color_yellow:
gl_circle(0.2, 20)
bullets = filter(bullets) b:
magnitude(b.pos) < worldsize * 2
gl_translate gl_local_mouse_pos(0):
gl_line_mode 1:
gl_color color_grey:
gl_circle(0.5, 20)
gl_translate playerpos:
gl_rotate_z tomouse:
gl_polygon([ float2 { -0.5, 0.5 }, float2_x, float2 { -0.5, -0.5 } ])
To be able to shoot, first we have to worry about giving our player
an orientation. We compute that in the vector tomouse
which
we get by subtracting the player position from the mouse position (what
we want to shoot towards). Something funny is going on here though, as
the name gl_local_mouse_pos
may indicate: normally mouse
positions are in pixels, but those we can’t compare against the player
position, which is in world coordinates! gl_local_mouse_pos
however gives us the mouse position relative to the current transform,
which is world coordinates (as specified by the
gl_translate
and gl_scale
above). We then
normalize this vector to make it easier to use, as we don’t care about
the original length of this vector.
To make the players orientation visual, we first render the player
differently: rather than a simple circle, we render him as a pointy
triangle, to make it clear what direction he’s looking at. That’s the
gl_polygon
at the end with 3 explicit coordinates (relative
to the playerpos, which has now become our coordinate system origin
thanks to gl_translate
). Additionally, we insert a
gl_rotate_z
command to make the pointy part of the triangle
always look towards the mouse cursor. The z
is because if
we rotate around the z axis, we end up rotating the xy plane, which is
what we look at in 2D. The argument to gl_rotate_z
can
either be a vector (as used here) or an angle in degrees. Vectors are
generally awesomer.
Additionally, to cater for situations where the mouse cursor isn’t
visible (which it typically isn’t in games) we draw a circle (for now)
at the mouse location to give the player feedback where he’s aiming at.
This starts at the gl_translate
before where we draw the
player (before, because if the two overlap, the last one will be drawn
on top). We translate to the mouse location in world space, change the
linemode to 1 (which draws just the outline instead of a filled circle)
and change the color. As you can see, all these commands are ones that
undo themselves automatically after the circle is drawn, which is very
convenient.
Now let’s start firing bullets. To keep things simple for now, we fire them automatically, but firing them using a button would be very easy to add (try it!). We add some constants up top, a firerate (second to fire the next bullet) and their speed of travel in the world. To keep track of what’s going on, we just need a list of bullets, and track when the last bullet was fired.
We define what a bullet is by defining a new class type, saying that it just has a current position and direction.
Now look at the if
inside the code: we check if time has
progressed beyond the point the last bullet was supposed to be fired,
and if so, we add a new bullet to the list of bullets, making it start
at the current player position, travelling in the direction of the
mouse. We also increase the lastbullet
variable to cause
the next one to be fired in 0.1 seconds.
A sidenote on how we’re implementing bullets here: there’s a couple of things not ideal about this, which we do all to keep the example simple and to really build a game from the ground up. First, the way the checking for time is implemented here is a bit fragile, as big time fluctuations may cause bullets to be shot at irregular intervals.
Now that we have a list of bullets being generated, we have to update
them and draw them. The first line in our for
loop updates
them, in a manner that should look familiar by now: we move the position
along the direction, scaled by the amount of time that has passed this
frame and their general speed in world units per second.
Now they’re moving, we can draw them at their current position. We make them yellow, and 0.2 units in radius.
One last thing to before we’re done: our list of bullets will grow
indefinitely, and eventually make the game run to a crawl, even though
most have moved off screen. We’ll cull bullets that have moved far
enough away from the origin that they’re not visible anymore. We’ll do
this functional style: filter
will give us a new list of
bullets for which the magnitude of the position (which is the same as a
vector from the origin, which is the middle of the screen) is within
twice the world size. We could cull them more precisely than this, but
for now, this will have the desired effect of keeping the list
small.
Wow, there’s a lot to understand to make even a simple game. But the good news is that in many games you will see the patterns of what we’re doing here again and again, so it is rather useful to get familiar with. It even translates to 3D.
But for now… target practice!
Since the code is getting long, let’s continue, talking purely in terms of modifications to the existing code:
def renderpointytriangle(pos, dir):
gl_translate pos:
gl_rotate_z dir:
gl_polygon([ float2 { -0.5, 0.5 }, float2_x, float2 { -0.5, -0.5 } ])
First, let’s take the code for rendering the player and put it in
it’s own function, since we’ll be needing it for enemies too. Call
instead of the original code with
renderpointytriangle(playerpos, tomouse)
class enemy:
pos:float2
hp:int
var enemyrate = 1.0
let enemyspeed = 3
let enemymaxhp = 5
var enemies = []
var lastenemy = gl_time()
We can set up enemies analogous to bullets. Of course, we could share some of this functionality between them, but let’s not complicate matters for now. Add this to the declarations.
if lastenemy < gl_time():
enemies.push(enemy { sincos(rnd(360)) * worldsize * 2, enemymaxhp })
lastenemy += enemyrate
enemyrate *= 0.999
for(enemies) e:
let playerdir = normalize(playerpos - e.pos)
e.pos += playerdir * gl_delta_time() * enemyspeed
for(bullets) b:
if magnitude(b.pos - e.pos) < 1:
e.hp = max(e.hp - 1, 0)
b.pos = float2_x * worldsize * 10
gl_color lerp(color_red, color_blue, div(e.hp, enemymaxhp)):
renderpointytriangle(e.pos, playerdir)
enemies = filter enemies: _.hp
During the frame, we use the above code to deal with enemies, which is very similar to bullets yet again. We spawn new enemies initially once per second. To compute a spawn location, take a random angle, convert to a vector, then offset that vector to somewhere outside the screen to have them flock in from all directions.
We do one special thing: we keep reducing the enemy rate subtly. This guarantees the game will get harder and harder and the player will guaranteed die eventually, it is just a matter of when.
Then we loop through all enemies, compute a vector towards the player, and move the enemy towards him. Of course, now we need to do collision detection between bullets and enemies, which we do in brute force manner by checking every bullet with every enemy. If the quantity of both stays low, this is ok, but for large amounts of objects this approach will eventually get too slow, requiring bucketing of objects in a grid. For now, this is ok. We check the distance between the center of the bullet and the center of the enemy, and consider it a hit if they are a generous 1 unit apart or less. Of course, we could check exact collision with the triangle, but besides being complicated, it might not even be desirable for gameplay.
If we have a hit, we reduce the HP of the enemy by one (we’re using
max
to ensure it doesn’t go below 0, you’ll see why in a
bit). We also need to “kill” the bullet when that happens, but since we
already have code that removes bullets that leave the world, we are lazy
and make use of that, by moving the bullet far from the center.
Then we render the enemy conveniently with our existing function. We
do something fun here, letting the health of the enemy determine its
color, from healthy blue to a dead red. We use lerp
(linearly interpolate) of 2 colors. div
is a useful
function that does the same as /
on 2 integers but gives a
float result.
Then of course we need to cull dead enemies, which we do with a
similar filter
function. Culling all at once like we do
here with bullets and enemies is nice, because culling during update can
introduce subtle bugs.
We can’t really play yet however, since we can’t die…
Now we have some loose ends to wrap up to call this thing a “game”: we have to keep track of the player health and score (and highscore), and give him a start / game over screen in-between sessions.
To do that, we will have to be able to render text. First step
towards doing that is loading up a font, right after
gl_window
:
check(gl_set_font_name("data/fonts/US101/US101.ttf") and gl_set_font_size(32), "can\'t load font!")
check
is another useful function much like fatal, that
ensures the first argument is true, and if not, exits the program with
the given message.
To implement the functionality, we start with some new variables:
var playerhealth = 0.0
var score = 0
var highscore = 0
var playing = false
inside our frame, we then test our playing
variable, and
when true, run the game code we were running before, and if false,
display the in-between screen, which simply says:
var msg = "press space to play!"
gl_translate float(gl_window_size() - gl_text_size(msg)) / 2:
gl_text(msg)
if gl_button("space") == 1:
score = 0
playerhealth = 100.0
playerpos = float2_0
bullets = []
lastbullet = gl_time()
enemyrate = 1.0
enemies = []
lastenemy = gl_time()
playing = true
The gl_translate
centers our text using the handy
gl_text_size
which tell us the size of a string in pixels
before we’ve even rendered it. gl_text
then draws it. We
then reset the game state when the game starts, and next frame the game
will be playing.
To show the current state to the player, we use the simple:
gl_text("health: {ceiling(playerhealth)} - score: {score} - highscore: {highscore}")
We call this as the very last thing in the frame, so it is visible
regardless of wether the player is in-game or not, for simplicity.
ceiling
is useful since we’ll be calculating the player’s
health in float, but want to show only the whole numbers.
ceiling
here is better than truncate
, since we
only want to show 0
when the player is truely dead.
if magnitude(playervec) < 1:
playerhealth -= gl_delta_time() * 50
if playerhealth <= 0:
playerhealth = 0
highscore = max(highscore, score)
playing = false
Then finally, inside our for(enemies) e:
loop, we add
this bit of code which checks if this particular enemy is “touching” the
player. If so, we substract health for how long he is touching. If the
player runs out of health, we update the high score, and revert back
into non-playing mode.
Game Over, and Tutorial Over!
We now have a very basic structure of a game. While it is not impressive, it does deal with all the typical things a game does, and thus extending it from here should be fun and easy. Some ideas of things you could add:
Tweak all the current variables: player and enemy speed, enemy health and spawn rates, etc. The current ones are workable defaults, but are they the most fun?
A variety of enemy types. You can make them differ by speed, size and hitpoints easily, though giving them different behaviors will give even more variety.
Pickups for the player. Think of randomly spawning health boxes, and powerups (faster fire, spread fire etc).
Better graphics! It is a very good idea to make a game fun first with geometric shapes like we have done, but then once the game has taken shape, adding graphics can make the game feel more immersive and give better feedback to the player.
Better UI and main menu.
Game structure: different levels the player can try to beat, permanent upgrades the player can buy, etc.
Also, at this point, our game has no sound at all. If you’d like to
see how to add some anbient or enemy sounds, have a look at the use of
the play_
and sound_
functions in
tut_sound.lobster
. This example also shows how to to
dynamically adjust the volume and pause or resume individual sounds.
This tutorial has all game state in top level variables, for
simplicity of explanation. If you want to have a look what the code
would be like if you instead stored all of it in classes, have a look at
tut_obj.lobster
.


Started working as a Big Data Engineer, Fractal
Working on a project with a client using various big data tools like Spark, Nifi, Kafka
Working on a project with a client using various big data tools like Spark, Nifi, Kafka
Two years of efforts and struggle paid off! It was an indeed a very different experience online. Thanks to all the professors who taught so well.
I helped my friend with a project that involved more to do with extracting audio out of the video and converting it into text, later getting a summarized part of the text using NLTK and then reconverting the text back to audio. On the other side extracting the frames out of the video and deleting the repetitive frames. For longer videos the frequency of frames had to be changed so as to get minimum images with entire content.
After getting an experience from Jio for about 2 years I decided to pursue master's in Data Science as working on data gave me an enthusiasm to explore more.
It was great adventure working at Jio for 2 years. I gained an exposure to the corporate culture and also increased my knowledge. I look ahead to joining a company where I can use my experience.
I worked on different projects that required me to create and plan flows, ingest data, and visualize the given data set. I designed data pipelines for Unique Identification number project, to insert data in Jio Big Data Lake using various processors and modified data on every stage with RegEx in a tool Apache NiFi. I actively took part to help build business requirement documents and plan deployments. Produced Jasper reports later utilized in Java application to generate dynamic content for Telecom Regulation of India project which improved the delivery of content by 30%.Also, I built data source for Jio Payments Bank project and constructed dashboards to derive useful information using Zoomdata - a tool specifically used for Big Data.
Soon as I graduated I started working at Jio. There I performed User Acceptance Test on Jio applications against various test cases on IBM Rational Tool. I also detected bugs and exploited IBM Rational Tool for logging bugs.
I graduated from Shreemati Nathibai Damodar Thackersey Women's University with 77%.
Along with studying I was active at participating in various committees and events. I was a Cabinet Member at SNDT ACM Students' Chapter. Also, an active member of ACM, IEEE, CSI, E-cell councils.


{title:'RequestHeaders', flags:'todo'}
The {@link oajr.RequestHeaders} object is the API for accessing the headers of an HTTP request. It can be accessed by passing it as a parameter on your REST Java method:
Some important methods on this class are:


package descriptors
Ordering
- Alphabetic
Visibility
- Public
- All
Type Members
- sealed trait BaseDescriptor extends AnyRef
- class Descriptor extends BaseDescriptor
- class DescriptorValidationException extends Exception
- class EnumDescriptor extends BaseDescriptor
- class EnumValueDescriptor extends BaseDescriptor
- class FieldDescriptor extends BaseDescriptor
- class FileDescriptor extends BaseDescriptor
- class MethodDescriptor extends BaseDescriptor
- class OneofDescriptor extends BaseDescriptor
- final case class PBoolean(value: Boolean) extends AnyVal with PValue with Product with Serializable
- final case class PByteString(value: ByteString) extends AnyVal with PValue with Product with Serializable
- final case class PDouble(value: Double) extends AnyVal with PValue with Product with Serializable
- final case class PEnum(value: EnumValueDescriptor) extends AnyVal with PValue with Product with Serializable
- final case class PFloat(value: Float) extends AnyVal with PValue with Product with Serializable
- final case class PInt(value: Int) extends AnyVal with PValue with Product with Serializable
- final case class PLong(value: Long) extends AnyVal with PValue with Product with Serializable
- final case class PMessage(value: Map[FieldDescriptor, PValue]) extends AnyVal with PValue with Product with Serializable
- final case class PRepeated(value: Vector[PValue]) extends AnyVal with PValue with Product with Serializable
- final case class PString(value: String) extends AnyVal with PValue with Product with Serializable
- sealed trait PValue extends Any
- class PackageDescriptor extends BaseDescriptor
- case class Reads[A](read: (PValue) ⇒ A) extends Product with Serializable
- trait ReadsCompat extends AnyRef
- class ReadsException extends Exception
- sealed trait ScalaType extends AnyRef
- class ServiceDescriptor extends BaseDescriptor
Value Members
- object FieldDescriptor
- object FileDescriptor
- object PEmpty extends PValue with Product with Serializable
- object Reads extends ReadsCompat with Serializable
- object ScalaType
- object SourceCodePath


In order to maintain the safety of our animals, staff, and customers we
have implemented a stringent cleaning schedule of our facilities. We are using a specialized
COVID-19 virucide, and surgical scrub. Please be assured that all gate latches, posts or
anywhere that visitors or staff may touch are disinfected. Lastly, we would like to thank our
team members for complying with our policies by restricting their interactions, and wearing a
mask and/or gloves when appropriate on the premises.
But, we also need your help!  This policy is in accordance with Hillsborough county’s mandate. If you have a medical condition that prevents you from using a mask, or a child age 8 or under with you that cannot wear a mask, you may wait at the Picnic Table just beyond the gate directly to the left. Please sit at the table, ring the bell, and someone will come to help you shortly.
Please remain 6' behind the customer in front of you and 3' from our tables.
Pre-order your products so we can have them ready for you when you arrive. This is essential for us to promote a speedy checkout and minimize physical contact! Check out our “Place an Order” page for more information. If you did not pre-order we cannot guarantee we will have the products you ask for available.
Please do not touch any products! If you did not pre-order, let us know what you would like and we will gather and bag your products for you.
Please pay with Venmo or Zelle. If you must pay with cash, we ask that you have exact change and drop it in the bucket. Do not be offended when we spray all cash and coins with our Covid-19 disinfectant!
If there are any extenuating circumstances making it difficult for any customer to abide by this policy, please contact us directly through Facebook or email and we will attempt to make reasonable accommodations.
Thank you for respecting our business policies. We appreciate your cooperation in keeping everyone safe and healthy!
Our preferred method of communication is by email. If you have any questions or would like to place orders, please email us!


Technical proposal
Our proposal comes in two parts a full lightning node implementation based on the
lightning RFC also
referred to as BOLT (Basis of Lightning Technology),
an implementation which is compatible with the Bitcoin network and the Stratis network (a multi-chain
lightning node).
The second part is about the applications of lightning that use the lightning node
implementation such as swaps, watchtowers
and routing services which will be targeting cloud provides or the Stratis master nodes.
Lightning Node
The following sections describe the BOLTs we will implement that are required to run a lightning
node.
It also includes a docker based test suite to test and insure compatibility between existing
implementations.
The node will be compatible with the popular UI for lightning called RTL (Ride The Lightning)
All the BOLT codebase will come in the form of nuget packages, this are lightning library components
that can be used in C# applications such as web, mobile and even games (with unity).
Work has already started on an implementation called Lyn (lightning in Danish).
The codebase can be found here Lyn
The lightning node adds scaling capabilities to the already wide Stratis technology stack, we will
develop
the node with cloud architecture in mind, parts of the workload required to successfully route
payments in lighting
can be delegated to dedicated cloud service providers or master nodes.
Payment Channels (BOLT1,2,3,5,8,9)
Payment channels allow the exchange of transactions between two participants which are sending
payments
off-chain in a trustless setup.
This include a node that can create funding transactions to open channels, the commitment
transaction
to secure the funds and the HTLCs (hash timed locked outputs) to make off chain payments between
participants.
It also includes lots of boilerplate components such as the gossip messages, noise protocol the
interaction with base layer etc..
A big part of this section is already implemented (BOLT1,3,8,9) in the Lyn repo.
Payment Routing (BOLT4,11)
Onion routing (built of layers like an onion) refer to the ability to route payments between
participants who don't share a channel directly,
an onion routed packet is used to route a payment from an origin node to a final node through a
number of intermediate nodes, called hops.
The payment initiator node, who knows the public keys of each intermediate, create the onion packet
in such a way that each node only knows
it's previous and next route but can't read information of any participant or how many hope this
route has.
Invoicing, defining protocol messages where participants can request payments over Lightning.
Payment Channel Discovery (BOLT7,10)
Node and channel discovery serve two different purposes, Node discovery allows nodes to broadcast
information about themselves, so that other
nodes can open connections and establish payment channels with them. Channel discovery allows the
creation and maintenance of a local
view of the network's topology, so that a node can discover routes to desired destinations.
Discovery is done using gossip messages, each node that receives gossip messages stores it and
routes
it on to its peers.
Lightning Applications
Features that use and build on top of the lightning node and are intended to be used by Stratis
master
nodes
Atomic Cross-Chain Lighting Swaps
Lightning enables channel rebalancing using atomic swaps between an off-chain lightning channel
to a Bitcoin
on-chain address (and reverse) using a protocol extension called submarine swaps.
LBTC to STRAX swaps -
We'll use the submarine swaps protocol to enable atomic swaps between LBTC (Bitcoin locked in
lightning channels)
to STRAX on the stratis main chain.
LBTC to LSTRAX swaps -
A lightning protocol extension called HODL invoices introduces expirable hash locked lightning
payments, where
a routed lightning payment is locked for a certain time until a secret is revealed.
Using this mechanism a lightning payment from one chain can be hash locked at the receiver until
the lighting
swap payment from the sender on the second chain is sent.
Swaps will come with a light weight lightning UI.
Master node swap services
Stratis master nodes can provide a swap matching service where users can register a request to
make a swap or ask for
available open swaps, effectively becoming a non-custodial market liquidity provider.
When a swap will take place it will be routed using the master node channels and will incur
routing and swapping fees.
Stratis master nodes are known, semi-trusted, entities however the swap users can stay unknown.
Master nodes that run a swap service will gain fees in BTC and STRAX and will be required to run
a fullnode and a lightning
node on the Bitcoin and Stratis main chain.
Master node watchtower services
Watchtowers are specialized services that are always online in order to monitor the blockchain
for channel breaches
on behalf of lightning network participants.
Lightning channels create asymmetric commitment transactions on each side of the channel when
sending funds off-chain,
every new commitment transaction effectively invalidates all previous commitment transactions.
A malicious side of the channel who breach the channel can be punished by loosing all the funds in
the channel.
In order to spot channel breaches node operator must stay online to monitor the blockchain.
The services of monitoring a channel breach can be delegated to master nodes who keep an always
online node anyway.
A lightning user that is not always online and uses a watchtower service will register an
encrypted justice transaction alongside a
transaction locator to the Watchtowers. Both the encryption key and the transaction locator are
derived from the breach transaction id,
meaning that the Watchtower will be able to decrypt the justice transaction only after the
corresponding breach is seen on the blockchain.
Master nodes that run a Watchtower service can claim fees for such a service either in BTC or
STRAX and will be required to run a fullnode
and a lightning node of the network they provides watchtower services for.
Master node routing services
Lighting nodes build payment routes in order to make a payment over several hopes.
To be able to construct routes a node needs to maintain a recent and correct view of the network
channels and balances.
This is done using gossip messages that are sent over the lighting network.

The services of constructing payment routes can be delegated to master who keep an always online
node anyway.
This enables light wallets that don't need to stay online to make route requests when making a
lightning payment.
Master nodes that run a routing service can claim fees for such a service either in BTC or STRAX
and will be required to run a fullnode
and a lightning node of the network they provides routing services for.
Routing services have some privacy disadvantages, to overcome that we can use Trampoline
payments
which are a proposed type of payment where the spender routes the payment to an intermediate
node
who can select the rest of the path to the final receiver or to another Trampoline enabled node.
Time permitting we may enable Master nodes to act as nodes that can route trampoline payments.


Pixel 2 and Pixel 2 XL are Android smartphones designed, developed and marketed by Google. They were announced during a Google event on October 4, 2017, as the successors to the Pixel and Pixel XL. They were released on October 19, 2017, and serve as the second set of smartphones in the Google Pixel hardware line. The back of the Pixel 2 and Pixel 2 XL is made from aluminum with a thin "premium coating" of plastic and has a top section made from glass to provide wireless transmissivity. Unlike the original Pixel XL, which was simply an enlarged version of the Pixel design with no other changes, the Pixel 2 XL's external design differs from its smaller sibling, employing a taller 18:9 P-OLED display instead of the Pixel 2's 16:9 AMOLED.
-
- CPU: Snapdragon 835 (4x2.35 GHz Kryo & 4x1.9 GHz Kryo)
- GPU: Adreno 540
- Storage: 4GB RAM/128GB
- Camera: 12.2 MP (f/1.8, 27mm, 1/2.6", 1.4µm, Dual Pixel PDAF), OIS, phase detection & laser autofocus, dual-LED flash
- Screen: AMOLED 5.0 inches/6.0 inches 1080p/1440p 18:9 Corning Gorilla Glass 5
- Sensors: Fingerprint accelerometer gyro proximity barometer compass
- Battery: 3530mAh with Fast-charge Type-C IP67
- Price: 700€


Are churros Christina's favorite nostalgic food indulgence?
Does Christina think her superhero name would be 'Telepathina'?
Did Christina move to Seattle because of Anthony Bourdain?
Was Christina ever bitten by an ostrich?
Did Christina perform on a European tour when she was a child?
Christina has moved 6 times in the past 5 years.
Christina has been to 16 countries: Argentina, Bahamas, Belgium, Cuba, France, Germany, Iceland, Indonesia, Netherlands, Malaysia, Mexico, Philippines, Singapore, South Korea, Thailand, and Uruguay.
Christina's Playlist for Today
- Jorja Smith
- The Black Skirts
- Dorothy Ashby
- Com Truise
- Blonde Redhead
Top 5 Favorite Dishes
- Kalbi Ribs
- Pizza with sausage, pineapple, pepperoni, and mushrooms
- Pho noodles
- Shake Shack burgers
- Empanadas


Pizza Snob
The best personalized pizzas -for people who just know what they want.
Name
Snobby Size
Personal (Mini) Snob
Small Snob
Medium Snob
Large Snob
Snobby Sauce
Organic Tomato Sauce
Organic Garlic and Olive Oil
Organic Pesto
Snobby Toppings
Roasted Garlic
Black Olives
Mushrooms
Spinach
Tomatoes
Artichokes
Green Onions
Kale
Snobby Cheeses
Mozzarella
Feta
Gorgonzola
Fontina
Parmesan
White Cheddar
Vegan Mozzarella
Tofu Cheese
Not-a-Ricotta
Snobby Protein
Pepperoni
Sausage
Bacon
Spicy Pulled Pork
Chicken
Vegan Pepperoni
Vegan Sausage
Buffalo Jackfruit
Submit
's Receipt
Snobby Ingredients:
Snobby Pizza Total: $
.55


Class Resource.Color
Inheritance
System.Object
Resource.Color
Namespace:xAPIWrapper.Tests.Droid
Assembly:xAPIWrapper.Tests.Droid.dll
Syntax
public class Color : object
Fields
View Source
abc_background_cache_hint_selector_material_dark
Declaration
public const int abc_background_cache_hint_selector_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_background_cache_hint_selector_material_light
Declaration
public const int abc_background_cache_hint_selector_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_color_highlight_material
Declaration
public const int abc_color_highlight_material = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
Declaration
public const int abc_input_method_navigation_guard = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_primary_text_disable_only_material_dark
Declaration
public const int abc_primary_text_disable_only_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_primary_text_disable_only_material_light
Declaration
public const int abc_primary_text_disable_only_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_primary_text_material_dark
Declaration
public const int abc_primary_text_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_primary_text_material_light
Declaration
public const int abc_primary_text_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_search_url_text
Declaration
public const int abc_search_url_text = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_search_url_text_normal
Declaration
public const int abc_search_url_text_normal = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_search_url_text_pressed
Declaration
public const int abc_search_url_text_pressed = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_search_url_text_selected
Declaration
public const int abc_search_url_text_selected = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_secondary_text_material_dark
Declaration
public const int abc_secondary_text_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
abc_secondary_text_material_light
Declaration
public const int abc_secondary_text_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
accent_material_dark
Declaration
public const int accent_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
accent_material_light
Declaration
public const int accent_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
background_floating_material_dark
Declaration
public const int background_floating_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
background_floating_material_light
Declaration
public const int background_floating_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
background_material_dark
Declaration
public const int background_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
background_material_light
Declaration
public const int background_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_disabled_material_dark
Declaration
public const int bright_foreground_disabled_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_disabled_material_light
Declaration
public const int bright_foreground_disabled_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_inverse_material_dark
Declaration
public const int bright_foreground_inverse_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_inverse_material_light
Declaration
public const int bright_foreground_inverse_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_material_dark
Declaration
public const int bright_foreground_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
bright_foreground_material_light
Declaration
public const int bright_foreground_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
Declaration
public const int button_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
Declaration
public const int button_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
cardview_dark_background
Declaration
public const int cardview_dark_background = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
cardview_light_background
Declaration
public const int cardview_light_background = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
cardview_shadow_end_color
Declaration
public const int cardview_shadow_end_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
cardview_shadow_start_color
Declaration
public const int cardview_shadow_start_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_shadow_end_color
Declaration
public const int design_fab_shadow_end_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_shadow_mid_color
Declaration
public const int design_fab_shadow_mid_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_shadow_start_color
Declaration
public const int design_fab_shadow_start_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_stroke_end_inner_color
Declaration
public const int design_fab_stroke_end_inner_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_stroke_end_outer_color
Declaration
public const int design_fab_stroke_end_outer_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_stroke_top_inner_color
Declaration
public const int design_fab_stroke_top_inner_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_fab_stroke_top_outer_color
Declaration
public const int design_fab_stroke_top_outer_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_snackbar_background_color
Declaration
public const int design_snackbar_background_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
design_textinput_error_color
Declaration
public const int design_textinput_error_color = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
dim_foreground_disabled_material_dark
Declaration
public const int dim_foreground_disabled_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
dim_foreground_disabled_material_light
Declaration
public const int dim_foreground_disabled_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
dim_foreground_material_dark
Declaration
public const int dim_foreground_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
dim_foreground_material_light
Declaration
public const int dim_foreground_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
foreground_material_dark
Declaration
public const int foreground_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
foreground_material_light
Declaration
public const int foreground_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
highlighted_text_material_dark
Declaration
public const int highlighted_text_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
highlighted_text_material_light
Declaration
public const int highlighted_text_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
hint_foreground_material_dark
Declaration
public const int hint_foreground_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
hint_foreground_material_light
Declaration
public const int hint_foreground_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_blue_grey_800
Declaration
public const int material_blue_grey_800 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_blue_grey_900
Declaration
public const int material_blue_grey_900 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_blue_grey_950
Declaration
public const int material_blue_grey_950 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_deep_teal_200
Declaration
public const int material_deep_teal_200 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_deep_teal_500
Declaration
public const int material_deep_teal_500 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_100
Declaration
public const int material_grey_100 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_300
Declaration
public const int material_grey_300 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_50
Declaration
public const int material_grey_50 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_600
Declaration
public const int material_grey_600 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_800
Declaration
public const int material_grey_800 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_850
Declaration
public const int material_grey_850 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
material_grey_900
Declaration
public const int material_grey_900 = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_dark_material_dark
Declaration
public const int primary_dark_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_dark_material_light
Declaration
public const int primary_dark_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_material_dark
Declaration
public const int primary_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_material_light
Declaration
public const int primary_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_text_default_material_dark
Declaration
public const int primary_text_default_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_text_default_material_light
Declaration
public const int primary_text_default_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_text_disabled_material_dark
Declaration
public const int primary_text_disabled_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
primary_text_disabled_material_light
Declaration
public const int primary_text_disabled_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
ripple_material_dark
Declaration
public const int ripple_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
ripple_material_light
Declaration
public const int ripple_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
secondary_text_default_material_dark
Declaration
public const int secondary_text_default_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
secondary_text_default_material_light
Declaration
public const int secondary_text_default_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
secondary_text_disabled_material_dark
Declaration
public const int secondary_text_disabled_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
secondary_text_disabled_material_light
Declaration
public const int secondary_text_disabled_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_disabled_material_dark
Declaration
public const int switch_thumb_disabled_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_disabled_material_light
Declaration
public const int switch_thumb_disabled_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_material_dark
Declaration
public const int switch_thumb_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_material_light
Declaration
public const int switch_thumb_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_normal_material_dark
Declaration
public const int switch_thumb_normal_material_dark = null
Field Value
| Type |
Description |
| System.Int32 |
|
View Source
switch_thumb_normal_material_light
Declaration
public const int switch_thumb_normal_material_light = null
Field Value
| Type |
Description |
| System.Int32 |
|


| DOSE: |
repeated |
smoked |
Crack |
(freebase) |
I was only 14 when I first smoked crack.   I was pretty popular and not bad looking. Then one day I snuck out with my friend, letís call her S, 17, and got really messed up on Xanex, liqour, weed, Caladopin, Oxy Cotton and at least 10 lines of coke. I don't remember anything that happened that night except being handcuffed in a back of cop car and spending 2 weeks in a teenage crisis facility. S went there voluntarily a week after I did because she wanted to get off Heroin. They told me that they were going to send me to a residential rehabilation program for 3-9 months. S had to go there too, and about a month after living there we couldn't take it anymore and we escaped.
When we ran away from the program we both only had 15$ on us each, and the first thing we did was take a bus to the other side of the town. We had no place to stay and S suggested we stay at an abandoned house she and her ex boyfriend used to stay at when they ran away. It wasn't that bad except for one thing-we had no money what so ever. So I managed to break into my house and take $60.  I met a guy, M, he was a bum in his early 30's and S knew him from sometime earlier and he said he'd get us our dope so we gave him the money. He suggested that we smoke some rocks with him, S had done it before once or twice but I hadn't, and I wasn't too hesitant. I knew how 'bad' it was but I had nothing to lose. He had a glass pipe and he put a piece of an embro in it, then a tic tac sized square of crack in it and as he lit it, it made a sizzling sound.
I'll never forget the first hit I took, my mouth and lips instantly went completely numb. I felt as if I could control anything and everything and I was really talkative. I loved it. I took the biggest drag ever, and my throat felt like it was on fire, and after I thought I couldn't inhale it anymore-I inhaled even more. M went to give our money to the dealer, but little did we know was the he spent it all on crack. Later he told us to wait for him where he stayed and he left his crack pipe with us. Me and S were smoking it like nothing, after there was none left I kept trying to get a hit and for a while I actually thought I was hitting it because my mouth was so numb. S kept telling me to stop that there wasn't any left but I had to have more. It was all I could think about. More.
Later that night we met a friend of Mís, B. We needed to get more money, and that's when S told me that she was trickin. I was kind of shocked but I always thought she was a hooker.  I was coming down, and it was the worst feeling in the world. I was scared and paranoid, I couldn't stop chewing my lip, and all I could think about was getting more. I had formed really painful blisters on the inside of my lip but even then I couldn't stop chewing 'em. S came back with over 200$ and we had spent it all on crack. We went back to Bís work place to smoke it, I was so in love with it, I had convinced myself I was going to become a crackhead because I loved it so much there was no way I'd give it up. The bad part of is that it only gets me high for about 15 minutes so we kept smoking non stop.
 When we came back to the abandoned house we smoked more, and after smoking $200 worth of crack and coming down off it was the most indescribable worst feeling in the world and the only way to stop was to smoke more. After we had none left, I kept trying to hit the pipe again until the glass got so hot it popped and I had a tiny piece of glass stuck right next to my eye, I couldn't feel anything and I didn't know what happened until S told me. I felt like my whole body was jello, I would glide through the room instead of walking.
I smoked crack quite a few more times after this with my back then boyfriend T and his friend P. The other times I smoked crack felt almost nothing like the first but I was already convinced I was on the verge of addiction after smoking non stop for 2 weeks. S got caught 2 weeks after we ran, she was pulled over be a cop while walking down the with a crackpipe and a heroin needle in her purse. When she got caught she left her diary in my bag, in it I read that all the money I had taken from my house and all the money she would get trickin she would spend on Heroin and not tell me.
 I wasn't anywhere near to who I used to be, I didn't even feel like the same person. The only thing I lived for was another blast. and another and another.
4 months later I came back home and I didn't have to go back to my rehabilitation program. I haven't smoked crack since I came home but I've had a lot of cravings. I had some withdrawals after quitting cold turkey. I still think about it on daily basis. I think most of the reason why I stopped smoking crack is because of the way I felt when I was coming down. The high only lasts 15 minutes, but coming down takes me up to 2 hours. Also because I was so in love with it I was ready to do anything and everything to get some and I was scared of the person I've become.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


At NSARK.com, our purpose is simple: to live and build WOW. Twenty years ago, we began as a small online retailer that only build small web. Today, we still build web — as well as game development, Mobile APP development and more. That "more" is providing the very best customer service, customer experience, and company culture. We aim to inspire the world by showing it's possible to simultaneously deliver happiness to customers, employees, vendors, shareholders, and the community in a long-term, sustainable way. We hope that in the future people won't even realize we build web online. Instead, they'll know NSARK as a service company that just happens to sell.
WEB DEVELOPMENT
MOBILE APP DEVELOPMENT
GAME DEVELOPMENT
SECURITY ENGINEER
UI/UX DESIGNER
Web development refers to building, creating, and an maintaining websites. It includes aspects such as web design, web publishing, web programming, and database management.
Mobile app development is the act or process by which a mobile app is developed for mobile devices, such as personal digital assistants, enterprise digital assistants or mobile phones.
Game Development is the art of creating games and describes the design, development and release of a game. A game developer could be a programmer, a sound designer, a designer or many other.
Do you need help with your business?


the and & for pits soil were that was digging The per bettongs bettong al., eastern are which with have study from not species {background al. Australian other rabbits than density pit this dig may our vegetation ecosystem number but native margin plots area {border-style different dug effects processes role where Eldridge large px;} woodland #ffffff;} also data each more population site areas microhabitat probability rabbit small their volume Sanctuary has significant sites Mulligans This animals been four fresh occurring Acacia available can plant time degraded ecological foraging only over Australia James, grassy greater observed phosphorus rate restoration soils these (Eldridge Bettongs all arid determine log low reintroduced structure they total within Arid European James changes did engineering experiments, found grazing had kangaroo landscape level logs tree (Bettongia .). ACT However, Soil animal basal could densities digs effect estimates habitat hectare litter mammals many mean model one open px; scalds species. studies temperate two variables water {font-family (Oryctolagus Eldridge, Flat These Woodland after approved authored between birds create density, desert designed draft. drafts during engineers final font-size infiltration information leaf natural near paper, potential restore reviewed semi-arid such there years Bradley Cunningham Ecology./j.-...x Eucalyptus Journal McIntyre Our Rabbit Research Shorthouse There University activity additional alter associated bioturbation bird bulk double; due echidnas endangered enhance eucalypt explanatory features function individual introduced key lost lower measured models present previously reintroduction significantly those three trees turnover under whether (McIntyre .), .–. Government Hill, Information Johnson Jones Manning, National South Territory Valentine across average behaviour border-color border-width box-gum calculated class compared conceived considered counts cuniculus design diggers disturbance eroded example, experimental extinct frequent fungi germination ground high higher included into layer livestock loss magnitude management most much period recovery reduced regression results scald seed shrubland similar since solid; some species, spring throughout time. unpublished used using very well when woody {font-style {font-weight (A.D. (Manning (Table (Treatment (cm) -month ./peerj./table-Table Animal Bettong Capital Council Data Davidson Ecology For Garkaklis, Hobbs LP, Management Manning Mensinga, Note: Research./wr Temperate Thus, Vegetation Whitford addition analysed and, any areas, assessing bandicoot become bettong, bettongs, bettongs. birds. bold coarse conducted confidence conservation counted courier; debris density. diet differed diggings dynamics early echidna either em; environmental estimated even exclusion extent feral field first floristic further grassland half here highly impact implications important include increasing influenced kangaroos larger late least locally logs, modelled naturally nature negative new now numbers nutrient occurred pallidum past patterns performed plot populations porcupine possible presence presented project pt;} rates research scalded season single size south-eastern spp. stem study. substantial substantially suggests through times type underground unit variable without woodlands, would year


A Mod for Stardew Valley
A mod that displays additional information on various objects. It marks inventory items that are still necessary for the bundle, calculates how many days are still left until the harvest and displays what is in a machine and how much time is left on it.
This mod also provides a handy API to extend its functionality.
Content of this ReadMe:
You need SMAPI to run any kind of mods. And of course you need Stardew Valley.
The mod is automatically present in the game. You just need to move the mouse over the object you wish to get the information from.
If you don’t like one or more of the displayed information (or worse, if there are conflicts with other mods), you can disable each type.
There are some decorators, i.e. images displayed on the regular item tooltip, that have a specific meaning:
For the Bundles Decorator, there is the option to show it on items needed for still locked bundles. On default, the decorator is only shown for the bundles you have access to, to keep it fair and balanced.
You can also configure the tooltip “trigger”, i.e. if you want the tooltip to show when the mouse hovers over an object, or if you want to press a key. You can also select the key to press.
On default, of all the big craftable objects in the game, only machines that produce something will get a tooltip. You can configure that to include all craftable objects, or all except chest (if you have a mod that shows specific information for them already).
If you wish to configure this mod, it’s advised to install spacechase0’s Generic Mod Config Menu. Then there will be a config page.
But if you wish to change the config.json file manually, you can also do that. The config.json with all entries is:
{
"DisplayIds": {
"bundles": true,
"challenger-decorator": true,
"crop": true,
"fieldoffice": true,
"fruit-tree": true,
"rarecrow": true,
"machine": true,
"museum": true,
"sell-price": true,
"shipping": true,
"tree": true
},
"DecorateLockedBundles": false,
"HideMachineTooltips": "ForNonMachines",
"TooltipTrigger": "Hover",
"TooltipTriggerButton": "MouseRight"
}
| Key in JSON | Config Name | Default Value | Explanation |
|---|---|---|---|
DisplayIds.bundles |
Bundles Decorator | true |
True if the bundle decorator should be activated |
DisplayIds.crop |
Crops Tooltip | true |
True if the crops tooltip should be activated |
DisplayIds.fieldoffice |
Field Office Decorator | true |
True if the field office decorator tooltip should be activated |
DisplayIds.fruit-tree |
Fruit Trees Tooltip | true |
True if the fruit trees tooltip should be activated |
DisplayIds.machine |
Machines Tooltip | true |
True if the machines tooltip should be activated |
DisplayIds.museum |
Museum Decorator | true |
True if the museum decorator should be activated |
DisplayIds.rarecrow |
Rarecrow Decorator | true |
True if the rarecrow decorator should be activated |
DisplayIds.sell-price |
Sell Price Decorator | true |
True to show the item’s price on the bottom of the tooltip |
DisplayIds.shipping |
Shipping Decorator | true |
True to marks items that were not shipped yet |
DisplayIds.tree |
Trees Tooltip | true |
True if the trees tooltip should be activated |
DecorateLockedBundles |
Decorate Locked Bundles | false |
ForNonMachines displays tooltips only on machines that
do workForChests hides tooltips only for
chestsNever displays tooltip on every item |
HideMachineTooltips |
Hide Machine Tooltips | ForNonMachines |
ForNonMachines displays tooltips only on machines that
do workForChests hides tooltips only for
chestsNever displays tooltip on every item |
TooltipTrigger |
Tooltip Trigger | Hover |
Hover to get tooltips when the mouse hovers over the
itemButtonHeld to get tooltips only when a button is
held |
TooltipTriggerButton |
Tooltip Button | MouseRight |
If the trigger is ButtonHeld , this is the button that
triggers the tooltip |
| Version | Issues | Changes |
|---|---|---|
| Future | Issues | |
| 1.4.0 | Issues | Add rarecrow and field office decorators |
| 1.3.3 | Issues | Portuguese translation and bugfixes |
| 1.3.2 | Issues | Translations (add French translation; update Korean translation) |
| 1.3.1 | Issues | Bugfixes (fix config for “new” recipe; fix fruit tree calculation on Ginger Island; make decorator display shipped item needed for “ship 15 of everything”; fix time remaining for casks; fix ginger tooltip) |
| 1.3.0 | Issues | Additional information (marks uncrafted recipes, shipping decorator, shows icons on tooltips) |
| 1.2.2 | Issues | Turkish translation |
| 1.2.1 | Issues | Chinese translation |
| 1.2.0 | Issues | Sell price feature |
| 1.1.1 | Issues | Bugfixes from NexusMods feedback |
| 1.1.0 | Issues | Split-screen & API fixes |
| 1.0.0 | Issues | Nexus Release |
| 0.4.0 | Issues | Prepare for Nexus Release |
| 0.3.0 | Issues | Strutured PoC |
| 0.2.0 | - | Crop Informant |
| 0.1.0 | - | Bundle Informant |
(All issues can be found here.)
Right now, not all translations are provided. If you want to help, translate either file in the i18n/ and test it right in your Stardew Valley (the same folder exists in your Mods/ folder). You can than provide it to me via pull request or email.
| Key | Language | Translated? |
|---|---|---|
default |
English | ✅ |
de |
German | ✅ |
es |
Spanish | 🔜 |
fr |
French | ✅ (thanks to ArndGlh) |
hu |
Hungarian | 🔜 |
it |
Italian | 🔜 |
ja |
Japanese | 🔜 |
ko |
Korean | ✅ (thanks to brighteast99) |
pt |
Portugese | ✅ (thanks to Mikeliro |
ru |
Russian | 🔜 |
th |
Thai | 🔜 |
tr |
Turkish | ✅ (thanks to ExaBronto) |
zh |
Chinese | ✅ (thanks to gottyduke) |
(This section contains notes to myself.)
To start developing this mod, you need to
There is a smaller API you can use without a direct dependency to this DLL. Just copy this interface:
using System;
using Microsoft.Xna.Framework.Graphics;
using StardewValley.TerrainFeatures;
namespace MyMod.ThirdParty;
///
/// Base class for the entire API. Can be used to add custom information providers.

/// API Version: 1.4.0
///
public interface IInformant {
///
/// Adds a tooltip generator for the <see cref="TerrainFeature"/>(s) under the mouse position.
///
void AddTerrainFeatureTooltipGenerator(string id, Func<string> displayName, Func<string> description, Func<TerrainFeature, string> generator);
///
/// Adds a tooltip generator for the <see cref="Object"/>(s) under the mouse position.
///
void AddObjectTooltipGenerator(string id, Func<string> displayName, Func<string> description, Func<SObject, string?> generator);
///
/// Adds a decorator for the <see cref="Item"/>(s) under the mouse position.
///
void AddItemDecorator(string id, Func<string> displayName, Func<string> description, Func<Item, Texture2D?> decorator);
}
And then you can access the mod’s API like this:
public class MyMod : Mod {
public override void Entry(IModHelper modHelper) {
.Events.GameLoop.GameLaunched += (sender, args) => {
Helpervar informant = Helper.ModRegistry.GetApi<IInformant>("Slothsoft.Informant");
if (informant is null)
return;
// now call the methods of the informant
.AddItemDecorator(...);
informant.AddObjectTooltipGenerator(...);
informant.AddTerrainFeatureTooltipGenerator(...);
informant};
}
}
If more control over the API is wanted or needed, a dependency to this mod can be added, and then the entire Api folder can be used.
.\build
This project is licensed under the MIT License - see the MIT license for details.


Contact
If you experience any bugs or crashes, please drop me a line at support[at]compartmental[dot]net.
I will work as quickly as I can to fix things and keep the app awesome.
Controls
Click and drag across the strings to create sound. For finer control you can click individual strings to play the harp like a piano.
Credits
Programming and Design: Damien Quartz


Overview
Duplicate code can be hard to find, especially in a large project. But PMD’s Copy/Paste Detector (CPD) can find it for you! CPD has been through three major incarnations:
-
First we wrote it using a variant of Michael Wise’s Greedy String Tiling algorithm (our variant is described here).
-
Then it was completely rewritten by Brian Ewins using the Burrows-Wheeler transform.
-
Finally, it was rewritten by Steve Hawkins to use the Karp-Rabin string matching algorithm.
Each rewrite made it much faster, and now it can process the JDK 1.4 java.* packages in about 4 seconds (on my workstation, at least).
Note that CPD works with Java, JSP, C, C++, C#, Fortran and PHP code and some more languages. For the full list, see below Supported Languages.
Your own language is missing? See how to add it here.
CPD is included with PMD, which you can download here.
Command line usage
Windows
CPD comes with its own starter batch file: cpd.bat
. It’s located in the bin
subdirectory in the PMD
binary distribution zip-file. Let’s assume, you are in this directory, then you can start CPD this way:
cpd.bat --minimum-tokens 100 --files c:\temp\src\java
The options “minimum-tokens” and “files” are the two required options; there are more options, see below.
Linux
For Linux, there is since PMD 5.0 a combined start script for all command line tools. This includes CPD.
The start script is called run.sh
and is located in the bin
subdirectory in the PMD binary distribution
zip-file. Let’s assume, you are in this directory, then you can start CPD this way:
./run.sh cpd --minimum-tokens 100 --files /tmp/src/java
The options “minimum-tokens” and “files” are the two required options; there are more options, see below.
Options
| Option | Description | Required | Applies for language |
|---|---|---|---|
| --minimum-tokens | The minimum token length which should be reported as a duplicate. | yes | |
| --files | List of files and directories to process | yes | |
| --filelist | Path to file containing a comma delimited list of files to analyze. If this is given, then you don't need to provide `--files`. | no | |
| --language | Sources code language. Default value is `java` | no | |
| --encoding | Character encoding to use when processing files | no | |
| --skip-duplicate-files | Ignore multiple copies of files of the same name and length in comparison. | no | |
| --exclude | Files to be excluded from CPD check | no | |
| --non-recursive | Don't scan subdirectiories | no | |
| --skip-lexical-errors | Skip files which can't be tokenized due to invalid characters instead of aborting CPD | no | |
| --format | Report format. Default value is `text`. | no | |
| --failOnViolation {true|false} | By default CPD exits with status 4 if code duplications are found. Disable this option with '--failOnViolation false' to exit with 0 instead and just write the report. | no | |
| --ignore-literals | Ignore number values and string contents when comparing text | no | java |
| --ignore-identifiers | Ignore constant and variable names when comparing text | no | java |
| --ignore-annotations | Ignore language annotations when comparing text | no | java |
| --ignore-usings | Ignore using directives in C# when comparing text | no | C# |
| --no-skip-blocks | Do not skip code blocks marked with --skip-blocks-pattern (e.g. #if 0 until #endif) | no | cpp |
| --skip-blocks-pattern | Pattern to find the blocks to skip. Start and End pattern separated by |. Default is `#if 0|#endif`. | no | cpp |
| --uri | URI to process | no | plsql |
| --help / -h | Print help text | no |
Examples
Note: The following example use the Linux start script. For Windows, just replace “./run.sh cpd” by “cpd.bat”.
Minimum required options: Just give it the minimum duplicate size and the source directory:
$ ./run.sh cpd --minimum-tokens 100 --files /usr/local/java/src/java
You can also specify the language:
$ ./run.sh cpd --minimum-tokens 100 --files /path/to/c/source --language cpp
You may wish to check sources that are stored in different directories:
$ ./run.sh cpd --minimum-tokens 100 --files /path/to/other/source --files /path/to/other/source --files /path/to/other/source --language fortran
There should be no limit to the number of ‘–files’, you may add… But if you stumble one, please tell us !
And if you’re checking a C source tree with duplicate files in different architecture directories you can skip those using –skip-duplicate-files:
$ ./run.sh cpd --minimum-tokens 100 --files /path/to/c/source --language cpp --skip-duplicate-files
You can also specify the encoding to use when parsing files:
$ ./run.sh cpd --minimum-tokens 100 --files /usr/local/java/src/java --encoding utf-16le
You can also specify a report format - here we’re using the XML report:
$ ./run.sh cpd --minimum-tokens 100 --files /usr/local/java/src/java --format xml
The default format is a text report, and there’s also a csv
report.
Note that CPD is pretty memory-hungry; you may need to give Java more memory to run it, like this:
$ export HEAPSIZE=512m
$ ./run.sh cpd --minimum-tokens 100 --files /usr/local/java/src/java
In order to change the heap size under Windows, you’ll need to edit the batch file cpd.bat
set the “OPTS”
variable to -Xmx512m
.
If you specify a source directory but don’t want to scan the sub-directories, you can use the non-recursive option:
$ ./run.sh cpd --minimum-tokens 100 --non-recursive --files /usr/local/java/src/java
Exit status
Please note that if CPD detects duplicated source code, it will exit with status 4 (since 5.0). This behavior has been introduced to ease CPD integration into scripts or hooks, such as SVN hooks.
| 0 | Everything is fine, now code duplications found |
| 1 | Couldn't understand command line parameters or CPD exited with an exception |
| 4 | At least one code duplication has been detected unless '--failOnViolation false' is used. |
Supported Languages
- Apex
- C#
- C/C++
- EcmaScript (JavaScript)
- Fortran
- Go
- Groovy
- Java
- Jsp
- Matlab
- Objective-C
- Perl
- PHP
- PL/SQL
- Python
- Ruby
- Scala
- Swift
- Visualforce
Available formats
- text : Default format
- xml
- csv
- csv_with_linecount_per_file
- vs
Ant task
Andy Glover wrote an Ant task for CPD; here’s how to use it:
<target name="cpd">
<taskdef name="cpd" classname="net.sourceforge.pmd.cpd.CPDTask" />
<cpd minimumTokenCount="100" outputFile="/home/tom/cpd.txt">
<fileset dir="/home/tom/tmp/ant">
<include name="**/*.java"/>
</fileset>
</cpd>
</target>
| Attribute | Description | Applies for language | Required |
| encoding |
The character set encoding (e.g., UTF-8) to use when reading the source code files, but also when
producing the report. A piece of warning, even if you set properly the encoding value,
let's say to UTF-8, but you are running CPD encoded with CP1252, you may end up with not UTF-8 file.
Indeed, CPD copy piece of source code in its report directly, therefore, the source files
keep their encoding. If not specified, CPD uses the system default encoding. |
No | |
| format | The format of the report (e.g. `csv`, `text`, `xml`); defaults to `text`. | No | |
| ignoreLiterals | if `true`, CPD ignores literal value differences when evaluating a duplicate block. This means that `foo=42;` and `foo=43;` will be seen as equivalent. You may want to run PMD with this option off to start with and then switch it on to see what it turns up; defaults to `false`. | java | No |
| ignoreIdentifiers | Similar to `ignoreLiterals` but for identifiers; i.e., variable names, methods names, and so forth; defaults to `false`. | java | No |
| ignoreAnnotations | Ignore annotations. More and more modern frameworks use annotations on classes and methods, which can be very redundant and trigger CPD matches. With J2EE (CDI, Transaction Handling, etc) and Spring (everything) annotations become very redundant. Often classes or methods have the same 5-6 lines of annotations. This causes false positives; defaults to `false`. | java | No |
| ignoreUsings | Ignore using directives in C#. | C# | No |
| skipDuplicateFiles | Ignore multiple copies of files of the same name and length in comparison; defaults to `false`. | No | |
| skipLexicalErrors | Skip files which can't be tokenized due to invalid characters instead of aborting CPD; defaults to `false`. | No | |
| skipBlocks | Enables or disabled skipping of blocks like a pre-processor; defaults to `true`. See also option skipBlocksPattern. | cpp | No |
| skipBlocksPattern | Configures the pattern, to find the blocks to skip. It is a string property and contains of two parts, separated by `|`. The first part is the start pattern, the second part is the ending pattern. The default value is `#if 0|#endif`. | cpp | no |
| language | Flag to select the appropriate language (e.g. `c`, `cpp`, `cs`, `java`, `jsp`, `php`, `ruby`, `fortran` `ecmascript`, and `plsql`); defaults to `java`. | No | |
| minimumtokencount | A positive integer indicating the minimum duplicate size. | Yes | |
| outputfile | The destination file for the report. If not specified the console will be used instead. | No |
Also, you can get verbose output from this task by running ant with the -v
flag; i.e.:
ant -v -f mybuildfile.xml cpd
Also, you can get an HTML report from CPD by using the XSLT script in pmd/etc/xslt/cpdhtml.xslt. Just run the CPD task as usual and right after it invoke the Ant XSLT script like this:
<xslt in="cpd.xml" style="etc/xslt/cpdhtml.xslt" out="cpd.html" />
GUI
CPD also comes with a simple GUI. You can start it via some scripts in the bin
folder:
For Windows:
cpdgui.bat
For Linux:
./run.sh cpdgui
Here’s a screenshot of CPD after running on the JDK 8 java.lang package:
Suppression
Arbitrary blocks of code can be ignored through comments on Java, C/C++, Javascript, Matlab,
Objective-C, PL/SQL and Python by including the keywords CPD-OFF
and CPD-ON
.
public Object someParameterizedFactoryMethod(int x) throws Exception {
// some unignored code
// tell cpd to start ignoring code - CPD-OFF
// mission critical code, manually loop unroll
goDoSomethingAwesome(x + x / 2);
goDoSomethingAwesome(x + x / 2);
goDoSomethingAwesome(x + x / 2);
goDoSomethingAwesome(x + x / 2);
goDoSomethingAwesome(x + x / 2);
goDoSomethingAwesome(x + x / 2);
// resume CPD analysis - CPD-ON
// further code will *not* be ignored
}
Additionally, Java allows to toggle suppression by adding the annotations
@SuppressWarnings("CPD-START")
and @SuppressWarnings("CPD-END")
all code within will be ignored by CPD.
This approach however, is limited to the locations were @SuppressWarnings
is accepted.
It’s legacy and the new comment’s based approch should be favored.
//enable suppression
@SuppressWarnings("CPD-START")
public Object someParameterizedFactoryMethod(int x) throws Exception {
// any code here will be ignored for the duplication detection
}
//disable suppression
@SuppressWarnings("CPD-END)
public void nextMethod() {
}
Other languages currently have no support to suppress CPD reports. In the future, the comment based approach will be extended to those of them that can support it.


Centered Hub
Pizza hub is a business center that had been in operation for more than ten as for now
.
We
are available 24/7 delivering services to our customers as per their orders.
We are also
in
social media as the same name implies.
We are among the best business centers in Kenya


We emphasize on working smart and not working hard. By 2020, the work culture will reform and reduce the work timing to 4 days a week and that eventually will bring more dependency, fast execution and clear communication among colleagues. At Vibrant, we believe in simplifying the teamwork, we believe in growth, and we believe in collaboration. We promise to bring you remarkable difference by developing innovative apps and solutions to a wide range of workplace problems.
Founder & CEO
Pranav worked for different organizations. Being not satisfied trying various applications to enable teams to be more productive at work, he came up with the idea to develop a single mobile first platform to simplify teamwork and to help customers build a happy & efficient work culture.
Advisor & Co-founder
Aswini has built and runs more than five successful ventures. Combined with his 25+ years of experience in manufacturing industry, he loves building next generation companies.
CTO
Suresh has over 15 years of experiance working in tech field he has led many teams to delever products successfully. Suresh is a information security expert and a TOGAF certified architect
Graduate from JBIET, Dinesh focuses on creating result driven intuitive applications for the user base. His personal philosophy is “Live to travel” and he practices it by working remotely while staying productive.
She breathes in & out on social media making sure she’s not left out of any breaking news. She has intertwined her computer science skills & marketing blend to grow the user base of multiple startups.
He likes taking pride in being an electrical engineer from IIT Bombay and pivoting his work path towards developing applications. He is the quietest among us and at the same time loves heavy metal music.
Electrical graduate from IIT BHU, Abhishek is a passionate coder. He believes in loving the work he does in order to do the great work. Apart from coding, he likes to take online courses related to AI and data analysis.
Graduated from RRIT Bangalore(ECE), Ajay is a self taught coder. He likes watching movies, anime's, playing video games and listening to rock music.


Listen to Webhook Notifications
Send an e-mail to
to get a notification
Waiting for notifications for subscription
...
Sign out
Sign out and delete the subscription


Create your card using markdown in the space on the right.
Use the button to toggle a preview of your slide.
When you are done, press save slide at the top right.
The METADATA tab below can be used to provide information about this slide. You can use this information in the slide with handlebar tags. For example to display the title, use {{|slide.title}}.
Some metadata fields are always present:
title
author
background-image (can be empty). If present, the linked image is used as the background of the slide.
tags (can be empty)
In addition to these standard fields, you can add custom fields. This allows you to use arbitrary data in your slide, and in the future will allow mass generation of slides from a template and data.
The values of fields you create can be used in the slide with the syntax {{|slide.fieldname}}. For example if you create a field called subject, you can use the value by entering {{|slide.subject}}.
{{> MDEdit id='slide-editor-mde' defaultContent="# {{slide.title}}\n\nby {{slide.author}}\n\n- this is a list\n- it has multiple entries\n\n1. this is a numbered list\n2. like above, but with NUMBERS!\n\n### A random image\n\n![](http://lorempixel.com/750/150)\n\n.right[.footnote[a footnote]]"}}


Description¶
IMDLIB is a python package to download and handle binary gridded data from the India Meteorological Department (IMD). For more information about the IMD datasets, check the following link: IMD Pune.
Installation¶
IMDLIB is tested for both Windows and Linux platforms with 64-bit architecture.
We recommend ‘Conda’ to install IMDLIB.
conda install -c iamsaswata imdlib
Installation using pip:
pip install imdlib
Installation from source/development version:
pip install git+https://github.com/iamsaswata/imdlib.git
Dependency¶
You need to have a python version 3.5 or higher for using IMDLIB. If you install IMDLIB from the source, the following plugins should be pre-installed.
Packages |
version |
|---|---|
certifi |
[2019.11.28] |
matplotlib |
[3.1.3] |
numpy |
[1.18.1] |
pandas |
[0.25.3] |
python-dateutil |
[ 2.8.1 ] |
pytest |
[5.3.4] |
pytz |
[ 2019.3] |
urllib3 |
[1.25.0] |
scipy |
[1.4.1] |
six |
[1.14.0] |
xarray |
[0.14.1] |
rioxarray (optional) |
[0.1.1] |


Messages
Map
Leaderboards
Login
Returning User? Login Here!
Email address
Password
Login
Forgot Password?
New User? Sign-up Here!
Sign-up


Japan-Tokyo
Send Invitation
Add Schedule
reply
Day1
Day2
Editors
Tommy
Wade
kobe
Tom
Duncan
Bosh
Curry
Green
kevin
Add co-editer
name
email
Add A New Spot
day
time
place
address
website
transpotation
addtion information